add Instance function for gcfg

修复gxml字符集转换的并发安全问题

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,29 +29,17 @@
     - 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. gfcache依旧使用gcache作为缓存控制对象，不要使用gmap；
-1. 增加对ghttp路由注册的{.struct}/{.method}单元测试；
-1. 更新跨域请求CORS相关功能文档；
 1. ghttp的热重启的本地进程端口监听，在不使用该特性时默认关闭掉；
-1. gcfg包目前允许添加重复的目录路径，需要在SetPath/AddPath时判断重复性，不能添加重复的路径；
-1. gdb执行数据写入时，如果参数为struct/[]struct，自动映射与表字段对应关系，不再使用gconv标签标识；
-
+1. gtcp增加对TLS加密通信的支持；
 
 
 
@@ -119,4 +100,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对象转换的键名属性映射；

g/container/gmap/gmap_int_interface_map.go

@@ -109,7 +109,9 @@ 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
 }
 

g/container/gmap/gmap_string_interface_map.go

@@ -109,7 +109,9 @@ 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
 }
 

g/container/gvar/gvar.go

@@ -18,7 +18,7 @@ import (
 
 type Var struct {
     value interface{} // 变量值
-    safe  bool        // 当为true时,value为 *gtype.Interface 类型
+    safe  bool        // 当为true时, value为 *gtype.Interface 类型
 }
 
 // 创建一个动态变量，value参数可以为nil

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"
@@ -155,22 +156,26 @@ const (
     gDEFAULT_BATCH_NUM          = 10
     // 默认的连接池连接存活时间(秒)
     gDEFAULT_CONN_MAX_LIFE_TIME = 30
+)
 
+var (
+    // 单例对象Map
+    instances = gmap.NewStringInterfaceMap()
 )
 
 // 使用默认/指定分组配置进行连接，数据库集群配置项：default
-func New(groupName ...string) (db DB, err error) {
-	group := config.d
-	if len(groupName) > 0 {
-        group = groupName[0]
+func New(name...string) (db DB, err error) {
+	group := configs.defaultGroup
+	if len(name) > 0 {
+        group = name[0]
 	}
-	config.RLock()
-	defer config.RUnlock()
+	configs.RLock()
+	defer configs.RUnlock()
 
-	if len(config.c) < 1 {
+	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,
@@ -204,9 +209,25 @@ func New(groupName ...string) (db DB, err error) {
 	}
 }
 
+// 获得数据库操作对象单例
+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)
@@ -319,17 +340,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)
 }

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,

g/database/gdb/gdb_mssql.go

@@ -30,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)

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)

g/database/gdb/gdb_oracle.go

@@ -30,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)
 	}

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)
     }

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
 	}

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)
+    })
+}

g/database/gdb/gdb_unit_init_test.go

@@ -1,3 +1,9 @@
+// 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 (

g/database/gdb/gdb_unit_method_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
 

g/database/gdb/gdb_unit_model_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
 

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
 

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()

g/database/gredis/gredis_config.go

@@ -0,0 +1,69 @@
+// 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_GROUP_NAME = "default"
+)
+var (
+    // 分组配置
+    configs = gmap.NewStringInterfaceMap()
+)
+
+// SetConfig sets the global configuration for specified group.
+// If <name> is not passed, it sets configuration for the default group name.
+//
+// 设置全局分组配置，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.
+// If <group> is not passed, it returns configuration of the default group name.
+//
+// 获取指定全局分组配置，group为非必需参数，默认为默认分组名称。
+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.
+//
+// 删除指定全局分组配置，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()
+}
+
+

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)
+    })
+}

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)
 }

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

g/encoding/gjson/gjson.go

