Merge branch 'master' of https://github.com/gogf/gf

improve grand.Intn; README updates
Merge pull request #96 from aloncn/master
2026-06-07 18:26:02 +08:00 · 2019-04-10 23:09:59 +08:00 · 2019-04-10 23:09:38 +08:00 · 2019-04-10 21:42:25 +08:00 · 2019-04-10 18:33:51 +08:00 · 2019-04-10 18:33:12 +08:00
537 changed files with 19174 additions and 9599 deletions
--- a/.gitee/ISSUE_TEMPLATE.MD
+++ b/.gitee/ISSUE_TEMPLATE.MD
@ -0,0 +1,34 @@
+<!-- 为更高效率地交流并解决问题，请按照以下模板提交issue，感谢！ -->
+
+### 1. 您当前使用的`Go`版本，及系统版本、系统架构？
+
+<!-- 使用 `go version` 命令查看，期望的结果如：`go 1.12, linux/amd64` -->
+
+
+### 2. 您当前使用的`GoFrame`框架版本？
+
+<!-- 框架版本可以查看自己项目下的 `go.mod`，或者框架文件 `version.go` -->
+
+
+### 3. 更新到最新的框架版本是否能够解决问题？
+
+<!-- 务必检查是否相同问题已在新版本中已修复 -->
+
+
+### 4. 问题描述？
+
+<!--
+请您尽可能地提供一份最短的，可复现问题的代码。
+代码尽可能地完整，最好是可以直接编译运行。
+-->
+
+
+
+### 5. 您期望得到的结果？
+
+
+
+### 6. 您实际得到的结果？
+
+
+
--- a/.github/ISSUE_TEMPLATE.MD
+++ b/.github/ISSUE_TEMPLATE.MD
@ -0,0 +1,36 @@
+<!-- Please answer these questions before submitting your issue. Thanks! -->
+
+### 1. What version of `Go` and system type/arch are you using?
+
+<!-- 
+Please paste the output of command `go version` from your terminal.
+What expect to see is like: `go 1.12, linux/amd64`
+-->
+
+
+### 2. What version of `GoFrame` are you using?
+
+<!-- You can find the GF version from your `go.mod`, or from the `version.go` in `GF` -->
+
+
+### 3. Can this issue be reproduced with the latest release?
+
+
+
+### 4. What did you do?
+
+<!--
+If possible, provide a copy of shortest codes for reproducing the error.
+A complete runnable program is best.
+-->
+
+
+
+### 5. What did you expect to see?
+
+
+
+### 6. What did you see instead?
+
+
+
--- a/.travis.yml
+++ b/.travis.yml
@ -1,7 +1,9 @@
 language: go

 go:
- "1.11.x"
+  - "1.10.x"
+  - "1.11.x"
+  - "1.12.x"

 branches:
  only:
@ -9,25 +11,29 @@ branches:
  - develop

 env:
- GO111MODULE=on
+  - GO111MODULE=on

 services:
- mysql
+  - mysql
+  - redis-server
+
+addons:
+  hosts:
+    - local

 before_install:
- pwd
+  - pwd

 install:
- pwd
+  - cat /etc/hosts

 script:
- cd g
- GOARCH=386 go test -v ./...
- GOARCH=amd64 go test -v ./... -race -coverprofile=coverage.txt -covermode=atomic
-
+  - cd g
+  - GOARCH=386 go test -v ./...
+  - GOARCH=amd64 go test -v ./... -race -coverprofile=coverage.txt -covermode=atomic

 after_success:
- bash <(curl -s https://codecov.io/bash)
+  - bash <(curl -s https://codecov.io/bash)



--- a/README.MD
+++ b/README.MD
@ -4,17 +4,15 @@
 [![Go Doc](https://godoc.org/github.com/gogf/gf?status.svg)](https://godoc.org/github.com/gogf/gf) 
 [![Build Status](https://travis-ci.org/gogf/gf.svg?branch=master)](https://travis-ci.org/gogf/gf) 
 [![Go Report](https://goreportcard.com/badge/github.com/gogf/gf)](https://goreportcard.com/report/github.com/gogf/gf) 
-[![Documents](https://img.shields.io/badge/docs-100%25-green.svg)](https://goframe.org) 
+[![Code Coverage](https://codecov.io/gh/gogf/gf/branch/master/graph/badge.svg)](https://codecov.io/gh/gogf/gf/branch/master)
+[![Production Ready](https://img.shields.io/badge/production-ready-blue.svg)](https://github.com/gogf/gf)
 [![License](https://img.shields.io/github/license/gogf/gf.svg?style=flat)](https://github.com/gogf/gf)
-[![Language](https://img.shields.io/badge/language-go-blue.svg)](https://github.com/gogf/gf)
-[![Release](https://img.shields.io/github/release/gogf/gf.svg?style=flat)](https://github.com/gogf/gf/releases)

 <!--
-[![Code Coverage](https://codecov.io/gh/gogf/gf/branch/master/graph/badge.svg)](https://codecov.io/gh/gogf/gf)
-[![Code Helper](https://www.codetriage.com/gogf/gf/badges/users.svg)](https://www.codetriage.com/gogf/gf) 
--> 
+GoFrame is a modular, loose-coupled, production-ready and most-powerful application development framework of golang. Providing a series of core components and dozens of practical modules, such as: cache, logging, containers, timer, validator, database orm, etc. Supporting web server integrated with router, cookie, session, logger, configure, template, https, hooks, rewrites and many more features. 
+-->

-`GF(GoFrame)` is a modular, loose-coupled and production-ready application development framework written in Go. Providing a series of core components and dozens of practical modules, such as: cache, logging, array/queue/set/map, timer/timing tasks, file/memory lock, object pool, validator, database ORM, etc. Supporting web server with graceful server, hot updates, multi-domain, multi-port, multi-service, HTTP/HTTPS, dynamic/hook routing, rewrite rules and many more features. 
+`GF(GoFrame)` is a modular, loose-coupled, production-ready and most-powerful application development framework of golang. Providing a series of core components and dozens of practical modules, such as: memcache, configure, validator, logging, array/queue/set/map containers, timer/timing tasks, file/memory lock, object pool, database ORM, etc. Supporting web server integrated with router, cookie, session, logger, template, https, hooks, rewrites and many more features. 

 # Installation
 ```
@ -32,7 +30,7 @@ golang version >= 1.9.2

 # Documentation

-* [GoDoc](https://godoc.org/github.com/gogf/gf)
+* [APIDoc](https://godoc.org/github.com/gogf/gf)
 * [中文文档](https://goframe.org)

 # Architecture
@ -66,42 +64,35 @@ func main() {

 `GF` is licensed under the [MIT License](LICENSE), 100% free and open-source, forever.

-# Contributors(TOP 10)
+# Contributors

-<a href="https://gitee.com/johng" target="_blank" title="John"><img src="https://gitee.com/uploads/27/1309327_johng.png?1530630243" width="60" align="left"></a>
-
-<a href="https://gitee.com/wenzi1" target="_blank" title="蚊子"><img src="https://images.gitee.com/uploads/22/1923122_wenzi1.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/zseeker" target="_blank" title="zseeker"><img src="https://goframe.org/images/contributors/zseeker.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/ymrjqyy" target="_blank" title="一墨染尽青衣颜"><img src="https://images.gitee.com/uploads/27/876827_ymrjqyy.png" width="60" align="left"></a>
-
-<a href="https://github.com/chenyang351" target="_blank" title="chenyang351"><img src="https://avatars1.githubusercontent.com/u/30063958?s=60&v=4" width="60" align="left"></a>
-
-<a href="https://gitee.com/wxkj" target="_blank" title="wxkj"><img src="https://gitee.com/uploads/56/91356_wxkj.png" width="60" align="left"></a>
-
-<a href="https://github.com/wxkj001" target="_blank" title="3wxkj001
-"><img src="https://avatars0.githubusercontent.com/u/7794279?s=60&v=4" width="60" align="left"></a>
-
-<a href="https://gitee.com/zhangjinfu" target="_blank" title="张金富"><img src="https://images.gitee.com/uploads/63/356163_zhangjinfu.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/garfieldkwong" target="_blank" title="GarfieldKwong"><img src="https://goframe.org/images/contributors/garfieldkwong.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/qq1054000800" target="_blank" title="hello"><img src="https://gitee.com/uploads/9/2209_qq1054000800.jpg" width="60" align="left"></a>
-
-<br /><br /><br />
+- [aloncn](https://github.com/aloncn)
+- [chenyang351](https://github.com/chenyang351)
+- [garfieldkwong](https://gitee.com/garfieldkwong)
+- [hailaz](https://gitee.com/hailaz)
+- [johng](https://gitee.com/johng)
+- [pibigstar](https://github.com/pibigstar)
+- [qq1054000800](https://gitee.com/qq1054000800)
+- [wenzi1](https://gitee.com/wenzi1)
+- [wxkj001](https://github.com/wxkj001)
+- [ymrjqyy](https://gitee.com/ymrjqyy)
+- [youyixiao](https://github.com/youyixiao)
+- [zhangjinfu](https://gitee.com/zhangjinfu)
+- [zhaopengme](https://github.com/zhaopengme)
+- [zseeker](https://gitee.com/zseeker)

 # Donators

-<a href="https://gitee.com/tiangenglan" target="_blank" title="zhuhuan12"><img src="https://images.gitee.com/uploads/99/1167099_tiangenglan.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/zhuhuan12" target="_blank" title="zhuhuan12"><img src="https://gitee.com/uploads/39/751839_zhuhuan12.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/zfan_codes" target="_blank" title="范钟"><img src="https://images.gitee.com/uploads/32/2044832_zfan_codes.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/hailaz" target="_blank" title="HaiLaz"><img src="https://gitee.com/uploads/87/1273187_hailaz.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/mg91" target="_blank" title="mg91"><img src="https://images.gitee.com/uploads/30/1410930_mg91.png" width="60" align="left"></a>
+- [flyke-xu](https://gitee.com/flyke-xu)
+- [hailaz](https://gitee.com/hailaz)
+- [mg91](https://gitee.com/mg91)
+- [pibigstar](https://github.com/pibigstar)
+- [tiangenglan](https://gitee.com/tiangenglan)
+- [wxkj](https://gitee.com/wxkj)
+- [zhuhuan12](https://gitee.com/zhuhuan12)
+- [zfan_codes](https://gitee.com/zfan_codes)
+
+



--- a/README_ZH.MD
+++ b/README_ZH.MD
@ -4,15 +4,9 @@
 [![Go Doc](https://godoc.org/github.com/gogf/gf?status.svg)](https://godoc.org/github.com/gogf/gf) 
 [![Build Status](https://travis-ci.org/gogf/gf.svg?branch=master)](https://travis-ci.org/gogf/gf) 
 [![Go Report](https://goreportcard.com/badge/github.com/gogf/gf)](https://goreportcard.com/report/github.com/gogf/gf) 
-[![Documents](https://img.shields.io/badge/docs-100%25-green.svg)](https://goframe.org) 
+[![Code Coverage](https://codecov.io/gh/gogf/gf/branch/master/graph/badge.svg)](https://codecov.io/gh/gogf/gf/branch/master)
+[![Production Ready](https://img.shields.io/badge/production-ready-blue.svg)](https://github.com/gogf/gf)
 [![License](https://img.shields.io/github/license/gogf/gf.svg?style=flat)](https://github.com/gogf/gf)
-[![Language](https://img.shields.io/badge/language-go-blue.svg)](https://github.com/gogf/gf)
-[![Release](https://img.shields.io/github/release/gogf/gf.svg?style=flat)](https://github.com/gogf/gf/releases)
-
-<!--
-[![Code Coverage](https://codecov.io/gh/gogf/gf/branch/master/graph/badge.svg)](https://codecov.io/gh/gogf/gf)
-[![Code Helper](https://www.codetriage.com/gogf/gf/badges/users.svg)](https://www.codetriage.com/gogf/gf) 
--> 

 `GF(Go Frame)`是一款模块化、松耦合、生产级Go应用开发框架。提供了常用的核心开发组件，如：缓存、日志、文件、时间、队列、数组、集合、字符串、定时器、命令行、文件锁、内存锁、对象池、连接池、数据校验、数据编码、文件监控、定时任务、数据库ORM、TCP/UDP组件、进程管理/通信、
 并发安全容器等等。并提供了Web服务开发的系列核心组件，如：Router、Cookie、Session、服务注册、配置管理、模板引擎等等，支持热重启、热更新、多域名、多端口、多服务、HTTPS、Rewrite等特性。
@ -81,31 +75,40 @@ func main() {

 `GF` 使用非常友好的 [MIT](LICENSE) 开源协议进行发布，永久`100%`开源免费。

+# 捐赠

-# 贡献者(TOP 10)
+捐赠支持`GF`框架的研发，
+请在捐赠时备注您的`github`/`gitee`账号名称。

-<a href="https://gitee.com/johng" target="_blank" title="John"><img src="https://gitee.com/uploads/27/1309327_johng.png" width="60" align="left"></a>
-<a href="https://gitee.com/wenzi1" target="_blank" title="蚊子"><img src="https://images.gitee.com/uploads/22/1923122_wenzi1.png" width="60" align="left"></a>
-<a href="https://gitee.com/zseeker" target="_blank" title="zseeker"><img src="https://goframe.org/images/contributors/zseeker.png" width="60" align="left"></a>
-<a href="https://gitee.com/ymrjqyy" target="_blank" title="一墨染尽青衣颜"><img src="https://images.gitee.com/uploads/27/876827_ymrjqyy.png" width="60" align="left"></a>
-<a href="https://github.com/chenyang351" target="_blank" title="chenyang351"><img src="https://avatars1.githubusercontent.com/u/30063958?s=60&v=4" width="60" align="left"></a>
-<a href="https://gitee.com/wxkj" target="_blank" title="wxkj"><img src="https://gitee.com/uploads/56/91356_wxkj.png" width="60" align="left"></a>
-<a href="https://github.com/wxkj001" target="_blank" title="3wxkj001
-"><img src="https://avatars0.githubusercontent.com/u/7794279?s=60&v=4" width="60" align="left"></a>
-<a href="https://gitee.com/zhangjinfu" target="_blank" title="张金富"><img src="https://images.gitee.com/uploads/63/356163_zhangjinfu.png" width="60" align="left"></a>
-<a href="https://gitee.com/garfieldkwong" target="_blank" title="GarfieldKwong"><img src="https://goframe.org/images/contributors/garfieldkwong.png" width="60" align="left"></a>
-<a href="https://gitee.com/qq1054000800" target="_blank" title="hello"><img src="https://gitee.com/uploads/9/2209_qq1054000800.jpg" width="60" align="left"></a>
+<a href="https://goframe.org/images/donate.png" target="_blank">
+<img src="https://goframe.org/images/donate.png" width="300"/>
+</a>

-<br /><br /><br />
+# 贡献者
+
+- [aloncn](https://github.com/aloncn)
+- [chenyang351](https://github.com/chenyang351)
+- [garfieldkwong](https://gitee.com/garfieldkwong)
+- [hailaz](https://gitee.com/hailaz)
+- [johng](https://gitee.com/johng)
+- [pibigstar](https://github.com/pibigstar)
+- [qq1054000800](https://gitee.com/qq1054000800)
+- [wenzi1](https://gitee.com/wenzi1)
+- [wxkj001](https://github.com/wxkj001)
+- [ymrjqyy](https://gitee.com/ymrjqyy)
+- [youyixiao](https://github.com/youyixiao)
+- [zhangjinfu](https://gitee.com/zhangjinfu)
+- [zhaopengme](https://github.com/zhaopengme)
+- [zseeker](https://gitee.com/zseeker)

 # 捐赠者

-<a href="https://gitee.com/tiangenglan" target="_blank" title="zhuhuan12"><img src="https://images.gitee.com/uploads/99/1167099_tiangenglan.png" width="60" align="left"></a>
+- [flyke-xu](https://gitee.com/flyke-xu)
+- [hailaz](https://gitee.com/hailaz)
+- [mg91](https://gitee.com/mg91)
+- [pibigstar](https://github.com/pibigstar)
+- [tiangenglan](https://gitee.com/tiangenglan)
+- [wxkj](https://gitee.com/wxkj)
+- [zhuhuan12](https://gitee.com/zhuhuan12)
+- [zfan_codes](https://gitee.com/zfan_codes)

-<a href="https://gitee.com/zhuhuan12" target="_blank" title="zhuhuan12"><img src="https://gitee.com/uploads/39/751839_zhuhuan12.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/zfan_codes" target="_blank" title="范钟"><img src="https://images.gitee.com/uploads/32/2044832_zfan_codes.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/hailaz" target="_blank" title="HaiLaz"><img src="https://gitee.com/uploads/87/1273187_hailaz.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/mg91" target="_blank" title="mg91"><img src="https://images.gitee.com/uploads/30/1410930_mg91.png" width="60" align="left"></a>
--- a/RELEASE.MD
+++ b/RELEASE.MD
@ -1,3 +1,86 @@
+# `v1.6.0` (2019-04-09)
+
+## 新功能/改进
+1. `gcron`定时任务模块增加运行日志记录功能：https://goframe.org/os/gcron/index
+1. `gredis`增加全局分组配置功能，并增加更多的配置选项`maxIdle/maxActive/idleTimeout/maxConnLifetime`：https://goframe.org/database/gredis/index
+1. `gcfg`模块增加更多的默认配置文件检索路径，并且增加全局分组配置特性，增加`Instance`单例方法：https://goframe.org/os/gcfg/index
+1. `gview`模块增加更多的默认配置文件检索路径，并且增加`Instance`单例方法：https://goframe.org/os/gview/index
+1. `ghttp`模块新功能及改进：
+    - 新增`CORS`HTTP(S)跨域请求特性: https://goframe.org/net/ghttp/cors
+    - 增加`TLSConfig`配置功能；
+    - 去掉路由注册方法的`error`返回值，当产生注册错误时直接终端打印错误/输出到日志文件；
+    - 增加在`HTTP Code 302`跳转时的`Set-Cookie`支持；
+    - 增加对`SESSION ID`的安全性检查；
+    - 增加对基于`HTTPS`的`WebSocket`支持（`WSS`）：https://goframe.org/net/ghttp/websocket/index
+    - `Request`对象增加`Error`方法，用于输出自定义错误信息到`WebServer`错误日志中；
+    - 其他一些改进；
+1. `gdb`模块新功能及改进：
+    - 新增`Instance`单例管理方法；
+    - 新增`Structs/Scan`链式操作方法，`gdb.DB/TX`新增`GetStructs/GetScan`方法，用于结果集`struct`/`slice`映射转换：https://goframe.org/database/gdb/chaining
+    - 新增`Safe`链式操作方法（默认非并发安全），用于链式安全控制：https://goframe.org/database/gdb/chaining
+    - `Where`链式操作方法改进：
+        - 方法支持任意的`string/map/slice/struct/*struct`类型；
+        - 逻辑调整，当链式操作中存在多个`Where`方法调用时，自动转换为`And`条件；
+        - 支持`slice`条件参数，常用在`SELECT IN`查询中，例如：`Where("uid IN(?)", g.Slice{1,2,3})`；
+        - 支持在`map`类型条件参数的`key`中传递条件，例如：`Where(g.Map{"uid>?", uid})`；
+1. `gconv`及`gvalid`模块改进并去掉对私有`struct`方法属性的转换/校验；
+1. `gconv.Map`转换方法新增对`json tag`: `-`, `omitempty`的支持: https://goframe.org/util/gconv/map
+1. `gstr`模块新增 `ReplaceI/ReplaceIByArray/ReplaceIByMap`大小写非敏感替换方法；
+1. `gutil`模块增加`IsEmpty`方法，用于判断给定变量是否为空（整型0, 布尔false, slice/map长度为0, 其他为nil的情况，判断为空），并增加快捷方法`g.IsEmpty`；
+1. `gutil`模块增加`Export`方法，用于导出返回格式化打印的变量内容字符串，并增加快捷方法`g.Export`；
+1. `gspath`增加缓存及非缓存检索检索方法`Search`/`SearchWithCache`；
+1. `gjson`模块增加默认的`UseNumber`功能支持；
+1. `gmap`增加`SetIfNotExistFunc/SetIfNotExistFuncLock`方法；
+1. 迁移`greuseport`模块到新的仓库：https://github.com/gogf/greuseport
+1. 大量的单元测试完善；
+
+## Bug Fix
+1. 修复`gqueue`模块的资源竞争问题；
+1. 修复`gconv.GTime`转换失败问题；
+1. 修复`gconv.String`在转换`int`参数时字节溢出问题；
+1. 修复`ghttp.Request`的`HTTP Basic Auth`校验问题；
+1. 修复`gxml`针对于非`UTF-8`编码内容转换的并发安全问题；
+1. 修复`gtime`部分`Format`（`G`&`j`）格式失效问题；
+1. 修复`gudp.Conn`对象的`RemoteAddr`获取客户端连接地址方法问题；
+1. 修复`gmap/gcache`模块的`GetOrSetFuncLock`方法，增加对回调方法返回值的`nil`判断，只有非nil返回值才会被保存；
+
+
+
+# `v1.5.8` (2019-02-28)
+
+## 新特性
+1. 主库从`gitee`迁移到了`github`( https://github.com/gogf/gf )，`gitee`作为镜像站，用于国内的代码贡献及ISSUE提交，迁移说明详见：https://goframe.org/upgradeto150
+1. 对常用的`container`数组模块: `garray`做了大量改进/完善工作，新增大量常用方法，并完善单元测试用例及方法注释，详见API文档：https://godoc.org/github.com/gogf/gf/g/container/garray
+1. 对常用的`container`集合模块: `gset`做了大量改进/完善工作，新增大量常用方法，并完善单元测试用例及方法注释，详见API文档：https://godoc.org/github.com/gogf/gf/g/container/gset
+1. 对常用的`container`MAP模块: `gmap`做了大量改进/完善工作，新增大量常用方法，并完善单元测试用例及方法注释，详见API文档：https://godoc.org/github.com/gogf/gf/g/container/gmap
+1. 对常用的字符串模块: `gstr`做了大量改进/完善工作，新增大量常用方法，并完善单元测试用例及方法注释，详见API文档：https://godoc.org/github.com/gogf/gf/g/text/gstr
+1. 改进`gform`中对`struct`/`*struct`参数的支持，`*Insert/*Save/*Replace/*Update/Where/Data`方法的参数调整为`interface{}`类型，并支持任意类型的: `string/map/slice/struct/*struct`参数传递，具体请参考：https://goframe.org/database/orm/chaining
+1. 新增/完善若干模块的单元测试用例, 包括：`gvalid`/`gregex`/`garray`/`gset`/`gmap`/`gstr`/`gconv`/`ghttp`/`gdb`；
+1. 由于`gkafka`模块比较重，且不是框架核心模块，因此将该模块迁移到新的仓库中独立管理，并去掉相关依赖包：https://github.com/gogf/gkafka
+1. 新增`greuseport`模块，用以实现TCP的`REUSEPORT`特性：https://godoc.org/github.com/gogf/gf/g/net/greuseport
+
+## 新功能/改进
+1. 去掉模板引擎内置变量中自动初始化`session`对象带来的内存占用问题；
+1. `ghttp.Client`改进，增加若干方法，详见：https://goframe.org/net/ghttp/client 
+1. `ghttp`分组路由增加`COMMON`方法，用以注册常用的`HTTP METHOD`(`GET/PUT/POST/DELETE`)路由；
+1. 更新框架依赖的`golang.org/x/sys`模块；
+1. 改进`gform`的批量操作(`Batch*`操作)返回结果对象，可以通过该结果对象获得批量操作准确的受影响记录行数；
+1. 将`gstr`/`gregex`模块从`util`分类迁移到了`text`分类目录下；
+1. 将`gtest`模块从`util`分类迁移到了`test`分类目录下；
+1. 完善`glog`方法注释；
+
+## Bug Fix
+1. 修复带点的邮件格式,用`gvalid.Check`的"`email`"规则不能匹配成功;
+1. 修复`gvalid.Check`在`regex`规则下的检查失败问题；
+1. 修复`gcron`模块定时规则中天和周不允许`?`符号的问题；
+1. 修复`ghttp.Server`在部分异常情况下仍然返回`200`状态码的问题；
+1. 修复`gfpool`模块中由于原子操作问题造成的高并发"内存泄露"问题；
+1. 修复分组路由注册对象/控制时，方法`Index`的路由仅能通过`/xxx/index`访问的问题；
+1. 修复模板引擎使用中，当不存在`config.toml`(即使没使用)配置文件时的报错问题；
+1. 其他一些修复；
+
+
+
 # `v1.4.6` (2019-01-24)

 ## 新特性
--- a/TODO.MD
+++ b/TODO.MD
@ -1,23 +1,16 @@
 # ON THE WAY
 1. 增加图形验证码支持，至少支持数字和英文字母；
-1. 增加热编译工具，提高开发环境的开发/测试效率（媲美PHP开发效率）；
-1. 增加可选择性的orm tag特性，用以数据表记录与struct对象转换的键名属性映射；
-1. ghttp.Response增加输出内容后自动退出当前请求机制，不需要用户手动return，参考beego如何实现；
 1. Cookie&Session数据池化处理；
 1. ghttp.Client增加proxy特性；
 1. gtime增加对时区转换的封装，并简化失去转换时对类似+80500时区的支持；
 1. orm增加sqlite对Save方法的支持(去掉触发器语句);
 1. ghttp.Server增加Ip访问控制功能(DenyIps&AllowIps)；
-1. ghttp路由功能增加分组路由特性；
 1. ghttp增加返回数据压缩机制；
 1. gview中的template标签失效问题；
-1. gfile文件stat信息使用gfsnotify进行缓存更新改进；
 1. ghttp.Server增加proxy功能特性，本地proxy和远程proxy，本地即将路由规则映射；远程即反向代理；
 1. gjson对大json数据的解析效率问题；
 1. ghttp增加route name特性，并同时支持backend和template(提供内置函数)引用，可以通过RedirectRoute方法给定route name和路由参数跳转到指定的路由地址上；
-1. ghttp.Client自动Close机制；
 1. gvalid校验支持当第一个规则失败后便不再校验后续的规则，最好做成链式操作；
-1. 检查ghttp.Server超时问题；
 1. gvalid增加支持对[]rune的长度校验(一个中文占3个字节)；
 1. ghttp.Request增加对输入参数的自动HtmlEncode机制；
 1. 常量命名风格根据golint进行修改；
@ -36,27 +29,20 @@
    - https://github.com/Masterminds/sprig
 1. gform参考 https://gohouse.github.io/gorose/dist/index.html 进行改进
 1. gtcp提供简便的包发送/接收方法(SendPkg/RecvPkg)以解决常见的TCP通信粘包问题，并完善文档（参考：https://www.cnblogs.com/kex1n/p/6502002.html）；
-1. gfile对于文件的读写强行使用了gfpool，在某些场景下不合适，需要考虑剥离开，并为开发者提供单独的指针池文件操作特性；
 1. 路由增加不区分大小写得匹配方式；
-1. str_ireplace: http://php.net/manual/en/function.str-ireplace.php
-1. strpos/stripos/strrpos/strripos: http://php.net/manual/en/function.stripos.php
 1. 改进WebServer获取POST参数处理逻辑，当提交非form数据时，例如json数据，针对某些方法可以直接解析；
 1. WebServer增加可选择的路由覆盖配置，默认情况下不覆盖；
-1. gkafka这个包比较重，未来从框架中剥离出来；
 1. grpool性能压测结果变慢的问题；
 1. 增加jumplist的数据结构容器；
 1. DelayQueue/PriorityQueue；
-1. gconv针对struct的转换增加json tag支持，gconv.Map默认也支持json tag, 完善开发文档；
-1. 增加SO_REUSEPORT的支持；
 1. 权限管理模块；
 1. 从ghttp中剥离SESSION功能构成单独的模块gsession；
 1. 改进gproc进程间通信处理逻辑，提高稳定性，以应对进程间大批量的数据发送/接收；
-1. gdb的Data方法支持struct参数传入；
-
-
-
-
-
+1. ghttp的热重启的本地进程端口监听，在不使用该特性时默认关闭掉；
+1. gtcp增加对TLS加密通信的支持；
+1. 添加Save/Replace/BatchSave/BatchReplace方法对sqlite数据库的支持；
+1. 添加sqlite数据库的单元测试用例；
+1. gredis增加cluster支持；

 # DONE
 1.  gconv完善针对不同类型的判断，例如：尽量减少sprintf("%v", xxx)来执行string类型的转换；
@ -115,4 +101,19 @@
 1. gform对于MySQL字段类型为datetime类型的时区问题分析；
 1. 改进证书打开失败时的WebServer错误提示，前置HOOK校验后关闭后续的HOOK逻辑执行；
 1. 目前WebServer的HOOK是按照优先级执行的，需要增加覆盖特性；
-
+1. 更新跨域请求CORS相关功能文档；
+1. ghttp.Response增加输出内容后自动退出当前请求机制，不需要用户手动return，参考beego如何实现；
+1. gcfg包目前允许添加重复的目录路径，需要在SetPath/AddPath时判断重复性，不能添加重复的路径；
+1. gdb执行数据写入时，如果参数为struct/[]struct，自动映射与表字段对应关系，不再使用gconv标签标识；
+1. gdb的Data方法支持struct参数传入；
+1. gfcache依旧使用gcache作为缓存控制对象，不要使用gmap；
+1. 增加对ghttp路由注册的{.struct}/{.method}单元测试；
+1. gconv针对struct的转换增加json tag支持，gconv.Map默认也支持json tag, 完善开发文档；
+1. 增加SO_REUSEPORT的支持；
+1. gkafka这个包比较重，未来从框架中剥离出来；
+1. str_ireplace: http://php.net/manual/en/function.str-ireplace.php
+1. strpos/stripos/strrpos/strripos: http://php.net/manual/en/function.stripos.php
+1. gfile对于文件的读写强行使用了gfpool，在某些场景下不合适，需要考虑剥离开，并为开发者提供单独的指针池文件操作特性；
+1. ghttp.Client自动Close机制；
+1. ghttp路由功能增加分组路由特性；
+1. 增加可选择性的orm tag特性，用以数据表记录与struct对象转换的键名属性映射；
--- a/g/container/garray/garray.go
+++ b/g/container/garray/garray.go
@ -4,8 +4,6 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.

-// Package garray provides kinds of concurrent-safe(alternative) arrays.
-//
-// 并发安全数组.
+// Package garray provides concurrent-safe/unsafe arrays.
 package garray

--- a/g/container/garray/garray_func.go
+++ b/g/container/garray/garray_func.go
@ -6,3 +6,15 @@

 package garray

+
+type apiSliceInterface interface {
+    Slice() []interface{}
+}
+
+type apiSliceInt interface {
+    Slice() []int
+}
+
+type apiSliceString interface {
+    Slice() []string
+}
--- a/g/container/garray/garray_normal_int.go
+++ b/g/container/garray/garray_normal_int.go
@ -7,12 +7,12 @@
 package garray

 import (
+    "bytes"
    "github.com/gogf/gf/g/internal/rwmutex"
    "github.com/gogf/gf/g/util/gconv"
    "github.com/gogf/gf/g/util/grand"
    "math"
    "sort"
-    "strings"
 )

 type IntArray struct {
@ -53,6 +53,20 @@ func NewIntArrayFrom(array []int, unsafe...bool) *IntArray {
    }
 }

+// Create an array from a copy of given slice <array>.
+// The param <unsafe> used to specify whether using array with un-concurrent-safety,
+// which is false in default, means concurrent-safe in default.
+//
+// 通过给定的slice拷贝创建数组对象，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
+func NewIntArrayFromCopy(array []int, unsafe...bool) *IntArray {
+    newArray := make([]int, len(array))
+    copy(newArray, array)
+    return &IntArray{
+        mu    : rwmutex.New(unsafe...),
+        array : newArray,
+    }
+}
+
 // Get value by index.
 //
 // 获取指定索引的数据项, 调用方注意判断数组边界。
@ -233,13 +247,31 @@ func (a *IntArray) PopRight() int {
    return value
 }

-// Pop an random item from array.
+// PopRand picks an random item out of array.
 //
 // 随机将一个数据项移出数组，并返回该数据项。
 func (a *IntArray) PopRand() int {
    return a.Remove(grand.Intn(len(a.array)))
 }

+// PopRands picks <size> items out of array.
+//
+// 随机将size个数据项移出数组，并返回该数据项。
+func (a *IntArray) PopRands(size int) []int {
+    a.mu.Lock()
+    defer a.mu.Unlock()
+    if size > len(a.array) {
+        size = len(a.array)
+    }
+    array := make([]int, size)
+    for i := 0; i < size; i++ {
+        index   := grand.Intn(len(a.array))
+        array[i] = a.array[index]
+        a.array  = append(a.array[ : index], a.array[index + 1 : ]...)
+    }
+    return array
+}
+
 // Pop <size> items from the beginning of array.
 //
 // 将最左端(首部)的size个数据项移出数组，并返回该数据项。
@ -409,8 +441,8 @@ func (a *IntArray) Unique() *IntArray {
 //
 // 使用自定义方法执行加锁修改操作。
 func (a *IntArray) LockFunc(f func(array []int)) *IntArray {
-	a.mu.Lock(true)
-	defer a.mu.Unlock(true)
+	a.mu.Lock()
+	defer a.mu.Unlock()
 	f(a.array)
    return a
 }
@ -419,23 +451,28 @@ func (a *IntArray) LockFunc(f func(array []int)) *IntArray {
 //
 // 使用自定义方法执行加锁读取操作。
 func (a *IntArray) RLockFunc(f func(array []int)) *IntArray {
-	a.mu.RLock(true)
-	defer a.mu.RUnlock(true)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
 	f(a.array)
    return a
 }

-// Merge two arrays.
+// Merge two arrays. The parameter <array> can be any garray type or slice type.
+// The difference between Merge and Append is Append supports only specified slice type,
+// but Merge supports more variable types.
 //
-// 合并两个数组.
-func (a *IntArray) Merge(array *IntArray) *IntArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if a != array {
-        array.mu.RLock()
-        defer array.mu.RUnlock()
+// 合并两个数组, 支持任意的garray数组类型及slice类型.
+func (a *IntArray) Merge(array interface{}) *IntArray {
+    switch v := array.(type) {
+        case *Array:             a.Append(gconv.Ints(v.Slice())...)
+        case *IntArray:          a.Append(gconv.Ints(v.Slice())...)
+        case *StringArray:       a.Append(gconv.Ints(v.Slice())...)
+        case *SortedArray:       a.Append(gconv.Ints(v.Slice())...)
+        case *SortedIntArray:    a.Append(gconv.Ints(v.Slice())...)
+        case *SortedStringArray: a.Append(gconv.Ints(v.Slice())...)
+        default:
+            a.Append(gconv.Ints(array)...)
    }
-    a.array = append(a.array, array.array...)
    return a
 }

@ -538,11 +575,19 @@ func (a *IntArray) SubSlice(offset, size int) []int {
    }
 }

-// Picks one or more random entries out of an array(a copy),
-// and returns the key (or keys) of the random entries.
+// Rand gets one random entry from array.
 //
-// 从数组中随机取出size个元素项，构成slice返回。
-func (a *IntArray) Rand(size int) []int {
+// 从数组中随机获得1个元素项(不删除)。
+func (a *IntArray) Rand() int {
+    a.mu.RLock()
+    defer a.mu.RUnlock()
+    return a.array[grand.Intn(len(a.array))]
+}
+
+// Rands gets one or more random entries from array(a copy).
+//
+// 从数组中随机拷贝size个元素项，构成slice返回。
+func (a *IntArray) Rands(size int) []int {
    a.mu.RLock()
    defer a.mu.RUnlock()
    if size > len(a.array) {
@ -588,5 +633,12 @@ func (a *IntArray) Reverse() *IntArray {
 func (a *IntArray) Join(glue string) string {
    a.mu.RLock()
    defer a.mu.RUnlock()
-    return strings.Join(gconv.Strings(a.array), glue)
+    buffer := bytes.NewBuffer(nil)
+    for k, v := range a.array {
+        buffer.WriteString(gconv.String(v))
+        if k != len(a.array) - 1 {
+            buffer.WriteString(glue)
+        }
+    }
+    return buffer.String()
 }
--- a/g/container/garray/garray_normal_interface.go
+++ b/g/container/garray/garray_normal_interface.go
@ -7,12 +7,13 @@
 package garray

 import (
+    "bytes"
+    "fmt"
    "github.com/gogf/gf/g/internal/rwmutex"
    "github.com/gogf/gf/g/util/gconv"
    "github.com/gogf/gf/g/util/grand"
    "math"
    "sort"
-    "strings"
 )

 type Array struct {
@ -30,8 +31,6 @@ func New(unsafe...bool) *Array {
 }

 // See New.
-//
-// 同New方法。
 func NewArray(unsafe...bool) *Array {
    return NewArraySize(0, 0, unsafe...)
 }
@ -48,6 +47,16 @@ func NewArraySize(size int, cap int, unsafe...bool) *Array {
    }
 }

+// See NewArrayFrom.
+func NewFrom(array []interface{}, unsafe...bool) *Array {
+    return NewArrayFrom(array, unsafe...)
+}
+
+// See NewArrayFromCopy.
+func NewFromCopy(array []interface{}, unsafe...bool) *Array {
+    return NewArrayFromCopy(array, unsafe...)
+}
+
 // Create an array with given slice <array>.
 // The param <unsafe> used to specify whether using array with un-concurrent-safety,
 // which is false in default, means concurrent-safe in default.
@ -60,6 +69,20 @@ func NewArrayFrom(array []interface{}, unsafe...bool) *Array {
    }
 }

+// Create an array from a copy of given slice <array>.
+// The param <unsafe> used to specify whether using array with un-concurrent-safety,
+// which is false in default, means concurrent-safe in default.
+//
+// 通过给定的slice拷贝创建数组对象，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
+func NewArrayFromCopy(array []interface{}, unsafe...bool) *Array {
+    newArray := make([]interface{}, len(array))
+    copy(newArray, array)
+    return &Array{
+        mu    : rwmutex.New(unsafe...),
+        array : newArray,
+    }
+}
+
 // Get value by index.
 //
 // 获取指定索引的数据项, 调用方注意判断数组边界
@ -196,13 +219,31 @@ func (a *Array) PushRight(value...interface{}) *Array {
    return a
 }

-// Pop an random item from array.
+// PopRand picks an random item out of array.
 //
 // 随机将一个数据项移出数组，并返回该数据项。
 func (a *Array) PopRand() interface{} {
    return a.Remove(grand.Intn(len(a.array)))
 }

+// PopRands picks <size> items out of array.
+//
+// 随机将size个数据项移出数组，并返回该数据项。
+func (a *Array) PopRands(size int) []interface{} {
+    a.mu.Lock()
+    defer a.mu.Unlock()
+    if size > len(a.array) {
+        size = len(a.array)
+    }
+    array := make([]interface{}, size)
+    for i := 0; i < size; i++ {
+        index   := grand.Intn(len(a.array))
+        array[i] = a.array[index]
+        a.array  = append(a.array[ : index], a.array[index + 1 : ]...)
+    }
+    return array
+}
+
 // Pop an item from the beginning of array.
 //
 // 将最左端(索引为0)的数据项移出数组，并返回该数据项。
@ -392,8 +433,8 @@ func (a *Array) Unique() *Array {
 //
 // 使用自定义方法执行加锁修改操作
 func (a *Array) LockFunc(f func(array []interface{})) *Array {
-    a.mu.Lock(true)
-    defer a.mu.Unlock(true)
+    a.mu.Lock()
+    defer a.mu.Unlock()
    f(a.array)
    return a
 }
@ -402,23 +443,28 @@ func (a *Array) LockFunc(f func(array []interface{})) *Array {
 //
 // 使用自定义方法执行加锁读取操作
 func (a *Array) RLockFunc(f func(array []interface{})) *Array {
-    a.mu.RLock(true)
-    defer a.mu.RUnlock(true)
+    a.mu.RLock()
+    defer a.mu.RUnlock()
    f(a.array)
    return a
 }

-// Merge two arrays.
+// Merge two arrays. The parameter <array> can be any garray type or slice type.
+// The difference between Merge and Append is Append supports only specified slice type,
+// but Merge supports more variable types.
 //
-// 合并两个数组.
-func (a *Array) Merge(array *Array) *Array {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if a != array {
-        array.mu.RLock()
-        defer array.mu.RUnlock()
+// 合并两个数组, 支持任意的garray数组类型及slice类型.
+func (a *Array) Merge(array interface{}) *Array {
+    switch v := array.(type) {
+        case *Array:             a.Append(gconv.Interfaces(v.Slice())...)
+        case *IntArray:          a.Append(gconv.Interfaces(v.Slice())...)
+        case *StringArray:       a.Append(gconv.Interfaces(v.Slice())...)
+        case *SortedArray:       a.Append(gconv.Interfaces(v.Slice())...)
+        case *SortedIntArray:    a.Append(gconv.Interfaces(v.Slice())...)
+        case *SortedStringArray: a.Append(gconv.Interfaces(v.Slice())...)
+        default:
+            a.Append(gconv.Interfaces(array)...)
    }
-    a.array = append(a.array, array.array...)
    return a
 }

@ -520,11 +566,19 @@ func (a *Array) SubSlice(offset, size int) []interface{} {
    }
 }

-// Picks one or more random entries out of an array(a copy),
-// and returns the key (or keys) of the random entries.
+// Rand gets one random entry from array.
 //
-// 从数组中随机取出size个元素项，构成slice返回。
-func (a *Array) Rand(size int) []interface{} {
+// 从数组中随机获得1个元素项(不删除)。
+func (a *Array) Rand() interface{} {
+    a.mu.RLock()
+    defer a.mu.RUnlock()
+    return a.array[grand.Intn(len(a.array))]
+}
+
+// Rands gets one or more random entries from array(a copy).
+//
+// 从数组中随机拷贝size个元素项，构成slice返回。
+func (a *Array) Rands(size int) []interface{} {
    a.mu.RLock()
    defer a.mu.RUnlock()
    if size > len(a.array) {
@ -570,7 +624,14 @@ func (a *Array) Reverse() *Array {
 func (a *Array) Join(glue string) string {
    a.mu.RLock()
    defer a.mu.RUnlock()
-    return strings.Join(gconv.Strings(a.array), glue)
+    buffer := bytes.NewBuffer(nil)
+    for k, v := range a.array {
+        buffer.WriteString(gconv.String(v))
+        if k != len(a.array) - 1 {
+            buffer.WriteString(glue)
+        }
+    }
+    return buffer.String()
 }

 // Counts all the values of an array.
@ -584,4 +645,13 @@ func (a *Array) CountValues() map[interface{}]int {
        m[v]++
    }
    return m
+}
+
+// String returns current array as a string.
+//
+// 将当前数组转换为字符串返回。
+func (a *Array) String() string {
+    a.mu.RLock()
+    defer a.mu.RUnlock()
+    return fmt.Sprint(a.array)
 }
--- a/g/container/garray/garray_normal_string.go
+++ b/g/container/garray/garray_normal_string.go
@ -7,6 +7,7 @@
 package garray

 import (
+    "bytes"
    "github.com/gogf/gf/g/internal/rwmutex"
    "github.com/gogf/gf/g/util/gconv"
    "github.com/gogf/gf/g/util/grand"
@ -53,6 +54,20 @@ func NewStringArrayFrom(array []string, unsafe...bool) *StringArray {
 	}
 }

+// Create an array from a copy of given slice <array>.
+// The param <unsafe> used to specify whether using array with un-concurrent-safety,
+// which is false in default, means concurrent-safe in default.
+//
+// 通过给定的slice拷贝创建数组对象，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
+func NewStringArrayFromCopy(array []string, unsafe...bool) *StringArray {
+    newArray := make([]string, len(array))
+    copy(newArray, array)
+    return &StringArray{
+        mu    : rwmutex.New(unsafe...),
+        array : newArray,
+    }
+}
+
 // Get value by index.
 //
 // 获取指定索引的数据项, 调用方注意判断数组边界。
@ -233,13 +248,31 @@ func (a *StringArray) PopRight() string {
    return value
 }

-// Pop an random item from array.
+// PopRand picks an random item out of array.
 //
 // 随机将一个数据项移出数组，并返回该数据项。
 func (a *StringArray) PopRand() string {
    return a.Remove(grand.Intn(len(a.array)))
 }

+// PopRands picks <size> items out of array.
+//
+// 随机将size个数据项移出数组，并返回该数据项。
+func (a *StringArray) PopRands(size int) []string {
+    a.mu.Lock()
+    defer a.mu.Unlock()
+    if size > len(a.array) {
+        size = len(a.array)
+    }
+    array := make([]string, size)
+    for i := 0; i < size; i++ {
+        index   := grand.Intn(len(a.array))
+        array[i] = a.array[index]
+        a.array  = append(a.array[ : index], a.array[index + 1 : ]...)
+    }
+    return array
+}
+
 // Pop <size> items from the beginning of array.
 //
 // 将最左端(首部)的size个数据项移出数组，并返回该数据项
@ -407,8 +440,8 @@ func (a *StringArray) Unique() *StringArray {
 //
 // 使用自定义方法执行加锁修改操作。
 func (a *StringArray) LockFunc(f func(array []string)) *StringArray {
-	a.mu.Lock(true)
-	defer a.mu.Unlock(true)
+	a.mu.Lock()
+	defer a.mu.Unlock()
 	f(a.array)
    return a
 }
@ -417,23 +450,28 @@ func (a *StringArray) LockFunc(f func(array []string)) *StringArray {
 //
 // 使用自定义方法执行加锁读取操作。
 func (a *StringArray) RLockFunc(f func(array []string)) *StringArray {
-	a.mu.RLock(true)
-	defer a.mu.RUnlock(true)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
 	f(a.array)
    return a
 }

-// Merge two arrays.
+// Merge two arrays. The parameter <array> can be any garray type or slice type.
+// The difference between Merge and Append is Append supports only specified slice type,
+// but Merge supports more variable types.
 //
-// 合并两个数组.
-func (a *StringArray) Merge(array *StringArray) *StringArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if a != array {
-        array.mu.RLock()
-        defer array.mu.RUnlock()
+// 合并两个数组, 支持任意的garray数组类型及slice类型.
+func (a *StringArray) Merge(array interface{}) *StringArray {
+    switch v := array.(type) {
+        case *Array:             a.Append(gconv.Strings(v.Slice())...)
+        case *IntArray:          a.Append(gconv.Strings(v.Slice())...)
+        case *StringArray:       a.Append(gconv.Strings(v.Slice())...)
+        case *SortedArray:       a.Append(gconv.Strings(v.Slice())...)
+        case *SortedIntArray:    a.Append(gconv.Strings(v.Slice())...)
+        case *SortedStringArray: a.Append(gconv.Strings(v.Slice())...)
+        default:
+            a.Append(gconv.Strings(array)...)
    }
-    a.array = append(a.array, array.array...)
    return a
 }

@ -537,11 +575,19 @@ func (a *StringArray) SubSlice(offset, size int) []string {
    }
 }

-// Picks one or more random entries out of an array(a copy),
-// and returns the key (or keys) of the random entries.
+// Rand gets one random entry from array.
 //
-// 从数组中随机取出size个元素项，构成slice返回。
-func (a *StringArray) Rand(size int) []string {
+// 从数组中随机获得1个元素项(不删除)。
+func (a *StringArray) Rand() string {
+    a.mu.RLock()
+    defer a.mu.RUnlock()
+    return a.array[grand.Intn(len(a.array))]
+}
+
+// Rands gets one or more random entries from array(a copy).
+//
+// 从数组中随机拷贝size个元素项，构成slice返回。
+func (a *StringArray) Rands(size int) []string {
    a.mu.RLock()
    defer a.mu.RUnlock()
    if size > len(a.array) {
@ -587,6 +633,13 @@ func (a *StringArray) Reverse() *StringArray {
 func (a *StringArray) Join(glue string) string {
    a.mu.RLock()
    defer a.mu.RUnlock()
-    return strings.Join(a.array, glue)
+    buffer := bytes.NewBuffer(nil)
+    for k, v := range a.array {
+        buffer.WriteString(gconv.String(v))
+        if k != len(a.array) - 1 {
+            buffer.WriteString(glue)
+        }
+    }
+    return buffer.String()
 }

--- a/g/container/garray/garray_sorted_int.go
+++ b/g/container/garray/garray_sorted_int.go
@ -7,13 +7,13 @@
 package garray

 import (
+    "bytes"
    "github.com/gogf/gf/g/container/gtype"
    "github.com/gogf/gf/g/internal/rwmutex"
    "github.com/gogf/gf/g/util/gconv"
    "github.com/gogf/gf/g/util/grand"
    "math"
    "sort"
-    "strings"
 )

 // 默认按照从小到大进行排序
@ -67,6 +67,20 @@ func NewSortedIntArrayFrom(array []int, unsafe...bool) *SortedIntArray {
    return a
 }

+// Create an array from a copy of given slice <array>.
+// The param <unsafe> used to specify whether using array with un-concurrent-safety,
+// which is false in default, means concurrent-safe in default.
+//
+// 通过给定的slice拷贝创建数组对象，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
+func NewSortedIntArrayFromCopy(array []int, unsafe...bool) *SortedIntArray {
+    newArray := make([]int, len(array))
+    copy(newArray, array)
+    return &SortedIntArray{
+        mu    : rwmutex.New(unsafe...),
+        array : newArray,
+    }
+}
+
 // Set the underlying slice array with the given <array> param.
 //
 // 设置底层数组变量.
@ -172,13 +186,31 @@ func (a *SortedIntArray) PopRight() int {
    return value
 }

-// Pop an random item from array.
+// PopRand picks an random item out of array.
 //
 // 随机将一个数据项移出数组，并返回该数据项。
 func (a *SortedIntArray) PopRand() int {
    return a.Remove(grand.Intn(len(a.array)))
 }

+// PopRands picks <size> items out of array.
+//
+// 随机将size个数据项移出数组，并返回该数据项。
+func (a *SortedIntArray) PopRands(size int) []int {
+    a.mu.Lock()
+    defer a.mu.Unlock()
+    if size > len(a.array) {
+        size = len(a.array)
+    }
+    array := make([]int, size)
+    for i := 0; i < size; i++ {
+        index   := grand.Intn(len(a.array))
+        array[i] = a.array[index]
+        a.array  = append(a.array[ : index], a.array[index + 1 : ]...)
+    }
+    return array
+}
+
 // Pop <size> items from the beginning of array.
 //
 // 将最左端(首部)的size个数据项移出数组，并返回该数据项
@ -383,8 +415,8 @@ func (a *SortedIntArray) Clear() *SortedIntArray {
 //
 // 使用自定义方法执行加锁修改操作。
 func (a *SortedIntArray) LockFunc(f func(array []int)) *SortedIntArray {
-    a.mu.Lock(true)
-    defer a.mu.Unlock(true)
+    a.mu.Lock()
+    defer a.mu.Unlock()
    f(a.array)
    return a
 }
@ -393,24 +425,28 @@ func (a *SortedIntArray) LockFunc(f func(array []int)) *SortedIntArray {
 //
 // 使用自定义方法执行加锁读取操作。
 func (a *SortedIntArray) RLockFunc(f func(array []int)) *SortedIntArray {
-    a.mu.RLock(true)
-    defer a.mu.RUnlock(true)
+    a.mu.RLock()
+    defer a.mu.RUnlock()
    f(a.array)
    return a
 }

-// Merge two arrays.
+// Merge two arrays. The parameter <array> can be any garray type or slice type.
+// The difference between Merge and Add is Add supports only specified slice type,
+// but Merge supports more variable types.
 //
-// 合并两个数组.
-func (a *SortedIntArray) Merge(array *SortedIntArray) *SortedIntArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if a != array {
-        array.mu.RLock()
-        defer array.mu.RUnlock()
+// 合并两个数组, 支持任意的garray数组类型及slice类型.
+func (a *SortedIntArray) Merge(array interface{}) *SortedIntArray {
+    switch v := array.(type) {
+        case *Array:             a.Add(gconv.Ints(v.Slice())...)
+        case *IntArray:          a.Add(gconv.Ints(v.Slice())...)
+        case *StringArray:       a.Add(gconv.Ints(v.Slice())...)
+        case *SortedArray:       a.Add(gconv.Ints(v.Slice())...)
+        case *SortedIntArray:    a.Add(gconv.Ints(v.Slice())...)
+        case *SortedStringArray: a.Add(gconv.Ints(v.Slice())...)
+        default:
+            a.Add(gconv.Ints(array)...)
    }
-    a.array = append(a.array, array.array...)
-    sort.Ints(a.array)
    return a
 }

@ -462,11 +498,19 @@ func (a *SortedIntArray) SubSlice(offset, size int) []int {
    }
 }

-// Picks one or more random entries out of an array(a copy),
-// and returns the key (or keys) of the random entries.
+// Rand gets one random entry from array.
 //
-// 从数组中随机取出size个元素项，构成slice返回。
-func (a *SortedIntArray) Rand(size int) []int {
+// 从数组中随机获得1个元素项(不删除)。
+func (a *SortedIntArray) Rand() int {
+    a.mu.RLock()
+    defer a.mu.RUnlock()
+    return a.array[grand.Intn(len(a.array))]
+}
+
+// Rands gets one or more random entries from array(a copy).
+//
+// 从数组中随机拷贝size个元素项，构成slice返回。
+func (a *SortedIntArray) Rands(size int) []int {
    a.mu.RLock()
    defer a.mu.RUnlock()
    if size > len(a.array) {
@ -488,5 +532,12 @@ func (a *SortedIntArray) Rand(size int) []int {
 func (a *SortedIntArray) Join(glue string) string {
    a.mu.RLock()
    defer a.mu.RUnlock()
-    return strings.Join(gconv.Strings(a.array), glue)
+    buffer := bytes.NewBuffer(nil)
+    for k, v := range a.array {
+        buffer.WriteString(gconv.String(v))
+        if k != len(a.array) - 1 {
+            buffer.WriteString(glue)
+        }
+    }
+    return buffer.String()
 }
--- a/g/container/garray/garray_sorted_interface.go
+++ b/g/container/garray/garray_sorted_interface.go
@ -7,13 +7,13 @@
 package garray

 import (
+    "bytes"
    "github.com/gogf/gf/g/container/gtype"
    "github.com/gogf/gf/g/internal/rwmutex"
    "github.com/gogf/gf/g/util/gconv"
    "github.com/gogf/gf/g/util/grand"
    "math"
    "sort"
-    "strings"
 )

 // 默认按照从小到大进行排序
@ -69,6 +69,20 @@ func NewSortedArrayFrom(array []interface{}, compareFunc func(v1, v2 interface{}
    return a
 }

+// Create an array from a copy of given slice <array>.
+// The param <unsafe> used to specify whether using array with un-concurrent-safety,
+// which is false in default, means concurrent-safe in default.
+//
+// 通过给定的slice拷贝创建数组对象，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
+func NewSortedArrayFromCopy(array []interface{}, unsafe...bool) *SortedArray {
+    newArray := make([]interface{}, len(array))
+    copy(newArray, array)
+    return &SortedArray{
+        mu    : rwmutex.New(unsafe...),
+        array : newArray,
+    }
+}
+
 // Set the underlying slice array with the given <array> param.
 //
 // 设置底层数组变量.
@ -178,13 +192,31 @@ func (a *SortedArray) PopRight() interface{} {
    return value
 }

-// Pop an random item from array.
+// PopRand picks an random item out of array.
 //
 // 随机将一个数据项移出数组，并返回该数据项。
 func (a *SortedArray) PopRand() interface{} {
    return a.Remove(grand.Intn(len(a.array)))
 }

+// PopRands picks <size> items out of array.
+//
+// 随机将size个数据项移出数组，并返回该数据项。
+func (a *SortedArray) PopRands(size int) []interface{} {
+    a.mu.Lock()
+    defer a.mu.Unlock()
+    if size > len(a.array) {
+        size = len(a.array)
+    }
+    array := make([]interface{}, size)
+    for i := 0; i < size; i++ {
+        index   := grand.Intn(len(a.array))
+        array[i] = a.array[index]
+        a.array  = append(a.array[ : index], a.array[index + 1 : ]...)
+    }
+    return array
+}
+
 // Pop <size> items from the beginning of array.
 //
 // 将最左端(首部)的size个数据项移出数组，并返回该数据项
@ -390,8 +422,8 @@ func (a *SortedArray) Clear() *SortedArray {
 //
 // 使用自定义方法执行加锁修改操作。
 func (a *SortedArray) LockFunc(f func(array []interface{})) *SortedArray {
-    a.mu.Lock(true)
-    defer a.mu.Unlock(true)
+    a.mu.Lock()
+    defer a.mu.Unlock()
    f(a.array)
    return a
 }
@ -400,26 +432,28 @@ func (a *SortedArray) LockFunc(f func(array []interface{})) *SortedArray {
 //
 // 使用自定义方法执行加锁读取操作。
 func (a *SortedArray) RLockFunc(f func(array []interface{})) *SortedArray {
-    a.mu.RLock(true)
-    defer a.mu.RUnlock(true)
+    a.mu.RLock()
+    defer a.mu.RUnlock()
    f(a.array)
    return a
 }

-// Merge two arrays.
+// Merge two arrays. The parameter <array> can be any garray type or slice type.
+// The difference between Merge and Add is Add supports only specified slice type,
+// but Merge supports more variable types.
 //
-// 合并两个数组.
-func (a *SortedArray) Merge(array *SortedArray) *SortedArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if a != array {
-        array.mu.RLock()
-        defer array.mu.RUnlock()
+// 合并两个数组, 支持任意的garray数组类型及slice类型.
+func (a *SortedArray) Merge(array interface{}) *SortedArray {
+    switch v := array.(type) {
+        case *Array:             a.Add(gconv.Interfaces(v.Slice())...)
+        case *IntArray:          a.Add(gconv.Interfaces(v.Slice())...)
+        case *StringArray:       a.Add(gconv.Interfaces(v.Slice())...)
+        case *SortedArray:       a.Add(gconv.Interfaces(v.Slice())...)
+        case *SortedIntArray:    a.Add(gconv.Interfaces(v.Slice())...)
+        case *SortedStringArray: a.Add(gconv.Interfaces(v.Slice())...)
+        default:
+            a.Add(gconv.Interfaces(array)...)
    }
-    a.array = append(a.array, array.array...)
-    sort.Slice(a.array, func(i, j int) bool {
-        return a.compareFunc(a.array[i], a.array[j]) < 0
-    })
    return a
 }

@ -471,11 +505,19 @@ func (a *SortedArray) SubSlice(offset, size int) []interface{} {
    }
 }

-// Picks one or more random entries out of an array(a copy),
-// and returns the key (or keys) of the random entries.
+// Rand gets one random entry from array.
 //
-// 从数组中随机取出size个元素项，构成slice返回。
-func (a *SortedArray) Rand(size int) []interface{} {
+// 从数组中随机获得1个元素项(不删除)。
+func (a *SortedArray) Rand() interface{} {
+    a.mu.RLock()
+    defer a.mu.RUnlock()
+    return a.array[grand.Intn(len(a.array))]
+}
+
+// Rands gets one or more random entries from array(a copy).
+//
+// 从数组中随机拷贝size个元素项，构成slice返回。
+func (a *SortedArray) Rands(size int) []interface{} {
    a.mu.RLock()
    defer a.mu.RUnlock()
    if size > len(a.array) {
@ -497,5 +539,12 @@ func (a *SortedArray) Rand(size int) []interface{} {
 func (a *SortedArray) Join(glue string) string {
    a.mu.RLock()
    defer a.mu.RUnlock()
-    return strings.Join(gconv.Strings(a.array), glue)
+    buffer := bytes.NewBuffer(nil)
+    for k, v := range a.array {
+        buffer.WriteString(gconv.String(v))
+        if k != len(a.array) - 1 {
+            buffer.WriteString(glue)
+        }
+    }
+    return buffer.String()
 }
--- a/g/container/garray/garray_sorted_string.go
+++ b/g/container/garray/garray_sorted_string.go
@ -7,6 +7,7 @@
 package garray

 import (
+    "bytes"
    "github.com/gogf/gf/g/container/gtype"
    "github.com/gogf/gf/g/internal/rwmutex"
    "github.com/gogf/gf/g/util/gconv"
@ -61,6 +62,20 @@ func NewSortedStringArrayFrom(array []string, unsafe...bool) *SortedStringArray
    return a
 }

+// Create an array from a copy of given slice <array>.
+// The param <unsafe> used to specify whether using array with un-concurrent-safety,
+// which is false in default, means concurrent-safe in default.
+//
+// 通过给定的slice拷贝创建数组对象，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
+func NewSortedStringArrayFromCopy(array []string, unsafe...bool) *SortedStringArray {
+    newArray := make([]string, len(array))
+    copy(newArray, array)
+    return &SortedStringArray{
+        mu    : rwmutex.New(unsafe...),
+        array : newArray,
+    }
+}
+
 // Set the underlying slice array with the given <array> param.
 //
 // 设置底层数组变量.
@ -166,13 +181,31 @@ func (a *SortedStringArray) PopRight() string {
    return value
 }

-// Pop an random item from array.
+// PopRand picks an random item out of array.
 //
 // 随机将一个数据项移出数组，并返回该数据项。
 func (a *SortedStringArray) PopRand() string {
    return a.Remove(grand.Intn(len(a.array)))
 }

+// PopRands picks <size> items out of array.
+//
+// 随机将size个数据项移出数组，并返回该数据项。
+func (a *SortedStringArray) PopRands(size int) []string {
+    a.mu.Lock()
+    defer a.mu.Unlock()
+    if size > len(a.array) {
+        size = len(a.array)
+    }
+    array := make([]string, size)
+    for i := 0; i < size; i++ {
+        index   := grand.Intn(len(a.array))
+        array[i] = a.array[index]
+        a.array  = append(a.array[ : index], a.array[index + 1 : ]...)
+    }
+    return array
+}
+
 // Pop <size> items from the beginning of array.
 //
 // 将最左端(首部)的size个数据项移出数组，并返回该数据项
@ -377,8 +410,8 @@ func (a *SortedStringArray) Clear() *SortedStringArray {
 //
 // 使用自定义方法执行加锁修改操作。
 func (a *SortedStringArray) LockFunc(f func(array []string)) *SortedStringArray {
-    a.mu.Lock(true)
-    defer a.mu.Unlock(true)
+    a.mu.Lock()
+    defer a.mu.Unlock()
    f(a.array)
    return a
 }
@ -387,24 +420,28 @@ func (a *SortedStringArray) LockFunc(f func(array []string)) *SortedStringArray
 //
 // 使用自定义方法执行加锁读取操作。
 func (a *SortedStringArray) RLockFunc(f func(array []string)) *SortedStringArray {
-    a.mu.RLock(true)
-    defer a.mu.RUnlock(true)
+    a.mu.RLock()
+    defer a.mu.RUnlock()
    f(a.array)
    return a
 }

-// Merge two arrays.
+// Merge two arrays. The parameter <array> can be any garray type or slice type.
+// The difference between Merge and Add is Add supports only specified slice type,
+// but Merge supports more variable types.
 //
-// 合并两个数组.
-func (a *SortedStringArray) Merge(array *SortedStringArray) *SortedStringArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if a != array {
-        array.mu.RLock()
-        defer array.mu.RUnlock()
+// 合并两个数组, 支持任意的garray数组类型及slice类型.
+func (a *SortedStringArray) Merge(array interface{}) *SortedStringArray {
+    switch v := array.(type) {
+        case *Array:             a.Add(gconv.Strings(v.Slice())...)
+        case *IntArray:          a.Add(gconv.Strings(v.Slice())...)
+        case *StringArray:       a.Add(gconv.Strings(v.Slice())...)
+        case *SortedArray:       a.Add(gconv.Strings(v.Slice())...)
+        case *SortedIntArray:    a.Add(gconv.Strings(v.Slice())...)
+        case *SortedStringArray: a.Add(gconv.Strings(v.Slice())...)
+        default:
+            a.Add(gconv.Strings(array)...)
    }
-    a.array = append(a.array, array.array...)
-    sort.Strings(a.array)
    return a
 }

@ -456,11 +493,19 @@ func (a *SortedStringArray) SubSlice(offset, size int) []string {
    }
 }

-// Picks one or more random entries out of an array(a copy),
-// and returns the key (or keys) of the random entries.
+// Rand gets one random entry from array.
 //
-// 从数组中随机取出size个元素项，构成slice返回。
-func (a *SortedStringArray) Rand(size int) []string {
+// 从数组中随机获得1个元素项(不删除)。
+func (a *SortedStringArray) Rand() string {
+    a.mu.RLock()
+    defer a.mu.RUnlock()
+    return a.array[grand.Intn(len(a.array))]
+}
+
+// Rands gets one or more random entries from array(a copy).
+//
+// 从数组中随机拷贝size个元素项，构成slice返回。
+func (a *SortedStringArray) Rands(size int) []string {
    a.mu.RLock()
    defer a.mu.RUnlock()
    if size > len(a.array) {
@ -482,5 +527,12 @@ func (a *SortedStringArray) Rand(size int) []string {
 func (a *SortedStringArray) Join(glue string) string {
    a.mu.RLock()
    defer a.mu.RUnlock()
-    return strings.Join(a.array, glue)
+    buffer := bytes.NewBuffer(nil)
+    for k, v := range a.array {
+        buffer.WriteString(gconv.String(v))
+        if k != len(a.array) - 1 {
+            buffer.WriteString(glue)
+        }
+    }
+    return buffer.String()
 }
--- a/g/container/garray/garray_z_example_test.go
+++ b/g/container/garray/garray_z_example_test.go
@ -0,0 +1,111 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package garray_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g/container/garray"
+)
+
+func Example_basic() {
+    // 创建普通的数组，默认并发安全(带锁)
+    a := garray.New()
+
+    // 添加数据项
+    for i := 0; i < 10; i++ {
+        a.Append(i)
+    }
+
+    // 获取当前数组长度
+    fmt.Println(a.Len())
+
+    // 获取当前数据项列表
+    fmt.Println(a.Slice())
+
+    // 获取指定索引项
+    fmt.Println(a.Get(6))
+
+    // 查找指定数据项是否存在
+    fmt.Println(a.Contains(6))
+    fmt.Println(a.Contains(100))
+
+    // 在指定索引前插入数据项
+    a.InsertAfter(9, 11)
+    // 在指定索引后插入数据项
+    a.InsertBefore(10, 10)
+
+    fmt.Println(a.Slice())
+
+    // 修改指定索引的数据项
+    a.Set(0, 100)
+    fmt.Println(a.Slice())
+
+    // 搜索数据项，返回搜索到的索引位置
+    fmt.Println(a.Search(5))
+
+    // 删除指定索引的数据项
+    a.Remove(0)
+    fmt.Println(a.Slice())
+
+    // 清空数组
+    fmt.Println(a.Slice())
+    a.Clear()
+    fmt.Println(a.Slice())
+
+    // Output:
+    // 10
+    // [0 1 2 3 4 5 6 7 8 9]
+    // 6
+    // true
+    // false
+    // [0 1 2 3 4 5 6 7 8 9 10 11]
+    // [100 1 2 3 4 5 6 7 8 9 10 11]
+    // 5
+    // [1 2 3 4 5 6 7 8 9 10 11]
+    // [1 2 3 4 5 6 7 8 9 10 11]
+    // []
+}
+
+func Example_rand() {
+    array := garray.NewFrom([]interface{}{1,2,3,4,5,6,7,8,9})
+    // 随机返回两个数据项(不删除)
+    fmt.Println(array.Rands(2))
+    fmt.Println(array.PopRand())
+}
+
+func Example_pop() {
+    array := garray.NewFrom([]interface{}{1,2,3,4,5,6,7,8,9})
+    fmt.Println(array.PopLeft())
+    fmt.Println(array.PopLefts(2))
+    fmt.Println(array.PopRight())
+    fmt.Println(array.PopRights(2))
+
+    // Output:
+    // 1
+    // [2 3]
+    // 9
+    // [7 8]
+}
+
+func Example_merge() {
+    array1 := garray.NewFrom([]interface{}{1,2})
+    array2 := garray.NewFrom([]interface{}{3,4})
+    slice1 := []interface{}{5,6}
+    slice2 := []int{7,8}
+    slice3 := []string{"9","0"}
+    fmt.Println(array1.Slice())
+    array1.Merge(array1)
+    array1.Merge(array2)
+    array1.Merge(slice1)
+    array1.Merge(slice2)
+    array1.Merge(slice3)
+    fmt.Println(array1.Slice())
+
+    // Output:
+    // [1 2]
+    // [1 2 1 2 3 4 5 6 7 8 9 0]
+}
--- a/g/container/garray/garray_z_unit_int_test.go
+++ b/g/container/garray/garray_z_unit_int_test.go
@ -161,9 +161,18 @@ func TestIntArray_Rand(t *testing.T) {
    gtest.Case(t, func() {
        a1 := []int{0,1,2,3,4,5,6}
        array1 := garray.NewIntArrayFrom(a1)
-        gtest.Assert(len(array1.Rand(2)),  2)
-        gtest.Assert(len(array1.Rand(10)), 7)
-        gtest.AssertIN(array1.Rand(1)[0], a1)
+        gtest.Assert(len(array1.Rands(2)),  2)
+        gtest.Assert(len(array1.Rands(10)), 7)
+        gtest.AssertIN(array1.Rands(1)[0], a1)
+        gtest.AssertIN(array1.Rand(), a1)
+    })
+}
+
+func TestIntArray_PopRands(t *testing.T) {
+    gtest.Case(t, func() {
+        a1 := []interface{}{100, 200, 300, 400, 500, 600}
+        array := garray.NewFromCopy(a1)
+        gtest.AssertIN(array.PopRands(2), a1)
    })
 }

--- a/g/container/garray/garray_z_unit_interface_test.go
+++ b/g/container/garray/garray_z_unit_interface_test.go
@ -80,6 +80,14 @@ func TestArray_PushAndPop(t *testing.T) {
    })
 }

+func TestArray_PopRands(t *testing.T) {
+    gtest.Case(t, func() {
+        a1 := []interface{}{100, 200, 300, 400, 500, 600}
+        array := garray.NewFromCopy(a1)
+        gtest.AssertIN(array.PopRands(2), a1)
+    })
+}
+
 func TestArray_PopLeftsAndPopRights(t *testing.T) {
    gtest.Case(t, func() {
        value1 := []interface{}{0,1,2,3,4,5,6}
@ -165,9 +173,9 @@ func TestArray_Rand(t *testing.T) {
    gtest.Case(t, func() {
        a1 := []interface{}{0,1,2,3,4,5,6}
        array1 := garray.NewArrayFrom(a1)
-        gtest.Assert(len(array1.Rand(2)),  2)
-        gtest.Assert(len(array1.Rand(10)), 7)
-        gtest.AssertIN(array1.Rand(1)[0], a1)
+        gtest.Assert(len(array1.Rands(2)),  2)
+        gtest.Assert(len(array1.Rands(10)), 7)
+        gtest.AssertIN(array1.Rands(1)[0], a1)
    })
 }

--- a/g/container/garray/garray_z_unit_string_test.go
+++ b/g/container/garray/garray_z_unit_string_test.go
@ -162,9 +162,17 @@ func TestStringArray_Rand(t *testing.T) {
    gtest.Case(t, func() {
        a1 := []string{"0","1","2","3","4","5","6"}
        array1 := garray.NewStringArrayFrom(a1)
-        gtest.Assert(len(array1.Rand(2)),  "2")
-        gtest.Assert(len(array1.Rand(10)), "7")
-        gtest.AssertIN(array1.Rand(1)[0], a1)
+        gtest.Assert(len(array1.Rands(2)),  "2")
+        gtest.Assert(len(array1.Rands(10)), "7")
+        gtest.AssertIN(array1.Rands(1)[0], a1)
+    })
+}
+
+func TestStringArray_PopRands(t *testing.T) {
+    gtest.Case(t, func() {
+        a1 := []interface{}{"100", "200", "300", "400", "500", "600"}
+        array := garray.NewFromCopy(a1)
+        gtest.AssertIN(array.PopRands(2), a1)
    })
 }

--- a/g/container/gchan/gchan.go
+++ b/g/container/gchan/gchan.go
@ -4,9 +4,9 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.

-// Package gchan provides graceful operations for channel.
+// Package gchan provides graceful channel for safe operations.
 //
-// 优雅的Channel操作.
+// It's safe to call Chan.Push/Close functions repeatedly.
 package gchan

 import (
@ -15,39 +15,48 @@ import (
 )

 type Chan struct {
-    list   chan interface{}
-    closed *gtype.Bool
+    channel chan interface{}
+    closed  *gtype.Bool
 }

+// New creates a graceful channel with given limit.
 func New(limit int) *Chan {
    return &Chan {
-        list   : make(chan interface{}, limit),
-        closed : gtype.NewBool(),
+	    channel : make(chan interface{}, limit),
+        closed  : gtype.NewBool(),
    }
 }

-// 将数据压入队列
-func (q *Chan) Push(v interface{}) error {
-    if q.closed.Val() {
+// Push pushes <value> to channel.
+// It is safe to be called repeatedly.
+func (c *Chan) Push(value interface{}) error {
+    if c.closed.Val() {
        return errors.New("closed")
    }
-    q.list <- v
+    c.channel <- value
    return nil
 }

-// 先进先出地从队列取出一项数据，当没有数据可获取时，阻塞等待
-func (q *Chan) Pop() interface{} {
-    return <- q.list
+// Pop pops value from channel.
+// If there's no value in channel, it would block to wait.
+func (c *Chan) Pop() interface{} {
+    return <- c.channel
 }

-// 关闭队列(通知所有通过Pop阻塞的协程退出)
-func (q *Chan) Close() {
-    if !q.closed.Set(true) {
-        close(q.list)
+// Close closes the channel.
+// It is safe to be called repeatedly.
+func (c *Chan) Close() {
+    if !c.closed.Set(true) {
+        close(c.channel)
    }
 }

-// 获取当前队列大小
-func (q *Chan) Size() int {
-    return len(q.list)
+// See Len.
+func (c *Chan) Size() int {
+    return c.Len()
+}
+
+// Len returns the length of the channel.
+func (c *Chan) Len() int {
+	return len(c.channel)
 }
--- a/g/container/glist/glist.go
+++ b/g/container/glist/glist.go
@ -5,9 +5,7 @@
 // You can obtain one at https://github.com/gogf/gf.
 //

-// Package glist provides a concurrent-safe(alternative) doubly linked list.
-//
-// 并发安全双向链表.
+// Package glist provides a concurrent-safe/unsafe doubly linked list.
 package glist

 import (
@ -15,14 +13,14 @@ import (
    "github.com/gogf/gf/g/internal/rwmutex"
 )

-// 变长双向链表
-type List struct {
-    mu     *rwmutex.RWMutex
-    list   *list.List
-}
-
-type Element = list.Element
+type (
+	List struct {
+	    mu   *rwmutex.RWMutex
+	    list *list.List
+	}

+	Element = list.Element
+)

 // 获得一个变长链表指针
 func New(unsafe...bool) *List {
--- a/g/container/gmap/gmap.go
+++ b/g/container/gmap/gmap.go
@ -4,46 +4,34 @@
 // If a copy of the MIT was not distributed with gm file,
 // You can obtain one at https://github.com/gogf/gf.

-// Package gmap provides kinds of concurrent-safe(alternative) maps.
-//
-// 并发安全MAP.
+// Package gmap provides concurrent-safe/unsafe maps.
 package gmap

 import "github.com/gogf/gf/g/internal/rwmutex"

-// 注意:
-// 1、这个Map是所有并发安全Map中效率最低的，如果对效率要求比较高的场合，请合理选择对应数据类型的Map；
-// 2、这个Map的优点是使用简便，由于键值都是interface{}类型，因此对键值的数据类型要求不高；
-// 3、底层实现比较类似于sync.Map；
 type Map struct {
    mu *rwmutex.RWMutex
    m  map[interface{}]interface{}
 }

-// Create an empty hash map.
+// New returns an empty hash map.
 // The param <unsafe> used to specify whether using map with un-concurrent-safety,
-// which is false in default, means concurrent-safe in default.
-//
-// 创建一个空的哈希表，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
-func New(unsafe...bool) *Map {
+// which is false in default, means concurrent-safe.
+func New(unsafe ...bool) *Map {
    return NewMap(unsafe...)
 }

-// See New.
-//
-// 同New方法。
-func NewMap(unsafe...bool) *Map {
+// Alias of New. See New.
+func NewMap(unsafe ...bool) *Map {
    return &Map{
        m  : make(map[interface{}]interface{}),
        mu : rwmutex.New(unsafe...),
    }
 }

-// Create a hash map from given map.
-// Be aware that, the param map is a type of pointer,
+// NewFrom returns a hash map from given map <m>.
+// Notice that, the param map is a type of pointer,
 // there might be some concurrent-safe issues when changing the map outside.
-//
-// 基于给定的map变量创建哈希表对象，注意由于map是指针类型，外部对map有操作时会有并发安全问题。
 func NewFrom(m map[interface{}]interface{}, unsafe...bool) *Map {
    return &Map{
        m  : m,
@ -51,12 +39,12 @@ func NewFrom(m map[interface{}]interface{}, unsafe...bool) *Map {
    }
 }

-// Create a hash map from given arrays.
+// NewFromArray returns a hash map from given array.
 // The param <keys> given as the keys of the map,
-// and <values> as the corresponding values.
+// and <values> as its corresponding values.
 //
-// 基于给定的数组变量创建哈希表对象，keys作为键名, values作为键值。
-// 当keys数组大小比values数组大时，多余的键名将会使用对应类型默认的键值。
+// If length of <keys> is greater than that of <values>,
+// the corresponding overflow map values will be the default value of its type.
 func NewFromArray(keys []interface{}, values []interface{}, unsafe...bool) *Map {
    m := make(map[interface{}]interface{})
    l := len(values)
@ -73,10 +61,8 @@ func NewFromArray(keys []interface{}, values []interface{}, unsafe...bool) *Map
    }
 }

-// Iterate the hash map with custom callback function <f>.
+// Iterator iterates the hash map with custom callback function <f>.
 // If f returns true, then continue iterating; or false to stop.
-//
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
 func (gm *Map) Iterator(f func (k interface{}, v interface{}) bool) {
    gm.mu.RLock()
    defer gm.mu.RUnlock()
@ -87,17 +73,12 @@ func (gm *Map) Iterator(f func (k interface{}, v interface{}) bool) {
    }
 }

-// Clone current hash map with copy of underlying data,
-// return a new hash map.
-//
-// 哈希表克隆.
-func (gm *Map) Clone() *Map {
-    return NewFrom(gm.Map(), !gm.mu.IsSafe())
+// Clone returns a new hash map with copy of current map data.
+func (gm *Map) Clone(unsafe ...bool) *Map {
+    return NewFrom(gm.Map(), unsafe ...)
 }

-// Returns copy of the data of the hash map.
-//
-// 返回当前哈希表的数据Map.
+// Map returns a copy of the data of the hash map.
 func (gm *Map) Map() map[interface{}]interface{} {
    m := make(map[interface{}]interface{})
    gm.mu.RLock()
@ -108,18 +89,14 @@ func (gm *Map) Map() map[interface{}]interface{} {
    return m
 }

-// Set key-value to the hash map.
-//
-// 设置键值对
+// Set sets key-value to the hash map.
 func (gm *Map) Set(key interface{}, val interface{}) {
    gm.mu.Lock()
    gm.m[key] = val
    gm.mu.Unlock()
 }

-// Batch set key-values to the hash map.
-//
-// 批量设置键值对
+// BatchSet batch sets key-values to the hash map.
 func (gm *Map) BatchSet(m map[interface{}]interface{}) {
    gm.mu.Lock()
    for k, v := range m {
@ -128,9 +105,7 @@ func (gm *Map) BatchSet(m map[interface{}]interface{}) {
    gm.mu.Unlock()
 }

-// Get value by key.
-//
-// 获取键值
+// Get returns the value by given <key>.
 func (gm *Map) Get(key interface{}) interface{} {
    gm.mu.RLock()
    val, _ := gm.m[key]
@ -138,8 +113,15 @@ func (gm *Map) Get(key interface{}) interface{} {
    return val
 }

-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given <key>,
+// or else just return the existing value.
+//
+// When setting value, if <value> is type of <func() interface {}>,
+// it will be executed with mutex.Lock of the hash map,
+// and its return value will be set to the map with <key>.
+//
+// It returns value with given <key>.
 func (gm *Map) doSetWithLockCheck(key interface{}, value interface{}) interface{} {
    gm.mu.Lock()
    defer gm.mu.Unlock()
@ -153,9 +135,8 @@ func (gm *Map) doSetWithLockCheck(key interface{}, value interface{}) interface{
    return value
 }

-// Get the value by key, or set it with given key-value if not exist.
-//
-// 当键名存在时返回其键值，否则写入指定的键值
+// GetOrSet returns the value by key,
+// or set value with given <value> if not exist and returns this value.
 func (gm *Map) GetOrSet(key interface{}, value interface{}) interface{} {
    if v := gm.Get(key); v == nil {
        return gm.doSetWithLockCheck(key, value)
@ -164,9 +145,9 @@ func (gm *Map) GetOrSet(key interface{}, value interface{}) interface{} {
    }
 }

-// Get the value by key, or set the it with return of callback function <f> if not exist.
-//
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+// GetOrSetFunc returns the value by key,
+// or sets value with return value of callback function <f> if not exist
+// and returns this value.
 func (gm *Map) GetOrSetFunc(key interface{}, f func() interface{}) interface{} {
    if v := gm.Get(key); v == nil {
        return gm.doSetWithLockCheck(key, f())
@ -175,10 +156,12 @@ func (gm *Map) GetOrSetFunc(key interface{}, f func() interface{}) interface{} {
    }
 }

-// Get the value by key, or set the it with return of callback function <f> if not exist.
-// The difference with GetOrSetFunc is, it locks in executing callback function <f>.
+// GetOrSetFuncLock returns the value by key,
+// or sets value with return value of callback function <f> if not exist
+// and returns this value.
 //
-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f>
+// with mutex.Lock of the hash map.
 func (gm *Map) GetOrSetFuncLock(key interface{}, f func() interface{}) interface{} {
    if v := gm.Get(key); v == nil {
        return gm.doSetWithLockCheck(key, f)
@ -187,9 +170,8 @@ func (gm *Map) GetOrSetFuncLock(key interface{}, f func() interface{}) interface
    }
 }

-// Set key-value if the key does not exist, then return true; or else return false.
-//
-// 当键名不存在时写入，并返回true；否则返回false。
+// SetIfNotExist sets <value> to the map if the <key> does not exist, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
 func (gm *Map) SetIfNotExist(key interface{}, value interface{}) bool {
    if !gm.Contains(key) {
        gm.doSetWithLockCheck(key, value)
@ -198,9 +180,30 @@ func (gm *Map) SetIfNotExist(key interface{}, value interface{}) bool {
    return false
 }

-// Batch remove by keys.
+// SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+func (gm *Map) SetIfNotExistFunc(key interface{}, f func() interface{}) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
+}
+
+// SetIfNotExistFuncLock sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
 //
-// 批量删除键值对
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function <f> with mutex.Lock of the hash map.
+func (gm *Map) SetIfNotExistFuncLock(key interface{}, f func() interface{}) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f)
+		return true
+	}
+	return false
+}
+
+// BatchRemove batch deletes values of the map by keys.
 func (gm *Map) BatchRemove(keys []interface{}) {
    gm.mu.Lock()
    for _, key := range keys {
@ -209,9 +212,7 @@ func (gm *Map) BatchRemove(keys []interface{}) {
    gm.mu.Unlock()
 }

-// Remove by given key.
-//
-// 返回对应的键值，并删除该键值
+// Remove deletes value from map by given <key>, and return this deleted value.
 func (gm *Map) Remove(key interface{}) interface{} {
    gm.mu.Lock()
    val, exists := gm.m[key]
@ -222,9 +223,7 @@ func (gm *Map) Remove(key interface{}) interface{} {
    return val
 }

-// Return all the keys of hash map as a slice.
-//
-// 返回键列表.
+// Keys returns all keys of the map as a slice.
 func (gm *Map) Keys() []interface{} {
    gm.mu.RLock()
    keys := make([]interface{}, 0)
@ -235,9 +234,7 @@ func (gm *Map) Keys() []interface{} {
    return keys
 }

-// Return all the values of hash map as a slice.
-//
-// 返回值列表(注意是随机排序)
+// Values returns all values of the map as a slice.
 func (gm *Map) Values() []interface{} {
    gm.mu.RLock()
    vals := make([]interface{}, 0)
@ -248,9 +245,8 @@ func (gm *Map) Values() []interface{} {
    return vals
 }

-// Check whether a key exist.
-//
-// 是否存在某个键
+// Contains checks whether a key exists.
+// It returns true if the <key> exists, or else false.
 func (gm *Map) Contains(key interface{}) bool {
    gm.mu.RLock()
    _, exists := gm.m[key]
@ -258,9 +254,7 @@ func (gm *Map) Contains(key interface{}) bool {
    return exists
 }

-// Get the size of hash map.
-//
-// 哈希表大小
+// Size returns the size of the map.
 func (gm *Map) Size() int {
    gm.mu.RLock()
    length := len(gm.m)
@ -268,9 +262,8 @@ func (gm *Map) Size() int {
    return length
 }

-// Check whether the hash map is empty.
-//
-// 哈希表是否为空
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
 func (gm *Map) IsEmpty() bool {
    gm.mu.RLock()
    empty := len(gm.m) == 0
@ -278,36 +271,28 @@ func (gm *Map) IsEmpty() bool {
    return empty
 }

-// Clear the hash map, it will remake a new underlying map data map.
-//
-// 清空哈希表
+// Clear deletes all data of the map, it will remake a new underlying map data map.
 func (gm *Map) Clear() {
    gm.mu.Lock()
    gm.m = make(map[interface{}]interface{})
    gm.mu.Unlock()
 }

-// Lock writing with given callback <f>.
-//
-// 并发安全锁操作，使用自定义方法执行加锁修改操作
+// LockFunc locks writing with given callback function <f> and mutex.Lock.
 func (gm *Map) LockFunc(f func(m map[interface{}]interface{})) {
-    gm.mu.Lock(true)
-    defer gm.mu.Unlock(true)
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
    f(gm.m)
 }

-// Lock reading with given callback <f>.
-//
-// 并发安全锁操作，使用自定义方法执行加锁读取操作
+// RLockFunc locks reading with given callback function <f> and mutex.RLock.
 func (gm *Map) RLockFunc(f func(m map[interface{}]interface{})) {
-    gm.mu.RLock(true)
-    defer gm.mu.RUnlock(true)
+    gm.mu.RLock()
+    defer gm.mu.RUnlock()
    f(gm.m)
 }

-// Exchange key-value in the hash map, it will change key-value to value-key.
-//
-// 交换Map中的键和值.
+// Flip exchanges key-value of the map, it will change key-value to value-key.
 func (gm *Map) Flip() {
    gm.mu.Lock()
    defer gm.mu.Unlock()
@ -318,17 +303,16 @@ func (gm *Map) Flip() {
    gm.m = n
 }

-// Merge two hash maps.
-//
-// 合并两个Map.
-func (gm *Map) Merge(m *Map) {
+// Merge merges two hash maps.
+// The <other> map will be merged into the map <gm>.
+func (gm *Map) Merge(other *Map) {
    gm.mu.Lock()
    defer gm.mu.Unlock()
-    if m != gm {
-        m.mu.RLock()
-        defer m.mu.RUnlock()
+    if other != gm {
+	    other.mu.RLock()
+        defer other.mu.RUnlock()
    }
-    for k, v := range m.m {
+    for k, v := range other.m {
        gm.m[k] = v
    }
 }
--- a/g/container/gmap/gmap_int_bool_map.go
+++ b/g/container/gmap/gmap_int_bool_map.go
@ -16,6 +16,9 @@ type IntBoolMap struct {
    mu *rwmutex.RWMutex
 }

+// NewIntBoolMap returns an empty IntBoolMap object.
+// The param <unsafe> used to specify whether using map with un-concurrent-safety,
+// which is false in default, means concurrent-safe.
 func NewIntBoolMap(unsafe...bool) *IntBoolMap {
 	return &IntBoolMap{
        m  : make(map[int]bool),
@ -23,6 +26,9 @@ func NewIntBoolMap(unsafe...bool) *IntBoolMap {
    }
 }

+// NewIntBoolMapFrom returns an IntBoolMap object from given map <m>.
+// Notice that, the param map is a type of pointer,
+// there might be some concurrent-safe issues when changing the map outside.
 func NewIntBoolMapFrom(m map[int]bool, unsafe...bool) *IntBoolMap {
    return &IntBoolMap{
        m  : m,
@ -30,6 +36,12 @@ func NewIntBoolMapFrom(m map[int]bool, unsafe...bool) *IntBoolMap {
    }
 }

+// NewIntBoolMapFromArray returns an IntBoolMap from given array.
+// The param <keys> given as the keys of the map,
+// and <values> as its corresponding values.
+//
+// If length of <keys> is greater than that of <values>,
+// the corresponding overflow map values will be the default value of its type.
 func NewIntBoolMapFromArray(keys []int, values []bool, unsafe...bool) *IntBoolMap {
    m := make(map[int]bool)
    l := len(values)
@ -46,12 +58,12 @@ func NewIntBoolMapFromArray(keys []int, values []bool, unsafe...bool) *IntBoolMa
    }
 }

-// 哈希表克隆.
+// Clone returns a new hash map with copy of current map data.
 func (gm *IntBoolMap) Clone() *IntBoolMap {
    return NewIntBoolMapFrom(gm.Map(), !gm.mu.IsSafe())
 }

-// 返回当前哈希表的数据Map.
+// Map returns a copy of the data of the hash map.
 func (gm *IntBoolMap) Map() map[int]bool {
 	m := make(map[int]bool)
 	gm.mu.RLock()
@ -62,7 +74,8 @@ func (gm *IntBoolMap) Map() map[int]bool {
 	return m
 }

-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
+// Iterator iterates the hash map with custom callback function <f>.
+// If f returns true, then continue iterating; or false to stop.
 func (gm *IntBoolMap) Iterator(f func (k int, v bool) bool) {
    gm.mu.RLock()
    defer gm.mu.RUnlock()
@ -73,14 +86,14 @@ func (gm *IntBoolMap) Iterator(f func (k int, v bool) bool) {
    }
 }

-// 设置键值对
+// Set sets key-value to the hash map.
 func (gm *IntBoolMap) Set(key int, val bool) {
 	gm.mu.Lock()
 	gm.m[key] = val
 	gm.mu.Unlock()
 }

-// 批量设置键值对
+// BatchSet batch sets key-values to the hash map.
 func (gm *IntBoolMap) BatchSet(m map[int]bool) {
 	gm.mu.Lock()
 	for k, v := range m {
@ -89,7 +102,7 @@ func (gm *IntBoolMap) BatchSet(m map[int]bool) {
 	gm.mu.Unlock()
 }

-// 获取键值
+// Get returns the value by given <key>.
 func (gm *IntBoolMap) Get(key int) bool {
 	gm.mu.RLock()
 	val, _ := gm.m[key]
@ -97,8 +110,11 @@ func (gm *IntBoolMap) Get(key int) bool {
 	return val
 }

-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given <key>,
+// or else just return the existing value.
+//
+// It returns value with given <key>.
 func (gm *IntBoolMap) doSetWithLockCheck(key int, value bool) bool {
    gm.mu.Lock()
    if v, ok := gm.m[key]; ok {
@ -110,7 +126,8 @@ func (gm *IntBoolMap) doSetWithLockCheck(key int, value bool) bool {
    return value
 }

-// 当键名存在时返回其键值，否则写入指定的键值
+// GetOrSet returns the value by key,
+// or set value with given <value> if not exist and returns this value.
 func (gm *IntBoolMap) GetOrSet(key int, value bool) bool {
    gm.mu.RLock()
    v, ok := gm.m[key]
@ -122,7 +139,8 @@ func (gm *IntBoolMap) GetOrSet(key int, value bool) bool {
    }
 }

-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+// GetOrSetFunc returns the value by key,
+// or sets value with return value of callback function <f> if not exist and returns this value.
 func (gm *IntBoolMap) GetOrSetFunc(key int, f func() bool) bool {
    gm.mu.RLock()
    v, ok := gm.m[key]
@ -134,7 +152,11 @@ func (gm *IntBoolMap) GetOrSetFunc(key int, f func() bool) bool {
    }
 }

-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
+// GetOrSetFuncLock returns the value by key,
+// or sets value with return value of callback function <f> if not exist and returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f>
+// with mutex.Lock of the hash map.
 func (gm *IntBoolMap) GetOrSetFuncLock(key int, f func() bool) bool {
    gm.mu.RLock()
    val, ok := gm.m[key]
@ -143,10 +165,9 @@ func (gm *IntBoolMap) GetOrSetFuncLock(key int, f func() bool) bool {
        gm.mu.Lock()
        defer gm.mu.Unlock()
        if v, ok := gm.m[key]; ok {
-            gm.mu.Unlock()
            return v
        }
-        val         = f()
+        val       = f()
        gm.m[key] = val
        return val
    } else {
@ -154,7 +175,8 @@ func (gm *IntBoolMap) GetOrSetFuncLock(key int, f func() bool) bool {
    }
 }

-// 当键名不存在时写入，并返回true；否则返回false。
+// SetIfNotExist sets <value> to the map if the <key> does not exist, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
 func (gm *IntBoolMap) SetIfNotExist(key int, value bool) bool {
    if !gm.Contains(key) {
        gm.doSetWithLockCheck(key, value)
@ -163,7 +185,34 @@ func (gm *IntBoolMap) SetIfNotExist(key int, value bool) bool {
    return false
 }

-// 批量删除键值对
+// SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+func (gm *IntBoolMap) SetIfNotExistFunc(key int, f func() bool) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
+}
+
+// SetIfNotExistFuncLock sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function <f> with mutex.Lock of the hash map.
+func (gm *IntBoolMap) SetIfNotExistFuncLock(key int, f func() bool) bool {
+	if !gm.Contains(key) {
+		gm.mu.Lock()
+		defer gm.mu.Unlock()
+		if _, ok := gm.m[key]; !ok {
+			gm.m[key] = f()
+		}
+		return true
+	}
+	return false
+}
+
+// BatchRemove batch deletes values of the map by keys.
 func (gm *IntBoolMap) BatchRemove(keys []int) {
    gm.mu.Lock()
    for _, key := range keys {
@ -172,7 +221,7 @@ func (gm *IntBoolMap) BatchRemove(keys []int) {
    gm.mu.Unlock()
 }

-// 返回对应的键值，并删除该键值
+// Remove deletes value from map by given <key>, and return this deleted value.
 func (gm *IntBoolMap) Remove(key int) bool {
    gm.mu.Lock()
    val, exists := gm.m[key]
@ -183,7 +232,7 @@ func (gm *IntBoolMap) Remove(key int) bool {
    return val
 }

-// 返回键列表
+// Keys returns all keys of the map as a slice.
 func (gm *IntBoolMap) Keys() []int {
    gm.mu.RLock()
    keys := make([]int, 0)
@ -194,18 +243,8 @@ func (gm *IntBoolMap) Keys() []int {
    return keys
 }

-// 返回值列表(注意是随机排序)
-//func (gm *IntBoolMap) Values() []bool {
-//    gm.mu.RLock()
-//    vals := make([]bool, 0)
-//    for _, val := range gm.m {
-//        vals = append(vals, val)
-//    }
-//    gm.mu.RUnlock()
-//    return vals
-//}
-
-// 是否存在某个键
+// Contains checks whether a key exists.
+// It returns true if the <key> exists, or else false.
 func (gm *IntBoolMap) Contains(key int) bool {
 	gm.mu.RLock()
 	_, exists := gm.m[key]
@ -213,7 +252,7 @@ func (gm *IntBoolMap) Contains(key int) bool {
 	return exists
 }

-// 哈希表大小
+// Size returns the size of the map.
 func (gm *IntBoolMap) Size() int {
    gm.mu.RLock()
    length := len(gm.m)
@ -221,7 +260,8 @@ func (gm *IntBoolMap) Size() int {
    return length
 }

-// 哈希表是否为空
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
 func (gm *IntBoolMap) IsEmpty() bool {
    gm.mu.RLock()
    empty := len(gm.m) == 0
@ -229,36 +269,37 @@ func (gm *IntBoolMap) IsEmpty() bool {
    return empty
 }

-// 清空哈希表
+// Clear deletes all data of the map, it will remake a new underlying map data map.
 func (gm *IntBoolMap) Clear() {
    gm.mu.Lock()
    gm.m = make(map[int]bool)
    gm.mu.Unlock()
 }

-// 并发安全锁操作，使用自定义方法执行加锁修改操作
+// LockFunc locks writing with given callback function <f> and mutex.Lock.
 func (gm *IntBoolMap) LockFunc(f func(m map[int]bool)) {
-    gm.mu.Lock(true)
-    defer gm.mu.Unlock(true)
-    f(gm.m)
-}
-
-// 并发安全锁操作，使用自定义方法执行加锁读取操作
-func (gm *IntBoolMap) RLockFunc(f func(m map[int]bool)) {
-    gm.mu.RLock(true)
-    defer gm.mu.RUnlock(true)
-    f(gm.m)
-}
-
-// 合并两个Map.
-func (gm *IntBoolMap) Merge(m *IntBoolMap) {
    gm.mu.Lock()
    defer gm.mu.Unlock()
-    if m != gm {
-        m.mu.RLock()
-        defer m.mu.RUnlock()
+    f(gm.m)
+}
+
+// RLockFunc locks reading with given callback function <f> and mutex.RLock.
+func (gm *IntBoolMap) RLockFunc(f func(m map[int]bool)) {
+    gm.mu.RLock()
+    defer gm.mu.RUnlock()
+    f(gm.m)
+}
+
+// Merge merges two hash maps.
+// The <other> map will be merged into the map <gm>.
+func (gm *IntBoolMap) Merge(other *IntBoolMap) {
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
+    if other != gm {
+	    other.mu.RLock()
+        defer other.mu.RUnlock()
    }
-    for k, v := range m.m {
+    for k, v := range other.m {
        gm.m[k] = v
    }
 }
--- a/g/container/gmap/gmap_int_int_map.go
+++ b/g/container/gmap/gmap_int_int_map.go
@ -16,6 +16,9 @@ type IntIntMap struct {
 	m  map[int]int
 }

+// NewIntIntMap returns an empty IntIntMap object.
+// The param <unsafe> used to specify whether using map with un-concurrent-safety,
+// which is false in default, means concurrent-safe.
 func NewIntIntMap(unsafe...bool) *IntIntMap {
 	return &IntIntMap{
        m  : make(map[int]int),
@ -23,6 +26,9 @@ func NewIntIntMap(unsafe...bool) *IntIntMap {
    }
 }

+// NewIntIntMapFrom returns an IntIntMap object from given map <m>.
+// Notice that, the param map is a type of pointer,
+// there might be some concurrent-safe issues when changing the map outside.
 func NewIntIntMapFrom(m map[int]int, unsafe...bool) *IntIntMap {
    return &IntIntMap{
        m  : m,
@ -30,6 +36,12 @@ func NewIntIntMapFrom(m map[int]int, unsafe...bool) *IntIntMap {
    }
 }

+// NewIntIntMapFromArray returns an IntIntMap object from given array.
+// The param <keys> given as the keys of the map,
+// and <values> as its corresponding values.
+//
+// If length of <keys> is greater than that of <values>,
+// the corresponding overflow map values will be the default value of its type.
 func NewIntIntMapFromArray(keys []int, values []int, unsafe...bool) *IntIntMap {
    m := make(map[int]int)
    l := len(values)
@ -46,7 +58,8 @@ func NewIntIntMapFromArray(keys []int, values []int, unsafe...bool) *IntIntMap {
    }
 }

-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
+// Iterator iterates the hash map with custom callback function <f>.
+// If f returns true, then continue iterating; or false to stop.
 func (gm *IntIntMap) Iterator(f func (k int, v int) bool) {
    gm.mu.RLock()
    defer gm.mu.RUnlock()
@ -57,12 +70,12 @@ func (gm *IntIntMap) Iterator(f func (k int, v int) bool) {
    }
 }

-// 哈希表克隆.
+// Clone returns a new hash map with copy of current map data.
 func (gm *IntIntMap) Clone() *IntIntMap {
    return NewIntIntMapFrom(gm.Map(), !gm.mu.IsSafe())
 }

-// 返回当前哈希表的数据Map.
+// Map returns a copy of the data of the hash map.
 func (gm *IntIntMap) Map() map[int]int {
 	m := make(map[int]int)
 	gm.mu.RLock()
@ -73,14 +86,14 @@ func (gm *IntIntMap) Map() map[int]int {
 	return m
 }

-// 设置键值对
+// Set sets key-value to the hash map.
 func (gm *IntIntMap) Set(key int, val int) {
 	gm.mu.Lock()
 	gm.m[key] = val
 	gm.mu.Unlock()
 }

-// 批量设置键值对
+// BatchSet batch sets key-values to the hash map.
 func (gm *IntIntMap) BatchSet(m map[int]int) {
 	gm.mu.Lock()
 	for k, v := range m {
@ -89,7 +102,7 @@ func (gm *IntIntMap) BatchSet(m map[int]int) {
 	gm.mu.Unlock()
 }

-// 获取键值
+// Get returns the value by given <key>.
 func (gm *IntIntMap) Get(key int) (int) {
 	gm.mu.RLock()
 	val, _ := gm.m[key]
@ -97,8 +110,11 @@ func (gm *IntIntMap) Get(key int) (int) {
 	return val
 }

-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given <key>,
+// or else just return the existing value.
+//
+// It returns value with given <key>.
 func (gm *IntIntMap) doSetWithLockCheck(key int, value int) int {
    gm.mu.Lock()
    if v, ok := gm.m[key]; ok {
@ -110,7 +126,8 @@ func (gm *IntIntMap) doSetWithLockCheck(key int, value int) int {
    return value
 }

-// 当键名存在时返回其键值，否则写入指定的键值
+// GetOrSet returns the value by key,
+// or set value with given <value> if not exist and returns this value.
 func (gm *IntIntMap) GetOrSet(key int, value int) int {
    gm.mu.RLock()
    v, ok := gm.m[key]
@ -122,7 +139,8 @@ func (gm *IntIntMap) GetOrSet(key int, value int) int {
    }
 }

-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+// GetOrSetFunc returns the value by key,
+// or sets value with return value of callback function <f> if not exist and returns this value.
 func (gm *IntIntMap) GetOrSetFunc(key int, f func() int) int {
    gm.mu.RLock()
    v, ok := gm.m[key]
@ -134,7 +152,11 @@ func (gm *IntIntMap) GetOrSetFunc(key int, f func() int) int {
    }
 }

-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
+// GetOrSetFuncLock returns the value by key,
+// or sets value with return value of callback function <f> if not exist and returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f>
+// with mutex.Lock of the hash map.
 func (gm *IntIntMap) GetOrSetFuncLock(key int, f func() int) int {
    gm.mu.RLock()
    val, ok := gm.m[key]
@ -143,7 +165,6 @@ func (gm *IntIntMap) GetOrSetFuncLock(key int, f func() int) int {
        gm.mu.Lock()
        defer gm.mu.Unlock()
        if v, ok := gm.m[key]; ok {
-            gm.mu.Unlock()
            return v
        }
        val         = f()
@ -154,7 +175,8 @@ func (gm *IntIntMap) GetOrSetFuncLock(key int, f func() int) int {
    }
 }

-// 当键名不存在时写入，并返回true；否则返回false。
+// SetIfNotExist sets <value> to the map if the <key> does not exist, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
 func (gm *IntIntMap) SetIfNotExist(key int, value int) bool {
    if !gm.Contains(key) {
        gm.doSetWithLockCheck(key, value)
@ -163,7 +185,34 @@ func (gm *IntIntMap) SetIfNotExist(key int, value int) bool {
    return false
 }

-// 批量删除键值对
+// SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+func (gm *IntIntMap) SetIfNotExistFunc(key int, f func() int) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
+}
+
+// SetIfNotExistFuncLock sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function <f> with mutex.Lock of the hash map.
+func (gm *IntIntMap) SetIfNotExistFuncLock(key int, f func() int) bool {
+	if !gm.Contains(key) {
+		gm.mu.Lock()
+		defer gm.mu.Unlock()
+		if _, ok := gm.m[key]; !ok {
+			gm.m[key] = f()
+		}
+		return true
+	}
+	return false
+}
+
+// BatchRemove batch deletes values of the map by keys.
 func (gm *IntIntMap) BatchRemove(keys []int) {
    gm.mu.Lock()
    for _, key := range keys {
@ -172,7 +221,7 @@ func (gm *IntIntMap) BatchRemove(keys []int) {
    gm.mu.Unlock()
 }

-// 返回对应的键值，并删除该键值
+// Remove deletes value from map by given <key>, and return this deleted value.
 func (gm *IntIntMap) Remove(key int) int {
    gm.mu.Lock()
    val, exists := gm.m[key]
@ -183,7 +232,7 @@ func (gm *IntIntMap) Remove(key int) int {
    return val
 }

-// 返回键列表
+// Keys returns all keys of the map as a slice.
 func (gm *IntIntMap) Keys() []int {
    gm.mu.RLock()
    keys := make([]int, 0)
@ -194,7 +243,7 @@ func (gm *IntIntMap) Keys() []int {
    return keys
 }

-// 返回值列表(注意是随机排序)
+// Values returns all values of the map as a slice.
 func (gm *IntIntMap) Values() []int {
    gm.mu.RLock()
    vals := make([]int, 0)
@ -205,7 +254,8 @@ func (gm *IntIntMap) Values() []int {
    return vals
 }

-// 是否存在某个键
+// Contains checks whether a key exists.
+// It returns true if the <key> exists, or else false.
 func (gm *IntIntMap) Contains(key int) bool {
    gm.mu.RLock()
    _, exists := gm.m[key]
@ -213,7 +263,7 @@ func (gm *IntIntMap) Contains(key int) bool {
    return exists
 }

-// 哈希表大小
+// Size returns the size of the map.
 func (gm *IntIntMap) Size() int {
    gm.mu.RLock()
    length := len(gm.m)
@ -221,7 +271,8 @@ func (gm *IntIntMap) Size() int {
    return length
 }

-// 哈希表是否为空
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
 func (gm *IntIntMap) IsEmpty() bool {
    gm.mu.RLock()
    empty := len(gm.m) == 0
@ -229,28 +280,28 @@ func (gm *IntIntMap) IsEmpty() bool {
    return empty
 }

-// 清空哈希表
+// Clear deletes all data of the map, it will remake a new underlying map data map.
 func (gm *IntIntMap) Clear() {
    gm.mu.Lock()
    gm.m = make(map[int]int)
    gm.mu.Unlock()
 }

-// 并发安全锁操作，使用自定义方法执行加锁修改操作
+// LockFunc locks writing with given callback function <f> and mutex.Lock.
 func (gm *IntIntMap) LockFunc(f func(m map[int]int)) {
-    gm.mu.Lock(true)
-    defer gm.mu.Unlock(true)
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
    f(gm.m)
 }

-// 并发安全锁操作，使用自定义方法执行加锁读取操作
+// RLockFunc locks reading with given callback function <f> and mutex.RLock.
 func (gm *IntIntMap) RLockFunc(f func(m map[int]int)) {
-    gm.mu.RLock(true)
-    defer gm.mu.RUnlock(true)
+    gm.mu.RLock()
+    defer gm.mu.RUnlock()
    f(gm.m)
 }

-// 交换Map中的键和值.
+// Flip exchanges key-value of the map, it will change key-value to value-key.
 func (gm *IntIntMap) Flip() {
    gm.mu.Lock()
    defer gm.mu.Unlock()
@ -261,15 +312,16 @@ func (gm *IntIntMap) Flip() {
    gm.m = n
 }

-// 合并两个Map.
-func (gm *IntIntMap) Merge(m *IntIntMap) {
+// Merge merges two hash maps.
+// The <other> map will be merged into the map <gm>.
+func (gm *IntIntMap) Merge(other *IntIntMap) {
    gm.mu.Lock()
    defer gm.mu.Unlock()
-    if m != gm {
-        m.mu.RLock()
-        defer m.mu.RUnlock()
+    if other != gm {
+	    other.mu.RLock()
+        defer other.mu.RUnlock()
    }
-    for k, v := range m.m {
+    for k, v := range other.m {
        gm.m[k] = v
    }
 }
--- a/g/container/gmap/gmap_int_interface_map.go
+++ b/g/container/gmap/gmap_int_interface_map.go
@ -17,6 +17,9 @@ type IntInterfaceMap struct {
 	m  map[int]interface{}
 }

+// NewIntInterfaceMap returns an empty IntInterfaceMap object.
+// The param <unsafe> used to specify whether using map with un-concurrent-safety,
+// which is false in default, means concurrent-safe.
 func NewIntInterfaceMap(unsafe...bool) *IntInterfaceMap {
 	return &IntInterfaceMap{
        m  : make(map[int]interface{}),
@ -24,6 +27,9 @@ func NewIntInterfaceMap(unsafe...bool) *IntInterfaceMap {
    }
 }

+// NewIntInterfaceMapFrom returns an IntInterfaceMap object from given map <m>.
+// Notice that, the param map is a type of pointer,
+// there might be some concurrent-safe issues when changing the map outside.
 func NewIntInterfaceMapFrom(m map[int]interface{}, unsafe...bool) *IntInterfaceMap {
    return &IntInterfaceMap{
        m  : m,
@ -31,6 +37,12 @@ func NewIntInterfaceMapFrom(m map[int]interface{}, unsafe...bool) *IntInterfaceM
    }
 }

+// NewFromArray returns a hash map from given array.
+// The param <keys> given as the keys of the map,
+// and <values> as its corresponding values.
+//
+// If length of <keys> is greater than that of <values>,
+// the corresponding overflow map values will be the default value of its type.
 func NewIntInterfaceMapFromArray(keys []int, values []interface{}, unsafe...bool) *IntInterfaceMap {
    m := make(map[int]interface{})
    l := len(values)
@ -47,7 +59,8 @@ func NewIntInterfaceMapFromArray(keys []int, values []interface{}, unsafe...bool
    }
 }

-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
+// Iterator iterates the hash map with custom callback function <f>.
+// If f returns true, then continue iterating; or false to stop.
 func (gm *IntInterfaceMap) Iterator(f func (k int, v interface{}) bool) {
    gm.mu.RLock()
    defer gm.mu.RUnlock()
@ -58,12 +71,12 @@ func (gm *IntInterfaceMap) Iterator(f func (k int, v interface{}) bool) {
    }
 }

-// 哈希表克隆.
+// Clone returns a new hash map with copy of current map data.
 func (gm *IntInterfaceMap) Clone() *IntInterfaceMap {
    return NewIntInterfaceMapFrom(gm.Map(), !gm.mu.IsSafe())
 }

-// 返回当前哈希表的数据Map.
+// Map returns a copy of the data of the hash map.
 func (gm *IntInterfaceMap) Map() map[int]interface{} {
 	m := make(map[int]interface{})
 	gm.mu.RLock()
@ -74,14 +87,14 @@ func (gm *IntInterfaceMap) Map() map[int]interface{} {
 	return m
 }

-// 设置键值对
+// Set sets key-value to the hash map.
 func (gm *IntInterfaceMap) Set(key int, val interface{}) {
 	gm.mu.Lock()
 	gm.m[key] = val
 	gm.mu.Unlock()
 }

-// 批量设置键值对
+// BatchSet batch sets key-values to the hash map.
 func (gm *IntInterfaceMap) BatchSet(m map[int]interface{}) {
 	gm.mu.Lock()
 	for k, v := range m {
@ -90,7 +103,7 @@ func (gm *IntInterfaceMap) BatchSet(m map[int]interface{}) {
 	gm.mu.Unlock()
 }

-// 获取键值
+// Get returns the value by given <key>.
 func (gm *IntInterfaceMap) Get(key int) (interface{}) {
 	gm.mu.RLock()
 	val, _ := gm.m[key]
@ -98,8 +111,16 @@ func (gm *IntInterfaceMap) Get(key int) (interface{}) {
 	return val
 }

-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
+
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given <key>,
+// or else just return the existing value.
+//
+// When setting value, if <value> is type of <func() interface {}>,
+// it will be executed with mutex.Lock of the hash map,
+// and its return value will be set to the map with <key>.
+//
+// It returns value with given <key>.
 func (gm *IntInterfaceMap) doSetWithLockCheck(key int, value interface{}) interface{} {
    gm.mu.Lock()
    defer gm.mu.Unlock()
@ -109,11 +130,14 @@ func (gm *IntInterfaceMap) doSetWithLockCheck(key int, value interface{}) interf
    if f, ok := value.(func() interface {}); ok {
        value = f()
    }
-    gm.m[key] = value
+    if value != nil {
+        gm.m[key] = value
+    }
    return value
 }

-// 当键名存在时返回其键值，否则写入指定的键值
+// GetOrSet returns the value by key,
+// or set value with given <value> if not exist and returns this value.
 func (gm *IntInterfaceMap) GetOrSet(key int, value interface{}) interface{} {
    if v := gm.Get(key); v == nil {
        return gm.doSetWithLockCheck(key, value)
@ -122,7 +146,8 @@ func (gm *IntInterfaceMap) GetOrSet(key int, value interface{}) interface{} {
    }
 }

-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+// GetOrSetFunc returns the value by key,
+// or sets value with return value of callback function <f> if not exist and returns this value.
 func (gm *IntInterfaceMap) GetOrSetFunc(key int, f func() interface{}) interface{} {
    if v := gm.Get(key); v == nil {
        return gm.doSetWithLockCheck(key, f())
@ -131,7 +156,11 @@ func (gm *IntInterfaceMap) GetOrSetFunc(key int, f func() interface{}) interface
    }
 }

-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
+// GetOrSetFuncLock returns the value by key,
+// or sets value with return value of callback function <f> if not exist and returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f>
+// with mutex.Lock of the hash map.
 func (gm *IntInterfaceMap) GetOrSetFuncLock(key int, f func() interface{}) interface{} {
    if v := gm.Get(key); v == nil {
        return gm.doSetWithLockCheck(key, f)
@ -140,7 +169,8 @@ func (gm *IntInterfaceMap) GetOrSetFuncLock(key int, f func() interface{}) inter
    }
 }

-// 当键名不存在时写入，并返回true；否则返回false。
+// SetIfNotExist sets <value> to the map if the <key> does not exist, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
 func (gm *IntInterfaceMap) SetIfNotExist(key int, value interface{}) bool {
    if !gm.Contains(key) {
        gm.doSetWithLockCheck(key, value)
@ -149,7 +179,31 @@ func (gm *IntInterfaceMap) SetIfNotExist(key int, value interface{}) bool {
    return false
 }

-// 批量删除键值对
+// SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+func (gm *IntInterfaceMap) SetIfNotExistFunc(key int, f func() interface{}) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
+}
+
+// SetIfNotExistFuncLock sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function <f> with mutex.Lock of the hash map.
+func (gm *IntInterfaceMap) SetIfNotExistFuncLock(key int, f func() interface{}) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f)
+		return true
+	}
+	return false
+}
+
+
+// BatchRemove batch deletes values of the map by keys.
 func (gm *IntInterfaceMap) BatchRemove(keys []int) {
    gm.mu.Lock()
    for _, key := range keys {
@ -158,7 +212,7 @@ func (gm *IntInterfaceMap) BatchRemove(keys []int) {
    gm.mu.Unlock()
 }

-// 返回对应的键值，并删除该键值
+// Remove deletes value from map by given <key>, and return this deleted value.
 func (gm *IntInterfaceMap) Remove(key int) interface{} {
    gm.mu.Lock()
    val, exists := gm.m[key]
@ -169,7 +223,7 @@ func (gm *IntInterfaceMap) Remove(key int) interface{} {
    return val
 }

-// 返回键列表
+// Keys returns all keys of the map as a slice.
 func (gm *IntInterfaceMap) Keys() []int {
    gm.mu.RLock()
    keys := make([]int, 0)
@ -180,7 +234,7 @@ func (gm *IntInterfaceMap) Keys() []int {
    return keys
 }

-// 返回值列表(注意是随机排序)
+// Values returns all values of the map as a slice.
 func (gm *IntInterfaceMap) Values() []interface{} {
    gm.mu.RLock()
    vals := make([]interface{}, 0)
@ -191,7 +245,8 @@ func (gm *IntInterfaceMap) Values() []interface{} {
    return vals
 }

-// 是否存在某个键
+// Contains checks whether a key exists.
+// It returns true if the <key> exists, or else false.
 func (gm *IntInterfaceMap) Contains(key int) bool {
    gm.mu.RLock()
    _, exists := gm.m[key]
@ -199,7 +254,7 @@ func (gm *IntInterfaceMap) Contains(key int) bool {
    return exists
 }

-// 哈希表大小
+// Size returns the size of the map.
 func (gm *IntInterfaceMap) Size() int {
    gm.mu.RLock()
    length := len(gm.m)
@ -207,7 +262,8 @@ func (gm *IntInterfaceMap) Size() int {
    return length
 }

-// 哈希表是否为空
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
 func (gm *IntInterfaceMap) IsEmpty() bool {
    gm.mu.RLock()
    empty := len(gm.m) == 0
@ -215,28 +271,28 @@ func (gm *IntInterfaceMap) IsEmpty() bool {
    return empty
 }

-// 清空哈希表
+// Clear deletes all data of the map, it will remake a new underlying map data map.
 func (gm *IntInterfaceMap) Clear() {
    gm.mu.Lock()
    gm.m = make(map[int]interface{})
    gm.mu.Unlock()
 }

-// 并发安全锁操作，使用自定义方法执行加锁修改操作
+// LockFunc locks writing with given callback function <f> and mutex.Lock.
 func (gm *IntInterfaceMap) LockFunc(f func(m map[int]interface{})) {
    gm.mu.Lock()
    defer gm.mu.Unlock()
    f(gm.m)
 }

-// 并发安全锁操作，使用自定义方法执行加锁读取操作
+// RLockFunc locks reading with given callback function <f> and mutex.RLock.
 func (gm *IntInterfaceMap) RLockFunc(f func(m map[int]interface{})) {
-    gm.mu.RLock(true)
-    defer gm.mu.RUnlock(true)
+    gm.mu.RLock()
+    defer gm.mu.RUnlock()
    f(gm.m)
 }

-// 交换Map中的键和值.
+// Flip exchanges key-value of the map, it will change key-value to value-key.
 func (gm *IntInterfaceMap) Flip() {
    gm.mu.Lock()
    defer gm.mu.Unlock()
@ -247,15 +303,16 @@ func (gm *IntInterfaceMap) Flip() {
    gm.m = n
 }

-// 合并两个Map.
-func (gm *IntInterfaceMap) Merge(m *IntInterfaceMap) {
+// Merge merges two hash maps.
+// The <other> map will be merged into the map <gm>.
+func (gm *IntInterfaceMap) Merge(other *IntInterfaceMap) {
    gm.mu.Lock()
    defer gm.mu.Unlock()
-    if m != gm {
-        m.mu.RLock()
-        defer m.mu.RUnlock()
+    if other != gm {
+	    other.mu.RLock()
+        defer other.mu.RUnlock()
    }
-    for k, v := range m.m {
+    for k, v := range other.m {
        gm.m[k] = v
    }
 }
--- a/g/container/gmap/gmap_int_string_map.go
+++ b/g/container/gmap/gmap_int_string_map.go
@ -17,6 +17,9 @@ type IntStringMap struct {
 	m  map[int]string
 }

+// NewIntStringMap returns an empty IntStringMap object.
+// The param <unsafe> used to specify whether using map with un-concurrent-safety,
+// which is false in default, means concurrent-safe.
 func NewIntStringMap(unsafe...bool) *IntStringMap {
 	return &IntStringMap{
        m  : make(map[int]string),
@ -24,6 +27,9 @@ func NewIntStringMap(unsafe...bool) *IntStringMap {
    }
 }

+// NewIntStringMapFrom returns an IntStringMap object from given map <m>.
+// Notice that, the param map is a type of pointer,
+// there might be some concurrent-safe issues when changing the map outside.
 func NewIntStringMapFrom(m map[int]string, unsafe...bool) *IntStringMap {
    return &IntStringMap{
        m  : m,
@ -31,6 +37,12 @@ func NewIntStringMapFrom(m map[int]string, unsafe...bool) *IntStringMap {
    }
 }

+// NewIntStringMapFromArray returns an IntStringMap object from given array.
+// The param <keys> given as the keys of the map,
+// and <values> as its corresponding values.
+//
+// If length of <keys> is greater than that of <values>,
+// the corresponding overflow map values will be the default value of its type.
 func NewIntStringMapFromArray(keys []int, values []string, unsafe...bool) *IntStringMap {
    m := make(map[int]string)
    l := len(values)
@ -47,7 +59,8 @@ func NewIntStringMapFromArray(keys []int, values []string, unsafe...bool) *IntSt
    }
 }

-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
+// Iterator iterates the hash map with custom callback function <f>.
+// If f returns true, then continue iterating; or false to stop.
 func (gm *IntStringMap) Iterator(f func (k int, v string) bool) {
    gm.mu.RLock()
    defer gm.mu.RUnlock()
@ -58,12 +71,12 @@ func (gm *IntStringMap) Iterator(f func (k int, v string) bool) {
    }
 }

-// 哈希表克隆.
+// Clone returns a new hash map with copy of current map data.
 func (gm *IntStringMap) Clone() *IntStringMap {
    return NewIntStringMapFrom(gm.Map(), !gm.mu.IsSafe())
 }

-// 返回当前哈希表的数据Map.
+// Map returns a copy of the data of the hash map.
 func (gm *IntStringMap) Map() map[int]string {
 	m := make(map[int]string)
 	gm.mu.RLock()
@ -74,14 +87,14 @@ func (gm *IntStringMap) Map() map[int]string {
 	return m
 }

-// 设置键值对
+// Set sets key-value to the hash map.
 func (gm *IntStringMap) Set(key int, val string) {
 	gm.mu.Lock()
 	gm.m[key] = val
 	gm.mu.Unlock()
 }

-// 批量设置键值对
+// BatchSet batch sets key-values to the hash map.
 func (gm *IntStringMap) BatchSet(m map[int]string) {
 	gm.mu.Lock()
 	for k, v := range m {
@ -90,7 +103,7 @@ func (gm *IntStringMap) BatchSet(m map[int]string) {
 	gm.mu.Unlock()
 }

-// 获取键值
+// Get returns the value by given <key>.
 func (gm *IntStringMap) Get(key int) string {
 	gm.mu.RLock()
 	val, _ := gm.m[key]
@ -98,8 +111,11 @@ func (gm *IntStringMap) Get(key int) string {
 	return val
 }

-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given <key>,
+// or else just return the existing value.
+//
+// It returns value with given <key>.
 func (gm *IntStringMap) doSetWithLockCheck(key int, value string) string {
    gm.mu.Lock()
    if v, ok := gm.m[key]; ok {
@ -111,7 +127,8 @@ func (gm *IntStringMap) doSetWithLockCheck(key int, value string) string {
    return value
 }

-// 当键名存在时返回其键值，否则写入指定的键值
+// GetOrSet returns the value by key,
+// or set value with given <value> if not exist and returns this value.
 func (gm *IntStringMap) GetOrSet(key int, value string) string {
    gm.mu.RLock()
    v, ok := gm.m[key]
@ -123,7 +140,8 @@ func (gm *IntStringMap) GetOrSet(key int, value string) string {
    }
 }

-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+// GetOrSetFunc returns the value by key,
+// or sets value with return value of callback function <f> if not exist and returns this value.
 func (gm *IntStringMap) GetOrSetFunc(key int, f func() string) string {
    gm.mu.RLock()
    v, ok := gm.m[key]
@ -135,7 +153,11 @@ func (gm *IntStringMap) GetOrSetFunc(key int, f func() string) string {
    }
 }

-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
+// GetOrSetFuncLock returns the value by key,
+// or sets value with return value of callback function <f> if not exist and returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f>
+// with mutex.Lock of the hash map.
 func (gm *IntStringMap) GetOrSetFuncLock(key int, f func() string) string {
    gm.mu.RLock()
    val, ok := gm.m[key]
@ -144,10 +166,9 @@ func (gm *IntStringMap) GetOrSetFuncLock(key int, f func() string) string {
        gm.mu.Lock()
        defer gm.mu.Unlock()
        if v, ok := gm.m[key]; ok {
-            gm.mu.Unlock()
            return v
        }
-        val         = f()
+        val       = f()
        gm.m[key] = val
        return val
    } else {
@ -155,7 +176,8 @@ func (gm *IntStringMap) GetOrSetFuncLock(key int, f func() string) string {
    }
 }

-// 当键名不存在时写入，并返回true；否则返回false。
+// SetIfNotExist sets <value> to the map if the <key> does not exist, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
 func (gm *IntStringMap) SetIfNotExist(key int, value string) bool {
    if !gm.Contains(key) {
        gm.doSetWithLockCheck(key, value)
@ -164,7 +186,35 @@ func (gm *IntStringMap) SetIfNotExist(key int, value string) bool {
    return false
 }

-// 批量删除键值对
+// SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+func (gm *IntStringMap) SetIfNotExistFunc(key int, f func() string) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
+}
+
+// SetIfNotExistFuncLock sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function <f> with mutex.Lock of the hash map.
+func (gm *IntStringMap) SetIfNotExistFuncLock(key int, f func() string) bool {
+	if !gm.Contains(key) {
+		gm.mu.Lock()
+		defer gm.mu.Unlock()
+		if _, ok := gm.m[key]; !ok {
+			gm.m[key] = f()
+		}
+		return true
+	}
+	return false
+}
+
+
+// BatchRemove batch deletes values of the map by keys.
 func (gm *IntStringMap) BatchRemove(keys []int) {
    gm.mu.Lock()
    for _, key := range keys {
@ -173,7 +223,7 @@ func (gm *IntStringMap) BatchRemove(keys []int) {
    gm.mu.Unlock()
 }

-// 返回对应的键值，并删除该键值
+// Remove deletes value from map by given <key>, and return this deleted value.
 func (gm *IntStringMap) Remove(key int) string {
    gm.mu.Lock()
    val, exists := gm.m[key]
@ -184,7 +234,7 @@ func (gm *IntStringMap) Remove(key int) string {
    return val
 }

-// 返回键列表
+// Keys returns all keys of the map as a slice.
 func (gm *IntStringMap) Keys() []int {
    gm.mu.RLock()
    keys := make([]int, 0)
@ -195,7 +245,7 @@ func (gm *IntStringMap) Keys() []int {
    return keys
 }

-// 返回值列表(注意是随机排序)
+// Values returns all values of the map as a slice.
 func (gm *IntStringMap) Values() []string {
    gm.mu.RLock()
    vals := make([]string, 0)
@ -206,7 +256,8 @@ func (gm *IntStringMap) Values() []string {
    return vals
 }

-// 是否存在某个键
+// Contains checks whether a key exists.
+// It returns true if the <key> exists, or else false.
 func (gm *IntStringMap) Contains(key int) bool {
    gm.mu.RLock()
    _, exists := gm.m[key]
@ -214,7 +265,7 @@ func (gm *IntStringMap) Contains(key int) bool {
    return exists
 }

-// 哈希表大小
+// Size returns the size of the map.
 func (gm *IntStringMap) Size() int {
    gm.mu.RLock()
    length := len(gm.m)
@ -222,7 +273,8 @@ func (gm *IntStringMap) Size() int {
    return length
 }

-// 哈希表是否为空
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
 func (gm *IntStringMap) IsEmpty() bool {
    gm.mu.RLock()
    empty := len(gm.m) == 0
@ -230,28 +282,28 @@ func (gm *IntStringMap) IsEmpty() bool {
    return empty
 }

-// 清空哈希表
+// Clear deletes all data of the map, it will remake a new underlying map data map.
 func (gm *IntStringMap) Clear() {
    gm.mu.Lock()
    gm.m = make(map[int]string)
    gm.mu.Unlock()
 }

-// 并发安全锁操作，使用自定义方法执行加锁修改操作
+// LockFunc locks writing with given callback function <f> and mutex.Lock.
 func (gm *IntStringMap) LockFunc(f func(m map[int]string)) {
-    gm.mu.Lock(true)
-    defer gm.mu.Unlock(true)
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
    f(gm.m)
 }

-// 并发安全锁操作，使用自定义方法执行加锁读取操作
+// RLockFunc locks reading with given callback function <f> and mutex.RLock.
 func (gm *IntStringMap) RLockFunc(f func(m map[int]string)) {
-    gm.mu.RLock(true)
-    defer gm.mu.RUnlock(true)
+    gm.mu.RLock()
+    defer gm.mu.RUnlock()
    f(gm.m)
 }

-// 交换Map中的键和值.
+// Flip exchanges key-value of the map, it will change key-value to value-key.
 func (gm *IntStringMap) Flip() {
    gm.mu.Lock()
    defer gm.mu.Unlock()
@ -262,15 +314,16 @@ func (gm *IntStringMap) Flip() {
    gm.m = n
 }

-// 合并两个Map.
-func (gm *IntStringMap) Merge(m *IntStringMap) {
+// Merge merges two hash maps.
+// The <other> map will be merged into the map <gm>.
+func (gm *IntStringMap) Merge(other *IntStringMap) {
    gm.mu.Lock()
    defer gm.mu.Unlock()
-    if m != gm {
-        m.mu.RLock()
-        defer m.mu.RUnlock()
+    if other != gm {
+	    other.mu.RLock()
+        defer other.mu.RUnlock()
    }
-    for k, v := range m.m {
+    for k, v := range other.m {
        gm.m[k] = v
    }
 }
--- a/g/container/gmap/gmap_string_bool_map.go
+++ b/g/container/gmap/gmap_string_bool_map.go
@ -16,6 +16,9 @@ type StringBoolMap struct {
 	m  map[string]bool
 }

+// NewStringBoolMap returns an empty StringBoolMap object.
+// The param <unsafe> used to specify whether using map with un-concurrent-safety,
+// which is false in default, means concurrent-safe.
 func NewStringBoolMap(unsafe...bool) *StringBoolMap {
 	return &StringBoolMap{
 		m  : make(map[string]bool),
@ -23,6 +26,9 @@ func NewStringBoolMap(unsafe...bool) *StringBoolMap {
 	}
 }

+// NewStringBoolMapFrom returns an StringBoolMap object from given map <m>.
+// Notice that, the param map is a type of pointer,
+// there might be some concurrent-safe issues when changing the map outside.
 func NewStringBoolMapFrom(m map[string]bool, unsafe...bool) *StringBoolMap {
    return &StringBoolMap{
        m  : m,
@ -30,6 +36,12 @@ func NewStringBoolMapFrom(m map[string]bool, unsafe...bool) *StringBoolMap {
    }
 }

+// NewFromArray returns a hash map from given array.
+// The param <keys> given as the keys of the map,
+// and <values> as its corresponding values.
+//
+// If length of <keys> is greater than that of <values>,
+// the corresponding overflow map values will be the default value of its type.
 func NewStringBoolMapFromArray(keys []string, values []bool, unsafe...bool) *StringBoolMap {
    m := make(map[string]bool)
    l := len(values)
@ -46,7 +58,8 @@ func NewStringBoolMapFromArray(keys []string, values []bool, unsafe...bool) *Str
    }
 }

-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
+// Iterator iterates the hash map with custom callback function <f>.
+// If f returns true, then continue iterating; or false to stop.
 func (gm *StringBoolMap) Iterator(f func (k string, v bool) bool) {
 	gm.mu.RLock()
 	defer gm.mu.RUnlock()
@ -57,12 +70,12 @@ func (gm *StringBoolMap) Iterator(f func (k string, v bool) bool) {
    }
 }

-// 哈希表克隆.
+// Clone returns a new hash map with copy of current map data.
 func (gm *StringBoolMap) Clone() *StringBoolMap {
    return NewStringBoolMapFrom(gm.Map(), !gm.mu.IsSafe())
 }

-// 返回当前哈希表的数据Map.
+// Map returns a copy of the data of the hash map.
 func (gm *StringBoolMap) Map() map[string]bool {
    m := make(map[string]bool)
    gm.mu.RLock()
@ -73,14 +86,14 @@ func (gm *StringBoolMap) Map() map[string]bool {
    return m
 }

-// 设置键值对
+// Set sets key-value to the hash map.
 func (gm *StringBoolMap) Set(key string, val bool) {
 	gm.mu.Lock()
 	gm.m[key] = val
 	gm.mu.Unlock()
 }

-// 批量设置键值对
+// BatchSet batch sets key-values to the hash map.
 func (gm *StringBoolMap) BatchSet(m map[string]bool) {
    gm.mu.Lock()
    for k, v := range m {
@ -89,7 +102,7 @@ func (gm *StringBoolMap) BatchSet(m map[string]bool) {
    gm.mu.Unlock()
 }

-// 获取键值
+// Get returns the value by given <key>.
 func (gm *StringBoolMap) Get(key string) bool {
 	gm.mu.RLock()
 	val, _ := gm.m[key]
@ -97,8 +110,11 @@ func (gm *StringBoolMap) Get(key string) bool {
 	return val
 }

-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given <key>,
+// or else just return the existing value.
+//
+// It returns value with given <key>.
 func (gm *StringBoolMap) doSetWithLockCheck(key string, value bool) bool {
 	gm.mu.Lock()
 	if v, ok := gm.m[key]; ok {
@ -110,7 +126,8 @@ func (gm *StringBoolMap) doSetWithLockCheck(key string, value bool) bool {
 	return value
 }

-// 当键名存在时返回其键值，否则写入指定的键值
+// GetOrSet returns the value by key,
+// or set value with given <value> if not exist and returns this value.
 func (gm *StringBoolMap) GetOrSet(key string, value bool) bool {
 	gm.mu.RLock()
 	v, ok := gm.m[key]
@ -122,7 +139,9 @@ func (gm *StringBoolMap) GetOrSet(key string, value bool) bool {
 	}
 }

-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+// GetOrSetFunc returns the value by key,
+// or sets value with return value of callback function <f> if not exist
+// and returns this value.
 func (gm *StringBoolMap) GetOrSetFunc(key string, f func() bool) bool {
 	gm.mu.RLock()
 	v, ok := gm.m[key]
@ -134,7 +153,12 @@ func (gm *StringBoolMap) GetOrSetFunc(key string, f func() bool) bool {
 	}
 }

-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
+// GetOrSetFuncLock returns the value by key,
+// or sets value with return value of callback function <f> if not exist
+// and returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f>
+// with mutex.Lock of the hash map.
 func (gm *StringBoolMap) GetOrSetFuncLock(key string, f func() bool) bool {
 	gm.mu.RLock()
 	val, ok := gm.m[key]
@ -143,7 +167,6 @@ func (gm *StringBoolMap) GetOrSetFuncLock(key string, f func() bool) bool {
 		gm.mu.Lock()
 		defer gm.mu.Unlock()
 		if v, ok := gm.m[key]; ok {
-			gm.mu.Unlock()
 			return v
 		}
 		val         = f()
@ -154,7 +177,9 @@ func (gm *StringBoolMap) GetOrSetFuncLock(key string, f func() bool) bool {
 	}
 }

-// 当键名不存在时写入，并返回true；否则返回false。
+
+// SetIfNotExist sets <value> to the map if the <key> does not exist, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
 func (gm *StringBoolMap) SetIfNotExist(key string, value bool) bool {
 	if !gm.Contains(key) {
 		gm.doSetWithLockCheck(key, value)
@ -163,7 +188,34 @@ func (gm *StringBoolMap) SetIfNotExist(key string, value bool) bool {
 	return false
 }

-// 批量删除键值对
+// SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+func (gm *StringBoolMap) SetIfNotExistFunc(key string, f func() bool) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
+}
+
+// SetIfNotExistFuncLock sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function <f> with mutex.Lock of the hash map.
+func (gm *StringBoolMap) SetIfNotExistFuncLock(key string, f func() bool) bool {
+	if !gm.Contains(key) {
+		gm.mu.Lock()
+		defer gm.mu.Unlock()
+		if _, ok := gm.m[key]; !ok {
+			gm.m[key] = f()
+		}
+		return true
+	}
+	return false
+}
+
+// BatchRemove batch deletes values of the map by keys.
 func (gm *StringBoolMap) BatchRemove(keys []string) {
    gm.mu.Lock()
    for _, key := range keys {
@ -172,7 +224,7 @@ func (gm *StringBoolMap) BatchRemove(keys []string) {
    gm.mu.Unlock()
 }

-// 返回对应的键值，并删除该键值
+// Remove deletes value from map by given <key>, and return this deleted value.
 func (gm *StringBoolMap) Remove(key string) bool {
 	gm.mu.Lock()
 	val, exists := gm.m[key]
@ -183,7 +235,7 @@ func (gm *StringBoolMap) Remove(key string) bool {
 	return val
 }

-// 返回键列表
+// Keys returns all keys of the map as a slice.
 func (gm *StringBoolMap) Keys() []string {
 	gm.mu.RLock()
 	keys := make([]string, 0)
@ -194,18 +246,8 @@ func (gm *StringBoolMap) Keys() []string {
 	return keys
 }

-// 返回值列表(注意是随机排序)
-//func (gm *StringBoolMap) Values() []bool {
-//	gm.mu.RLock()
-//	vals := make([]bool, 0)
-//	for _, val := range gm.m {
-//		vals = append(vals, val)
-//	}
-//	gm.mu.RUnlock()
-//	return vals
-//}
-
-// 是否存在某个键
+// Contains checks whether a key exists.
+// It returns true if the <key> exists, or else false.
 func (gm *StringBoolMap) Contains(key string) bool {
 	gm.mu.RLock()
 	_, exists := gm.m[key]
@ -213,7 +255,7 @@ func (gm *StringBoolMap) Contains(key string) bool {
 	return exists
 }

-// 哈希表大小
+// Size returns the size of the map.
 func (gm *StringBoolMap) Size() int {
 	gm.mu.RLock()
 	length := len(gm.m)
@ -221,7 +263,8 @@ func (gm *StringBoolMap) Size() int {
 	return length
 }

-// 哈希表是否为空
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
 func (gm *StringBoolMap) IsEmpty() bool {
 	gm.mu.RLock()
 	empty := len(gm.m) == 0
@ -229,36 +272,37 @@ func (gm *StringBoolMap) IsEmpty() bool {
 	return empty
 }

-// 清空哈希表
+// Clear deletes all data of the map, it will remake a new underlying map data map.
 func (gm *StringBoolMap) Clear() {
    gm.mu.Lock()
    gm.m = make(map[string]bool)
    gm.mu.Unlock()
 }

-// 并发安全锁操作，使用自定义方法执行加锁修改操作
+// LockFunc locks writing with given callback function <f> and mutex.Lock.
 func (gm *StringBoolMap) LockFunc(f func(m map[string]bool)) {
-	gm.mu.Lock(true)
-	defer gm.mu.Unlock(true)
-	f(gm.m)
-}
-
-// 并发安全锁操作，使用自定义方法执行加锁读取操作
-func (gm *StringBoolMap) RLockFunc(f func(m map[string]bool)) {
-	gm.mu.RLock(true)
-	defer gm.mu.RUnlock(true)
-	f(gm.m)
-}
-
-// 合并两个Map.
-func (gm *StringBoolMap) Merge(m *StringBoolMap) {
 	gm.mu.Lock()
 	defer gm.mu.Unlock()
-	if m != gm {
-		m.mu.RLock()
-		defer m.mu.RUnlock()
+	f(gm.m)
+}
+
+// RLockFunc locks reading with given callback function <f> and mutex.RLock.
+func (gm *StringBoolMap) RLockFunc(f func(m map[string]bool)) {
+	gm.mu.RLock()
+	defer gm.mu.RUnlock()
+	f(gm.m)
+}
+
+// Merge merges two hash maps.
+// The <other> map will be merged into the map <gm>.
+func (gm *StringBoolMap) Merge(other *StringBoolMap) {
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
+	if other != gm {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
 	}
-	for k, v := range m.m {
+	for k, v := range other.m {
 		gm.m[k] = v
 	}
 }
--- a/g/container/gmap/gmap_string_int_map.go
+++ b/g/container/gmap/gmap_string_int_map.go
@ -17,6 +17,9 @@ type StringIntMap struct {
 	m  map[string]int
 }

+// NewStringIntMap returns an empty StringIntMap object.
+// The param <unsafe> used to specify whether using map with un-concurrent-safety,
+// which is false in default, means concurrent-safe.
 func NewStringIntMap(unsafe...bool) *StringIntMap {
 	return &StringIntMap{
        m  : make(map[string]int),
@ -24,6 +27,9 @@ func NewStringIntMap(unsafe...bool) *StringIntMap {
    }
 }

+// NewStringIntMapFrom returns an StringIntMap object from given map <m>.
+// Notice that, the param map is a type of pointer,
+// there might be some concurrent-safe issues when changing the map outside.
 func NewStringIntMapFrom(m map[string]int, unsafe...bool) *StringIntMap {
    return &StringIntMap{
        m  : m,
@ -31,6 +37,12 @@ func NewStringIntMapFrom(m map[string]int, unsafe...bool) *StringIntMap {
    }
 }

+// NewStringIntMapFromArray returns an StringIntMap object from given array.
+// The param <keys> given as the keys of the map,
+// and <values> as its corresponding values.
+//
+// If length of <keys> is greater than that of <values>,
+// the corresponding overflow map values will be the default value of its type.
 func NewStringIntMapFromArray(keys []string, values []int, unsafe...bool) *StringIntMap {
    m := make(map[string]int)
    l := len(values)
@ -47,7 +59,8 @@ func NewStringIntMapFromArray(keys []string, values []int, unsafe...bool) *Strin
    }
 }

-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
+// Iterator iterates the hash map with custom callback function <f>.
+// If f returns true, then continue iterating; or false to stop.
 func (gm *StringIntMap) Iterator(f func (k string, v int) bool) {
    gm.mu.RLock()
    defer gm.mu.RUnlock()
@ -58,12 +71,12 @@ func (gm *StringIntMap) Iterator(f func (k string, v int) bool) {
    }
 }

-// 哈希表克隆.
+// Clone returns a new hash map with copy of current map data.
 func (gm *StringIntMap) Clone() *StringIntMap {
    return NewStringIntMapFrom(gm.Map(), !gm.mu.IsSafe())
 }

-// 返回当前哈希表的数据Map.
+// Map returns a copy of the data of the hash map.
 func (gm *StringIntMap) Map() map[string]int {
    m := make(map[string]int)
    gm.mu.RLock()
@ -74,14 +87,14 @@ func (gm *StringIntMap) Map() map[string]int {
    return m
 }

-// 设置键值对
+// Set sets key-value to the hash map.
 func (gm *StringIntMap) Set(key string, val int) {
 	gm.mu.Lock()
 	gm.m[key] = val
 	gm.mu.Unlock()
 }

-// 批量设置键值对
+// BatchSet batch sets key-values to the hash map.
 func (gm *StringIntMap) BatchSet(m map[string]int) {
 	gm.mu.Lock()
 	for k, v := range m {
@ -90,7 +103,7 @@ func (gm *StringIntMap) BatchSet(m map[string]int) {
 	gm.mu.Unlock()
 }

-// 获取键值
+// Get returns the value by given <key>.
 func (gm *StringIntMap) Get(key string) int {
 	gm.mu.RLock()
 	val, _ := gm.m[key]
@ -98,8 +111,11 @@ func (gm *StringIntMap) Get(key string) int {
 	return val
 }

-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given <key>,
+// or else just return the existing value.
+//
+// It returns value with given <key>.
 func (gm *StringIntMap) doSetWithLockCheck(key string, value int) int {
    gm.mu.Lock()
    if v, ok := gm.m[key]; ok {
@ -111,7 +127,8 @@ func (gm *StringIntMap) doSetWithLockCheck(key string, value int) int {
    return value
 }

-// 当键名存在时返回其键值，否则写入指定的键值
+// GetOrSet returns the value by key,
+// or set value with given <value> if not exist and returns this value.
 func (gm *StringIntMap) GetOrSet(key string, value int) int {
    gm.mu.RLock()
    v, ok := gm.m[key]
@ -123,7 +140,9 @@ func (gm *StringIntMap) GetOrSet(key string, value int) int {
    }
 }

-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+// GetOrSetFunc returns the value by key,
+// or sets value with return value of callback function <f> if not exist
+// and returns this value.
 func (gm *StringIntMap) GetOrSetFunc(key string, f func() int) int {
    gm.mu.RLock()
    v, ok := gm.m[key]
@ -135,7 +154,12 @@ func (gm *StringIntMap) GetOrSetFunc(key string, f func() int) int {
    }
 }

-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
+// GetOrSetFuncLock returns the value by key,
+// or sets value with return value of callback function <f> if not exist
+// and returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f>
+// with mutex.Lock of the hash map.
 func (gm *StringIntMap) GetOrSetFuncLock(key string, f func() int) int {
    gm.mu.RLock()
    val, ok := gm.m[key]
@ -144,10 +168,9 @@ func (gm *StringIntMap) GetOrSetFuncLock(key string, f func() int) int {
        gm.mu.Lock()
        defer gm.mu.Unlock()
        if v, ok := gm.m[key]; ok {
-            gm.mu.Unlock()
            return v
        }
-        val         = f()
+        val       = f()
        gm.m[key] = val
        return val
    } else {
@ -155,7 +178,8 @@ func (gm *StringIntMap) GetOrSetFuncLock(key string, f func() int) int {
    }
 }

-// 当键名不存在时写入，并返回true；否则返回false。
+// SetIfNotExist sets <value> to the map if the <key> does not exist, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
 func (gm *StringIntMap) SetIfNotExist(key string, value int) bool {
    if !gm.Contains(key) {
        gm.doSetWithLockCheck(key, value)
@ -164,7 +188,34 @@ func (gm *StringIntMap) SetIfNotExist(key string, value int) bool {
    return false
 }

-// 批量删除键值对
+// SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+func (gm *StringIntMap) SetIfNotExistFunc(key string, f func() int) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
+}
+
+// SetIfNotExistFuncLock sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function <f> with mutex.Lock of the hash map.
+func (gm *StringIntMap) SetIfNotExistFuncLock(key string, f func() int) bool {
+	if !gm.Contains(key) {
+		gm.mu.Lock()
+		defer gm.mu.Unlock()
+		if _, ok := gm.m[key]; !ok {
+			gm.m[key] = f()
+		}
+		return true
+	}
+	return false
+}
+
+// BatchRemove batch deletes values of the map by keys.
 func (gm *StringIntMap) BatchRemove(keys []string) {
    gm.mu.Lock()
    for _, key := range keys {
@ -173,7 +224,7 @@ func (gm *StringIntMap) BatchRemove(keys []string) {
    gm.mu.Unlock()
 }

-// 返回对应的键值，并删除该键值
+// Remove deletes value from map by given <key>, and return this deleted value.
 func (gm *StringIntMap) Remove(key string) int {
    gm.mu.Lock()
    val, exists := gm.m[key]
@ -184,7 +235,7 @@ func (gm *StringIntMap) Remove(key string) int {
    return val
 }

-// 返回键列表
+// Keys returns all keys of the map as a slice.
 func (gm *StringIntMap) Keys() []string {
    gm.mu.RLock()
    keys := make([]string, 0)
@ -195,7 +246,7 @@ func (gm *StringIntMap) Keys() []string {
    return keys
 }

-// 返回值列表(注意是随机排序)
+// Values returns all values of the map as a slice.
 func (gm *StringIntMap) Values() []int {
    gm.mu.RLock()
    vals := make([]int, 0)
@ -206,7 +257,8 @@ func (gm *StringIntMap) Values() []int {
    return vals
 }

-// 是否存在某个键
+// Contains checks whether a key exists.
+// It returns true if the <key> exists, or else false.
 func (gm *StringIntMap) Contains(key string) bool {
    gm.mu.RLock()
    _, exists := gm.m[key]
@ -214,7 +266,7 @@ func (gm *StringIntMap) Contains(key string) bool {
    return exists
 }

-// 哈希表大小
+// Size returns the size of the map.
 func (gm *StringIntMap) Size() int {
    gm.mu.RLock()
    length := len(gm.m)
@ -222,7 +274,8 @@ func (gm *StringIntMap) Size() int {
    return length
 }

-// 哈希表是否为空
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
 func (gm *StringIntMap) IsEmpty() bool {
    gm.mu.RLock()
    empty := len(gm.m) == 0
@ -230,28 +283,28 @@ func (gm *StringIntMap) IsEmpty() bool {
    return empty
 }

-// 清空哈希表
+// Clear deletes all data of the map, it will remake a new underlying map data map.
 func (gm *StringIntMap) Clear() {
    gm.mu.Lock()
    gm.m = make(map[string]int)
    gm.mu.Unlock()
 }

-// 并发安全写锁操作，使用自定义方法执行加锁修改操作
+// LockFunc locks writing with given callback function <f> and mutex.Lock.
 func (gm *StringIntMap) LockFunc(f func(m map[string]int)) {
-    gm.mu.Lock(true)
-    defer gm.mu.Unlock(true)
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
    f(gm.m)
 }

-// 并发安全读锁操作，使用自定义方法执行加锁读取操作
+// RLockFunc locks reading with given callback function <f> and mutex.RLock.
 func (gm *StringIntMap) RLockFunc(f func(m map[string]int)) {
-    gm.mu.RLock(true)
-    defer gm.mu.RUnlock(true)
+    gm.mu.RLock()
+    defer gm.mu.RUnlock()
    f(gm.m)
 }

-// 交换Map中的键和值.
+// Flip exchanges key-value of the map, it will change key-value to value-key.
 func (gm *StringIntMap) Flip() {
    gm.mu.Lock()
    defer gm.mu.Unlock()
@ -262,15 +315,16 @@ func (gm *StringIntMap) Flip() {
    gm.m = n
 }

-// 合并两个Map.
-func (gm *StringIntMap) Merge(m *StringIntMap) {
+// Merge merges two hash maps.
+// The <other> map will be merged into the map <gm>.
+func (gm *StringIntMap) Merge(other *StringIntMap) {
    gm.mu.Lock()
    defer gm.mu.Unlock()
-    if m != gm {
-        m.mu.RLock()
-        defer m.mu.RUnlock()
+    if other != gm {
+	    other.mu.RLock()
+        defer other.mu.RUnlock()
    }
-    for k, v := range m.m {
+    for k, v := range other.m {
        gm.m[k] = v
    }
 }
--- a/g/container/gmap/gmap_string_interface_map.go
+++ b/g/container/gmap/gmap_string_interface_map.go
@ -17,6 +17,9 @@ type StringInterfaceMap struct {
 	m  map[string]interface{}
 }

+// NewStringInterfaceMap returns an empty StringInterfaceMap object.
+// The param <unsafe> used to specify whether using map with un-concurrent-safety,
+// which is false in default, means concurrent-safe.
 func NewStringInterfaceMap(unsafe...bool) *StringInterfaceMap {
 	return &StringInterfaceMap{
 		m  : make(map[string]interface{}),
@ -24,6 +27,9 @@ func NewStringInterfaceMap(unsafe...bool) *StringInterfaceMap {
 	}
 }

+// NewStringInterfaceMapFrom returns an StringInterfaceMap object from given map <m>.
+// Notice that, the param map is a type of pointer,
+// there might be some concurrent-safe issues when changing the map outside.
 func NewStringInterfaceMapFrom(m map[string]interface{}, unsafe...bool) *StringInterfaceMap {
    return &StringInterfaceMap{
        m  : m,
@ -31,6 +37,12 @@ func NewStringInterfaceMapFrom(m map[string]interface{}, unsafe...bool) *StringI
    }
 }

+// NewStringInterfaceMapFromArray returns an StringInterfaceMap object from given array.
+// The param <keys> given as the keys of the map,
+// and <values> as its corresponding values.
+//
+// If length of <keys> is greater than that of <values>,
+// the corresponding overflow map values will be the default value of its type.
 func NewStringInterfaceMapFromArray(keys []string, values []interface{}, unsafe...bool) *StringInterfaceMap {
    m := make(map[string]interface{})
    l := len(values)
@ -47,7 +59,8 @@ func NewStringInterfaceMapFromArray(keys []string, values []interface{}, unsafe.
    }
 }

-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
+// Iterator iterates the hash map with custom callback function <f>.
+// If f returns true, then continue iterating; or false to stop.
 func (gm *StringInterfaceMap) Iterator(f func (k string, v interface{}) bool) {
 	gm.mu.RLock()
 	defer gm.mu.RUnlock()
@ -58,12 +71,12 @@ func (gm *StringInterfaceMap) Iterator(f func (k string, v interface{}) bool) {
 	}
 }

-// 哈希表克隆.
+// Clone returns a new hash map with copy of current map data.
 func (gm *StringInterfaceMap) Clone() *StringInterfaceMap {
    return NewStringInterfaceMapFrom(gm.Map(), !gm.mu.IsSafe())
 }

-// 返回当前哈希表的数据Map.
+// Map returns a copy of the data of the hash map.
 func (gm *StringInterfaceMap) Map() map[string]interface{} {
    m := make(map[string]interface{})
    gm.mu.RLock()
@ -74,14 +87,14 @@ func (gm *StringInterfaceMap) Map() map[string]interface{} {
    return m
 }

-// 设置键值对
+// Set sets key-value to the hash map.
 func (gm *StringInterfaceMap) Set(key string, val interface{}) {
 	gm.mu.Lock()
 	gm.m[key] = val
 	gm.mu.Unlock()
 }

-// 批量设置键值对
+// BatchSet batch sets key-values to the hash map.
 func (gm *StringInterfaceMap) BatchSet(m map[string]interface{}) {
    gm.mu.Lock()
    for k, v := range m {
@ -90,7 +103,7 @@ func (gm *StringInterfaceMap) BatchSet(m map[string]interface{}) {
    gm.mu.Unlock()
 }

-// 获取键值
+// Get returns the value by given <key>.
 func (gm *StringInterfaceMap) Get(key string) interface{} {
 	gm.mu.RLock()
 	val, _ := gm.m[key]
@ -98,8 +111,15 @@ func (gm *StringInterfaceMap) Get(key string) interface{} {
 	return val
 }

-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given <key>,
+// or else just return the existing value.
+//
+// When setting value, if <value> is type of <func() interface {}>,
+// it will be executed with mutex.Lock of the hash map,
+// and its return value will be set to the map with <key>.
+//
+// It returns value with given <key>.
 func (gm *StringInterfaceMap) doSetWithLockCheck(key string, value interface{}) interface{} {
 	gm.mu.Lock()
 	defer gm.mu.Unlock()
@ -109,11 +129,14 @@ func (gm *StringInterfaceMap) doSetWithLockCheck(key string, value interface{})
    if f, ok := value.(func() interface {}); ok {
        value = f()
    }
-    gm.m[key] = value
+    if value != nil {
+        gm.m[key] = value
+    }
    return value
 }

-// 当键名存在时返回其键值，否则写入指定的键值
+// GetOrSet returns the value by key,
+// or set value with given <value> if not exist and returns this value.
 func (gm *StringInterfaceMap) GetOrSet(key string, value interface{}) interface{} {
    if v := gm.Get(key); v == nil {
        return gm.doSetWithLockCheck(key, value)
@ -122,7 +145,9 @@ func (gm *StringInterfaceMap) GetOrSet(key string, value interface{}) interface{
    }
 }

-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+// GetOrSetFunc returns the value by key,
+// or sets value with return value of callback function <f> if not exist
+// and returns this value.
 func (gm *StringInterfaceMap) GetOrSetFunc(key string, f func() interface{}) interface{} {
    if v := gm.Get(key); v == nil {
        return gm.doSetWithLockCheck(key, f())
@ -131,7 +156,12 @@ func (gm *StringInterfaceMap) GetOrSetFunc(key string, f func() interface{}) int
    }
 }

-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
+// GetOrSetFuncLock returns the value by key,
+// or sets value with return value of callback function <f> if not exist
+// and returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f>
+// with mutex.Lock of the hash map.
 func (gm *StringInterfaceMap) GetOrSetFuncLock(key string, f func() interface{}) interface{} {
    if v := gm.Get(key); v == nil {
        return gm.doSetWithLockCheck(key, f)
@ -140,7 +170,8 @@ func (gm *StringInterfaceMap) GetOrSetFuncLock(key string, f func() interface{})
    }
 }

-// 当键名不存在时写入，并返回true；否则返回false。
+// SetIfNotExist sets <value> to the map if the <key> does not exist, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
 func (gm *StringInterfaceMap) SetIfNotExist(key string, value interface{}) bool {
    if !gm.Contains(key) {
        gm.doSetWithLockCheck(key, value)
@ -149,7 +180,30 @@ func (gm *StringInterfaceMap) SetIfNotExist(key string, value interface{}) bool
    return false
 }

-// 批量删除键值对
+// SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+func (gm *StringInterfaceMap) SetIfNotExistFunc(key string, f func() interface{}) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
+}
+
+// SetIfNotExistFuncLock sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function <f> with mutex.Lock of the hash map.
+func (gm *StringInterfaceMap) SetIfNotExistFuncLock(key string, f func() interface{}) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f)
+		return true
+	}
+	return false
+}
+
+// BatchRemove batch deletes values of the map by keys.
 func (gm *StringInterfaceMap) BatchRemove(keys []string) {
    gm.mu.Lock()
    for _, key := range keys {
@ -158,7 +212,7 @@ func (gm *StringInterfaceMap) BatchRemove(keys []string) {
    gm.mu.Unlock()
 }

-// 返回对应的键值，并删除该键值
+// Remove deletes value from map by given <key>, and return this deleted value.
 func (gm *StringInterfaceMap) Remove(key string) interface{} {
 	gm.mu.Lock()
 	val, exists := gm.m[key]
@ -169,7 +223,7 @@ func (gm *StringInterfaceMap) Remove(key string) interface{} {
 	return val
 }

-// 返回键列表
+// Keys returns all keys of the map as a slice.
 func (gm *StringInterfaceMap) Keys() []string {
 	gm.mu.RLock()
 	keys := make([]string, 0)
@ -180,7 +234,7 @@ func (gm *StringInterfaceMap) Keys() []string {
 	return keys
 }

-// 返回值列表(注意是随机排序)
+// Values returns all values of the map as a slice.
 func (gm *StringInterfaceMap) Values() []interface{} {
 	gm.mu.RLock()
 	vals := make([]interface{}, 0)
@ -191,7 +245,8 @@ func (gm *StringInterfaceMap) Values() []interface{} {
 	return vals
 }

-// 是否存在某个键
+// Contains checks whether a key exists.
+// It returns true if the <key> exists, or else false.
 func (gm *StringInterfaceMap) Contains(key string) bool {
 	gm.mu.RLock()
 	_, exists := gm.m[key]
@ -199,7 +254,7 @@ func (gm *StringInterfaceMap) Contains(key string) bool {
 	return exists
 }

-// 哈希表大小
+// Size returns the size of the map.
 func (gm *StringInterfaceMap) Size() int {
 	gm.mu.RLock()
 	length := len(gm.m)
@ -207,7 +262,8 @@ func (gm *StringInterfaceMap) Size() int {
 	return length
 }

-// 哈希表是否为空
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
 func (gm *StringInterfaceMap) IsEmpty() bool {
 	gm.mu.RLock()
 	empty := len(gm.m) == 0
@ -215,28 +271,28 @@ func (gm *StringInterfaceMap) IsEmpty() bool {
 	return empty
 }

-// 清空哈希表
+// Clear deletes all data of the map, it will remake a new underlying map data map.
 func (gm *StringInterfaceMap) Clear() {
    gm.mu.Lock()
    gm.m = make(map[string]interface{})
    gm.mu.Unlock()
 }

-// 并发安全写锁操作，使用自定义方法执行加锁修改操作
+// LockFunc locks writing with given callback function <f> and mutex.Lock.
 func (gm *StringInterfaceMap) LockFunc(f func(m map[string]interface{})) {
-	gm.mu.Lock(true)
-	defer gm.mu.Unlock(true)
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
 	f(gm.m)
 }

-// 并发安全读锁操作，使用自定义方法执行加锁读取操作
+// RLockFunc locks reading with given callback function <f> and mutex.RLock.
 func (gm *StringInterfaceMap) RLockFunc(f func(m map[string]interface{})) {
-	gm.mu.RLock(true)
-	defer gm.mu.RUnlock(true)
+	gm.mu.RLock()
+	defer gm.mu.RUnlock()
 	f(gm.m)
 }

-// 交换Map中的键和值.
+// Flip exchanges key-value of the map, it will change key-value to value-key.
 func (gm *StringInterfaceMap) Flip() {
 	gm.mu.Lock()
 	defer gm.mu.Unlock()
@ -247,15 +303,16 @@ func (gm *StringInterfaceMap) Flip() {
 	gm.m = n
 }

-// 合并两个Map.
-func (gm *StringInterfaceMap) Merge(m *StringInterfaceMap) {
+// Merge merges two hash maps.
+// The <other> map will be merged into the map <gm>.
+func (gm *StringInterfaceMap) Merge(other *StringInterfaceMap) {
 	gm.mu.Lock()
 	defer gm.mu.Unlock()
-	if m != gm {
-		m.mu.RLock()
-		defer m.mu.RUnlock()
+	if other != gm {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
 	}
-	for k, v := range m.m {
+	for k, v := range other.m {
 		gm.m[k] = v
 	}
 }
--- a/g/container/gmap/gmap_string_string_map.go
+++ b/g/container/gmap/gmap_string_string_map.go
@ -16,6 +16,9 @@ type StringStringMap struct {
 	m  map[string]string
 }

+// NewStringStringMap returns an empty StringStringMap object.
+// The param <unsafe> used to specify whether using map with un-concurrent-safety,
+// which is false in default, means concurrent-safe.
 func NewStringStringMap(unsafe...bool) *StringStringMap {
 	return &StringStringMap{
 		m  : make(map[string]string),
@ -23,6 +26,9 @@ func NewStringStringMap(unsafe...bool) *StringStringMap {
 	}
 }

+// NewStringStringMapFrom returns an StringStringMap object from given map <m>.
+// Notice that, the param map is a type of pointer,
+// there might be some concurrent-safe issues when changing the map outside.
 func NewStringStringMapFrom(m map[string]string, unsafe...bool) *StringStringMap {
    return &StringStringMap{
        m  : m,
@ -30,6 +36,12 @@ func NewStringStringMapFrom(m map[string]string, unsafe...bool) *StringStringMap
    }
 }

+// NewStringStringMapFromArray returns an StringStringMap object from given array.
+// The param <keys> given as the keys of the map,
+// and <values> as its corresponding values.
+//
+// If length of <keys> is greater than that of <values>,
+// the corresponding overflow map values will be the default value of its type.
 func NewStringStringMapFromArray(keys []string, values []string, unsafe...bool) *StringStringMap {
    m := make(map[string]string)
    l := len(values)
@ -46,7 +58,8 @@ func NewStringStringMapFromArray(keys []string, values []string, unsafe...bool)
    }
 }

-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
+// Iterator iterates the hash map with custom callback function <f>.
+// If f returns true, then continue iterating; or false to stop.
 func (gm *StringStringMap) Iterator(f func (k string, v string) bool) {
 	gm.mu.RLock()
 	defer gm.mu.RUnlock()
@ -57,12 +70,12 @@ func (gm *StringStringMap) Iterator(f func (k string, v string) bool) {
 	}
 }

-// 哈希表克隆.
+// Clone returns a new hash map with copy of current map data.
 func (gm *StringStringMap) Clone() *StringStringMap {
    return NewStringStringMapFrom(gm.Map(), !gm.mu.IsSafe())
 }

-// 返回当前哈希表的数据Map.
+// Map returns a copy of the data of the hash map.
 func (gm *StringStringMap) Map() map[string]string {
    m := make(map[string]string)
    gm.mu.RLock()
@ -73,14 +86,14 @@ func (gm *StringStringMap) Map() map[string]string {
    return m
 }

-// 设置键值对
+// Set sets key-value to the hash map.
 func (gm *StringStringMap) Set(key string, val string) {
 	gm.mu.Lock()
 	gm.m[key] = val
 	gm.mu.Unlock()
 }

-// 批量设置键值对
+// BatchSet batch sets key-values to the hash map.
 func (gm *StringStringMap) BatchSet(m map[string]string) {
    gm.mu.Lock()
    for k, v := range m {
@ -89,7 +102,7 @@ func (gm *StringStringMap) BatchSet(m map[string]string) {
    gm.mu.Unlock()
 }

-// 获取键值
+// Get returns the value by given <key>.
 func (gm *StringStringMap) Get(key string) string {
 	gm.mu.RLock()
 	val, _ := gm.m[key]
@ -97,8 +110,11 @@ func (gm *StringStringMap) Get(key string) string {
 	return val
 }

-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given <key>,
+// or else just return the existing value.
+//
+// It returns value with given <key>.
 func (gm *StringStringMap) doSetWithLockCheck(key string, value string) string {
 	gm.mu.Lock()
 	if v, ok := gm.m[key]; ok {
@ -110,7 +126,8 @@ func (gm *StringStringMap) doSetWithLockCheck(key string, value string) string {
 	return value
 }

-// 当键名存在时返回其键值，否则写入指定的键值
+// GetOrSet returns the value by key,
+// or set value with given <value> if not exist and returns this value.
 func (gm *StringStringMap) GetOrSet(key string, value string) string {
 	gm.mu.RLock()
 	v, ok := gm.m[key]
@ -122,7 +139,9 @@ func (gm *StringStringMap) GetOrSet(key string, value string) string {
 	}
 }

-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+// GetOrSetFunc returns the value by key,
+// or sets value with return value of callback function <f> if not exist
+// and returns this value.
 func (gm *StringStringMap) GetOrSetFunc(key string, f func() string) string {
 	gm.mu.RLock()
 	v, ok := gm.m[key]
@ -134,7 +153,12 @@ func (gm *StringStringMap) GetOrSetFunc(key string, f func() string) string {
 	}
 }

-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
+// GetOrSetFuncLock returns the value by key,
+// or sets value with return value of callback function <f> if not exist
+// and returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f>
+// with mutex.Lock of the hash map.
 func (gm *StringStringMap) GetOrSetFuncLock(key string, f func() string) string {
 	gm.mu.RLock()
 	val, ok := gm.m[key]
@ -143,10 +167,9 @@ func (gm *StringStringMap) GetOrSetFuncLock(key string, f func() string) string
 		gm.mu.Lock()
 		defer gm.mu.Unlock()
 		if v, ok := gm.m[key]; ok {
-			gm.mu.Unlock()
 			return v
 		}
-		val         = f()
+		val       = f()
 		gm.m[key] = val
 		return val
 	} else {
@ -154,7 +177,8 @@ func (gm *StringStringMap) GetOrSetFuncLock(key string, f func() string) string
 	}
 }

-// 当键名不存在时写入，并返回true；否则返回false。
+// SetIfNotExist sets <value> to the map if the <key> does not exist, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
 func (gm *StringStringMap) SetIfNotExist(key string, value string) bool {
 	if !gm.Contains(key) {
 		gm.doSetWithLockCheck(key, value)
@ -163,7 +187,34 @@ func (gm *StringStringMap) SetIfNotExist(key string, value string) bool {
 	return false
 }

-// 批量删除键值对
+// SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+func (gm *StringStringMap) SetIfNotExistFunc(key string, f func() string) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
+}
+
+// SetIfNotExistFuncLock sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function <f> with mutex.Lock of the hash map.
+func (gm *StringStringMap) SetIfNotExistFuncLock(key string, f func() string) bool {
+	if !gm.Contains(key) {
+		gm.mu.Lock()
+		defer gm.mu.Unlock()
+		if _, ok := gm.m[key]; !ok {
+			gm.m[key] = f()
+		}
+		return true
+	}
+	return false
+}
+
+// BatchRemove batch deletes values of the map by keys.
 func (gm *StringStringMap) BatchRemove(keys []string) {
    gm.mu.Lock()
    for _, key := range keys {
@ -172,7 +223,7 @@ func (gm *StringStringMap) BatchRemove(keys []string) {
    gm.mu.Unlock()
 }

-// 返回对应的键值，并删除该键值
+// Remove deletes value from map by given <key>, and return this deleted value.
 func (gm *StringStringMap) Remove(key string) string {
 	gm.mu.Lock()
 	val, exists := gm.m[key]
@ -183,7 +234,7 @@ func (gm *StringStringMap) Remove(key string) string {
 	return val
 }

-// 返回键列表
+// Keys returns all keys of the map as a slice.
 func (gm *StringStringMap) Keys() []string {
 	gm.mu.RLock()
 	keys := make([]string, 0)
@ -194,7 +245,7 @@ func (gm *StringStringMap) Keys() []string {
 	return keys
 }

-// 返回值列表(注意是随机排序)
+// Values returns all values of the map as a slice.
 func (gm *StringStringMap) Values() []string {
 	gm.mu.RLock()
 	vals := make([]string, 0)
@ -205,7 +256,8 @@ func (gm *StringStringMap) Values() []string {
 	return vals
 }

-// 是否存在某个键
+// Contains checks whether a key exists.
+// It returns true if the <key> exists, or else false.
 func (gm *StringStringMap) Contains(key string) bool {
 	gm.mu.RLock()
 	_, exists := gm.m[key]
@ -213,7 +265,7 @@ func (gm *StringStringMap) Contains(key string) bool {
 	return exists
 }

-// 哈希表大小
+// Size returns the size of the map.
 func (gm *StringStringMap) Size() int {
 	gm.mu.RLock()
 	length := len(gm.m)
@ -221,7 +273,8 @@ func (gm *StringStringMap) Size() int {
 	return length
 }

-// 哈希表是否为空
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
 func (gm *StringStringMap) IsEmpty() bool {
 	gm.mu.RLock()
 	empty := len(gm.m) == 0
@ -229,28 +282,28 @@ func (gm *StringStringMap) IsEmpty() bool {
 	return empty
 }

-// 清空哈希表
+// Clear deletes all data of the map, it will remake a new underlying map data map.
 func (gm *StringStringMap) Clear() {
    gm.mu.Lock()
    gm.m = make(map[string]string)
    gm.mu.Unlock()
 }

-// 并发安全写锁操作，使用自定义方法执行加锁修改操作
+// LockFunc locks writing with given callback function <f> and mutex.Lock.
 func (gm *StringStringMap) LockFunc(f func(m map[string]string)) {
-	gm.mu.Lock(true)
-	defer gm.mu.Unlock(true)
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
 	f(gm.m)
 }

-// 并发安全读锁操作，使用自定义方法执行加锁读取操作
+// RLockFunc locks reading with given callback function <f> and mutex.RLock.
 func (gm *StringStringMap) RLockFunc(f func(m map[string]string)) {
-	gm.mu.RLock(true)
-	defer gm.mu.RUnlock(true)
+	gm.mu.RLock()
+	defer gm.mu.RUnlock()
 	f(gm.m)
 }

-// 交换Map中的键和值.
+// Flip exchanges key-value of the map, it will change key-value to value-key.
 func (gm *StringStringMap) Flip() {
 	gm.mu.Lock()
 	defer gm.mu.Unlock()
@ -261,15 +314,16 @@ func (gm *StringStringMap) Flip() {
 	gm.m = n
 }

-// 合并两个Map.
-func (gm *StringStringMap) Merge(m *StringStringMap) {
+// Merge merges two hash maps.
+// The <other> map will be merged into the map <gm>.
+func (gm *StringStringMap) Merge(other *StringStringMap) {
 	gm.mu.Lock()
 	defer gm.mu.Unlock()
-	if m != gm {
-		m.mu.RLock()
-		defer m.mu.RUnlock()
+	if other != gm {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
 	}
-	for k, v := range m.m {
+	for k, v := range other.m {
 		gm.m[k] = v
 	}
 }
--- a/g/container/gpool/gpool.go
+++ b/g/container/gpool/gpool.go
@ -5,8 +5,6 @@
 // You can obtain one at https://github.com/gogf/gf.

 // Package gpool provides a object-reusable concurrent-safe pool.
-//
-// 对象复用池.
 package gpool

 import (
--- a/g/container/gqueue/gqueue.go
+++ b/g/container/gqueue/gqueue.go
@ -15,9 +15,8 @@
 package gqueue

 import (
-    "container/list"
+    "github.com/gogf/gf/g/container/glist"
    "math"
-    "sync"
 )

 // 1、这是一个先进先出的队列(chan <-- list)；
@ -28,9 +27,8 @@ import (
 //
 // 4、由于功能主体是chan，那么操作仍然像chan那样具有阻塞效果；
 type Queue struct {
-    mu        sync.Mutex       // 底层链表写锁
    limit     int              // 队列限制大小
-    list      *list.List       // 底层数据链表
+    list      *glist.List       // 底层数据链表
    events    chan struct{}    // 写入事件通知
    closed    chan struct{}    // 队列关闭通知
    C         chan interface{} // 队列数据读取
@ -50,7 +48,7 @@ func New(limit...int) *Queue {
        q.limit  = limit[0]
        q.C      = make(chan interface{}, limit[0])
    } else {
-        q.list   = list.New()
+        q.list   = glist.New()
        q.events = make(chan struct{}, math.MaxInt32)
        q.C      = make(chan interface{}, gDEFAULT_QUEUE_SIZE)
        go q.startAsyncLoop()
@ -68,7 +66,6 @@ func (q *Queue) startAsyncLoop() {
                for {
                    if length := q.list.Len(); length > 0 {
                        array := make([]interface{}, length)
-                        q.mu.Lock()
                        for i := 0; i < length; i++ {
                            if e := q.list.Front(); e != nil {
                                array[i] = q.list.Remove(e)
@ -76,7 +73,6 @@ func (q *Queue) startAsyncLoop() {
                                break
                            }
                        }
-                        q.mu.Unlock()
                        for _, v := range array {
                           q.C <- v
                        }
@ -93,9 +89,7 @@ func (q *Queue) Push(v interface{}) {
    if q.limit > 0 {
        q.C <- v
    } else {
-        q.mu.Lock()
        q.list.PushBack(v)
-        q.mu.Unlock()
        q.events <- struct{}{}
    }
 }
--- a/g/container/gring/gring.go
+++ b/g/container/gring/gring.go
@ -4,9 +4,7 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.

-// Package gring provides a concurrent-safe(alternative) ring(circular lists).
-//
-// 并发安全环.
+// Package gring provides a concurrent-safe/unsafe ring(circular lists).
 package gring

 import (
@ -149,8 +147,8 @@ func (r *Ring) Unlink(n int) *Ring {

 // 读锁遍历，往后只读遍历，回调函数返回true表示继续遍历，否则退出遍历
 func (r *Ring) RLockIteratorNext(f func(value interface{}) bool) {
-    r.mu.RLock(true)
-    defer r.mu.RUnlock(true)
+    r.mu.RLock()
+    defer r.mu.RUnlock()
    if !f(r.ring.Value) {
        return
    }
@ -163,8 +161,8 @@ func (r *Ring) RLockIteratorNext(f func(value interface{}) bool) {

 // 读锁遍历，往前只读遍历，回调函数返回true表示继续遍历，否则退出遍历
 func (r *Ring) RLockIteratorPrev(f func(value interface{}) bool) {
-    r.mu.RLock(true)
-    defer r.mu.RUnlock(true)
+    r.mu.RLock()
+    defer r.mu.RUnlock()
    if !f(r.ring.Value) {
        return
    }
@ -177,8 +175,8 @@ func (r *Ring) RLockIteratorPrev(f func(value interface{}) bool) {

 // 写锁遍历，往后写遍历，回调函数返回true表示继续遍历，否则退出遍历
 func (r *Ring) LockIteratorNext(f func(item *ring.Ring) bool) {
-    r.mu.RLock(true)
-    defer r.mu.RUnlock(true)
+    r.mu.RLock()
+    defer r.mu.RUnlock()
    if !f(r.ring) {
        return
    }
@ -191,8 +189,8 @@ func (r *Ring) LockIteratorNext(f func(item *ring.Ring) bool) {

 // 写锁遍历，往前写遍历，回调函数返回true表示继续遍历，否则退出遍历
 func (r *Ring) LockIteratorPrev(f func(item *ring.Ring) bool) {
-    r.mu.RLock(true)
-    defer r.mu.RUnlock(true)
+    r.mu.RLock()
+    defer r.mu.RUnlock()
    if !f(r.ring) {
        return
    }
--- a/g/container/gring/gring_unit_test.go
+++ b/g/container/gring/gring_unit_test.go
@ -0,0 +1,229 @@
+package gring_test
+
+import (
+	"container/ring"
+	"github.com/gogf/gf/g"
+	"github.com/gogf/gf/g/container/gring"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
+)
+type Student struct {
+	position int
+	name    string
+	upgrade bool
+}
+
+func TestRing_Val(t *testing.T) {
+	gtest.Case(t, func() {
+		//定义cap 为3的ring类型数据
+		r := gring.New(3, true)
+		//分别给3个元素初始化赋值
+		r.Put(&Student{1,"jimmy", true})
+		r.Put(&Student{2,"tom", true})
+		r.Put(&Student{3,"alon", false})
+
+		//元素取值并判断和预设值是否相等
+		gtest.Assert(r.Val().(*Student).name,"jimmy")
+		//从当前位置往后移两个元素
+		r.Move(2)
+		gtest.Assert(r.Val().(*Student).name,"alon")
+		//更新元素值
+		//测试 value == nil
+		r.Set(nil)
+		gtest.Assert(r.Val(),nil)
+		//测试value != nil
+		r.Set(&Student{3, "jack", true})
+	})
+}
+func TestRing_CapLen(t *testing.T) {
+	gtest.Case(t, func() {
+		r := gring.New(10)
+		r.Put("goframe")
+		//cap长度 10
+		gtest.Assert(r.Cap(), 10)
+		//已有数据项 1
+		gtest.Assert(r.Len(), 1)
+	})
+}
+
+func TestRing_Position(t *testing.T) {
+	gtest.Case(t, func() {
+		r := gring.New(2)
+		r.Put(1)
+		r.Put(2)
+		//往后移动1个元素
+		r.Next()
+		gtest.Assert(r.Val(),2)
+		//往前移动1个元素
+		r.Prev()
+		gtest.Assert(r.Val(),1)
+
+	})
+}
+
+func TestRing_Link(t *testing.T) {
+	gtest.Case(t, func() {
+		r := gring.New(3)
+		r.Put(1)
+		r.Put(2)
+		r.Put(3)
+		s := gring.New(2)
+		s.Put("a")
+		s.Put("b")
+
+		rs := r.Link(s)
+		gtest.Assert(rs.Move(2).Val(), "b")
+
+	})
+}
+
+func TestRing_Unlink(t *testing.T) {
+	gtest.Case(t, func() {
+		r := gring.New(5)
+		for i := 0; i< 5; i++  {
+			r.Put(i+1)
+		}
+		// 1 2 3 4
+		// 删除当前位置往后的2个数据，返回被删除的数据
+		// 重新计算s len
+		s := r.Unlink(2)		// 2 3
+		gtest.Assert(s.Val(), 2)
+		gtest.Assert(s.Len(), 1)
+	})
+}
+
+func TestRing_Slice(t *testing.T) {
+	gtest.Case(t, func() {
+		ringLen := 5
+		r := gring.New(ringLen)
+		for i := 0; i< ringLen; i++  {
+			r.Put(i+1)
+		}
+		r.Move(2)	// 3
+		array := r.SliceNext()		// [3 4 5 1 2]
+		gtest.Assert(array[0], 3)
+		gtest.Assert(len(array), 5)
+
+		//判断array是否等于[3 4 5 1 2]
+		ra := []int{3,4,5,1,2}
+		gtest.Assert(ra, array)
+
+		//第3个元素设为nil
+		r.Set(nil)
+		array2 := r.SliceNext() 	//[4 5 1 2]
+		//返回当前位置往后不为空的元素数组，长度为4
+		gtest.Assert(array2, g.Slice{4,5,1,2})
+
+		array3 := r.SlicePrev() 	//[2 1 5 4]
+		gtest.Assert(array3, g.Slice{2,1,5,4})
+
+		s := gring.New(ringLen)
+		for i := 0; i< ringLen; i++  {
+			s.Put(i+1)
+		}
+		array4 := s.SlicePrev()	// []
+		gtest.Assert(array4, g.Slice{1,5,4,3,2})
+
+	})
+}
+
+func TestRing_RLockIterator(t *testing.T) {
+	gtest.Case(t, func() {
+		ringLen := 5
+		r := gring.New(ringLen)
+
+		//ring不存在有值元素
+		r.RLockIteratorNext(func(v interface{}) bool {
+			gtest.Assert(v, nil)
+			return false
+		})
+		r.RLockIteratorNext(func(v interface{}) bool {
+			gtest.Assert(v, nil)
+			return true
+		})
+
+		r.RLockIteratorPrev(func(v interface{}) bool {
+			gtest.Assert(v, nil)
+			return true
+		})
+
+		for i := 0; i< ringLen; i++  {
+			r.Put(i+1)
+		}
+
+		//回调函数返回true,RLockIteratorNext遍历5次,期望值分别是1、2、3、4、5
+		i := 0
+		r.RLockIteratorNext(func(v interface{}) bool {
+			gtest.Assert(v, i+1)
+			i++;
+			return true
+		})
+
+		//RLockIteratorPrev遍历1次返回 false,退出遍历
+		r.RLockIteratorPrev(func(v interface{}) bool {
+			gtest.Assert(v, 1)
+			return false
+		})
+
+	})
+}
+
+func TestRing_LockIterator(t *testing.T) {
+	gtest.Case(t, func() {
+		ringLen := 5
+		r := gring.New(ringLen)
+
+		//不存在有值元素
+		r.LockIteratorNext(func(item *ring.Ring) bool {
+			gtest.Assert(item.Value, nil)
+			return false
+		})
+		r.LockIteratorNext(func(item *ring.Ring) bool {
+			gtest.Assert(item.Value, nil)
+			return false
+		})
+		r.LockIteratorNext(func(item *ring.Ring) bool {
+			gtest.Assert(item.Value, nil)
+			return true
+		})
+
+		r.LockIteratorPrev(func(item *ring.Ring) bool {
+			gtest.Assert(item.Value, nil)
+			return false
+		})
+		r.LockIteratorPrev(func(item *ring.Ring) bool {
+			gtest.Assert(item.Value, nil)
+			return true
+		})
+
+		//ring初始化元素值
+		for i := 0; i< ringLen; i++  {
+			r.Put(i+1)
+		}
+
+		//往后遍历组成数据 [1,2,3,4,5]
+		array1 := g.Slice{1,2,3,4,5}
+		ii := 0
+		r.LockIteratorNext(func(item *ring.Ring) bool {
+			//校验每一次遍历取值是否是期望值
+			gtest.Assert(item.Value, array1[ii])
+			ii++;
+			return true
+		})
+
+		//往后取3个元素组成数组
+		//获得 [1,5,4]
+		i := 0
+		a := g.Slice{1,5,4}
+		r.LockIteratorPrev(func(item *ring.Ring) bool {
+			if i > 2 {
+				return false
+			}
+			gtest.Assert(item.Value, a[i])
+			i++;
+			return true
+		})
+
+
+	})
+}
--- a/g/container/gset/gset.go
+++ b/g/container/gset/gset.go
@ -4,9 +4,7 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.

-// Package gset provides kinds of concurrent-safe(alternative) sets.
-//
-// 并发安全集合.
+// Package gset provides kinds of concurrent-safe/unsafe sets.
 package gset

 import (
@ -139,8 +137,8 @@ func (set *Set) String() string {
 //
 // 使用自定义方法执行加锁修改操作。
 func (set *Set) LockFunc(f func(m map[interface{}]struct{})) *Set {
-    set.mu.Lock(true)
-    defer set.mu.Unlock(true)
+    set.mu.Lock()
+    defer set.mu.Unlock()
    f(set.m)
    return set
 }
@ -149,8 +147,8 @@ func (set *Set) LockFunc(f func(m map[interface{}]struct{})) *Set {
 //
 // 使用自定义方法执行加锁读取操作。
 func (set *Set) RLockFunc(f func(m map[interface{}]struct{})) *Set {
-    set.mu.RLock(true)
-    defer set.mu.RUnlock(true)
+    set.mu.RLock()
+    defer set.mu.RUnlock()
    f(set.m)
    return set
 }
--- a/g/container/gset/gset_int_set.go
+++ b/g/container/gset/gset_int_set.go
@ -130,8 +130,8 @@ func (set *IntSet) String() string {
 //
 // 使用自定义方法执行加锁修改操作。
 func (set *IntSet) LockFunc(f func(m map[int]struct{})) *IntSet {
-	set.mu.Lock(true)
-	defer set.mu.Unlock(true)
+	set.mu.Lock()
+	defer set.mu.Unlock()
 	f(set.m)
    return set
 }
@ -140,8 +140,8 @@ func (set *IntSet) LockFunc(f func(m map[int]struct{})) *IntSet {
 //
 // 使用自定义方法执行加锁读取操作。
 func (set *IntSet) RLockFunc(f func(m map[int]struct{})) *IntSet {
-    set.mu.RLock(true)
-    defer set.mu.RUnlock(true)
+    set.mu.RLock()
+    defer set.mu.RUnlock()
    f(set.m)
    return set
 }
--- a/g/container/gset/gset_string_set.go
+++ b/g/container/gset/gset_string_set.go
@ -130,8 +130,8 @@ func (set *StringSet) String() string {
 //
 // 使用自定义方法执行加锁修改操作。
 func (set *StringSet) LockFunc(f func(m map[string]struct{})) *StringSet {
-	set.mu.Lock(true)
-	defer set.mu.Unlock(true)
+	set.mu.Lock()
+	defer set.mu.Unlock()
 	f(set.m)
    return set
 }
@ -140,8 +140,8 @@ func (set *StringSet) LockFunc(f func(m map[string]struct{})) *StringSet {
 //
 // 使用自定义方法执行加锁读取操作。
 func (set *StringSet) RLockFunc(f func(m map[string]struct{})) *StringSet {
-	set.mu.RLock(true)
-	defer set.mu.RUnlock(true)
+	set.mu.RLock()
+	defer set.mu.RUnlock()
 	f(set.m)
    return set
 }
--- a/g/container/gtype/gtype.go
+++ b/g/container/gtype/gtype.go
@ -4,9 +4,7 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.

-// Package gtype provides kinds of high performance, concurrent-safe basic variable types.
-//
-// 并发安全基本类型.
+// Package gtype provides kinds of high performance, concurrent-safe/unsafe basic variable types.
 package gtype

 type Type = Interface
--- a/g/container/gvar/gvar.go
+++ b/g/container/gvar/gvar.go
@ -5,8 +5,6 @@
 // You can obtain one at https://github.com/gogf/gf.

 // Package gvar provides an universal variable type, like generics.
-//
-// 通用动态变量.
 package gvar

 import (
@ -18,7 +16,7 @@ import (

 type Var struct {
    value interface{} // 变量值
-    safe  bool        // 当为true时,value为 *gtype.Interface 类型
+    safe  bool        // 当为true时, value为 *gtype.Interface 类型
 }

 // 创建一个动态变量，value参数可以为nil
--- a/g/crypto/crypto.go
+++ b/g/crypto/crypto.go
@ -1,7 +0,0 @@
-// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-package crypto
--- a/g/database/database.go
+++ b/g/database/database.go
@ -1,7 +0,0 @@
-// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-package database
--- a/g/database/gdb/gdb.go
+++ b/g/database/gdb/gdb.go
@ -14,6 +14,7 @@ import (
    "database/sql"
    "errors"
    "fmt"
+    "github.com/gogf/gf/g/container/gmap"
    "github.com/gogf/gf/g/container/gring"
    "github.com/gogf/gf/g/container/gtype"
    "github.com/gogf/gf/g/container/gvar"
@ -37,17 +38,19 @@ type DB interface {
    doQuery(link dbLink, query string, args ...interface{}) (rows *sql.Rows, err error)
    doExec(link dbLink, query string, args ...interface{}) (result sql.Result, err error)
    doPrepare(link dbLink, query string) (*sql.Stmt, error)
-    doInsert(link dbLink, table string, data Map, option int) (result sql.Result, err error)
-    doBatchInsert(link dbLink, table string, list List, batch int, option int) (result sql.Result, err error)
-    doUpdate(link dbLink, table string, data interface{}, condition interface{}, args ...interface{}) (result sql.Result, err error)
-    doDelete(link dbLink, table string, condition interface{}, args ...interface{}) (result sql.Result, err error)
+    doInsert(link dbLink, table string, data interface{}, option int, batch...int) (result sql.Result, err error)
+    doBatchInsert(link dbLink, table string, list interface{}, option int, batch...int) (result sql.Result, err error)
+    doUpdate(link dbLink, table string, data interface{}, condition string, args ...interface{}) (result sql.Result, err error)
+    doDelete(link dbLink, table string, condition string, args ...interface{}) (result sql.Result, err error)

 	// 数据库查询
 	GetAll(query string, args ...interface{}) (Result, error)
 	GetOne(query string, args ...interface{}) (Record, error)
 	GetValue(query string, args ...interface{}) (Value, error)
    GetCount(query string, args ...interface{}) (int, error)
-    GetStruct(obj interface{}, query string, args ...interface{}) error
+    GetStruct(objPointer interface{}, query string, args ...interface{}) error
+    GetStructs(objPointerSlice interface{}, query string, args ...interface{}) error
+    GetScan(objPointer interface{}, query string, args ...interface{}) error

    // 创建底层数据库master/slave链接对象
    Master() (*sql.DB, error)
@ -61,14 +64,14 @@ type DB interface {
 	Begin() (*TX, error)

 	// 数据表插入/更新/保存操作
-	Insert(table string, data Map) (sql.Result, error)
-	Replace(table string, data Map) (sql.Result, error)
-	Save(table string, data Map) (sql.Result, error)
+	Insert(table string, data interface{}, batch...int) (sql.Result, error)
+	Replace(table string, data interface{}, batch...int) (sql.Result, error)
+	Save(table string, data interface{}, batch...int) (sql.Result, error)

 	// 数据表插入/更新/保存操作(批量)
-	BatchInsert(table string, list List, batch int) (sql.Result, error)
-	BatchReplace(table string, list List, batch int) (sql.Result, error)
-	BatchSave(table string, list List, batch int) (sql.Result, error)
+	BatchInsert(table string, list interface{}, batch...int) (sql.Result, error)
+	BatchReplace(table string, list interface{}, batch...int) (sql.Result, error)
+	BatchSave(table string, list interface{}, batch...int) (sql.Result, error)

 	// 数据修改/删除
 	Update(table string, data interface{}, condition interface{}, args ...interface{}) (sql.Result, error)
@ -145,27 +148,34 @@ type Map  = map[string]interface{}
 type List = []Map

 const (
-    OPTION_INSERT  = 0
-    OPTION_REPLACE = 1
-    OPTION_SAVE    = 2
-    OPTION_IGNORE  = 3
-    // 默认的连接池连接存活时间(秒)
-    gDEFAULT_CONN_MAX_LIFE_TIME = 30
+    OPTION_INSERT               = 0
+    OPTION_REPLACE              = 1
+    OPTION_SAVE                 = 2
+    OPTION_IGNORE               = 3
+    gDEFAULT_BATCH_NUM          = 10 // Per count for batch insert/replace/save
+    gDEFAULT_CONN_MAX_LIFE_TIME = 30 // Max life time for per connection in pool.
 )

-// 使用默认/指定分组配置进行连接，数据库集群配置项：default
-func New(groupName ...string) (db DB, err error) {
-	group := config.d
-	if len(groupName) > 0 {
-        group = groupName[0]
-	}
-	config.RLock()
-	defer config.RUnlock()
+var (
+    // Instance map.
+    instances = gmap.NewStringInterfaceMap()
+)

-	if len(config.c) < 1 {
+// New creates ORM DB object with global configurations.
+// The param <name> specifies the configuration group name,
+// which is DEFAULT_GROUP_NAME in default.
+func New(name ...string) (db DB, err error) {
+	group := configs.defaultGroup
+	if len(name) > 0 {
+        group = name[0]
+	}
+	configs.RLock()
+	defer configs.RUnlock()
+
+	if len(configs.config) < 1 {
 		return nil, errors.New("empty database configuration")
 	}
-	if _, ok := config.c[group]; ok {
+	if _, ok := configs.config[group]; ok {
 	    if node, err := getConfigNodeByGroup(group, true); err == nil {
 	        base := &dbBase {
                group            : group,
@ -199,9 +209,27 @@ func New(groupName ...string) (db DB, err error) {
 	}
 }

+// Instance returns an instance for DB operations.
+// The param <name> specifies the configuration group name,
+// which is DEFAULT_GROUP_NAME in default.
+func Instance(name ...string) (db DB, err error) {
+    group := configs.defaultGroup
+    if len(name) > 0 {
+        group = name[0]
+    }
+    v := instances.GetOrSetFuncLock(group, func() interface{} {
+        db, err = New(group)
+        return db
+    })
+    if v != nil {
+        return v.(DB), nil
+    }
+    return
+}
+
 // 获取指定数据库角色的一个配置项，内部根据权重计算负载均衡
 func getConfigNodeByGroup(group string, master bool) (*ConfigNode, error) {
-    if list, ok := config.c[group]; ok {
+    if list, ok := configs.config[group]; ok {
        // 将master, slave集群列表拆分出来
        masterList := make(ConfigGroup, 0)
        slaveList  := make(ConfigGroup, 0)
@ -314,17 +342,17 @@ func (bs *dbBase) getSqlDb(master bool) (sqlDb *sql.DB, err error) {
    return
 }

-// 切换操作的数据库(注意该切换是全局的)
+// 切换当前数据库对象操作的数据库。
 func (bs *dbBase) SetSchema(schema string) {
    bs.schema.Set(schema)
 }

-// 创建底层数据库master链接对象
+// 创建底层数据库master链接对象。
 func (bs *dbBase) Master() (*sql.DB, error) {
 	return bs.getSqlDb(true)
 }

-// 创建底层数据库slave链接对象
+// 创建底层数据库slave链接对象。
 func (bs *dbBase) Slave() (*sql.DB, error) {
    return bs.getSqlDb(false)
 }
--- a/g/database/gdb/gdb_base.go
+++ b/g/database/gdb/gdb_base.go
@ -14,8 +14,8 @@ import (
    "github.com/gogf/gf/g/container/gvar"
    "github.com/gogf/gf/g/os/gcache"
    "github.com/gogf/gf/g/os/gtime"
-    "github.com/gogf/gf/g/util/gconv"
    "github.com/gogf/gf/g/text/gregex"
+    "github.com/gogf/gf/g/util/gconv"
    "reflect"
    "strings"
 )
@ -165,13 +165,44 @@ func (bs *dbBase) GetOne(query string, args ...interface{}) (Record, error) {
    return nil, nil
 }

-// 数据库查询，获取查询结果记录，自动映射数据到给定的struct对象中
-func (bs *dbBase) GetStruct(obj interface{}, query string, args ...interface{}) error {
+// 数据库查询，查询单条记录，自动映射数据到给定的struct对象中
+func (bs *dbBase) GetStruct(objPointer interface{}, query string, args ...interface{}) error {
    one, err := bs.GetOne(query, args...)
    if err != nil {
        return err
    }
-    return one.ToStruct(obj)
+    return one.ToStruct(objPointer)
+}
+
+// 数据库查询，查询多条记录，并自动转换为指定的slice对象, 如: []struct/[]*struct。
+func (bs *dbBase) GetStructs(objPointerSlice interface{}, query string, args ...interface{}) error {
+    all, err := bs.GetAll(query, args...)
+    if err != nil {
+        return err
+    }
+    return all.ToStructs(objPointerSlice)
+}
+
+// 将结果转换为指定的struct/*struct/[]struct/[]*struct,
+// 参数应该为指针类型，否则返回失败。
+// 该方法自动识别参数类型，调用Struct/Structs方法。
+func (bs *dbBase) GetScan(objPointer interface{}, query string, args ...interface{}) error {
+    t := reflect.TypeOf(objPointer)
+    k := t.Kind()
+    if k != reflect.Ptr {
+        return fmt.Errorf("params should be type of pointer, but got: %v", k)
+    }
+    k = t.Elem().Kind()
+    switch k {
+        case reflect.Array:
+        case reflect.Slice:
+            return bs.db.GetStructs(objPointer, query, args ...)
+        case reflect.Struct:
+            return bs.db.GetStruct(objPointer, query, args ...)
+        default:
+            return fmt.Errorf("element type should be type of struct/slice, unsupported: %v", k)
+    }
+    return nil
 }

 // 数据库查询，获取查询字段值
@ -234,45 +265,72 @@ func (bs *dbBase) Begin() (*TX, error) {
    }
 }

-// CURD操作:单条数据写入, 仅仅执行写入操作，如果存在冲突的主键或者唯一索引，那么报错返回
-func (bs *dbBase) Insert(table string, data Map) (sql.Result, error) {
-    return bs.db.doInsert(nil, table, data, OPTION_INSERT)
+// CURD操作:单条数据写入, 仅仅执行写入操作，如果存在冲突的主键或者唯一索引，那么报错返回。
+// 参数data支持map/struct/*struct/slice类型，
+// 当为slice(例如[]map/[]struct/[]*struct)类型时，batch参数生效，并自动切换为批量操作。
+func (bs *dbBase) Insert(table string, data interface{}, batch...int) (sql.Result, error) {
+    return bs.db.doInsert(nil, table, data, OPTION_INSERT, batch...)
 }

-// CURD操作:单条数据写入, 如果数据存在(主键或者唯一索引)，那么删除后重新写入一条
-func (bs *dbBase) Replace(table string, data Map) (sql.Result, error) {
-    return bs.db.doInsert(nil, table, data, OPTION_REPLACE)
+// CURD操作:单条数据写入, 如果数据存在(主键或者唯一索引)，那么删除后重新写入一条。
+// 参数data支持map/struct/*struct/slice类型，
+// 当为slice(例如[]map/[]struct/[]*struct)类型时，batch参数生效，并自动切换为批量操作。
+func (bs *dbBase) Replace(table string, data interface{}, batch...int) (sql.Result, error) {
+    return bs.db.doInsert(nil, table, data, OPTION_REPLACE, batch...)
 }

-// CURD操作:单条数据写入, 如果数据存在(主键或者唯一索引)，那么更新，否则写入一条新数据
-func (bs *dbBase) Save(table string, data Map) (sql.Result, error) {
-    return bs.db.doInsert(nil, table, data, OPTION_SAVE)
+// CURD操作:单条数据写入, 如果数据存在(主键或者唯一索引)，那么更新，否则写入一条新数据。
+// 参数data支持map/struct/*struct/slice类型，
+// 当为slice(例如[]map/[]struct/[]*struct)类型时，batch参数生效，并自动切换为批量操作。
+func (bs *dbBase) Save(table string, data interface{}, batch...int) (sql.Result, error) {
+    return bs.db.doInsert(nil, table, data, OPTION_SAVE, batch...)
 }

-// insert、replace, save， ignore操作
-// 0: insert:  仅仅执行写入操作，如果存在冲突的主键或者唯一索引，那么报错返回
-// 1: replace: 如果数据存在(主键或者唯一索引)，那么删除后重新写入一条
-// 2: save:    如果数据存在(主键或者唯一索引)，那么更新，否则写入一条新数据
-// 3: ignore:  如果数据存在(主键或者唯一索引)，那么什么也不做
-func (bs *dbBase) doInsert(link dbLink, table string, data Map, option int) (result sql.Result, err error) {
-    var fields []string
-    var values []string
-    var params []interface{}
-    charl, charr := bs.db.getChars()
-    for k, v := range data {
-        fields = append(fields,   charl + k + charr)
+// 支持insert、replace, save， ignore操作。
+// 0: insert:  仅仅执行写入操作，如果存在冲突的主键或者唯一索引，那么报错返回;
+// 1: replace: 如果数据存在(主键或者唯一索引)，那么删除后重新写入一条;
+// 2: save:    如果数据存在(主键或者唯一索引)，那么更新，否则写入一条新数据;
+// 3: ignore:  如果数据存在(主键或者唯一索引)，那么什么也不做;
+//
+// 参数data支持map/struct/*struct/slice类型，
+// 当为slice(例如[]map/[]struct/[]*struct)类型时，batch参数生效，并自动切换为批量操作。
+func (bs *dbBase) doInsert(link dbLink, table string, data interface{}, option int, batch...int) (result sql.Result, err error) {
+    var fields  []string
+    var values  []string
+    var params  []interface{}
+    var dataMap Map
+    // 使用反射判断data数据类型，如果为slice类型，那么自动转为批量操作
+    rv   := reflect.ValueOf(data)
+    kind := rv.Kind()
+    if kind == reflect.Ptr {
+        rv   = rv.Elem()
+        kind = rv.Kind()
+    }
+    switch kind {
+        case reflect.Slice: fallthrough
+        case reflect.Array:
+            return bs.db.doBatchInsert(link, table, data, option, batch...)
+        case reflect.Map:   fallthrough
+        case reflect.Struct:
+            dataMap = gconv.Map(data)
+        default:
+            return result, errors.New(fmt.Sprint("unsupported data type:", kind))
+    }
+    charL, charR := bs.db.getChars()
+    for k, v := range dataMap {
+        fields = append(fields, charL + k + charR)
        values = append(values, "?")
-        params = append(params, v)
+        params = append(params, convertParam(v))
    }
    operation := getInsertOperationByOption(option)
    updateStr := ""
    if option == OPTION_SAVE {
        var updates []string
-        for k, _ := range data {
+        for k, _ := range dataMap {
            updates = append(updates,
                fmt.Sprintf("%s%s%s=VALUES(%s%s%s)",
-                    charl, k, charr,
-                    charl, k, charr,
+                    charL, k, charR,
+                    charL, k, charR,
                ),
            )
        }
@ -290,28 +348,59 @@ func (bs *dbBase) doInsert(link dbLink, table string, data Map, option int) (res
 }

 // CURD操作:批量数据指定批次量写入
-func (bs *dbBase) BatchInsert(table string, list List, batch int) (sql.Result, error) {
-    return bs.db.doBatchInsert(nil, table, list, batch, OPTION_INSERT)
+func (bs *dbBase) BatchInsert(table string, list interface{}, batch...int) (sql.Result, error) {
+    return bs.db.doBatchInsert(nil, table, list, OPTION_INSERT, batch...)
 }

 // CURD操作:批量数据指定批次量写入, 如果数据存在(主键或者唯一索引)，那么删除后重新写入一条
-func (bs *dbBase) BatchReplace(table string, list List, batch int) (sql.Result, error) {
-    return bs.db.doBatchInsert(nil, table, list, batch, OPTION_REPLACE)
+func (bs *dbBase) BatchReplace(table string, list interface{}, batch...int) (sql.Result, error) {
+    return bs.db.doBatchInsert(nil, table, list, OPTION_REPLACE, batch...)
 }

 // CURD操作:批量数据指定批次量写入, 如果数据存在(主键或者唯一索引)，那么更新，否则写入一条新数据
-func (bs *dbBase) BatchSave(table string, list List, batch int) (sql.Result, error) {
-    return bs.db.doBatchInsert(nil, table, list, batch, OPTION_SAVE)
+func (bs *dbBase) BatchSave(table string, list interface{}, batch...int) (sql.Result, error) {
+    return bs.db.doBatchInsert(nil, table, list, OPTION_SAVE, batch...)
 }

-// 批量写入数据
-func (bs *dbBase) doBatchInsert(link dbLink, table string, list List, batch int, option int) (result sql.Result, err error) {
-    var keys    []string
-    var values  []string
-    var bvalues []string
-    var params  []interface{}
+// 批量写入数据, 参数list支持slice类型，例如: []map/[]struct/[]*struct。
+func (bs *dbBase) doBatchInsert(link dbLink, table string, list interface{}, option int, batch...int) (result sql.Result, err error) {
+    var keys   []string
+    var values []string
+    var params []interface{}
+    listMap := (List)(nil)
+    switch v := list.(type) {
+        case Result:
+            listMap = v.ToList()
+        case Record:
+            listMap = List{v.ToMap()}
+        case List:
+            listMap = v
+        case Map:
+            listMap = List{v}
+        default:
+            rv   := reflect.ValueOf(list)
+            kind := rv.Kind()
+            if kind == reflect.Ptr {
+                rv   = rv.Elem()
+                kind = rv.Kind()
+            }
+            switch kind {
+                // 如果是slice，那么转换为List类型
+                case reflect.Slice: fallthrough
+                case reflect.Array:
+                    listMap = make(List, rv.Len())
+                    for i := 0; i < rv.Len(); i++ {
+                        listMap[i] = gconv.Map(rv.Index(i).Interface())
+                    }
+                case reflect.Map:   fallthrough
+                case reflect.Struct:
+                    listMap = List{Map(gconv.Map(list))}
+                default:
+                    return result, errors.New(fmt.Sprint("unsupported list type:", kind))
+            }
+    }
    // 判断长度
-    if len(list) < 1 {
+    if len(listMap) < 1 {
        return result, errors.New("empty data list")
    }
    if link == nil {
@ -320,14 +409,15 @@ func (bs *dbBase) doBatchInsert(link dbLink, table string, list List, batch int,
        }
    }
    // 首先获取字段名称及记录长度
-    for k, _ := range list[0] {
-        keys   = append(keys,   k)
-        values = append(values, "?")
+    holders := []string(nil)
+    for k, _ := range listMap[0] {
+        keys    = append(keys,   k)
+        holders = append(holders, "?")
    }
    batchResult    := new(batchSqlResult)
-    charl, charr   := bs.db.getChars()
-    keyStr         := charl + strings.Join(keys, charl + "," + charr) + charr
-    valueHolderStr := "(" + strings.Join(values, ",") + ")"
+    charL, charR   := bs.db.getChars()
+    keyStr         := charL + strings.Join(keys, charL + "," + charR) + charR
+    valueHolderStr := "(" + strings.Join(holders, ",") + ")"
    // 操作判断
    operation := getInsertOperationByOption(option)
    updateStr := ""
@ -336,22 +426,26 @@ func (bs *dbBase) doBatchInsert(link dbLink, table string, list List, batch int,
        for _, k := range keys {
            updates = append(updates,
                fmt.Sprintf("%s%s%s=VALUES(%s%s%s)",
-                    charl, k, charr,
-                    charl, k, charr,
+                    charL, k, charR,
+                    charL, k, charR,
                ),
            )
        }
        updateStr = fmt.Sprintf(" ON DUPLICATE KEY UPDATE %s", strings.Join(updates, ","))
    }
    // 构造批量写入数据格式(注意map的遍历是无序的)
-    for i := 0; i < len(list); i++ {
+    batchNum := gDEFAULT_BATCH_NUM
+    if len(batch) > 0 {
+        batchNum = batch[0]
+    }
+    for i := 0; i < len(listMap); i++ {
        for _, k := range keys {
-            params = append(params, list[i][k])
+            params = append(params, convertParam(listMap[i][k]))
        }
-        bvalues = append(bvalues, valueHolderStr)
-        if len(bvalues) == batch {
+        values = append(values, valueHolderStr)
+        if len(values) == batchNum {
            r, err := bs.db.doExec(link, fmt.Sprintf("%s INTO %s(%s) VALUES%s %s",
-                operation, table, keyStr, strings.Join(bvalues, ","),
+                operation, table, keyStr, strings.Join(values, ","),
                updateStr),
                params...)
            if err != nil {
@ -363,14 +457,14 @@ func (bs *dbBase) doBatchInsert(link dbLink, table string, list List, batch int,
                batchResult.lastResult    = r
                batchResult.rowsAffected += n
            }
-            params  = params[:0]
-            bvalues = bvalues[:0]
+            params = params[:0]
+            values = values[:0]
        }
    }
    // 处理最后不构成指定批量的数据
-    if len(bvalues) > 0 {
+    if len(values) > 0 {
        r, err := bs.db.doExec(link, fmt.Sprintf("%s INTO %s(%s) VALUES%s %s",
-            operation, table, keyStr, strings.Join(bvalues, ","),
+            operation, table, keyStr, strings.Join(values, ","),
            updateStr),
            params...)
        if err != nil {
@ -386,59 +480,70 @@ func (bs *dbBase) doBatchInsert(link dbLink, table string, list List, batch int,
    return batchResult, nil
 }

-// CURD操作:数据更新，统一采用sql预处理
-// data参数支持字符串或者关联数组类型，内部会自行做判断处理
+// CURD操作:数据更新，统一采用sql预处理。
+// data参数支持string/map/struct/*struct类型。
 func (bs *dbBase) Update(table string, data interface{}, condition interface{}, args ...interface{}) (sql.Result, error) {
-    link, err := bs.db.Master()
-    if err != nil {
-        return nil, err
-    }
-    return bs.db.doUpdate(link, table, data, condition, args ...)
+    newWhere, newArgs := formatCondition(condition, args)
+    return bs.db.doUpdate(nil, table, data, newWhere, newArgs ...)
 }

-// CURD操作:数据更新，统一采用sql预处理
-// data参数支持字符串或者关联数组类型，内部会自行做判断处理
-func (bs *dbBase) doUpdate(link dbLink, table string, data interface{}, condition interface{}, args ...interface{}) (result sql.Result, err error) {
-    params       := ([]interface{})(nil)
+// CURD操作:数据更新，统一采用sql预处理。
+// data参数支持string/map/struct/*struct类型类型。
+func (bs *dbBase) doUpdate(link dbLink, table string, data interface{}, condition string, args ...interface{}) (result sql.Result, err error) {
    updates      := ""
-    charl, charr := bs.db.getChars()
-    refValue     := reflect.ValueOf(data)
-    if refValue.Kind() == reflect.Map {
-        var fields []string
-        keys := refValue.MapKeys()
-        for _, k := range keys {
-            fields = append(fields, fmt.Sprintf("%s%s%s=?", charl, k, charr))
-            params = append(params, gconv.String(refValue.MapIndex(k).Interface()))
-        }
-        updates = strings.Join(fields, ",")
-    } else {
-        updates = gconv.String(data)
+    charL, charR := bs.db.getChars()
+    // 使用反射进行类型判断
+    rv   := reflect.ValueOf(data)
+    kind := rv.Kind()
+    if kind == reflect.Ptr {
+        rv   = rv.Elem()
+        kind = rv.Kind()
    }
-    for _, v := range args {
-        params = append(params, gconv.String(v))
+    params := []interface{}(nil)
+    switch kind {
+        case reflect.Map:   fallthrough
+        case reflect.Struct:
+            var fields []string
+            for k, v := range gconv.Map(data) {
+                fields = append(fields, fmt.Sprintf("%s%s%s=?", charL, k, charR))
+                params = append(params, convertParam(v))
+            }
+            updates = strings.Join(fields, ",")
+        default:
+            updates = gconv.String(data)
    }
+    if len(params) > 0 {
+        args = append(params, args...)
+    }
+    // 如果没有传递link，那么使用默认的写库对象
    if link == nil {
        if link, err = bs.db.Master(); err != nil {
            return nil, err
        }
    }
-    newWhere, newArgs := formatCondition(condition, params)
-    return bs.db.doExec(link, fmt.Sprintf("UPDATE %s SET %s WHERE %s", table, updates, newWhere), newArgs...)
+    if len(condition) == 0 {
+        return bs.db.doExec(link, fmt.Sprintf("UPDATE %s SET %s", table, updates), args...)
+    }
+    return bs.db.doExec(link, fmt.Sprintf("UPDATE %s SET %s WHERE %s", table, updates, condition), args...)
 }

 // CURD操作:删除数据
 func (bs *dbBase) Delete(table string, condition interface{}, args ...interface{}) (result sql.Result, err error) {
-    link, err := bs.db.Master()
-    if err != nil {
-        return nil, err
-    }
-    return bs.db.doDelete(link, table, condition, args ...)
+    newWhere, newArgs := formatCondition(condition, args)
+    return bs.db.doDelete(nil, table, newWhere, newArgs ...)
 }

 // CURD操作:删除数据
-func (bs *dbBase) doDelete(link dbLink, table string, condition interface{}, args ...interface{}) (result sql.Result, err error) {
-    newWhere, newArgs := formatCondition(condition, args)
-    return bs.db.doExec(link, fmt.Sprintf("DELETE FROM %s WHERE %s", table, newWhere), newArgs...)
+func (bs *dbBase) doDelete(link dbLink, table string, condition string, args ...interface{}) (result sql.Result, err error) {
+    if link == nil {
+        if link, err = bs.db.Master(); err != nil {
+            return nil, err
+        }
+    }
+    if len(condition) == 0 {
+        return bs.db.doExec(link, fmt.Sprintf("DELETE FROM %s", table), args...)
+    }
+    return bs.db.doExec(link, fmt.Sprintf("DELETE FROM %s WHERE %s", table, condition), args...)
 }

 // 获得缓存对象
--- a/g/database/gdb/gdb_config.go
+++ b/g/database/gdb/gdb_config.go
@ -17,14 +17,7 @@ const (
    DEFAULT_GROUP_NAME = "default" // 默认配置名称
 )

-// 数据库配置包内对象
-var config struct {
-    sync.RWMutex
-    c  Config // 数据库配置
-    d  string // 默认数据库分组名称
-}
-
-// 数据库配置
+// 数据库分组配置
 type Config      map[string]ConfigGroup

 // 数据库集群配置
@ -41,12 +34,19 @@ type ConfigNode  struct {
    Role             string   // (可选，默认为master)数据库的角色，用于主从操作分离，至少需要有一个master，参数值：master, slave
    Charset          string   // (可选，默认为 utf8)编码，默认为 utf8
    Priority         int      // (可选)用于负载均衡的权重计算，当集群中只有一个节点时，权重没有任何意义
-    Linkinfo         string   // (可选)自定义链接信息，当该字段被设置值时，以上链接字段(Host,Port,User,Pass,Name)将失效(该字段是一个扩展功能)
+    LinkInfo         string   // (可选)自定义链接信息，当该字段被设置值时，以上链接字段(Host,Port,User,Pass,Name)将失效(该字段是一个扩展功能)
    MaxIdleConnCount int      // (可选)连接池最大限制的连接数
    MaxOpenConnCount int      // (可选)连接池最大打开的连接数
    MaxConnLifetime  int      // (可选，单位秒)连接对象可重复使用的时间长度
 }

+// 数据库配置包内对象
+var configs struct {
+    sync.RWMutex        // 并发安全互斥锁
+    config       Config // 数据库分组配置
+    defaultGroup string // 默认数据库分组名称
+}
+
 // 数据库集群配置示例，支持主从处理，多数据库集群支持
 /*
 var DatabaseConfiguration = Config {
@ -80,29 +80,32 @@ var DatabaseConfiguration = Config {

 // 包初始化
 func init() {
-    config.c = make(Config)
-    config.d = DEFAULT_GROUP_NAME
+    configs.config       = make(Config)
+    configs.defaultGroup = DEFAULT_GROUP_NAME
 }

 // 设置当前应用的数据库配置信息，进行全局数据库配置覆盖操作
-func SetConfig (c Config) {
-    config.Lock()
-    defer config.Unlock()
-    config.c = c
+func SetConfig (config Config) {
+    defer instances.Clear()
+    configs.Lock()
+    defer configs.Unlock()
+    configs.config = config
 }

 // 添加数据库服务器集群配置
 func AddConfigGroup (group string, nodes ConfigGroup) {
-    config.Lock()
-    config.c[group] = nodes
-    config.Unlock()
+    defer instances.Clear()
+    configs.Lock()
+    defer configs.Unlock()
+    configs.config[group] = nodes
 }

 // 添加一台数据库服务器配置
 func AddConfigNode (group string, node ConfigNode) {
-    config.Lock()
-    config.c[group] = append(config.c[group], node)
-    config.Unlock()
+    defer instances.Clear()
+    configs.Lock()
+    defer configs.Unlock()
+    configs.config[group] = append(configs.config[group], node)
 }

 // 添加默认链接的一台数据库服务器配置
@ -117,16 +120,25 @@ func AddDefaultConfigGroup (nodes ConfigGroup) {

 // 添加一台数据库服务器配置
 func GetConfig (group string) ConfigGroup {
-    config.RLock()
-    defer config.RUnlock()
-    return config.c[group]
+    configs.RLock()
+    defer configs.RUnlock()
+    return configs.config[group]
 }

 // 设置默认链接的数据库链接配置项(默认是 default)
-func SetDefaultGroup (groupName string) {
-    config.Lock()
-    config.d = groupName
-    config.Unlock()
+func SetDefaultGroup (name string) {
+    defer instances.Clear()
+    configs.Lock()
+    defer configs.Unlock()
+    configs.defaultGroup = name
+}
+
+// 获取默认链接的数据库链接配置项(默认是 default)
+func GetDefaultGroup() string {
+    defer instances.Clear()
+    configs.Lock()
+    defer configs.Unlock()
+    return configs.defaultGroup
 }

 // 设置数据库连接池中空闲链接的大小
@ -147,8 +159,8 @@ func (bs *dbBase) SetConnMaxLifetime(n int) {

 // 节点配置转换为字符串
 func (node *ConfigNode) String() string {
-    if node.Linkinfo != "" {
-        return node.Linkinfo
+    if node.LinkInfo != "" {
+        return node.LinkInfo
    }
    return fmt.Sprintf(`%s@%s:%s,%s,%s,%s,%s,%d-%d-%d`, node.User, node.Host, node.Port,
        node.Name, node.Type, node.Role, node.Charset,
--- a/g/database/gdb/gdb_func.go
+++ b/g/database/gdb/gdb_func.go
@ -12,44 +12,81 @@ import (
    "fmt"
    "github.com/gogf/gf/g/os/glog"
    "github.com/gogf/gf/g/os/gtime"
-    "github.com/gogf/gf/g/util/gconv"
    "github.com/gogf/gf/g/text/gregex"
    "github.com/gogf/gf/g/text/gstr"
+    "github.com/gogf/gf/g/util/gconv"
    _ "github.com/gogf/gf/third/github.com/go-sql-driver/mysql"
    "reflect"
    "strings"
 )

 // 格式化SQL查询条件
-func formatCondition(where interface{}, args []interface{}) (string, []interface{}) {
+func formatCondition(where interface{}, args []interface{}) (newWhere string, newArgs []interface{}) {
    // 条件字符串处理
    buffer := bytes.NewBuffer(nil)
-    if reflect.ValueOf(where).Kind() == reflect.Map {
-        ks := reflect.ValueOf(where).MapKeys()
-        vs := reflect.ValueOf(where)
-        for _, k := range ks {
-            key   := gconv.String(k.Interface())
-            value := gconv.String(vs.MapIndex(k).Interface())
-            if buffer.Len() > 0 {
-                buffer.WriteString(" AND ")
-            }
-            if gstr.IsNumeric(value) || value == "?" {
-                buffer.WriteString(key + "=" + value)
-            } else {
-                buffer.WriteString(key + "='" + value + "'")
-            }
-        }
-    } else {
-        buffer.Write(gconv.Bytes(where))
+    // 使用反射进行类型判断
+    rv   := reflect.ValueOf(where)
+    kind := rv.Kind()
+    if kind == reflect.Ptr {
+        rv   = rv.Elem()
+        kind = rv.Kind()
    }
+    tmpArgs := []interface{}(nil)
+    switch kind {
+        // map/struct类型
+        case reflect.Map:   fallthrough
+        case reflect.Struct:
+            for key, value := range gconv.Map(where) {
+                if buffer.Len() > 0 {
+                    buffer.WriteString(" AND ")
+                }
+                // 支持slice键值/属性，如果只有一个?占位符号，那么作为IN查询，否则打散作为多个查询参数
+                rv := reflect.ValueOf(value)
+                switch rv.Kind() {
+                    case reflect.Slice: fallthrough
+                    case reflect.Array:
+                        count := gstr.Count(key, "?")
+                        if count == 0 {
+                            buffer.WriteString(key + " IN(?)")
+                            tmpArgs = append(tmpArgs, value)
+                        } else if count != rv.Len() {
+                            buffer.WriteString(key)
+                            tmpArgs = append(tmpArgs, value)
+                        } else {
+                            buffer.WriteString(key)
+                            // 如果键名/属性名称中带有多个?占位符号，那么将参数打散
+                            tmpArgs = append(tmpArgs, gconv.Interfaces(value)...)
+                        }
+                    default:
+                        if value == nil {
+                            buffer.WriteString(key)
+                        } else {
+                            if gstr.Pos(key, "?") == -1 {
+                                if gstr.Pos(key, "<") == -1 && gstr.Pos(key, ">") == -1 && gstr.Pos(key, "=") == -1 {
+                                    buffer.WriteString(key + "=?")
+                                } else {
+                                    buffer.WriteString(key + "?")
+                                }
+                            } else {
+                                buffer.WriteString(key)
+                            }
+                            tmpArgs = append(tmpArgs, value)
+                        }
+                }
+            }
+
+        default:
+            buffer.WriteString(gconv.String(where))
+    }
+    // 没有任何条件查询参数，直接返回
    if buffer.Len() == 0 {
-        buffer.WriteString("1=1")
+        return "", args
    }
-    // 查询条件处理
-    newWhere := buffer.String()
-    newArgs  := make([]interface{}, 0)
-    if len(args) > 0 {
-        for index, arg := range args {
+    newWhere = buffer.String()
+    tmpArgs  = append(tmpArgs, args...)
+    // 查询条件参数处理，主要处理slice参数类型
+    if len(tmpArgs) > 0 {
+        for index, arg := range tmpArgs {
            rv   := reflect.ValueOf(arg)
            kind := rv.Kind()
            if kind == reflect.Ptr {
@ -57,11 +94,14 @@ func formatCondition(where interface{}, args []interface{}) (string, []interface
                kind = rv.Kind()
            }
            switch kind {
+                // '?'占位符支持slice类型,
+                // 这里会将slice参数拆散，并更新原有占位符'?'为多个'?'，使用','符号连接。
                case reflect.Slice: fallthrough
                case reflect.Array:
                    for i := 0; i < rv.Len(); i++ {
                        newArgs = append(newArgs, rv.Index(i).Interface())
                    }
+                    // counter用于匹配该参数的位置(与index对应)
                    counter    := 0
                    newWhere, _ = gregex.ReplaceStringFunc(`\?`, newWhere, func(s string) string {
                        counter++
@ -71,11 +111,35 @@ func formatCondition(where interface{}, args []interface{}) (string, []interface
                        return s
                    })
                default:
+                    // 支持例如 Where/And/Or("uid", 1) 这种格式
+                    if gstr.Pos(newWhere, "?") == -1 {
+                        if gstr.Pos(newWhere, "<") == -1 && gstr.Pos(newWhere, ">") == -1 && gstr.Pos(newWhere, "=") == -1 {
+                            newWhere += "=?"
+                        } else {
+                            newWhere += "?"
+                        }
+                    }
                    newArgs = append(newArgs, arg)
            }
        }
    }
-    return newWhere, newArgs
+    return
+}
+
+// 将预处理参数转换为底层数据库引擎支持的格式。
+// 主要是判断参数是否为复杂数据类型，如果是，那么转换为基础类型。
+func convertParam(value interface{}) interface{} {
+    rv   := reflect.ValueOf(value)
+    kind := rv.Kind()
+    if kind == reflect.Ptr {
+        rv   = rv.Elem()
+        kind = rv.Kind()
+    }
+    switch kind {
+        case reflect.Struct:
+            return gconv.String(value)
+    }
+    return value
 }

 // 打印SQL对象(仅在debug=true时有效)
@ -109,13 +173,13 @@ func formatError(err error, query string, args ...interface{}) error {

 // 根据insert选项获得操作名称
 func getInsertOperationByOption(option int) string {
-    oper := "INSERT"
+    operator := "INSERT"
    switch option {
        case OPTION_REPLACE:
-            oper = "REPLACE"
+            operator = "REPLACE"
        case OPTION_SAVE:
        case OPTION_IGNORE:
-            oper = "INSERT IGNORE"
+            operator = "INSERT IGNORE"
    }
-    return oper
+    return operator
 }
--- a/g/database/gdb/gdb_model.go
+++ b/g/database/gdb/gdb_model.go
@ -3,17 +3,18 @@
 // This Source Code Form is subject to the terms of the MIT License.
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
+//
+// @author john, ymrjqyy

 package gdb

 import (
-	"fmt"
-	"errors"
-	"database/sql"
-	"github.com/gogf/gf/g/util/gconv"
-	_ "github.com/gogf/gf/third/github.com/go-sql-driver/mysql"
+    "database/sql"
+    "errors"
+    "fmt"
+    "github.com/gogf/gf/g/util/gconv"
+    _ "github.com/gogf/gf/third/github.com/go-sql-driver/mysql"
    "reflect"
-    "strings"
 )

 // 数据库链式操作模型对象
@ -35,6 +36,7 @@ type Model struct {
 	cacheEnabled bool          // 当前SQL操作是否开启查询缓存功能
 	cacheTime    int           // 查询缓存时间
 	cacheName    string        // 查询缓存名称
+    safe         bool          // 当前模型是否运行安全模式（可修改当前模型，否则每一次链式操作都是返回新的模型对象）
 }

 // 链式操作，数据表字段，可支持多个表，以半角逗号连接
@ -44,6 +46,7 @@ func (bs *dbBase) Table(tables string) (*Model) {
        tablesInit : tables,
 		tables     : tables,
 		fields     : "*",
+        safe       : false,
 	}
 }

@ -59,6 +62,7 @@ func (tx *TX) Table(tables string) (*Model) {
 		tx         : tx,
        tablesInit : tables,
 		tables     : tables,
+        safe       : false,
 	}
 }

@ -79,98 +83,130 @@ func (md *Model) Clone() *Model {
    return newModel
 }

+// 标识当前对象运行安全模式(可被修改)。
+// 1. 默认情况下，模型对象的对象属性无法被修改，
+// 每一次链式操作都是克隆一个新的模型对象，这样所有的操作都不会污染模型对象。
+// 但是链式操作如果需要分开执行，那么需要将新的克隆对象赋值给旧的模型对象继续操作。
+// 2. 当标识模型对象为可修改，那么在当前模型对象的所有链式操作均会影响下一次的链式操作，
+// 即使是链式操作分开执行。
+// 3. 大部分ORM框架默认模型对象是可修改的，但是GF框架的ORM提供给开发者更灵活，更安全的链式操作选项。
+func (md *Model) Safe(safe...bool) *Model {
+    if len(safe) > 0 {
+        md.safe = safe[0]
+    } else {
+        md.safe = true
+    }
+    return md
+}
+
+// 返回操作的模型对象，可能是当前对象，也可能是新的克隆对象，根据alterable决定。
+func (md *Model) getModel() *Model {
+    if !md.safe {
+        return md
+    } else {
+        return md.Clone()
+    }
+}
+
 // 链式操作，左联表
 func (md *Model) LeftJoin(joinTable string, on string) (*Model) {
-    model        := md.Clone()
+    model        := md.getModel()
    model.tables += fmt.Sprintf(" LEFT JOIN %s ON (%s)", joinTable, on)
 	return model
 }

 // 链式操作，右联表
 func (md *Model) RightJoin(joinTable string, on string) (*Model) {
-    model        := md.Clone()
+    model        := md.getModel()
    model.tables += fmt.Sprintf(" RIGHT JOIN %s ON (%s)", joinTable, on)
 	return model
 }

 // 链式操作，内联表
 func (md *Model) InnerJoin(joinTable string, on string) (*Model) {
-    model        := md.Clone()
+    model        := md.getModel()
    model.tables += fmt.Sprintf(" INNER JOIN %s ON (%s)", joinTable, on)
 	return model
 }

 // 链式操作，查询字段
 func (md *Model) Fields(fields string) (*Model) {
-    model       := md.Clone()
+    model       := md.getModel()
    model.fields = fields
 	return model
 }

 // 链式操作，过滤字段
 func (md *Model) Filter() (*Model) {
-    model       := md.Clone()
+    model       := md.getModel()
    model.filter = true
    return model
 }

-// 链式操作，condition，支持string & gdb.Map
+// 链式操作，condition，支持string & gdb.Map.
+// 注意，多个Where调用时，会自动转换为And条件调用。
 func (md *Model) Where(where interface{}, args ...interface{}) (*Model) {
-    model             := md.Clone()
+    model := md.getModel()
+    if model.where != "" {
+        return md.And(where, args...)
+    }
    newWhere, newArgs := formatCondition(where, args)
    model.where        = newWhere
-    model.whereArgs    = append(model.whereArgs, newArgs...)
-	// 支持 Where("uid", 1)这种格式
-	if len(args) == 1 && strings.Index(model.where , "?") < 0 {
-        model.where += "=?"
-    }
+    model.whereArgs    = newArgs
 	return model
 }

 // 链式操作，添加AND条件到Where中
 func (md *Model) And(where interface{}, args ...interface{}) (*Model) {
-    model             := md.Clone()
+    model             := md.getModel()
    newWhere, newArgs := formatCondition(where, args)
-    model.where       += " AND " + newWhere
-    model.whereArgs    = append(model.whereArgs, newArgs...)
+    if len(model.where) > 0 && model.where[0] == '(' {
+        model.where = fmt.Sprintf(`%s AND (%s)`, model.where, newWhere)
+    } else {
+        model.where = fmt.Sprintf(`(%s) AND (%s)`, model.where, newWhere)
+    }
+    model.whereArgs = append(model.whereArgs, newArgs...)
 	return model
 }

 // 链式操作，添加OR条件到Where中
 func (md *Model) Or(where interface{}, args ...interface{}) (*Model) {
-    model             := md.Clone()
+    model             := md.getModel()
    newWhere, newArgs := formatCondition(where, args)
-    model.where       += " OR " + newWhere
-    model.whereArgs    = append(model.whereArgs, newArgs...)
+    if len(model.where) > 0 && model.where[0] == '(' {
+        model.where = fmt.Sprintf(`%s OR (%s)`, model.where, newWhere)
+    } else {
+        model.where = fmt.Sprintf(`(%s) OR (%s)`, model.where, newWhere)
+    }
+    model.whereArgs = append(model.whereArgs, newArgs...)
 	return model
 }

 // 链式操作，group by
 func (md *Model) GroupBy(groupBy string) (*Model) {
-    model        := md.Clone()
+    model        := md.getModel()
    model.groupBy = groupBy
 	return model
 }

 // 链式操作，order by
 func (md *Model) OrderBy(orderBy string) (*Model) {
-    model        := md.Clone()
+    model        := md.getModel()
    model.orderBy = orderBy
 	return model
 }

 // 链式操作，limit
 func (md *Model) Limit(start int, limit int) (*Model) {
-    model      := md.Clone()
+    model      := md.getModel()
    model.start = start
    model.limit = limit
 	return model
 }

-// 链式操作，翻页
-// @author ymrjqyy
+// 链式操作，翻页，注意分页页码从1开始，而Limit方法从0开始。
 func (md *Model) ForPage(page, limit int) (*Model) {
-    model      := md.Clone()
+    model      := md.getModel()
    model.start = (page - 1) * limit
    model.limit = limit
 	return model
@ -178,7 +214,7 @@ func (md *Model) ForPage(page, limit int) (*Model) {

 // 设置批处理的大小
 func (md *Model) Batch(batch int) *Model {
-    model      := md.Clone()
+    model      := md.getModel()
    model.batch = batch
    return model
 }
@ -188,7 +224,7 @@ func (md *Model) Batch(batch int) *Model {
 // name表示自定义的缓存名称，便于业务层精准定位缓存项(如果业务层需要手动清理时，必须指定缓存名称)，
 // 例如：查询缓存时设置名称，清理缓存时可以给定清理的缓存名称进行精准清理。
 func (md *Model) Cache(time int, name ... string) *Model {
-    model          := md.Clone()
+    model          := md.getModel()
    model.cacheTime = time
    if len(name) > 0 {
        model.cacheName = name[0]
@ -200,29 +236,35 @@ func (md *Model) Cache(time int, name ... string) *Model {
    return model
 }

-// 链式操作，操作数据记录项，可以是string/Map, 也可以是：key,value,key,value,...
-func (md *Model) Data(data ...interface{}) (*Model) {
-    model := md.Clone()
+// 链式操作，操作数据项，参数data类型支持 string/map/slice/struct/*struct ,
+// 也可以是：key,value,key,value,...。
+func (md *Model) Data(data ...interface{}) *Model {
+    model := md.getModel()
 	if len(data) > 1 {
 		m := make(map[string]interface{})
 		for i := 0; i < len(data); i += 2 {
-			m[gconv.String(data[i])] = data[i+1]
+			m[gconv.String(data[i])] = data[i + 1]
 		}
        model.data = m
 	} else {
-		switch data[0].(type) {
+		switch params := data[0].(type) {
+			case Result:
+				model.data = params.ToList()
+			case Record:
+				model.data = params.ToMap()
 			case List:
-                model.data = data[0]
+                model.data = params
 			case Map:
-                model.data = data[0]
+                model.data = params
 			default:
-                rv   := reflect.ValueOf(data[0])
+                rv   := reflect.ValueOf(params)
                kind := rv.Kind()
                if kind == reflect.Ptr {
                    rv   = rv.Elem()
                    kind = rv.Kind()
                }
                switch kind {
+                	// 如果是slice，那么转换为List类型
                    case reflect.Slice: fallthrough
                    case reflect.Array:
                        list := make(List, rv.Len())
@ -230,8 +272,9 @@ func (md *Model) Data(data ...interface{}) (*Model) {
                            list[i] = gconv.Map(rv.Index(i).Interface())
                        }
                        model.data = list
-                    case reflect.Map:
-                        model.data = gconv.Map(data[0])
+                    case reflect.Map:   fallthrough
+                    case reflect.Struct:
+                        model.data = Map(gconv.Map(data[0]))
                    default:
                        model.data = data[0]
                }
@ -240,7 +283,9 @@ func (md *Model) Data(data ...interface{}) (*Model) {
 	return model
 }

-// 链式操作， CURD - Insert/BatchInsert
+// 链式操作， CURD - Insert/BatchInsert。
+// 根据Data方法传递的参数类型决定该操作是单条操作还是批量操作，
+// 如果Data方法传递的是slice类型，那么为批量操作。
 func (md *Model) Insert() (result sql.Result, err error) {
 	defer func() {
 		if err == nil {
@ -279,7 +324,9 @@ func (md *Model) Insert() (result sql.Result, err error) {
 	return nil, errors.New("inserting into table with invalid data type")
 }

-// 链式操作， CURD - Replace/BatchReplace
+// 链式操作， CURD - Replace/BatchReplace。
+// 根据Data方法传递的参数类型决定该操作是单条操作还是批量操作，
+// 如果Data方法传递的是slice类型，那么为批量操作。
 func (md *Model) Replace() (result sql.Result, err error) {
 	defer func() {
 		if err == nil {
@ -318,7 +365,9 @@ func (md *Model) Replace() (result sql.Result, err error) {
 	return nil, errors.New("replacing into table with invalid data type")
 }

-// 链式操作， CURD - Save/BatchSave
+// 链式操作， CURD - Save/BatchSave。
+// 根据Data方法传递的参数类型决定该操作是单条操作还是批量操作，
+// 如果Data方法传递的是slice类型，那么为批量操作。
 func (md *Model) Save() (result sql.Result, err error) {
 	defer func() {
 		if err == nil {
@ -330,7 +379,7 @@ func (md *Model) Save() (result sql.Result, err error) {
 	}
 	// 批量操作
 	if list, ok := md.data.(List); ok {
-		batch := 10
+		batch := gDEFAULT_BATCH_NUM
 		if md.batch > 0 {
 			batch = md.batch
 		}
@ -375,9 +424,9 @@ func (md *Model) Update() (result sql.Result, err error) {
        }
    }
 	if md.tx == nil {
-		return md.db.Update(md.tables, md.data, md.where, md.whereArgs ...)
+		return md.db.doUpdate(nil, md.tables, md.data, md.where, md.whereArgs ...)
 	} else {
-		return md.tx.Update(md.tables, md.data, md.where, md.whereArgs ...)
+		return md.tx.doUpdate(md.tables, md.data, md.where, md.whereArgs ...)
 	}
 }

@ -389,9 +438,9 @@ func (md *Model) Delete() (result sql.Result, err error) {
 		}
 	}()
 	if md.tx == nil {
-		return md.db.Delete(md.tables, md.where, md.whereArgs...)
+		return md.db.doDelete(nil, md.tables, md.where, md.whereArgs...)
 	} else {
-		return md.tx.Delete(md.tables, md.where, md.whereArgs...)
+		return md.tx.doDelete(md.tables, md.where, md.whereArgs...)
 	}
 }

@ -429,13 +478,44 @@ func (md *Model) Value() (Value, error) {
 	return nil, nil
 }

-// 链式操作，查询单条记录，并自动转换为struct对象
-func (md *Model) Struct(obj interface{}) error {
+// 链式操作，查询单条记录，并自动转换为struct对象, 参数必须为对象的指针，不能为空指针。
+func (md *Model) Struct(objPointer interface{}) error {
 	one, err := md.One()
 	if err != nil {
 		return err
 	}
-	return one.ToStruct(obj)
+	return one.ToStruct(objPointer)
+}
+
+// 链式操作，查询多条记录，并自动转换为指定的slice对象, 如: []struct/[]*struct。
+func (md *Model) Structs(objPointerSlice interface{}) error {
+	r, err := md.All()
+	if err != nil {
+		return err
+	}
+	return r.ToStructs(objPointerSlice)
+}
+
+// 链式操作，将结果转换为指定的struct/*struct/[]struct/[]*struct,
+// 参数应该为指针类型，否则返回失败。
+// 该方法自动识别参数类型，调用Struct/Structs方法。
+func (md *Model) Scan(objPointer interface{}) error {
+    t := reflect.TypeOf(objPointer)
+    k := t.Kind()
+    if k != reflect.Ptr {
+        return fmt.Errorf("params should be type of pointer, but got: %v", k)
+    }
+    k = t.Elem().Kind()
+    switch k {
+        case reflect.Array:
+        case reflect.Slice:
+            return md.Structs(objPointer)
+        case reflect.Struct:
+            return md.Struct(objPointer)
+        default:
+            return fmt.Errorf("element type should be type of struct/slice, unsupported: %v", k)
+    }
+    return nil
 }

 // 链式操作，查询数量，fields可以为空，也可以自定义查询字段，
@ -523,14 +603,13 @@ func (md *Model) getFormattedSql() string {
 	return s
 }

-// 组块结果集
-// @author ymrjqyy
-// @author 2018-08-15
+// 组块结果集。
 func (md *Model) Chunk(limit int, callback func(result Result, err error) bool) {
-	page := 1
+	page  := 1
+	model := md
 	for {
-		md.ForPage(page, limit)
-		data, err := md.getAll(md.getFormattedSql(), md.whereArgs...)
+        model      = model.ForPage(page, limit)
+		data, err := model.All()
 		if err != nil {
 			callback(nil, err)
 			break
--- a/g/database/gdb/gdb_mssql.go
+++ b/g/database/gdb/gdb_mssql.go
@ -11,6 +11,7 @@
    2.不支持save/replace方法
    3.不支持LastInsertId方法
 */
+
 package gdb

 import (
@ -29,8 +30,8 @@ type dbMssql struct {
 // 创建SQL操作对象
 func (db *dbMssql) Open(config *ConfigNode) (*sql.DB, error) {
 	source := ""
-	if config.Linkinfo != "" {
-		source = config.Linkinfo
+	if config.LinkInfo != "" {
+		source = config.LinkInfo
 	} else {
 		source = fmt.Sprintf("user id=%s;password=%s;server=%s;port=%s;database=%s;encrypt=disable",
 			config.User, config.Pass, config.Host, config.Port, config.Name)
--- a/g/database/gdb/gdb_mysql.go
+++ b/g/database/gdb/gdb_mysql.go
@ -20,8 +20,8 @@ type dbMysql struct {
 // 创建SQL操作对象，内部采用了lazy link处理
 func (db *dbMysql) Open (config *ConfigNode) (*sql.DB, error) {
    var source string
-    if config.Linkinfo != "" {
-        source = config.Linkinfo
+    if config.LinkInfo != "" {
+        source = config.LinkInfo
    } else {
        source = fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=%s&multiStatements=true",
            config.User, config.Pass, config.Host, config.Port, config.Name, config.Charset)
--- a/g/database/gdb/gdb_oracle.go
+++ b/g/database/gdb/gdb_oracle.go
@ -11,6 +11,7 @@
    2.不支持save/replace方法，可以调用这2个方法估计会报错，还没测试过,(应该是可以通过oracle的merge来实现这2个功能的，还没仔细研究)
    3.不支持LastInsertId方法
 */
+
 package gdb

 import (
@ -29,8 +30,8 @@ type dbOracle struct {
 // 创建SQL操作对象
 func (db *dbOracle) Open(config *ConfigNode) (*sql.DB, error) {
 	var source string
-	if config.Linkinfo != "" {
-		source = config.Linkinfo
+	if config.LinkInfo != "" {
+		source = config.LinkInfo
 	} else {
 		source = fmt.Sprintf("%s/%s@%s", config.User, config.Pass, config.Name)
 	}
--- a/g/database/gdb/gdb_pgsql.go
+++ b/g/database/gdb/gdb_pgsql.go
@ -26,8 +26,8 @@ type dbPgsql struct {
 // 创建SQL操作对象，内部采用了lazy link处理
 func (db *dbPgsql) Open (config *ConfigNode) (*sql.DB, error) {
    var source string
-    if config.Linkinfo != "" {
-        source = config.Linkinfo
+    if config.LinkInfo != "" {
+        source = config.LinkInfo
    } else {
        source = fmt.Sprintf("user=%s password=%s host=%s port=%s dbname=%s", config.User, config.Pass, config.Host, config.Port, config.Name)
    }
--- a/g/database/gdb/gdb_sqlite.go
+++ b/g/database/gdb/gdb_sqlite.go
@ -24,8 +24,8 @@ type dbSqlite struct {

 func (db *dbSqlite) Open(config *ConfigNode) (*sql.DB, error) {
 	var source string
-	if config.Linkinfo != "" {
-		source = config.Linkinfo
+	if config.LinkInfo != "" {
+		source = config.LinkInfo
 	} else {
 		source = config.Name
 	}
--- a/g/database/gdb/gdb_structure.go
+++ b/g/database/gdb/gdb_structure.go
@ -4,7 +4,6 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.

-
 package gdb

 import (
@ -85,8 +84,8 @@ func (bs *dbBase) getTableFields(table string) (fields map[string]string, err er
    // 缓存不存在时会查询数据表结构，缓存后不过期，直至程序重启(重新部署)
    v := bs.cache.GetOrSetFunc("table_fields_" + table, func() interface{} {
        result       := (Result)(nil)
-        charl, charr := bs.db.getChars()
-        result, err   = bs.GetAll(fmt.Sprintf(`SHOW COLUMNS FROM %s%s%s`, charl, table, charr))
+        charL, charR := bs.db.getChars()
+        result, err   = bs.GetAll(fmt.Sprintf(`SHOW COLUMNS FROM %s%s%s`, charL, table, charR))
        if err != nil {
            return nil
        }
--- a/g/database/gdb/gdb_transaction.go
+++ b/g/database/gdb/gdb_transaction.go
@ -8,8 +8,10 @@ package gdb

 import (
    "database/sql"
+    "fmt"
    "github.com/gogf/gf/g/text/gregex"
    _ "github.com/gogf/gf/third/github.com/go-sql-driver/mysql"
+    "reflect"
 )

 // 数据库事务对象
@ -75,6 +77,37 @@ func (tx *TX) GetStruct(obj interface{}, query string, args ...interface{}) erro
    return one.ToStruct(obj)
 }

+// 数据库查询，查询多条记录，并自动转换为指定的slice对象, 如: []struct/[]*struct。
+func (tx *TX) GetStructs(objPointerSlice interface{}, query string, args ...interface{}) error {
+    all, err := tx.GetAll(query, args...)
+    if err != nil {
+        return err
+    }
+    return all.ToStructs(objPointerSlice)
+}
+
+// 将结果转换为指定的struct/*struct/[]struct/[]*struct,
+// 参数应该为指针类型，否则返回失败。
+// 该方法自动识别参数类型，调用Struct/Structs方法。
+func (tx *TX) GetScan(objPointer interface{}, query string, args ...interface{}) error {
+    t := reflect.TypeOf(objPointer)
+    k := t.Kind()
+    if k != reflect.Ptr {
+        return fmt.Errorf("params should be type of pointer, but got: %v", k)
+    }
+    k = t.Elem().Kind()
+    switch k {
+        case reflect.Array:
+        case reflect.Slice:
+            return tx.db.GetStructs(objPointer, query, args ...)
+        case reflect.Struct:
+            return tx.db.GetStruct(objPointer, query, args ...)
+        default:
+            return fmt.Errorf("element type should be type of struct/slice, unsupported: %v", k)
+    }
+    return nil
+}
+
 // 数据库查询，获取查询字段值
 func (tx *TX) GetValue(query string, args ...interface{}) (Value, error) {
    one, err := tx.GetOne(query, args ...)
@ -100,43 +133,57 @@ func (tx *TX) GetCount(query string, args ...interface{}) (int, error) {
 }

 // CURD操作:单条数据写入, 仅仅执行写入操作，如果存在冲突的主键或者唯一索引，那么报错返回
-func (tx *TX) Insert(table string, data Map) (sql.Result, error) {
-    return tx.db.doInsert(tx.tx, table, data, OPTION_INSERT)
+func (tx *TX) Insert(table string, data interface{}, batch...int) (sql.Result, error) {
+    return tx.db.doInsert(tx.tx, table, data, OPTION_INSERT, batch...)
 }

 // CURD操作:单条数据写入, 如果数据存在(主键或者唯一索引)，那么删除后重新写入一条
-func (tx *TX) Replace(table string, data Map) (sql.Result, error) {
-    return tx.db.doInsert(tx.tx, table, data, OPTION_REPLACE)
+func (tx *TX) Replace(table string, data interface{}, batch...int) (sql.Result, error) {
+    return tx.db.doInsert(tx.tx, table, data, OPTION_REPLACE, batch...)
 }

 // CURD操作:单条数据写入, 如果数据存在(主键或者唯一索引)，那么更新，否则写入一条新数据
-func (tx *TX) Save(table string, data Map) (sql.Result, error) {
-    return tx.db.doInsert(tx.tx, table, data, OPTION_SAVE)
+func (tx *TX) Save(table string, data interface{}, batch...int) (sql.Result, error) {
+    return tx.db.doInsert(tx.tx, table, data, OPTION_SAVE, batch...)
 }

 // CURD操作:批量数据指定批次量写入
-func (tx *TX) BatchInsert(table string, list List, batch int) (sql.Result, error) {
-    return tx.db.doBatchInsert(tx.tx, table, list, batch, OPTION_INSERT)
+func (tx *TX) BatchInsert(table string, list interface{}, batch...int) (sql.Result, error) {
+    return tx.db.doBatchInsert(tx.tx, table, list, OPTION_INSERT, batch...)
 }

 // CURD操作:批量数据指定批次量写入, 如果数据存在(主键或者唯一索引)，那么删除后重新写入一条
-func (tx *TX) BatchReplace(table string, list List, batch int) (sql.Result, error) {
-    return tx.db.doBatchInsert(tx.tx, table, list, batch, OPTION_REPLACE)
+func (tx *TX) BatchReplace(table string, list interface{}, batch...int) (sql.Result, error) {
+    return tx.db.doBatchInsert(tx.tx, table, list, OPTION_REPLACE, batch...)
 }

 // CURD操作:批量数据指定批次量写入, 如果数据存在(主键或者唯一索引)，那么更新，否则写入一条新数据
-func (tx *TX) BatchSave(table string, list List, batch int) (sql.Result, error) {
-    return tx.db.doBatchInsert(tx.tx, table, list, batch, OPTION_SAVE)
+func (tx *TX) BatchSave(table string, list interface{}, batch...int) (sql.Result, error) {
+    return tx.db.doBatchInsert(tx.tx, table, list, OPTION_SAVE, batch...)
 }

-// CURD操作:数据更新，统一采用sql预处理
-// data参数支持字符串或者关联数组类型，内部会自行做判断处理
+// CURD操作:数据更新，统一采用sql预处理,
+// data参数支持字符串或者关联数组类型，内部会自行做判断处理.
 func (tx *TX) Update(table string, data interface{}, condition interface{}, args ...interface{}) (sql.Result, error) {
+    newWhere, newArgs := formatCondition(condition, args)
+    return tx.doUpdate(table, data, newWhere, newArgs ...)
+}
+
+// 与Update方法的区别是不处理条件参数
+func (tx *TX) doUpdate(table string, data interface{}, condition string, args ...interface{}) (sql.Result, error) {
    return tx.db.doUpdate(tx.tx, table, data, condition, args ...)
 }

 // CURD操作:删除数据
 func (tx *TX) Delete(table string, condition interface{}, args ...interface{}) (sql.Result, error) {
+    newWhere, newArgs := formatCondition(condition, args)
+    return tx.doDelete(table, newWhere, newArgs ...)
+}
+
+// 与Delete方法的区别是不处理条件参数
+func (tx *TX) doDelete(table string, condition string, args ...interface{}) (sql.Result, error) {
    return tx.db.doDelete(tx.tx, table, condition, args ...)
 }

+
+
--- a/g/database/gdb/gdb_type_record.go
+++ b/g/database/gdb/gdb_type_record.go
@ -33,10 +33,6 @@ func (r Record) ToMap() Map {
 }

 // 将Map变量映射到指定的struct对象中，注意参数应当是一个对象的指针
-func (r Record) ToStruct(obj interface{}) error {
-    m := make(map[string]interface{})
-    for k, v := range r {
-        m[k] = v.Val()
-    }
-    return gconv.Struct(m, obj)
+func (r Record) ToStruct(objPointer interface{}) error {
+    return gconv.Struct(r.ToMap(), objPointer)
 }
--- a/g/database/gdb/gdb_type_result.go
+++ b/g/database/gdb/gdb_type_result.go
@ -7,7 +7,9 @@
 package gdb

 import (
+    "fmt"
    "github.com/gogf/gf/g/encoding/gparser"
+    "reflect"
 )

 // 将结果集转换为JSON字符串
@ -96,3 +98,30 @@ func (r Result) ToUintRecord(key string) map[uint]Record {
    }
    return m
 }
+
+// 将结果列表转换为指定对象的slice。
+func (r Result) ToStructs(objPointerSlice interface{}) error {
+    l := len(r)
+    if l == 0 {
+        return nil
+    }
+    t := reflect.TypeOf(objPointerSlice)
+    if t.Kind() != reflect.Ptr {
+        return fmt.Errorf("params should be type of pointer, but got: %v", t.Kind())
+    }
+    a := reflect.MakeSlice(t.Elem(), l, l)
+    itemType := a.Index(0).Type()
+    for i := 0; i < l; i++ {
+        if itemType.Kind() == reflect.Ptr {
+            e := reflect.New(itemType.Elem()).Elem()
+            r[i].ToStruct(e)
+            a.Index(i).Set(e.Addr())
+        } else {
+            e := reflect.New(itemType).Elem()
+            r[i].ToStruct(e)
+            a.Index(i).Set(e)
+        }
+    }
+    reflect.ValueOf(objPointerSlice).Elem().Set(a)
+    return nil
+}
--- a/g/database/gdb/gdb_unit_0_test.go
+++ b/g/database/gdb/gdb_unit_0_test.go
@ -1,52 +0,0 @@
-package gdb_test
-
-import (
-    "github.com/gogf/gf/g/database/gdb"
-    "github.com/gogf/gf/g/test/gtest"
-)
-
-var (
-	// 数据库对象/接口
-	db gdb.DB
-)
-
-// 初始化连接参数。
-// 测试前需要修改连接参数。
-func init() {
-	gdb.AddDefaultConfigNode(gdb.ConfigNode{
-		Host:     "127.0.0.1",
-		Port:     "3306",
-		User:     "root",
-		Pass:     "",
-		Name:     "",
-		Type:     "mysql",
-		Role:     "master",
-		Charset:  "utf8",
-        Priority: 1,
-	})
-	if r, err := gdb.New(); err != nil {
-        gtest.Fatal(err)
-	} else {
-		db = r
-	}
-	// 准备测试数据结构
-    if _, err := db.Exec("CREATE DATABASE IF NOT EXISTS `test` CHARACTER SET UTF8"); err != nil {
-        gtest.Fatal(err)
-    }
-    db.SetSchema("test")
-    if _, err := db.Exec("DROP TABLE IF EXISTS `user`"); err != nil {
-        gtest.Fatal(err)
-    }
-    if _, err := db.Exec(`
-    CREATE TABLE user (
-        id int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '用户ID',
-        passport varchar(45) NOT NULL COMMENT '账号',
-        password char(32) NOT NULL COMMENT '密码',
-        nickname varchar(45) NOT NULL COMMENT '昵称',
-        create_time timestamp NOT NULL COMMENT '创建时间/注册时间',
-        PRIMARY KEY (id)
-    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-    `); err != nil {
-        gtest.Fatal(err)
-    }
-}
--- a/g/database/gdb/gdb_unit_1_test.go
+++ b/g/database/gdb/gdb_unit_1_test.go
@ -1,177 +0,0 @@
-// 方法操作
-
-package gdb_test
-
-import (
-    "github.com/gogf/gf/g"
-    "github.com/gogf/gf/g/os/gtime"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
-)
-
-func TestDbBase_Query(t *testing.T) {
-    if _, err := db.Query("SELECT ?", 1); err != nil {
-        gtest.Fatal(err)
-    }
-    if _, err := db.Query("ERROR"); err == nil {
-        gtest.Fatal("FAIL")
-    }
-}
-
-func TestDbBase_Exec(t *testing.T) {
-	if _, err := db.Exec("SELECT ?", 1); err != nil {
-		gtest.Fatal(err)
-	}
-	if _, err := db.Exec("ERROR"); err == nil {
-		gtest.Fatal("FAIL")
-	}
-}
-
-func TestDbBase_Prepare(t *testing.T) {
-    st, err := db.Prepare("SELECT 100")
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    rows, err := st.Query()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    array, err := rows.Columns()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(array[0], "100")
-    if err := rows.Close(); err != nil {
-        gtest.Fatal(err)
-    }
-}
-
-func TestDbBase_Insert(t *testing.T) {
-    if _, err := db.Insert("user", g.Map{
-        "id"          : 1,
-        "passport"    : "t1",
-        "password"    : "25d55ad283aa400af464c76d713c07ad",
-        "nickname"    : "T1",
-        "create_time" : gtime.Now().String(),
-    }); err != nil {
-        gtest.Fatal(err)
-    }
-}
-
-func TestDbBase_BatchInsert(t *testing.T) {
-    if r, err := db.BatchInsert("user", g.List {
-        {
-            "id"          : 2,
-            "passport"    : "t2",
-            "password"    : "25d55ad283aa400af464c76d713c07ad",
-            "nickname"    : "T2",
-            "create_time" : gtime.Now().String(),
-        },
-        {
-            "id"          : 3,
-            "passport"    : "t3",
-            "password"    : "25d55ad283aa400af464c76d713c07ad",
-            "nickname"    : "T3",
-            "create_time" : gtime.Now().String(),
-        },
-    }, 1); err != nil {
-        gtest.Fatal(err)
-    } else {
-        n, _ := r.RowsAffected()
-        gtest.Assert(n, 2)
-    }
-}
-
-func TestDbBase_Save(t *testing.T) {
-    if _, err := db.Save("user", g.Map{
-        "id"          : 1,
-        "passport"    : "t1",
-        "password"    : "25d55ad283aa400af464c76d713c07ad",
-        "nickname"    : "T11",
-        "create_time" : gtime.Now().String(),
-    }); err != nil {
-        gtest.Fatal(err)
-    }
-}
-
-func TestDbBase_Replace(t *testing.T) {
-    if _, err := db.Save("user", g.Map{
-        "id"          : 1,
-        "passport"    : "t1",
-        "password"    : "25d55ad283aa400af464c76d713c07ad",
-        "nickname"    : "T111",
-        "create_time" : gtime.Now().String(),
-    }); err != nil {
-        gtest.Fatal(err)
-    }
-}
-
-func TestDbBase_Update(t *testing.T) {
-    if result, err := db.Update("user", "create_time='2010-10-10 00:00:01'", "id=3"); err != nil {
-        gtest.Fatal(err)
-    } else {
-        n, _ := result.RowsAffected()
-        gtest.Assert(n, 1)
-    }
-}
-
-func TestDbBase_GetAll(t *testing.T) {
-    if result, err := db.GetAll("SELECT * FROM user WHERE id=?", 1); err != nil {
-        gtest.Fatal(err)
-    } else {
-        gtest.Assert(len(result), 1)
-    }
-}
-
-func TestDbBase_GetOne(t *testing.T) {
-    if record, err := db.GetOne("SELECT * FROM user WHERE passport=?", "t1"); err != nil {
-        gtest.Fatal(err)
-    } else {
-        if record == nil {
-            gtest.Fatal("FAIL")
-        }
-        gtest.Assert(record["nickname"].String(), "T111")
-    }
-}
-
-func TestDbBase_GetValue(t *testing.T) {
-    if value, err := db.GetValue("SELECT id FROM user WHERE passport=?", "t3"); err != nil {
-        gtest.Fatal(err)
-    } else {
-        gtest.Assert(value.Int(), 3)
-    }
-}
-
-func TestDbBase_GetCount(t *testing.T) {
-    if count, err := db.GetCount("SELECT * FROM user"); err != nil {
-        gtest.Fatal(err)
-    } else {
-        gtest.Assert(count, 3)
-    }
-}
-
-func TestDbBase_GetStruct(t *testing.T) {
-    type User struct {
-        Id         int
-        Passport   string
-        Password   string
-        NickName   string
-        CreateTime gtime.Time
-    }
-    user := new(User)
-    if err := db.GetStruct(user, "SELECT * FROM user WHERE id=?", 3); err != nil {
-        gtest.Fatal(err)
-    } else {
-        gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
-    }
-}
-
-func TestDbBase_Delete(t *testing.T) {
-    if result, err := db.Delete("user", nil); err != nil {
-        gtest.Fatal(err)
-    } else {
-        n, _ := result.RowsAffected()
-        gtest.Assert(n, 3)
-    }
-}
-
--- a/g/database/gdb/gdb_unit_2_test.go
+++ b/g/database/gdb/gdb_unit_2_test.go
@ -1,222 +0,0 @@
-// 链式操作
-
-package gdb_test
-
-import (
-    "github.com/gogf/gf/g"
-    "github.com/gogf/gf/g/os/gtime"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
-)
-
-func TestModel_Insert(t *testing.T) {
-    result, err := db.Table("user").Filter().Data(g.Map{
-        "id"          : 1,
-        "uid"         : 1,
-        "passport"    : "t1",
-        "password"    : "25d55ad283aa400af464c76d713c07ad",
-        "nickname"    : "T1",
-        "create_time" : gtime.Now().String(),
-    }).Insert()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    n, _ := result.LastInsertId()
-    gtest.Assert(n, 1)
-}
-
-func TestModel_Batch(t *testing.T) {
-    result, err := db.Table("user").Filter().Data(g.List{
-        {
-            "id"          : 2,
-            "uid"         : 2,
-            "passport"    : "t2",
-            "password"    : "25d55ad283aa400af464c76d713c07ad",
-            "nickname"    : "T2",
-            "create_time" : gtime.Now().String(),
-        },
-        {
-            "id"          : 3,
-            "uid"         : 3,
-            "passport"    : "t3",
-            "password"    : "25d55ad283aa400af464c76d713c07ad",
-            "nickname"    : "T3",
-            "create_time" : gtime.Now().String(),
-        },
-    }).Batch(1).Insert()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    n, _ := result.RowsAffected()
-    gtest.Assert(n, 2)
-}
-
-func TestModel_Replace(t *testing.T) {
-    result, err := db.Table("user").Data(g.Map{
-        "id"          : 1,
-        "passport"    : "t11",
-        "password"    : "25d55ad283aa400af464c76d713c07ad",
-        "nickname"    : "T11",
-        "create_time" : gtime.Now().String(),
-    }).Replace()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    n, _ := result.RowsAffected()
-    gtest.Assert(n, 2)
-}
-
-func TestModel_Save(t *testing.T) {
-    result, err := db.Table("user").Data(g.Map{
-        "id"          : 1,
-        "passport"    : "t111",
-        "password"    : "25d55ad283aa400af464c76d713c07ad",
-        "nickname"    : "T111",
-        "create_time" : gtime.Now().String(),
-    }).Save()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    n, _ := result.RowsAffected()
-    gtest.Assert(n, 2)
-}
-
-func TestModel_Update(t *testing.T) {
-    result, err := db.Table("user").Data("passport", "t22").Where("passport=?", "t2").Update()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    n, _ := result.RowsAffected()
-    gtest.Assert(n, 1)
-}
-
-func TestModel_Clone(t *testing.T) {
-    md := db.Table("user").Where("id IN(?)", g.Slice{1,3})
-    count, err := md.Count()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    record, err := md.OrderBy("id DESC").One()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    result, err := md.OrderBy("id ASC").All()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(count, 2)
-    gtest.Assert(record["id"].Int(), 3)
-    gtest.Assert(len(result), 2)
-    gtest.Assert(result[0]["id"].Int(), 1)
-    gtest.Assert(result[1]["id"].Int(), 3)
-}
-
-func TestModel_All(t *testing.T) {
-    result, err := db.Table("user").All()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(len(result), 3)
-}
-
-func TestModel_One(t *testing.T) {
-    record, err := db.Table("user").Where("id", 1).One()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    if record == nil {
-        gtest.Fatal("FAIL")
-    }
-    gtest.Assert(record["nickname"].String(), "T111")
-}
-
-func TestModel_Value(t *testing.T) {
-    value, err := db.Table("user").Fields("nickname").Where("id", 1).Value()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    if value == nil {
-        gtest.Fatal("FAIL")
-    }
-    gtest.Assert(value.String(), "T111")
-}
-
-func TestModel_Count(t *testing.T) {
-    count, err := db.Table("user").Count()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(count, 3)
-}
-
-func TestModel_Select(t *testing.T) {
-    result, err := db.Table("user").Select()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(len(result), 3)
-}
-
-func TestModel_Struct(t *testing.T) {
-    type User struct {
-        Id         int
-        Passport   string
-        Password   string
-        NickName   string
-        CreateTime gtime.Time
-    }
-    user := new(User)
-    err := db.Table("user").Where("id=1").Struct(user)
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(user.NickName, "T111")
-}
-
-func TestModel_OrderBy(t *testing.T) {
-    result, err := db.Table("user").OrderBy("id DESC").Select()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(len(result), 3)
-    gtest.Assert(result[0]["nickname"].String(), "T3")
-}
-
-func TestModel_GroupBy(t *testing.T) {
-    result, err := db.Table("user").GroupBy("id").Select()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(len(result), 3)
-    gtest.Assert(result[0]["nickname"].String(), "T111")
-}
-
-func TestModel_Where1(t *testing.T) {
-    result, err := db.Table("user").Where("id IN(?)", g.Slice{1,3}).OrderBy("id ASC").All()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(len(result), 2)
-    gtest.Assert(result[0]["id"].Int(), 1)
-    gtest.Assert(result[1]["id"].Int(), 3)
-}
-
-func TestModel_Where2(t *testing.T) {
-    result, err := db.Table("user").Where("nickname=? AND id IN(?)", "T3", g.Slice{1,3}).OrderBy("id ASC").All()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(len(result), 1)
-    gtest.Assert(result[0]["id"].Int(), 3)
-}
-
-func TestModel_Delete(t *testing.T) {
-    result, err := db.Table("user").Delete()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    n, _ := result.RowsAffected()
-    gtest.Assert(n, 3)
-}
-
-
--- a/g/database/gdb/gdb_unit_basic_test.go
+++ b/g/database/gdb/gdb_unit_basic_test.go
@ -0,0 +1,28 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gdb_test
+
+import (
+    "github.com/gogf/gf/g/database/gdb"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+func Test_Instance(t *testing.T) {
+    gtest.Case(t, func() {
+        _, err := gdb.Instance("none")
+        gtest.AssertNE(err, nil)
+
+        db, err := gdb.Instance()
+        gtest.Assert(err, nil)
+
+        err1 := db.PingMaster()
+        err2 := db.PingSlave()
+        gtest.Assert(err1, nil)
+        gtest.Assert(err2, nil)
+    })
+}
--- a/g/database/gdb/gdb_unit_init_test.go
+++ b/g/database/gdb/gdb_unit_init_test.go
@ -0,0 +1,119 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gdb_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/container/garray"
+    "github.com/gogf/gf/g/database/gdb"
+    "github.com/gogf/gf/g/os/gtime"
+    "github.com/gogf/gf/g/test/gtest"
+	"os"
+)
+
+const (
+    // 初始化表数据量
+    INIT_DATA_SIZE = 10
+)
+
+var (
+	// 数据库对象/接口
+	db gdb.DB
+)
+
+// 初始化连接参数。
+// 测试前需要修改连接参数。
+func init() {
+	node := gdb.ConfigNode{
+		Host:     "127.0.0.1",
+		Port:     "3306",
+		User:     "root",
+		Pass:     "",
+		Name:     "",
+		Type:     "mysql",
+		Role:     "master",
+		Charset:  "utf8",
+		Priority: 1,
+	}
+	hostname, _ := os.Hostname()
+	// 本地测试hack
+	if hostname == "ijohn" {
+		node.Pass = "12345678"
+	}
+	gdb.AddConfigNode("test",                 node)
+	gdb.AddConfigNode(gdb.DEFAULT_GROUP_NAME, node)
+	if r, err := gdb.New(); err != nil {
+        gtest.Fatal(err)
+	} else {
+		db = r
+	}
+	// 准备测试数据结构
+    if _, err := db.Exec("CREATE DATABASE IF NOT EXISTS `test` CHARACTER SET UTF8"); err != nil {
+        gtest.Fatal(err)
+    }
+    // 选择操作数据库
+    db.SetSchema("test")
+    // 创建默认用户表
+    createTable("user")
+}
+
+// 创建指定名称的user测试表，当table为空时，创建随机的表名。
+// 创建的测试表默认没有任何数据。
+// 执行完成后返回该表名。
+// TODO 支持更多数据库
+func createTable(table...string) (name string) {
+    if len(table) > 0 {
+        name = table[0]
+    } else {
+        name = fmt.Sprintf(`user_%d`, gtime.Nanosecond())
+    }
+    dropTable(name)
+    if _, err := db.Exec(fmt.Sprintf(`
+    CREATE TABLE %s (
+        id int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '用户ID',
+        passport varchar(45) NOT NULL COMMENT '账号',
+        password char(32) NOT NULL COMMENT '密码',
+        nickname varchar(45) NOT NULL COMMENT '昵称',
+        create_time timestamp NOT NULL COMMENT '创建时间/注册时间',
+        PRIMARY KEY (id)
+    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+    `, name)); err != nil {
+        gtest.Fatal(err)
+    }
+    return
+}
+
+// 删除指定表.
+func dropTable(table string) {
+    if _, err := db.Exec(fmt.Sprintf("DROP TABLE IF EXISTS `%s`", table)); err != nil {
+        gtest.Fatal(err)
+    }
+}
+
+// See createTable.
+// 创建测试表，并初始化默认数据。
+func createInitTable(table...string) (name string) {
+    name   = createTable(table...)
+    array := garray.New(true)
+    for i := 1; i <= INIT_DATA_SIZE; i++ {
+        array.Append(g.Map{
+            "id"          : i,
+            "passport"    : fmt.Sprintf(`t%d`, i),
+            "password"    : fmt.Sprintf(`p%d`, i),
+            "nickname"    : fmt.Sprintf(`T%d`, i),
+            "create_time" : gtime.Now().String(),
+        })
+    }
+    result, err := db.Table(name).Data(array.Slice()).Insert()
+    gtest.Assert(err, nil)
+
+    n, e := result.RowsAffected()
+    gtest.Assert(e, nil)
+    gtest.Assert(n, INIT_DATA_SIZE)
+    return
+}
--- a/g/database/gdb/gdb_unit_method_test.go
+++ b/g/database/gdb/gdb_unit_method_test.go
@ -0,0 +1,490 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gdb_test
+
+import (
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/os/gtime"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+func TestDbBase_Ping(t *testing.T) {
+    gtest.Case(t, func() {
+        err1 := db.PingMaster()
+        err2 := db.PingSlave()
+        gtest.Assert(err1, nil)
+        gtest.Assert(err2, nil)
+    })
+}
+
+func TestDbBase_Query(t *testing.T) {
+    if _, err := db.Query("SELECT ?", 1); err != nil {
+        gtest.Fatal(err)
+    }
+    if _, err := db.Query("ERROR"); err == nil {
+        gtest.Fatal("FAIL")
+    }
+}
+
+func TestDbBase_Exec(t *testing.T) {
+	if _, err := db.Exec("SELECT ?", 1); err != nil {
+		gtest.Fatal(err)
+	}
+	if _, err := db.Exec("ERROR"); err == nil {
+		gtest.Fatal("FAIL")
+	}
+}
+
+func TestDbBase_Prepare(t *testing.T) {
+    st, err := db.Prepare("SELECT 100")
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    rows, err := st.Query()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    array, err := rows.Columns()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    gtest.Assert(array[0], "100")
+    if err := rows.Close(); err != nil {
+        gtest.Fatal(err)
+    }
+}
+
+func TestDbBase_Insert(t *testing.T) {
+    if _, err := db.Insert("user", g.Map{
+        "id"          : 1,
+        "passport"    : "t1",
+        "password"    : "25d55ad283aa400af464c76d713c07ad",
+        "nickname"    : "T1",
+        "create_time" : gtime.Now().String(),
+    }); err != nil {
+        gtest.Fatal(err)
+    }
+    // normal map
+    result, err := db.Insert("user", map[interface{}]interface{} {
+        "id"          : "2",
+        "passport"    : "t2",
+        "password"    : "25d55ad283aa400af464c76d713c07ad",
+        "nickname"    : "T2",
+        "create_time" : gtime.Now().String(),
+    })
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ := result.RowsAffected()
+    gtest.Assert(n, 1)
+
+    // struct
+    type User struct {
+        Id         int    `gconv:"id"`
+        Passport   string `json:"passport"`
+        Password   string `gconv:"password"`
+        Nickname   string `gconv:"nickname"`
+        CreateTime string `json:"create_time"`
+    }
+    result, err = db.Insert("user", User{
+        Id          : 3,
+        Passport    : "t3",
+        Password    : "25d55ad283aa400af464c76d713c07ad",
+        Nickname    : "T3",
+        CreateTime  : gtime.Now().String(),
+    })
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ = result.RowsAffected()
+    gtest.Assert(n, 1)
+    value, err := db.GetValue("select `passport` from `user` where id=?", 3)
+    gtest.Assert(err, nil)
+    gtest.Assert(value.String(), "t3")
+
+    // *struct
+    result, err = db.Insert("user", &User{
+        Id          : 4,
+        Passport    : "t4",
+        Password    : "25d55ad283aa400af464c76d713c07ad",
+        Nickname    : "T4",
+        CreateTime  : gtime.Now().String(),
+    })
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ = result.RowsAffected()
+    gtest.Assert(n, 1)
+    value, err = db.GetValue("select `passport` from `user` where id=?", 4)
+    gtest.Assert(err, nil)
+    gtest.Assert(value.String(), "t4")
+
+    // batch with Insert
+    if r, err := db.Insert("user", []interface{} {
+        map[interface{}]interface{} {
+            "id"          : 200,
+            "passport"    : "t200",
+            "password"    : "25d55ad283aa400af464c76d713c07ad",
+            "nickname"    : "T200",
+            "create_time" : gtime.Now().String(),
+        },
+        map[interface{}]interface{} {
+            "id"          : 300,
+            "passport"    : "t300",
+            "password"    : "25d55ad283aa400af464c76d713c07ad",
+            "nickname"    : "T300",
+            "create_time" : gtime.Now().String(),
+        },
+    }); err != nil {
+        gtest.Fatal(err)
+    } else {
+        n, _ := r.RowsAffected()
+        gtest.Assert(n, 2)
+    }
+
+    // clear unnecessary data
+    result, err = db.Delete("user", "id>?", 1)
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ = result.RowsAffected()
+    gtest.Assert(n, 5)
+}
+
+func TestDbBase_BatchInsert(t *testing.T) {
+    gtest.Case(t, func() {
+        if r, err := db.BatchInsert("user", g.List {
+            {
+                "id"          : 2,
+                "passport"    : "t2",
+                "password"    : "25d55ad283aa400af464c76d713c07ad",
+                "nickname"    : "T2",
+                "create_time" : gtime.Now().String(),
+            },
+            {
+                "id"          : 3,
+                "passport"    : "t3",
+                "password"    : "25d55ad283aa400af464c76d713c07ad",
+                "nickname"    : "T3",
+                "create_time" : gtime.Now().String(),
+            },
+        }, 1); err != nil {
+            gtest.Fatal(err)
+        } else {
+            n, _ := r.RowsAffected()
+            gtest.Assert(n, 2)
+        }
+
+        result, err := db.Delete("user", "id>?", 1)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        n, _ := result.RowsAffected()
+        gtest.Assert(n, 2)
+
+        // []interface{}
+        if r, err := db.BatchInsert("user", []interface{} {
+            map[interface{}]interface{} {
+                "id"          : 2,
+                "passport"    : "t2",
+                "password"    : "25d55ad283aa400af464c76d713c07ad",
+                "nickname"    : "T2",
+                "create_time" : gtime.Now().String(),
+            },
+            map[interface{}]interface{} {
+                "id"          : 3,
+                "passport"    : "t3",
+                "password"    : "25d55ad283aa400af464c76d713c07ad",
+                "nickname"    : "T3",
+                "create_time" : gtime.Now().String(),
+            },
+        }, 1); err != nil {
+            gtest.Fatal(err)
+        } else {
+            n, _ := r.RowsAffected()
+            gtest.Assert(n, 2)
+        }
+    })
+    // batch insert map
+    gtest.Case(t, func() {
+        table := createTable()
+        defer dropTable(table)
+        result, err := db.BatchInsert(table, g.Map{
+            "id"          : 1,
+            "passport"    : "t1",
+            "password"    : "p1",
+            "nickname"    : "T1",
+            "create_time" : gtime.Now().String(),
+        })
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        n, _ := result.RowsAffected()
+        gtest.Assert(n, 1)
+    })
+    // batch insert struct
+    gtest.Case(t, func() {
+        table := createTable()
+        defer dropTable(table)
+
+        type User struct {
+            Id         int         `gconv:"id"`
+            Passport   string      `gconv:"passport"`
+            Password   string      `gconv:"password"`
+            NickName   string      `gconv:"nickname"`
+            CreateTime *gtime.Time `gconv:"create_time"`
+        }
+        user := &User{
+            Id          : 1,
+            Passport    : "t1",
+            Password    : "p1",
+            NickName    : "T1",
+            CreateTime  : gtime.Now(),
+        }
+        result, err := db.BatchInsert(table, user)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        n, _ := result.RowsAffected()
+        gtest.Assert(n, 1)
+    })
+}
+
+func TestDbBase_Save(t *testing.T) {
+    if _, err := db.Save("user", g.Map{
+        "id"          : 1,
+        "passport"    : "t1",
+        "password"    : "25d55ad283aa400af464c76d713c07ad",
+        "nickname"    : "T11",
+        "create_time" : gtime.Now().String(),
+    }); err != nil {
+        gtest.Fatal(err)
+    }
+}
+
+func TestDbBase_Replace(t *testing.T) {
+    if _, err := db.Save("user", g.Map{
+        "id"          : 1,
+        "passport"    : "t1",
+        "password"    : "25d55ad283aa400af464c76d713c07ad",
+        "nickname"    : "T111",
+        "create_time" : gtime.Now().String(),
+    }); err != nil {
+        gtest.Fatal(err)
+    }
+}
+
+func TestDbBase_Update(t *testing.T) {
+    if result, err := db.Update("user", "create_time='2010-10-10 00:00:01'", "id=3"); err != nil {
+        gtest.Fatal(err)
+    } else {
+        n, _ := result.RowsAffected()
+        gtest.Assert(n, 1)
+    }
+}
+
+func TestDbBase_GetAll(t *testing.T) {
+    if result, err := db.GetAll("SELECT * FROM user WHERE id=?", 1); err != nil {
+        gtest.Fatal(err)
+    } else {
+        gtest.Assert(len(result), 1)
+    }
+}
+
+func TestDbBase_GetOne(t *testing.T) {
+    if record, err := db.GetOne("SELECT * FROM user WHERE passport=?", "t1"); err != nil {
+        gtest.Fatal(err)
+    } else {
+        if record == nil {
+            gtest.Fatal("FAIL")
+        }
+        gtest.Assert(record["nickname"].String(), "T111")
+    }
+}
+
+func TestDbBase_GetValue(t *testing.T) {
+    if value, err := db.GetValue("SELECT id FROM user WHERE passport=?", "t3"); err != nil {
+        gtest.Fatal(err)
+    } else {
+        gtest.Assert(value.Int(), 3)
+    }
+}
+
+func TestDbBase_GetCount(t *testing.T) {
+    if count, err := db.GetCount("SELECT * FROM user"); err != nil {
+        gtest.Fatal(err)
+    } else {
+        gtest.Assert(count, 3)
+    }
+}
+
+func TestDbBase_GetStruct(t *testing.T) {
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        user := new(User)
+        if err := db.GetStruct(user, "SELECT * FROM user WHERE id=?", 3); err != nil {
+            gtest.Fatal(err)
+        } else {
+            gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
+        }
+    })
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        user := new(User)
+        if err := db.GetStruct(user, "SELECT * FROM user WHERE id=?", 3); err != nil {
+            gtest.Fatal(err)
+        } else {
+            gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
+        }
+    })
+}
+
+func TestDbBase_GetStructs(t *testing.T) {
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        var users []User
+        if err := db.GetStructs(&users, "SELECT * FROM user WHERE id>=?", 1); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  3)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T111")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
+    })
+
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        var users []User
+        if err := db.GetStructs(&users, "SELECT * FROM user WHERE id>=?", 1); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  3)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T111")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
+    })
+}
+
+func TestDbBase_GetScan(t *testing.T) {
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        user := new(User)
+        if err := db.GetScan(user, "SELECT * FROM user WHERE id=?", 3); err != nil {
+            gtest.Fatal(err)
+        } else {
+            gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
+        }
+    })
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        user := new(User)
+        if err := db.GetScan(user, "SELECT * FROM user WHERE id=?", 3); err != nil {
+            gtest.Fatal(err)
+        } else {
+            gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
+        }
+    })
+
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        var users []User
+        if err := db.GetScan(&users, "SELECT * FROM user WHERE id>=?", 1); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  3)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T111")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
+    })
+
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        var users []User
+        if err := db.GetScan(&users, "SELECT * FROM user WHERE id>=?", 1); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  3)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T111")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
+    })
+}
+
+func TestDbBase_Delete(t *testing.T) {
+    if result, err := db.Delete("user", nil); err != nil {
+        gtest.Fatal(err)
+    } else {
+        n, _ := result.RowsAffected()
+        gtest.Assert(n, 3)
+    }
+}
+
--- a/g/database/gdb/gdb_unit_model_test.go
+++ b/g/database/gdb/gdb_unit_model_test.go
@ -0,0 +1,655 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gdb_test
+
+import (
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/os/gtime"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+// 基本测试
+func TestModel_Insert(t *testing.T) {
+    result, err := db.Table("user").Filter().Data(g.Map{
+        "id"          : 1,
+        "uid"         : 1,
+        "passport"    : "t1",
+        "password"    : "25d55ad283aa400af464c76d713c07ad",
+        "nickname"    : "T1",
+        "create_time" : gtime.Now().String(),
+    }).Insert()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ := result.LastInsertId()
+    gtest.Assert(n, 1)
+
+    result, err = db.Table("user").Filter().Data(map[interface{}]interface{} {
+        "id"          : "2",
+        "uid"         : "2",
+        "passport"    : "t2",
+        "password"    : "25d55ad283aa400af464c76d713c07ad",
+        "nickname"    : "T2",
+        "create_time" : gtime.Now().String(),
+    }).Insert()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ = result.RowsAffected()
+    gtest.Assert(n, 1)
+
+    type User struct {
+        Id         int    `gconv:"id"`
+        Uid        int    `gconv:"uid"`
+        Passport   string `json:"passport"`
+        Password   string `gconv:"password"`
+        Nickname   string `gconv:"nickname"`
+        CreateTime string `json:"create_time"`
+    }
+    result, err = db.Table("user").Filter().Data(User{
+        Id          : 3,
+        Uid         : 3,
+        Passport    : "t3",
+        Password    : "25d55ad283aa400af464c76d713c07ad",
+        Nickname    : "T3",
+        CreateTime  : gtime.Now().String(),
+    }).Insert()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ = result.RowsAffected()
+    gtest.Assert(n, 1)
+    value, err := db.Table("user").Fields("passport").Where("id=3").Value()
+    gtest.Assert(err, nil)
+    gtest.Assert(value.String(), "t3")
+
+    result, err = db.Table("user").Filter().Data(&User{
+        Id          : 4,
+        Uid         : 4,
+        Passport    : "t4",
+        Password    : "25d55ad283aa400af464c76d713c07ad",
+        Nickname    : "T4",
+        CreateTime  : gtime.Now().String(),
+    }).Insert()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ = result.RowsAffected()
+    gtest.Assert(n, 1)
+    value, err = db.Table("user").Fields("passport").Where("id=4").Value()
+    gtest.Assert(err, nil)
+    gtest.Assert(value.String(), "t4")
+
+    result, err = db.Table("user").Where("id>?", 1).Delete()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ = result.RowsAffected()
+    gtest.Assert(n, 3)
+}
+
+func TestModel_Batch(t *testing.T) {
+    // batch insert
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Filter().Data(g.List{
+            {
+                "id"          : 2,
+                "uid"         : 2,
+                "passport"    : "t2",
+                "password"    : "25d55ad283aa400af464c76d713c07ad",
+                "nickname"    : "T2",
+                "create_time" : gtime.Now().String(),
+            },
+            {
+                "id"          : 3,
+                "uid"         : 3,
+                "passport"    : "t3",
+                "password"    : "25d55ad283aa400af464c76d713c07ad",
+                "nickname"    : "T3",
+                "create_time" : gtime.Now().String(),
+            },
+        }).Batch(1).Insert()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        n, _ := result.RowsAffected()
+        gtest.Assert(n, 2)
+    })
+
+    // batch save
+    gtest.Case(t, func() {
+        table := createInitTable()
+        defer dropTable(table)
+        result, err  := db.Table(table).All()
+        gtest.Assert(err,         nil)
+        gtest.Assert(len(result), INIT_DATA_SIZE)
+        for _, v := range result {
+            v["nickname"].Set(v["nickname"].String() + v["id"].String())
+        }
+        r, e := db.Table(table).Data(result).Save()
+        gtest.Assert(e, nil)
+        n, e := r.RowsAffected()
+        gtest.Assert(e, nil)
+        gtest.Assert(n, INIT_DATA_SIZE*2)
+    })
+
+    // batch replace
+    gtest.Case(t, func() {
+        table := createInitTable()
+        defer dropTable(table)
+        result, err  := db.Table(table).All()
+        gtest.Assert(err,         nil)
+        gtest.Assert(len(result), INIT_DATA_SIZE)
+        for _, v := range result {
+            v["nickname"].Set(v["nickname"].String() + v["id"].String())
+        }
+        r, e := db.Table(table).Data(result).Replace()
+        gtest.Assert(e, nil)
+        n, e := r.RowsAffected()
+        gtest.Assert(e, nil)
+        gtest.Assert(n, INIT_DATA_SIZE*2)
+    })
+}
+
+func TestModel_Replace(t *testing.T) {
+    result, err := db.Table("user").Data(g.Map{
+        "id"          : 1,
+        "passport"    : "t11",
+        "password"    : "25d55ad283aa400af464c76d713c07ad",
+        "nickname"    : "T11",
+        "create_time" : "2018-10-10 00:01:10",
+    }).Replace()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ := result.RowsAffected()
+    gtest.Assert(n, 2)
+}
+
+func TestModel_Save(t *testing.T) {
+    result, err := db.Table("user").Data(g.Map{
+        "id"          : 1,
+        "passport"    : "t111",
+        "password"    : "25d55ad283aa400af464c76d713c07ad",
+        "nickname"    : "T111",
+        "create_time" : "2018-10-10 00:01:10",
+    }).Save()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ := result.RowsAffected()
+    gtest.Assert(n, 2)
+}
+
+func TestModel_Update(t *testing.T) {
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Data("passport", "t22").Where("passport=?", "t2").Update()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        n, _ := result.RowsAffected()
+        gtest.Assert(n, 1)
+    })
+
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Data("passport", "t2").Where("passport='t22'").Update()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        n, _ := result.RowsAffected()
+        gtest.Assert(n, 1)
+    })
+}
+
+func TestModel_Clone(t *testing.T) {
+    md := db.Table("user").Where("id IN(?)", g.Slice{1,3})
+    count, err := md.Count()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    record, err := md.OrderBy("id DESC").One()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    result, err := md.OrderBy("id ASC").All()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    gtest.Assert(count,                 2)
+    gtest.Assert(record["id"].Int(),    3)
+    gtest.Assert(len(result),           2)
+    gtest.Assert(result[0]["id"].Int(), 1)
+    gtest.Assert(result[1]["id"].Int(), 3)
+}
+
+func TestModel_Safe(t *testing.T) {
+    gtest.Case(t, func() {
+        md := db.Table("user").Safe(false).Where("id IN(?)", g.Slice{1,3})
+        count, err := md.Count()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(count, 2)
+        md.And("id = ?", 1)
+        count, err = md.Count()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(count, 1)
+    })
+    gtest.Case(t, func() {
+        md := db.Table("user").Safe(true).Where("id IN(?)", g.Slice{1,3})
+        count, err := md.Count()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(count, 2)
+        md.And("id = ?", 1)
+        count, err = md.Count()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(count, 2)
+    })
+}
+
+func TestModel_All(t *testing.T) {
+    result, err := db.Table("user").All()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    gtest.Assert(len(result), 3)
+}
+
+func TestModel_One(t *testing.T) {
+    record, err := db.Table("user").Where("id", 1).One()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    if record == nil {
+        gtest.Fatal("FAIL")
+    }
+    gtest.Assert(record["nickname"].String(), "T111")
+}
+
+func TestModel_Value(t *testing.T) {
+    value, err := db.Table("user").Fields("nickname").Where("id", 1).Value()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    if value == nil {
+        gtest.Fatal("FAIL")
+    }
+    gtest.Assert(value.String(), "T111")
+}
+
+func TestModel_Count(t *testing.T) {
+    count, err := db.Table("user").Count()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    gtest.Assert(count, 3)
+}
+
+func TestModel_Select(t *testing.T) {
+    result, err := db.Table("user").Select()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    gtest.Assert(len(result), 3)
+}
+
+func TestModel_Struct(t *testing.T) {
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        user := new(User)
+        err := db.Table("user").Where("id=1").Struct(user)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(user.NickName,            "T111")
+        gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10")
+    })
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        user := new(User)
+        err := db.Table("user").Where("id=1").Struct(user)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(user.NickName,            "T111")
+        gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10")
+    })
+}
+
+func TestModel_Structs(t *testing.T) {
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        var users []User
+        err := db.Table("user").OrderBy("id asc").Structs(&users)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  3)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T111")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
+    })
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        var users []*User
+        err := db.Table("user").OrderBy("id asc").Structs(&users)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  3)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T111")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
+    })
+}
+
+func TestModel_Scan(t *testing.T) {
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        user := new(User)
+        err := db.Table("user").Where("id=1").Scan(user)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(user.NickName,            "T111")
+        gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10")
+    })
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        user := new(User)
+        err := db.Table("user").Where("id=1").Scan(user)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(user.NickName,            "T111")
+        gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10")
+    })
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        var users []User
+        err := db.Table("user").OrderBy("id asc").Scan(&users)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  3)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T111")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
+    })
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        var users []*User
+        err := db.Table("user").OrderBy("id asc").Scan(&users)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  3)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T111")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
+    })
+}
+
+func TestModel_OrderBy(t *testing.T) {
+    result, err := db.Table("user").OrderBy("id DESC").Select()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    gtest.Assert(len(result), 3)
+    gtest.Assert(result[0]["nickname"].String(), "T3")
+}
+
+func TestModel_GroupBy(t *testing.T) {
+    result, err := db.Table("user").GroupBy("id").Select()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    gtest.Assert(len(result), 3)
+    gtest.Assert(result[0]["nickname"].String(), "T111")
+}
+
+func TestModel_Where(t *testing.T) {
+    // string
+    gtest.Case(t, func() {
+       result, err := db.Table("user").Where("id=? and nickname=?", 3, "T3").One()
+       if err != nil {
+           gtest.Fatal(err)
+       }
+       gtest.AssertGT(len(result),      0)
+       gtest.Assert(result["id"].Int(), 3)
+    })
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where("id", 3).One()
+        if err != nil {
+           gtest.Fatal(err)
+        }
+        gtest.AssertGT(len(result),      0)
+        gtest.Assert(result["id"].Int(), 3)
+    })
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where("id", 3).Where("nickname", "T3").One()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(result["id"].Int(), 3)
+    })
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where("id", 3).And("nickname", "T3").One()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(result["id"].Int(), 3)
+    })
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where("id", 30).Or("nickname", "T3").One()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(result["id"].Int(), 3)
+    })
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where("id", 30).Or("nickname", "T3").And("id>?", 1).One()
+        gtest.Assert(err,                nil)
+        gtest.Assert(result["id"].Int(), 3)
+    })
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where("id", 30).Or("nickname", "T3").And("id>", 1).One()
+        gtest.Assert(err,                nil)
+        gtest.Assert(result["id"].Int(), 3)
+    })
+    // map
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where(g.Map{"id" : 3, "nickname" : "T3"}).One()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(result["id"].Int(), 3)
+    })
+    // map key operator
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where(g.Map{"id>" : 1, "id<" : 3}).One()
+        gtest.Assert(err,                nil)
+        gtest.Assert(result["id"].Int(), 2)
+    })
+    // complicated where 1
+    gtest.Case(t, func() {
+        //db.SetDebug(true)
+        conditions := g.Map{
+           "nickname like ?"      : "%T%",
+           "id between ? and ?"   : g.Slice{1,3},
+           "id > 0"               : nil,
+           "create_time > 0"      : nil,
+           "id"                   : g.Slice{1,2,3},
+        }
+        result, err := db.Table("user").Where(conditions).OrderBy("id asc").All()
+        gtest.Assert(err,                   nil)
+        gtest.Assert(len(result),           3)
+        gtest.Assert(result[0]["id"].Int(), 1)
+    })
+    // complicated where 2
+    gtest.Case(t, func() {
+        //db.SetDebug(true)
+        conditions := g.Map{
+            "nickname like ?"      : "%T%",
+            "id between ? and ?"   : g.Slice{1,3},
+            "id >= ?"              : 1,
+            "create_time > ?"      : 0,
+            "id in(?)"             : g.Slice{1,2,3},
+        }
+        result, err := db.Table("user").Where(conditions).OrderBy("id asc").All()
+        gtest.Assert(err,                   nil)
+        gtest.Assert(len(result),           3)
+        gtest.Assert(result[0]["id"].Int(), 1)
+    })
+    // struct
+    gtest.Case(t, func() {
+        type User struct {
+            Id       int    `json:"id"`
+            Nickname string `gconv:"nickname"`
+        }
+        result, err := db.Table("user").Where(User{3, "T3"}).One()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(result["id"].Int(), 3)
+
+        result, err  = db.Table("user").Where(&User{3, "T3"}).One()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(result["id"].Int(), 3)
+    })
+    // slice single
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where("id IN(?)", g.Slice{1, 3}).OrderBy("id ASC").All()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(result), 2)
+        gtest.Assert(result[0]["id"].Int(), 1)
+        gtest.Assert(result[1]["id"].Int(), 3)
+    })
+    // slice + string
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where("nickname=? AND id IN(?)", "T3", g.Slice{1,3}).OrderBy("id ASC").All()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(result), 1)
+        gtest.Assert(result[0]["id"].Int(), 3)
+    })
+    // slice + map
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where(g.Map{
+            "id"       : g.Slice{1,3},
+            "nickname" : "T3",
+        }).OrderBy("id ASC").All()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(result), 1)
+        gtest.Assert(result[0]["id"].Int(), 3)
+    })
+    // slice + struct
+    gtest.Case(t, func() {
+        type User struct {
+            Ids      []int  `json:"id"`
+            Nickname string `gconv:"nickname"`
+        }
+        result, err := db.Table("user").Where(User{
+            Ids      : []int{1, 3},
+            Nickname : "T3",
+        }).OrderBy("id ASC").All()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(result), 1)
+        gtest.Assert(result[0]["id"].Int(), 3)
+    })
+}
+
+func TestModel_Delete(t *testing.T) {
+    result, err := db.Table("user").Delete()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ := result.RowsAffected()
+    gtest.Assert(n, 3)
+}
+
+
--- a/g/database/gdb/gdb_unit_transaction_test.go
+++ b/g/database/gdb/gdb_unit_transaction_test.go
@ -1,4 +1,8 @@
-// 事务操作
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.

 package gdb_test

@ -267,6 +271,29 @@ func TestTX_Save(t *testing.T) {
    }
 }

+func TestTX_Update(t *testing.T) {
+    gtest.Case(t, func() {
+        tx, err := db.Begin()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        if result, err := db.Update("user", "create_time='2010-10-10 00:00:01'", "id=3"); err != nil {
+            gtest.Fatal(err)
+        } else {
+            n, _ := result.RowsAffected()
+            gtest.Assert(n, 1)
+        }
+        if err := tx.Commit(); err != nil {
+            gtest.Fatal(err)
+        }
+        if value, err := db.Table("user").Fields("create_time").Where("id", 3).Value(); err != nil {
+            gtest.Fatal(err)
+        } else {
+            gtest.Assert(value.String(), "2010-10-10 00:00:01")
+        }
+    })
+}
+
 func TestTX_GetAll(t *testing.T) {
    tx, err := db.Begin()
    if err != nil {
@ -331,26 +358,215 @@ func TestTX_GetCount(t *testing.T) {
 }

 func TestTX_GetStruct(t *testing.T) {
-    tx, err := db.Begin()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    type User struct {
-        Id         int
-        Passport   string
-        Password   string
-        NickName   string
-        CreateTime gtime.Time
-    }
-    user := new(User)
-    if err := tx.GetStruct(user, "SELECT * FROM user WHERE id=?", 1); err != nil {
-        gtest.Fatal(err)
-    } else {
-        gtest.Assert(user.NickName, "T11")
-    }
-    if err := tx.Commit(); err != nil {
-        gtest.Fatal(err)
-    }
+    gtest.Case(t, func() {
+        tx, err := db.Begin()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        user := new(User)
+        if err := tx.GetStruct(user, "SELECT * FROM user WHERE id=?", 3); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(user.NickName,            "T3")
+        gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
+        if err := tx.Commit(); err != nil {
+            gtest.Fatal(err)
+        }
+    })
+    gtest.Case(t, func() {
+        tx, err := db.Begin()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        user := new(User)
+        if err := tx.GetStruct(user, "SELECT * FROM user WHERE id=?", 3); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(user.NickName,            "T3")
+        gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
+        if err := tx.Commit(); err != nil {
+            gtest.Fatal(err)
+        }
+    })
+}
+
+func TestTX_GetStructs(t *testing.T) {
+    gtest.Case(t, func() {
+        tx, err := db.Begin()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        var users []User
+        if err := tx.GetStructs(&users, "SELECT * FROM user WHERE id>=?", 1); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  4)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T11")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
+        if err := tx.Commit(); err != nil {
+            gtest.Fatal(err)
+        }
+    })
+
+    gtest.Case(t, func() {
+        tx, err := db.Begin()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        var users []User
+        if err := tx.GetStructs(&users, "SELECT * FROM user WHERE id>=?", 1); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  4)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T11")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
+        if err := tx.Commit(); err != nil {
+            gtest.Fatal(err)
+        }
+    })
+}
+
+func TestTX_GetScan(t *testing.T) {
+    gtest.Case(t, func() {
+        tx, err := db.Begin()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        user := new(User)
+        if err := tx.GetScan(user, "SELECT * FROM user WHERE id=?", 3); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(user.NickName,            "T3")
+        gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
+        if err := tx.Commit(); err != nil {
+            gtest.Fatal(err)
+        }
+    })
+    gtest.Case(t, func() {
+        tx, err := db.Begin()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        user := new(User)
+        if err := tx.GetScan(user, "SELECT * FROM user WHERE id=?", 3); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(user.NickName,            "T3")
+        gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
+        if err := tx.Commit(); err != nil {
+            gtest.Fatal(err)
+        }
+    })
+
+    gtest.Case(t, func() {
+        tx, err := db.Begin()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        var users []User
+        if err := tx.GetScan(&users, "SELECT * FROM user WHERE id>=?", 1); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  4)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T11")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
+        if err := tx.Commit(); err != nil {
+            gtest.Fatal(err)
+        }
+    })
+
+    gtest.Case(t, func() {
+        tx, err := db.Begin()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        var users []User
+        if err := tx.GetScan(&users, "SELECT * FROM user WHERE id>=?", 1); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  4)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T11")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
+        if err := tx.Commit(); err != nil {
+            gtest.Fatal(err)
+        }
+    })
 }

 func TestTX_Delete(t *testing.T) {
--- a/g/database/gredis/gredis.go
+++ b/g/database/gredis/gredis.go
@ -4,37 +4,45 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.

-// Package gredis provides client for redis server.
+// Package gredis provides convenient client for redis server.
 //
 // Redis客户端.
-// Redis中文手册文档请参考：http://redisdoc.com/ , Redis官方命令请参考：https://redis.io/commands
+// Redis中文手册请参考：http://redisdoc.com/
+// Redis官方命令请参考：https://redis.io/commands
 package gredis

 import (
-    "time"
-    "github.com/gogf/gf/third/github.com/gomodule/redigo/redis"
-    "github.com/gogf/gf/g/container/gmap"
    "fmt"
+    "github.com/gogf/gf/g/container/gmap"
+    "github.com/gogf/gf/third/github.com/gomodule/redigo/redis"
+    "time"
 )

 const (
-    gDEFAULT_POOL_MAX_IDLE      = 1
-    gDEFAULT_POOL_MAX_ACTIVE    = 10
-    gDEFAULT_POOL_IDLE_TIMEOUT  = 180 * time.Second
-    gDEFAULT_POOL_MAX_LIFE_TIME = 60  * time.Second
+    gDEFAULT_POOL_IDLE_TIMEOUT  = 60 * time.Second
+    gDEFAULT_POOL_MAX_LIFE_TIME = 60 * time.Second
 )

-// Redis客户端
+// Redis客户端(管理连接池)
 type Redis struct {
-    pool *redis.Pool
+    pool   *redis.Pool // 底层连接池
+    group  string      // 配置分组
+    config Config      // 配置对象
 }

+// Redis连接对象(连接池中的单个连接)
+type Conn redis.Conn
+
 // Redis服务端但节点连接配置信息
 type Config struct {
-    Host string // IP/域名
-    Port int    // 端口
-    Db   int    // db
-    Pass string // 密码
+    Host            string        // 地址
+    Port            int           // 端口
+    Db              int           // 数据库
+    Pass            string        // 授权密码
+    MaxIdle         int           // 最大允许空闲存在的连接数(默认为0表示不存在闲置连接)
+    MaxActive       int           // 最大连接数量限制(默认为0表示不限制)
+    IdleTimeout     time.Duration // 连接最大空闲时间(默认为60秒,不允许设置为0)
+    MaxConnLifetime time.Duration // 连接最长存活时间(默认为60秒,不允许设置为0)
 }

 // Redis链接池统计信息
@ -42,91 +50,160 @@ type PoolStats struct {
    redis.PoolStats
 }

-// 连接池map
-var pools = gmap.NewStringInterfaceMap()
+var (
+    // 单例对象Map
+    instances = gmap.NewStringInterfaceMap()
+    // 连接池Map
+    pools     = gmap.NewStringInterfaceMap()
+)

-// 创建redis操作对象.
+// New creates a redis client object with given configuration.
+// Redis client maintains a connection pool automatically.
+//
+// 创建redis操作对象，底层根据配置信息公用的连接池（连接池单例）。
 func New(config Config) *Redis {
-    r       := &Redis{}
-    poolKey := fmt.Sprintf("%s:%d,%d", config.Host, config.Port, config.Db)
-    if v := pools.Get(poolKey); v == nil {
-        pool := &redis.Pool {
-            MaxIdle         : gDEFAULT_POOL_MAX_IDLE,
-            MaxActive       : gDEFAULT_POOL_MAX_ACTIVE,
-            IdleTimeout     : gDEFAULT_POOL_IDLE_TIMEOUT,
-            MaxConnLifetime : gDEFAULT_POOL_MAX_LIFE_TIME,
-            Dial            : func() (redis.Conn, error) {
-                c, err := redis.Dial("tcp", fmt.Sprintf("%s:%d", config.Host, config.Port))
-                if err != nil {
-                    return nil, err
-                }
-                if len(config.Pass) > 0 {
-                    if _, err := c.Do("AUTH", config.Pass); err != nil {
+    if config.IdleTimeout == 0 {
+        config.IdleTimeout = gDEFAULT_POOL_IDLE_TIMEOUT
+    }
+    if config.MaxConnLifetime == 0 {
+        config.MaxConnLifetime = gDEFAULT_POOL_MAX_LIFE_TIME
+    }
+    return &Redis{
+        config : config,
+        pool   : pools.GetOrSetFuncLock(fmt.Sprintf("%v", config), func() interface{} {
+            return &redis.Pool {
+                IdleTimeout     : config.IdleTimeout,
+                MaxConnLifetime : config.MaxConnLifetime,
+                Dial            : func() (redis.Conn, error) {
+                    c, err := redis.Dial("tcp", fmt.Sprintf("%s:%d", config.Host, config.Port))
+                    if err != nil {
                        return nil, err
                    }
-                }
-                if _, err := c.Do("SELECT", config.Db); err != nil {
-                    return nil, err
-                }
-                return c, nil
-            },
-            // 用来测试连接是否可用
-            TestOnBorrow: func(c redis.Conn, t time.Time) error {
-			    _, err := c.Do("PING")
-			    return err
-		    },
-        }
-        pools.Set(poolKey, pool)
-        r.pool = pool
-    } else {
-        r.pool = v.(*redis.Pool)
+                    // 密码设置
+                    if len(config.Pass) > 0 {
+                        if _, err := c.Do("AUTH", config.Pass); err != nil {
+                            return nil, err
+                        }
+                    }
+                    // 数据库设置
+                    if _, err := c.Do("SELECT", config.Db); err != nil {
+                        return nil, err
+                    }
+                    return c, nil
+                },
+                // 在被应用从连接池中获取出来之后，用以测试连接是否可用，
+                // 如果返回error那么关闭该连接对象重新创建新的连接。
+                TestOnBorrow: func(c redis.Conn, t time.Time) error {
+                    _, err := c.Do("PING")
+                    return err
+                },
+            }
+        }).(*redis.Pool),
    }
-    return r
 }

-// 关闭redis管理对象，将会关闭底层的
+// Instance returns an instance of redis client with specified group.
+// The <group> param is unnecessary, if <group> is not passed,
+// return redis instance with default group.
+//
+// 获取指定分组名称的Redis单例对象，底层根据配置信息公用的连接池（连接池单例）。
+func Instance(name ...string) *Redis {
+    group := DEFAULT_GROUP_NAME
+    if len(name) > 0 {
+        group = name[0]
+    }
+    v := instances.GetOrSetFuncLock(group, func() interface{} {
+        if config, ok := GetConfig(group); ok {
+            r      := New(config)
+            r.group = group
+            return r
+        }
+        return nil
+    })
+    if v != nil {
+        return v.(*Redis)
+    }
+    return nil
+}
+
+// Close closes the redis connection pool,
+// it will release all connections reserved by this pool.
+// It always not necessary to call Close manually.
+//
+// 关闭redis管理对象，将会关闭底层的连接池。
+// 往往没必要手动调用，跟随进程销毁即可。
 func (r *Redis) Close() error {
+    if r.group != "" {
+        // 如果是单例对象，那么需要从单例对象Map中删除
+        instances.Remove(r.group)
+    }
+    pools.Remove(fmt.Sprintf("%v", r.config))
    return r.pool.Close()
 }

-// 获得一个原生的redis连接对象，用于自定义连接操作，
-// 但是需要注意的是如果不再使用该连接对象时，需要手动Close连接，否则会造成连接数超限。
-func (r *Redis) GetConn() redis.Conn {
-    return r.pool.Get()
+// See GetConn.
+func (r *Redis) Conn() Conn {
+    return r.GetConn()
 }

+// GetConn returns a raw connection object,
+// which expose more methods communication with server.
+// **You should call Close function manually if you do not use this connection any further.**
+//
+// 获得一个原生的redis连接对象，用于自定义连接操作，
+// 但是需要注意的是如果不再使用该连接对象时，需要手动Close连接，否则会造成连接数超限。
+func (r *Redis) GetConn() Conn {
+    return r.pool.Get().(Conn)
+}
+
+// SetMaxIdle sets the MaxIdle attribute of the connection pool.
+//
 // 设置属性 - MaxIdle
 func (r *Redis) SetMaxIdle(value int) {
    r.pool.MaxIdle = value
 }

+// SetMaxIdle sets the MaxActive attribute of the connection pool.
+//
 // 设置属性 - MaxActive
 func (r *Redis) SetMaxActive(value int) {
    r.pool.MaxActive = value
 }

+// SetMaxIdle sets the IdleTimeout attribute of the connection pool.
+//
 // 设置属性 - IdleTimeout
 func (r *Redis) SetIdleTimeout(value time.Duration) {
    r.pool.IdleTimeout = value
 }

+// SetMaxIdle sets the MaxConnLifetime attribute of the connection pool.
+//
 // 设置属性 - MaxConnLifetime
 func (r *Redis) SetMaxConnLifetime(value time.Duration) {
    r.pool.MaxConnLifetime = value
 }

-// 获取当前连接池统计信息
+// Stats returns pool's statistics.
+//
+// 获取当前连接池统计信息。
 func (r *Redis) Stats() *PoolStats {
    return &PoolStats{r.pool.Stats()}
 }

-// 执行同步命令 - Do
+// Do sends a command to the server and returns the received reply.
+// Do automatically get a connection from pool, and close it when reply received.
+//
+// 执行同步命令，自动从连接池中获取连接，使用完毕后关闭连接（丢回连接池），开发者不用自行Close.
 func (r *Redis) Do(command string, args ...interface{}) (interface{}, error) {
    conn := r.pool.Get()
    defer conn.Close()
    return conn.Do(command, args...)
 }

+// Deprecated.
+// Send writes the command to the client's output buffer.
+//
 // 执行异步命令 - Send
 func (r *Redis) Send(command string, args ...interface{}) error {
    conn := r.pool.Get()
--- a/g/database/gredis/gredis_config.go
+++ b/g/database/gredis/gredis_config.go
@ -0,0 +1,61 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gredis
+
+import "github.com/gogf/gf/g/container/gmap"
+
+const (
+    // Default configuration group name.
+    DEFAULT_GROUP_NAME = "default"
+)
+var (
+    // Configuration groups.
+    configs = gmap.NewStringInterfaceMap()
+)
+
+// SetConfig sets the global configuration for specified group.
+// If <name> is not passed, it sets configuration for the default group name.
+func SetConfig(config Config, name...string) {
+    group := DEFAULT_GROUP_NAME
+    if len(name) > 0 {
+        group = name[0]
+    }
+    configs.Set(group, config)
+    instances.Remove(group)
+}
+
+// GetConfig returns the global configuration with specified group name.
+// If <name> is not passed, it returns configuration of the default group name.
+func GetConfig(name...string) (config Config, ok bool) {
+    group := DEFAULT_GROUP_NAME
+    if len(name) > 0 {
+        group = name[0]
+    }
+    if v := configs.Get(group); v != nil {
+        return v.(Config), true
+    }
+    return Config{}, false
+}
+
+// RemoveConfig removes the global configuration with specified group.
+// If <name> is not passed, it removes configuration of the default group name.
+func RemoveConfig(name...string) {
+    group := DEFAULT_GROUP_NAME
+    if len(name) > 0 {
+        group = name[0]
+    }
+    configs.Remove(group)
+    instances.Remove(group)
+}
+
+// ClearConfig removes all configurations and instances of redis.
+func ClearConfig() {
+    configs.Clear()
+    instances.Clear()
+}
+
+
--- a/g/database/gredis/gredis_unit_test.go
+++ b/g/database/gredis/gredis_unit_test.go
@ -0,0 +1,139 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gredis_test
+
+import (
+    "github.com/gogf/gf/g/database/gredis"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+var (
+    config = gredis.Config{
+        Host : "127.0.0.1",
+        Port : 6379,
+        Db   : 1,
+    }
+)
+
+func Test_NewClose(t *testing.T) {
+    gtest.Case(t, func() {
+        redis := gredis.New(config)
+        gtest.AssertNE(redis, nil)
+        err := redis.Close()
+        gtest.Assert(err, nil)
+    })
+}
+
+func Test_Do(t *testing.T) {
+    gtest.Case(t, func() {
+        redis := gredis.New(config)
+        defer redis.Close()
+        _, err := redis.Do("SET", "k", "v")
+        gtest.Assert(err, nil)
+
+        r, err := redis.Do("GET", "k")
+        gtest.Assert(err, nil)
+        gtest.Assert(r, []byte("v"))
+
+        _, err  = redis.Do("DEL", "k")
+        gtest.Assert(err, nil)
+        r, err  = redis.Do("GET", "k")
+        gtest.Assert(err, nil)
+        gtest.Assert(r, nil)
+    })
+}
+
+func Test_Send(t *testing.T) {
+    gtest.Case(t, func() {
+        redis := gredis.New(config)
+        defer redis.Close()
+        err := redis.Send("SET", "k", "v")
+        gtest.Assert(err, nil)
+
+        r, err := redis.Do("GET", "k")
+        gtest.Assert(err, nil)
+        gtest.Assert(r,   []byte("v"))
+    })
+}
+
+func Test_Stats(t *testing.T) {
+    gtest.Case(t, func() {
+        redis := gredis.New(config)
+        defer redis.Close()
+        redis.SetMaxIdle(2)
+        redis.SetMaxActive(100)
+        redis.SetIdleTimeout(500*time.Millisecond)
+        redis.SetMaxConnLifetime(500*time.Millisecond)
+
+        array := make([]gredis.Conn, 0)
+        for i := 0; i < 10; i++ {
+            array = append(array, redis.Conn())
+        }
+        stats := redis.Stats()
+        gtest.Assert(stats.ActiveCount, 10)
+        gtest.Assert(stats.IdleCount,    0)
+        for i := 0; i < 10; i++ {
+            array[i].Close()
+        }
+        stats  = redis.Stats()
+        gtest.Assert(stats.ActiveCount,  2)
+        gtest.Assert(stats.IdleCount,    2)
+        //time.Sleep(3000*time.Millisecond)
+        //stats  = redis.Stats()
+        //fmt.Println(stats)
+        //gtest.Assert(stats.ActiveCount,  0)
+        //gtest.Assert(stats.IdleCount,    0)
+    })
+}
+
+func Test_Conn(t *testing.T) {
+    gtest.Case(t, func() {
+        redis := gredis.New(config)
+        defer redis.Close()
+        conn := redis.Conn()
+        defer conn.Close()
+
+
+        r, err := conn.Do("GET", "k")
+        gtest.Assert(err, nil)
+        gtest.Assert(r,   []byte("v"))
+
+        _, err  = conn.Do("DEL", "k")
+        gtest.Assert(err, nil)
+        r, err  = conn.Do("GET", "k")
+        gtest.Assert(err, nil)
+        gtest.Assert(r, nil)
+    })
+}
+
+func Test_Instance(t *testing.T) {
+    gtest.Case(t, func() {
+        group := "my-test"
+        gredis.SetConfig(config, group)
+        defer gredis.RemoveConfig(group)
+        redis := gredis.Instance(group)
+        defer redis.Close()
+
+        conn := redis.Conn()
+        defer conn.Close()
+
+        _, err := conn.Do("SET", "k", "v")
+        gtest.Assert(err, nil)
+
+        r, err := conn.Do("GET", "k")
+        gtest.Assert(err, nil)
+        gtest.Assert(r,   []byte("v"))
+
+        _, err  = conn.Do("DEL", "k")
+        gtest.Assert(err, nil)
+        r, err  = conn.Do("GET", "k")
+        gtest.Assert(err, nil)
+        gtest.Assert(r, nil)
+    })
+}
--- a/g/encoding/encoding.go
+++ b/g/encoding/encoding.go
@ -1,7 +0,0 @@
-// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-package encoding
--- a/g/encoding/gcharset/gcharset.go
+++ b/g/encoding/gcharset/gcharset.go
@ -51,5 +51,5 @@ func ToUTF8(charset string, src string) (dst string, err error) {

 // UTF8转指定字符集
 func UTF8To(charset string, src string) (dst string, err error) {
-	return  Convert(charset, "UTF-8", src)
+	return Convert(charset, "UTF-8", src)
 }
--- a/g/encoding/gcharset/gcharset_test.go
+++ b/g/encoding/gcharset/gcharset_test.go
@ -1,10 +1,16 @@
-package gcharset
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gcharset_test

 import (
+	"github.com/gogf/gf/g/encoding/gcharset"
 	"testing"
 )

-
 var testData = []struct {
 	utf8, other, otherEncoding string
 }{
@ -52,7 +58,7 @@ var testData = []struct {
 func TestDecode(t *testing.T) {
 	for _, data := range testData {
 		str := ""
-		str, err := Convert("UTF-8", data.otherEncoding, data.other)
+		str, err := gcharset.Convert("UTF-8", data.otherEncoding, data.other)
 		if err != nil {
 			t.Errorf("Could not create decoder for %v", err)
 			continue
@ -68,7 +74,7 @@ func TestDecode(t *testing.T) {
 func TestEncode(t *testing.T) {
 	for _, data := range testData {
 		str := ""
-		str, err := Convert(data.otherEncoding, "UTF-8", data.utf8)
+		str, err := gcharset.Convert(data.otherEncoding, "UTF-8", data.utf8)
 		if err != nil {
 			t.Errorf("Could not create decoder for %v", err)
 			continue
@ -86,7 +92,7 @@ func TestConvert(t *testing.T) {
 	dstCharset := "gbk"
 	dst := "Hello \xb3\xa3\xd3\xc3\x87\xf8\xd7\xd6\x98\xcb\x9c\xca\xd7\xd6\xf3\x77\xb1\xed"

-	str, err := Convert(dstCharset, srcCharset, src)
+	str, err := gcharset.Convert(dstCharset, srcCharset, src)
 	if err != nil {
 		t.Errorf("convert error. %v", err)
 		return
--- a/g/encoding/gjson/gjson.go
+++ b/g/encoding/gjson/gjson.go
--- a/g/encoding/gjson/gjson_bench_test.go
+++ b/g/encoding/gjson/gjson_bench_test.go
@ -0,0 +1,30 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gjson_test
+
+import (
+    "github.com/gogf/gf/g/encoding/gjson"
+    "testing"
+)
+
+func Benchmark_Set1(b *testing.B) {
+    for i := 0; i < b.N; i++ {
+        p := gjson.New(map[string]string{
+            "k1" : "v1",
+            "k2" : "v2",
+        })
+        p.Set("k1.k11", []int{1,2,3})
+    }
+}
+
+func Benchmark_Set2(b *testing.B) {
+    for i := 0; i < b.N; i++ {
+        p := gjson.New([]string{"a"})
+        p.Set("0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0", []int{1,2,3})
+    }
+}
+
--- a/g/encoding/gjson/gjson_unit_basic_test.go
+++ b/g/encoding/gjson/gjson_unit_basic_test.go
@ -0,0 +1,253 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gjson_test
+
+import (
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/encoding/gjson"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+func Test_New(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gjson.New(data)
+        gtest.Assert(j.Get("n"), "123456789")
+        gtest.Assert(j.Get("m"), g.Map{"k" : "v"})
+        gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+    })
+}
+
+func Test_NewUnsafe(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gjson.NewUnsafe(data)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+}
+
+func Test_Valid(t *testing.T) {
+    data1 := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    data2 := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]`)
+    gtest.Case(t, func() {
+        gtest.Assert(gjson.Valid(data1), true)
+        gtest.Assert(gjson.Valid(data2), false)
+    })
+}
+
+func Test_Encode(t *testing.T) {
+    value := g.Slice{1, 2, 3}
+    gtest.Case(t, func() {
+        b, err := gjson.Encode(value)
+        gtest.Assert(err, nil)
+        gtest.Assert(b,   []byte(`[1,2,3]`))
+    })
+}
+
+func Test_Decode(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        v, err := gjson.Decode(data)
+        gtest.Assert(err, nil)
+        gtest.Assert(v, g.Map{
+            "n" : 123456789,
+            "a" : g.Slice{1, 2, 3},
+            "m" : g.Map{
+                "k" : "v",
+            },
+        })
+    })
+    gtest.Case(t, func() {
+        var v interface{}
+        err := gjson.DecodeTo(data, &v)
+        gtest.Assert(err, nil)
+        gtest.Assert(v, g.Map{
+            "n" : 123456789,
+            "a" : g.Slice{1, 2, 3},
+            "m" : g.Map{
+                "k" : "v",
+            },
+        })
+    })
+    gtest.Case(t, func() {
+        j, err := gjson.DecodeToJson(data)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+}
+
+func Test_SplitChar(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j, err := gjson.DecodeToJson(data)
+        j.SetSplitChar(byte('#'))
+        gtest.Assert(err, nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m#k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a#1"), 2)
+    })
+}
+
+func Test_ViolenceCheck(t *testing.T) {
+    data := []byte(`{"m":{"a":[1,2,3], "v1.v2":"4"}}`)
+    gtest.Case(t, func() {
+        j, err := gjson.DecodeToJson(data)
+        gtest.Assert(err, nil)
+        gtest.Assert(j.Get("m.a.2"),   3)
+        gtest.Assert(j.Get("m.v1.v2"), nil)
+        j.SetViolenceCheck(true)
+        gtest.Assert(j.Get("m.v1.v2"), 4)
+    })
+}
+
+func Test_GetToVar(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        var m map[string]string
+        var n int
+        var a []int
+        j, err := gjson.DecodeToJson(data)
+        gtest.Assert(err, nil)
+
+        j.GetToVar("n", &n)
+        j.GetToVar("m", &m)
+        j.GetToVar("a", &a)
+
+        gtest.Assert(n, "123456789")
+        gtest.Assert(m, g.Map{"k" : "v"})
+        gtest.Assert(a, g.Slice{1, 2, 3})
+    })
+}
+
+func Test_GetMap(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j, err := gjson.DecodeToJson(data)
+        gtest.Assert(err, nil)
+        gtest.Assert(j.GetMap("n"), nil)
+        gtest.Assert(j.GetMap("m"), g.Map{"k" : "v"})
+        gtest.Assert(j.GetMap("a"), nil)
+    })
+}
+
+func Test_GetJson(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j, err := gjson.DecodeToJson(data)
+        gtest.Assert(err, nil)
+        j2 := j.GetJson("m")
+        gtest.AssertNE(j2, nil)
+        gtest.Assert(j2.Get("k"), "v")
+        gtest.Assert(j2.Get("a"), nil)
+        gtest.Assert(j2.Get("n"), nil)
+    })
+}
+
+func Test_GetArray(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j, err := gjson.DecodeToJson(data)
+        gtest.Assert(err, nil)
+        gtest.Assert(j.GetArray("n"), g.Array{123456789})
+        gtest.Assert(j.GetArray("m"), g.Array{g.Map{"k":"v"}})
+        gtest.Assert(j.GetArray("a"), g.Array{1,2,3})
+    })
+}
+
+func Test_GetString(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j, err := gjson.DecodeToJson(data)
+        gtest.Assert(err, nil)
+        gtest.AssertEQ(j.GetString("n"), "123456789")
+        gtest.AssertEQ(j.GetString("m"), `{"k":"v"}`)
+        gtest.AssertEQ(j.GetString("a"), `[1,2,3]`)
+        gtest.AssertEQ(j.GetString("i"), "")
+    })
+}
+
+func Test_GetStrings(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j, err := gjson.DecodeToJson(data)
+        gtest.Assert(err, nil)
+        gtest.AssertEQ(j.GetStrings("n"), g.SliceStr{"123456789"})
+        gtest.AssertEQ(j.GetStrings("m"), g.SliceStr{`{"k":"v"}`})
+        gtest.AssertEQ(j.GetStrings("a"), g.SliceStr{"1", "2", "3"})
+        gtest.AssertEQ(j.GetStrings("i"), nil)
+    })
+}
+
+func Test_GetInterfaces(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j, err := gjson.DecodeToJson(data)
+        gtest.Assert(err, nil)
+        gtest.AssertEQ(j.GetInterfaces("n"), g.Array{123456789})
+        gtest.AssertEQ(j.GetInterfaces("m"), g.Array{g.Map{"k":"v"}})
+        gtest.AssertEQ(j.GetInterfaces("a"), g.Array{1,2,3})
+    })
+}
+
+func Test_Len(t *testing.T) {
+    gtest.Case(t, func() {
+        p := gjson.New(nil)
+        p.Append("a", 1)
+        p.Append("a", 2)
+        gtest.Assert(p.Len("a"), 2)
+    })
+    gtest.Case(t, func() {
+        p := gjson.New(nil)
+        p.Append("a.b", 1)
+        p.Append("a.c", 2)
+        gtest.Assert(p.Len("a"), 2)
+    })
+    gtest.Case(t, func() {
+        p := gjson.New(nil)
+        p.Set("a", 1)
+        gtest.Assert(p.Len("a"), -1)
+    })
+}
+
+func Test_Append(t *testing.T) {
+    gtest.Case(t, func() {
+        p := gjson.New(nil)
+        p.Append("a", 1)
+        p.Append("a", 2)
+        gtest.Assert(p.Get("a"), g.Slice{1, 2})
+    })
+    gtest.Case(t, func() {
+        p := gjson.New(nil)
+        p.Append("a.b", 1)
+        p.Append("a.c", 2)
+        gtest.Assert(p.Get("a"), g.Map{
+            "b" : g.Slice{1},
+            "c" : g.Slice{2},
+        })
+    })
+    gtest.Case(t, func() {
+        p := gjson.New(nil)
+        p.Set("a", 1)
+        err := p.Append("a", 2)
+        gtest.AssertNE(err, nil)
+        gtest.Assert(p.Get("a"), 1)
+    })
+}
+
+
+
--- a/g/encoding/gjson/gjson_unit_load_test.go
+++ b/g/encoding/gjson/gjson_unit_load_test.go
@ -0,0 +1,156 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gjson_test
+
+import (
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/encoding/gjson"
+    "github.com/gogf/gf/g/os/gfile"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+
+func Test_Load_JSON(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    // JSON
+    gtest.Case(t, func() {
+        j, err := gjson.LoadContent(data)
+        gtest.Assert(err,        nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+    // JSON
+    gtest.Case(t, func() {
+        path := "test.json"
+        gfile.PutBinContents(path, data)
+        defer gfile.Remove(path)
+        j, err := gjson.Load(path)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+}
+
+func Test_Load_XML(t *testing.T) {
+    data := []byte(`<doc><a>1</a><a>2</a><a>3</a><m><k>v</k></m><n>123456789</n></doc>`)
+    // XML
+    gtest.Case(t, func() {
+        j, err := gjson.LoadContent(data)
+        gtest.Assert(err, nil)
+        gtest.Assert(j.Get("doc.n"),   "123456789")
+        gtest.Assert(j.Get("doc.m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("doc.m.k"), "v")
+        gtest.Assert(j.Get("doc.a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("doc.a.1"), 2)
+    })
+    // XML
+    gtest.Case(t, func() {
+        path := "test.xml"
+        gfile.PutBinContents(path, data)
+        defer gfile.Remove(path)
+        j, err := gjson.Load(path)
+        gtest.Assert(err, nil)
+        gtest.Assert(j.Get("doc.n"),   "123456789")
+        gtest.Assert(j.Get("doc.m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("doc.m.k"), "v")
+        gtest.Assert(j.Get("doc.a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("doc.a.1"), 2)
+    })
+}
+
+func Test_Load_YAML1(t *testing.T) {
+    data := []byte(`
+a:
+- 1
+- 2
+- 3
+m:
+ k: v
+"n": 123456789
+    `)
+    // YAML
+    gtest.Case(t, func() {
+        j, err := gjson.LoadContent(data)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+    // YAML
+    gtest.Case(t, func() {
+        path := "test.yaml"
+        gfile.PutBinContents(path, data)
+        defer gfile.Remove(path)
+        j, err := gjson.Load(path)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+}
+
+func Test_Load_YAML2(t *testing.T) {
+    data := []byte("i : 123456789")
+    gtest.Case(t, func() {
+        j, err := gjson.LoadContent(data)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("i"),   "123456789")
+    })
+}
+
+func Test_Load_TOML1(t *testing.T) {
+    data := []byte(`
+a = ["1", "2", "3"]
+n = "123456789"
+
+[m]
+  k = "v"
+`)
+    // TOML
+    gtest.Case(t, func() {
+        j, err := gjson.LoadContent(data)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+    // TOML
+    gtest.Case(t, func() {
+        path := "test.toml"
+        gfile.PutBinContents(path, data)
+        defer gfile.Remove(path)
+        j, err := gjson.Load(path)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+}
+
+func Test_Load_TOML2(t *testing.T) {
+    data := []byte("i=123456789")
+    gtest.Case(t, func() {
+        j, err := gjson.LoadContent(data)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("i"),   "123456789")
+    })
+}
--- a/g/encoding/gjson/gjson_unit_set_test.go
+++ b/g/encoding/gjson/gjson_unit_set_test.go
@ -0,0 +1,230 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gjson_test
+
+import (
+    "bytes"
+    "github.com/gogf/gf/g/encoding/gjson"
+    "testing"
+)
+
+func Test_Set1(t *testing.T) {
+    e := []byte(`{"k1":{"k11":[1,2,3]},"k2":"v2"}`)
+    p := gjson.New(map[string]string{
+        "k1" : "v1",
+        "k2" : "v2",
+    })
+    p.Set("k1.k11", []int{1,2,3})
+    if c, err := p.ToJson(); err == nil {
+        
+        if bytes.Compare(c, []byte(`{"k1":{"k11":[1,2,3]},"k2":"v2"}`)) != 0 {
+            t.Error("expect:", string(e))
+        }
+    } else {
+        t.Error(err)
+    }
+}
+
+func Test_Set2(t *testing.T) {
+    e := []byte(`[[null,1]]`)
+    p := gjson.New([]string{"a"})
+    p.Set("0.1", 1)
+    if c, err := p.ToJson(); err == nil {
+        
+        if bytes.Compare(c, e) != 0 {
+            t.Error("expect:", string(e))
+        }
+    } else {
+        t.Error(err)
+    }
+}
+
+func Test_Set3(t *testing.T) {
+    e := []byte(`{"kv":{"k1":"v1"}}`)
+    p := gjson.New([]string{"a"})
+    p.Set("kv", map[string]string {
+        "k1" : "v1",
+    })
+    if c, err := p.ToJson(); err == nil {
+        
+        if bytes.Compare(c, e) != 0 {
+            t.Error("expect:", string(e))
+        }
+    } else {
+        t.Error(err)
+    }
+}
+
+func Test_Set4(t *testing.T) {
+    e := []byte(`["a",[{"k1":"v1"}]]`)
+    p := gjson.New([]string{"a"})
+    p.Set("1.0", map[string]string{
+        "k1" : "v1",
+    })
+    if c, err := p.ToJson(); err == nil {
+        
+        if bytes.Compare(c, e) != 0 {
+            t.Error("expect:", string(e))
+        }
+    } else {
+        t.Error(err)
+    }
+}
+
+func Test_Set5(t *testing.T) {
+    e := []byte(`[[[[[[[[[[[[[[[[[[[[[1,2,3]]]]]]]]]]]]]]]]]]]]]`)
+    p := gjson.New([]string{"a"})
+    p.Set("0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0", []int{1,2,3})
+    if c, err := p.ToJson(); err == nil {
+        
+        if bytes.Compare(c, e) != 0 {
+            t.Error("expect:", string(e))
+        }
+    } else {
+        t.Error(err)
+    }
+}
+
+func Test_Set6(t *testing.T) {
+    e := []byte(`["a",[1,2,3]]`)
+    p := gjson.New([]string{"a"})
+    p.Set("1", []int{1,2,3})
+    if c, err := p.ToJson(); err == nil {
+        
+        if bytes.Compare(c, e) != 0 {
+            t.Error("expect:", string(e))
+        }
+    } else {
+        t.Error(err)
+    }
+}
+
+func Test_Set7(t *testing.T) {
+    e := []byte(`{"0":[null,[1,2,3]],"k1":"v1","k2":"v2"}`)
+    p := gjson.New(map[string]string{
+        "k1" : "v1",
+        "k2" : "v2",
+    })
+    p.Set("0.1", []int{1,2,3})
+    if c, err := p.ToJson(); err == nil {
+        
+        if bytes.Compare(c, e) != 0 {
+            t.Error("expect:", string(e))
+        }
+    } else {
+        t.Error(err)
+    }
+}
+
+func Test_Set8(t *testing.T) {
+    e := []byte(`{"0":[[[[[[null,[1,2,3]]]]]]],"k1":"v1","k2":"v2"}`)
+    p := gjson.New(map[string]string{
+        "k1" : "v1",
+        "k2" : "v2",
+    })
+    p.Set("0.0.0.0.0.0.1", []int{1,2,3})
+    if c, err := p.ToJson(); err == nil {
+        
+        if bytes.Compare(c, e) != 0 {
+            t.Error("expect:", string(e))
+        }
+    } else {
+        t.Error(err)
+    }
+}
+
+func Test_Set9(t *testing.T) {
+    e := []byte(`{"k1":[null,[1,2,3]],"k2":"v2"}`)
+    p := gjson.New(map[string]string{
+        "k1" : "v1",
+        "k2" : "v2",
+    })
+    p.Set("k1.1", []int{1,2,3})
+    if c, err := p.ToJson(); err == nil {
+        
+        if bytes.Compare(c, e) != 0 {
+            t.Error("expect:", string(e))
+        }
+    } else {
+        t.Error(err)
+    }
+}
+
+
+func Test_Set10(t *testing.T) {
+    e := []byte(`{"a":{"b":{"c":1}}}`)
+    p := gjson.New(nil)
+    p.Set("a.b.c", 1)
+    if c, err := p.ToJson(); err == nil {
+        
+        if bytes.Compare(c, e) != 0 {
+            t.Error("expect:", string(e))
+        }
+    } else {
+        t.Error(err)
+    }
+}
+
+
+func Test_Set11(t *testing.T) {
+    e    := []byte(`{"a":{"b":{}}}`)
+    p, _ := gjson.LoadContent([]byte(`{"a":{"b":{"c":1}}}`))
+    p.Remove("a.b.c")
+    if c, err := p.ToJson(); err == nil {
+        
+        if bytes.Compare(c, e) != 0 {
+            t.Error("expect:", string(e))
+        }
+    } else {
+        t.Error(err)
+    }
+}
+
+func Test_Set12(t *testing.T) {
+    e := []byte(`[0,1]`)
+    p := gjson.New(nil)
+    p.Set("0", 0)
+    p.Set("1", 1)
+    if c, err := p.ToJson(); err == nil {
+        
+        if bytes.Compare(c, e) != 0 {
+            t.Error("expect:", string(e))
+        }
+    } else {
+        t.Error(err)
+    }
+}
+
+func Test_Set13(t *testing.T) {
+    e := []byte(`{"array":[0,1]}`)
+    p := gjson.New(nil)
+    p.Set("array.0", 0)
+    p.Set("array.1", 1)
+    if c, err := p.ToJson(); err == nil {
+        
+        if bytes.Compare(c, e) != 0 {
+            t.Error("expect:", string(e))
+        }
+    } else {
+        t.Error(err)
+    }
+}
+
+func Test_Set14(t *testing.T) {
+    e := []byte(`{"f":{"a":1}}`)
+    p := gjson.New(nil)
+    p.Set("f",   "m")
+    p.Set("f.a", 1)
+    if c, err := p.ToJson(); err == nil {
+        
+        if bytes.Compare(c, e) != 0 {
+            t.Error("expect:", string(e))
+        }
+    } else {
+        t.Error(err)
+    }
+}
--- a/g/encoding/gparser/gparser.go
+++ b/g/encoding/gparser/gparser.go
@ -4,7 +4,7 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://gitee.com/johng/gp.

-// Package gparser provides a flexible and easy way for accessing/converting variable and JSON/XML/YAML/TOML contents.
+// Package gparser provides convenient API for accessing/converting variable and JSON/XML/YAML/TOML.
 package gparser

 import (
@ -16,13 +16,16 @@ type Parser struct {
    json *gjson.Json
 }

-// 将变量转换为Parser对象进行处理，该变量至少应当是一个map或者array，否者转换没有意义
-// value可以传递nil, 表示创建一个空的Parser对象
-func New (value interface{}, unsafe...bool) *Parser {
+// New creates a Parser object with any variable type of <data>,
+// but <data> should be a map or slice for data access reason,
+// or it will make no sense.
+// The <unsafe> param specifies whether using this Parser object
+// in un-concurrent-safe context, which is false in default.
+func New(value interface{}, unsafe...bool) *Parser {
    return &Parser{gjson.New(value, unsafe...)}
 }

-// 非并发安全Parser对象
+// NewUnsafe creates a un-concurrent-safe Parser object.
 func NewUnsafe (value...interface{}) *Parser {
    if len(value) > 0 {
        return &Parser{gjson.New(value[0], false)}
@ -30,57 +33,64 @@ func NewUnsafe (value...interface{}) *Parser {
    return &Parser{gjson.New(nil, false)}
 }

-func Load (path string) (*Parser, error) {
-    if j, e := gjson.Load(path); e == nil {
+// Load loads content from specified file <path>,
+// and creates a Parser object from its content.
+func Load (path string, unsafe...bool) (*Parser, error) {
+    if j, e := gjson.Load(path, unsafe...); e == nil {
        return &Parser{j}, nil
    } else {
        return nil, e
    }
 }

-// 支持的数据内容格式：json(默认), xml, yaml/yml, toml
-func LoadContent (data []byte, dataType...string) (*Parser, error) {
-    if j, e := gjson.LoadContent(data, dataType...); e == nil {
+// LoadContent creates a Parser object from given content,
+// it checks the data type of <content> automatically,
+// supporting JSON, XML, YAML and TOML types of data.
+func LoadContent (data []byte, unsafe...bool) (*Parser, error) {
+    if j, e := gjson.LoadContent(data, unsafe...); e == nil {
        return &Parser{j}, nil
    } else {
        return nil, e
    }
 }

-// 设置自定义的层级分隔符号
+// SetSplitChar sets the separator char for hierarchical data access.
 func (p *Parser) SetSplitChar(char byte) {
    p.json.SetSplitChar(char)
 }

-// 设置是否执行层级冲突检查，当键名中存在层级符号时需要开启该特性，默认为关闭。
-// 开启比较耗性能，也不建议允许键名中存在分隔符，最好在应用端避免这种情况。
+// SetViolenceCheck enables/disables violence check for hierarchical data access.
 func (p *Parser) SetViolenceCheck(check bool) {
    p.json.SetViolenceCheck(check)
 }

-// 将指定的json内容转换为指定结构返回，查找失败或者转换失败，目标对象转换为nil
-// 注意第二个参数需要给的是变量地址
+// GetToVar gets the value by specified <pattern>,
+// and converts it to specified golang variable <v>.
+// The <v> should be a pointer type.
 func (p *Parser) GetToVar(pattern string, v interface{}) error {
    return p.json.GetToVar(pattern, v)
 }

-// 获得一个键值对关联数组/哈希表，方便操作，不需要自己做类型转换
-// 注意，如果获取的值不存在，或者类型与json类型不匹配，那么将会返回nil
+// GetMap gets the value by specified <pattern>,
+// and converts it to map[string]interface{}.
 func (p *Parser) GetMap(pattern string) map[string]interface{} {
    return p.json.GetMap(pattern)
 }

-// 获得一个数组[]interface{}，方便操作，不需要自己做类型转换
-// 注意，如果获取的值不存在，或者类型与json类型不匹配，那么将会返回nil
+// GetArray gets the value by specified <pattern>,
+// and converts it to a slice of []interface{}.
 func (p *Parser) GetArray(pattern string) []interface{} {
    return p.json.GetArray(pattern)
 }

-// 返回指定json中的string
+// GetString gets the value by specified <pattern>,
+// and converts it to string.
 func (p *Parser) GetString(pattern string) string {
    return p.json.GetString(pattern)
 }

+// GetStrings gets the value by specified <pattern>,
+// and converts it to a slice of []string.
 func (p *Parser) GetStrings(pattern string) []string {
    return p.json.GetStrings(pattern)
 }
@ -97,7 +107,10 @@ func (p *Parser) GetTimeDuration(pattern string) time.Duration {
    return p.json.GetTimeDuration(pattern)
 }

-// 返回指定json中的bool(false:"", 0, false, off)
+// GetBool gets the value by specified <pattern>,
+// and converts it to bool.
+// It returns false when value is: "", 0, false, off, nil;
+// or returns true instead.
 func (p *Parser) GetBool(pattern string) bool {
    return p.json.GetBool(pattern)
 }
@ -158,51 +171,60 @@ func (p *Parser) GetFloats(pattern string) []float64 {
    return p.json.GetFloats(pattern)
 }

-// 将指定变量转换为struct对象(对象属性赋值)
+// GetToStruct gets the value by specified <pattern>,
+// and converts it to specified object <objPointer>.
+// The <objPointer> should be the pointer to an object.
 func (p *Parser) GetToStruct(pattern string, objPointer interface{}) error {
    return p.json.GetToStruct(pattern, objPointer)
 }

-// 根据pattern查找并设置数据
-// 注意：写入的时候"."符号只能表示层级，不能使用带"."符号的键名
+// Set sets value with specified <pattern>.
+// It supports hierarchical data access by char separator, which is '.' in default.
 func (p *Parser) Set(pattern string, value interface{}) error {
    return p.json.Set(pattern, value)
 }

-// 计算指定pattern的元素长度(pattern对应数据类型为map[string]interface{}/[]interface{}时有效)
+// Len returns the length/size of the value by specified <pattern>.
+// The target value by <pattern> should be type of slice or map.
+// It returns -1 if the target value is not found, or its type is invalid.
 func (p *Parser) Len(pattern string) int {
    return p.json.Len(pattern)
 }

-// 指定pattern追加元素
+// Append appends value to the value by specified <pattern>.
+// The target value by <pattern> should be type of slice.
 func (p *Parser) Append(pattern string, value interface{}) error {
    return p.json.Append(pattern, value)
 }

-// 动态删除变量节点
+// Remove deletes value with specified <pattern>.
+// It supports hierarchical data access by char separator, which is '.' in default.
 func (p *Parser) Remove(pattern string) error {
    return p.json.Remove(pattern)
 }

-// 根据约定字符串方式访问json解析数据，参数形如： "items.name.first", "list.0"; 当pattern为空时，表示获取所有数据
-// 返回的结果类型的interface{}，因此需要自己做类型转换;
-// 如果找不到对应节点的数据，返回nil;
+// Get returns value by specified <pattern>.
+// It returns all values of current Json object, if <pattern> is empty or not specified.
+// It returns nil if no value found by <pattern>.
+//
+// We can also access slice item by its index number in <pattern>,
+// eg: "items.name.first", "list.10".
 func (p *Parser) Get(pattern...string) interface{} {
    return p.json.Get(pattern...)
 }

-// 转换为map[string]interface{}类型,如果转换失败，返回nil
+// ToMap converts current object values to map[string]interface{}.
+// It returns nil if fails.
 func (p *Parser) ToMap() map[string]interface{} {
    return p.json.ToMap()
 }

-// 转换为[]interface{}类型,如果转换失败，返回nil
+// ToArray converts current object values to []interface{}.
+// It returns nil if fails.
 func (p *Parser) ToArray() []interface{} {
    return p.json.ToArray()
 }

-/* 以下为数据文件格式转换，支持类型：xml, json, yaml/yml, toml */
-
 func (p *Parser) ToXml(rootTag...string) ([]byte, error) {
    return p.json.ToXml(rootTag...)
 }
@ -227,12 +249,13 @@ func (p *Parser) ToToml() ([]byte, error) {
    return p.json.ToToml()
 }

-// 打印Json对象
+// Dump prints current Json object with more manually readable.
 func (p *Parser) Dump() error {
    return p.json.Dump()
 }

-// 将变量解析为对应的struct对象，注意传递的参数为struct对象指针
+// ToStruct converts current Json object to specified object.
+// The <objPointer> should be a pointer type.
 func (p *Parser) ToStruct(o interface{}) error {
    return p.json.ToStruct(o)
 }
@ -261,7 +284,6 @@ func VarToToml(value interface{}) ([]byte, error) {
    return New(value).ToToml()
 }

-// 将变量解析为对应的struct对象，注意传递的参数为struct对象指针
 func VarToStruct(value interface{}, obj interface{}) error {
    return New(value).ToStruct(obj)
 }
--- a/g/encoding/gparser/gparser_unit_basic_test.go
+++ b/g/encoding/gparser/gparser_unit_basic_test.go
@ -0,0 +1,208 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gparser_test
+
+import (
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/encoding/gparser"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+func Test_New(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gparser.New(data)
+        gtest.Assert(j.Get("n"), "123456789")
+        gtest.Assert(j.Get("m"), g.Map{"k" : "v"})
+        gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+    })
+}
+
+func Test_NewUnsafe(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gparser.NewUnsafe(data)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+}
+
+func Test_Encode(t *testing.T) {
+    value := g.Slice{1, 2, 3}
+    gtest.Case(t, func() {
+        b, err := gparser.VarToJson(value)
+        gtest.Assert(err, nil)
+        gtest.Assert(b,   []byte(`[1,2,3]`))
+    })
+}
+
+func Test_Decode(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gparser.New(data)
+        gtest.AssertNE(j,          nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+}
+
+func Test_SplitChar(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gparser.New(data)
+        j.SetSplitChar(byte('#'))
+        gtest.AssertNE(j, nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m#k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a#1"), 2)
+    })
+}
+
+func Test_ViolenceCheck(t *testing.T) {
+    data := []byte(`{"m":{"a":[1,2,3], "v1.v2":"4"}}`)
+    gtest.Case(t, func() {
+        j := gparser.New(data)
+        gtest.AssertNE(j, nil)
+        gtest.Assert(j.Get("m.a.2"),   3)
+        gtest.Assert(j.Get("m.v1.v2"), nil)
+        j.SetViolenceCheck(true)
+        gtest.Assert(j.Get("m.v1.v2"), 4)
+    })
+}
+
+func Test_GetToVar(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        var m map[string]string
+        var n int
+        var a []int
+        j := gparser.New(data)
+        gtest.AssertNE(j, nil)
+
+        j.GetToVar("n", &n)
+        j.GetToVar("m", &m)
+        j.GetToVar("a", &a)
+
+        gtest.Assert(n, "123456789")
+        gtest.Assert(m, g.Map{"k" : "v"})
+        gtest.Assert(a, g.Slice{1, 2, 3})
+    })
+}
+
+func Test_GetMap(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gparser.New(data)
+        gtest.AssertNE(j, nil)
+        gtest.Assert(j.GetMap("n"), nil)
+        gtest.Assert(j.GetMap("m"), g.Map{"k" : "v"})
+        gtest.Assert(j.GetMap("a"), nil)
+    })
+}
+
+func Test_GetArray(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gparser.New(data)
+        gtest.AssertNE(j, nil)
+        gtest.Assert(j.GetArray("n"), g.Array{123456789})
+        gtest.Assert(j.GetArray("m"), g.Array{g.Map{"k":"v"}})
+        gtest.Assert(j.GetArray("a"), g.Array{1,2,3})
+    })
+}
+
+func Test_GetString(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gparser.New(data)
+        gtest.AssertNE(j, nil)
+        gtest.AssertEQ(j.GetString("n"), "123456789")
+        gtest.AssertEQ(j.GetString("m"), `{"k":"v"}`)
+        gtest.AssertEQ(j.GetString("a"), `[1,2,3]`)
+        gtest.AssertEQ(j.GetString("i"), "")
+    })
+}
+
+func Test_GetStrings(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gparser.New(data)
+        gtest.AssertNE(j, nil)
+        gtest.AssertEQ(j.GetStrings("n"), g.SliceStr{"123456789"})
+        gtest.AssertEQ(j.GetStrings("m"), g.SliceStr{`{"k":"v"}`})
+        gtest.AssertEQ(j.GetStrings("a"), g.SliceStr{"1", "2", "3"})
+        gtest.AssertEQ(j.GetStrings("i"), nil)
+    })
+}
+
+func Test_GetInterfaces(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gparser.New(data)
+        gtest.AssertNE(j, nil)
+        gtest.AssertEQ(j.GetInterfaces("n"), g.Array{123456789})
+        gtest.AssertEQ(j.GetInterfaces("m"), g.Array{g.Map{"k":"v"}})
+        gtest.AssertEQ(j.GetInterfaces("a"), g.Array{1,2,3})
+    })
+}
+
+func Test_Len(t *testing.T) {
+    gtest.Case(t, func() {
+        p := gparser.New(nil)
+        p.Append("a", 1)
+        p.Append("a", 2)
+        gtest.Assert(p.Len("a"), 2)
+    })
+    gtest.Case(t, func() {
+        p := gparser.New(nil)
+        p.Append("a.b", 1)
+        p.Append("a.c", 2)
+        gtest.Assert(p.Len("a"), 2)
+    })
+    gtest.Case(t, func() {
+        p := gparser.New(nil)
+        p.Set("a", 1)
+        gtest.Assert(p.Len("a"), -1)
+    })
+}
+
+func Test_Append(t *testing.T) {
+    gtest.Case(t, func() {
+        p := gparser.New(nil)
+        p.Append("a", 1)
+        p.Append("a", 2)
+        gtest.Assert(p.Get("a"), g.Slice{1, 2})
+    })
+    gtest.Case(t, func() {
+        p := gparser.New(nil)
+        p.Append("a.b", 1)
+        p.Append("a.c", 2)
+        gtest.Assert(p.Get("a"), g.Map{
+            "b" : g.Slice{1},
+            "c" : g.Slice{2},
+        })
+    })
+    gtest.Case(t, func() {
+        p := gparser.New(nil)
+        p.Set("a", 1)
+        err := p.Append("a", 2)
+        gtest.AssertNE(err, nil)
+        gtest.Assert(p.Get("a"), 1)
+    })
+}
+
+
+
--- a/g/encoding/gparser/gparser_unit_load_test.go
+++ b/g/encoding/gparser/gparser_unit_load_test.go
@ -0,0 +1,156 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gparser_test
+
+import (
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/encoding/gparser"
+    "github.com/gogf/gf/g/os/gfile"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+
+func Test_Load_JSON(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    // JSON
+    gtest.Case(t, func() {
+        j, err := gparser.LoadContent(data)
+        gtest.Assert(err,        nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+    // JSON
+    gtest.Case(t, func() {
+        path := "test.json"
+        gfile.PutBinContents(path, data)
+        defer gfile.Remove(path)
+        j, err := gparser.Load(path)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+}
+
+func Test_Load_XML(t *testing.T) {
+    data := []byte(`<doc><a>1</a><a>2</a><a>3</a><m><k>v</k></m><n>123456789</n></doc>`)
+    // XML
+    gtest.Case(t, func() {
+        j, err := gparser.LoadContent(data)
+        gtest.Assert(err, nil)
+        gtest.Assert(j.Get("doc.n"),   "123456789")
+        gtest.Assert(j.Get("doc.m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("doc.m.k"), "v")
+        gtest.Assert(j.Get("doc.a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("doc.a.1"), 2)
+    })
+    // XML
+    gtest.Case(t, func() {
+        path := "test.xml"
+        gfile.PutBinContents(path, data)
+        defer gfile.Remove(path)
+        j, err := gparser.Load(path)
+        gtest.Assert(err, nil)
+        gtest.Assert(j.Get("doc.n"),   "123456789")
+        gtest.Assert(j.Get("doc.m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("doc.m.k"), "v")
+        gtest.Assert(j.Get("doc.a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("doc.a.1"), 2)
+    })
+}
+
+func Test_Load_YAML1(t *testing.T) {
+    data := []byte(`
+a:
+- 1
+- 2
+- 3
+m:
+ k: v
+"n": 123456789
+    `)
+    // YAML
+    gtest.Case(t, func() {
+        j, err := gparser.LoadContent(data)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+    // YAML
+    gtest.Case(t, func() {
+        path := "test.yaml"
+        gfile.PutBinContents(path, data)
+        defer gfile.Remove(path)
+        j, err := gparser.Load(path)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+}
+
+func Test_Load_YAML2(t *testing.T) {
+    data := []byte("i : 123456789")
+    gtest.Case(t, func() {
+        j, err := gparser.LoadContent(data)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("i"),   "123456789")
+    })
+}
+
+func Test_Load_TOML1(t *testing.T) {
+    data := []byte(`
+a = ["1", "2", "3"]
+n = "123456789"
+
+[m]
+  k = "v"
+`)
+    // TOML
+    gtest.Case(t, func() {
+        j, err := gparser.LoadContent(data)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+    // TOML
+    gtest.Case(t, func() {
+        path := "test.toml"
+        gfile.PutBinContents(path, data)
+        defer gfile.Remove(path)
+        j, err := gparser.Load(path)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+}
+
+func Test_Load_TOML2(t *testing.T) {
+    data := []byte("i=123456789")
+    gtest.Case(t, func() {
+        j, err := gparser.LoadContent(data)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("i"),   "123456789")
+    })
+}
--- a/g/encoding/gparser/gparser_unit_set_test.go
+++ b/g/encoding/gparser/gparser_unit_set_test.go
@ -4,15 +4,12 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.

-// 单元测试
-
 package gparser_test

 import (
    "bytes"
-    "testing"
    "github.com/gogf/gf/g/encoding/gparser"
-    "fmt"
+    "testing"
 )

 func Test_Set1(t *testing.T) {
@ -23,7 +20,6 @@ func Test_Set1(t *testing.T) {
    })
    p.Set("k1.k11", []int{1,2,3})
    if c, err := p.ToJson(); err == nil {
-        fmt.Println(string(c))
        if bytes.Compare(c, []byte(`{"k1":{"k11":[1,2,3]},"k2":"v2"}`)) != 0 {
            t.Error("expect:", string(e))
        }
@ -37,7 +33,6 @@ func Test_Set2(t *testing.T) {
    p := gparser.New([]string{"a"})
    p.Set("0.1", 1)
    if c, err := p.ToJson(); err == nil {
-        fmt.Println(string(c))
        if bytes.Compare(c, e) != 0 {
            t.Error("expect:", string(e))
        }
@ -49,11 +44,10 @@ func Test_Set2(t *testing.T) {
 func Test_Set3(t *testing.T) {
    e := []byte(`{"kv":{"k1":"v1"}}`)
    p := gparser.New([]string{"a"})
-    p.Set("kv", map[string]string{
+    p.Set("kv", map[string]string {
        "k1" : "v1",
    })
    if c, err := p.ToJson(); err == nil {
-        fmt.Println(string(c))
        if bytes.Compare(c, e) != 0 {
            t.Error("expect:", string(e))
        }
@ -69,7 +63,6 @@ func Test_Set4(t *testing.T) {
        "k1" : "v1",
    })
    if c, err := p.ToJson(); err == nil {
-        fmt.Println(string(c))
        if bytes.Compare(c, e) != 0 {
            t.Error("expect:", string(e))
        }
@ -83,7 +76,6 @@ func Test_Set5(t *testing.T) {
    p := gparser.New([]string{"a"})
    p.Set("0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0", []int{1,2,3})
    if c, err := p.ToJson(); err == nil {
-        fmt.Println(string(c))
        if bytes.Compare(c, e) != 0 {
            t.Error("expect:", string(e))
        }
@ -97,7 +89,6 @@ func Test_Set6(t *testing.T) {
    p := gparser.New([]string{"a"})
    p.Set("1", []int{1,2,3})
    if c, err := p.ToJson(); err == nil {
-        fmt.Println(string(c))
        if bytes.Compare(c, e) != 0 {
            t.Error("expect:", string(e))
        }
@ -114,7 +105,6 @@ func Test_Set7(t *testing.T) {
    })
    p.Set("0.1", []int{1,2,3})
    if c, err := p.ToJson(); err == nil {
-        fmt.Println(string(c))
        if bytes.Compare(c, e) != 0 {
            t.Error("expect:", string(e))
        }
@ -131,7 +121,6 @@ func Test_Set8(t *testing.T) {
    })
    p.Set("0.0.0.0.0.0.1", []int{1,2,3})
    if c, err := p.ToJson(); err == nil {
-        fmt.Println(string(c))
        if bytes.Compare(c, e) != 0 {
            t.Error("expect:", string(e))
        }
@ -148,7 +137,6 @@ func Test_Set9(t *testing.T) {
    })
    p.Set("k1.1", []int{1,2,3})
    if c, err := p.ToJson(); err == nil {
-        fmt.Println(string(c))
        if bytes.Compare(c, e) != 0 {
            t.Error("expect:", string(e))
        }
@ -163,7 +151,6 @@ func Test_Set10(t *testing.T) {
    p := gparser.New(nil)
    p.Set("a.b.c", 1)
    if c, err := p.ToJson(); err == nil {
-        fmt.Println(string(c))
        if bytes.Compare(c, e) != 0 {
            t.Error("expect:", string(e))
        }
@ -175,10 +162,9 @@ func Test_Set10(t *testing.T) {

 func Test_Set11(t *testing.T) {
    e    := []byte(`{"a":{"b":{}}}`)
-    p, _ := gparser.LoadContent([]byte(`{"a":{"b":{"c":1}}}`), "json")
+    p, _ := gparser.LoadContent([]byte(`{"a":{"b":{"c":1}}}`))
    p.Remove("a.b.c")
    if c, err := p.ToJson(); err == nil {
-        fmt.Println(string(c))
        if bytes.Compare(c, e) != 0 {
            t.Error("expect:", string(e))
        }
@ -193,7 +179,6 @@ func Test_Set12(t *testing.T) {
    p.Set("0", 0)
    p.Set("1", 1)
    if c, err := p.ToJson(); err == nil {
-        fmt.Println(string(c))
        if bytes.Compare(c, e) != 0 {
            t.Error("expect:", string(e))
        }
@ -208,7 +193,6 @@ func Test_Set13(t *testing.T) {
    p.Set("array.0", 0)
    p.Set("array.1", 1)
    if c, err := p.ToJson(); err == nil {
-        fmt.Println(string(c))
        if bytes.Compare(c, e) != 0 {
            t.Error("expect:", string(e))
        }
@ -217,7 +201,16 @@ func Test_Set13(t *testing.T) {
    }
 }

-
-
-
-
+func Test_Set14(t *testing.T) {
+    e := []byte(`{"f":{"a":1}}`)
+    p := gparser.New(nil)
+    p.Set("f",   "m")
+    p.Set("f.a", 1)
+    if c, err := p.ToJson(); err == nil {
+        if bytes.Compare(c, e) != 0 {
+            t.Error("expect:", string(e))
+        }
+    } else {
+        t.Error(err)
+    }
+}
--- a/g/encoding/gxml/gxml.go
+++ b/g/encoding/gxml/gxml.go
@ -5,75 +5,80 @@
 // You can obtain one at https://github.com/gogf/gf.

 // Package gxml provides accessing and converting for XML content.
+//
+// XML数据格式解析。
 package gxml

 import (
-    "github.com/gogf/gf/third/github.com/clbanning/mxj"
-    "encoding/xml"
-    "io"
+	"fmt"
 	"github.com/gogf/gf/g/text/gregex"
 	"github.com/gogf/gf/third/github.com/axgle/mahonia"
-	"errors"
-	"fmt"
+	"github.com/gogf/gf/third/github.com/clbanning/mxj"
 	"strings"
 )

 // 将XML内容解析为map变量
-func Decode(xmlbyte []byte) (map[string]interface{}, error) {
-    prepare(xmlbyte)
-    return mxj.NewMapXml(xmlbyte)
+func Decode(content []byte) (map[string]interface{}, error) {
+	res, err := convert(content)
+	if err != nil {
+		return nil, err
+	}
+	return mxj.NewMapXml(res)
 }

 // 将map变量解析为XML格式内容
-func Encode(v map[string]interface{}, rootTag...string) ([]byte, error) {
-    return mxj.Map(v).Xml(rootTag...)
+func Encode(v map[string]interface{}, rootTag ...string) ([]byte, error) {
+	return mxj.Map(v).Xml(rootTag...)
 }

-func EncodeWithIndent(v map[string]interface{}, rootTag...string) ([]byte, error) {
-    return mxj.Map(v).XmlIndent("", "\t", rootTag...)
+func EncodeWithIndent(v map[string]interface{}, rootTag ...string) ([]byte, error) {
+	return mxj.Map(v).XmlIndent("", "\t", rootTag...)
 }

 // XML格式内容直接转换为JSON格式内容
-func ToJson(xmlbyte []byte) ([]byte, error) {
-    prepare(xmlbyte)
-	mv, err := mxj.NewMapXml(xmlbyte)
+func ToJson(content []byte) ([]byte, error) {
+	res, err := convert(content)
+	if err != nil {
+		fmt.Println("convert error. ", err)
+		return nil, err
+	}
+
+	mv, err := mxj.NewMapXml(res)
 	if err == nil {
-        return mv.Json()
-    } else {
-        return nil, err
-    }
+		return mv.Json()
+	} else {
+		return nil, err
+	}
 }

 // XML字符集预处理
 // @author wenzi1
-// @date 20180604
-func prepare(xmlbyte []byte) error {
+// @date 20180604  修复并发安全问题,改为如果非UTF8字符集则先做字符集转换
+func convert(xmlbyte []byte) (res []byte, err error) {
 	patten := `<\?xml.*encoding\s*=\s*['|"](.*?)['|"].*\?>`
-	charsetReader := func(charset string, input io.Reader) (io.Reader, error) {
-		reader := mahonia.GetCharset(charset)
-		if reader == nil {
-			return nil, errors.New(fmt.Sprintf("not support charset:%s", charset))
-		}
-		return reader.NewDecoder().NewReader(input), nil
-	}
-
 	matchStr, err := gregex.MatchString(patten, string(xmlbyte))
 	if err != nil {
-		return err
+		return nil, err
 	}
-	
+
 	xmlEncode := "UTF-8"
 	if len(matchStr) == 2 {
-		xmlEncode = matchStr[1]	
+		xmlEncode = matchStr[1]
 	}

-	charset := mahonia.GetCharset(xmlEncode)
-	if charset == nil {
-		return errors.New(fmt.Sprintf("not support charset:%s", xmlEncode))
+	s := mahonia.GetCharset(xmlEncode)
+	if s == nil {
+		return nil, fmt.Errorf("not support charset:%s\n", xmlEncode)
 	}

-	if !strings.EqualFold(charset.Name, "UTF-8") {
-		mxj.CustomDecoder = &xml.Decoder{Strict : false, CharsetReader : charsetReader}
+	res, err = gregex.Replace(patten, []byte(""), []byte(xmlbyte))
+	if err != nil {
+		return nil, err
 	}
-	return nil
-}
+
+	if !strings.EqualFold(s.Name, "UTF-8") {
+		res = []byte(s.NewDecoder().ConvertString(string(res)))
+	}
+
+	return res, nil
+}
--- a/g/encoding/gxml/gxml_test.go
+++ b/g/encoding/gxml/gxml_test.go
@ -0,0 +1,140 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gxml_test
+
+import (
+	"bytes"
+	"github.com/gogf/gf/g/encoding/gcharset"
+	"github.com/gogf/gf/g/encoding/gparser"
+	"github.com/gogf/gf/g/encoding/gxml"
+	"strings"
+	"testing"
+)
+
+var testData = []struct {
+	utf8, other, otherEncoding string
+}{
+	{"Hello 常用國字標準字體表", "Hello \xb1`\xa5\u03b0\xea\xa6r\xbc\u0437\u01e6r\xc5\xe9\xaa\xed", "big5"},
+	{"Hello 常用國字標準字體表", "Hello \xb3\xa3\xd3\xc3\x87\xf8\xd7\xd6\x98\xcb\x9c\xca\xd7\xd6\xf3\x77\xb1\xed", "gbk"},
+	{"Hello 常用國字標準字體表", "Hello \xb3\xa3\xd3\xc3\x87\xf8\xd7\xd6\x98\xcb\x9c\xca\xd7\xd6\xf3\x77\xb1\xed", "gb18030"},
+}
+
+func buildXml(charset string, str string) (string, string) {
+	head := `<?xml version="1.0" encoding="UTF-8"?>`
+	srcXml := strings.Replace(head, "UTF-8", charset, -1)
+
+	srcParser := gparser.New(nil)
+	srcParser.Set("name", str)
+	srcParser.Set("age", "12")
+
+	s, err := srcParser.ToXml()
+	if err != nil {
+		return "", ""
+	}
+
+	srcXml = srcXml + string(s)
+	srcXml, err = gcharset.UTF8To(charset, srcXml)
+	if err != nil {
+		return "", ""
+	}
+
+	dstXml := head + string(s)
+
+	return srcXml, dstXml
+}
+
+//测试XML中字符集的转换
+func Test_XmlToJson(t *testing.T) {
+	for _, v := range testData {
+		srcXml, dstXml := buildXml(v.otherEncoding, v.utf8)
+		if len(srcXml) == 0 && len(dstXml) == 0 {
+			t.Errorf("build xml string error. srcEncoding:%s, src:%s, utf8:%s", v.otherEncoding, v.other, v.utf8)
+		}
+
+		srcJson, err := gxml.ToJson([]byte(srcXml))
+		if err != nil {
+			t.Errorf("gxml.ToJson error. %s", srcXml)
+		}
+
+		dstJson, err := gxml.ToJson([]byte(dstXml))
+		if err != nil {
+			t.Errorf("dstXml to json error. %s", dstXml)
+		}
+
+		if bytes.Compare(srcJson, dstJson) != 0 {
+			t.Errorf("convert to json error. srcJson:%s, dstJson:%s", string(srcJson), string(dstJson))
+		}
+
+	}
+}
+
+func Test_Decode(t *testing.T) {
+	for _, v := range testData {
+		srcXml, dstXml := buildXml(v.otherEncoding, v.utf8)
+		if len(srcXml) == 0 && len(dstXml) == 0 {
+			t.Errorf("build xml string error. srcEncoding:%s, src:%s, utf8:%s", v.otherEncoding, v.other, v.utf8)
+		}
+
+		srcMap, err := gxml.Decode([]byte(srcXml))
+		if err != nil {
+			t.Errorf("gxml.Decode error. %s", srcXml)
+		}
+
+		dstMap, err := gxml.Decode([]byte(dstXml))
+		if err != nil {
+			t.Errorf("gxml decode error. %s", dstXml)
+		}
+		s := srcMap["doc"].(map[string]interface{})
+		d := dstMap["doc"].(map[string]interface{})
+		for kk, vv := range s {
+			if vv.(string) != d[kk].(string) {
+				t.Errorf("convert to map error. src:%v, dst:%v", vv, d[kk])
+			}
+		}
+	}
+}
+
+func Test_Encode(t *testing.T) {
+	m := make(map[string]interface{})
+	v := map[string]interface{}{
+		"string": "hello world",
+		"int":    123,
+		"float":  100.92,
+		"bool":   true,
+	}
+	m["root"] = interface{}(v)
+
+	xmlStr, err := gxml.Encode(m)
+	if err != nil {
+		t.Errorf("encode error.")
+	}
+	t.Logf("%s\n", string(xmlStr))
+
+	res := `<root><bool>true</bool><float>100.92</float><int>123</int><string>hello world</string></root>`
+	if string(xmlStr) != res {
+		t.Errorf("encode error. result: [%s], expect:[%s]", string(xmlStr), res)
+	}
+}
+
+func Test_EncodeIndent(t *testing.T) {
+	m := make(map[string]interface{})
+	v := map[string]interface{}{
+		"string": "hello world",
+		"int":    123,
+		"float":  100.92,
+		"bool":   true,
+	}
+	m["root"] = interface{}(v)
+
+	xmlStr, err := gxml.EncodeWithIndent(m, "xml")
+	if err != nil {
+		t.Errorf("encodeWithIndent error.")
+	}
+
+	t.Logf("%s\n", string(xmlStr))
+
+}
--- a/g/frame/frame.go
+++ b/g/frame/frame.go
@ -1,7 +0,0 @@
-// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-package frame
--- a/g/frame/gins/gins.go
+++ b/g/frame/gins/gins.go
@ -4,30 +4,25 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.

-// Package gins provides instances management and some core components.
-// 
-// 单例对象管理.
-// 框架内置了一些核心对象获取方法，并且可以通过Set和Get方法实现IoC以及对内置核心对象的自定义替换
+// Package gins provides instances management and core components management.
 package gins

 import (
-    "fmt"
-    "github.com/gogf/gf/g/container/gmap"
-    "github.com/gogf/gf/g/database/gdb"
-    "github.com/gogf/gf/g/database/gredis"
-    "github.com/gogf/gf/g/internal/cmdenv"
-    "github.com/gogf/gf/g/os/gcfg"
-    "github.com/gogf/gf/g/os/gfile"
-    "github.com/gogf/gf/g/os/gfsnotify"
-    "github.com/gogf/gf/g/os/glog"
-    "github.com/gogf/gf/g/os/gview"
-    "github.com/gogf/gf/g/util/gconv"
-    "github.com/gogf/gf/g/text/gregex"
+	"fmt"
+	"github.com/gogf/gf/g/container/gmap"
+	"github.com/gogf/gf/g/database/gdb"
+	"github.com/gogf/gf/g/database/gredis"
+	"github.com/gogf/gf/g/os/gcfg"
+	"github.com/gogf/gf/g/os/gfsnotify"
+	"github.com/gogf/gf/g/os/glog"
+	"github.com/gogf/gf/g/os/gview"
+	"github.com/gogf/gf/g/text/gregex"
+	"github.com/gogf/gf/g/text/gstr"
+	"github.com/gogf/gf/g/util/gconv"
+	"time"
 )

 const (
-    gFRAME_CORE_COMPONENT_NAME_VIEW       = "gf.core.component.view"
-    gFRAME_CORE_COMPONENT_NAME_CONFIG     = "gf.core.component.config"
    gFRAME_CORE_COMPONENT_NAME_REDIS      = "gf.core.component.redis"
    gFRAME_CORE_COMPONENT_NAME_DATABASE   = "gf.core.component.database"
 )
@ -65,47 +60,20 @@ func SetIfNotExist(key string, value interface{}) bool {
    return instances.SetIfNotExist(key, value)
 }

-// 核心对象：View
-func View(name...string) *gview.View {
-    group := "default"
-    if len(name) > 0 {
-        group = name[0]
-    }
-    key := fmt.Sprintf("%s.%s", gFRAME_CORE_COMPONENT_NAME_VIEW, group)
-    return instances.GetOrSetFuncLock(key, func() interface{} {
-        path := cmdenv.Get("gf.gview.path", gfile.SelfDir()).String()
-        view := gview.New(path)
-        // 添加基于源码的搜索目录检索地址，常用于开发环境调试，只添加入口文件目录
-        if p := gfile.MainPkgPath(); p != "" && gfile.Exists(p) {
-            view.AddPath(p)
-        }
-        // 框架内置函数
-        view.BindFunc("config", funcConfig)
-        return view
-    }).(*gview.View)
+// View returns an instance of View with default settings.
+// The param <name> is the name for the instance.
+func View(name ...string) *gview.View {
+	return gview.Instance(name ...)
 }

-// 核心对象：Config
-// 配置文件目录查找依次为：启动参数cfgpath、当前程序运行目录
-func Config(file...string) *gcfg.Config {
-    configFile := gcfg.DEFAULT_CONFIG_FILE
-    if len(file) > 0 {
-        configFile = file[0]
-    }
-    return instances.GetOrSetFuncLock(fmt.Sprintf("%s.%s", gFRAME_CORE_COMPONENT_NAME_CONFIG, configFile),
-        func() interface{} {
-            path   := cmdenv.Get("gf.gcfg.path", gfile.SelfDir()).String()
-            config := gcfg.New(path, configFile)
-            // 添加基于源码的搜索目录检索地址，常用于开发环境调试，只添加入口文件目录
-            if p := gfile.MainPkgPath(); p != "" && gfile.Exists(p) {
-                config.AddPath(p)
-            }
-            return config
-    }).(*gcfg.Config)
+// Config returns an instance of View with default settings.
+// The param <name> is the name for the instance.
+func Config(name ...string) *gcfg.Config {
+    return gcfg.Instance(name ...)
 }

 // 数据库操作对象，使用了连接池
-func Database(name...string) gdb.DB {
+func Database(name ...string) gdb.DB {
    config := Config()
    group  := gdb.DEFAULT_GROUP_NAME
    if len(name) > 0 {
@ -122,46 +90,66 @@ func Database(name...string) gdb.DB {
            for group, v := range m {
                cg := gdb.ConfigGroup{}
                if list, ok := v.([]interface{}); ok {
-                    for _, nodev := range list {
-                        node  := gdb.ConfigNode{}
-                        nodem := nodev.(map[string]interface{})
-                        if value, ok := nodem["host"]; ok {
+                    for _, nodeValue := range list {
+                        node    := gdb.ConfigNode{}
+                        nodeMap := nodeValue.(map[string]interface{})
+                        if value, ok := nodeMap["host"]; ok {
                            node.Host = gconv.String(value)
                        }
-                        if value, ok := nodem["port"]; ok {
+                        if value, ok := nodeMap["port"]; ok {
                            node.Port = gconv.String(value)
                        }
-                        if value, ok := nodem["user"]; ok {
+                        if value, ok := nodeMap["user"]; ok {
                            node.User = gconv.String(value)
                        }
-                        if value, ok := nodem["pass"]; ok {
+                        if value, ok := nodeMap["pass"]; ok {
                            node.Pass = gconv.String(value)
                        }
-                        if value, ok := nodem["name"]; ok {
+                        if value, ok := nodeMap["name"]; ok {
                            node.Name = gconv.String(value)
                        }
-                        if value, ok := nodem["type"]; ok {
+                        if value, ok := nodeMap["type"]; ok {
                            node.Type = gconv.String(value)
                        }
-                        if value, ok := nodem["role"]; ok {
+                        if value, ok := nodeMap["role"]; ok {
                            node.Role = gconv.String(value)
                        }
-                        if value, ok := nodem["charset"]; ok {
+                        if value, ok := nodeMap["charset"]; ok {
                            node.Charset = gconv.String(value)
                        }
-                        if value, ok := nodem["priority"]; ok {
+                        if value, ok := nodeMap["priority"]; ok {
                            node.Priority = gconv.Int(value)
                        }
-                        if value, ok := nodem["linkinfo"]; ok {
-                            node.Linkinfo = gconv.String(value)
+                        // Deprecated
+                        if value, ok := nodeMap["linkinfo"]; ok {
+                            node.LinkInfo = gconv.String(value)
                        }
-                        if value, ok := nodem["max-idle"]; ok {
+                        // Deprecated
+                        if value, ok := nodeMap["link-info"]; ok {
+                            node.LinkInfo = gconv.String(value)
+                        }
+                        if value, ok := nodeMap["linkInfo"]; ok {
+                            node.LinkInfo = gconv.String(value)
+                        }
+                        // Deprecated
+                        if value, ok := nodeMap["max-idle"]; ok {
                            node.MaxIdleConnCount = gconv.Int(value)
                        }
-                        if value, ok := nodem["max-open"]; ok {
+                        if value, ok := nodeMap["maxIdle"]; ok {
+                            node.MaxIdleConnCount = gconv.Int(value)
+                        }
+                        // Deprecated
+                        if value, ok := nodeMap["max-open"]; ok {
                            node.MaxOpenConnCount = gconv.Int(value)
                        }
-                        if value, ok := nodem["max-lifetime"]; ok {
+                        if value, ok := nodeMap["maxOpen"]; ok {
+                            node.MaxOpenConnCount = gconv.Int(value)
+                        }
+                        // Deprecated
+                        if value, ok := nodeMap["max-lifetime"]; ok {
+                            node.MaxConnLifetime = gconv.Int(value)
+                        }
+                        if value, ok := nodeMap["maxLifetime"]; ok {
                            node.MaxConnLifetime = gconv.Int(value)
                        }
                        cg = append(cg, node)
@ -169,10 +157,7 @@ func Database(name...string) gdb.DB {
                }
                gdb.AddConfigGroup(group, cg)
            }
-            // 使用gfsnotify进行文件监控，当配置文件有任何变化时，清空数据库配置缓存
-            gfsnotify.Add(config.GetFilePath(), func(event *gfsnotify.Event) {
-                instances.Remove(key)
-            })
+            addConfigMonitor(key, config)
        }
        if db, err := gdb.New(name...); err == nil {
            return db
@ -197,11 +182,36 @@ func Redis(name...string) *gredis.Redis {
    key    := fmt.Sprintf("%s.%s", gFRAME_CORE_COMPONENT_NAME_REDIS, group)
    result := instances.GetOrSetFuncLock(key, func() interface{} {
        if m := config.GetMap("redis"); m != nil {
-            // host:port[,db[,pass]]
+            // host:port[,db,pass?maxIdle=x&maxActive=x&idleTimeout=x&maxConnLifetime=x]
            if v, ok := m[group]; ok {
-                line     := gconv.String(v)
-                array, _ := gregex.MatchString(`(.+):(\d+),{0,1}(\d*),{0,1}(.*)`, line)
-                if len(array) > 4 {
+                line := gconv.String(v)
+                array, _ := gregex.MatchString(`(.+):(\d+),{0,1}(\d*),{0,1}(.*)\?(.+)`, line)
+                if len(array) == 6 {
+                    parse, _    := gstr.Parse(array[5])
+                    redisConfig := gredis.Config{
+                        Host : array[1],
+                        Port : gconv.Int(array[2]),
+                        Db   : gconv.Int(array[3]),
+                        Pass : array[4],
+                    }
+                    if v, ok := parse["maxIdle"]; ok {
+                        redisConfig.MaxIdle = gconv.Int(v)
+                    }
+                    if v, ok := parse["maxActive"]; ok {
+                        redisConfig.MaxActive = gconv.Int(v)
+                    }
+                    if v, ok := parse["idleTimeout"]; ok {
+                        redisConfig.IdleTimeout = gconv.TimeDuration(v)*time.Second
+                    }
+                    if v, ok := parse["maxConnLifetime"]; ok {
+                        redisConfig.MaxConnLifetime = gconv.TimeDuration(v)*time.Second
+                    }
+                    addConfigMonitor(key, config)
+                    return gredis.New(redisConfig)
+                }
+                array, _ = gregex.MatchString(`(.+):(\d+),{0,1}(\d*),{0,1}(.*)`, line)
+                if len(array) == 5 {
+                    addConfigMonitor(key, config)
                    return gredis.New(gredis.Config{
                        Host : array[1],
                        Port : gconv.Int(array[2]),
@ -225,6 +235,16 @@ func Redis(name...string) *gredis.Redis {
    return nil
 }

+// 添加对单例对象的配置文件inotify监控
+func addConfigMonitor(key string, config *gcfg.Config) {
+    // 使用gfsnotify进行文件监控，当配置文件有任何变化时，清空对象单例缓存
+    if path := config.GetFilePath(); path != "" {
+        gfsnotify.Add(path, func(event *gfsnotify.Event) {
+            instances.Remove(key)
+        })
+    }
+}
+
 // 模板内置方法：config
 func funcConfig(pattern string, file...string) string {
    return Config().GetString(pattern, file...)
--- a/g/frame/gins/gins_basic_test.go
+++ b/g/frame/gins/gins_basic_test.go
@ -0,0 +1,43 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gins_test
+
+import (
+    "github.com/gogf/gf/g/frame/gins"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+func Test_SetGet(t *testing.T) {
+    gtest.Case(t, func() {
+        gins.Set("test-user", 1)
+        gtest.Assert(gins.Get("test-user"),   1)
+        gtest.Assert(gins.Get("none-exists"), nil)
+    })
+    gtest.Case(t, func() {
+        gtest.Assert(gins.GetOrSet("test-1", 1), 1)
+        gtest.Assert(gins.Get("test-1"), 1)
+    })
+    gtest.Case(t, func() {
+        gtest.Assert(gins.GetOrSetFunc("test-2", func() interface{} {
+            return 2
+        }), 2)
+        gtest.Assert(gins.Get("test-2"), 2)
+    })
+    gtest.Case(t, func() {
+        gtest.Assert(gins.GetOrSetFuncLock("test-3", func() interface{} {
+            return 3
+        }), 3)
+        gtest.Assert(gins.Get("test-3"), 3)
+    })
+    gtest.Case(t, func() {
+        gtest.Assert(gins.SetIfNotExist("test-4", 4), true)
+        gtest.Assert(gins.Get("test-4"), 4)
+        gtest.Assert(gins.SetIfNotExist("test-4", 5), false)
+        gtest.Assert(gins.Get("test-4"), 4)
+    })
+}
--- a/g/frame/gins/gins_config_test.go
+++ b/g/frame/gins/gins_config_test.go
@ -0,0 +1,169 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gins_test
+
+import (
+	"fmt"
+	"github.com/gogf/gf/g/frame/gins"
+	"github.com/gogf/gf/g/os/gfile"
+	"github.com/gogf/gf/g/os/gtime"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
+	"time"
+)
+
+func Test_Config(t *testing.T) {
+    config := `
+# 模板引擎目录
+viewpath = "/home/www/templates/"
+test = "v=1"
+# MySQL数据库配置
+[database]
+    [[database.default]]
+        host     = "127.0.0.1"
+        port     = "3306"
+        user     = "root"
+        pass     = ""
+        name     = "test"
+        type     = "mysql"
+        role     = "master"
+        charset  = "utf8"
+        priority = "1"
+    [[database.default]]
+        host     = "127.0.0.1"
+        port     = "3306"
+        user     = "root"
+        pass     = "8692651"
+        name     = "test"
+        type     = "mysql"
+        role     = "master"
+        charset  = "utf8"
+        priority = "1"
+# Redis数据库配置
+[redis]
+    disk  = "127.0.0.1:6379,0"
+    cache = "127.0.0.1:6379,1"
+`
+    gtest.Case(t, func() {
+        gtest.AssertNE(gins.Config(), nil)
+    })
+
+    // relative path
+    gtest.Case(t, func() {
+        path := "config.toml"
+        err  := gfile.PutContents(path, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(path)
+        defer gins.Config().Clear()
+        gtest.Assert(gins.Config().Get("test"), "v=1")
+        gtest.Assert(gins.Config().Get("database.default.1.host"), "127.0.0.1")
+        gtest.Assert(gins.Config().Get("redis.disk"), "127.0.0.1:6379,0")
+    })
+    // for gfsnotify callbacks to refresh cache of config file
+    time.Sleep(500*time.Millisecond)
+
+    // relative path, config folder
+    gtest.Case(t, func() {
+        path := "config/config.toml"
+        err  := gfile.PutContents(path, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(path)
+        defer gins.Config().Clear()
+        gtest.Assert(gins.Config().Get("test"), "v=1")
+        gtest.Assert(gins.Config().Get("database.default.1.host"), "127.0.0.1")
+        gtest.Assert(gins.Config().Get("redis.disk"), "127.0.0.1:6379,0")
+    })
+    // for gfsnotify callbacks to refresh cache of config file
+    time.Sleep(500*time.Millisecond)
+
+    gtest.Case(t, func() {
+        path := "test.toml"
+        err  := gfile.PutContents(path, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(path)
+        defer gins.Config("test").Clear()
+	    gins.Config("test").SetFileName("test.toml")
+        gtest.Assert(gins.Config("test").Get("test"), "v=1")
+        gtest.Assert(gins.Config("test").Get("database.default.1.host"), "127.0.0.1")
+        gtest.Assert(gins.Config("test").Get("redis.disk"), "127.0.0.1:6379,0")
+    })
+    // for gfsnotify callbacks to refresh cache of config file
+    time.Sleep(500*time.Millisecond)
+
+    gtest.Case(t, func() {
+        path := "config/test.toml"
+        err  := gfile.PutContents(path, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(path)
+        defer gins.Config("test").Clear()
+	    gins.Config("test").SetFileName("test.toml")
+        gtest.Assert(gins.Config("test").Get("test"), "v=1")
+        gtest.Assert(gins.Config("test").Get("database.default.1.host"), "127.0.0.1")
+        gtest.Assert(gins.Config("test").Get("redis.disk"), "127.0.0.1:6379,0")
+    })
+    // for gfsnotify callbacks to refresh cache of config file
+    time.Sleep(500*time.Millisecond)
+
+
+    // absolute path
+    gtest.Case(t, func() {
+        path := fmt.Sprintf(`%s/%d`, gfile.TempDir(), gtime.Nanosecond())
+        file := fmt.Sprintf(`%s/%s`, path, "config.toml")
+        err  := gfile.PutContents(file, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(file)
+        defer gins.Config().Clear()
+        gtest.Assert(gins.Config().AddPath(path), nil)
+        gtest.Assert(gins.Config().Get("test"),   "v=1")
+        gtest.Assert(gins.Config().Get("database.default.1.host"), "127.0.0.1")
+        gtest.Assert(gins.Config().Get("redis.disk"), "127.0.0.1:6379,0")
+    })
+    time.Sleep(500*time.Millisecond)
+
+    gtest.Case(t, func() {
+        path := fmt.Sprintf(`%s/%d/config`, gfile.TempDir(), gtime.Nanosecond())
+        file := fmt.Sprintf(`%s/%s`, path, "config.toml")
+        err  := gfile.PutContents(file, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(file)
+        defer gins.Config().Clear()
+        gtest.Assert(gins.Config().AddPath(path), nil)
+        gtest.Assert(gins.Config().Get("test"),   "v=1")
+        gtest.Assert(gins.Config().Get("database.default.1.host"), "127.0.0.1")
+        gtest.Assert(gins.Config().Get("redis.disk"), "127.0.0.1:6379,0")
+    })
+    time.Sleep(500*time.Millisecond)
+
+    gtest.Case(t, func() {
+        path := fmt.Sprintf(`%s/%d`, gfile.TempDir(), gtime.Nanosecond())
+        file := fmt.Sprintf(`%s/%s`, path, "test.toml")
+        err  := gfile.PutContents(file, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(file)
+        defer gins.Config("test").Clear()
+	    gins.Config("test").SetFileName("test.toml")
+        gtest.Assert(gins.Config("test").AddPath(path), nil)
+        gtest.Assert(gins.Config("test").Get("test"),   "v=1")
+        gtest.Assert(gins.Config("test").Get("database.default.1.host"), "127.0.0.1")
+        gtest.Assert(gins.Config("test").Get("redis.disk"), "127.0.0.1:6379,0")
+    })
+    time.Sleep(500*time.Millisecond)
+
+    gtest.Case(t, func() {
+        path := fmt.Sprintf(`%s/%d/config`, gfile.TempDir(), gtime.Nanosecond())
+        file := fmt.Sprintf(`%s/%s`, path, "test.toml")
+        err  := gfile.PutContents(file, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(file)
+        defer gins.Config().Clear()
+	    gins.Config("test").SetFileName("test.toml")
+        gtest.Assert(gins.Config("test").AddPath(path), nil)
+        gtest.Assert(gins.Config("test").Get("test"),   "v=1")
+        gtest.Assert(gins.Config("test").Get("database.default.1.host"), "127.0.0.1")
+        gtest.Assert(gins.Config("test").Get("redis.disk"), "127.0.0.1:6379,0")
+    })
+}
--- a/g/frame/gins/gins_database_test.go
+++ b/g/frame/gins/gins_database_test.go
@ -0,0 +1,75 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gins_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g/frame/gins"
+    "github.com/gogf/gf/g/os/gfile"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+func Test_Database(t *testing.T) {
+    config := `
+# 模板引擎目录
+viewpath = "/home/www/templates/"
+test = "v=2"
+# MySQL数据库配置
+[database]
+    [[database.default]]
+        host     = "127.0.0.1"
+        port     = "3306"
+        user     = "root"
+        pass     = ""
+        # pass     = "12345678"
+        name     = "test"
+        type     = "mysql"
+        role     = "master"
+        charset  = "utf8"
+        priority = "1"
+    [[database.test]]
+        host     = "127.0.0.1"
+        port     = "3306"
+        user     = "root"
+        pass     = ""
+        # pass     = "12345678"
+        name     = "test"
+        type     = "mysql"
+        role     = "master"
+        charset  = "utf8"
+        priority = "1"
+# Redis数据库配置
+[redis]
+    default = "127.0.0.1:6379,0"
+    cache = "127.0.0.1:6379,1"
+`
+    path := "config.toml"
+    err  := gfile.PutContents(path, config)
+    gtest.Assert(err, nil)
+    defer gfile.Remove(path)
+    defer gins.Config().Clear()
+
+    // for gfsnotify callbacks to refresh cache of config file
+    time.Sleep(500*time.Millisecond)
+
+    gtest.Case(t, func() {
+        fmt.Println("gins Test_Database", gins.Config().Get("test"))
+
+        dbDefault := gins.Database()
+        dbTest    := gins.Database("test")
+        gtest.AssertNE(dbDefault, nil)
+        gtest.AssertNE(dbTest,    nil)
+
+        gtest.Assert(dbDefault.PingMaster(), nil)
+        gtest.Assert(dbDefault.PingSlave(),  nil)
+        gtest.Assert(dbTest.PingMaster(),    nil)
+        gtest.Assert(dbTest.PingSlave(),     nil)
+    })
+}
+
--- a/g/frame/gins/gins_redis_test.go
+++ b/g/frame/gins/gins_redis_test.go
@ -0,0 +1,86 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gins_test
+
+import (
+    "github.com/gogf/gf/g/frame/gins"
+    "github.com/gogf/gf/g/os/gfile"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+func Test_Redis(t *testing.T) {
+    config := `
+# 模板引擎目录
+viewpath = "/home/www/templates/"
+test = "v=3"
+# MySQL数据库配置
+[database]
+    [[database.default]]
+        host     = "127.0.0.1"
+        port     = "3306"
+        user     = "root"
+        pass     = ""
+        # pass     = "12345678"
+        name     = "test"
+        type     = "mysql"
+        role     = "master"
+        charset  = "utf8"
+        priority = "1"
+    [[database.test]]
+        host     = "127.0.0.1"
+        port     = "3306"
+        user     = "root"
+        pass     = ""
+        # pass     = "12345678"
+        name     = "test"
+        type     = "mysql"
+        role     = "master"
+        charset  = "utf8"
+        priority = "1"
+# Redis数据库配置
+[redis]
+    default = "127.0.0.1:6379,7"
+    cache   = "127.0.0.1:6379,8"
+    disk    = "127.0.0.1:6379,9,?maxIdle=1&maxActive=10&idleTimeout=10&maxConnLifetime=10"
+`
+    path := "config.toml"
+    err  := gfile.PutContents(path, config)
+    gtest.Assert(err, nil)
+    defer gfile.Remove(path)
+    defer gins.Config().Clear()
+
+    // for gfsnotify callbacks to refresh cache of config file
+    time.Sleep(500*time.Millisecond)
+
+    gtest.Case(t, func() {
+        //fmt.Println("gins Test_Redis", gins.Config().Get("test"))
+
+        redisDefault := gins.Redis()
+        redisCache   := gins.Redis("cache")
+        redisDisk    := gins.Redis("disk")
+        gtest.AssertNE(redisDefault, nil)
+        gtest.AssertNE(redisCache,   nil)
+        gtest.AssertNE(redisDisk,   nil)
+
+        r, err := redisDefault.Do("PING")
+        gtest.Assert(err, nil)
+        gtest.Assert(r,   "PONG")
+
+        r, err  = redisCache.Do("PING")
+        gtest.Assert(err, nil)
+        gtest.Assert(r,   "PONG")
+
+        _, err  = redisDisk.Do("SET", "k", "v")
+        gtest.Assert(err, nil)
+        r, err  = redisDisk.Do("GET", "k")
+        gtest.Assert(err, nil)
+        gtest.Assert(r, []byte("v"))
+    })
+}
+
--- a/g/frame/gins/gins_view_test.go
+++ b/g/frame/gins/gins_view_test.go
@ -0,0 +1,49 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gins_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g/frame/gins"
+    "github.com/gogf/gf/g/os/gfile"
+    "github.com/gogf/gf/g/os/gtime"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+func Test_View(t *testing.T) {
+    gtest.Case(t, func() {
+        gtest.AssertNE(gins.View(), nil)
+        b, e := gins.View().ParseContent(`{{"我是中国人" | substr 2 -1}}`, nil)
+        gtest.Assert(e,         nil)
+        gtest.Assert(string(b), "中国人")
+    })
+    gtest.Case(t, func() {
+        tpl := "t.tpl"
+        err := gfile.PutContents(tpl, `{{"我是中国人" | substr 2 -1}}`)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(tpl)
+
+        b, e := gins.View().Parse("t.tpl", nil)
+        gtest.Assert(e,         nil)
+        gtest.Assert(string(b), "中国人")
+    })
+    gtest.Case(t, func() {
+        path := fmt.Sprintf(`%s/%d`, gfile.TempDir(), gtime.Nanosecond())
+        tpl  := fmt.Sprintf(`%s/%s`, path, "t.tpl")
+        err  := gfile.PutContents(tpl, `{{"我是中国人" | substr 2 -1}}`)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(tpl)
+        err = gins.View().AddPath(path)
+        gtest.Assert(err, nil)
+
+        b, e := gins.View().Parse("t.tpl", nil)
+        gtest.Assert(e,         nil)
+        gtest.Assert(string(b), "中国人")
+    })
+}
+
--- a/g/g.go
+++ b/g/g.go
@ -3,34 +3,43 @@
 // This Source Code Form is subject to the terms of the MIT License.
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
-// 常用数据类型以及对象封装

 package g

 import "github.com/gogf/gf/g/container/gvar"

-// 框架动态变量，可以用该类型替代interface{}类型
-type Var       = gvar.Var
+// Universal variable type, like generics.
+type Var        = gvar.Var

-// 常用map数据结构(使用别名)
+// Frequently-used map type alias.
 type Map        = map[string]interface{}
+type MapAnyAny  = map[interface{}]interface{}
+type MapAnyStr  = map[interface{}]string
+type MapAnyInt  = map[interface{}]int
+type MapStrAny  = map[string]interface{}
 type MapStrStr  = map[string]string
 type MapStrInt  = map[string]int
+type MapIntAny  = map[int]interface{}
 type MapIntStr  = map[int]string
 type MapIntInt  = map[int]int

-// 常用list数据结构(使用别名)
+// Frequently-used slice type alias.
 type List       = []Map
+type ListAnyStr = []map[interface{}]string
+type ListAnyInt = []map[interface{}]int
+type ListStrAny = []map[string]interface{}
 type ListStrStr = []map[string]string
 type ListStrInt = []map[string]int
+type ListIntAny = []map[int]interface{}
 type ListIntStr = []map[int]string
 type ListIntInt = []map[int]int

-
-// 常用slice数据结构(使用别名)
+// Frequently-used slice type alias.
 type Slice      = []interface{}
+type SliceAny   = []interface{}
 type SliceStr   = []string
 type SliceInt   = []int
-type Array      = Slice
-type ArrayStr   = SliceStr
-type ArrayInt   = SliceInt
+type Array      = []interface{}
+type ArrayAny   = []interface{}
+type ArrayStr   = []string
+type ArrayInt   = []int
--- a/g/g_func.go
+++ b/g/g_func.go
@ -7,43 +7,46 @@
 package g

 import (
+    "github.com/gogf/gf/g/container/gvar"
+    "github.com/gogf/gf/g/internal/empty"
    "github.com/gogf/gf/g/net/ghttp"
    "github.com/gogf/gf/g/util/gutil"
-    "github.com/gogf/gf/g/os/glog"
-    "github.com/gogf/gf/g/container/gvar"
 )

-const (
-    LOG_LEVEL_ALL  = glog.LEVEL_ALL
-    LOG_LEVEL_DEBU = glog.LEVEL_DEBU
-    LOG_LEVEL_INFO = glog.LEVEL_INFO
-    LOG_LEVEL_NOTI = glog.LEVEL_NOTI
-    LOG_LEVEL_WARN = glog.LEVEL_WARN
-    LOG_LEVEL_ERRO = glog.LEVEL_ERRO
-    LOG_LEVEL_CRIT = glog.LEVEL_CRIT
-)
-
-// 动态变量
+// NewVar returns a *gvar.Var.
 func NewVar(i interface{}, unsafe...bool) *Var {
    return gvar.New(i, unsafe...)
 }

-// 阻塞等待HTTPServer执行完成(同一进程多HTTPServer情况下)
+// Wait blocks until all the web servers shutdown.
 func Wait() {
    ghttp.Wait()
 }

-// 打印变量
+// Dump dumps a variable to stdout with more manually readable.
 func Dump(i...interface{}) {
    gutil.Dump(i...)
 }

-// 抛出一个异常
+// Export exports a variable to string with more manually readable.
+func Export(i...interface{}) string {
+    return gutil.Export(i...)
+}
+
+// Throw throws a exception, which can be caught by TryCatch function.
+// It always be used in TryCatch function.
 func Throw(exception interface{}) {
    gutil.Throw(exception)
 }

-// try...catch...
+// TryCatch does the try...catch... logic.
 func TryCatch(try func(), catch ... func(exception interface{})) {
    gutil.TryCatch(try, catch...)
+}
+
+// IsEmpty checks given value empty or not.
+// It returns false if value is: integer(0), bool(false), slice/map(len=0), nil;
+// or else true.
+func IsEmpty(value interface{}) bool {
+    return empty.IsEmpty(value)
 }
--- a/g/g_logger.go
+++ b/g/g_logger.go
@ -10,17 +10,17 @@ import (
    "github.com/gogf/gf/g/os/glog"
 )

-// 是否显示调试信息
+// SetDebug disables/enables debug level for logging globally.
 func SetDebug(debug bool) {
    glog.SetDebug(debug)
 }

-// 设置日志的显示等级
+// SetLogLevel sets the logging level globally.
 func SetLogLevel(level int) {
    glog.SetLevel(level)
 }

-// 获取设置的日志显示等级
+// GetLogLevel returns the global logging level.
 func GetLogLevel() int {
    return glog.GetLevel()
 }
--- a/g/g_object.go
+++ b/g/g_object.go
@ -17,43 +17,42 @@ import (
    "github.com/gogf/gf/g/os/gcfg"
 )

-// HTTPServer单例对象
+// Server returns an instance of http server with specified name.
 func Server(name...interface{}) *ghttp.Server {
    return ghttp.GetServer(name...)
 }

-// TCPServer单例对象
+// TCPServer returns an instance of tcp server with specified name.
 func TCPServer(name...interface{}) *gtcp.Server {
    return gtcp.GetServer(name...)
 }

-// UDPServer单例对象
+// UDPServer returns an instance of udp server with specified name.
 func UDPServer(name...interface{}) *gudp.Server {
    return gudp.GetServer(name...)
 }

-// 核心对象：View
+// View returns an instance of template engine object with specified name.
 func View(name...string) *gview.View {
    return gins.View(name...)
 }

-// Config配置管理对象
-// 配置文件目录查找依次为：启动参数cfgpath、当前程序运行目录
+// Config returns an instance of config object with specified name.
 func Config(file...string) *gcfg.Config {
    return gins.Config(file...)
 }

-// 数据库操作对象，使用了连接池
+// Database returns an instance of database ORM object with specified configuration group name.
 func Database(name...string) gdb.DB {
    return gins.Database(name...)
 }

-// (别名)Database
+// Alias of Database. See Database.
 func DB(name...string) gdb.DB {
    return gins.Database(name...)
 }

-// Redis操作对象，使用了连接池
+// Redis returns an instance of redis client with specified configuration group name.
 func Redis(name...string) *gredis.Redis {
    return gins.Redis(name...)
 }
--- a/g/g_setting.go
+++ b/g/g_setting.go
@ -8,9 +8,8 @@ package g

 import "github.com/gogf/gf/g/net/ghttp"

-// SetServerGraceful enables/disables graceful reload feature of ghttp Web Server.
-//
-// 是否开启WebServer的平滑重启特性。
+// SetServerGraceful enables/disables graceful/hot reload feature of http Web Server.
+// This feature is disabled in default.
 func SetServerGraceful(enabled bool) {
    ghttp.SetGraceful(enabled)
 }
--- a/g/internal/cmdenv/cmdenv.go
+++ b/g/internal/cmdenv/cmdenv.go
@ -17,7 +17,7 @@ import (
 // 规则:
 // 1、命令行参数以小写字母格式，使用: gf.包名.变量名 传递；
 // 2、环境变量参数以大写字母格式，使用: GF_包名_变量名 传递；
-func Get(key string, def...interface{}) *gvar.Var {
+func Get(key string, def...interface{}) gvar.VarRead {
    value := interface{}(nil)
    if len(def) > 0 {
        value = def[0]
--- a/g/internal/empty/empty.go
+++ b/g/internal/empty/empty.go
@ -0,0 +1,52 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package empty
+
+import (
+    "reflect"
+)
+
+// 判断给定的变量是否为空。
+// 整型为0, 布尔为false, slice/map长度为0, 其他为nil的情况，都为空。
+// 为空时返回true，否则返回false。
+func IsEmpty(value interface{}) bool {
+    if value == nil {
+        return true
+    }
+    // 优先通过断言来进行常用类型判断
+    switch value := value.(type) {
+        case int:     return value == 0
+        case int8:    return value == 0
+        case int16:   return value == 0
+        case int32:   return value == 0
+        case int64:   return value == 0
+        case uint:    return value == 0
+        case uint8:   return value == 0
+        case uint16:  return value == 0
+        case uint32:  return value == 0
+        case uint64:  return value == 0
+        case float32: return value == 0
+        case float64: return value == 0
+        case bool:    return value == false
+        case string:  return value == ""
+        case []byte:  return len(value) == 0
+        default:
+            // 最后通过反射来判断
+            rv := reflect.ValueOf(value)
+            if rv.IsNil() {
+                return true
+            }
+            kind := rv.Kind()
+            switch kind {
+                case reflect.Map:   fallthrough
+                case reflect.Slice: fallthrough
+                case reflect.Array:
+                    return rv.Len() == 0
+            }
+    }
+    return false
+}
--- a/g/net/ghttp/ghttp.go
+++ b/g/net/ghttp/ghttp.go
@ -4,5 +4,7 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.

-// Package ghttp provides quite powerful HTTP server and simple client implementations.
+// Package ghttp provides a powerful http server and a simple client.
+//
+// ghttp是GF框架的核心模块，实现了一个强大的Web Server，并提供了一个简便的HTTP客户端。
 package ghttp
--- a/g/net/ghttp/ghttp_client_request_api.go
+++ b/g/net/ghttp/ghttp_client_request_api.go
--- a/g/net/ghttp/ghttp_client_config.go
+++ b/g/net/ghttp/ghttp_client_config.go
@ -0,0 +1,96 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+// HTTP客户端请求.
+
+package ghttp
+
+import (
+    "github.com/gogf/gf/g/text/gregex"
+    "strings"
+    "time"
+)
+
+// 是否模拟浏览器模式(自动保存提交COOKIE)
+func (c *Client) SetBrowserMode(enabled bool) {
+    c.browserMode = enabled
+}
+
+// 设置HTTP Header
+func (c *Client) SetHeader(key, value string) {
+    c.header[key] = value
+}
+
+// 通过字符串设置HTTP Header
+func (c *Client) SetHeaderRaw(header string) {
+    for _, line := range strings.Split(strings.TrimSpace(header), "\n") {
+        array, _ := gregex.MatchString(`^([\w\-]+):\s*(.+)`, line)
+        if len(array) >= 3 {
+            c.header[array[1]] = array[2]
+        }
+    }
+}
+
+// 设置COOKIE
+func (c *Client) SetCookie(key, value string) {
+    c.cookies[key] = value
+}
+
+// 使用Map设置COOKIE
+func (c *Client) SetCookieMap(cookieMap map[string]string) {
+    for k, v := range cookieMap {
+        c.cookies[k] = v
+    }
+}
+
+// 设置请求的URL前缀
+func (c *Client) SetPrefix(prefix string) {
+    c.prefix = prefix
+}
+
+// 设置请求过期时间
+func (c *Client) SetTimeOut(t time.Duration)  {
+    c.Timeout = t
+}
+
+// 设置HTTP访问账号密码
+func (c *Client) SetBasicAuth(user, pass string) {
+    c.authUser = user
+    c.authPass = pass
+}
+
+// 设置失败重试次数及间隔，失败仅针对网络请求失败情况。
+// 重试间隔时间单位为秒。
+func (c *Client) SetRetry(retryCount int, retryInterval int) {
+    c.retryCount    = retryCount
+    c.retryInterval = retryInterval
+}
+
+// 链式操作, See SetBrowserMode
+func (c *Client) BrowserMode(enabled bool) *Client {
+    c.browserMode = enabled
+    return c
+}
+
+// 链式操作, See SetTimeOut
+func (c *Client) TimeOut(t time.Duration) *Client {
+    c.Timeout = t
+    return c
+}
+
+// 链式操作, See SetBasicAuth
+func (c *Client) BasicAuth(user, pass string) *Client {
+    c.authUser = user
+    c.authPass = pass
+    return c
+}
+
+// 链式操作, See SetRetry
+func (c *Client) Retry(retryCount int, retryInterval int) *Client {
+    c.retryCount    = retryCount
+    c.retryInterval = retryInterval
+    return c
+}
--- a/g/net/ghttp/ghttp_client_request_client.go
+++ b/g/net/ghttp/ghttp_client_request_client.go
@ -9,89 +9,58 @@
 package ghttp

 import (
-    "github.com/gogf/gf/g/text/gregex"
-    "time"
    "bytes"
-    "strings"
-    "net/http"
-    "mime/multipart"
-    "os"
-    "io"
-    "github.com/gogf/gf/g/os/gfile"
+    "encoding/json"
    "errors"
    "fmt"
+    "github.com/gogf/gf/g/os/gfile"
+    "io"
+    "mime/multipart"
+    "net/http"
+    "os"
+    "strings"
+    "time"
 )

 // http客户端
 type Client struct {
-    http.Client                   // 底层http client对象
-    header      map[string]string // HEADER信息Map
-    cookies     map[string]string // 自定义COOKIE
-    prefix      string            // 设置请求的URL前缀
-    authUser    string            // HTTP基本权限设置：名称
-    authPass    string            // HTTP基本权限设置：密码
-    browserMode bool              // 是否模拟浏览器模式(自动保存提交COOKIE)
+    http.Client                     // 底层http client对象
+    header        map[string]string // HEADER信息Map
+    cookies       map[string]string // 自定义COOKIE
+    prefix        string            // 设置请求的URL前缀
+    authUser      string            // HTTP基本权限设置：名称
+    authPass      string            // HTTP基本权限设置：密码
+    browserMode   bool              // 是否模拟浏览器模式(自动保存提交COOKIE)
+    retryCount    int               // 失败重试次数(网络失败情况下)
+    retryInterval int               // 失败重试间隔
 }

 // http客户端对象指针
-func NewClient() (*Client) {
+func NewClient() *Client {
    return &Client{
        Client : http.Client {
            Transport: &http.Transport {
                DisableKeepAlives: true,
            },
        },
-        header  : make(map[string]string),
-        cookies : make(map[string]string),
+        header        : make(map[string]string),
+        cookies       : make(map[string]string),
    }
 }

-// 是否模拟浏览器模式(自动保存提交COOKIE)
-func (c *Client) SetBrowserMode(enabled bool) {
-    c.browserMode = enabled
-}
-
-// 设置HTTP Header
-func (c *Client) SetHeader(key, value string) {
-    c.header[key] = value
-}
-
-// 通过字符串设置HTTP Header
-func (c *Client) SetHeaderRaw(header string) {
-    for _, line := range strings.Split(strings.TrimSpace(header), "\n") {
-        array, _ := gregex.MatchString(`^([\w\-]+):\s*(.+)`, line)
-        if len(array) >= 3 {
-            c.header[array[1]] = array[2]
-        }
+// 克隆当前客户端对象，复制属性。
+func (c *Client) Clone() *Client {
+    newClient := NewClient()
+    *newClient = *c
+    newClient.header  = make(map[string]string)
+    newClient.cookies = make(map[string]string)
+    for k, v := range c.header {
+        newClient.header[k] = v
    }
-}
-
-// 设置COOKIE
-func (c *Client) SetCookie(key, value string) {
-    c.cookies[key] = value
-}
-
-// 使用Map设置COOKIE
-func (c *Client) SetCookieMap(cookieMap map[string]string) {
-    for k, v := range cookieMap {
-        c.cookies[k] = v
+    for k, v := range c.cookies {
+        newClient.cookies[k] = v
    }
-}
-
-// 设置请求的URL前缀
-func (c *Client) SetPrefix(prefix string) {
-    c.prefix = prefix
-}
-
-// 设置请求过期时间
-func (c *Client) SetTimeOut(t time.Duration)  {
-    c.Timeout = t
-}
-
-// 设置HTTP访问账号密码
-func (c *Client) SetBasicAuth(user, pass string) {
-    c.authUser = user
-    c.authPass = pass
+    return newClient
 }

 // GET请求
@ -117,6 +86,7 @@ func (c *Client) Post(url string, data...string) (*ClientResponse, error) {
    }
    req := (*http.Request)(nil)
    if strings.Contains(param, "@file:") {
+        // 文件上传
        buffer := new(bytes.Buffer)
        writer := multipart.NewWriter(buffer)
        for _, item := range strings.Split(param, "&") {
@ -150,11 +120,17 @@ func (c *Client) Post(url string, data...string) (*ClientResponse, error) {
            req.Header.Set("Content-Type", writer.FormDataContentType())
        }
    } else {
-        if r, err := http.NewRequest("POST", url, bytes.NewReader([]byte(param))); err != nil {
+        // 识别提交数据格式
+        paramBytes := []byte(param)
+        if r, err := http.NewRequest("POST", url, bytes.NewReader(paramBytes)); err != nil {
            return nil, err
        } else {
            req = r
-            req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+            if json.Valid(paramBytes) {
+                req.Header.Set("Content-Type", "application/json")
+            } else {
+                req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+            }
        }
    }
    // 自定义header
@ -181,9 +157,18 @@ func (c *Client) Post(url string, data...string) (*ClientResponse, error) {
        req.SetBasicAuth(c.authUser, c.authPass)
    }
    // 执行请求
-    resp, err := c.Do(req)
-    if err != nil {
-        return nil, err
+    resp := (*http.Response)(nil)
+    for {
+        if r, err := c.Do(req); err != nil {
+            if c.retryCount > 0 {
+                c.retryCount--
+            } else {
+                return nil, err
+            }
+        } else {
+            resp = r
+            break
+        }
    }
    r := &ClientResponse{
        cookies : make(map[string]string),
@ -303,9 +288,18 @@ func (c *Client) DoRequest(method, url string, data...string) (*ClientResponse,
        }
    }
    // 执行请求
-    resp, err := c.Do(req)
-    if err != nil {
-        return nil, err
+    resp := (*http.Response)(nil)
+    for {
+        if r, err := c.Do(req); err != nil {
+            if c.retryCount > 0 {
+                c.retryCount--
+            } else {
+                return nil, err
+            }
+        } else {
+            resp = r
+            break
+        }
    }
    r := &ClientResponse{
        cookies : make(map[string]string),
--- a/g/net/ghttp/ghttp_request.go
+++ b/g/net/ghttp/ghttp_request.go
@ -57,7 +57,7 @@ func newRequest(s *Server, r *http.Request, w http.ResponseWriter) *Request {
    return request
 }

-// 获取Web Socket连接对象(如果是非WS请求会失败，注意检查然会的error结果)
+// 获取Web Socket连接对象(如果是非WS请求会失败，注意检查返回的error结果)
 func (r *Request) WebSocket() (*WebSocket, error) {
    if conn, err := wsUpgrader.Upgrade(r.Response.ResponseWriter.ResponseWriter, r.Request, nil); err == nil {
        return &WebSocket {
@ -79,20 +79,31 @@ func (r *Request) GetVar(key string, def ... interface{}) gvar.VarRead {
    return r.GetRequestVar(key, def...)
 }

-// 获取原始请求输入字符串
+// 获取原始请求输入二进制。
 func (r *Request) GetRaw() []byte {
+    err := error(nil)
    if r.rawContent == nil {
-        r.rawContent, _ = ioutil.ReadAll(r.Body)
+        r.rawContent, err = ioutil.ReadAll(r.Body)
+        if err != nil {
+            r.Error("error reading request body: ", err)
+        }
    }
    return r.rawContent
 }

+// 获取原始请求输入字符串。
+func (r *Request) GetRawString() string {
+    return string(r.GetRaw())
+}
+
 // 获取原始json请求输入字符串，并解析为json对象
 func (r *Request) GetJson() *gjson.Json {
    data := r.GetRaw()
-    if data != nil {
+    if len(data) > 0 {
        if j, err := gjson.DecodeToJson(data); err == nil {
            return j
+        } else {
+            r.Error(err, ": ", string(data))
        }
    }
    return nil
@ -213,14 +224,14 @@ func (r *Request) GetReferer() string {

 // 获得结构体对象的参数名称标签，构成map返回
 func (r *Request) getStructParamsTagMap(object interface{}) map[string]string {
-    tagmap := make(map[string]string)
+    tagMap := make(map[string]string)
    fields := structs.Fields(object)
    for _, field := range fields {
        if tag := field.Tag("params"); tag != "" {
            for _, v := range strings.Split(tag, ",") {
-                tagmap[strings.TrimSpace(v)] = field.Name()
+                tagMap[strings.TrimSpace(v)] = field.Name()
            }
        }
    }
-    return tagmap
+    return tagMap
 }
--- a/g/net/ghttp/ghttp_request_auth.go
+++ b/g/net/ghttp/ghttp_request_auth.go
@ -26,21 +26,21 @@ func (r *Request) setBasicAuth(tips...string) {
 }

 // 设置HTTP基础账号密码认证，如果用户没有提交账号密码，那么提示用户输出信息。
-// 验证成功之后返回true，否则返回false
+// 验证成功之后返回true，否则返回false。
 func (r *Request) BasicAuth(user, pass string, tips...string) bool {
    auth := r.Header.Get("Authorization")
    if auth == "" {
        r.setBasicAuth(tips...)
        return false
    }
-    auths := strings.SplitN(auth, " ", 2)
-    if len(auths) != 2 {
+    authArray := strings.SplitN(auth, " ", 2)
+    if len(authArray) != 2 {
        r.Response.WriteStatus(http.StatusForbidden)
        return false
    }
-    switch auths[0] {
+    switch authArray[0] {
        case "Basic":
-            authStr, err := gbase64.Decode(auths[1])
+            authStr, err := gbase64.Decode(authArray[1])
            if err != nil {
                r.Response.WriteStatus(http.StatusForbidden, err.Error())
                return false
@ -54,11 +54,12 @@ func (r *Request) BasicAuth(user, pass string, tips...string) bool {
                r.setBasicAuth(tips...)
                return false
            }
+            return true

        default:
            r.Response.WriteStatus(http.StatusForbidden)
            return false
    }
-    return true
+    return false
 }

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
John	872536c035	Merge branch 'master' of https://github.com/gogf/gf	2019-04-10 23:09:59 +08:00
John	c7a6a6fff0	improve grand.Intn; README updates	2019-04-10 23:09:38 +08:00
John Guo	0cb82d70fd	Merge pull request #96 from aloncn/master update unit test for gring	2019-04-10 21:42:25 +08:00
John	acac5a2ad6	version updates	2019-04-10 18:33:51 +08:00
John	9ec15ad2ca	fix issue in repeated rand value of grand.Intn	2019-04-10 18:33:12 +08:00
aloncn	ad50ca6e60	update unit test for gring	2019-04-10 14:26:21 +08:00
aloncn	8285c31bf1	Update unit test for gring	2019-04-10 10:44:40 +08:00
aloncn	230be66fa9	update unit test for gring	2019-04-10 10:13:56 +08:00
aloncn	2c53f934c9	Merge branch 'master' of https://github.com/gogf/gf	2019-04-10 09:50:29 +08:00
John	08785cb272	update unit test cases of gjson	2019-04-10 08:54:49 +08:00
aloncn	bd0207c938	update unit test for gring	2019-04-10 01:16:45 +08:00
John	6fad737617	update unit test cases of gjson/gparser	2019-04-10 01:00:51 +08:00
aloncn	af4148d985	Merge branch 'master' of github.com:aloncn/gf	2019-04-10 00:37:22 +08:00
aloncn	922eaf4d42	Update unit test for gring	2019-04-10 00:37:06 +08:00
farmer chen	4b5153950f	Add unit test for gring	2019-04-10 00:37:06 +08:00
aloncn	78010d2bd7	Update unit test for gring	2019-04-10 00:22:10 +08:00
John	85c2ed1bf2	improve nil checks for gtest.Assert*	2019-04-09 23:12:22 +08:00
farmer chen	429aa90e0d	Merge branch 'master' of github.com:aloncn/gf	2019-04-09 18:42:16 +08:00
farmer chen	4f792b347d	Add unit test for gring	2019-04-09 18:40:48 +08:00
farmer chen	6d8ced21b9	Add unit test for gring	2019-04-09 17:27:58 +08:00
John	8b3eb5b02d	version&release updates	2019-04-09 00:15:48 +08:00
John	b90d61b27c	README updates	2019-04-07 22:03:04 +08:00
John	85606e3e7e	README updates	2019-04-07 21:59:28 +08:00
John	1fc85d49bd	gtime updates; README updates	2019-04-07 21:49:24 +08:00
John Guo	a5cfb4e638	Merge pull request #82 from hailaz/master Add gtime unit test	2019-04-07 21:27:29 +08:00
John Guo	38754bf062	Merge pull request #78 from youyixiao/youyixiao_gogf gregex_unit_test	2019-04-07 21:23:03 +08:00
hailaz	f1818ed2ff	补充gtime_format的覆盖测试。	2019-04-06 23:53:06 +08:00
hailaz	352ad17715	避免pr时造成gtime文件的更改。	2019-04-06 22:56:47 +08:00
hailaz	e50b8d9632	移除gtime unit test中注释掉的函数。	2019-04-06 22:50:37 +08:00
hailaz	2107061a46	Add gtime unit test	2019-04-06 22:48:47 +08:00
John	61f57b4895	update comments of gstr	2019-04-06 21:31:01 +08:00
hailaz	d34273abff	同步master	2019-04-05 23:53:43 +08:00
hailaz	0aff0f0362	同步master	2019-04-05 23:49:20 +08:00
John	68949b69bc	update example of gtime	2019-04-05 23:31:14 +08:00
John	c56c77d3a1	fix issue in G&j char format	2019-04-05 23:13:47 +08:00
John	dc82ce395a	comment updates for gcfg	2019-04-05 00:23:59 +08:00
John	2a29483456	comment fix	2019-04-04 23:24:27 +08:00
John	4f10562980	remove limit for gdb.Model.One	2019-04-04 23:22:09 +08:00
一墨染尽青衣颜	6863928b06	!18 限制下查询单条记录查询条数 Merge pull request !18 from 一墨染尽青衣颜/master	2019-04-04 22:55:13 +08:00
John	aa4dca11f0	fix issue in gtime; update comment for g/gtest	2019-04-04 22:52:56 +08:00
hailaz	dc6ab820ce	修复解析日期函数（parseDateStr）对"02.jan.2006"格式日期解析异常的问题。更正函数（isNumeric）的注释。	2019-04-04 17:57:17 +08:00
肖有益	be0fa4d60b	gregex_unit_test	2019-04-04 17:45:04 +08:00
肖有益	a86d2272af	gregex_unit_test	2019-04-04 16:15:50 +08:00
John	08550d413e	update unit test cases for gcfg	2019-04-04 09:18:43 +08:00
John	b89294561b	add gmap.SetIfNotExistFunc/SetIfNotExistFuncLock for gmap; update comment of gmap; update instance feature of gcfg	2019-04-03 23:39:31 +08:00
John	630d8fdb43	add Instance function for gcfg	2019-04-03 09:59:15 +08:00
John	c4c7e6caf4	gofmt	2019-04-03 00:03:46 +08:00
John	8a8fea1257	v1.5.23	2019-04-02 23:40:20 +08:00
John	0e0f297a3f	add consurrent safety parameter for gjson.Load/LoadContent; fulfil data type auto-check logics for gjson.LoadConetnt; update comment of gjson/gparser	2019-04-02 23:33:27 +08:00
John Guo	fd2c0f2b24	Merge pull request #59 from wenzi1/master 修复gxml字符集转换的并发安全问题	2019-04-02 17:43:19 +08:00
John	ecc6e3888d	up	2019-04-02 17:10:21 +08:00
John	47c073aaf3	add Clear function for gcfg; mark Reload function of gcfg as deprecated; update unit test for gins	2019-04-02 16:08:46 +08:00
John	07476a4349	add instance management feature for gdb/gredis; add customized configuration content management feature for gcfg; update gjson for data content type check	2019-04-02 14:37:46 +08:00
wenzi1	817148f3a1	增加单元测试	2019-04-01 18:32:37 +08:00
wenzi1	bd4271cd8c	增加gxml的单元测试	2019-03-31 23:36:11 +08:00
John	b1804fc346	TODO updates; version updates	2019-03-31 21:13:11 +08:00
John	a3886c2179	fix issue in RemoteAddr of gudp.Conn	2019-03-31 20:58:31 +08:00
John	f258b5bf1c	change logging level from error to debug in route regitsry for struct for ghttp package; handle possible overrange usage of r.URL.Path in ghttp.Server	2019-03-31 20:52:30 +08:00
wenzi1	a05361011f	修复并发安全问题,改为如果非UTF8字符集则先做字符集转换	2019-03-30 23:53:42 +08:00
wenzi1	6b34a77251	修复并发安全问题,改为如果非UTF8字符集则先做字符集转换	2019-03-30 23:39:07 +08:00
John	afb1adee3d	version updates	2019-03-28 17:58:33 +08:00
John	22fa7a37f3	add UseNumber support for gjson; add more unit test cases for gjson	2019-03-28 17:51:05 +08:00
John	6a58bfc574	add stdout printing support for ghttp.Server logging	2019-03-28 09:34:16 +08:00
John	64124c60fc	add fatal error when no router set or statis feature enabled for ghttp.Server	2019-03-27 16:23:35 +08:00
John	9a0066de62	add file/folder search support for gcfg/gview in order of envpath/pwdpath/binpath/mainpath; add gfile.Search function	2019-03-27 11:48:53 +08:00
John	22c7c7403b	fix issue in basic http auth check for server side	2019-03-27 09:16:23 +08:00
John	83db8e4b15	add wss example for websocket	2019-03-22 17:26:39 +08:00
John	25f2e121e7	version updates	2019-03-22 15:09:22 +08:00
John	1325a145d8	fix issue in config auto reload of gcfg	2019-03-22 15:08:43 +08:00
John	9bc49c0b29	add logging for error in ghttp.Request	2019-03-22 14:31:02 +08:00
John	8e84e5b0f3	update comment of gredis	2019-03-22 11:22:03 +08:00
John	a42e6b0c45	ignore private attribute of struct in gconv/gvalid	2019-03-22 10:12:43 +08:00
John	51bb7a9854	ignore private attribute of struct in gconv/gvalid	2019-03-22 10:12:15 +08:00
John	62580b5719	add examples for gredis	2019-03-21 23:51:57 +08:00
John	15cfd5ce5c	add g.Export	2019-03-21 18:21:53 +08:00
John	11c89c4090	fix issue in GetOrSetFuncLock of gmap/gcache; add gutil.IsEmpty/Export functions	2019-03-21 18:20:20 +08:00
John	4a12cb9f27	version updates	2019-03-21 10:52:12 +08:00
John	32f575eddd	update unit test of gins	2019-03-21 10:36:24 +08:00
John	fbb4cb3b1c	add more unit test cases for gredis	2019-03-21 10:04:53 +08:00
John	c9d2d5e8ab	add configuration support for maxIdle/maxActive/idleTimeout/maxConnLifetime of gredis; update gjson.Append/Len functions; add more unit test cases for gredis/gins/gstr/gjson	2019-03-21 00:14:23 +08:00
John	93763192f2	version updates	2019-03-19 17:55:02 +08:00
John	80e0eae6b0	add TLSConfig support for ghttp.Server	2019-03-19 17:48:37 +08:00
John	4e3d735b90	add logging for gcron	2019-03-19 13:58:18 +08:00
John	60e5a7da28	add more unit test cases for grand/gstr	2019-03-18 23:52:25 +08:00
John	997b5ba889	README updates	2019-03-18 14:10:30 +08:00
John	b3e7ca1963	travis updates	2019-03-18 14:05:46 +08:00
John	5a82d695c1	mv greuseport to a new repo	2019-03-18 13:56:16 +08:00
John	64a0427150	travis updates	2019-03-18 13:34:51 +08:00
John	bca5532df8	version updates	2019-03-17 22:36:58 +08:00
John	72eeadd9aa	Merge branch 'master' into develop	2019-03-17 22:31:15 +08:00
John	0af55794f6	add more unit test cases for gdb	2019-03-17 22:26:41 +08:00
John	25a6c53533	add unit test cases for gfsnotify	2019-03-15 14:54:01 +08:00
John	9f9172c775	update unit test cases of package gconv	2019-03-15 09:05:56 +08:00
John	320e0db417	fix int-overflow issue in gconv.String when converting int64 to string; add more unit test cases for package gconv	2019-03-15 00:22:39 +08:00
John	cb8362d447	update unit test cases of package gins	2019-03-14 23:28:56 +08:00
John	45a83fc53c	unit test cases update for package gins	2019-03-14 00:23:46 +08:00
John	3411bd1c1d	merge master	2019-03-13 22:41:00 +08:00
John	6ab0a77364	add more defaulr searching paths for g.Config()	2019-03-13 22:12:59 +08:00
John	281bae4116	unit test cases update for package gins	2019-03-13 09:11:50 +08:00
John	218c692fe0	update unit test cases	2019-03-12 23:56:09 +08:00
John	fa69b581e1	update unit test cases	2019-03-12 23:50:30 +08:00
John	bd0baceeca	update unit test cases	2019-03-12 23:47:27 +08:00
John	e71c837472	update unit test cases	2019-03-12 23:45:44 +08:00
John	782aaabd07	add more unit test cases for gins; update text/template for gview	2019-03-12 23:26:10 +08:00
John	8ae9276732	add disable cache feature option for package gspath	2019-03-12 00:24:31 +08:00
John	79a3aa5916	add more unit test cases for package gvalid	2019-03-11 22:58:21 +08:00
John	733c5db228	version updates	2019-03-11 22:33:43 +08:00
John	6171c621a7	fix issue in missing customed error messages in package gvalid	2019-03-11 22:33:20 +08:00
John	802568856c	version updates	2019-03-11 16:35:44 +08:00
John	127fb67185	add session id check in session object initialzing	2019-03-11 16:33:51 +08:00
John	5db039bbce	gdb.Model updates, rename Alterable function to Safe, change gdb.Model alterable in default, update Where function to support more cases when using map as its param, add more unit test cases for gdb.Model	2019-03-11 16:14:55 +08:00
John	8a3365d18e	ghttp comment updates	2019-03-10 00:39:34 +08:00
John	2ae5b1a4f8	add more unit test cases for ghttp.Server	2019-03-10 00:35:03 +08:00
John	f9515d7126	version updates	2019-03-09 10:20:11 +08:00
John	b56679a97c	revert g.Map to map[string]interface{}, add g.MapAnyAny	2019-03-09 10:17:21 +08:00
John	d1b123964a	README updates	2019-03-08 21:07:18 +08:00
John	991f7c4958	ghttp.Response updates	2019-03-08 19:03:22 +08:00
John	770619c39e	update unit test cases og gcron	2019-03-08 18:27:11 +08:00
John	4ad5450b80	gtest updates; remove one unit test case of gconv.Struct	2019-03-08 18:18:29 +08:00
John	49ce7fe885	fix data race issue of gqueue	2019-03-08 17:54:50 +08:00
John	e66f63262b	add more unit test cases for ghttp.Server	2019-03-08 17:31:30 +08:00
John	94bd5da68a	add map key operator support in Where function for gdb	2019-03-08 11:12:52 +08:00
John	3eee95caf2	VERSION updates	2019-03-08 10:35:35 +08:00
John	5c638c630a	add select in support for slice type of arguments in Where function of gdb	2019-03-08 10:33:36 +08:00
John	a6ec9d7a1c	update gdb.Model.Where, orverwrite args if multiple calls Where function	2019-03-08 10:18:38 +08:00
John	374c70c0e3	README updates	2019-03-08 09:03:32 +08:00
John	40771066d4	travis updates	2019-03-08 08:48:53 +08:00
John	22a7ef43ce	Merge branch 'master' into develop	2019-03-08 00:21:52 +08:00
John	05f22d1cee	README updates	2019-03-08 00:15:57 +08:00
John	ebf56a86ab	add Alterable function for gdb.Model	2019-03-07 23:53:56 +08:00
John	2ba59e8943	fix issue in gtime convert in package gconv; add Structs/Scan functions for gdb.Model; add GetStructs/GetScan functions for gdb.Base and gdb.TX	2019-03-07 23:36:45 +08:00
John	83be1de04c	remove error returns from router registry functions of WebServer; add more unit test cases for WebServer	2019-03-06 15:21:00 +08:00
John	c8251ed82f	g.Map updates	2019-03-06 10:38:50 +08:00
John	2335ea0c4d	merge master	2019-03-05 21:07:54 +08:00
John	5d874e9063	add example code for gconv.Map; comment updates of gdb	2019-03-05 17:52:34 +08:00
John	f2c080d25f	update ghttp.Response	2019-03-05 17:16:21 +08:00
John	975da97b4a	fix issue in empty check for nil attribute of struct in package 'empty';add set-cookie support for 302 status in ghttp.Server	2019-03-05 17:06:37 +08:00
John	37617589a6	add more unit test cases for ghttp.Server	2019-03-04 23:51:44 +08:00
John	5c9f0db903	version updates	2019-03-04 23:37:01 +08:00
John	28abf0c175	add ReplaceI/ReplaceIByArray/ReplaceIByMap case-insensetive replacing functions for gstr	2019-03-04 23:35:06 +08:00
John	13749feab4	add json features '-' and 'omitempty' for gconv.Map, like package 'json' from stdlib; add internal package 'empty', to check empty variable	2019-03-04 22:59:29 +08:00
John	c1e77b7e09	update example of gtcp	2019-03-03 20:40:36 +08:00
John	962a5e93f7	update example of gtcp	2019-03-03 20:20:31 +08:00
John	c3b9b8d5ae	gconv updates	2019-03-03 00:53:35 +08:00
John	1ad076c522	travis updates	2019-03-03 00:31:16 +08:00
John	b01777fcd1	travis updates	2019-03-03 00:28:32 +08:00
John	55a5532c2e	gdb updates	2019-03-03 00:14:20 +08:00
John	adb928941a	issue template updates	2019-03-02 00:02:05 +08:00
John	f92c1fc527	update CORS feature of ghttp.Response; add more unit cases for ghttp.Server	2019-03-01 23:45:55 +08:00
John	3ae7279ebc	issue template updates	2019-03-01 14:01:05 +08:00
John	66287c2d0e	update the admin feature and unit test cases of ghttp	2019-02-28 23:57:20 +08:00
John	5d37626981	hot fix issue in router registry	2019-02-28 14:07:00 +08:00
John	d0ed3b979d	release updates	2019-02-28 10:28:09 +08:00
John	fa256aec9f	add example for layout using template engine; fix issue with config error output in gview when no config used	2019-02-27 22:53:39 +08:00
John	86834c5a15	version and comment updates	2019-02-27 22:17:09 +08:00
John	c2046157d6	add ghttp.Request.GetRawString function	2019-02-27 21:17:56 +08:00
John	cdb2cc89c0	remove password for unit test of gdb	2019-02-27 12:51:48 +08:00
John	4964c09a77	add more unit test cases for gdb	2019-02-27 12:38:12 +08:00
John	ef34b2c9ce	gdb updates, add batch operation support for Insert/Save/Replace, change list param type from List to interface{} for Batch* functions	2019-02-27 09:38:10 +08:00
John	9afe242293	Merge branch 'master' into qiangg_gdb_map	2019-02-27 08:52:50 +08:00
John	136d93d373	add donate for gitee	2019-02-26 23:39:09 +08:00
John	3102cec5b8	issue template updates	2019-02-26 23:06:14 +08:00
John	e28eb9da04	add issue template	2019-02-26 22:58:52 +08:00
John	754ed86dfb	add issue template	2019-02-26 22:56:52 +08:00
John	e352b07055	add issue_template	2019-02-26 22:51:30 +08:00
John	fdea242b50	Merge branch 'master' into develop	2019-02-26 22:23:24 +08:00
John	7f44f2f5e4	gdb updates	2019-02-26 14:23:29 +08:00
John	66efbe63f0	add struct support for Insert/Save/Replace/Update/Where/Data functions	2019-02-26 01:19:01 +08:00
John	72ecf2d2af	TODO++	2019-02-25 12:39:07 +08:00
John	0f854e46d8	refact Merge function for garray; add more frequently-used type alias for gf	2019-02-22 09:08:46 +08:00
John	4564f38e1a	add PopRands/Rands functions for garray	2019-02-20 19:06:08 +08:00
John	7e06bf6705	Merge branch 'master' into qiangg_garray2	2019-02-20 16:28:24 +08:00
John	d780cf64c2	garray updates	2019-02-20 14:18:11 +08:00