@@ -4,10 +4,11 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
-// Package gjson provides quite flexible and useful API for JSON/XML/YAML/TOML content handling.
+// Package gjson provides convenient API for JSON/XML/YAML/TOML data handling.
 package gjson
 
 import (
+    "bytes"
     "encoding/json"
     "errors"
     "fmt"
@@ -16,42 +17,48 @@ import (
     "github.com/gogf/gf/g/encoding/gyaml"
     "github.com/gogf/gf/g/internal/rwmutex"
     "github.com/gogf/gf/g/os/gfcache"
-    "github.com/gogf/gf/g/os/gfile"
     "github.com/gogf/gf/g/text/gregex"
     "github.com/gogf/gf/g/text/gstr"
     "github.com/gogf/gf/g/util/gconv"
+    "reflect"
     "strconv"
     "strings"
     "time"
 )
 
 const (
-    gDEFAULT_SPLIT_CHAR = '.' // 默认层级分隔符号
+    // Separator char for hierarchical data access.
+    gDEFAULT_SPLIT_CHAR = '.'
 )
 
-// json解析结果存放数组
+// The customized JSON struct.
 type Json struct {
     mu *rwmutex.RWMutex
-    p  *interface{} // 注意这是一个指针
-    c  byte         // 层级分隔符，默认为"."
-    vc bool         // 层级检索是否执行分隔符冲突检测(默认为false，检测会比较影响检索效率)
+    p  *interface{} // Pointer for hierarchical data access, it's the root of data in default.
+    c  byte         // Char separator('.' in default).
+    vc bool         // Violence Check(false in default), which is used to access data
+                    // when the hierarchical data key contains separator char.
 }
 
-// 将变量转换为Json对象进行处理，该变量至少应当是一个map或者slice，否者转换没有意义
-func New(value interface{}, unsafe...bool) *Json {
+// New creates a Json 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 Json object
+// in un-concurrent-safe context, which is false in default.
+func New(data interface{}, unsafe...bool) *Json {
     j := (*Json)(nil)
-    switch value.(type) {
+    switch data.(type) {
         case map[string]interface{}, []interface{}, nil:
             j = &Json {
-                p  : &value,
+                p  : &data,
                 c  : byte(gDEFAULT_SPLIT_CHAR),
                 vc : false ,
             }
         case string, []byte:
-            j, _ = LoadContent(gconv.Bytes(value))
+            j, _ = LoadContent(gconv.Bytes(data))
         default:
             v := (interface{})(nil)
-            if m := gconv.Map(value); m != nil {
+            if m := gconv.Map(data); m != nil {
                 v = m
                 j = &Json {
                     p  : &v,
@@ -59,7 +66,7 @@ func New(value interface{}, unsafe...bool) *Json {
                     vc : false,
                 }
             } else {
-                v = gconv.Interfaces(value)
+                v = gconv.Interfaces(data)
                 j = &Json {
                     p  : &v,
                     c  : byte(gDEFAULT_SPLIT_CHAR),
@@ -71,114 +78,130 @@ func New(value interface{}, unsafe...bool) *Json {
     return j
 }
 
-// 创建一个非并发安全的Json对象
-func NewUnsafe(value...interface{}) *Json {
-    if len(value) > 0 {
-        return New(value[0], true)
+// NewUnsafe creates a un-concurrent-safe Json object.
+func NewUnsafe(data...interface{}) *Json {
+    if len(data) > 0 {
+        return New(data[0], true)
     }
     return New(nil, true)
 }
 
-// 识别当前给定内容是否为JSON格式
-func Valid (v interface{}) bool {
-    return json.Valid(gconv.Bytes(v))
+// Valid checks whether <data> is a valid JSON data type.
+func Valid(data interface{}) bool {
+    return json.Valid(gconv.Bytes(data))
 }
 
-// 编码go变量为json字符串，并返回json字符串指针
-func Encode (v interface{}) ([]byte, error) {
-    return json.Marshal(v)
+// Encode encodes <value> to JSON data type of bytes.
+func Encode(value interface{}) ([]byte, error) {
+    return json.Marshal(value)
 }
 
-// 解码字符串为interface{}变量
-func Decode (b []byte) (interface{}, error) {
-    var v interface{}
-    if err := DecodeTo(b, &v); err != nil {
+// Decode decodes <data>(string/[]byte) to golang variable.
+func Decode(data interface{}) (interface{}, error) {
+    var value interface{}
+    if err := DecodeTo(gconv.Bytes(data), &value); err != nil {
         return nil, err
     } else {
-        return v, nil
+        return value, nil
     }
 }
 
-// 解析json字符串为go变量，注意第二个参数为指针(任意结构的变量)
-func DecodeTo (b []byte, v interface{}) error {
-    return json.Unmarshal(b, v)
+// Decode decodes <data>(string/[]byte) to specified golang variable <v>.
+// The <v> should be a pointer type.
+func DecodeTo(data interface{}, v interface{}) error {
+    decoder := json.NewDecoder(bytes.NewReader(gconv.Bytes(data)))
+    decoder.UseNumber()
+    return decoder.Decode(v)
 }
 
-// 解析json字符串为gjson.Json对象，并返回操作对象指针
-func DecodeToJson (b []byte) (*Json, error) {
-    if v, err := Decode(b); err != nil {
+// DecodeToJson codes <data>(string/[]byte) to a Json object.
+func DecodeToJson(data interface{}, unsafe...bool) (*Json, error) {
+    if v, err := Decode(gconv.Bytes(data)); err != nil {
         return nil, err
     } else {
-        return New(v), nil
+        return New(v, unsafe...), nil
     }
 }
 
-// 支持多种配置文件类型转换为json格式内容并解析为gjson.Json对象
-func Load (path string) (*Json, error) {
-    return LoadContent(gfcache.GetBinContents(path), gfile.Ext(path))
+// Load loads content from specified file <path>,
+// and creates a Json object from its content.
+func Load(path string, unsafe...bool) (*Json, error) {
+    return LoadContent(gfcache.GetBinContents(path), unsafe...)
 }
 
-// 支持的配置文件格式：xml, json, yaml/yml, toml,
-// 默认为自动识别，当无法检测成功时使用json解析。
-func LoadContent(data []byte, dataType...string) (*Json, error) {
+// LoadContent creates a Json object from given content,
+// it checks the data type of <content> automatically,
+// supporting JSON, XML, YAML and TOML types of data.
+func LoadContent(data interface{}, unsafe...bool) (*Json, error) {
     var err    error
     var result interface{}
+    b := gconv.Bytes(data)
     t := "json"
-    if len(dataType) > 0 {
-        t = dataType[0]
+    // auto check data type
+    if json.Valid(b) {
+        t = "json"
+    } else if gregex.IsMatch(`^<.+>.*</.+>$`, b) {
+        t = "xml"
+    } else if gregex.IsMatch(`^[\s\t]*\w+\s*:\s*.+`, b) || gregex.IsMatch(`\n[\s\t]*\w+\s*:\s*.+`, b) {
+        t = "yml"
+    } else if gregex.IsMatch(`^[\s\t]*\w+\s*=\s*.+`, b) || gregex.IsMatch(`\n[\s\t]*\w+\s*=\s*.+`, b) {
+        t = "toml"
     } else {
-        if gregex.IsMatch(`<.+>.*</.+>`, data) {
-            t = "xml"
-        } else if gregex.IsMatch(`\w+\s*:\s*\w+`, data) {
-            t = "yml"
-        } else if gregex.IsMatch(`\w+\s*=\s*\w+`, data) {
-            t = "toml"
-        }
+        return nil, errors.New("unsupported data type")
     }
+    // convert to json type data
     switch t {
-        case  "xml", ".xml":
-            data, err = gxml.ToJson(data)
-            if err != nil {
-                return nil, err
-            }
+        case "json", ".json":
+            // ok
+        case "xml", ".xml":
+            // TODO UseNumber
+            b, err = gxml.ToJson(b)
 
-        case   "yml", "yaml", ".yml", ".yaml":
-            data, err = gyaml.ToJson(data)
-            if err != nil {
-                return nil, err
-            }
+        case "yml", "yaml", ".yml", ".yaml":
+            // TODO UseNumber
+            b, err = gyaml.ToJson(b)
 
-        case  "toml", ".toml":
-            data, err = gtoml.ToJson(data)
-            if err != nil {
-                return nil, err
-            }
+        case "toml", ".toml":
+            // TODO UseNumber
+            b, err = gtoml.ToJson(b)
+
+        default:
+            err = errors.New("nonsupport type " + t)
+    }
+    if err != nil {
+        return nil, err
     }
     if result == nil {
-        if err := json.Unmarshal(data, &result); err != nil {
+        decoder := json.NewDecoder(bytes.NewReader(b))
+        decoder.UseNumber()
+        if err := decoder.Decode(&result); err != nil {
             return nil, err
         }
+        switch result.(type) {
+            case string, []byte:
+                return nil, fmt.Errorf(`json decoding failed for content: %s`, string(b))
+        }
     }
-    return New(result), nil
+    return New(result, unsafe...), nil
 }
 
-// 设置自定义的层级分隔符号
+// SetSplitChar sets the separator char for hierarchical data access.
 func (j *Json) SetSplitChar(char byte) {
     j.mu.Lock()
     j.c = char
     j.mu.Unlock()
 }
 
-// 设置是否执行层级冲突检查，当键名中存在层级符号时需要开启该特性，默认为关闭。
-// 开启比较耗性能，也不建议允许键名中存在分隔符，最好在应用端避免这种情况。
-func (j *Json) SetViolenceCheck(check bool) {
+// SetViolenceCheck enables/disables violence check for hierarchical data access.
+func (j *Json) SetViolenceCheck(enabled bool) {
     j.mu.Lock()
-    j.vc = check
+    j.vc = enabled
     j.mu.Unlock()
 }
 
-// 将指定的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 (j *Json) GetToVar(pattern string, v interface{}) error {
     r := j.Get(pattern)
     if r != nil {
@@ -193,19 +216,18 @@ func (j *Json) GetToVar(pattern string, v interface{}) error {
     return nil
 }
 
-// 获得一个键值对关联数组/哈希表，方便操作，不需要自己做类型转换
-// 注意，如果获取的值不存在，或者类型与json类型不匹配，那么将会返回nil
+// GetMap gets the value by specified <pattern>,
+// and converts it to map[string]interface{}.
 func (j *Json) GetMap(pattern string) map[string]interface{} {
     result := j.Get(pattern)
     if result != nil {
-        if r, ok := result.(map[string]interface{}); ok {
-            return r
-        }
+        return gconv.Map(result)
     }
     return nil
 }
 
-// 将检索值转换为Json对象指针返回
+// GetJson gets the value by specified <pattern>,
+// and converts it to a Json object.
 func (j *Json) GetJson(pattern string) *Json {
     result := j.Get(pattern)
     if result != nil {
@@ -214,28 +236,39 @@ func (j *Json) GetJson(pattern string) *Json {
     return nil
 }
 
-// 获得一个数组[]interface{}，方便操作，不需要自己做类型转换
-// 注意，如果获取的值不存在，或者类型与json类型不匹配，那么将会返回nil
-func (j *Json) GetArray(pattern string) []interface{} {
-    result := j.Get(pattern)
-    if result != nil {
-        if r, ok := result.([]interface{}); ok {
-            return r
+// GetJsons gets the value by specified <pattern>,
+// and converts it to a slice of Json object.
+func (j *Json) GetJsons(pattern string) []*Json {
+    array := j.GetArray(pattern)
+    if len(array) > 0 {
+        jsons := make([]*Json, len(array))
+        for i := 0; i < len(array); i++ {
+            jsons[i] = New(array[i], !j.mu.IsSafe())
         }
+        return jsons
     }
     return nil
 }
 
-// 返回指定json中的string
+// GetArray gets the value by specified <pattern>,
+// and converts it to a slice of []interface{}.
+func (j *Json) GetArray(pattern string) []interface{} {
+    return gconv.Interfaces(j.Get(pattern))
+}
+
+// GetString gets the value by specified <pattern>,
+// and converts it to string.
 func (j *Json) GetString(pattern string) string {
     return gconv.String(j.Get(pattern))
 }
 
-// 返回指定json中的strings(转换为[]string数组)
+// GetStrings gets the value by specified <pattern>,
+// and converts it to a slice of []string.
 func (j *Json) GetStrings(pattern string) []string {
     return gconv.Strings(j.Get(pattern))
 }
 
+// See GetArray.
 func (j *Json) GetInterfaces(pattern string) []interface{} {
     return gconv.Interfaces(j.Get(pattern))
 }
@@ -248,7 +281,10 @@ func (j *Json) GetTimeDuration(pattern string) time.Duration {
     return gconv.TimeDuration(j.Get(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 (j *Json) GetBool(pattern string) bool {
     return gconv.Bool(j.Get(pattern))
 }
@@ -309,25 +345,29 @@ func (j *Json) GetFloats(pattern string) []float64 {
     return gconv.Floats(j.Get(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 (j *Json) GetToStruct(pattern string, objPointer interface{}) error {
     return gconv.Struct(j.Get(pattern), objPointer)
 }
 
-// 动态设置层级变量
+// Set sets value with specified <pattern>.
+// It supports hierarchical data access by char separator, which is '.' in default.
 func (j *Json) Set(pattern string, value interface{}) error {
     return j.setValue(pattern, value, false)
 }
 
-// 动态删除层级变量
+// Remove deletes value with specified <pattern>.
+// It supports hierarchical data access by char separator, which is '.' in default.
 func (j *Json) Remove(pattern string) error {
     return j.setValue(pattern, nil, true)
 }
 
-// 根据pattern查找并设置数据
-// 注意：
-// 1、写入的value为nil且removed为true时，表示删除;
-// 2、里面的层级处理比较复杂，逻辑较复杂的地方在于层级检索及节点创建，叶子赋值;
+// Set <value> by <pattern>.
+// Notice:
+// 1. If value is nil and removed is true, means deleting this value;
+// 2. It's quite complicated in hierarchical data search, node creating and data assignment;
 func (j *Json) setValue(pattern string, value interface{}, removed bool) error {
     array   := strings.Split(pattern, string(j.c))
     length  := len(array)
@@ -346,187 +386,202 @@ func (j *Json) setValue(pattern string, value interface{}, removed bool) error {
     defer j.mu.Unlock()
     for i:= 0; i < length; i++ {
         switch (*pointer).(type) {
-        case map[string]interface{}:
-            if i == length - 1 {
-                if removed && value == nil {
-                    // 删除map元素
-                    delete((*pointer).(map[string]interface{}), array[i])
-                } else {
-                    (*pointer).(map[string]interface{})[array[i]] = value
-                }
-            } else {
-                // 当键名不存在的情况这里会进行处理
-                if v, ok := (*pointer).(map[string]interface{})[array[i]]; !ok {
-                    if removed && value == nil {
-                        goto done
-                    }
-                    // 创建新节点
-                    if gstr.IsNumeric(array[i + 1]) {
-                        // 创建array节点
-                        n, _ := strconv.Atoi(array[i + 1])
-                        var v interface{} = make([]interface{}, n + 1)
-                        pparent = j.setPointerWithValue(pointer, array[i], v)
-                        pointer = &v
-                    } else {
-                        // 创建map节点
-                        var v interface{} = make(map[string]interface{})
-                        pparent = j.setPointerWithValue(pointer, array[i], v)
-                        pointer = &v
-                    }
-                } else {
-                    pparent = pointer
-                    pointer = &v
-                }
-            }
-
-        case []interface{}:
-            // 键名与当前指针类型不符合，需要执行**覆盖操作**
-            if !gstr.IsNumeric(array[i]) {
+            case map[string]interface{}:
                 if i == length - 1 {
-                    *pointer = map[string]interface{}{ array[i] : value }
+                    if removed && value == nil {
+                        // 删除map元素
+                        delete((*pointer).(map[string]interface{}), array[i])
+                    } else {
+                        (*pointer).(map[string]interface{})[array[i]] = value
+                    }
                 } else {
-                    var v interface{} = make(map[string]interface{})
-                    *pointer = v
-                    pparent  = pointer
-                    pointer  = &v
+                    // 当键名不存在的情况这里会进行处理
+                    if v, ok := (*pointer).(map[string]interface{})[array[i]]; !ok {
+                        if removed && value == nil {
+                            goto done
+                        }
+                        // 创建新节点
+                        if gstr.IsNumeric(array[i + 1]) {
+                            // 创建array节点
+                            n, _ := strconv.Atoi(array[i + 1])
+                            var v interface{} = make([]interface{}, n + 1)
+                            pparent = j.setPointerWithValue(pointer, array[i], v)
+                            pointer = &v
+                        } else {
+                            // 创建map节点
+                            var v interface{} = make(map[string]interface{})
+                            pparent = j.setPointerWithValue(pointer, array[i], v)
+                            pointer = &v
+                        }
+                    } else {
+                        pparent = pointer
+                        pointer = &v
+                    }
                 }
-                continue
-            }
 
-            valn, err := strconv.Atoi(array[i])
-            if err != nil {
-                return err
-            }
-            // 叶子节点
-            if i == length - 1 {
-                if len((*pointer).([]interface{})) > valn {
-                    if removed && value == nil {
-                        // 删除数据元素
-                        j.setPointerWithValue(pparent, array[i - 1], append((*pointer).([]interface{})[ : valn], (*pointer).([]interface{})[valn + 1 : ]...))
+            case []interface{}:
+                // 键名与当前指针类型不符合，需要执行**覆盖操作**
+                if !gstr.IsNumeric(array[i]) {
+                    if i == length - 1 {
+                        *pointer = map[string]interface{}{ array[i] : value }
                     } else {
-                        (*pointer).([]interface{})[valn] = value
-                    }
-                } else {
-                    if removed && value == nil {
-                        goto done
-                    }
-                    if pparent == nil {
-                        // 表示根节点
-                        j.setPointerWithValue(pointer, array[i], value)
-                    } else {
-                        // 非根节点
-                        s := make([]interface{}, valn + 1)
-                        copy(s, (*pointer).([]interface{}))
-                        s[valn] = value
-                        j.setPointerWithValue(pparent, array[i - 1], s)
+                        var v interface{} = make(map[string]interface{})
+                        *pointer = v
+                        pparent  = pointer
+                        pointer  = &v
                     }
+                    continue
                 }
-            } else {
-                if gstr.IsNumeric(array[i + 1]) {
-                    n, _ := strconv.Atoi(array[i + 1])
+
+                valn, err := strconv.Atoi(array[i])
+                if err != nil {
+                    return err
+                }
+                // 叶子节点
+                if i == length - 1 {
                     if len((*pointer).([]interface{})) > valn {
-                        (*pointer).([]interface{})[valn] = make([]interface{}, n + 1)
-                        pparent                          = pointer
-                        pointer                          = &(*pointer).([]interface{})[valn]
+                        if removed && value == nil {
+                            // 删除数据元素
+                            j.setPointerWithValue(pparent, array[i - 1], append((*pointer).([]interface{})[ : valn], (*pointer).([]interface{})[valn + 1 : ]...))
+                        } else {
+                            (*pointer).([]interface{})[valn] = value
+                        }
                     } else {
                         if removed && value == nil {
                             goto done
                         }
-                        var v interface{} = make([]interface{}, n + 1)
+                        if pparent == nil {
+                            // 表示根节点
+                            j.setPointerWithValue(pointer, array[i], value)
+                        } else {
+                            // 非根节点
+                            s := make([]interface{}, valn + 1)
+                            copy(s, (*pointer).([]interface{}))
+                            s[valn] = value
+                            j.setPointerWithValue(pparent, array[i - 1], s)
+                        }
+                    }
+                } else {
+                    if gstr.IsNumeric(array[i + 1]) {
+                        n, _ := strconv.Atoi(array[i + 1])
+                        if len((*pointer).([]interface{})) > valn {
+                            (*pointer).([]interface{})[valn] = make([]interface{}, n + 1)
+                            pparent                          = pointer
+                            pointer                          = &(*pointer).([]interface{})[valn]
+                        } else {
+                            if removed && value == nil {
+                                goto done
+                            }
+                            var v interface{} = make([]interface{}, n + 1)
+                            pparent = j.setPointerWithValue(pointer, array[i], v)
+                            pointer = &v
+                        }
+                    } else {
+                        var v interface{} = make(map[string]interface{})
                         pparent = j.setPointerWithValue(pointer, array[i], v)
                         pointer = &v
                     }
-                } else {
-                    var v interface{} = make(map[string]interface{})
-                    pparent = j.setPointerWithValue(pointer, array[i], v)
-                    pointer = &v
                 }
-            }
 
             // 如果当前指针指向的变量不是引用类型的，
             // 那么修改变量必须通过父级进行修改，即 pparent
-        default:
-            if removed && value == nil {
-                goto done
-            }
-            if gstr.IsNumeric(array[i]) {
-                n, _    := strconv.Atoi(array[i])
-                s       := make([]interface{}, n + 1)
-                if i == length - 1 {
-                    s[n] = value
+            default:
+                if removed && value == nil {
+                    goto done
                 }
-                if pparent != nil {
-                    pparent = j.setPointerWithValue(pparent, array[i - 1], s)
-                } else {
-                    *pointer = s
-                    pparent  = pointer
-                }
-            } else {
-                var v interface{} = make(map[string]interface{})
-                if i == length - 1 {
-                    v = map[string]interface{}{
-                        array[i] : value,
+                if gstr.IsNumeric(array[i]) {
+                    n, _    := strconv.Atoi(array[i])
+                    s       := make([]interface{}, n + 1)
+                    if i == length - 1 {
+                        s[n] = value
+                    }
+                    if pparent != nil {
+                        pparent = j.setPointerWithValue(pparent, array[i - 1], s)
+                    } else {
+                        *pointer = s
+                        pparent  = pointer
                     }
-                }
-                if pparent != nil {
-                    pparent = j.setPointerWithValue(pparent, array[i - 1], v)
                 } else {
-                    *pointer = v
-                    pparent  = pointer
+                    var v interface{} = make(map[string]interface{})
+                    if i == length - 1 {
+                        v = map[string]interface{}{
+                            array[i] : value,
+                        }
+                    }
+                    if pparent != nil {
+                        pparent = j.setPointerWithValue(pparent, array[i - 1], v)
+                    } else {
+                        *pointer = v
+                        pparent  = pointer
+                    }
+                    pointer = &v
                 }
-                pointer = &v
-            }
-
         }
     }
 done:
     return nil
 }
 
-// 数据结构转换，map参数必须转换为map[string]interface{}，数组参数必须转换为[]interface{}
+// Convert <value> to map[string]interface{} or []interface{},
+// which can be supported for hierarchical data access.
 func (j *Json) convertValue(value interface{}) interface{} {
     switch value.(type) {
-    case map[string]interface{}:
-        return value
-    case []interface{}:
-        return value
-    default:
-        // 这里效率会比较低，当然比直接用反射也不会差到哪儿去
-        // 为了操作的灵活性，牺牲了一定的效率
-        b, _ := Encode(value)
-        v, _ := Decode(b)
-        return v
+        case map[string]interface{}:
+            return value
+        case []interface{}:
+            return value
+        default:
+            rv   := reflect.ValueOf(value)
+            kind := rv.Kind()
+            if kind == reflect.Ptr {
+                rv   = rv.Elem()
+                kind = rv.Kind()
+            }
+            switch kind {
+                case reflect.Array:  return gconv.Interfaces(value)
+                case reflect.Slice:  return gconv.Interfaces(value)
+                case reflect.Map:    return gconv.Map(value)
+                case reflect.Struct: return gconv.Map(value)
+                default:
+                    // Use json decode/encode at last.
+                    b, _ := Encode(value)
+                    v, _ := Decode(b)
+                    return v
+            }
     }
 }
 
-// 用于Set方法中，对指针指向的内存地址进行赋值
-// 返回修改后的父级指针
+// Set <key>:<value> to <pointer>, the <key> may be a map key or slice index.
+// It returns the pointer to the new value set.
 func (j *Json) setPointerWithValue(pointer *interface{}, key string, value interface{}) *interface{} {
     switch (*pointer).(type) {
-    case map[string]interface{}:
-        (*pointer).(map[string]interface{})[key] = value
-        return &value
-    case []interface{}:
-        n, _ := strconv.Atoi(key)
-        if len((*pointer).([]interface{})) > n {
-            (*pointer).([]interface{})[n] = value
-            return &(*pointer).([]interface{})[n]
-        } else {
-            s := make([]interface{}, n + 1)
-            copy(s, (*pointer).([]interface{}))
-            s[n] = value
-            *pointer = s
-            return &s[n]
-        }
-    default:
-        *pointer = value
+        case map[string]interface{}:
+            (*pointer).(map[string]interface{})[key] = value
+            return &value
+        case []interface{}:
+            n, _ := strconv.Atoi(key)
+            if len((*pointer).([]interface{})) > n {
+                (*pointer).([]interface{})[n] = value
+                return &(*pointer).([]interface{})[n]
+            } else {
+                s := make([]interface{}, n + 1)
+                copy(s, (*pointer).([]interface{}))
+                s[n] = value
+                *pointer = s
+                return &s[n]
+            }
+        default:
+            *pointer = value
     }
     return pointer
 }
 
-// 根据约定字符串方式访问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 (j *Json) Get(pattern...string) interface{} {
     j.mu.RLock()
     defer j.mu.RUnlock()
@@ -539,7 +594,7 @@ func (j *Json) Get(pattern...string) interface{} {
     if j.vc {
         result = j.getPointerByPattern(queryPattern)
     } else {
-        result = j.getPointerByPatternWithoutSplitCharViolenceCheck(queryPattern)
+        result = j.getPointerByPatternWithoutViolenceCheck(queryPattern)
     }
     if result != nil {
         return *result
@@ -547,49 +602,57 @@ func (j *Json) Get(pattern...string) interface{} {
     return nil
 }
 
-// 判断锁给定pattern是否数据存在
+// Contains checks whether the value by specified <pattern> exist.
 func (j *Json) Contains(pattern...string) bool {
     return j.Get(pattern...) != nil
 }
 
-// 计算指定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 (j *Json) Len(pattern string) int {
     p := j.getPointerByPattern(pattern)
     if p != nil {
         switch (*p).(type) {
-        case map[string]interface{}:
-            return len((*p).(map[string]interface{}))
-        case []interface{}:
-            return len((*p).([]interface{}))
-        default:
-            return -1
+            case map[string]interface{}:
+                return len((*p).(map[string]interface{}))
+            case []interface{}:
+                return len((*p).([]interface{}))
+            default:
+                return -1
         }
     }
     return -1
 }
 
-// 指定pattern追加元素
+// Append appends value to the value by specified <pattern>.
+// The target value by <pattern> should be type of slice.
 func (j *Json) Append(pattern string, value interface{}) error {
-    length := j.Len(pattern)
-    if length != -1 {
-        return j.Set(fmt.Sprintf("%s.%d", pattern, length), value)
+    p := j.getPointerByPattern(pattern)
+    if p == nil {
+        return j.Set(fmt.Sprintf("%s.0", pattern), value)
     }
-    return errors.New(fmt.Sprintf("cannot find item for pattern: %s", pattern))
+    switch (*p).(type) {
+        case []interface{}:
+            return j.Set(fmt.Sprintf("%s.%d", pattern, len((*p).([]interface{}))), value)
+    }
+    return fmt.Errorf("invalid variable type of %s", pattern)
 }
 
-// 根据pattern层级查找**变量指针**
-// 检索方式：例如检索 a.a.a ，值为1
-// 1. 检索 a.a.a.a 是否存在对应map的键名；
-// 2. 检索 a.a.a   是否存在对应map的键名；
-// 3. 检索 a.a     是否存在对应map的键名；
-// 4. 检索 a       是否存在对应map的键名，如果检索出这是一个map，假如为变量m1；
-// 5. 在m1中检索 a.a.a 否存在对应map的键名；
-// 6. 在m1中检索 a.a   否存在对应map的键名；
-// 7. 在m1中检索 a     否存在对应map的键名，如果检索出这是一个map，假如为变量m2；
-// 8. 在m2中检索 a.a   否存在对应map的键名；
-// 9. 在m2中检索 a     否存在对应map的键名，检索到有值，值为1；
-// 这样检索的复杂度很高，主要是为了避免键名中存在分隔符号(默认为".")的情况，避免歧义。
+// Get a pointer to the value by specified <pattern>.
 func (j *Json) getPointerByPattern(pattern string) *interface{} {
+    if j.vc {
+        return j.getPointerByPatternWithViolenceCheck(pattern)
+    } else {
+        return j.getPointerByPatternWithoutViolenceCheck(pattern)
+    }
+}
+
+// Get a pointer to the value of specified <pattern> with violence check.
+func (j *Json) getPointerByPatternWithViolenceCheck(pattern string) *interface{} {
+    if !j.vc {
+        return j.getPointerByPatternWithoutViolenceCheck(pattern)
+    }
     index   := len(pattern)
     start   := 0
     length  := 0
@@ -611,7 +674,7 @@ func (j *Json) getPointerByPattern(pattern string) *interface{} {
                 pointer = r
             }
         } else {
-            // 查找下一个分割符号的索引位置
+            // Get the position for next separator char.
             index = strings.LastIndexByte(pattern[start:index], j.c)
             if index != -1 && length > 0 {
                 index += length + 1
@@ -624,8 +687,11 @@ func (j *Json) getPointerByPattern(pattern string) *interface{} {
     return nil
 }
 
-// 层级检索，内部不执行分隔符冲突检查，检索效率会有所提高，但是冲突需要开发者自己根据自定义的分隔符来进行解决
-func (j *Json) getPointerByPatternWithoutSplitCharViolenceCheck(pattern string) *interface{} {
+// Get a pointer to the value of specified <pattern>, with no violence check.
+func (j *Json) getPointerByPatternWithoutViolenceCheck(pattern string) *interface{} {
+    if j.vc {
+        return j.getPointerByPatternWithViolenceCheck(pattern)
+    }
     pointer := j.p
     if len(pattern) == 0 {
         return pointer
@@ -645,26 +711,27 @@ func (j *Json) getPointerByPatternWithoutSplitCharViolenceCheck(pattern string)
     return nil
 }
 
-// 判断给定的key在当前的pointer下是否有值，并返回对应的pointer
-// 注意这里返回的指针都是临时变量的内存地址
+// Check whether there's value by <key> in specified <pointer>.
+// It returns a pointer to the value.
 func (j *Json) checkPatternByPointer(key string, pointer *interface{}) *interface{} {
     switch (*pointer).(type) {
-    case map[string]interface{}:
-        if v, ok := (*pointer).(map[string]interface{})[key]; ok {
-            return &v
-        }
-    case []interface{}:
-        if gstr.IsNumeric(key) {
-            n, err := strconv.Atoi(key)
-            if err == nil && len((*pointer).([]interface{})) > n {
-                return &(*pointer).([]interface{})[n]
+        case map[string]interface{}:
+            if v, ok := (*pointer).(map[string]interface{})[key]; ok {
+                return &v
+            }
+        case []interface{}:
+            if gstr.IsNumeric(key) {
+                n, err := strconv.Atoi(key)
+                if err == nil && len((*pointer).([]interface{})) > n {
+                    return &(*pointer).([]interface{})[n]
+                }
             }
-        }
     }
     return nil
 }
 
-// 转换为map[string]interface{}类型,如果转换失败，返回nil
+// ToMap converts current Json object to map[string]interface{}.
+// It returns nil if fails.
 func (j *Json) ToMap() map[string]interface{} {
     j.mu.RLock()
     defer j.mu.RUnlock()
@@ -676,15 +743,16 @@ func (j *Json) ToMap() map[string]interface{} {
     }
 }
 
-// 转换为[]interface{}类型,如果转换失败，返回nil
+// ToArray converts current Json object to []interface{}.
+// It returns nil if fails.
 func (j *Json) ToArray() []interface{} {
     j.mu.RLock()
     defer j.mu.RUnlock()
     switch (*(j.p)).(type) {
-    case []interface{}:
-        return (*(j.p)).([]interface{})
-    default:
-        return nil
+        case []interface{}:
+            return (*(j.p)).([]interface{})
+        default:
+            return nil
     }
 }
 
@@ -692,42 +760,73 @@ func (j *Json) ToXml(rootTag...string) ([]byte, error) {
     return gxml.Encode(j.ToMap(), rootTag...)
 }
 
+func (j *Json) ToXmlString(rootTag...string) (string, error) {
+    b, e := j.ToXml(rootTag...)
+    return string(b), e
+}
+
 func (j *Json) ToXmlIndent(rootTag...string) ([]byte, error) {
     return gxml.EncodeWithIndent(j.ToMap(), rootTag...)
 }
 
+func (j *Json) ToXmlIndentString(rootTag...string) (string, error) {
+    b, e := j.ToXmlIndent(rootTag...)
+    return string(b), e
+}
+
 func (j *Json) ToJson() ([]byte, error) {
     j.mu.RLock()
     defer j.mu.RUnlock()
     return Encode(*(j.p))
 }
 
+func (j *Json) ToJsonString() (string, error) {
+    b, e := j.ToJson()
+    return string(b), e
+}
+
 func (j *Json) ToJsonIndent() ([]byte, error) {
     j.mu.RLock()
     defer j.mu.RUnlock()
     return json.MarshalIndent(*(j.p), "", "\t")
 }
 
+func (j *Json) ToJsonIndentString() (string, error) {
+    b, e := j.ToJsonIndent()
+    return string(b), e
+}
+
 func (j *Json) ToYaml() ([]byte, error) {
     j.mu.RLock()
     defer j.mu.RUnlock()
     return gyaml.Encode(*(j.p))
 }
 
+func (j *Json) ToYamlString() (string, error) {
+    b, e := j.ToYaml()
+    return string(b), e
+}
+
 func (j *Json) ToToml() ([]byte, error) {
     j.mu.RLock()
     defer j.mu.RUnlock()
     return gtoml.Encode(*(j.p))
 }
 
-// 转换为指定的struct对象
-func (j *Json) ToStruct(o interface{}) error {
-    j.mu.RLock()
-    defer j.mu.RUnlock()
-    return gconv.Struct(*(j.p), o)
+func (j *Json) ToTomlString() (string, error) {
+    b, e := j.ToToml()
+    return string(b), e
 }
 
-// 打印Json对象
+// ToStruct converts current Json object to specified object.
+// The <objPointer> should be a pointer type.
+func (j *Json) ToStruct(objPointer interface{}) error {
+    j.mu.RLock()
+    defer j.mu.RUnlock()
+    return gconv.Struct(*(j.p), objPointer)
+}
+
+// Dump prints current Json object with more manually readable.
 func (j *Json) Dump() error {
     j.mu.RLock()
     defer j.mu.RUnlock()

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})
+    }
+}
+

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"), g.Map{})
+        gtest.Assert(j.GetMap("m"), g.Map{"k" : "v"})
+        gtest.Assert(j.GetMap("a"), g.Map{})
+    })
+}
+
+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"), g.SliceStr{})
+    })
+}
+
+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)
+    })
+}
+
+
+

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")
+    })
+}

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)
+    }
+}

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)
 }

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"), g.Map{})
+        gtest.Assert(j.GetMap("m"), g.Map{"k" : "v"})
+        gtest.Assert(j.GetMap("a"), g.Map{})
+    })
+}
+
+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"), g.SliceStr{})
+    })
+}
+
+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)
+    })
+}
+
+
+

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")
+    })
+}

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)
+    }
+}

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
+}

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))
+
+}

g/frame/gins/gins.go

@@ -4,10 +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 gins provides instances management and some core components.
-// 
-// 单例对象管理.
-// 框架内置了一些核心对象获取方法，并且可以通过Set和Get方法实现IoC以及对内置核心对象的自定义替换
+// Package gins provides instances management and core components management.
 package gins
 
 import (
@@ -21,8 +18,10 @@ import (
     "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"
+    "github.com/gogf/gf/g/text/gstr"
+    "github.com/gogf/gf/g/util/gconv"
+    "time"
 )
 
 const (
@@ -73,11 +72,18 @@ func View(name...string) *gview.View {
     }
     key := fmt.Sprintf("%s.%s", gFRAME_CORE_COMPONENT_NAME_VIEW, group)
     return instances.GetOrSetFuncLock(key, func() interface{} {
-        path := cmdenv.Get("gf.gview.path", gfile.Pwd()).String()
-        view := gview.New(path)
-        // 添加基于源码的搜索目录检索地址，常用于开发环境调试，只添加入口文件目录
-        if p := gfile.MainPkgPath(); p != "" && gfile.Exists(p) {
-            view.AddPath(p)
+        view := gview.New(gfile.Pwd())
+        // 自定义的环境变量/启动参数路径，优先级最高，覆盖默认的工作目录
+        if envPath := cmdenv.Get("gf.gview.path").String(); envPath != "" && gfile.Exists(envPath) {
+            view.SetPath(envPath)
+        }
+        // 二进制文件执行目录
+        if selfPath := gfile.SelfDir(); selfPath != "" && gfile.Exists(selfPath) {
+            view.AddPath(selfPath)
+        }
+        // 开发环境源码main包目录
+        if mainPath := gfile.MainPkgPath(); mainPath != "" && gfile.Exists(mainPath) {
+            view.AddPath(mainPath)
         }
         // 框架内置函数
         view.BindFunc("config", funcConfig)
@@ -92,26 +98,9 @@ func Config(file...string) *gcfg.Config {
     if len(file) > 0 {
         configFile = file[0]
     }
-    return instances.GetOrSetFuncLock(fmt.Sprintf("%s.%s", gFRAME_CORE_COMPONENT_NAME_CONFIG, configFile),
-        func() interface{} {
-            pwdPath  := gfile.Pwd()
-            envPath  := cmdenv.Get("gf.gcfg.path").String()
-            selfPath := gfile.SelfDir()
-            mainPath := gfile.MainPkgPath()
-            config   := gcfg.New(pwdPath, configFile)
-            // 自定义的环境变量/启动参数路径，优先级最高，覆盖默认的工作目录
-            if envPath != "" && gfile.Exists(envPath) {
-                config.SetPath(envPath)
-            }
-            // 二进制文件执行目录
-            if selfPath != "" && gfile.Exists(selfPath) {
-                config.AddPath(selfPath)
-            }
-            // 开发环境源码main包目录
-            if mainPath != "" && gfile.Exists(mainPath) {
-                config.AddPath(mainPath)
-            }
-            return config
+    key := fmt.Sprintf("%s.%s", gFRAME_CORE_COMPONENT_NAME_CONFIG, configFile)
+    return instances.GetOrSetFuncLock(key, func() interface{} {
+        return gcfg.New(configFile)
     }).(*gcfg.Config)
 }
 
@@ -133,46 +122,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)
@@ -180,10 +189,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
@@ -208,11 +214,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]),
@@ -236,6 +267,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...)

g/frame/gins/gins_config_test.go

@@ -57,7 +57,7 @@ test = "v=1"
         err  := gfile.PutContents(path, config)
         gtest.Assert(err, nil)
         defer gfile.Remove(path)
-        defer gins.Config().Reload()
+        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")
@@ -71,7 +71,7 @@ test = "v=1"
         err  := gfile.PutContents(path, config)
         gtest.Assert(err, nil)
         defer gfile.Remove(path)
-        defer gins.Config().Reload()
+        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")
@@ -84,7 +84,7 @@ test = "v=1"
         err  := gfile.PutContents(path, config)
         gtest.Assert(err, nil)
         defer gfile.Remove(path)
-        defer gins.Config().Reload()
+        defer gins.Config().Clear()
         gtest.Assert(gins.Config("test.toml").Get("test"), "v=1")
         gtest.Assert(gins.Config("test.toml").Get("database.default.1.host"), "127.0.0.1")
         gtest.Assert(gins.Config("test.toml").Get("redis.disk"), "127.0.0.1:6379,0")
@@ -97,7 +97,7 @@ test = "v=1"
         err  := gfile.PutContents(path, config)
         gtest.Assert(err, nil)
         defer gfile.Remove(path)
-        defer gins.Config().Reload()
+        defer gins.Config().Clear()
         gtest.Assert(gins.Config("test.toml").Get("test"), "v=1")
         gtest.Assert(gins.Config("test.toml").Get("database.default.1.host"), "127.0.0.1")
         gtest.Assert(gins.Config("test.toml").Get("redis.disk"), "127.0.0.1:6379,0")
@@ -113,7 +113,7 @@ test = "v=1"
         err  := gfile.PutContents(file, config)
         gtest.Assert(err, nil)
         defer gfile.Remove(file)
-        defer gins.Config().Reload()
+        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")
@@ -127,7 +127,7 @@ test = "v=1"
         err  := gfile.PutContents(file, config)
         gtest.Assert(err, nil)
         defer gfile.Remove(file)
-        defer gins.Config().Reload()
+        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")
@@ -141,7 +141,7 @@ test = "v=1"
         err  := gfile.PutContents(file, config)
         gtest.Assert(err, nil)
         defer gfile.Remove(file)
-        defer gins.Config("test.toml").Reload()
+        defer gins.Config("test.toml").Clear()
 
         gtest.Assert(gins.Config("test.toml").AddPath(path), nil)
         gtest.Assert(gins.Config("test.toml").Get("test"),   "v=1")
@@ -156,7 +156,7 @@ test = "v=1"
         err  := gfile.PutContents(file, config)
         gtest.Assert(err, nil)
         defer gfile.Remove(file)
-        defer gins.Config("test.toml").Reload()
+        defer gins.Config("test.toml").Clear()
 
         gtest.Assert(gins.Config("test.toml").AddPath(path), nil)
         gtest.Assert(gins.Config("test.toml").Get("test"),   "v=1")

g/frame/gins/gins_database_test.go

@@ -53,7 +53,7 @@ test = "v=2"
     err  := gfile.PutContents(path, config)
     gtest.Assert(err, nil)
     defer gfile.Remove(path)
-    defer gins.Config().Reload()
+    defer gins.Config().Clear()
 
     // for gfsnotify callbacks to refresh cache of config file
     time.Sleep(500*time.Millisecond)

g/frame/gins/gins_redis_test.go

@@ -7,7 +7,6 @@
 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"
@@ -46,25 +45,28 @@ test = "v=3"
         priority = "1"
 # Redis数据库配置
 [redis]
-    default = "127.0.0.1:6379,0"
-    cache   = "127.0.0.1:6379,1"
+    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().Reload()
+    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"))
+        //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)
@@ -73,6 +75,12 @@ test = "v=3"
         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"))
     })
 }
 

g/g_func.go

@@ -7,20 +7,10 @@
 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 creates a *Var.
@@ -39,11 +29,18 @@ func 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 Catch function.
 // It always be used in TryCatch function.
 //
@@ -55,4 +52,15 @@ func Throw(exception interface{}) {
 // 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.
+// false: integer(0), bool(false), slice/map(len=0), nil;
+// true : other.
+//
+// 判断给定的变量是否为空。
+// 整型为0, 布尔为false, slice/map长度为0, 其他为nil的情况，都为空。
+// 为空时返回true，否则返回false。
+func IsEmpty(value interface{}) bool {
+    return empty.IsEmpty(value)
 }

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
+}

g/net/ghttp/ghttp_client_request.go

@@ -9,90 +9,58 @@
 package ghttp
 
 import (
-    "encoding/json"
-    "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请求
@@ -189,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),
@@ -311,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),

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 {
@@ -81,26 +81,29 @@ func (r *Request) GetVar(key string, def ... interface{}) gvar.VarRead {
 
 // 获取原始请求输入二进制。
 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 {
-    if r.rawContent == nil {
-        r.rawContent, _ = ioutil.ReadAll(r.Body)
-    }
-    return string(r.rawContent)
+    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
@@ -221,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
 }

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
 }
 

g/net/ghttp/ghttp_request_log.go

@@ -0,0 +1,14 @@
+// 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 ghttp
+
+import "fmt"
+
+// 打印error日志
+func (r *Request) Error(value... interface{}) {
+    r.Server.handleErrorLog(fmt.Sprint(value...), r)
+}

g/net/ghttp/ghttp_request_post.go

@@ -169,7 +169,7 @@ func (r *Request) GetPostMap(def...map[string]string) map[string]string {
 }
 
 // 将所有的request参数映射到struct属性上，参数object应当为一个struct对象的指针, mapping为非必需参数，自定义参数与属性的映射关系
-func (r *Request) GetPostToStruct(object interface{}, mapping...map[string]string) {
+func (r *Request) GetPostToStruct(object interface{}, mapping...map[string]string) error {
     tagmap := r.getStructParamsTagMap(object)
     if len(mapping) > 0 {
         for k, v := range mapping[0] {
@@ -180,5 +180,5 @@ func (r *Request) GetPostToStruct(object interface{}, mapping...map[string]strin
     for k, v := range r.GetPostMap() {
         params[k] = v
     }
-    gconv.Struct(params, object, tagmap)
+    return gconv.Struct(params, object, tagmap)
 }

g/net/ghttp/ghttp_request_query.go

@@ -177,7 +177,7 @@ func (r *Request) GetQueryMap(def ... map[string]string) map[string]string {
 }
 
 // 将所有的get参数映射到struct属性上，参数object应当为一个struct对象的指针, mapping为非必需参数，自定义参数与属性的映射关系
-func (r *Request) GetQueryToStruct(object interface{}, mapping...map[string]string) {
+func (r *Request) GetQueryToStruct(object interface{}, mapping...map[string]string) error {
     tagmap := r.getStructParamsTagMap(object)
     if len(mapping) > 0 {
         for k, v := range mapping[0] {
@@ -188,5 +188,5 @@ func (r *Request) GetQueryToStruct(object interface{}, mapping...map[string]stri
     for k, v := range r.GetQueryMap() {
         params[k] = v
     }
-    gconv.Struct(params, object, tagmap)
+    return gconv.Struct(params, object, tagmap)
 }

g/net/ghttp/ghttp_request_request.go

@@ -162,7 +162,7 @@ func (r *Request) GetRequestMap(def...map[string]string) map[string]string {
 }
 
 // 将所有的request参数映射到struct属性上，参数object应当为一个struct对象的指针, mapping为非必需参数，自定义参数与属性的映射关系
-func (r *Request) GetRequestToStruct(object interface{}, mapping...map[string]string) {
+func (r *Request) GetRequestToStruct(object interface{}, mapping...map[string]string) error {
     tagmap := r.getStructParamsTagMap(object)
     if len(mapping) > 0 {
         for k, v := range mapping[0] {
@@ -178,6 +178,6 @@ func (r *Request) GetRequestToStruct(object interface{}, mapping...map[string]st
             params = j.ToMap()
         }
     }
-    gconv.Struct(params, object, tagmap)
+    return gconv.Struct(params, object, tagmap)
 }
 

g/net/ghttp/ghttp_response_cors.go

@@ -56,7 +56,7 @@ func (r *Response) CORS(options CORSOptions) {
     }
 }
 
-// 允许请求跨域访问(使用more配置).
+// 允许请求跨域访问(使用默认配置).
 func (r *Response) CORSDefault() {
     r.CORS(r.DefaultCORSOptions())
 }

g/net/ghttp/ghttp_server.go

@@ -15,7 +15,6 @@ import (
     "github.com/gogf/gf/g/container/gtype"
     "github.com/gogf/gf/g/os/gcache"
     "github.com/gogf/gf/g/os/genv"
-    "github.com/gogf/gf/g/os/gfile"
     "github.com/gogf/gf/g/os/glog"
     "github.com/gogf/gf/g/os/gproc"
     "github.com/gogf/gf/g/os/gtimer"
@@ -108,7 +107,10 @@ const (
     HOOK_AFTER_SERVE           = "AfterServe"
     HOOK_BEFORE_OUTPUT         = "BeforeOutput"
     HOOK_AFTER_OUTPUT          = "AfterOutput"
+
+    // deprecated.
     HOOK_BEFORE_CLOSE          = "BeforeClose"
+    // deprecated.
     HOOK_AFTER_CLOSE           = "AfterClose"
 
     HTTP_METHODS               = "GET,PUT,POST,DELETE,PATCH,HEAD,CONNECT,OPTIONS,TRACE"
@@ -187,9 +189,9 @@ func serverProcessInit() {
     }
 
     // 是否处于开发环境
-    if gfile.MainPkgPath() != "" {
-        glog.Debug("GF notices that you're in develop environment, so error logs are auto enabled to stdout.")
-    }
+    //if gfile.MainPkgPath() != "" {
+    //    glog.Debug("GF notices that you're in develop environment, so error logs are auto enabled to stdout.")
+    //}
 }
 
 // 获取/创建一个默认配置的HTTP Server(默认监听端口是80)
@@ -217,8 +219,6 @@ func GetServer(name...interface{}) (*Server) {
         servedCount      : gtype.NewInt(),
         logger           : glog.New(),
     }
-    // 日志的标准输出默认关闭，但是错误信息会特殊处理
-    s.logger.SetStdPrint(false)
     // 初始化时使用默认配置
     s.SetConfig(defaultServerConfig)
     // 记录到全局ServerMap中
@@ -237,6 +237,11 @@ func (s *Server) Start() error {
         return errors.New("server is already running")
     }
 
+    // 没有注册任何路由，且没有开启文件服务，那么提示错误
+    if len(s.routesMap) == 0 && !s.config.FileServerEnabled {
+        glog.Fatal("[ghttp] no router set or static feature enabled, did you forget import the router?")
+    }
+
     // 底层http server配置
     if s.config.Handler == nil {
         s.config.Handler = http.HandlerFunc(s.defaultHttpHandle)
@@ -277,7 +282,7 @@ func (s *Server) Start() error {
     if gproc.IsChild() {
         gtimer.SetTimeout(2*time.Second, func() {
             if err := gproc.Send(gproc.PPid(), []byte("exit"), gADMIN_GPROC_COMM_GROUP); err != nil {
-                glog.Error("ghttp server error in process communication:", err)
+                glog.Error("[ghttp] server error in process communication:", err)
             }
         })
     }
@@ -350,7 +355,10 @@ func (s *Server) GetRouteMap() string {
     }
     addr := s.config.Addr
     if s.config.HTTPSAddr != "" {
-        addr += ",tls" + s.config.HTTPSAddr
+        if len(addr) > 0 {
+            addr += ","
+        }
+        addr += "tls" + s.config.HTTPSAddr
     }
     for _, a := range m {
         data := make([]string, 8)

g/net/ghttp/ghttp_server_admin_process.go

@@ -168,7 +168,7 @@ func getServerFdMap() map[string]listenerFdMap {
 func bufferToServerFdMap(buffer []byte) map[string]listenerFdMap {
     sfm := make(map[string]listenerFdMap)
     if len(buffer) > 0 {
-        j, _ := gjson.LoadContent(buffer, "json")
+        j, _ := gjson.LoadContent(buffer)
         for k, _ := range j.ToMap() {
             m := make(map[string]string)
             for k, v := range j.GetMap(k) {

g/net/ghttp/ghttp_server_config.go

@@ -74,10 +74,11 @@ type ServerConfig struct {
     Rewrites          map[string]string     // URI Rewrite重写配置
 
     // 日志配置
-    LogPath           string                // 存放日志的目录路径
-    LogHandler        LogHandler            // 自定义日志处理回调方法
-    ErrorLogEnabled   bool                  // 是否开启error log
-    AccessLogEnabled  bool                  // 是否开启access log
+    LogPath           string                // 存放日志的目录路径(默认为空，表示不写文件)
+    LogHandler        LogHandler            // 自定义日志处理回调方法(默认为空)
+    LogStdPrint       bool                  // 是否打印日志到终端(默认开启)
+    ErrorLogEnabled   bool                  // 是否开启error log(默认开启)
+    AccessLogEnabled  bool                  // 是否开启access log(默认关闭)
 
     // 其他设置
     NameToUriType     int                   // 服务注册时对象和方法名称转换为URI时的规则
@@ -110,12 +111,11 @@ var defaultServerConfig = ServerConfig {
     SessionMaxAge     : gDEFAULT_SESSION_MAX_AGE,
     SessionIdName     : gDEFAULT_SESSION_ID_NAME,
 
+    LogStdPrint       : true,
     ErrorLogEnabled   : true,
-
+    AccessLogEnabled  : false,
     GzipContentTypes  : defaultGzipContentTypes,
-
     DumpRouteMap      : true,
-
     RouterCacheExpire : 60,
     Rewrites          : make(map[string]string),
 }

g/net/ghttp/ghttp_server_config_logger.go

@@ -10,7 +10,10 @@ import (
     "github.com/gogf/gf/g/os/glog"
 )
 
-// 设置日志目录
+// 设置日志目录，只有在设置了日志目录的情况下才会输出日志到日志文件中。
+// 日志文件路径格式为：
+// 1. 请求日志: access/YYYY-MM-DD.log
+// 2. 错误日志: error/YYYY-MM-DD.log
 func (s *Server)SetLogPath(path string) {
     if s.Status() == SERVER_STATUS_RUNNING {
         glog.Error(gCHANGE_CONFIG_WHILE_RUNNING_ERROR)
@@ -23,6 +26,16 @@ func (s *Server)SetLogPath(path string) {
     s.logger.SetPath(path)
 }
 
+// 设置日志内容是否输出到终端，默认情况下只有错误日志才会自动输出到终端。
+// 如果需要输出请求日志到终端，默认情况下使用SetAccessLogEnabled方法开启请求日志特性即可。
+func (s *Server)SetLogStdPrint(enabled bool) {
+    if s.Status() == SERVER_STATUS_RUNNING {
+        glog.Error(gCHANGE_CONFIG_WHILE_RUNNING_ERROR)
+        return
+    }
+    s.config.LogStdPrint = enabled
+}
+
 // 设置是否开启access log日志功能
 func (s *Server)SetAccessLogEnabled(enabled bool) {
     if s.Status() == SERVER_STATUS_RUNNING {
@@ -51,7 +64,7 @@ func (s *Server) SetLogHandler(handler LogHandler) {
 }
 
 // 获取日志写入的回调函数
-func (s *Server) GetLogHandler() LogHandler {
+func (s *Server)GetLogHandler() LogHandler {
     return s.config.LogHandler
 }
 

g/net/ghttp/ghttp_server_config_static.go

@@ -57,15 +57,12 @@ func (s *Server)SetServerRoot(root string) {
         return
     }
     // RealPath的作用除了校验地址正确性以外，还转换分隔符号为当前系统正确的文件分隔符号
-    path := gfile.RealPath(root)
-    if path == "" {
-        path = gfile.RealPath(gfile.MainPkgPath() + gfile.Separator + root)
+    realPath, err := gfile.Search(root)
+    if err != nil {
+        glog.Fatal(fmt.Sprintf(`[ghttp] SetServerRoot failed: %s`, err.Error()))
     }
-    if path == "" {
-        glog.Fatal(fmt.Sprintf(`[ghttp] SetServerRoot failed: path "%s" does not exist`, root))
-    }
-    glog.Debug("[ghttp] SetServerRoot path:", path)
-    s.config.SearchPaths       = []string{strings.TrimRight(path, gfile.Separator)}
+    glog.Debug("[ghttp] SetServerRoot path:", realPath)
+    s.config.SearchPaths       = []string{strings.TrimRight(realPath, gfile.Separator)}
     s.config.FileServerEnabled = true
 }
 
@@ -75,13 +72,9 @@ func (s *Server) AddSearchPath(path string) {
         glog.Error(gCHANGE_CONFIG_WHILE_RUNNING_ERROR)
         return
     }
-    // RealPath的作用除了校验地址正确性以外，还转换分隔符号为当前系统正确的文件分隔符号
-    realPath := gfile.RealPath(path)
-    if realPath == "" {
-        realPath = gfile.RealPath(gfile.MainPkgPath() + gfile.Separator + path)
-    }
-    if realPath == "" {
-        glog.Fatal(fmt.Sprintf(`[ghttp] AddSearchPath failed: path "%s" does not exist`, path))
+    realPath, err := gfile.Search(path)
+    if err != nil {
+        glog.Fatal(fmt.Sprintf(`[ghttp] AddSearchPath failed: %s`, err.Error()))
     }
     s.config.SearchPaths       = append(s.config.SearchPaths, realPath)
     s.config.FileServerEnabled = true
@@ -93,13 +86,9 @@ func (s *Server) AddStaticPath(prefix string, path string) {
         glog.Error(gCHANGE_CONFIG_WHILE_RUNNING_ERROR)
         return
     }
-    // RealPath的作用除了校验地址正确性以外，还转换分隔符号为当前系统正确的文件分隔符号
-    realPath := gfile.RealPath(path)
-    if realPath == "" {
-        realPath = gfile.RealPath(gfile.MainPkgPath() + gfile.Separator + path)
-    }
-    if realPath == "" {
-        glog.Fatal(fmt.Sprintf(`[ghttp] AddStaticPath failed: path "%s" does not exist`, path))
+    realPath, err := gfile.Search(path)
+    if err != nil {
+        glog.Fatal(fmt.Sprintf(`[ghttp] AddStaticPath failed: %s`, err.Error()))
     }
     addItem := staticPathItem {
         prefix : prefix,

g/net/ghttp/ghttp_server_handler.go

@@ -35,6 +35,12 @@ func (s *Server)handleRequest(w http.ResponseWriter, r *http.Request) {
             r.URL.Path = rewrite
         }
     }
+
+    // URI默认值
+    if r.URL.Path == "" {
+        r.URL.Path = "/"
+    }
+
     // 去掉末尾的"/"号
     if r.URL.Path != "/" {
         for r.URL.Path[len(r.URL.Path) - 1] == '/' {
@@ -52,6 +58,13 @@ func (s *Server)handleRequest(w http.ResponseWriter, r *http.Request) {
         if !request.IsExited() {
             s.callHookHandler(HOOK_BEFORE_OUTPUT, request)
         }
+        // error log
+        if e := recover(); e != nil {
+            request.Response.WriteStatus(http.StatusInternalServerError)
+            s.handleErrorLog(e, request)
+        }
+        // access log
+        s.handleAccessLog(request)
         // 输出Cookie
         request.Cookie.Output()
         // 输出缓冲区
@@ -60,18 +73,8 @@ func (s *Server)handleRequest(w http.ResponseWriter, r *http.Request) {
         if !request.IsExited() {
             s.callHookHandler(HOOK_AFTER_OUTPUT, request)
         }
-        // 事件 - BeforeClose
-        s.callHookHandler(HOOK_BEFORE_CLOSE, request)
-        // access log
-        s.handleAccessLog(request)
-        // error log使用recover进行判断
-        if e := recover(); e != nil {
-            request.Response.WriteStatus(http.StatusInternalServerError)
-            s.handleErrorLog(e, request)
-        }
         // 更新Session会话超时时间
         request.Session.UpdateExpire()
-        s.callHookHandler(HOOK_AFTER_CLOSE, request)
     }()
 
     // ============================================================

g/net/ghttp/ghttp_server_log.go

@@ -9,7 +9,7 @@ package ghttp
 
 import (
     "fmt"
-    "github.com/gogf/gf/g/os/gfile"
+    "github.com/gogf/gf/g/os/gtime"
 )
 
 // 处理服务错误信息，主要是panic，http请求的status由access log进行管理
@@ -22,19 +22,19 @@ func (s *Server) handleAccessLog(r *Request) {
         v(r)
         return
     }
-    content := fmt.Sprintf(`"%s %s %s %s" %d`,
-        r.Method, r.Host, r.URL.String(), r.Proto,
+    content := fmt.Sprintf(`%d "%s %s %s %s"`,
         r.Response.Status,
+        r.Method, r.Host, r.URL.String(), r.Proto,
     )
     content += fmt.Sprintf(` %.3f`, float64(r.LeaveTime - r.EnterTime)/1000)
     content += fmt.Sprintf(`, %s, "%s", "%s"`, r.GetClientIp(), r.Referer(), r.UserAgent())
-    s.logger.Cat("access").Backtrace(false, 2).Println(content)
+    s.logger.Cat("access").Backtrace(false, 2).StdPrint(s.config.LogStdPrint).Println(content)
 }
 
 // 处理服务错误信息，主要是panic，http请求的status由access log进行管理
 func (s *Server) handleErrorLog(error interface{}, r *Request) {
     // 错误输出默认是开启的
-    if !s.IsErrorLogEnabled() && gfile.MainPkgPath() == "" {
+    if !s.IsErrorLogEnabled() {
         return
     }
 
@@ -46,17 +46,11 @@ func (s *Server) handleErrorLog(error interface{}, r *Request) {
 
     // 错误日志信息
     content := fmt.Sprintf(`%v, "%s %s %s %s"`, error, r.Method, r.Host, r.URL.String(), r.Proto)
-    content += fmt.Sprintf(` %.3f`, float64(r.LeaveTime - r.EnterTime)/1000)
-    content += fmt.Sprintf(`, %s, "%s", "%s"`,  r.GetClientIp(), r.Referer(), r.UserAgent())
-
-    if s.logger.GetPath() == "" {
-        // 错误信息特殊处理，在未开启日志文件保存时强制强制输出到终端
-        s.logger.Cat("error").Backtrace(true, 2).StdPrint(true).Error(content)
+    if r.LeaveTime > r.EnterTime {
+        content += fmt.Sprintf(` %.3f`, float64(r.LeaveTime - r.EnterTime)/1000)
     } else {
-        s.logger.Cat("error").Backtrace(true, 2).Error(content)
-        // 开发环境下(MainPkgPath)自动输出错误信息到标准输出
-        if gfile.MainPkgPath() != "" {
-            s.logger.Cat("error").Backtrace(true, 2).StdPrint(true).Error(content)
-        }
+        content += fmt.Sprintf(` %.3f`, float64(gtime.Microsecond() - r.EnterTime)/1000)
     }
+    content += fmt.Sprintf(`, %s, "%s", "%s"`,  r.GetClientIp(), r.Referer(), r.UserAgent())
+    s.logger.Cat("error").Backtrace(true, 2).StdPrint(s.config.LogStdPrint).Error(content)
 }

g/net/ghttp/ghttp_server_router.go

@@ -37,7 +37,7 @@ func (s *Server)parsePattern(pattern string) (domain, method, path string, err e
         }
     }
     if path == "" {
-        err = errors.New("invalid pattern")
+        err = errors.New("invalid pattern: URI should not be empty")
     }
     // 去掉末尾的"/"符号，与路由匹配时处理一致
     if path != "/" {
@@ -72,11 +72,11 @@ func (s *Server) setHandler(pattern string, handler *handlerItem, hook ... strin
     }
     domain, method, uri, err := s.parsePattern(pattern)
     if err != nil {
-        glog.Error("invalid pattern:", pattern)
+        glog.Error("invalid pattern:", pattern, err)
         return
     }
     if len(uri) == 0 || uri[0] != '/' {
-        glog.Error("invalid pattern:", pattern)
+        glog.Error("invalid pattern:", pattern, "URI should lead with '/'")
         return
     }
     // 注册地址记录及重复注册判断
@@ -84,7 +84,7 @@ func (s *Server) setHandler(pattern string, handler *handlerItem, hook ... strin
     caller := s.getHandlerRegisterCallerLine(handler)
     if len(hook) == 0 {
         if item, ok := s.routesMap[regkey]; ok {
-            glog.Errorfln(`duplicated route registry "%s", already registered in %s`, pattern, item[0].file)
+            glog.Errorfln(`duplicated route registry "%s", already registered at %s`, pattern, item[0].file)
             return
         }
     }

g/net/ghttp/ghttp_server_service_controller.go

@@ -43,14 +43,22 @@ func (s *Server)BindController(pattern string, c Controller, methods...string) {
         if mname == "Init" || mname == "Shut" || mname == "Exit"  {
             continue
         }
-        if _, ok := v.Method(i).Interface().(func()); !ok {
-            glog.Errorfln(`invalid method definition "%s", while "func()" is required`, v.Method(i).Type().String())
-            continue
-        }
         ctlName := gstr.Replace(t.String(), fmt.Sprintf(`%s.`, pkgName), "")
         if ctlName[0] == '*' {
             ctlName = fmt.Sprintf(`(%s)`, ctlName)
         }
+        if _, ok := v.Method(i).Interface().(func()); !ok {
+            if len(methodMap) > 0 {
+                // 指定的方法名称注册，那么需要使用错误提示
+                glog.Errorfln(`invalid route method: %s.%s.%s defined as "%s", but "func()" is required`,
+                    pkgPath, ctlName, mname, v.Method(i).Type().String())
+            } else {
+                // 否则只是Debug提示
+                glog.Debugfln(`ignore route method: %s.%s.%s defined as "%s", no match "func()"`,
+                    pkgPath, ctlName, mname, v.Method(i).Type().String())
+            }
+            continue
+        }
         key   := s.mergeBuildInNameToPattern(pattern, sname, mname, true)
         m[key] = &handlerItem {
             name  : fmt.Sprintf(`%s.%s.%s`, pkgPath, ctlName, mname),
@@ -93,16 +101,17 @@ func (s *Server)BindControllerMethod(pattern string, c Controller, method string
         glog.Error("invalid method name:" + mname)
         return
     }
-    if _, ok := fval.Interface().(func()); !ok {
-        glog.Errorfln(`invalid method definition "%s", while "func()" is required`, fval.Type().String())
-        return
-    }
     pkgPath := t.Elem().PkgPath()
     pkgName := gfile.Basename(pkgPath)
     ctlName := gstr.Replace(t.String(), fmt.Sprintf(`%s.`, pkgName), "")
     if ctlName[0] == '*' {
         ctlName = fmt.Sprintf(`(%s)`, ctlName)
     }
+    if _, ok := fval.Interface().(func()); !ok {
+        glog.Errorfln(`invalid route method: %s.%s.%s defined as "%s", but "func()" is required`,
+            pkgPath, ctlName, mname, fval.Type().String())
+        return
+    }
     key     := s.mergeBuildInNameToPattern(pattern, sname, mname, false)
     m[key]   = &handlerItem {
         name  : fmt.Sprintf(`%s.%s.%s`, pkgPath, ctlName, mname),
@@ -132,15 +141,16 @@ func (s *Server)BindControllerRest(pattern string, c Controller) {
         if _, ok := methodsMap[method]; !ok {
             continue
         }
-        if _, ok := v.Method(i).Interface().(func()); !ok {
-            glog.Errorfln(`invalid method definition "%s", while "func()" is required`, v.Method(i).Type().String())
-            return
-        }
         pkgName := gfile.Basename(pkgPath)
         ctlName := gstr.Replace(t.String(), fmt.Sprintf(`%s.`, pkgName), "")
         if ctlName[0] == '*' {
             ctlName = fmt.Sprintf(`(%s)`, ctlName)
         }
+        if _, ok := v.Method(i).Interface().(func()); !ok {
+            glog.Errorfln(`invalid route method: %s.%s.%s defined as "%s", but "func()" is required`,
+                pkgPath, ctlName, mname, v.Method(i).Type().String())
+            return
+        }
         key   := s.mergeBuildInNameToPattern(mname + ":" + pattern, sname, mname, false)
         m[key] = &handlerItem {
             name  : fmt.Sprintf(`%s.%s.%s`, pkgPath, ctlName, mname),

g/net/ghttp/ghttp_server_service_object.go

@@ -49,15 +49,23 @@ func (s *Server)BindObject(pattern string, obj interface{}, methods...string) {
         if mname == "Init" || mname == "Shut" {
             continue
         }
-        faddr, ok := v.Method(i).Interface().(func(*Request))
-        if !ok {
-            glog.Errorfln(`invalid method definition "%s", while "func(*Request))" is required`, v.Method(i).Type().String())
-            continue
-        }
         objName := gstr.Replace(t.String(), fmt.Sprintf(`%s.`, pkgName), "")
         if objName[0] == '*' {
             objName = fmt.Sprintf(`(%s)`, objName)
         }
+        faddr, ok := v.Method(i).Interface().(func(*Request))
+        if !ok {
+            if len(methodMap) > 0 {
+                // 指定的方法名称注册，那么需要使用错误提示
+                glog.Errorfln(`invalid route method: %s.%s.%s defined as "%s", but "func(*ghttp.Request)" is required`,
+                    pkgPath, objName, mname, v.Method(i).Type().String())
+            } else {
+                // 否则只是Debug提示
+                glog.Debugfln(`ignore route method: %s.%s.%s defined as "%s", no match "func(*ghttp.Request)"`,
+                    pkgPath, objName, mname, v.Method(i).Type().String())
+            }
+            continue
+        }
         key    := s.mergeBuildInNameToPattern(pattern, sname, mname, true)
         m[key]  = &handlerItem {
             name  : fmt.Sprintf(`%s.%s.%s`, pkgPath, objName, mname),
@@ -103,11 +111,6 @@ func (s *Server)BindObjectMethod(pattern string, obj interface{}, method string)
         glog.Error("invalid method name:" + mname)
         return
     }
-    faddr, ok := fval.Interface().(func(*Request))
-    if !ok {
-        glog.Errorfln(`invalid method definition "%s", while "func(*Request)" is required`, fval.Type().String())
-        return
-    }
     finit := (func(*Request))(nil)
     fshut := (func(*Request))(nil)
     if v.MethodByName("Init").IsValid() {
@@ -122,6 +125,12 @@ func (s *Server)BindObjectMethod(pattern string, obj interface{}, method string)
     if objName[0] == '*' {
         objName = fmt.Sprintf(`(%s)`, objName)
     }
+    faddr, ok := fval.Interface().(func(*Request))
+    if !ok {
+        glog.Errorfln(`invalid route method: %s.%s.%s defined as "%s", but "func(*ghttp.Request)" is required`,
+            pkgPath, objName, mname, fval.Type().String())
+        return
+    }
     key   := s.mergeBuildInNameToPattern(pattern, sname, mname, false)
     m[key] = &handlerItem{
         name  : fmt.Sprintf(`%s.%s.%s`, pkgPath, objName, mname),
@@ -158,16 +167,17 @@ func (s *Server)BindObjectRest(pattern string, obj interface{}) {
         if _, ok := methodsMap[method]; !ok {
             continue
         }
-        faddr, ok := v.Method(i).Interface().(func(*Request))
-        if !ok {
-            glog.Errorfln(`invalid method definition "%s", while "func(*Request)" is required`, v.Method(i).Type().String())
-            continue
-        }
         pkgName := gfile.Basename(pkgPath)
         objName := gstr.Replace(t.String(), fmt.Sprintf(`%s.`, pkgName), "")
         if objName[0] == '*' {
             objName = fmt.Sprintf(`(%s)`, objName)
         }
+        faddr, ok := v.Method(i).Interface().(func(*Request))
+        if !ok {
+            glog.Errorfln(`invalid route method: %s.%s.%s defined as "%s", but "func(*ghttp.Request)" is required`,
+                pkgPath, objName, mname, v.Method(i).Type().String())
+            continue
+        }
         key   := s.mergeBuildInNameToPattern(mname + ":" + pattern, sname, mname, false)
         m[key] = &handlerItem {
             name  : fmt.Sprintf(`%s.%s.%s`, pkgPath, objName, mname),

g/net/gtcp/gtcp_server.go

@@ -30,7 +30,7 @@ var serverMapping = gmap.NewStringInterfaceMap()
 
 // 获取/创建一个空配置的TCP Server
 // 单例模式，请保证name的唯一性
-func GetServer(name...interface{}) (*Server) {
+func GetServer(name...interface{}) *Server {
     serverName := gDEFAULT_SERVER
     if len(name) > 0 {
         serverName = gconv.String(name[0])

g/net/gudp/gudp_conn.go

@@ -221,8 +221,11 @@ func (c *Conn) LocalAddr() net.Addr {
     return c.conn.LocalAddr()
 }
 
+// 不能使用c.conn.RemoteAddr()，其返回为nil，
+// 这里使用c.raddr获取远程连接地址。
 func (c *Conn) RemoteAddr() net.Addr {
-    return c.conn.RemoteAddr()
+    //return c.conn.RemoteAddr()
+    return c.raddr
 }
 
 func (c *Conn) Close() error {

g/os/gcache/gcache_mem_cache.go

@@ -119,6 +119,9 @@ func (c *memCache) doSetWithLockCheck(key interface{}, value interface{}, expire
     if f, ok := value.(func() interface {}); ok {
         value = f()
     }
+    if value == nil {
+        return nil
+    }
     c.data[key] = memCacheItem{v : value, e : expireTimestamp}
     c.dataMu.Unlock()
     c.eventList.PushBack(&memCacheEvent{k : key, e : expireTimestamp})

g/os/gcache/gcache_z_unit_1_test.go

@@ -57,7 +57,7 @@ func TestCache_LRU(t *testing.T) {
 
         gtest.Assert(cache.Size(), 10)
         gtest.Assert(cache.Get(6), 6)
-        time.Sleep(3*time.Second)
+        time.Sleep(4*time.Second)
         gtest.Assert(cache.Size(), 2)
         gtest.Assert(cache.Get(6), 6)
         gtest.Assert(cache.Get(1), nil)

g/os/gcfg/gcfg.go

@@ -4,44 +4,41 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
-// Package gcfg provides reading, caching and managing for configuration files.
-// 
-// 配置管理,
-// 配置文件格式支持：json, xml, toml, yaml/yml
+// Package gcfg provides reading, caching and managing for configuration files/contents.
 package gcfg
 
 import (
-    "bytes"
-    "errors"
-    "fmt"
-    "github.com/gogf/gf/g/container/garray"
-    "github.com/gogf/gf/g/container/gmap"
-    "github.com/gogf/gf/g/container/gtype"
-    "github.com/gogf/gf/g/container/gvar"
-    "github.com/gogf/gf/g/encoding/gjson"
-    "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/gspath"
+	"bytes"
+	"errors"
+	"fmt"
+	"github.com/gogf/gf/g/container/garray"
+	"github.com/gogf/gf/g/container/gmap"
+	"github.com/gogf/gf/g/container/gtype"
+	"github.com/gogf/gf/g/container/gvar"
+	"github.com/gogf/gf/g/encoding/gjson"
+	"github.com/gogf/gf/g/internal/cmdenv"
+	"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/gspath"
 )
 
 const (
-    // 默认的配置管理文件名称
+    // Default configuration file name.
     DEFAULT_CONFIG_FILE = "config.toml"
 )
 
-// 配置管理对象
+// Configuration struct.
 type Config struct {
-    name   *gtype.String            // 默认配置文件名称
-    paths  *garray.StringArray      // 搜索目录路径
-    jsons  *gmap.StringInterfaceMap // 配置文件对象
-    vc     *gtype.Bool              // 层级检索是否执行分隔符冲突检测(默认为false，检测会比较影响检索效率)
+    name   *gtype.String            // Default configuration file name.
+    paths  *garray.StringArray      // Searching path array.
+    jsons  *gmap.StringInterfaceMap // The pared JSON objects for configuration files.
+    vc     *gtype.Bool              // Whether do violence check in value index searching.
+                                    // It affects the performance when set true(false in default).
 }
 
 // New returns a new configuration management object.
-//
-// 生成一个配置管理对象
-func New(path string, file...string) *Config {
+func New(file...string) *Config {
     name := DEFAULT_CONFIG_FILE
     if len(file) > 0 {
         name = file[0]
@@ -52,15 +49,24 @@ func New(path string, file...string) *Config {
         jsons  : gmap.NewStringInterfaceMap(),
         vc     : gtype.NewBool(),
     }
-    if len(path) > 0 {
-        c.SetPath(path)
-    }
+    // Dir path of working dir.
+    c.SetPath(gfile.Pwd())
+	// Dir path from env/cmd, most high priority, will overwrite previous dir path setting.
+	if envPath := cmdenv.Get("gf.gcfg.path").String(); envPath != "" && gfile.Exists(envPath) {
+		c.SetPath(envPath)
+	}
+	// Dir path of binary.
+	if selfPath := gfile.SelfDir(); selfPath != "" && gfile.Exists(selfPath) {
+		c.AddPath(selfPath)
+	}
+	// Dir path of main package.
+	if mainPath := gfile.MainPkgPath(); mainPath != "" && gfile.Exists(mainPath) {
+		c.AddPath(mainPath)
+	}
     return c
 }
 
 // filePath returns the absolute configuration file path for the given filename by <file>.
-//
-// 判断从哪个配置文件中获取内容，返回配置文件的绝对路径
 func (c *Config) filePath(file...string) (path string) {
     name := c.name.Val()
     if len(file) > 0 {
@@ -86,10 +92,40 @@ func (c *Config) filePath(file...string) (path string) {
 
 // 设置配置管理器的配置文件存放目录绝对路径
 func (c *Config) SetPath(path string) error {
+    // 判断绝对路径(或者工作目录下目录)
     realPath := gfile.RealPath(path)
     if realPath == "" {
-        err := errors.New(fmt.Sprintf(`path "%s" does not exist`, path))
-        glog.Error(fmt.Sprintf(`[gcfg] SetPath failed: %s`, err.Error()))
+        // 判断相对路径
+        c.paths.RLockFunc(func(array []string) {
+            for _, v := range array {
+                if path, _ := gspath.Search(v, path); path != "" {
+                    realPath = path
+                    break
+                }
+            }
+        })
+    }
+    // 目录不存在错误处理
+    if realPath == "" {
+        buffer := bytes.NewBuffer(nil)
+        if c.paths.Len() > 0 {
+            buffer.WriteString(fmt.Sprintf("[gcfg] SetPath failed: cannot find directory \"%s\" in following paths:", path))
+            c.paths.RLockFunc(func(array []string) {
+                for k, v := range array {
+                    buffer.WriteString(fmt.Sprintf("\n%d. %s",k + 1,  v))
+                }
+            })
+        } else {
+            buffer.WriteString(fmt.Sprintf(`[gcfg] SetPath failed: path "%s" does not exist`, path))
+        }
+        err := errors.New(buffer.String())
+        glog.Error(err)
+        return err
+    }
+    // 路径必须为目录类型
+    if !gfile.IsDir(realPath) {
+        err := errors.New(fmt.Sprintf(`[gcfg] SetPath failed: path "%s" should be directory type`, path))
+        glog.Error(err)
         return err
     }
     // 重复判断
@@ -107,15 +143,45 @@ func (c *Config) SetPath(path string) error {
 // 开启比较耗性能，也不建议允许键名中存在分隔符，最好在应用端避免这种情况。
 func (c *Config) SetViolenceCheck(check bool) {
     c.vc.Set(check)
-    c.Reload()
+    c.Clear()
 }
 
 // 添加配置管理器的配置文件搜索路径
 func (c *Config) AddPath(path string) error {
+    // 判断绝对路径(或者工作目录下目录)
     realPath := gfile.RealPath(path)
     if realPath == "" {
-        err := errors.New(fmt.Sprintf(`path "%s" does not exist`, path))
-        glog.Error(fmt.Sprintf(`[gcfg] AddPath failed: %s`, err.Error()))
+        // 判断相对路径
+        c.paths.RLockFunc(func(array []string) {
+            for _, v := range array {
+                if path, _ := gspath.Search(v, path); path != "" {
+                    realPath = path
+                    break
+                }
+            }
+        })
+    }
+    // 目录不存在错误处理
+    if realPath == "" {
+        buffer := bytes.NewBuffer(nil)
+        if c.paths.Len() > 0 {
+            buffer.WriteString(fmt.Sprintf("[gcfg] AddPath failed: cannot find directory \"%s\" in following paths:", path))
+            c.paths.RLockFunc(func(array []string) {
+                for k, v := range array {
+                    buffer.WriteString(fmt.Sprintf("\n%d. %s",k + 1,  v))
+                }
+            })
+        } else {
+            buffer.WriteString(fmt.Sprintf(`[gcfg] AddPath failed: path "%s" does not exist`, path))
+        }
+        err := errors.New(buffer.String())
+        glog.Error(err)
+        return err
+    }
+    // 路径必须为目录类型
+    if !gfile.IsDir(realPath) {
+        err := errors.New(fmt.Sprintf(`[gcfg] AddPath failed: path "%s" should be directory type`, path))
+        glog.Error(err)
         return err
     }
     // 重复判断
@@ -155,23 +221,49 @@ func (c *Config) SetFileName(name string) {
     c.name.Set(name)
 }
 
+// 获取配置管理对象的默认文件名称
+func (c *Config) GetFileName() string {
+    return c.name.Val()
+}
+
 // 添加配置文件到配置管理器中，第二个参数为非必须，如果不输入表示添加进入默认的配置名称中
+// 内部带缓存控制功能。
 func (c *Config) getJson(file...string) *gjson.Json {
-    filePath := c.filePath(file...)
-    if filePath == "" {
+    name := c.name.Val()
+    if len(file) > 0 {
+        name = file[0]
+    }
+    r := c.jsons.GetOrSetFuncLock(name, func() interface{} {
+        content  := ""
+        filePath := ""
+        if content = GetContent(name); content == "" {
+            filePath = c.filePath(name)
+            if filePath == "" {
+                return nil
+            }
+            content = gfile.GetContents(filePath)
+        }
+        if j, err := gjson.LoadContent(content); err == nil {
+            j.SetViolenceCheck(c.vc.Val())
+            // 添加配置文件监听，如果有任何变化，删除文件内容缓存，下一次查询会自动更新
+            if filePath != "" {
+                gfsnotify.Add(filePath, func(event *gfsnotify.Event) {
+                    c.jsons.Remove(name)
+                })
+            }
+            return j
+        } else {
+            if filePath != "" {
+                glog.Criticalfln(`[gcfg] Load config file "%s" failed: %s`, filePath, err.Error())
+            } else {
+                glog.Criticalfln(`[gcfg] Load configuration failed: %s`, err.Error())
+            }
+        }
         return nil
-    }
-    if r := c.jsons.Get(filePath); r != nil {
+    })
+    if r != nil {
         return r.(*gjson.Json)
     }
-    if j, err := gjson.Load(filePath); err == nil {
-        j.SetViolenceCheck(c.vc.Val())
-        c.addMonitor(filePath)
-        c.jsons.Set(filePath, j)
-        return j
-    } else {
-        glog.Errorfln(`[gcfg] Load config file "%s" failed: %s`, filePath, err.Error())
-    }
     return nil
 }
 
@@ -357,19 +449,14 @@ func (c *Config) GetToStruct(pattern string, objPointer interface{}, file...stri
     return errors.New("config file not found")
 }
 
-// 清空当前配置文件缓存，强制重新从磁盘文件读取配置文件内容
+// Deprecated. See Clear.
 func (c *Config) Reload() {
     c.jsons.Clear()
 }
 
-// 添加文件监控
-func (c *Config) addMonitor(path string) {
-    // 防止多goroutine同时调用
-    if c.jsons.Get(path) != nil {
-        return
-    }
-    gfsnotify.Add(path, func(event *gfsnotify.Event) {
-        // 删除文件内容缓存，下一次查询会自动更新
-        c.jsons.Remove(event.Path)
-    })
+// Clear removes all parsed configuration files content cache,
+// which will force reload configuration content from file.
+func (c *Config) Clear() {
+    c.jsons.Clear()
 }
+

g/os/gcfg/gcfg_config.go

@@ -0,0 +1,39 @@
+// 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 gcfg
+
+import "github.com/gogf/gf/g/container/gmap"
+
+var (
+    // Customized configuration content.
+    configs = gmap.NewStringStringMap()
+)
+
+// SetContent sets customized configuration content for specified <file>.
+// The <file> is unnecessary param, default is DEFAULT_CONFIG_FILE.
+func SetContent(content string, file...string) {
+    name := DEFAULT_CONFIG_FILE
+    if len(file) > 0 {
+        name = file[0]
+    }
+    configs.Set(name, content)
+}
+
+// GetContent returns customized configuration content for specified <file>.
+// The <file> is unnecessary param, default is DEFAULT_CONFIG_FILE.
+func GetContent(file...string) string {
+    name := DEFAULT_CONFIG_FILE
+    if len(file) > 0 {
+        name = file[0]
+    }
+    return configs.Get(name)
+}
+
+// ClearContent removes all global configuration contents.
+func ClearContent() {
+    configs.Clear()
+}

g/os/gcfg/gcfg_instance.go

@@ -0,0 +1,27 @@
+// 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 gcfg
+
+import (
+	"github.com/gogf/gf/g/container/gmap"
+)
+
+var (
+    // Instances map.
+    instances = gmap.NewStringInterfaceMap()
+)
+
+// Instance returns an instance of Config.
+func Instance(file...string) *Config {
+	configFile := DEFAULT_CONFIG_FILE
+	if len(file) > 0 {
+		configFile = file[0]
+	}
+	return instances.GetOrSetFuncLock(configFile, func() interface{} {
+		return New(configFile)
+	}).(*Config)
+}

g/os/gcfg/gcfg_z_unit_test.go

@@ -27,12 +27,12 @@ array = [1,2,3]
     cache = "127.0.0.1:6379,1"
 `
     gtest.Case(t, func() {
-        path := "config.toml"
+        path := gcfg.DEFAULT_CONFIG_FILE
         err  := gfile.PutContents(path, config)
         gtest.Assert(err, nil)
         defer gfile.Remove(path)
 
-        c := gcfg.New(".")
+        c := gcfg.New()
         gtest.Assert(c.Get("v1"),           1)
         gtest.AssertEQ(c.GetInt("v1"),      1)
         gtest.AssertEQ(c.GetInt8("v1"),     int8(1))
@@ -71,7 +71,201 @@ array = [1,2,3]
             "disk"  : "127.0.0.1:6379,0",
             "cache" : "127.0.0.1:6379,1",
         })
-        gtest.AssertEQ(c.GetFilePath(),    gfile.Pwd() + gfile.Separator + "config.toml")
+        gtest.AssertEQ(c.GetFilePath(),    gfile.Pwd() + gfile.Separator + path)
 
     })
 }
+
+func Test_Content(t *testing.T) {
+    content := `
+v1    = 1
+v2    = "true"
+v3    = "off"
+v4    = "1.23"
+array = [1,2,3]
+[redis]
+    disk  = "127.0.0.1:6379,0"
+    cache = "127.0.0.1:6379,1"
+`
+    gcfg.SetContent(content)
+    defer gcfg.ClearContent()
+
+    gtest.Case(t, func() {
+        c := gcfg.New()
+        gtest.Assert(c.Get("v1"),           1)
+        gtest.AssertEQ(c.GetInt("v1"),      1)
+        gtest.AssertEQ(c.GetInt8("v1"),     int8(1))
+        gtest.AssertEQ(c.GetInt16("v1"),    int16(1))
+        gtest.AssertEQ(c.GetInt32("v1"),    int32(1))
+        gtest.AssertEQ(c.GetInt64("v1"),    int64(1))
+        gtest.AssertEQ(c.GetUint("v1"),     uint(1))
+        gtest.AssertEQ(c.GetUint8("v1"),    uint8(1))
+        gtest.AssertEQ(c.GetUint16("v1"),   uint16(1))
+        gtest.AssertEQ(c.GetUint32("v1"),   uint32(1))
+        gtest.AssertEQ(c.GetUint64("v1"),   uint64(1))
+
+        gtest.AssertEQ(c.GetVar("v1").String(), "1")
+        gtest.AssertEQ(c.GetVar("v1").Bool(),   true)
+        gtest.AssertEQ(c.GetVar("v2").String(), "true")
+        gtest.AssertEQ(c.GetVar("v2").Bool(),   true)
+
+        gtest.AssertEQ(c.GetString("v1"),  "1")
+        gtest.AssertEQ(c.GetFloat32("v4"), float32(1.23))
+        gtest.AssertEQ(c.GetFloat64("v4"), float64(1.23))
+        gtest.AssertEQ(c.GetString("v2"),  "true")
+        gtest.AssertEQ(c.GetBool("v2"),    true)
+        gtest.AssertEQ(c.GetBool("v3"),    false)
+
+        gtest.AssertEQ(c.Contains("v1"),    true)
+        gtest.AssertEQ(c.Contains("v2"),    true)
+        gtest.AssertEQ(c.Contains("v3"),    true)
+        gtest.AssertEQ(c.Contains("v4"),    true)
+        gtest.AssertEQ(c.Contains("v5"),    false)
+
+        gtest.AssertEQ(c.GetInts("array"),        []int{1,2,3})
+        gtest.AssertEQ(c.GetStrings("array"),     []string{"1","2","3"})
+        gtest.AssertEQ(c.GetArray("array"),       []interface{}{"1","2","3"})
+        gtest.AssertEQ(c.GetInterfaces("array"),  []interface{}{"1","2","3"})
+        gtest.AssertEQ(c.GetMap("redis"),         map[string]interface{}{
+            "disk"  : "127.0.0.1:6379,0",
+            "cache" : "127.0.0.1:6379,1",
+        })
+    })
+}
+
+func Test_SetFileName(t *testing.T) {
+    config := `
+{
+	"array": [
+		1,
+		2,
+		3
+	],
+	"redis": {
+		"cache": "127.0.0.1:6379,1",
+		"disk": "127.0.0.1:6379,0"
+	},
+	"v1": 1,
+	"v2": "true",
+	"v3": "off",
+	"v4": "1.234"
+}
+`
+    gtest.Case(t, func() {
+        path := "config.json"
+        err  := gfile.PutContents(path, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(path)
+
+        c := gcfg.New()
+        c.SetFileName(path)
+        gtest.Assert(c.Get("v1"),           1)
+        gtest.AssertEQ(c.GetInt("v1"),      1)
+        gtest.AssertEQ(c.GetInt8("v1"),     int8(1))
+        gtest.AssertEQ(c.GetInt16("v1"),    int16(1))
+        gtest.AssertEQ(c.GetInt32("v1"),    int32(1))
+        gtest.AssertEQ(c.GetInt64("v1"),    int64(1))
+        gtest.AssertEQ(c.GetUint("v1"),     uint(1))
+        gtest.AssertEQ(c.GetUint8("v1"),    uint8(1))
+        gtest.AssertEQ(c.GetUint16("v1"),   uint16(1))
+        gtest.AssertEQ(c.GetUint32("v1"),   uint32(1))
+        gtest.AssertEQ(c.GetUint64("v1"),   uint64(1))
+
+        gtest.AssertEQ(c.GetVar("v1").String(), "1")
+        gtest.AssertEQ(c.GetVar("v1").Bool(),   true)
+        gtest.AssertEQ(c.GetVar("v2").String(), "true")
+        gtest.AssertEQ(c.GetVar("v2").Bool(),   true)
+
+        gtest.AssertEQ(c.GetString("v1"),  "1")
+        gtest.AssertEQ(c.GetFloat32("v4"), float32(1.234))
+        gtest.AssertEQ(c.GetFloat64("v4"), float64(1.234))
+        gtest.AssertEQ(c.GetString("v2"),  "true")
+        gtest.AssertEQ(c.GetBool("v2"),    true)
+        gtest.AssertEQ(c.GetBool("v3"),    false)
+
+        gtest.AssertEQ(c.Contains("v1"),    true)
+        gtest.AssertEQ(c.Contains("v2"),    true)
+        gtest.AssertEQ(c.Contains("v3"),    true)
+        gtest.AssertEQ(c.Contains("v4"),    true)
+        gtest.AssertEQ(c.Contains("v5"),    false)
+
+        gtest.AssertEQ(c.GetInts("array"),        []int{1,2,3})
+        gtest.AssertEQ(c.GetStrings("array"),     []string{"1","2","3"})
+        gtest.AssertEQ(c.GetArray("array"),       []interface{}{"1","2","3"})
+        gtest.AssertEQ(c.GetInterfaces("array"),  []interface{}{"1","2","3"})
+        gtest.AssertEQ(c.GetMap("redis"),         map[string]interface{}{
+            "disk"  : "127.0.0.1:6379,0",
+            "cache" : "127.0.0.1:6379,1",
+        })
+        gtest.AssertEQ(c.GetFilePath(),    gfile.Pwd() + gfile.Separator + path)
+
+    })
+}
+
+func Test_Instance(t *testing.T) {
+    config := `
+{
+	"array": [
+		1,
+		2,
+		3
+	],
+	"redis": {
+		"cache": "127.0.0.1:6379,1",
+		"disk": "127.0.0.1:6379,0"
+	},
+	"v1": 1,
+	"v2": "true",
+	"v3": "off",
+	"v4": "1.234"
+}
+`
+    gtest.Case(t, func() {
+        path := gcfg.DEFAULT_CONFIG_FILE
+        err  := gfile.PutContents(path, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(path)
+
+        c := gcfg.Instance()
+        gtest.Assert(c.Get("v1"),           1)
+        gtest.AssertEQ(c.GetInt("v1"),      1)
+        gtest.AssertEQ(c.GetInt8("v1"),     int8(1))
+        gtest.AssertEQ(c.GetInt16("v1"),    int16(1))
+        gtest.AssertEQ(c.GetInt32("v1"),    int32(1))
+        gtest.AssertEQ(c.GetInt64("v1"),    int64(1))
+        gtest.AssertEQ(c.GetUint("v1"),     uint(1))
+        gtest.AssertEQ(c.GetUint8("v1"),    uint8(1))
+        gtest.AssertEQ(c.GetUint16("v1"),   uint16(1))
+        gtest.AssertEQ(c.GetUint32("v1"),   uint32(1))
+        gtest.AssertEQ(c.GetUint64("v1"),   uint64(1))
+
+        gtest.AssertEQ(c.GetVar("v1").String(), "1")
+        gtest.AssertEQ(c.GetVar("v1").Bool(),   true)
+        gtest.AssertEQ(c.GetVar("v2").String(), "true")
+        gtest.AssertEQ(c.GetVar("v2").Bool(),   true)
+
+        gtest.AssertEQ(c.GetString("v1"),  "1")
+        gtest.AssertEQ(c.GetFloat32("v4"), float32(1.234))
+        gtest.AssertEQ(c.GetFloat64("v4"), float64(1.234))
+        gtest.AssertEQ(c.GetString("v2"),  "true")
+        gtest.AssertEQ(c.GetBool("v2"),    true)
+        gtest.AssertEQ(c.GetBool("v3"),    false)
+
+        gtest.AssertEQ(c.Contains("v1"),    true)
+        gtest.AssertEQ(c.Contains("v2"),    true)
+        gtest.AssertEQ(c.Contains("v3"),    true)
+        gtest.AssertEQ(c.Contains("v4"),    true)
+        gtest.AssertEQ(c.Contains("v5"),    false)
+
+        gtest.AssertEQ(c.GetInts("array"),        []int{1,2,3})
+        gtest.AssertEQ(c.GetStrings("array"),     []string{"1","2","3"})
+        gtest.AssertEQ(c.GetArray("array"),       []interface{}{"1","2","3"})
+        gtest.AssertEQ(c.GetInterfaces("array"),  []interface{}{"1","2","3"})
+        gtest.AssertEQ(c.GetMap("redis"),         map[string]interface{}{
+            "disk"  : "127.0.0.1:6379,0",
+            "cache" : "127.0.0.1:6379,1",
+        })
+        gtest.AssertEQ(c.GetFilePath(),    gfile.Pwd() + gfile.Separator + path)
+
+    })
+}

g/os/gcron/gcron_cron.go

@@ -141,11 +141,6 @@ func (c *Cron) Search(name string) *Entry {
     return nil
 }
 
-// 根据指定名称删除定时任务
-func (c *Cron) Remove(name string) {
-    c.entries.Remove(name)
-}
-
 // 开启定时任务执行(可以指定特定名称的一个或若干个定时任务)
 func (c *Cron) Start(name...string) {
     if len(name) > 0 {
@@ -172,6 +167,13 @@ func (c *Cron) Stop(name...string) {
     }
 }
 
+// 根据指定名称删除定时任务。
+func (c *Cron) Remove(name string) {
+    if v := c.entries.Get(name); v != nil {
+        v.(*Entry).Close()
+    }
+}
+
 // 关闭定时任务
 func (c *Cron) Close() {
     c.status.Set(STATUS_CLOSED)

g/os/gcron/gcron_entry.go

@@ -87,7 +87,7 @@ func (entry *Entry) Stop() {
 
 // 关闭定时任务
 func (entry *Entry) Close() {
-    entry.cron.Remove(entry.Name)
+    entry.cron.entries.Remove(entry.Name)
     entry.entry.Close()
 }
 
@@ -96,6 +96,7 @@ func (entry *Entry) check() {
     if entry.schedule.meet(time.Now()) {
         path  := entry.cron.GetLogPath()
         level := entry.cron.GetLogLevel()
+        // 检查定时任务对象状态(非任务状态)
         switch entry.cron.status.Val() {
             case STATUS_STOPPED:
                 return

g/os/gcron/gcron_unit_1_test.go

@@ -71,6 +71,24 @@ func TestCron_Basic(t *testing.T) {
     })
 }
 
+func TestCron_Remove(t *testing.T) {
+    gtest.Case(t, func() {
+        cron  := gcron.New()
+        array := garray.New()
+        cron.Add("* * * * * *", func() {
+            array.Append(1)
+        }, "add")
+        gtest.Assert(array.Len(), 0)
+        time.Sleep(1200*time.Millisecond)
+        gtest.Assert(array.Len(), 1)
+
+        cron.Remove("add")
+        gtest.Assert(array.Len(), 1)
+        time.Sleep(1200*time.Millisecond)
+        gtest.Assert(array.Len(), 1)
+    })
+}
+
 func TestCron_AddSingleton(t *testing.T) {
     // un used, can be removed
     gtest.Case(t, func() {

g/os/gfile/gfile_search.go

@@ -0,0 +1,63 @@
+// Copyright 2017-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 gfile
+
+import (
+    "bytes"
+    "errors"
+    "fmt"
+    "github.com/gogf/gf/g/container/garray"
+)
+
+
+// 如果给定绝对路径将会去掉其中的相对路径符号后返回；
+// 如果是给定的相对路径，那么将会按照以下路径优先级搜索文件(重复路径会去重)：
+// prioritySearchPaths、当前工作目录、二进制文件目录、源码main包目录(开发环境下)
+func Search(name string, prioritySearchPaths...string) (realPath string, err error) {
+    // 是否绝对路径
+    realPath = RealPath(name)
+    if realPath != "" {
+        return
+    }
+    // 相对路径搜索
+    array := garray.NewStringArray(true)
+    // 自定义优先路径
+    array.Append(prioritySearchPaths...)
+    // 用户工作目录
+    array.Append(Pwd())
+    // 二进制所在目录
+    array.Append(SelfDir())
+    // 源码main包目录
+    if path := MainPkgPath(); path != "" {
+        array.Append(path)
+    }
+    // 路径去重
+    array.Unique()
+    // 执行相对路径搜索
+    array.RLockFunc(func(array []string) {
+        path := ""
+        for _, v := range array {
+            path = RealPath(v + Separator + name)
+            if path != "" {
+                realPath = path
+                break
+            }
+        }
+    })
+    // 目录不存在错误处理
+    if realPath == "" {
+        buffer := bytes.NewBuffer(nil)
+        buffer.WriteString(fmt.Sprintf("cannot find file/folder \"%s\" in following paths:", name))
+        array.RLockFunc(func(array []string) {
+            for k, v := range array {
+                buffer.WriteString(fmt.Sprintf("\n%d. %s", k + 1,  v))
+            }
+        })
+        err = errors.New(buffer.String())
+    }
+    return
+}

g/os/glog/glog_logger_chaining.go

@@ -12,7 +12,7 @@ import (
 )
 
 // To is a chaining function, 
-// which redirects current logging content output to the sepecified <writer>.
+// which redirects current logging content output to the specified <writer>.
 // 
 // 链式操作，设置下一次写入日志内容的Writer
 func (l *Logger) To(writer io.Writer) *Logger {

g/os/gview/gview.go

@@ -24,8 +24,8 @@ import (
     "github.com/gogf/gf/g/os/gspath"
     "github.com/gogf/gf/g/os/gtime"
     "github.com/gogf/gf/g/os/gview/internal/text/template"
-    "github.com/gogf/gf/g/util/gconv"
     "github.com/gogf/gf/g/text/gstr"
+    "github.com/gogf/gf/g/util/gconv"
     "strings"
     "sync"
 )
@@ -48,16 +48,10 @@ type FuncMap = map[string]interface{}
 // 默认的视图对象
 var viewObj *View
 
-// 初始化默认的视图对象
+// 初始化默认的视图对象, 默认加载包不会初始化，使用包方法才会初始化模板引擎对象。
 func checkAndInitDefaultView() {
     if viewObj == nil {
-        // gfile.MainPkgPath() 用以判断是否开发环境
-        mainPkgPath := gfile.MainPkgPath()
-        if gfile.MainPkgPath() == "" {
-            viewObj = New(gfile.Pwd())
-        } else {
-            viewObj = New(mainPkgPath)
-        }
+        viewObj = New(gfile.Pwd())
     }
 }
 
@@ -106,13 +100,40 @@ func New(path...string) *View {
 
 // 设置模板目录绝对路径
 func (view *View) SetPath(path string) error {
+    // 判断绝对路径(或者工作目录下目录)
     realPath := gfile.RealPath(path)
     if realPath == "" {
-        realPath = gfile.RealPath(gfile.MainPkgPath() + gfile.Separator + path)
+        // 判断相对路径
+        view.paths.RLockFunc(func(array []string) {
+            for _, v := range array {
+                if path, _ := gspath.Search(v, path); path != "" {
+                    realPath = path
+                    break
+                }
+            }
+        })
     }
+    // 目录不存在错误处理
     if realPath == "" {
-        err := errors.New(fmt.Sprintf(`path "%s" does not exist`, path))
-        glog.Error(fmt.Sprintf(`[gview] SetPath failed: %s`, err.Error()))
+        buffer := bytes.NewBuffer(nil)
+        if view.paths.Len() > 0 {
+            buffer.WriteString(fmt.Sprintf("[gview] SetPath failed: cannot find directory \"%s\" in following paths:", path))
+            view.paths.RLockFunc(func(array []string) {
+                for k, v := range array {
+                    buffer.WriteString(fmt.Sprintf("\n%d. %s",k + 1,  v))
+                }
+            })
+        } else {
+            buffer.WriteString(fmt.Sprintf(`[gview] SetPath failed: path "%s" does not exist`, path))
+        }
+        err := errors.New(buffer.String())
+        glog.Error(err)
+        return err
+    }
+    // 路径必须为目录类型
+    if !gfile.IsDir(realPath) {
+        err := errors.New(fmt.Sprintf(`[gview] SetPath failed: path "%s" should be directory type`, path))
+        glog.Error(err)
         return err
     }
     // 重复判断
@@ -127,13 +148,40 @@ func (view *View) SetPath(path string) error {
 
 // 添加模板目录搜索路径
 func (view *View) AddPath(path string) error {
+    // 判断绝对路径(或者工作目录下目录)
     realPath := gfile.RealPath(path)
     if realPath == "" {
-        realPath = gfile.RealPath(gfile.MainPkgPath() + gfile.Separator + path)
+        // 判断相对路径
+        view.paths.RLockFunc(func(array []string) {
+            for _, v := range array {
+                if path, _ := gspath.Search(v, path); path != "" {
+                    realPath = path
+                    break
+                }
+            }
+        })
     }
+    // 目录不存在错误处理
     if realPath == "" {
-        err := errors.New(fmt.Sprintf(`path "%s" does not exist`, path))
-        glog.Error(fmt.Sprintf(`[gview] AddPath failed: %s`, err.Error()))
+        buffer := bytes.NewBuffer(nil)
+        if view.paths.Len() > 0 {
+            buffer.WriteString(fmt.Sprintf("[gview] AddPath failed: cannot find directory \"%s\" in following paths:", path))
+            view.paths.RLockFunc(func(array []string) {
+                for k, v := range array {
+                    buffer.WriteString(fmt.Sprintf("\n%d. %s",k + 1,  v))
+                }
+            })
+        } else {
+            buffer.WriteString(fmt.Sprintf(`[gview] AddPath failed: path "%s" does not exist`, path))
+        }
+        err := errors.New(buffer.String())
+        glog.Error(err)
+        return err
+    }
+    // 路径必须为目录类型
+    if !gfile.IsDir(realPath) {
+        err := errors.New(fmt.Sprintf(`[gview] AddPath failed: path "%s" should be directory type`, path))
+        glog.Error(err)
         return err
     }
     // 重复判断

g/text/gstr/gstr_parse.go

@@ -12,92 +12,21 @@ import (
     "strings"
 )
 
-// Parses the string into variables.
-// f1=m&f2=n -> map[f1:m f2:n]
-// f[a]=m&f[b]=n -> map[f:map[a:m b:n]]
+// Parses the string into map[string]interface{}.
+//
+// f1=m&f2=n           -> map[f1:m f2:n]
+// f[a]=m&f[b]=n       -> map[f:map[a:m b:n]]
 // f[a][a]=m&f[a][b]=n -> map[f:map[a:map[a:m b:n]]]
-// f[]=m&f[]=n -> map[f:[m n]]
-// f[a][]=m&f[a][]=n -> map[f:map[a:[m n]]]
-// f[][]=m&f[][]=n -> map[f:[map[]]] // Currently does not support nested slice.
-// f=m&f[a]=n -> error // This is not the same as PHP.
-// a .[[b=c -> map[a___[b:c]
+// f[]=m&f[]=n         -> map[f:[m n]]
+// f[a][]=m&f[a][]=n   -> map[f:map[a:[m n]]]
+// f[][]=m&f[][]=n     -> map[f:[map[]]] // Currently does not support nested slice.
+// f=m&f[a]=n          -> error
+// a .[[b=c            -> map[a___[b:c]
 //
 // 将字符串解析成Map。
-func Parse(encodedString string, result map[string]interface{}) error {
-    // build nested map.
-    var build func(map[string]interface{}, []string, interface{}) error
-    build = func(result map[string]interface{}, keys []string, value interface{}) error {
-        length := len(keys)
-        // trim ',"
-        key := strings.Trim(keys[0], "'\"")
-        if length == 1 {
-            result[key] = value
-            return nil
-        }
-
-        // The end is slice. like f[], f[a][]
-        if keys[1] == "" && length == 2 {
-            // todo nested slice
-            if key == "" {
-                return nil
-            }
-            val, ok := result[key]
-            if !ok {
-                result[key] = []interface{}{value}
-                return nil
-            }
-            children, ok := val.([]interface{})
-            if !ok {
-                return fmt.Errorf("expected type '[]interface{}' for key '%s', but got '%T'", key, val)
-            }
-            result[key] = append(children, value)
-            return nil
-        }
-
-        // The end is slice + map. like f[][a]
-        if keys[1] == "" && length > 2 && keys[2] != "" {
-            val, ok := result[key]
-            if !ok {
-                result[key] = []interface{}{}
-                val = result[key]
-            }
-            children, ok := val.([]interface{})
-            if !ok {
-                return fmt.Errorf("expected type '[]interface{}' for key '%s', but got '%T'", key, val)
-            }
-            if l := len(children); l > 0 {
-                if child, ok := children[l-1].(map[string]interface{}); ok {
-                    if _, ok := child[keys[2]]; !ok {
-                        build(child, keys[2:], value)
-                        return nil
-                    }
-                }
-            }
-            child := map[string]interface{}{}
-            build(child, keys[2:], value)
-            result[key] = append(children, child)
-
-            return nil
-        }
-
-        // map. like f[a], f[a][b]
-        val, ok := result[key]
-        if !ok {
-            result[key] = map[string]interface{}{}
-            val = result[key]
-        }
-        children, ok := val.(map[string]interface{})
-        if !ok {
-            return fmt.Errorf("expected type 'map[string]interface{}' for key '%s', but got '%T'", key, val)
-        }
-        if err := build(children, keys[1:], value); err != nil {
-            return err
-        }
-        return nil
-    }
-
-    // split encodedString.
-    parts := strings.Split(encodedString, "&")
+func Parse(s string) (result map[string]interface{}, err error) {
+    result = make(map[string]interface{})
+    parts := strings.Split(s, "&")
     for _, part := range parts {
         pos := strings.Index(part, "=")
         if pos <= 0 {
@@ -105,7 +34,7 @@ func Parse(encodedString string, result map[string]interface{}) error {
         }
         key, err := url.QueryUnescape(part[:pos])
         if err != nil {
-            return err
+            return nil, err
         }
         for key[0] == ' ' {
             key = key[1:]
@@ -115,9 +44,8 @@ func Parse(encodedString string, result map[string]interface{}) error {
         }
         value, err := url.QueryUnescape(part[pos+1:])
         if err != nil {
-            return err
+            return nil, err
         }
-
         // split into multiple keys
         var keys []string
         left := 0
@@ -127,11 +55,11 @@ func Parse(encodedString string, result map[string]interface{}) error {
             } else if k == ']' {
                 if left > 0 {
                     if len(keys) == 0 {
-                        keys = append(keys, key[:left])
+                        keys = append(keys, key[ : left])
                     }
-                    keys = append(keys, key[left+1:i])
+                    keys = append(keys, key[left + 1 : i])
                     left = 0
-                    if i+1 < len(key) && key[i+1] != '[' {
+                    if i+1 < len(key) && key[i + 1] != '[' {
                         break
                     }
                 }
@@ -149,7 +77,7 @@ func Parse(encodedString string, result map[string]interface{}) error {
                 first += string(chr)
             }
             if chr == '[' {
-                first += keys[0][i+1:]
+                first += keys[0][i + 1: ]
                 break
             }
         }
@@ -157,9 +85,78 @@ func Parse(encodedString string, result map[string]interface{}) error {
 
         // build nested map
         if err := build(result, keys, value); err != nil {
-            return err
+            return nil, err
         }
     }
+    return result, nil
+}
 
+// build nested map.
+func build(result map[string]interface{}, keys []string, value interface{}) error {
+    length := len(keys)
+    // trim ',"
+    key := strings.Trim(keys[0], "'\"")
+    if length == 1 {
+        result[key] = value
+        return nil
+    }
+
+    // The end is slice. like f[], f[a][]
+    if keys[1] == "" && length == 2 {
+        // todo nested slice
+        if key == "" {
+            return nil
+        }
+        val, ok := result[key]
+        if !ok {
+            result[key] = []interface{}{value}
+            return nil
+        }
+        children, ok := val.([]interface{})
+        if !ok {
+            return fmt.Errorf("expected type '[]interface{}' for key '%s', but got '%T'", key, val)
+        }
+        result[key] = append(children, value)
+        return nil
+    }
+
+    // The end is slice + map. like f[][a]
+    if keys[1] == "" && length > 2 && keys[2] != "" {
+        val, ok := result[key]
+        if !ok {
+            result[key] = []interface{}{}
+            val = result[key]
+        }
+        children, ok := val.([]interface{})
+        if !ok {
+            return fmt.Errorf("expected type '[]interface{}' for key '%s', but got '%T'", key, val)
+        }
+        if l := len(children); l > 0 {
+            if child, ok := children[l-1].(map[string]interface{}); ok {
+                if _, ok := child[keys[2]]; !ok {
+                    build(child, keys[2:], value)
+                    return nil
+                }
+            }
+        }
+        child := map[string]interface{}{}
+        build(child, keys[2:], value)
+        result[key] = append(children, child)
+        return nil
+    }
+
+    // map. like f[a], f[a][b]
+    val, ok := result[key]
+    if !ok {
+        result[key] = map[string]interface{}{}
+        val = result[key]
+    }
+    children, ok := val.(map[string]interface{})
+    if !ok {
+        return fmt.Errorf("expected type 'map[string]interface{}' for key '%s', but got '%T'", key, val)
+    }
+    if err := build(children, keys[1:], value); err != nil {
+        return err
+    }
     return nil
 }

g/text/gstr/gstr_z_bench_test.go

@@ -9,6 +9,7 @@
 package gstr_test
 
 import (
+    "github.com/gogf/gf/g/text/gstr"
     "testing"
 )
 
@@ -31,4 +32,22 @@ func Benchmark_BytesToString(b *testing.B) {
 
         }
     }
+}
+
+func Benchmark_Parse1(b *testing.B) {
+    for i := 0; i < b.N; i++ {
+        gstr.Parse("a=1&b=2")
+    }
+}
+
+func Benchmark_Parse2(b *testing.B) {
+    for i := 0; i < b.N; i++ {
+        gstr.Parse("m[]=1&m[]=2")
+    }
+}
+
+func Benchmark_Parse3(b *testing.B) {
+    for i := 0; i < b.N; i++ {
+        gstr.Parse("m[a1][b1][c1][d1]=1&m[a2][b2]=2&m[a3][b3][c3]=3")
+    }
 }

g/text/gstr/gstr_z_unit_parse_test.go

@@ -0,0 +1,75 @@
+// 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.
+
+// go test *.go -bench=".*"
+
+package gstr_test
+
+import (
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/test/gtest"
+    "github.com/gogf/gf/g/text/gstr"
+    "testing"
+)
+
+func Test_Parse(t *testing.T) {
+    gtest.Case(t, func() {
+        // slice
+        m, err := gstr.Parse("a[]=1&a[]=2")
+        gtest.Assert(err, nil)
+        gtest.Assert(m,   g.Map{
+            "a" : g.Slice{"1", "2"},
+        })
+        // map
+        m, err  = gstr.Parse("a=1&b=2&c=3")
+        gtest.Assert(err, nil)
+        gtest.Assert(m,   g.Map{
+            "a" : "1",
+            "b" : "2",
+            "c" : "3",
+        })
+        // map
+        m, err  = gstr.Parse("m[a]=1&m[b]=2&m[c]=3")
+        gtest.Assert(err, nil)
+        gtest.Assert(m,   g.Map{
+            "m" : g.Map{
+                "a" : "1",
+                "b" : "2",
+                "c" : "3",
+            },
+        })
+        // map - slice
+        m, err  = gstr.Parse("m[a][]=1&m[a][]=2")
+        gtest.Assert(err, nil)
+        gtest.Assert(m,   g.Map{
+            "m" : g.Map{
+                "a" : g.Slice{"1", "2"},
+            },
+        })
+        // map - complicated
+        m, err  = gstr.Parse("m[a1][b1][c1][d1]=1&m[a2][b2]=2&m[a3][b3][c3]=3")
+        gtest.Assert(err, nil)
+        gtest.Assert(m,   g.Map{
+            "m" : g.Map{
+                "a1" : g.Map{
+                    "b1" : g.Map{
+                        "c1" : g.Map{
+                            "d1" : "1",
+                        },
+                    },
+                },
+                "a2" : g.Map{
+                    "b2" : "2",
+                },
+                "a3" : g.Map{
+                    "b3" : g.Map{
+                        "c3" : "3",
+                    },
+                },
+            },
+        })
+    })
+}

g/util/gconv/gconv_map.go

@@ -8,6 +8,7 @@ package gconv
 
 import (
     "github.com/gogf/gf/g/internal/empty"
+    "github.com/gogf/gf/g/text/gstr"
     "reflect"
     "strings"
 )
@@ -102,6 +103,11 @@ func Map(value interface{}, noTagCheck...bool) map[string]interface{} {
                         rt   := rv.Type()
                         name := ""
                         for i := 0; i < rv.NumField(); i++ {
+                            // 只转换公开属性
+                            fieldName := rt.Field(i).Name
+                            if !gstr.IsLetterUpper(fieldName[0]) {
+                                continue
+                            }
                             name = ""
                             // 检查tag, 支持gconv, json标签, 优先使用gconv
                             if len(noTagCheck) == 0 || !noTagCheck[0] {
@@ -111,7 +117,7 @@ func Map(value interface{}, noTagCheck...bool) map[string]interface{} {
                                 }
                             }
                             if name == "" {
-                                name = strings.TrimSpace(rt.Field(i).Name)
+                                name = strings.TrimSpace(fieldName)
                             } else {
                                 // 支持标准库json特性: -, omitempty
                                 name = strings.TrimSpace(name)

g/util/gconv/gconv_slice.go

@@ -7,6 +7,7 @@
 package gconv
 
 import (
+    "github.com/gogf/gf/g/text/gstr"
     "reflect"
 )
 
@@ -311,7 +312,12 @@ func Interfaces(i interface{}) []interface{} {
                             array = append(array, rv.Index(i).Interface())
                         }
                     case reflect.Struct:
+                        rt := rv.Type()
                         for i := 0; i < rv.NumField(); i++ {
+                            // 只获取公开属性
+                            if !gstr.IsLetterUpper(rt.Field(i).Name[0]) {
+                                continue
+                            }
                             array = append(array, rv.Field(i).Interface())
                         }
                     default:

g/util/gconv/gconv_struct.go

@@ -78,6 +78,10 @@ func Struct(params interface{}, objPointer interface{}, attrMapping...map[string
     attrMap  := make(map[string]struct{})
     elemType := elem.Type()
     for i := 0; i < elem.NumField(); i++ {
+        // 只转换公开属性
+        if !gstr.IsLetterUpper(elemType.Field(i).Name[0]) {
+            continue
+        }
         attrMap[elemType.Field(i).Name] = struct{}{}
     }
     for mapK, mapV := range paramsMap {

g/util/gconv/gconv_z_unit_map_test.go

@@ -112,3 +112,15 @@ func Test_Map_StructWithJsonTag(t *testing.T) {
         gtest.Assert(map2["password2"], "456")
     })
 }
+
+// 私有属性不会进行转换
+func Test_Map_PrivateAttribute(t *testing.T) {
+    type User struct {
+        Id   int
+        name string
+    }
+    gtest.Case(t, func() {
+        user := &User{1, "john"}
+        gtest.Assert(gconv.Map(user), g.Map{"Id" : 1})
+    })
+}

g/util/gconv/gconv_z_unit_slice_test.go

@@ -7,6 +7,7 @@
 package gconv_test
 
 import (
+    "github.com/gogf/gf/g"
     "github.com/gogf/gf/g/util/gconv"
     "github.com/gogf/gf/g/test/gtest"
     "testing"
@@ -23,3 +24,15 @@ func Test_Slice(t *testing.T) {
         gtest.AssertEQ(gconv.Interfaces(value), []interface{}{123.456})
     })
 }
+
+// 私有属性不会进行转换
+func Test_Slice_PrivateAttribute(t *testing.T) {
+    type User struct {
+        Id   int
+        name string
+    }
+    gtest.Case(t, func() {
+        user := &User{1, "john"}
+        gtest.Assert(gconv.Interfaces(user), g.Slice{1})
+    })
+}

g/util/gconv/gconv_z_unit_struct_test.go

@@ -8,12 +8,11 @@ package gconv_test
 
 import (
     "github.com/gogf/gf/g"
-    "github.com/gogf/gf/g/util/gconv"
     "github.com/gogf/gf/g/test/gtest"
+    "github.com/gogf/gf/g/util/gconv"
     "testing"
 )
 
-
 func Test_Struct_Basic1(t *testing.T) {
     gtest.Case(t, func() {
         type User struct {
@@ -302,3 +301,18 @@ func Test_Struct_Attr_Struct_Slice_Ptr(t *testing.T) {
         }
     })
 }
+
+// 私有属性不会进行转换
+func Test_Struct_PrivateAttribute(t *testing.T) {
+    type User struct {
+        Id   int
+        name string
+    }
+    gtest.Case(t, func() {
+        user := new(User)
+        err  := gconv.Struct(g.Map{"id" : 1, "name" : "john"}, user)
+        gtest.Assert(err,       nil)
+        gtest.Assert(user.Id,   1)
+        gtest.Assert(user.name, "")
+    })
+}

g/util/gutil/gutil.go

@@ -13,17 +13,27 @@ import (
     "bytes"
     "encoding/json"
     "fmt"
+    "github.com/gogf/gf/g/internal/empty"
     "github.com/gogf/gf/g/util/gconv"
     "os"
     "reflect"
     "runtime"
 )
 
-// 格式化打印变量(类似于PHP-vardump)
+// 格式化打印变量
 func Dump(i...interface{}) {
+    s := Export(i...)
+    if s != "" {
+        fmt.Println(s)
+    }
+}
+
+// 格式化导出变量
+func Export(i...interface{}) string {
+    buffer := bytes.NewBuffer(nil)
     for _, v := range i {
         if b, ok := v.([]byte); ok {
-            fmt.Print(string(b))
+            buffer.Write(b)
         } else {
             // 主要针对 map[interface{}]* 进行处理，json无法进行encode，
             // 这里强制对所有map进行反射处理转换
@@ -32,24 +42,20 @@ func Dump(i...interface{}) {
                 m := make(map[string]interface{})
                 keys := refValue.MapKeys()
                 for _, k := range keys {
-                    key   := gconv.String(k.Interface())
-                    m[key] = refValue.MapIndex(k).Interface()
+                    m[gconv.String(k.Interface())] = refValue.MapIndex(k).Interface()
                 }
                 v = m
             }
-            // json encode并打印到终端
-            buffer  := &bytes.Buffer{}
+            // JSON格式化
             encoder := json.NewEncoder(buffer)
             encoder.SetEscapeHTML(false)
             encoder.SetIndent("", "\t")
-            if err := encoder.Encode(v); err == nil {
-                fmt.Print(buffer.String())
-            } else {
+            if err := encoder.Encode(v); err != nil {
                 fmt.Fprintln(os.Stderr, err.Error())
             }
         }
-        //fmt.Println()
     }
+    return buffer.String()
 }
 
 // 打印完整的调用回溯信息
@@ -84,4 +90,15 @@ func TryCatch(try func(), catch ... func(exception interface{})) {
     try()
 }
 
+// IsEmpty checks given value empty or not.
+// false: integer(0), bool(false), slice/map(len=0), nil;
+// true : other.
+//
+// 判断给定的变量是否为空。
+// 整型为0, 布尔为false, slice/map长度为0, 其他为nil的情况，都为空。
+// 为空时返回true，否则返回false。
+func IsEmpty(value interface{}) bool {
+    return empty.IsEmpty(value)
+}
+
 

g/util/gvalid/gvalid_check_struct.go

@@ -7,6 +7,7 @@
 package gvalid
 
 import (
+    "github.com/gogf/gf/g/text/gstr"
     "github.com/gogf/gf/g/util/gconv"
     "github.com/gogf/gf/third/github.com/fatih/structs"
     "strings"
@@ -59,14 +60,19 @@ func CheckStruct(object interface{}, rules interface{}, msgs...CustomMsg) *Error
         case map[string]string:
             checkRules = v
     }
-    // 首先, 按照属性循环一遍将strcut的属性、数值、tag解析
+    // 首先, 按照属性循环一遍将struct的属性、数值、tag解析
     for _, field := range fields {
-        params[field.Name()] = field.Value()
+        fieldName := field.Name()
+        // 只检测公开属性
+        if !gstr.IsLetterUpper(fieldName[0]) {
+            continue
+        }
+        params[fieldName] = field.Value()
         if tag := field.Tag("gvalid"); tag != "" {
             // sequence tag == struct tag, 这里的name为别名
             name, rule, msg := parseSequenceTag(tag)
             if len(name) == 0 {
-                name = field.Name()
+                name = fieldName
             }
             // params参数使用别名**扩容**(而不仅仅使用别名)，仅用于验证使用
             if _, ok := params[name]; !ok {
@@ -151,3 +157,4 @@ func CheckStruct(object interface{}, rules interface{}, msgs...CustomMsg) *Error
     }
     return nil
 }
+

geg/container/garray/array_unique.go

@@ -3,15 +3,14 @@ package main
 import "fmt"
 
 func main() {
-    array := []uint{1, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6}
-    for i := 0; i < len(array) - 1; i++ {
-        for j := i + 1; j < len(array); j++ {
-            if array[i] == array[j] {
-                array = append(array[ : j], array[j + 1 : ]...)
-            }
-        }
-    }
-    fmt.Println(array)
+	array := []uint{1, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6}
+	for i := 0; i < len(array)-1; i++ {
+		for j := i + 1; j < len(array); j++ {
+			if array[i] == array[j] {
+				array = append(array[:j], array[j+1:]...)
+			}
+		}
+	}
+	fmt.Println(array)
 
-
-}
+}

geg/container/garray/garray1.go

@@ -1,59 +1,58 @@
 package main
 
 import (
-    "fmt"
-    "github.com/gogf/gf/g/container/garray"
+	"fmt"
+	"github.com/gogf/gf/g/container/garray"
 )
 
+func main() {
+	// 创建普通的int类型数组，并关闭默认的并发安全特性
+	a := garray.NewIntArray(true)
 
-func main () {
-    // 创建普通的int类型数组，并关闭默认的并发安全特性
-    a := garray.NewIntArray(true)
+	// 添加数据项
+	for i := 0; i < 10; i++ {
+		a.Append(i)
+	}
 
-    // 添加数据项
-    for i := 0; i < 10; i++ {
-        a.Append(i)
-    }
+	// 获取当前数组长度
+	fmt.Println(a.Len())
 
-    // 获取当前数组长度
-    fmt.Println(a.Len())
+	// 获取当前数据项列表
+	fmt.Println(a.Slice())
 
-    // 获取当前数据项列表
-    fmt.Println(a.Slice())
+	// 获取指定索引项
+	fmt.Println(a.Get(6))
 
-    // 获取指定索引项
-    fmt.Println(a.Get(6))
+	// 在指定索引前插入数据项
+	a.InsertAfter(9, 11)
+	// 在指定索引后插入数据项
+	a.InsertBefore(10, 10)
+	fmt.Println(a.Slice())
 
-    // 在指定索引前插入数据项
-    a.InsertAfter(9, 11)
-    // 在指定索引后插入数据项
-    a.InsertBefore(10, 10)
-    fmt.Println(a.Slice())
+	// 修改指定索引的数据项
+	a.Set(0, 100)
+	fmt.Println(a.Slice())
 
-    // 修改指定索引的数据项
-    a.Set(0, 100)
-    fmt.Println(a.Slice())
+	// 搜索数据项，返回搜索到的索引位置
+	fmt.Println(a.Search(5))
 
-    // 搜索数据项，返回搜索到的索引位置
-    fmt.Println(a.Search(5))
+	// 删除指定索引的数据项
+	a.Remove(0)
+	fmt.Println(a.Slice())
 
-    // 删除指定索引的数据项
-    a.Remove(0)
-    fmt.Println(a.Slice())
+	// 并发安全，写锁操作
+	a.LockFunc(func(array []int) {
+		// 将末尾项改为100
+		array[len(array)-1] = 100
+	})
 
-    // 并发安全，写锁操作
-    a.LockFunc(func(array []int) {
-        // 将末尾项改为100
-        array[len(array) - 1] = 100
-    })
+	// 并发安全，读锁操作
+	a.RLockFunc(func(array []int) {
+		fmt.Println(array[len(array)-1])
+	})
 
-    // 并发安全，读锁操作
-    a.RLockFunc(func(array []int) {
-        fmt.Println(array[len(array) - 1])
-    })
-
-    // 清空数组
-    fmt.Println(a.Slice())
-    a.Clear()
-    fmt.Println(a.Slice())
+	// 清空数组
+	fmt.Println(a.Slice())
+	a.Clear()
+	fmt.Println(a.Slice())
 }

geg/container/garray/garray2.go

@@ -1,40 +1,39 @@
 package main
 
 import (
-    "fmt"
-    "github.com/gogf/gf/g/container/garray"
+	"fmt"
+	"github.com/gogf/gf/g/container/garray"
 )
 
+func main() {
+	// 自定义排序数组，降序排序(SortedIntArray管理的数据是升序)
+	a := garray.NewSortedArray(func(v1, v2 interface{}) int {
+		if v1.(int) < v2.(int) {
+			return 1
+		}
+		if v1.(int) > v2.(int) {
+			return -1
+		}
+		return 0
+	})
 
-func main () {
-    // 自定义排序数组，降序排序(SortedIntArray管理的数据是升序)
-    a := garray.NewSortedArray(func(v1, v2 interface{}) int {
-        if v1.(int) < v2.(int) {
-            return 1
-        }
-        if v1.(int) > v2.(int) {
-            return -1
-        }
-        return 0
-    })
+	// 添加数据
+	a.Add(2)
+	a.Add(3)
+	a.Add(1)
+	fmt.Println(a.Slice())
 
-    // 添加数据
-    a.Add(2)
-    a.Add(3)
-    a.Add(1)
-    fmt.Println(a.Slice())
+	// 添加重复数据
+	a.Add(3)
+	fmt.Println(a.Slice())
 
-    // 添加重复数据
-    a.Add(3)
-    fmt.Println(a.Slice())
+	// 检索数据，返回最后对比的索引位置，检索结果
+	// 检索结果：0: 匹配; <0:参数小于对比值; >0:参数大于对比值
+	fmt.Println(a.Search(1))
 
-    // 检索数据，返回最后对比的索引位置，检索结果
-    // 检索结果：0: 匹配; <0:参数小于对比值; >0:参数大于对比值
-    fmt.Println(a.Search(1))
-
-    // 设置不可重复
-    a.SetUnique(true)
-    fmt.Println(a.Slice())
-    a.Add(1)
-    fmt.Println(a.Slice())
+	// 设置不可重复
+	a.SetUnique(true)
+	fmt.Println(a.Slice())
+	a.Add(1)
+	fmt.Println(a.Slice())
 }

geg/container/garray/garray_slice_safe.go

@@ -1,18 +1,17 @@
 package main
 
 import (
-    "github.com/gogf/gf/g/container/garray"
-    "github.com/gogf/gf/g"
+	"github.com/gogf/gf/g"
+	"github.com/gogf/gf/g/container/garray"
 )
 
+func main() {
+	a := garray.NewIntArray()
+	a.Append(1, 2, 3)
 
-func main () {
-    a := garray.NewIntArray()
-    a.Append(1, 2, 3)
+	v := a.Slice()
+	v[0] = 4
 
-    v   := a.Slice()
-    v[0] = 4
-
-    g.Dump(a.Slice())
-    g.Dump(v)
+	g.Dump(a.Slice())
+	g.Dump(v)
 }

geg/container/garray/sorted_string_array1.go

@@ -1,20 +1,20 @@
 package main
 
 import (
-    "github.com/gogf/gf/g"
-    "github.com/gogf/gf/g/container/garray"
+	"github.com/gogf/gf/g"
+	"github.com/gogf/gf/g/container/garray"
 )
 
-func main()  {
-    array := garray.NewSortedStringArray()
-    array.Add("1")
-    array.Add("2")
-    array.Add("3")
-    array.Add("4")
-    array.Add("5")
-    array.Add("6")
-    array.Add("7")
-    array.Add("8")
-    array.Add("9")
-    g.Dump(array.Slice())
-}
+func main() {
+	array := garray.NewSortedStringArray()
+	array.Add("1")
+	array.Add("2")
+	array.Add("3")
+	array.Add("4")
+	array.Add("5")
+	array.Add("6")
+	array.Add("7")
+	array.Add("8")
+	array.Add("9")
+	g.Dump(array.Slice())
+}

geg/container/garray/sorted_string_array2.go

@@ -1,26 +1,26 @@
 package main
 
 import (
-    "fmt"
-    "github.com/gogf/gf/g"
-    "github.com/gogf/gf/g/container/garray"
-    "strings"
+	"fmt"
+	"github.com/gogf/gf/g"
+	"github.com/gogf/gf/g/container/garray"
+	"strings"
 )
 
-func main()  {
-    array := garray.NewSortedStringArray()
-    array.Add("/api/ctl/show")
-    array.Add("/api/ctl/post")
-    array.Add("/api/obj/rest")
-    array.Add("/api/handler")
-    array.Add("/api/obj/delete")
-    array.Add("/api/obj/show")
-    array.Add("/api/obj/my-show")
-    array.Add("/api/*")
-    array.Add("/api/ctl/rest")
-    array.Add("/api/ctl/my-show")
-    g.Dump(array.Slice())
+func main() {
+	array := garray.NewSortedStringArray()
+	array.Add("/api/ctl/show")
+	array.Add("/api/ctl/post")
+	array.Add("/api/obj/rest")
+	array.Add("/api/handler")
+	array.Add("/api/obj/delete")
+	array.Add("/api/obj/show")
+	array.Add("/api/obj/my-show")
+	array.Add("/api/*")
+	array.Add("/api/ctl/rest")
+	array.Add("/api/ctl/my-show")
+	g.Dump(array.Slice())
 
-    fmt.Println(strings.Compare("/api/ctl/post", "/api/*"))
-    fmt.Println(strings.Compare("/api/*", "/api/ctl/my-show"))
-}
+	fmt.Println(strings.Compare("/api/ctl/post", "/api/*"))
+	fmt.Println(strings.Compare("/api/*", "/api/ctl/my-show"))
+}

geg/container/gmap/gmap.go

@@ -1,73 +1,73 @@
 package main
 
 import (
-    "fmt"
-    "github.com/gogf/gf/g/container/gmap"
+	"fmt"
+	"github.com/gogf/gf/g/container/gmap"
 )
 
 func main() {
-    // 创建一个默认的gmap对象，
-    // 默认情况下该gmap对象支持并发安全特性，
-    // 初始化时可以给定false参数关闭并发安全特性，当做一个普通的map使用。
-    m := gmap.New()
+	// 创建一个默认的gmap对象，
+	// 默认情况下该gmap对象支持并发安全特性，
+	// 初始化时可以给定false参数关闭并发安全特性，当做一个普通的map使用。
+	m := gmap.New()
 
-    // 设置键值对
-    for i := 0; i < 10; i++ {
-        m.Set(i, i)
-    }
-    // 查询大小
-    fmt.Println(m.Size())
-    // 批量设置键值对(不同的数据类型对象参数不同)
-    m.BatchSet(map[interface{}]interface{}{
-        10 : 10,
-        11 : 11,
-    })
-    fmt.Println(m.Size())
+	// 设置键值对
+	for i := 0; i < 10; i++ {
+		m.Set(i, i)
+	}
+	// 查询大小
+	fmt.Println(m.Size())
+	// 批量设置键值对(不同的数据类型对象参数不同)
+	m.BatchSet(map[interface{}]interface{}{
+		10: 10,
+		11: 11,
+	})
+	fmt.Println(m.Size())
 
-    // 查询是否存在
-    fmt.Println(m.Contains(1))
+	// 查询是否存在
+	fmt.Println(m.Contains(1))
 
-    // 查询键值
-    fmt.Println(m.Get(1))
+	// 查询键值
+	fmt.Println(m.Get(1))
 
-    // 删除数据项
-    m.Remove(9)
-    fmt.Println(m.Size())
+	// 删除数据项
+	m.Remove(9)
+	fmt.Println(m.Size())
 
-    // 批量删除
-    m.BatchRemove([]interface{}{10, 11})
-    fmt.Println(m.Size())
+	// 批量删除
+	m.BatchRemove([]interface{}{10, 11})
+	fmt.Println(m.Size())
 
-    // 当前键名列表(随机排序)
-    fmt.Println(m.Keys())
-    // 当前键值列表(随机排序)
-    fmt.Println(m.Values())
+	// 当前键名列表(随机排序)
+	fmt.Println(m.Keys())
+	// 当前键值列表(随机排序)
+	fmt.Println(m.Values())
 
-    // 查询键名，当键值不存在时，写入给定的默认值
-    fmt.Println(m.GetWithDefault(100, 100))
+	// 查询键名，当键值不存在时，写入给定的默认值
+	fmt.Println(m.GetWithDefault(100, 100))
 
-    // 删除键值对，并返回对应的键值
-    fmt.Println(m.GetAndRemove(100))
+	// 删除键值对，并返回对应的键值
+	fmt.Println(m.GetAndRemove(100))
 
-    // 遍历map
-    m.Iterator(func(k interface{}, v interface{}) bool {
-        fmt.Printf("%v:%v ", k, v)
-        return true
-    })
+	// 遍历map
+	m.Iterator(func(k interface{}, v interface{}) bool {
+		fmt.Printf("%v:%v ", k, v)
+		return true
+	})
 
-    // 自定义写锁操作
-    m.LockFunc(func(m map[interface{}]interface{}) {
-        m[99] = 99
-    })
+	// 自定义写锁操作
+	m.LockFunc(func(m map[interface{}]interface{}) {
+		m[99] = 99
+	})
 
-    // 自定义读锁操作
-    m.RLockFunc(func(m map[interface{}]interface{}) {
-        fmt.Println(m[99])
-    })
+	// 自定义读锁操作
+	m.RLockFunc(func(m map[interface{}]interface{}) {
+		fmt.Println(m[99])
+	})
 
-    // 清空map
-    m.Clear()
+	// 清空map
+	m.Clear()
 
-    // 判断map是否为空
-    fmt.Println(m.IsEmpty())
+	// 判断map是否为空
+	fmt.Println(m.IsEmpty())
 }

geg/container/gmap/gmap_map_safe.go

@@ -1,17 +1,17 @@
 package main
 
 import (
-    "github.com/gogf/gf/g/container/gmap"
-    "github.com/gogf/gf/g"
+	"github.com/gogf/gf/g"
+	"github.com/gogf/gf/g/container/gmap"
 )
 
 func main() {
-    m := gmap.New()
-    m.Set("1", "1")
+	m := gmap.New()
+	m.Set("1", "1")
 
-    m1 := m.Clone()
-    m1["2"] = "2"
+	m1 := m.Clone()
+	m1["2"] = "2"
 
-    g.Dump(m.Clone())
-    g.Dump(m1)
+	g.Dump(m.Clone())
+	g.Dump(m1)
 }

geg/container/gmap/safe_map_delete.go

@@ -1,39 +1,39 @@
 package main
 
 import (
-    "sync"
-    "time"
-    "fmt"
+	"fmt"
+	"sync"
+	"time"
 )
 
 // 验证 map 的delete方法是否并发安全
 func main() {
-    // 创建一个初始化的map
-    m := make(map[int]int)
-    for i := 0; i < 10000; i++ {
-        m[i] = i
-    }
+	// 创建一个初始化的map
+	m := make(map[int]int)
+	for i := 0; i < 10000; i++ {
+		m[i] = i
+	}
 
-    fmt.Println("map size:", len(m))
+	fmt.Println("map size:", len(m))
 
-    wg := sync.WaitGroup{}
-    ev := make(chan struct{}, 0)
+	wg := sync.WaitGroup{}
+	ev := make(chan struct{}, 0)
 
-    // 创建10个并发的goroutine，使用ev控制并发开始事件，更容易模拟data race
-    for i := 0; i < 10; i++ {
-        wg.Add(1)
-        go func() {
-            <- ev
-            fmt.Println("start")
-            for i := 0; i < 10000; i++ {
-                delete(m, i)
-            }
-            wg.Done()
-        }()
-    }
+	// 创建10个并发的goroutine，使用ev控制并发开始事件，更容易模拟data race
+	for i := 0; i < 10; i++ {
+		wg.Add(1)
+		go func() {
+			<-ev
+			fmt.Println("start")
+			for i := 0; i < 10000; i++ {
+				delete(m, i)
+			}
+			wg.Done()
+		}()
+	}
 
-    time.Sleep(time.Second)
+	time.Sleep(time.Second)
 
-    close(ev)
-    wg.Wait()
+	close(ev)
+	wg.Wait()
 }

geg/container/gpool/gpool.go

@@ -1,25 +1,25 @@
 package main
 
 import (
-    "github.com/gogf/gf/g/container/gpool"
-    "fmt"
-    "time"
+	"fmt"
+	"github.com/gogf/gf/g/container/gpool"
+	"time"
 )
 
-func main () {
-    // 创建一个对象池，过期时间为1000毫秒
-    p := gpool.New(1000, nil)
+func main() {
+	// 创建一个对象池，过期时间为1000毫秒
+	p := gpool.New(1000, nil)
 
-    // 从池中取一个对象，返回nil及错误信息
-    fmt.Println(p.Get())
+	// 从池中取一个对象，返回nil及错误信息
+	fmt.Println(p.Get())
 
-    // 丢一个对象到池中
-    p.Put(1)
+	// 丢一个对象到池中
+	p.Put(1)
 
-    // 重新从池中取一个对象，返回1
-    fmt.Println(p.Get())
+	// 重新从池中取一个对象，返回1
+	fmt.Println(p.Get())
 
-    // 等待1秒后重试，发现对象已过期，返回nil及错误信息
-    time.Sleep(time.Second)
-    fmt.Println(p.Get())
+	// 等待1秒后重试，发现对象已过期，返回nil及错误信息
+	time.Sleep(time.Second)
+	fmt.Println(p.Get())
 }

geg/container/gqueue/gqueue.go

@@ -1,33 +1,33 @@
 package main
 
 import (
-    "fmt"
-    "github.com/gogf/gf/g/os/gtimer"
-    "time"
-    "github.com/gogf/gf/g/os/gtime"
-    "github.com/gogf/gf/g/container/gqueue"
+	"fmt"
+	"github.com/gogf/gf/g/container/gqueue"
+	"github.com/gogf/gf/g/os/gtime"
+	"github.com/gogf/gf/g/os/gtimer"
+	"time"
 )
 
 func main() {
-    q := gqueue.New()
-    // 数据生产者，每隔1秒往队列写数据
-    gtimer.SetInterval(time.Second, func() {
-        v := gtime.Now().String()
-        q.Push(v)
-        fmt.Println("Push:", v)
-    })
+	q := gqueue.New()
+	// 数据生产者，每隔1秒往队列写数据
+	gtimer.SetInterval(time.Second, func() {
+		v := gtime.Now().String()
+		q.Push(v)
+		fmt.Println("Push:", v)
+	})
 
-    // 3秒后关闭队列
-    gtimer.SetTimeout(3*time.Second, func() {
-        q.Close()
-    })
+	// 3秒后关闭队列
+	gtimer.SetTimeout(3*time.Second, func() {
+		q.Close()
+	})
 
-    // 消费者，不停读取队列数据并输出到终端
-    for {
-        if v := q.Pop(); v != nil {
-            fmt.Println(" Pop:", v)
-        } else {
-            break
-        }
-    }
+	// 消费者，不停读取队列数据并输出到终端
+	for {
+		if v := q.Pop(); v != nil {
+			fmt.Println(" Pop:", v)
+		} else {
+			break
+		}
+	}
 }

geg/container/gqueue/gqueue2.go

@@ -1,27 +1,27 @@
 package main
 
 import (
-    "fmt"
-    "github.com/gogf/gf/g/container/gqueue"
-    "github.com/gogf/gf/g/os/gtimer"
-    "time"
+	"fmt"
+	"github.com/gogf/gf/g/container/gqueue"
+	"github.com/gogf/gf/g/os/gtimer"
+	"time"
 )
 
 func main() {
-    q := gqueue.New()
-    // 数据生产者，每隔1秒往队列写数据
-    gtimer.SetInterval(time.Second, func() {
-        for i := 0; i < 10; i++ {
-            q.Push(i)
-        }
-    })
+	q := gqueue.New()
+	// 数据生产者，每隔1秒往队列写数据
+	gtimer.SetInterval(time.Second, func() {
+		for i := 0; i < 10; i++ {
+			q.Push(i)
+		}
+	})
 
-    // 消费者，不停读取队列数据并输出到终端
-    for {
-        if v := q.Pop(); v != nil {
-            fmt.Println(" Pop:", v)
-        } else {
-            break
-        }
-    }
+	// 消费者，不停读取队列数据并输出到终端
+	for {
+		if v := q.Pop(); v != nil {
+			fmt.Println(" Pop:", v)
+		} else {
+			break
+		}
+	}
 }

geg/container/gqueue/gqueue3.go

@@ -1,29 +1,29 @@
 package main
 
 import (
-    "fmt"
-    "github.com/gogf/gf/g/container/gqueue"
-    "github.com/gogf/gf/g/os/gtime"
-    "github.com/gogf/gf/g/os/gtimer"
-    "time"
+	"fmt"
+	"github.com/gogf/gf/g/container/gqueue"
+	"github.com/gogf/gf/g/os/gtime"
+	"github.com/gogf/gf/g/os/gtimer"
+	"time"
 )
 
 func main() {
-    queue := gqueue.New()
-    // 数据生产者，每隔1秒往队列写数据
-    gtimer.SetInterval(time.Second, func() {
-        queue.Push(gtime.Now().String())
-    })
+	queue := gqueue.New()
+	// 数据生产者，每隔1秒往队列写数据
+	gtimer.SetInterval(time.Second, func() {
+		queue.Push(gtime.Now().String())
+	})
 
-    // 消费者，不停读取队列数据并输出到终端
-    for {
-        select {
-            case v := <-queue.C:
-                if v != nil {
-                    fmt.Println(v)
-                } else {
-                    return
-                }
-        }
-    }
+	// 消费者，不停读取队列数据并输出到终端
+	for {
+		select {
+		case v := <-queue.C:
+			if v != nil {
+				fmt.Println(v)
+			} else {
+				return
+			}
+		}
+	}
 }

geg/container/gring/gring.go

@@ -1,27 +1,27 @@
 package main
 
 import (
-    "github.com/gogf/gf/g/container/gring"
-    "fmt"
+	"fmt"
+	"github.com/gogf/gf/g/container/gring"
 )
 
 func main() {
-    r1 := gring.New(10)
-    for i := 0; i < 5; i ++ {
-        r1.Set(i).Next()
-    }
-    fmt.Println("Len:", r1.Len())
-    fmt.Println("Cap:", r1.Cap())
-    fmt.Println(r1.SlicePrev())
-    fmt.Println(r1.SliceNext())
+	r1 := gring.New(10)
+	for i := 0; i < 5; i++ {
+		r1.Set(i).Next()
+	}
+	fmt.Println("Len:", r1.Len())
+	fmt.Println("Cap:", r1.Cap())
+	fmt.Println(r1.SlicePrev())
+	fmt.Println(r1.SliceNext())
 
-    r2 := gring.New(10)
-    for i := 0; i < 10; i ++ {
-        r2.Set(i).Next()
-    }
-    fmt.Println("Len:", r2.Len())
-    fmt.Println("Cap:", r2.Cap())
-    fmt.Println(r2.SlicePrev())
-    fmt.Println(r2.SliceNext())
+	r2 := gring.New(10)
+	for i := 0; i < 10; i++ {
+		r2.Set(i).Next()
+	}
+	fmt.Println("Len:", r2.Len())
+	fmt.Println("Cap:", r2.Cap())
+	fmt.Println(r2.SlicePrev())
+	fmt.Println(r2.SliceNext())
 
 }

geg/container/gring/gring_josephus.go

@@ -1,57 +1,57 @@
 package main
 
 import (
-    "fmt"
-    "github.com/gogf/gf/g/container/gring"
+	"fmt"
+	"github.com/gogf/gf/g/container/gring"
 )
 
 type Player struct {
-    position int  // 位置
-    alive    bool // 是否存活
+	position int  // 位置
+	alive    bool // 是否存活
 }
 
 const (
-    playerCount = 41  // 玩家人数
-    startPos    = 1   // 开始报数位置
+	playerCount = 41 // 玩家人数
+	startPos    = 1  // 开始报数位置
 )
 
 var (
-    deadline = 3
+	deadline = 3
 )
 
 func main() {
-    // 关闭并发安全，当前场景没有必要
-    r := gring.New(playerCount, false)
+	// 关闭并发安全，当前场景没有必要
+	r := gring.New(playerCount, false)
 
-    // 设置所有玩家初始值
-    for i := 1; i <= playerCount; i++ {
-        r.Put(&Player{i, true})
-    }
+	// 设置所有玩家初始值
+	for i := 1; i <= playerCount; i++ {
+		r.Put(&Player{i, true})
+	}
 
-    // 如果开始报数的位置不为1，则设置开始位置
-    if startPos > 1 {
-        r.Move(startPos - 1)
-    }
+	// 如果开始报数的位置不为1，则设置开始位置
+	if startPos > 1 {
+		r.Move(startPos - 1)
+	}
 
-    counter   := 1  // 报数从1开始，因为下面的循环从第二个开始计算
-    deadCount := 0  // 死亡人数，初始值为0
+	counter := 1   // 报数从1开始，因为下面的循环从第二个开始计算
+	deadCount := 0 // 死亡人数，初始值为0
 
-    // 直到所有人都死亡，否则循环一直执行
-    for deadCount < playerCount {
-        // 跳到下一个人
-        r.Next()
+	// 直到所有人都死亡，否则循环一直执行
+	for deadCount < playerCount {
+		// 跳到下一个人
+		r.Next()
 
-        // 如果是活着的人，则报数
-        if r.Val().(*Player).alive {
-            counter++
-        }
+		// 如果是活着的人，则报数
+		if r.Val().(*Player).alive {
+			counter++
+		}
 
-        // 如果报数为deadline，则此人淘汰出局
-        if counter == deadline {
-            r.Val().(*Player).alive = false
-            fmt.Printf("Player %d died!\n", r.Val().(*Player).position)
-            deadCount++
-            counter = 0
-        }
-    }
-}
+		// 如果报数为deadline，则此人淘汰出局
+		if counter == deadline {
+			r.Val().(*Player).alive = false
+			fmt.Printf("Player %d died!\n", r.Val().(*Player).position)
+			deadCount++
+			counter = 0
+		}
+	}
+}

geg/container/gset/gset.go

@@ -1,52 +1,52 @@
 package main
 
 import (
-    "github.com/gogf/gf/g/container/gset"
-    "fmt"
+	"fmt"
+	"github.com/gogf/gf/g/container/gset"
 )
 
 func main() {
-    // 创建一个非并发安全的集合对象
-    s := gset.New(false)
+	// 创建一个非并发安全的集合对象
+	s := gset.New(false)
 
-    // 添加数据项
-    s.Add(1)
+	// 添加数据项
+	s.Add(1)
 
-    // 批量添加数据项
-    s.BatchAdd([]interface{}{1, 2, 3})
+	// 批量添加数据项
+	s.BatchAdd([]interface{}{1, 2, 3})
 
-    // 集合数据项大小
-    fmt.Println(s.Size())
+	// 集合数据项大小
+	fmt.Println(s.Size())
 
-    // 集合中是否存在指定数据项
-    fmt.Println(s.Contains(2))
+	// 集合中是否存在指定数据项
+	fmt.Println(s.Contains(2))
 
-    // 返回数据项slice
-    fmt.Println(s.Slice())
+	// 返回数据项slice
+	fmt.Println(s.Slice())
 
-    // 删除数据项
-    s.Remove(3)
+	// 删除数据项
+	s.Remove(3)
 
-    // 遍历数据项
-    s.Iterator(func(v interface{}) bool {
-        fmt.Println("Iterator:", v)
-        return true
-    })
+	// 遍历数据项
+	s.Iterator(func(v interface{}) bool {
+		fmt.Println("Iterator:", v)
+		return true
+	})
 
-    // 将集合转换为字符串
-    fmt.Println(s.String())
+	// 将集合转换为字符串
+	fmt.Println(s.String())
 
-    // 并发安全写锁操作
-    s.LockFunc(func(m map[interface{}]struct{}) {
-        m[4] = struct{}{}
-    })
+	// 并发安全写锁操作
+	s.LockFunc(func(m map[interface{}]struct{}) {
+		m[4] = struct{}{}
+	})
 
-    // 并发安全读锁操作
-    s.RLockFunc(func(m map[interface{}]struct{}) {
-        fmt.Println(m)
-    })
+	// 并发安全读锁操作
+	s.RLockFunc(func(m map[interface{}]struct{}) {
+		fmt.Println(m)
+	})
 
-    // 清空集合
-    s.Clear()
-    fmt.Println(s.Size())
+	// 清空集合
+	s.Clear()
+	fmt.Println(s.Size())
 }

geg/container/gtype/gtype_int.go

@@ -1,20 +1,20 @@
 package main
 
 import (
-    "github.com/gogf/gf/g/container/gtype"
-    "fmt"
+	"fmt"
+	"github.com/gogf/gf/g/container/gtype"
 )
 
 func main() {
-    // 创建一个Int型的并发安全基本类型对象
-    i := gtype.NewInt()
+	// 创建一个Int型的并发安全基本类型对象
+	i := gtype.NewInt()
 
-    // 设置值
-    i.Set(10)
+	// 设置值
+	i.Set(10)
 
-    // 获取值
-    fmt.Println(i.Val())
+	// 获取值
+	fmt.Println(i.Val())
 
-    // (整型/浮点型有效)数值 增加/删除 delta
-    fmt.Println(i.Add(-1))
+	// (整型/浮点型有效)数值 增加/删除 delta
+	fmt.Println(i.Add(-1))
 }

geg/container/gvar/g.var.go

@@ -1,36 +1,36 @@
 package main
 
 import (
-    "github.com/gogf/gf/g"
-    "fmt"
+	"fmt"
+	"github.com/gogf/gf/g"
 )
 
 func main() {
-    var v g.Var
+	var v g.Var
 
-    v.Set("123")
+	v.Set("123")
 
-    fmt.Println(v.Val())
+	fmt.Println(v.Val())
 
-    // 基本类型转换
-    fmt.Println(v.Int())
-    fmt.Println(v.Uint())
-    fmt.Println(v.Float64())
+	// 基本类型转换
+	fmt.Println(v.Int())
+	fmt.Println(v.Uint())
+	fmt.Println(v.Float64())
 
-    // slice转换
-    fmt.Println(v.Ints())
-    fmt.Println(v.Floats())
-    fmt.Println(v.Strings())
+	// slice转换
+	fmt.Println(v.Ints())
+	fmt.Println(v.Floats())
+	fmt.Println(v.Strings())
 
-    // struct转换
-    type Score struct {
-        Value int
-    }
-    s := new(Score)
-    v.Struct(s)
-    fmt.Println(s)
+	// struct转换
+	type Score struct {
+		Value int
+	}
+	s := new(Score)
+	v.Struct(s)
+	fmt.Println(s)
 
-    // 只读接口
-    r := v.ReadOnly()
-    fmt.Println(r.String())
+	// 只读接口
+	r := v.ReadOnly()
+	fmt.Println(r.String())
 }