update comment of gredis

ignore private attribute of struct in gconv/gvalid
2026-06-09 19:13:58 +08:00 · 2019-03-22 11:22:03 +08:00 · 2019-03-22 10:12:43 +08:00 · 2019-03-22 10:12:15 +08:00 · 2019-03-21 23:51:57 +08:00 · 2019-03-21 18:21:53 +08:00
137 changed files with 4384 additions and 1572 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -1,6 +1,7 @@
 language: go

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

@ -14,6 +15,7 @@ env:

 services:
  - mysql
+  - redis-server

 addons:
  hosts:
--- a/README.MD
+++ b/README.MD
@ -65,42 +65,30 @@ func main() {

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

-# Contributors(TOP 10)
+# Contributors

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

 # Donators

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



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

-<!--
-[![Code Coverage](https://codecov.io/gh/gogf/gf/branch/master/graph/badge.svg)](https://codecov.io/gh/gogf/gf)
-[![Code Helper](https://www.codetriage.com/gogf/gf/badges/users.svg)](https://www.codetriage.com/gogf/gf) 
--> 
-
 `GF(Go Frame)`是一款模块化、松耦合、生产级Go应用开发框架。提供了常用的核心开发组件，如：缓存、日志、文件、时间、队列、数组、集合、字符串、定时器、命令行、文件锁、内存锁、对象池、连接池、数据校验、数据编码、文件监控、定时任务、数据库ORM、TCP/UDP组件、进程管理/通信、
 并发安全容器等等。并提供了Web服务开发的系列核心组件，如：Router、Cookie、Session、服务注册、配置管理、模板引擎等等，支持热重启、热更新、多域名、多端口、多服务、HTTPS、Rewrite等特性。

@ -90,30 +85,27 @@ func main() {
 <img src="https://goframe.org/images/donate.png" width="300"/>
 </a>

-# 贡献者(TOP 10)
+# 贡献者

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

 # 捐赠者

-<a href="https://gitee.com/tiangenglan" target="_blank" title="zhuhuan12"><img src="https://images.gitee.com/uploads/99/1167099_tiangenglan.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/zhuhuan12" target="_blank" title="zhuhuan12"><img src="https://gitee.com/uploads/39/751839_zhuhuan12.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/zfan_codes" target="_blank" title="范钟"><img src="https://images.gitee.com/uploads/32/2044832_zfan_codes.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/hailaz" target="_blank" title="HaiLaz"><img src="https://gitee.com/uploads/87/1273187_hailaz.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/mg91" target="_blank" title="mg91"><img src="https://images.gitee.com/uploads/30/1410930_mg91.png" width="60" align="left"></a>
+- [tiangenglan](https://gitee.com/tiangenglan)
+- [zhuhuan12](https://gitee.com/zhuhuan12)
+- [zfan_codes](https://gitee.com/zfan_codes)
+- [hailaz](https://gitee.com/hailaz)
+- [mg91](https://gitee.com/mg91)
+- [wxkj](https://gitee.com/wxkj)
+- [pibigstar](https://github.com/pibigstar)
+- [flyke-xu](https://gitee.com/flyke-xu)
--- a/TODO.MD
+++ b/TODO.MD
@ -57,7 +57,7 @@
 1. 更新跨域请求CORS相关功能文档；
 1. ghttp的热重启的本地进程端口监听，在不使用该特性时默认关闭掉；
 1. gcfg包目前允许添加重复的目录路径，需要在SetPath/AddPath时判断重复性，不能添加重复的路径；
-
+1. gdb执行数据写入时，如果参数为struct/[]struct，自动映射与表字段对应关系，不再使用gconv标签标识；



--- a/g/container/garray/garray_normal_int.go
+++ b/g/container/garray/garray_normal_int.go
@ -441,8 +441,8 @@ func (a *IntArray) Unique() *IntArray {
 //
 // 使用自定义方法执行加锁修改操作。
 func (a *IntArray) LockFunc(f func(array []int)) *IntArray {
-	a.mu.Lock(true)
-	defer a.mu.Unlock(true)
+	a.mu.Lock()
+	defer a.mu.Unlock()
 	f(a.array)
    return a
 }
@ -451,8 +451,8 @@ func (a *IntArray) LockFunc(f func(array []int)) *IntArray {
 //
 // 使用自定义方法执行加锁读取操作。
 func (a *IntArray) RLockFunc(f func(array []int)) *IntArray {
-	a.mu.RLock(true)
-	defer a.mu.RUnlock(true)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
 	f(a.array)
    return a
 }
--- a/g/container/garray/garray_normal_interface.go
+++ b/g/container/garray/garray_normal_interface.go
@ -433,8 +433,8 @@ func (a *Array) Unique() *Array {
 //
 // 使用自定义方法执行加锁修改操作
 func (a *Array) LockFunc(f func(array []interface{})) *Array {
-    a.mu.Lock(true)
-    defer a.mu.Unlock(true)
+    a.mu.Lock()
+    defer a.mu.Unlock()
    f(a.array)
    return a
 }
@ -443,8 +443,8 @@ func (a *Array) LockFunc(f func(array []interface{})) *Array {
 //
 // 使用自定义方法执行加锁读取操作
 func (a *Array) RLockFunc(f func(array []interface{})) *Array {
-    a.mu.RLock(true)
-    defer a.mu.RUnlock(true)
+    a.mu.RLock()
+    defer a.mu.RUnlock()
    f(a.array)
    return a
 }
--- a/g/container/garray/garray_normal_string.go
+++ b/g/container/garray/garray_normal_string.go
@ -440,8 +440,8 @@ func (a *StringArray) Unique() *StringArray {
 //
 // 使用自定义方法执行加锁修改操作。
 func (a *StringArray) LockFunc(f func(array []string)) *StringArray {
-	a.mu.Lock(true)
-	defer a.mu.Unlock(true)
+	a.mu.Lock()
+	defer a.mu.Unlock()
 	f(a.array)
    return a
 }
@ -450,8 +450,8 @@ func (a *StringArray) LockFunc(f func(array []string)) *StringArray {
 //
 // 使用自定义方法执行加锁读取操作。
 func (a *StringArray) RLockFunc(f func(array []string)) *StringArray {
-	a.mu.RLock(true)
-	defer a.mu.RUnlock(true)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
 	f(a.array)
    return a
 }
--- a/g/container/garray/garray_sorted_int.go
+++ b/g/container/garray/garray_sorted_int.go
@ -415,8 +415,8 @@ func (a *SortedIntArray) Clear() *SortedIntArray {
 //
 // 使用自定义方法执行加锁修改操作。
 func (a *SortedIntArray) LockFunc(f func(array []int)) *SortedIntArray {
-    a.mu.Lock(true)
-    defer a.mu.Unlock(true)
+    a.mu.Lock()
+    defer a.mu.Unlock()
    f(a.array)
    return a
 }
@ -425,8 +425,8 @@ func (a *SortedIntArray) LockFunc(f func(array []int)) *SortedIntArray {
 //
 // 使用自定义方法执行加锁读取操作。
 func (a *SortedIntArray) RLockFunc(f func(array []int)) *SortedIntArray {
-    a.mu.RLock(true)
-    defer a.mu.RUnlock(true)
+    a.mu.RLock()
+    defer a.mu.RUnlock()
    f(a.array)
    return a
 }
--- a/g/container/garray/garray_sorted_interface.go
+++ b/g/container/garray/garray_sorted_interface.go
@ -422,8 +422,8 @@ func (a *SortedArray) Clear() *SortedArray {
 //
 // 使用自定义方法执行加锁修改操作。
 func (a *SortedArray) LockFunc(f func(array []interface{})) *SortedArray {
-    a.mu.Lock(true)
-    defer a.mu.Unlock(true)
+    a.mu.Lock()
+    defer a.mu.Unlock()
    f(a.array)
    return a
 }
@ -432,8 +432,8 @@ func (a *SortedArray) LockFunc(f func(array []interface{})) *SortedArray {
 //
 // 使用自定义方法执行加锁读取操作。
 func (a *SortedArray) RLockFunc(f func(array []interface{})) *SortedArray {
-    a.mu.RLock(true)
-    defer a.mu.RUnlock(true)
+    a.mu.RLock()
+    defer a.mu.RUnlock()
    f(a.array)
    return a
 }
--- a/g/container/garray/garray_sorted_string.go
+++ b/g/container/garray/garray_sorted_string.go
@ -410,8 +410,8 @@ func (a *SortedStringArray) Clear() *SortedStringArray {
 //
 // 使用自定义方法执行加锁修改操作。
 func (a *SortedStringArray) LockFunc(f func(array []string)) *SortedStringArray {
-    a.mu.Lock(true)
-    defer a.mu.Unlock(true)
+    a.mu.Lock()
+    defer a.mu.Unlock()
    f(a.array)
    return a
 }
@ -420,8 +420,8 @@ func (a *SortedStringArray) LockFunc(f func(array []string)) *SortedStringArray
 //
 // 使用自定义方法执行加锁读取操作。
 func (a *SortedStringArray) RLockFunc(f func(array []string)) *SortedStringArray {
-    a.mu.RLock(true)
-    defer a.mu.RUnlock(true)
+    a.mu.RLock()
+    defer a.mu.RUnlock()
    f(a.array)
    return a
 }
--- a/g/container/gmap/gmap.go
+++ b/g/container/gmap/gmap.go
@ -291,8 +291,8 @@ func (gm *Map) Clear() {
 //
 // 并发安全锁操作，使用自定义方法执行加锁修改操作
 func (gm *Map) LockFunc(f func(m map[interface{}]interface{})) {
-    gm.mu.Lock(true)
-    defer gm.mu.Unlock(true)
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
    f(gm.m)
 }

@ -300,8 +300,8 @@ func (gm *Map) LockFunc(f func(m map[interface{}]interface{})) {
 //
 // 并发安全锁操作，使用自定义方法执行加锁读取操作
 func (gm *Map) RLockFunc(f func(m map[interface{}]interface{})) {
-    gm.mu.RLock(true)
-    defer gm.mu.RUnlock(true)
+    gm.mu.RLock()
+    defer gm.mu.RUnlock()
    f(gm.m)
 }

--- a/g/container/gmap/gmap_int_bool_map.go
+++ b/g/container/gmap/gmap_int_bool_map.go
@ -238,15 +238,15 @@ func (gm *IntBoolMap) Clear() {

 // 并发安全锁操作，使用自定义方法执行加锁修改操作
 func (gm *IntBoolMap) LockFunc(f func(m map[int]bool)) {
-    gm.mu.Lock(true)
-    defer gm.mu.Unlock(true)
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
    f(gm.m)
 }

 // 并发安全锁操作，使用自定义方法执行加锁读取操作
 func (gm *IntBoolMap) RLockFunc(f func(m map[int]bool)) {
-    gm.mu.RLock(true)
-    defer gm.mu.RUnlock(true)
+    gm.mu.RLock()
+    defer gm.mu.RUnlock()
    f(gm.m)
 }

--- a/g/container/gmap/gmap_int_int_map.go
+++ b/g/container/gmap/gmap_int_int_map.go
@ -238,15 +238,15 @@ func (gm *IntIntMap) Clear() {

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

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

--- a/g/container/gmap/gmap_int_interface_map.go
+++ b/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
 }

@ -231,8 +233,8 @@ func (gm *IntInterfaceMap) LockFunc(f func(m map[int]interface{})) {

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

--- a/g/container/gmap/gmap_int_string_map.go
+++ b/g/container/gmap/gmap_int_string_map.go
@ -239,15 +239,15 @@ func (gm *IntStringMap) Clear() {

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

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

--- a/g/container/gmap/gmap_string_bool_map.go
+++ b/g/container/gmap/gmap_string_bool_map.go
@ -238,15 +238,15 @@ func (gm *StringBoolMap) Clear() {

 // 并发安全锁操作，使用自定义方法执行加锁修改操作
 func (gm *StringBoolMap) LockFunc(f func(m map[string]bool)) {
-	gm.mu.Lock(true)
-	defer gm.mu.Unlock(true)
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
 	f(gm.m)
 }

 // 并发安全锁操作，使用自定义方法执行加锁读取操作
 func (gm *StringBoolMap) RLockFunc(f func(m map[string]bool)) {
-	gm.mu.RLock(true)
-	defer gm.mu.RUnlock(true)
+	gm.mu.RLock()
+	defer gm.mu.RUnlock()
 	f(gm.m)
 }

--- a/g/container/gmap/gmap_string_int_map.go
+++ b/g/container/gmap/gmap_string_int_map.go
@ -239,15 +239,15 @@ func (gm *StringIntMap) Clear() {

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

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

--- a/g/container/gmap/gmap_string_interface_map.go
+++ b/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
 }

@ -224,15 +226,15 @@ func (gm *StringInterfaceMap) Clear() {

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

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

--- a/g/container/gmap/gmap_string_string_map.go
+++ b/g/container/gmap/gmap_string_string_map.go
@ -238,15 +238,15 @@ func (gm *StringStringMap) Clear() {

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

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

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

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

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

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

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

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

 // 写锁遍历，往前写遍历，回调函数返回true表示继续遍历，否则退出遍历
 func (r *Ring) LockIteratorPrev(f func(item *ring.Ring) bool) {
-    r.mu.RLock(true)
-    defer r.mu.RUnlock(true)
+    r.mu.RLock()
+    defer r.mu.RUnlock()
    if !f(r.ring) {
        return
    }
--- a/g/container/gset/gset.go
+++ b/g/container/gset/gset.go
@ -139,8 +139,8 @@ func (set *Set) String() string {
 //
 // 使用自定义方法执行加锁修改操作。
 func (set *Set) LockFunc(f func(m map[interface{}]struct{})) *Set {
-    set.mu.Lock(true)
-    defer set.mu.Unlock(true)
+    set.mu.Lock()
+    defer set.mu.Unlock()
    f(set.m)
    return set
 }
@ -149,8 +149,8 @@ func (set *Set) LockFunc(f func(m map[interface{}]struct{})) *Set {
 //
 // 使用自定义方法执行加锁读取操作。
 func (set *Set) RLockFunc(f func(m map[interface{}]struct{})) *Set {
-    set.mu.RLock(true)
-    defer set.mu.RUnlock(true)
+    set.mu.RLock()
+    defer set.mu.RUnlock()
    f(set.m)
    return set
 }
--- a/g/container/gset/gset_int_set.go
+++ b/g/container/gset/gset_int_set.go
@ -130,8 +130,8 @@ func (set *IntSet) String() string {
 //
 // 使用自定义方法执行加锁修改操作。
 func (set *IntSet) LockFunc(f func(m map[int]struct{})) *IntSet {
-	set.mu.Lock(true)
-	defer set.mu.Unlock(true)
+	set.mu.Lock()
+	defer set.mu.Unlock()
 	f(set.m)
    return set
 }
@ -140,8 +140,8 @@ func (set *IntSet) LockFunc(f func(m map[int]struct{})) *IntSet {
 //
 // 使用自定义方法执行加锁读取操作。
 func (set *IntSet) RLockFunc(f func(m map[int]struct{})) *IntSet {
-    set.mu.RLock(true)
-    defer set.mu.RUnlock(true)
+    set.mu.RLock()
+    defer set.mu.RUnlock()
    f(set.m)
    return set
 }
--- a/g/container/gset/gset_string_set.go
+++ b/g/container/gset/gset_string_set.go
@ -130,8 +130,8 @@ func (set *StringSet) String() string {
 //
 // 使用自定义方法执行加锁修改操作。
 func (set *StringSet) LockFunc(f func(m map[string]struct{})) *StringSet {
-	set.mu.Lock(true)
-	defer set.mu.Unlock(true)
+	set.mu.Lock()
+	defer set.mu.Unlock()
 	f(set.m)
    return set
 }
@ -140,8 +140,8 @@ func (set *StringSet) LockFunc(f func(m map[string]struct{})) *StringSet {
 //
 // 使用自定义方法执行加锁读取操作。
 func (set *StringSet) RLockFunc(f func(m map[string]struct{})) *StringSet {
-	set.mu.RLock(true)
-	defer set.mu.RUnlock(true)
+	set.mu.RLock()
+	defer set.mu.RUnlock()
 	f(set.m)
    return set
 }
--- a/g/container/gvar/gvar.go
+++ b/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
--- a/g/database/gdb/gdb.go
+++ b/g/database/gdb/gdb.go
@ -39,8 +39,8 @@ type DB interface {
    doPrepare(link dbLink, query string) (*sql.Stmt, error)
    doInsert(link dbLink, table string, data interface{}, option int, batch...int) (result sql.Result, err error)
    doBatchInsert(link dbLink, table string, list interface{}, option int, batch...int) (result sql.Result, err error)
-    doUpdate(link dbLink, table string, data interface{}, condition interface{}, args ...interface{}) (result sql.Result, err error)
-    doDelete(link dbLink, table string, condition interface{}, args ...interface{}) (result sql.Result, err error)
+    doUpdate(link dbLink, table string, data interface{}, condition string, args ...interface{}) (result sql.Result, err error)
+    doDelete(link dbLink, table string, condition string, args ...interface{}) (result sql.Result, err error)

 	// 数据库查询
 	GetAll(query string, args ...interface{}) (Result, error)
--- a/g/database/gdb/gdb_base.go
+++ b/g/database/gdb/gdb_base.go
@ -312,7 +312,7 @@ func (bs *dbBase) doInsert(link dbLink, table string, data interface{}, option i
            return bs.db.doBatchInsert(link, table, data, option, batch...)
        case reflect.Map:   fallthrough
        case reflect.Struct:
-            dataMap = Map(gconv.Map(data))
+            dataMap = gconv.Map(data)
        default:
            return result, errors.New(fmt.Sprint("unsupported data type:", kind))
    }
@ -320,7 +320,7 @@ func (bs *dbBase) doInsert(link dbLink, table string, data interface{}, option i
    for k, v := range dataMap {
        fields = append(fields, charL + k + charR)
        values = append(values, "?")
-        params = append(params, v)
+        params = append(params, convertParam(v))
    }
    operation := getInsertOperationByOption(option)
    updateStr := ""
@ -369,6 +369,10 @@ func (bs *dbBase) doBatchInsert(link dbLink, table string, list interface{}, opt
    var params []interface{}
    listMap := (List)(nil)
    switch v := list.(type) {
+        case Result:
+            listMap = v.ToList()
+        case Record:
+            listMap = List{v.ToMap()}
        case List:
            listMap = v
        case Map:
@ -436,7 +440,7 @@ func (bs *dbBase) doBatchInsert(link dbLink, table string, list interface{}, opt
    }
    for i := 0; i < len(listMap); i++ {
        for _, k := range keys {
-            params = append(params, listMap[i][k])
+            params = append(params, convertParam(listMap[i][k]))
        }
        values = append(values, valueHolderStr)
        if len(values) == batchNum {
@ -479,17 +483,13 @@ func (bs *dbBase) doBatchInsert(link dbLink, table string, list interface{}, opt
 // CURD操作:数据更新，统一采用sql预处理。
 // data参数支持string/map/struct/*struct类型。
 func (bs *dbBase) Update(table string, data interface{}, condition interface{}, args ...interface{}) (sql.Result, error) {
-    link, err := bs.db.Master()
-    if err != nil {
-        return nil, err
-    }
-    return bs.db.doUpdate(link, table, data, condition, args ...)
+    newWhere, newArgs := formatCondition(condition, args)
+    return bs.db.doUpdate(nil, table, data, newWhere, newArgs ...)
 }

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

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

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

 // 获得缓存对象
--- a/g/database/gdb/gdb_func.go
+++ b/g/database/gdb/gdb_func.go
@ -31,41 +31,62 @@ func formatCondition(where interface{}, args []interface{}) (newWhere string, ne
        rv   = rv.Elem()
        kind = rv.Kind()
    }
+    tmpArgs := []interface{}(nil)
    switch kind {
-        // 注意当where为map/struct类型时，args参数必须为空。
+        // map/struct类型
        case reflect.Map:   fallthrough
        case reflect.Struct:
-            for k, v := range gconv.Map(where) {
+            for key, value := range gconv.Map(where) {
                if buffer.Len() > 0 {
                    buffer.WriteString(" AND ")
                }
-                // 支持slice键值/属性，这个时候作为IN查询
-                switch reflect.ValueOf(v).Kind() {
+                // 支持slice键值/属性，如果只有一个?占位符号，那么作为IN查询，否则打散作为多个查询参数
+                rv := reflect.ValueOf(value)
+                switch rv.Kind() {
                    case reflect.Slice: fallthrough
                    case reflect.Array:
-                        buffer.WriteString(k + " IN(?)")
-                    default:
-                        if gstr.Pos(k, "<") == -1 && gstr.Pos(k, ">") == -1 && gstr.Pos(k, "=") == -1 {
-                            buffer.WriteString(k + "=?")
+                        count := gstr.Count(key, "?")
+                        if count == 0 {
+                            buffer.WriteString(key + " IN(?)")
+                            tmpArgs = append(tmpArgs, value)
+                        } else if count != rv.Len() {
+                            buffer.WriteString(key)
+                            tmpArgs = append(tmpArgs, value)
                        } else {
-                            buffer.WriteString(k + "?")
+                            buffer.WriteString(key)
+                            // 如果键名/属性名称中带有多个?占位符号，那么将参数打散
+                            tmpArgs = append(tmpArgs, gconv.Interfaces(value)...)
+                        }
+                    default:
+                        if value == nil {
+                            buffer.WriteString(key)
+                        } else {
+                            if gstr.Pos(key, "?") == -1 {
+                                if gstr.Pos(key, "<") == -1 && gstr.Pos(key, ">") == -1 && gstr.Pos(key, "=") == -1 {
+                                    buffer.WriteString(key + "=?")
+                                } else {
+                                    buffer.WriteString(key + "?")
+                                }
+                            } else {
+                                buffer.WriteString(key)
+                            }
+                            tmpArgs = append(tmpArgs, value)
                        }
                }
-                // 当给定的Where参数为map/struct时，args参数必定为空，
-                // 考虑到后续还会对args做处理，特别是判断slice类型，这里直接给args赋值。
-                args = append(args, v)
            }
-            newWhere = buffer.String()
+
        default:
            buffer.WriteString(gconv.String(where))
    }
+    // 没有任何条件查询参数，直接返回
    if buffer.Len() == 0 {
-        buffer.WriteString("1=1")
+        return "", args
    }
-    // 查询条件参数处理，主要处理slice参数类型
    newWhere = buffer.String()
-    if len(args) > 0 {
-        for index, arg := range args {
+    tmpArgs  = append(tmpArgs, args...)
+    // 查询条件参数处理，主要处理slice参数类型
+    if len(tmpArgs) > 0 {
+        for index, arg := range tmpArgs {
            rv   := reflect.ValueOf(arg)
            kind := rv.Kind()
            if kind == reflect.Ptr {
@ -90,6 +111,14 @@ func formatCondition(where interface{}, args []interface{}) (newWhere string, ne
                        return s
                    })
                default:
+                    // 支持例如 Where/And/Or("uid", 1) 这种格式
+                    if gstr.Pos(newWhere, "?") == -1 {
+                        if gstr.Pos(newWhere, "<") == -1 && gstr.Pos(newWhere, ">") == -1 && gstr.Pos(newWhere, "=") == -1 {
+                            newWhere += "=?"
+                        } else {
+                            newWhere += "?"
+                        }
+                    }
                    newArgs = append(newArgs, arg)
            }
        }
@ -97,6 +126,22 @@ func formatCondition(where interface{}, args []interface{}) (newWhere string, ne
    return
 }

+// 将预处理参数转换为底层数据库引擎支持的格式。
+// 主要是判断参数是否为复杂数据类型，如果是，那么转换为基础类型。
+func convertParam(value interface{}) interface{} {
+    rv   := reflect.ValueOf(value)
+    kind := rv.Kind()
+    if kind == reflect.Ptr {
+        rv   = rv.Elem()
+        kind = rv.Kind()
+    }
+    switch kind {
+        case reflect.Struct:
+            return gconv.String(value)
+    }
+    return value
+}
+
 // 打印SQL对象(仅在debug=true时有效)
 func printSql(v *Sql) {
    s := fmt.Sprintf("%s, %v, %s, %s, %d ms, %s", v.Sql, v.Args,
--- a/g/database/gdb/gdb_model.go
+++ b/g/database/gdb/gdb_model.go
@ -3,17 +3,18 @@
 // This Source Code Form is subject to the terms of the MIT License.
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
+//
+// @author john, ymrjqyy

 package gdb

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

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

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

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

@ -80,21 +83,25 @@ func (md *Model) Clone() *Model {
    return newModel
 }

-// 标识当前对象可被修改。
+// 标识当前对象运行安全模式(可被修改)。
 // 1. 默认情况下，模型对象的对象属性无法被修改，
 // 每一次链式操作都是克隆一个新的模型对象，这样所有的操作都不会污染模型对象。
 // 但是链式操作如果需要分开执行，那么需要将新的克隆对象赋值给旧的模型对象继续操作。
 // 2. 当标识模型对象为可修改，那么在当前模型对象的所有链式操作均会影响下一次的链式操作，
 // 即使是链式操作分开执行。
 // 3. 大部分ORM框架默认模型对象是可修改的，但是GF框架的ORM提供给开发者更灵活，更安全的链式操作选项。
-func (md *Model) Alterable() *Model {
-    md.alterable = true
+func (md *Model) Safe(safe...bool) *Model {
+    if len(safe) > 0 {
+        md.safe = safe[0]
+    } else {
+        md.safe = true
+    }
    return md
 }

 // 返回操作的模型对象，可能是当前对象，也可能是新的克隆对象，根据alterable决定。
 func (md *Model) getModel() *Model {
-    if md.alterable {
+    if !md.safe {
        return md
    } else {
        return md.Clone()
@ -137,16 +144,15 @@ func (md *Model) Filter() (*Model) {
 }

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

@ -154,8 +160,12 @@ func (md *Model) Where(where interface{}, args ...interface{}) (*Model) {
 func (md *Model) And(where interface{}, args ...interface{}) (*Model) {
    model             := md.getModel()
    newWhere, newArgs := formatCondition(where, args)
-    model.where       += " AND " + newWhere
-    model.whereArgs    = append(model.whereArgs, newArgs...)
+    if len(model.where) > 0 && model.where[0] == '(' {
+        model.where = fmt.Sprintf(`%s AND (%s)`, model.where, newWhere)
+    } else {
+        model.where = fmt.Sprintf(`(%s) AND (%s)`, model.where, newWhere)
+    }
+    model.whereArgs = append(model.whereArgs, newArgs...)
 	return model
 }

@ -163,8 +173,12 @@ func (md *Model) And(where interface{}, args ...interface{}) (*Model) {
 func (md *Model) Or(where interface{}, args ...interface{}) (*Model) {
    model             := md.getModel()
    newWhere, newArgs := formatCondition(where, args)
-    model.where       += " OR " + newWhere
-    model.whereArgs    = append(model.whereArgs, newArgs...)
+    if len(model.where) > 0 && model.where[0] == '(' {
+        model.where = fmt.Sprintf(`%s OR (%s)`, model.where, newWhere)
+    } else {
+        model.where = fmt.Sprintf(`(%s) OR (%s)`, model.where, newWhere)
+    }
+    model.whereArgs = append(model.whereArgs, newArgs...)
 	return model
 }

@ -190,8 +204,7 @@ func (md *Model) Limit(start int, limit int) (*Model) {
 	return model
 }

-// 链式操作，翻页
-// @author ymrjqyy
+// 链式操作，翻页，注意分页页码从1开始，而Limit方法从0开始。
 func (md *Model) ForPage(page, limit int) (*Model) {
    model      := md.getModel()
    model.start = (page - 1) * limit
@ -234,13 +247,17 @@ func (md *Model) Data(data ...interface{}) *Model {
 		}
        model.data = m
 	} else {
-		switch data[0].(type) {
+		switch params := data[0].(type) {
+			case Result:
+				model.data = params.ToList()
+			case Record:
+				model.data = params.ToMap()
 			case List:
-                model.data = data[0]
+                model.data = params
 			case Map:
-                model.data = data[0]
+                model.data = params
 			default:
-                rv   := reflect.ValueOf(data[0])
+                rv   := reflect.ValueOf(params)
                kind := rv.Kind()
                if kind == reflect.Ptr {
                    rv   = rv.Elem()
@ -407,9 +424,9 @@ func (md *Model) Update() (result sql.Result, err error) {
        }
    }
 	if md.tx == nil {
-		return md.db.Update(md.tables, md.data, md.where, md.whereArgs ...)
+		return md.db.doUpdate(nil, md.tables, md.data, md.where, md.whereArgs ...)
 	} else {
-		return md.tx.Update(md.tables, md.data, md.where, md.whereArgs ...)
+		return md.tx.doUpdate(md.tables, md.data, md.where, md.whereArgs ...)
 	}
 }

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

@ -586,14 +603,13 @@ func (md *Model) getFormattedSql() string {
 	return s
 }

-// 组块结果集
-// @author ymrjqyy
-// @author 2018-08-15
+// 组块结果集。
 func (md *Model) Chunk(limit int, callback func(result Result, err error) bool) {
-	page := 1
+	page  := 1
+	model := md
 	for {
-		md.ForPage(page, limit)
-		data, err := md.getAll(md.getFormattedSql(), md.whereArgs...)
+        model      = model.ForPage(page, limit)
+		data, err := model.All()
 		if err != nil {
 			callback(nil, err)
 			break
--- a/g/database/gdb/gdb_transaction.go
+++ b/g/database/gdb/gdb_transaction.go
@ -162,14 +162,28 @@ func (tx *TX) BatchSave(table string, list interface{}, batch...int) (sql.Result
    return tx.db.doBatchInsert(tx.tx, table, list, OPTION_SAVE, batch...)
 }

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

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

+
+
--- a/g/database/gdb/gdb_unit_init_test.go
+++ b/g/database/gdb/gdb_unit_init_test.go
@ -1,11 +1,26 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
 package gdb_test

 import (
+    "fmt"
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/container/garray"
    "github.com/gogf/gf/g/database/gdb"
+    "github.com/gogf/gf/g/os/gtime"
    "github.com/gogf/gf/g/test/gtest"
 	"os"
 )

+const (
+    // 初始化表数据量
+    INIT_DATA_SIZE = 10
+)
+
 var (
 	// 数据库对象/接口
 	db gdb.DB
@ -26,10 +41,12 @@ func init() {
 		Priority: 1,
 	}
 	hostname, _ := os.Hostname()
+	// 本地测试hack
 	if hostname == "ijohn" {
 		node.Pass = "12345678"
 	}
-	gdb.AddDefaultConfigNode(node)
+	gdb.AddConfigNode("test",                 node)
+	gdb.AddConfigNode(gdb.DEFAULT_GROUP_NAME, node)
 	if r, err := gdb.New(); err != nil {
        gtest.Fatal(err)
 	} else {
@ -39,12 +56,25 @@ func init() {
    if _, err := db.Exec("CREATE DATABASE IF NOT EXISTS `test` CHARACTER SET UTF8"); err != nil {
        gtest.Fatal(err)
    }
+    // 选择操作数据库
    db.SetSchema("test")
-    if _, err := db.Exec("DROP TABLE IF EXISTS `user`"); err != nil {
-        gtest.Fatal(err)
+    // 创建默认用户表
+    createTable("user")
+}
+
+// 创建指定名称的user测试表，当table为空时，创建随机的表名。
+// 创建的测试表默认没有任何数据。
+// 执行完成后返回该表名。
+// TODO 支持更多数据库
+func createTable(table...string) (name string) {
+    if len(table) > 0 {
+        name = table[0]
+    } else {
+        name = fmt.Sprintf(`user_%d`, gtime.Nanosecond())
    }
-    if _, err := db.Exec(`
-    CREATE TABLE user (
+    dropTable(name)
+    if _, err := db.Exec(fmt.Sprintf(`
+    CREATE TABLE %s (
        id int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '用户ID',
        passport varchar(45) NOT NULL COMMENT '账号',
        password char(32) NOT NULL COMMENT '密码',
@ -52,7 +82,38 @@ func init() {
        create_time timestamp NOT NULL COMMENT '创建时间/注册时间',
        PRIMARY KEY (id)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-    `); err != nil {
+    `, name)); err != nil {
+        gtest.Fatal(err)
+    }
+    return
+}
+
+// 删除指定表.
+func dropTable(table string) {
+    if _, err := db.Exec(fmt.Sprintf("DROP TABLE IF EXISTS `%s`", table)); err != nil {
        gtest.Fatal(err)
    }
 }
+
+// See createTable.
+// 创建测试表，并初始化默认数据。
+func createInitTable(table...string) (name string) {
+    name   = createTable(table...)
+    array := garray.New(true)
+    for i := 1; i <= INIT_DATA_SIZE; i++ {
+        array.Append(g.Map{
+            "id"          : i,
+            "passport"    : fmt.Sprintf(`t%d`, i),
+            "password"    : fmt.Sprintf(`p%d`, i),
+            "nickname"    : fmt.Sprintf(`T%d`, i),
+            "create_time" : gtime.Now().String(),
+        })
+    }
+    result, err := db.Table(name).Data(array.Slice()).Insert()
+    gtest.Assert(err, nil)
+
+    n, e := result.RowsAffected()
+    gtest.Assert(e, nil)
+    gtest.Assert(n, INIT_DATA_SIZE)
+    return
+}
--- a/g/database/gdb/gdb_unit_method_test.go
+++ b/g/database/gdb/gdb_unit_method_test.go
@ -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

@ -9,6 +13,15 @@ import (
    "testing"
 )

+func TestDbBase_Ping(t *testing.T) {
+    gtest.Case(t, func() {
+        err1 := db.PingMaster()
+        err2 := db.PingSlave()
+        gtest.Assert(err1, nil)
+        gtest.Assert(err2, nil)
+    })
+}
+
 func TestDbBase_Query(t *testing.T) {
    if _, err := db.Query("SELECT ?", 1); err != nil {
        gtest.Fatal(err)
@ -144,57 +157,102 @@ func TestDbBase_Insert(t *testing.T) {
 }

 func TestDbBase_BatchInsert(t *testing.T) {
-    if r, err := db.BatchInsert("user", g.List {
-        {
-            "id"          : 2,
-            "passport"    : "t2",
-            "password"    : "25d55ad283aa400af464c76d713c07ad",
-            "nickname"    : "T2",
-            "create_time" : gtime.Now().String(),
-        },
-        {
-            "id"          : 3,
-            "passport"    : "t3",
-            "password"    : "25d55ad283aa400af464c76d713c07ad",
-            "nickname"    : "T3",
-            "create_time" : gtime.Now().String(),
-        },
-    }, 1); err != nil {
-        gtest.Fatal(err)
-    } else {
-        n, _ := r.RowsAffected()
-        gtest.Assert(n, 2)
-    }
+    gtest.Case(t, func() {
+        if r, err := db.BatchInsert("user", g.List {
+            {
+                "id"          : 2,
+                "passport"    : "t2",
+                "password"    : "25d55ad283aa400af464c76d713c07ad",
+                "nickname"    : "T2",
+                "create_time" : gtime.Now().String(),
+            },
+            {
+                "id"          : 3,
+                "passport"    : "t3",
+                "password"    : "25d55ad283aa400af464c76d713c07ad",
+                "nickname"    : "T3",
+                "create_time" : gtime.Now().String(),
+            },
+        }, 1); err != nil {
+            gtest.Fatal(err)
+        } else {
+            n, _ := r.RowsAffected()
+            gtest.Assert(n, 2)
+        }

-    result, err := db.Delete("user", "id>?", 1)
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    n, _ := result.RowsAffected()
-    gtest.Assert(n, 2)
-
-    // []interface{}
-    if r, err := db.BatchInsert("user", []interface{} {
-        map[interface{}]interface{} {
-            "id"          : 2,
-            "passport"    : "t2",
-            "password"    : "25d55ad283aa400af464c76d713c07ad",
-            "nickname"    : "T2",
-            "create_time" : gtime.Now().String(),
-        },
-        map[interface{}]interface{} {
-            "id"          : 3,
-            "passport"    : "t3",
-            "password"    : "25d55ad283aa400af464c76d713c07ad",
-            "nickname"    : "T3",
-            "create_time" : gtime.Now().String(),
-        },
-    }, 1); err != nil {
-        gtest.Fatal(err)
-    } else {
-        n, _ := r.RowsAffected()
+        result, err := db.Delete("user", "id>?", 1)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        n, _ := result.RowsAffected()
        gtest.Assert(n, 2)
-    }
+
+        // []interface{}
+        if r, err := db.BatchInsert("user", []interface{} {
+            map[interface{}]interface{} {
+                "id"          : 2,
+                "passport"    : "t2",
+                "password"    : "25d55ad283aa400af464c76d713c07ad",
+                "nickname"    : "T2",
+                "create_time" : gtime.Now().String(),
+            },
+            map[interface{}]interface{} {
+                "id"          : 3,
+                "passport"    : "t3",
+                "password"    : "25d55ad283aa400af464c76d713c07ad",
+                "nickname"    : "T3",
+                "create_time" : gtime.Now().String(),
+            },
+        }, 1); err != nil {
+            gtest.Fatal(err)
+        } else {
+            n, _ := r.RowsAffected()
+            gtest.Assert(n, 2)
+        }
+    })
+    // batch insert map
+    gtest.Case(t, func() {
+        table := createTable()
+        defer dropTable(table)
+        result, err := db.BatchInsert(table, g.Map{
+            "id"          : 1,
+            "passport"    : "t1",
+            "password"    : "p1",
+            "nickname"    : "T1",
+            "create_time" : gtime.Now().String(),
+        })
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        n, _ := result.RowsAffected()
+        gtest.Assert(n, 1)
+    })
+    // batch insert struct
+    gtest.Case(t, func() {
+        table := createTable()
+        defer dropTable(table)
+
+        type User struct {
+            Id         int         `gconv:"id"`
+            Passport   string      `gconv:"passport"`
+            Password   string      `gconv:"password"`
+            NickName   string      `gconv:"nickname"`
+            CreateTime *gtime.Time `gconv:"create_time"`
+        }
+        user := &User{
+            Id          : 1,
+            Passport    : "t1",
+            Password    : "p1",
+            NickName    : "T1",
+            CreateTime  : gtime.Now(),
+        }
+        result, err := db.BatchInsert(table, user)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        n, _ := result.RowsAffected()
+        gtest.Assert(n, 1)
+    })
 }

 func TestDbBase_Save(t *testing.T) {
--- a/g/database/gdb/gdb_unit_model_test.go
+++ b/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

@ -90,29 +94,66 @@ func TestModel_Insert(t *testing.T) {
 }

 func TestModel_Batch(t *testing.T) {
-    result, err := db.Table("user").Filter().Data(g.List{
-        {
-            "id"          : 2,
-            "uid"         : 2,
-            "passport"    : "t2",
-            "password"    : "25d55ad283aa400af464c76d713c07ad",
-            "nickname"    : "T2",
-            "create_time" : gtime.Now().String(),
-        },
-        {
-            "id"          : 3,
-            "uid"         : 3,
-            "passport"    : "t3",
-            "password"    : "25d55ad283aa400af464c76d713c07ad",
-            "nickname"    : "T3",
-            "create_time" : gtime.Now().String(),
-        },
-    }).Batch(1).Insert()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    n, _ := result.RowsAffected()
-    gtest.Assert(n, 2)
+    // batch insert
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Filter().Data(g.List{
+            {
+                "id"          : 2,
+                "uid"         : 2,
+                "passport"    : "t2",
+                "password"    : "25d55ad283aa400af464c76d713c07ad",
+                "nickname"    : "T2",
+                "create_time" : gtime.Now().String(),
+            },
+            {
+                "id"          : 3,
+                "uid"         : 3,
+                "passport"    : "t3",
+                "password"    : "25d55ad283aa400af464c76d713c07ad",
+                "nickname"    : "T3",
+                "create_time" : gtime.Now().String(),
+            },
+        }).Batch(1).Insert()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        n, _ := result.RowsAffected()
+        gtest.Assert(n, 2)
+    })
+
+    // batch save
+    gtest.Case(t, func() {
+        table := createInitTable()
+        defer dropTable(table)
+        result, err  := db.Table(table).All()
+        gtest.Assert(err,         nil)
+        gtest.Assert(len(result), INIT_DATA_SIZE)
+        for _, v := range result {
+            v["nickname"].Set(v["nickname"].String() + v["id"].String())
+        }
+        r, e := db.Table(table).Data(result).Save()
+        gtest.Assert(e, nil)
+        n, e := r.RowsAffected()
+        gtest.Assert(e, nil)
+        gtest.Assert(n, INIT_DATA_SIZE*2)
+    })
+
+    // batch replace
+    gtest.Case(t, func() {
+        table := createInitTable()
+        defer dropTable(table)
+        result, err  := db.Table(table).All()
+        gtest.Assert(err,         nil)
+        gtest.Assert(len(result), INIT_DATA_SIZE)
+        for _, v := range result {
+            v["nickname"].Set(v["nickname"].String() + v["id"].String())
+        }
+        r, e := db.Table(table).Data(result).Replace()
+        gtest.Assert(e, nil)
+        n, e := r.RowsAffected()
+        gtest.Assert(e, nil)
+        gtest.Assert(n, INIT_DATA_SIZE*2)
+    })
 }

 func TestModel_Replace(t *testing.T) {
@ -146,12 +187,23 @@ func TestModel_Save(t *testing.T) {
 }

 func TestModel_Update(t *testing.T) {
-    result, err := db.Table("user").Data("passport", "t22").Where("passport=?", "t2").Update()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    n, _ := result.RowsAffected()
-    gtest.Assert(n, 1)
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Data("passport", "t22").Where("passport=?", "t2").Update()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        n, _ := result.RowsAffected()
+        gtest.Assert(n, 1)
+    })
+
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Data("passport", "t2").Where("passport='t22'").Update()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        n, _ := result.RowsAffected()
+        gtest.Assert(n, 1)
+    })
 }

 func TestModel_Clone(t *testing.T) {
@ -175,9 +227,9 @@ func TestModel_Clone(t *testing.T) {
    gtest.Assert(result[1]["id"].Int(), 3)
 }

-func TestModel_Alterable(t *testing.T) {
+func TestModel_Safe(t *testing.T) {
    gtest.Case(t, func() {
-        md := db.Table("user").Alterable().Where("id IN(?)", g.Slice{1,3})
+        md := db.Table("user").Safe(false).Where("id IN(?)", g.Slice{1,3})
        count, err := md.Count()
        if err != nil {
            gtest.Fatal(err)
@ -190,6 +242,20 @@ func TestModel_Alterable(t *testing.T) {
        }
        gtest.Assert(count, 1)
    })
+    gtest.Case(t, func() {
+        md := db.Table("user").Safe(true).Where("id IN(?)", g.Slice{1,3})
+        count, err := md.Count()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(count, 2)
+        md.And("id = ?", 1)
+        count, err = md.Count()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(count, 2)
+    })
 }

 func TestModel_All(t *testing.T) {
@ -420,12 +486,52 @@ func TestModel_GroupBy(t *testing.T) {
 func TestModel_Where(t *testing.T) {
    // string
    gtest.Case(t, func() {
-        result, err := db.Table("user").Where("id=? and nickname=?", 3, "T3").One()
+       result, err := db.Table("user").Where("id=? and nickname=?", 3, "T3").One()
+       if err != nil {
+           gtest.Fatal(err)
+       }
+       gtest.AssertGT(len(result),      0)
+       gtest.Assert(result["id"].Int(), 3)
+    })
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where("id", 3).One()
+        if err != nil {
+           gtest.Fatal(err)
+        }
+        gtest.AssertGT(len(result),      0)
+        gtest.Assert(result["id"].Int(), 3)
+    })
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where("id", 3).Where("nickname", "T3").One()
        if err != nil {
            gtest.Fatal(err)
        }
        gtest.Assert(result["id"].Int(), 3)
    })
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where("id", 3).And("nickname", "T3").One()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(result["id"].Int(), 3)
+    })
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where("id", 30).Or("nickname", "T3").One()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(result["id"].Int(), 3)
+    })
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where("id", 30).Or("nickname", "T3").And("id>?", 1).One()
+        gtest.Assert(err,                nil)
+        gtest.Assert(result["id"].Int(), 3)
+    })
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where("id", 30).Or("nickname", "T3").And("id>", 1).One()
+        gtest.Assert(err,                nil)
+        gtest.Assert(result["id"].Int(), 3)
+    })
    // map
    gtest.Case(t, func() {
        result, err := db.Table("user").Where(g.Map{"id" : 3, "nickname" : "T3"}).One()
@ -437,11 +543,39 @@ func TestModel_Where(t *testing.T) {
    // map key operator
    gtest.Case(t, func() {
        result, err := db.Table("user").Where(g.Map{"id>" : 1, "id<" : 3}).One()
-        if err != nil {
-            gtest.Fatal(err)
-        }
+        gtest.Assert(err,                nil)
        gtest.Assert(result["id"].Int(), 2)
    })
+    // complicated where 1
+    gtest.Case(t, func() {
+        //db.SetDebug(true)
+        conditions := g.Map{
+           "nickname like ?"      : "%T%",
+           "id between ? and ?"   : g.Slice{1,3},
+           "id > 0"               : nil,
+           "create_time > 0"      : nil,
+           "id"                   : g.Slice{1,2,3},
+        }
+        result, err := db.Table("user").Where(conditions).OrderBy("id asc").All()
+        gtest.Assert(err,                   nil)
+        gtest.Assert(len(result),           3)
+        gtest.Assert(result[0]["id"].Int(), 1)
+    })
+    // complicated where 2
+    gtest.Case(t, func() {
+        //db.SetDebug(true)
+        conditions := g.Map{
+            "nickname like ?"      : "%T%",
+            "id between ? and ?"   : g.Slice{1,3},
+            "id >= ?"              : 1,
+            "create_time > ?"      : 0,
+            "id in(?)"             : g.Slice{1,2,3},
+        }
+        result, err := db.Table("user").Where(conditions).OrderBy("id asc").All()
+        gtest.Assert(err,                   nil)
+        gtest.Assert(len(result),           3)
+        gtest.Assert(result[0]["id"].Int(), 1)
+    })
    // struct
    gtest.Case(t, func() {
        type User struct {
--- a/g/database/gdb/gdb_unit_transaction_test.go
+++ b/g/database/gdb/gdb_unit_transaction_test.go
@ -1,4 +1,8 @@
-// 事务操作
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.

 package gdb_test

--- a/g/database/gredis/gredis.go
+++ b/g/database/gredis/gredis.go
@ -11,30 +11,36 @@
 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
+    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链接池统计信息
@ -45,88 +51,123 @@ type PoolStats struct {
 // 连接池map
 var pools = gmap.NewStringInterfaceMap()

+// 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管理对象，将会关闭底层的
+// Close closes the redis connection pool,
+// it will release all connections reserved by this pool.
+//
+// 关闭redis管理对象，将会关闭底层的连接池。
 func (r *Redis) Close() error {
+    pools.Remove(fmt.Sprintf("%v", r.config))
    return r.pool.Close()
 }

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

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

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

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

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

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

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

+// Deprecated.
+// Send writes the command to the client's output buffer.
+//
 // 执行异步命令 - Send
 func (r *Redis) Send(command string, args ...interface{}) error {
    conn := r.pool.Get()
--- a/g/database/gredis/gredis_unit_test.go
+++ b/g/database/gredis/gredis_unit_test.go
@ -0,0 +1,112 @@
+// 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)
+    })
+}
--- a/g/encoding/gjson/gjson.go
+++ b/g/encoding/gjson/gjson.go
@ -8,21 +8,21 @@
 package gjson

 import (
-    "errors"
-    "github.com/gogf/gf/g/text/gregex"
-    "strings"
-    "strconv"
-    "io/ioutil"
    "encoding/json"
-    "github.com/gogf/gf/g/os/gfile"
-    "github.com/gogf/gf/g/util/gconv"
+    "fmt"
+    "github.com/gogf/gf/g/encoding/gtoml"
    "github.com/gogf/gf/g/encoding/gxml"
    "github.com/gogf/gf/g/encoding/gyaml"
-    "github.com/gogf/gf/g/encoding/gtoml"
-    "github.com/gogf/gf/g/text/gstr"
-    "time"
    "github.com/gogf/gf/g/internal/rwmutex"
-    "fmt"
+    "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 (
@ -79,6 +79,11 @@ func NewUnsafe(value...interface{}) *Json {
    return New(nil, true)
 }

+// 识别当前给定内容是否为JSON格式
+func Valid (v interface{}) bool {
+    return json.Valid(gconv.Bytes(v))
+}
+
 // 编码go变量为json字符串，并返回json字符串指针
 func Encode (v interface{}) ([]byte, error) {
    return json.Marshal(v)
@ -110,11 +115,7 @@ func DecodeToJson (b []byte) (*Json, error) {

 // 支持多种配置文件类型转换为json格式内容并解析为gjson.Json对象
 func Load (path string) (*Json, error) {
-    data, err := ioutil.ReadFile(path)
-    if err != nil {
-        return nil, err
-    }
-    return LoadContent(data, gfile.Ext(path))
+    return LoadContent(gfcache.GetBinContents(path), gfile.Ext(path))
 }

 // 支持的配置文件格式：xml, json, yaml/yml, toml,
@ -485,16 +486,28 @@ done:
 // 数据结构转换，map参数必须转换为map[string]interface{}，数组参数必须转换为[]interface{}
 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:
+                    // 最后使用JSON编解码
+                    b, _ := Encode(value)
+                    v, _ := Decode(b)
+                    return v
+            }
    }
 }

@ -502,23 +515,23 @@ func (j *Json) convertValue(value interface{}) interface{} {
 // 返回修改后的父级指针
 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
 }
@ -538,7 +551,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
@ -546,17 +559,23 @@ func (j *Json) Get(pattern...string) interface{} {
    return nil
 }

-// 计算指定pattern的元素长度(pattern对应数据类型为map[string]interface{}/[]interface{}时有效)
+// 判断锁给定pattern是否数据存在
+func (j *Json) Contains(pattern...string) bool {
+    return j.Get(pattern...) != nil
+}
+
+// 计算指定pattern的元素长度(pattern对应数据类型为map/slice时有效)。
+// 当pattern对应的数据类型非map/slice时，返回-1。
 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
@ -564,14 +583,27 @@ func (j *Json) Len(pattern string) int {

 // 指定pattern追加元素
 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层级查找**变量指针**
+// 根据pattern获取对应元素项的指针
+func (j *Json) getPointerByPattern(pattern string) *interface{} {
+    if j.vc {
+        return j.getPointerByPatternWithViolenceCheck(pattern)
+    } else {
+        return j.getPointerByPatternWithoutViolenceCheck(pattern)
+    }
+}
+
+// 根据pattern层级查找**变量指针**, 执行冲突检测。
 // 检索方式：例如检索 a.a.a ，值为1
 // 1. 检索 a.a.a.a 是否存在对应map的键名；
 // 2. 检索 a.a.a   是否存在对应map的键名；
@ -583,7 +615,10 @@ func (j *Json) Append(pattern string, value interface{}) error {
 // 8. 在m2中检索 a.a   否存在对应map的键名；
 // 9. 在m2中检索 a     否存在对应map的键名，检索到有值，值为1；
 // 这样检索的复杂度很高，主要是为了避免键名中存在分隔符号(默认为".")的情况，避免歧义。
-func (j *Json) getPointerByPattern(pattern string) *interface{} {
+func (j *Json) getPointerByPatternWithViolenceCheck(pattern string) *interface{} {
+    if !j.vc {
+        return j.getPointerByPatternWithoutViolenceCheck(pattern)
+    }
    index   := len(pattern)
    start   := 0
    length  := 0
@ -619,7 +654,10 @@ func (j *Json) getPointerByPattern(pattern string) *interface{} {
 }

 // 层级检索，内部不执行分隔符冲突检查，检索效率会有所提高，但是冲突需要开发者自己根据自定义的分隔符来进行解决
-func (j *Json) getPointerByPatternWithoutSplitCharViolenceCheck(pattern string) *interface{} {
+func (j *Json) getPointerByPatternWithoutViolenceCheck(pattern string) *interface{} {
+    if j.vc {
+        return j.getPointerByPatternWithViolenceCheck(pattern)
+    }
    pointer := j.p
    if len(pattern) == 0 {
        return pointer
@ -639,21 +677,21 @@ func (j *Json) getPointerByPatternWithoutSplitCharViolenceCheck(pattern string)
    return nil
 }

-// 判断给定的key在当前的pointer下是否有值，并返回对应的pointer
+// 判断给定的key在当前的pointer下是否有值，并返回对应的pointer,
 // 注意这里返回的指针都是临时变量的内存地址
 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
 }
--- a/g/encoding/gjson/gjson_bench_test.go
+++ b/g/encoding/gjson/gjson_bench_test.go
@ -0,0 +1,30 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gjson_test
+
+import (
+    "github.com/gogf/gf/g/encoding/gjson"
+    "testing"
+)
+
+func Benchmark_Set1(b *testing.B) {
+    for i := 0; i < b.N; i++ {
+        p := gjson.New(map[string]string{
+            "k1" : "v1",
+            "k2" : "v2",
+        })
+        p.Set("k1.k11", []int{1,2,3})
+    }
+}
+
+func Benchmark_Set2(b *testing.B) {
+    for i := 0; i < b.N; i++ {
+        p := gjson.New([]string{"a"})
+        p.Set("0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0", []int{1,2,3})
+    }
+}
+
--- a/g/encoding/gjson/gjson_unit_test.go
+++ b/g/encoding/gjson/gjson_unit_test.go
@ -0,0 +1,280 @@
+// 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"
+    "github.com/gogf/gf/g/encoding/gjson"
+    "github.com/gogf/gf/g/test/gtest"
+    "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}}}`), "json")
+    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)
+    }
+}
+
+func Test_Len(t *testing.T) {
+    gtest.Case(t, func() {
+        p := gjson.New(nil)
+        p.Append("a", 1)
+        p.Append("a", 2)
+        gtest.Assert(p.Len("a"), 2)
+    })
+    gtest.Case(t, func() {
+        p := gjson.New(nil)
+        p.Append("a.b", 1)
+        p.Append("a.c", 2)
+        gtest.Assert(p.Len("a"), 2)
+    })
+    gtest.Case(t, func() {
+        p := gjson.New(nil)
+        p.Set("a", 1)
+        gtest.Assert(p.Len("a"), -1)
+    })
+}
+
+func Test_Append(t *testing.T) {
+    gtest.Case(t, func() {
+        p := gjson.New(nil)
+        p.Append("a", 1)
+        p.Append("a", 2)
+        gtest.Assert(p.Get("a"), g.Slice{1, 2})
+    })
+    gtest.Case(t, func() {
+        p := gjson.New(nil)
+        p.Append("a.b", 1)
+        p.Append("a.c", 2)
+        gtest.Assert(p.Get("a"), g.Map{
+            "b" : g.Slice{1},
+            "c" : g.Slice{2},
+        })
+    })
+    gtest.Case(t, func() {
+        p := gjson.New(nil)
+        p.Set("a", 1)
+        err := p.Append("a", 2)
+        gtest.AssertNE(err, nil)
+        gtest.Assert(p.Get("a"), 1)
+    })
+}
+
+
+
--- a/g/encoding/gparser/gparser_test.go
+++ b/g/encoding/gparser/gparser_test.go
@ -10,9 +10,8 @@ package gparser_test

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

 func Test_Set1(t *testing.T) {
@ -23,7 +22,7 @@ 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 +36,7 @@ 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))
        }
@ -53,7 +52,7 @@ func Test_Set3(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))
        }
@ -69,7 +68,7 @@ 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 +82,7 @@ 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 +96,7 @@ 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 +113,7 @@ 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 +130,7 @@ 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 +147,7 @@ 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 +162,7 @@ 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))
        }
@ -178,7 +177,7 @@ func Test_Set11(t *testing.T) {
    p, _ := gparser.LoadContent([]byte(`{"a":{"b":{"c":1}}}`), "json")
    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 +192,7 @@ 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 +207,7 @@ 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))
        }
--- a/g/frame/gins/gins.go
+++ b/g/frame/gins/gins.go
@ -21,8 +21,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/text/gstr"
    "github.com/gogf/gf/g/util/gconv"
    "github.com/gogf/gf/g/text/gregex"
+    "time"
 )

 const (
@ -73,7 +75,7 @@ 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.SelfDir()).String()
+        path := cmdenv.Get("gf.gview.path", gfile.Pwd()).String()
        view := gview.New(path)
        // 添加基于源码的搜索目录检索地址，常用于开发环境调试，只添加入口文件目录
        if p := gfile.MainPkgPath(); p != "" && gfile.Exists(p) {
@ -94,11 +96,22 @@ func Config(file...string) *gcfg.Config {
    }
    return instances.GetOrSetFuncLock(fmt.Sprintf("%s.%s", gFRAME_CORE_COMPONENT_NAME_CONFIG, configFile),
        func() interface{} {
-            path   := cmdenv.Get("gf.gcfg.path", gfile.SelfDir()).String()
-            config := gcfg.New(path, configFile)
-            // 添加基于源码的搜索目录检索地址，常用于开发环境调试，只添加入口文件目录
-            if p := gfile.MainPkgPath(); p != "" && gfile.Exists(p) {
-                config.AddPath(p)
+            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
    }).(*gcfg.Config)
@ -152,18 +165,34 @@ func Database(name...string) gdb.DB {
                        if value, ok := nodem["priority"]; ok {
                            node.Priority = gconv.Int(value)
                        }
+                        // Deprecated
                        if value, ok := nodem["linkinfo"]; ok {
                            node.Linkinfo = gconv.String(value)
                        }
+                        if value, ok := nodem["linkInfo"]; ok {
+                            node.Linkinfo = gconv.String(value)
+                        }
+                        // Deprecated
                        if value, ok := nodem["max-idle"]; ok {
                            node.MaxIdleConnCount = gconv.Int(value)
                        }
+                        if value, ok := nodem["maxIdle"]; ok {
+                            node.MaxIdleConnCount = gconv.Int(value)
+                        }
+                        // Deprecated
                        if value, ok := nodem["max-open"]; ok {
                            node.MaxOpenConnCount = gconv.Int(value)
                        }
+                        if value, ok := nodem["maxOpen"]; ok {
+                            node.MaxOpenConnCount = gconv.Int(value)
+                        }
+                        // Deprecated
                        if value, ok := nodem["max-lifetime"]; ok {
                            node.MaxConnLifetime = gconv.Int(value)
                        }
+                        if value, ok := nodem["maxLifetime"]; ok {
+                            node.MaxConnLifetime = gconv.Int(value)
+                        }
                        cg = append(cg, node)
                    }
                }
@ -197,11 +226,34 @@ 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])
+                    config   := gredis.Config{
+                        Host : array[1],
+                        Port : gconv.Int(array[2]),
+                        Db   : gconv.Int(array[3]),
+                        Pass : array[4],
+                    }
+                    if v, ok := parse["maxIdle"]; ok {
+                        config.MaxIdle = gconv.Int(v)
+                    }
+                    if v, ok := parse["maxActive"]; ok {
+                        config.MaxActive = gconv.Int(v)
+                    }
+                    if v, ok := parse["idleTimeout"]; ok {
+                        config.IdleTimeout = gconv.TimeDuration(v)*time.Second
+                    }
+                    if v, ok := parse["maxConnLifetime"]; ok {
+                        config.MaxConnLifetime = gconv.TimeDuration(v)*time.Second
+                    }
+                    return gredis.New(config)
+                }
+                array, _ = gregex.MatchString(`(.+):(\d+),{0,1}(\d*),{0,1}(.*)`, line)
+                if len(array) == 5 {
                    return gredis.New(gredis.Config{
                        Host : array[1],
                        Port : gconv.Int(array[2]),
--- a/g/frame/gins/gins_basic_test.go
+++ b/g/frame/gins/gins_basic_test.go
@ -0,0 +1,43 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gins_test
+
+import (
+    "github.com/gogf/gf/g/frame/gins"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+func Test_SetGet(t *testing.T) {
+    gtest.Case(t, func() {
+        gins.Set("test-user", 1)
+        gtest.Assert(gins.Get("test-user"),   1)
+        gtest.Assert(gins.Get("none-exists"), nil)
+    })
+    gtest.Case(t, func() {
+        gtest.Assert(gins.GetOrSet("test-1", 1), 1)
+        gtest.Assert(gins.Get("test-1"), 1)
+    })
+    gtest.Case(t, func() {
+        gtest.Assert(gins.GetOrSetFunc("test-2", func() interface{} {
+            return 2
+        }), 2)
+        gtest.Assert(gins.Get("test-2"), 2)
+    })
+    gtest.Case(t, func() {
+        gtest.Assert(gins.GetOrSetFuncLock("test-3", func() interface{} {
+            return 3
+        }), 3)
+        gtest.Assert(gins.Get("test-3"), 3)
+    })
+    gtest.Case(t, func() {
+        gtest.Assert(gins.SetIfNotExist("test-4", 4), true)
+        gtest.Assert(gins.Get("test-4"), 4)
+        gtest.Assert(gins.SetIfNotExist("test-4", 5), false)
+        gtest.Assert(gins.Get("test-4"), 4)
+    })
+}
--- a/g/frame/gins/gins_config_test.go
+++ b/g/frame/gins/gins_config_test.go
@ -0,0 +1,166 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gins_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g/frame/gins"
+    "github.com/gogf/gf/g/os/gfile"
+    "github.com/gogf/gf/g/os/gtime"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+func Test_Config(t *testing.T) {
+    config := `
+# 模板引擎目录
+viewpath = "/home/www/templates/"
+test = "v=1"
+# MySQL数据库配置
+[database]
+    [[database.default]]
+        host     = "127.0.0.1"
+        port     = "3306"
+        user     = "root"
+        pass     = ""
+        name     = "test"
+        type     = "mysql"
+        role     = "master"
+        charset  = "utf8"
+        priority = "1"
+    [[database.default]]
+        host     = "127.0.0.1"
+        port     = "3306"
+        user     = "root"
+        pass     = "8692651"
+        name     = "test"
+        type     = "mysql"
+        role     = "master"
+        charset  = "utf8"
+        priority = "1"
+# Redis数据库配置
+[redis]
+    disk  = "127.0.0.1:6379,0"
+    cache = "127.0.0.1:6379,1"
+`
+    gtest.Case(t, func() {
+        gtest.AssertNE(gins.Config(), nil)
+    })
+    // relative path
+    gtest.Case(t, func() {
+        path := "config.toml"
+        err  := gfile.PutContents(path, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(path)
+        defer gins.Config().Reload()
+        gtest.Assert(gins.Config().Get("test"), "v=1")
+        gtest.Assert(gins.Config().Get("database.default.1.host"), "127.0.0.1")
+        gtest.Assert(gins.Config().Get("redis.disk"), "127.0.0.1:6379,0")
+    })
+    // for gfsnotify callbacks to refresh cache of config file
+    time.Sleep(500*time.Millisecond)
+
+    // relative path, config folder
+    gtest.Case(t, func() {
+        path := "config/config.toml"
+        err  := gfile.PutContents(path, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(path)
+        defer gins.Config().Reload()
+        gtest.Assert(gins.Config().Get("test"), "v=1")
+        gtest.Assert(gins.Config().Get("database.default.1.host"), "127.0.0.1")
+        gtest.Assert(gins.Config().Get("redis.disk"), "127.0.0.1:6379,0")
+    })
+    // for gfsnotify callbacks to refresh cache of config file
+    time.Sleep(500*time.Millisecond)
+
+    gtest.Case(t, func() {
+        path := "test.toml"
+        err  := gfile.PutContents(path, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(path)
+        defer gins.Config().Reload()
+        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")
+    })
+    // for gfsnotify callbacks to refresh cache of config file
+    time.Sleep(500*time.Millisecond)
+
+    gtest.Case(t, func() {
+        path := "config/test.toml"
+        err  := gfile.PutContents(path, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(path)
+        defer gins.Config().Reload()
+        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")
+    })
+    // for gfsnotify callbacks to refresh cache of config file
+    time.Sleep(500*time.Millisecond)
+
+
+    // absolute path
+    gtest.Case(t, func() {
+        path := fmt.Sprintf(`%s/%d`, gfile.TempDir(), gtime.Nanosecond())
+        file := fmt.Sprintf(`%s/%s`, path, "config.toml")
+        err  := gfile.PutContents(file, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(file)
+        defer gins.Config().Reload()
+        gtest.Assert(gins.Config().AddPath(path), nil)
+        gtest.Assert(gins.Config().Get("test"),   "v=1")
+        gtest.Assert(gins.Config().Get("database.default.1.host"), "127.0.0.1")
+        gtest.Assert(gins.Config().Get("redis.disk"), "127.0.0.1:6379,0")
+    })
+    time.Sleep(500*time.Millisecond)
+
+    gtest.Case(t, func() {
+        path := fmt.Sprintf(`%s/%d/config`, gfile.TempDir(), gtime.Nanosecond())
+        file := fmt.Sprintf(`%s/%s`, path, "config.toml")
+        err  := gfile.PutContents(file, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(file)
+        defer gins.Config().Reload()
+        gtest.Assert(gins.Config().AddPath(path), nil)
+        gtest.Assert(gins.Config().Get("test"),   "v=1")
+        gtest.Assert(gins.Config().Get("database.default.1.host"), "127.0.0.1")
+        gtest.Assert(gins.Config().Get("redis.disk"), "127.0.0.1:6379,0")
+    })
+    time.Sleep(500*time.Millisecond)
+
+    gtest.Case(t, func() {
+        path := fmt.Sprintf(`%s/%d`, gfile.TempDir(), gtime.Nanosecond())
+        file := fmt.Sprintf(`%s/%s`, path, "test.toml")
+        err  := gfile.PutContents(file, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(file)
+        defer gins.Config("test.toml").Reload()
+
+        gtest.Assert(gins.Config("test.toml").AddPath(path), nil)
+        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")
+    })
+    time.Sleep(500*time.Millisecond)
+
+    gtest.Case(t, func() {
+        path := fmt.Sprintf(`%s/%d/config`, gfile.TempDir(), gtime.Nanosecond())
+        file := fmt.Sprintf(`%s/%s`, path, "test.toml")
+        err  := gfile.PutContents(file, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(file)
+        defer gins.Config("test.toml").Reload()
+
+        gtest.Assert(gins.Config("test.toml").AddPath(path), nil)
+        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")
+    })
+}
--- a/g/frame/gins/gins_database_test.go
+++ b/g/frame/gins/gins_database_test.go
@ -0,0 +1,75 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gins_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g/frame/gins"
+    "github.com/gogf/gf/g/os/gfile"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+func Test_Database(t *testing.T) {
+    config := `
+# 模板引擎目录
+viewpath = "/home/www/templates/"
+test = "v=2"
+# MySQL数据库配置
+[database]
+    [[database.default]]
+        host     = "127.0.0.1"
+        port     = "3306"
+        user     = "root"
+        pass     = ""
+        # pass     = "12345678"
+        name     = "test"
+        type     = "mysql"
+        role     = "master"
+        charset  = "utf8"
+        priority = "1"
+    [[database.test]]
+        host     = "127.0.0.1"
+        port     = "3306"
+        user     = "root"
+        pass     = ""
+        # pass     = "12345678"
+        name     = "test"
+        type     = "mysql"
+        role     = "master"
+        charset  = "utf8"
+        priority = "1"
+# Redis数据库配置
+[redis]
+    default = "127.0.0.1:6379,0"
+    cache = "127.0.0.1:6379,1"
+`
+    path := "config.toml"
+    err  := gfile.PutContents(path, config)
+    gtest.Assert(err, nil)
+    defer gfile.Remove(path)
+    defer gins.Config().Reload()
+
+    // for gfsnotify callbacks to refresh cache of config file
+    time.Sleep(500*time.Millisecond)
+
+    gtest.Case(t, func() {
+        fmt.Println("gins Test_Database", gins.Config().Get("test"))
+
+        dbDefault := gins.Database()
+        dbTest    := gins.Database("test")
+        gtest.AssertNE(dbDefault, nil)
+        gtest.AssertNE(dbTest,    nil)
+
+        gtest.Assert(dbDefault.PingMaster(), nil)
+        gtest.Assert(dbDefault.PingSlave(),  nil)
+        gtest.Assert(dbTest.PingMaster(),    nil)
+        gtest.Assert(dbTest.PingSlave(),     nil)
+    })
+}
+
--- a/g/frame/gins/gins_redis_test.go
+++ b/g/frame/gins/gins_redis_test.go
@ -0,0 +1,86 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gins_test
+
+import (
+    "github.com/gogf/gf/g/frame/gins"
+    "github.com/gogf/gf/g/os/gfile"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+func Test_Redis(t *testing.T) {
+    config := `
+# 模板引擎目录
+viewpath = "/home/www/templates/"
+test = "v=3"
+# MySQL数据库配置
+[database]
+    [[database.default]]
+        host     = "127.0.0.1"
+        port     = "3306"
+        user     = "root"
+        pass     = ""
+        # pass     = "12345678"
+        name     = "test"
+        type     = "mysql"
+        role     = "master"
+        charset  = "utf8"
+        priority = "1"
+    [[database.test]]
+        host     = "127.0.0.1"
+        port     = "3306"
+        user     = "root"
+        pass     = ""
+        # pass     = "12345678"
+        name     = "test"
+        type     = "mysql"
+        role     = "master"
+        charset  = "utf8"
+        priority = "1"
+# Redis数据库配置
+[redis]
+    default = "127.0.0.1:6379,7"
+    cache   = "127.0.0.1:6379,8"
+    disk    = "127.0.0.1:6379,9,?maxIdle=1&maxActive=10&idleTimeout=10&maxConnLifetime=10"
+`
+    path := "config.toml"
+    err  := gfile.PutContents(path, config)
+    gtest.Assert(err, nil)
+    defer gfile.Remove(path)
+    defer gins.Config().Reload()
+
+    // for gfsnotify callbacks to refresh cache of config file
+    time.Sleep(500*time.Millisecond)
+
+    gtest.Case(t, func() {
+        //fmt.Println("gins Test_Redis", gins.Config().Get("test"))
+
+        redisDefault := gins.Redis()
+        redisCache   := gins.Redis("cache")
+        redisDisk    := gins.Redis("disk")
+        gtest.AssertNE(redisDefault, nil)
+        gtest.AssertNE(redisCache,   nil)
+        gtest.AssertNE(redisDisk,   nil)
+
+        r, err := redisDefault.Do("PING")
+        gtest.Assert(err, nil)
+        gtest.Assert(r,   "PONG")
+
+        r, err  = redisCache.Do("PING")
+        gtest.Assert(err, nil)
+        gtest.Assert(r,   "PONG")
+
+        _, err  = redisDisk.Do("SET", "k", "v")
+        gtest.Assert(err, nil)
+        r, err  = redisDisk.Do("GET", "k")
+        gtest.Assert(err, nil)
+        gtest.Assert(r, []byte("v"))
+    })
+}
+
--- a/g/frame/gins/gins_view_test.go
+++ b/g/frame/gins/gins_view_test.go
@ -0,0 +1,49 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gins_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g/frame/gins"
+    "github.com/gogf/gf/g/os/gfile"
+    "github.com/gogf/gf/g/os/gtime"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+func Test_View(t *testing.T) {
+    gtest.Case(t, func() {
+        gtest.AssertNE(gins.View(), nil)
+        b, e := gins.View().ParseContent(`{{"我是中国人" | substr 2 -1}}`, nil)
+        gtest.Assert(e,         nil)
+        gtest.Assert(string(b), "中国人")
+    })
+    gtest.Case(t, func() {
+        tpl := "t.tpl"
+        err := gfile.PutContents(tpl, `{{"我是中国人" | substr 2 -1}}`)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(tpl)
+
+        b, e := gins.View().Parse("t.tpl", nil)
+        gtest.Assert(e,         nil)
+        gtest.Assert(string(b), "中国人")
+    })
+    gtest.Case(t, func() {
+        path := fmt.Sprintf(`%s/%d`, gfile.TempDir(), gtime.Nanosecond())
+        tpl  := fmt.Sprintf(`%s/%s`, path, "t.tpl")
+        err  := gfile.PutContents(tpl, `{{"我是中国人" | substr 2 -1}}`)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(tpl)
+        err = gins.View().AddPath(path)
+        gtest.Assert(err, nil)
+
+        b, e := gins.View().Parse("t.tpl", nil)
+        gtest.Assert(e,         nil)
+        gtest.Assert(string(b), "中国人")
+    })
+}
+
--- a/g/g.go
+++ b/g/g.go
@ -16,7 +16,8 @@ type Var        = gvar.Var
 // Frequently-used map type alias.
 //
 // 常用map数据结构(使用别名)
-type Map        = map[interface{}]interface{}
+type Map        = map[string]interface{}
+type MapAnyAny  = map[interface{}]interface{}
 type MapAnyStr  = map[interface{}]string
 type MapAnyInt  = map[interface{}]int
 type MapStrAny  = map[string]interface{}
--- a/g/g_func.go
+++ b/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)
 }
--- a/g/internal/cmdenv/cmdenv.go
+++ b/g/internal/cmdenv/cmdenv.go
@ -17,7 +17,7 @@ import (
 // 规则:
 // 1、命令行参数以小写字母格式，使用: gf.包名.变量名 传递；
 // 2、环境变量参数以大写字母格式，使用: GF_包名_变量名 传递；
-func Get(key string, def...interface{}) *gvar.Var {
+func Get(key string, def...interface{}) gvar.VarRead {
    value := interface{}(nil)
    if len(def) > 0 {
        value = def[0]
--- a/g/net/ghttp/ghttp.go
+++ b/g/net/ghttp/ghttp.go
@ -4,5 +4,7 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.

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

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

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

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

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

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

-// 获取Web Socket连接对象(如果是非WS请求会失败，注意检查然会的error结果)
+// 获取Web Socket连接对象(如果是非WS请求会失败，注意检查返回的error结果)
 func (r *Request) WebSocket() (*WebSocket, error) {
    if conn, err := wsUpgrader.Upgrade(r.Response.ResponseWriter.ResponseWriter, r.Request, nil); err == nil {
        return &WebSocket {
@ -101,6 +101,8 @@ func (r *Request) GetJson() *gjson.Json {
    if data != nil {
        if j, err := gjson.DecodeToJson(data); err == nil {
            return j
+        } else {
+            panic(err)
        }
    }
    return nil
@ -221,14 +223,14 @@ func (r *Request) GetReferer() string {

 // 获得结构体对象的参数名称标签，构成map返回
 func (r *Request) getStructParamsTagMap(object interface{}) map[string]string {
-    tagmap := make(map[string]string)
+    tagMap := make(map[string]string)
    fields := structs.Fields(object)
    for _, field := range fields {
        if tag := field.Tag("params"); tag != "" {
            for _, v := range strings.Split(tag, ",") {
-                tagmap[strings.TrimSpace(v)] = field.Name()
+                tagMap[strings.TrimSpace(v)] = field.Name()
            }
        }
    }
-    return tagmap
+    return tagMap
 }
--- a/g/net/ghttp/ghttp_response.go
+++ b/g/net/ghttp/ghttp_response.go
@ -45,13 +45,10 @@ func (r *Response) Write(content ... interface{}) {
        return
    }
    for _, v := range content {
-        switch v.(type) {
-            case []byte:
-                // 如果是二进制数据，那么返回二进制数据
-                r.buffer.Write(gconv.Bytes(v))
-
+        switch value := v.(type) {
+            case []byte: r.buffer.Write(value)
+            case string: r.buffer.WriteString(value)
            default:
-                // 否则一律按照可显示的字符串进行转换
                r.buffer.WriteString(gconv.String(v))
        }
    }
--- a/g/net/ghttp/ghttp_response_view.go
+++ b/g/net/ghttp/ghttp_response_view.go
@ -13,10 +13,10 @@ import (
 )

 // 展示模板，可以给定模板参数，及临时的自定义模板函数
-func (r *Response) WriteTpl(tpl string, params map[string]interface{}, funcmap...map[string]interface{}) error {
+func (r *Response) WriteTpl(tpl string, params map[string]interface{}, funcMap...map[string]interface{}) error {
    fmap := make(gview.FuncMap)
-    if len(funcmap) > 0 {
-        fmap = funcmap[0]
+    if len(funcMap) > 0 {
+        fmap = funcMap[0]
    }
    if b, err := r.ParseTpl(tpl, params, fmap); err != nil {
        r.Write("Tpl Parsing Error: " + err.Error())
@ -28,10 +28,10 @@ func (r *Response) WriteTpl(tpl string, params map[string]interface{}, funcmap..
 }

 // 展示模板内容，可以给定模板参数，及临时的自定义模板函数
-func (r *Response) WriteTplContent(content string, params map[string]interface{}, funcmap...map[string]interface{}) error {
+func (r *Response) WriteTplContent(content string, params map[string]interface{}, funcMap...map[string]interface{}) error {
    fmap := make(gview.FuncMap)
-    if len(funcmap) > 0 {
-        fmap = funcmap[0]
+    if len(funcMap) > 0 {
+        fmap = funcMap[0]
    }
    if b, err := r.ParseTplContent(content, params, fmap); err != nil {
        r.Write("Tpl Parsing Error: " + err.Error())
@ -43,19 +43,19 @@ func (r *Response) WriteTplContent(content string, params map[string]interface{}
 }

 // 解析模板文件，并返回模板内容
-func (r *Response) ParseTpl(tpl string, params gview.Params, funcmap...map[string]interface{}) ([]byte, error) {
+func (r *Response) ParseTpl(tpl string, params gview.Params, funcMap...map[string]interface{}) ([]byte, error) {
    fmap := make(gview.FuncMap)
-    if len(funcmap) > 0 {
-        fmap = funcmap[0]
+    if len(funcMap) > 0 {
+        fmap = funcMap[0]
    }
    return gins.View().Parse(tpl, r.buildInVars(params), r.buildInFuncs(fmap))
 }

 // 解析并返回模板内容
-func (r *Response) ParseTplContent(content string, params gview.Params, funcmap...map[string]interface{}) ([]byte, error) {
+func (r *Response) ParseTplContent(content string, params gview.Params, funcMap...map[string]interface{}) ([]byte, error) {
    fmap := make(gview.FuncMap)
-    if len(funcmap) > 0 {
-        fmap = funcmap[0]
+    if len(funcMap) > 0 {
+        fmap = funcMap[0]
    }
    return gins.View().ParseContent(content, r.buildInVars(params), r.buildInFuncs(fmap))
 }
@ -77,14 +77,14 @@ func (r *Response) buildInVars(params map[string]interface{}) map[string]interfa
 }

 // 内置函数
-func (r *Response) buildInFuncs(funcmap map[string]interface{}) map[string]interface{} {
-    if funcmap == nil {
-        funcmap = make(map[string]interface{})
+func (r *Response) buildInFuncs(funcMap map[string]interface{}) map[string]interface{} {
+    if funcMap == nil {
+        funcMap = make(map[string]interface{})
    }
-    funcmap["get"]       = r.funcGet
-    funcmap["post"]      = r.funcPost
-    funcmap["request"]   = r.funcRequest
-    return funcmap
+    funcMap["get"]       = r.funcGet
+    funcMap["post"]      = r.funcPost
+    funcMap["request"]   = r.funcRequest
+    return funcMap
 }

 // 模板内置函数: get
--- a/g/net/ghttp/ghttp_server.go
+++ b/g/net/ghttp/ghttp_server.go
@ -242,7 +242,7 @@ func (s *Server) Start() error {
        s.config.Handler = http.HandlerFunc(s.defaultHttpHandle)
    }
    // 不允许访问的路由注册(使用HOOK实现)
-    // @TODO 去掉HOOK的实现方式
+    // TODO 去掉HOOK的实现方式
    if s.config.DenyRoutes != nil {
        for _, v := range s.config.DenyRoutes {
            s.BindHookHandler(v, HOOK_BEFORE_SERVE, func(r *Request) {
@ -398,7 +398,8 @@ func Wait() {
 // 开启底层Web Server执行
 func (s *Server) startServer(fdMap listenerFdMap) {
    var httpsEnabled bool
-    if len(s.config.HTTPSCertPath) > 0 && len(s.config.HTTPSKeyPath) > 0 {
+    // 判断是否启用HTTPS
+    if len(s.config.TLSConfig.Certificates) > 0 || (len(s.config.HTTPSCertPath) > 0 && len(s.config.HTTPSKeyPath) > 0) {
        // ================
        // HTTPS
        // ================
@ -479,7 +480,7 @@ func (s *Server) startServer(fdMap listenerFdMap) {
            s.serverCount.Add(1)
            err := (error)(nil)
            if server.isHttps {
-                err = server.ListenAndServeTLS(s.config.HTTPSCertPath, s.config.HTTPSKeyPath)
+                err = server.ListenAndServeTLS(s.config.HTTPSCertPath, s.config.HTTPSKeyPath, &s.config.TLSConfig)
            } else {
                err = server.ListenAndServe()
            }
--- a/g/net/ghttp/ghttp_server_config.go
+++ b/g/net/ghttp/ghttp_server_config.go
@ -7,6 +7,7 @@
 package ghttp

 import (
+    "crypto/tls"
    "fmt"
    "github.com/gogf/gf/g/os/gfile"
    "github.com/gogf/gf/g/os/glog"
@ -24,7 +25,7 @@ const (
    NAME_TO_URI_TYPE_CAMEL             = 3                // 采用驼峰命名方式
    gDEFAULT_COOKIE_PATH               = "/"              // 默认path
    gDEFAULT_COOKIE_MAX_AGE            = 86400*365        // 默认cookie有效期(一年)
-    gDEFAULT_SESSION_MAX_AGE           = 600              // 默认session有效期(600秒)
+    gDEFAULT_SESSION_MAX_AGE           = 600000           // 默认session有效期(600秒)
    gDEFAULT_SESSION_ID_NAME           = "gfsessionid"    // 默认存放Cookie中的SessionId名称
    gCHANGE_CONFIG_WHILE_RUNNING_ERROR = "cannot be changed while running"
 )
@ -44,6 +45,7 @@ type ServerConfig struct {
    WriteTimeout      time.Duration         // 写入超时
    IdleTimeout       time.Duration         // 等待超时
    MaxHeaderBytes    int                   // 最大的header长度
+    TLSConfig         tls.Config

    // 静态文件配置
    IndexFiles        []string              // 默认访问的文件列表
@ -191,28 +193,46 @@ func (s *Server)SetHTTPSPort(port...int) {
    }
 }

-// 开启HTTPS支持，但是必须提供Cert和Key文件
-func (s *Server)EnableHTTPS(certFile, keyFile string) {
+// 开启HTTPS支持，但是必须提供Cert和Key文件，tlsConfig为可选项
+func (s *Server)EnableHTTPS(certFile, keyFile string, tlsConfig...tls.Config) {
    if s.Status() == SERVER_STATUS_RUNNING {
        glog.Error(gCHANGE_CONFIG_WHILE_RUNNING_ERROR)
        return
    }
    certFileRealPath := gfile.RealPath(certFile)
    if certFileRealPath == "" {
-        certFileRealPath = gfile.RealPath(gfile.MainPkgPath() + gfile.Separator + certFileRealPath)
+        certFileRealPath = gfile.RealPath(gfile.Pwd() + gfile.Separator + certFile)
+        if certFileRealPath == "" {
+            certFileRealPath = gfile.RealPath(gfile.MainPkgPath() + gfile.Separator + certFile)
+        }
    }
    if certFileRealPath == "" {
        glog.Fatal(fmt.Sprintf(`[ghttp] EnableHTTPS failed: certFile "%s" does not exist`, certFile))
    }
    keyFileRealPath := gfile.RealPath(keyFile)
    if keyFileRealPath == "" {
-        keyFileRealPath = gfile.RealPath(gfile.MainPkgPath() + gfile.Separator + keyFileRealPath)
+        keyFileRealPath = gfile.RealPath(gfile.Pwd() + gfile.Separator + keyFile)
+        if keyFileRealPath == "" {
+            keyFileRealPath = gfile.RealPath(gfile.MainPkgPath() + gfile.Separator + keyFile)
+        }
    }
    if keyFileRealPath == "" {
        glog.Fatal(fmt.Sprintf(`[ghttp] EnableHTTPS failed: keyFile "%s" does not exist`, keyFile))
    }
    s.config.HTTPSCertPath = certFileRealPath
    s.config.HTTPSKeyPath  = keyFileRealPath
+    if len(tlsConfig) > 0 {
+        s.config.TLSConfig = tlsConfig[0]
+    }
+}
+
+// 设置TLS配置对象
+func (s *Server)SetTLSConfig(tlsConfig tls.Config)  {
+    if s.Status() == SERVER_STATUS_RUNNING {
+        glog.Error(gCHANGE_CONFIG_WHILE_RUNNING_ERROR)
+        return
+    }
+    s.config.TLSConfig = tlsConfig
 }

 // 设置http server参数 - ReadTimeout
--- a/g/net/ghttp/ghttp_server_config_static.go
+++ b/g/net/ghttp/ghttp_server_config_static.go
@ -64,6 +64,7 @@ func (s *Server)SetServerRoot(root string) {
    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)}
    s.config.FileServerEnabled = true
 }
--- a/g/net/ghttp/ghttp_server_cookie.go
+++ b/g/net/ghttp/ghttp_server_cookie.go
@ -5,7 +5,7 @@
 // You can obtain one at https://github.com/gogf/gf.
 //
 // HTTP Cookie管理对象，
-// 由于Cookie是和HTTP请求挂钩的，因此被包含到 ghttp 包中进行管理
+// 由于Cookie是和HTTP请求挂钩的，因此被包含到 ghttp 包中进行管理。

 package ghttp

@ -87,6 +87,14 @@ func (c *Cookie) SessionId() string {
    return id
 }

+// 获取SessionId，不存在时则创建
+func (c *Cookie) MakeSessionId() string {
+    c.init()
+    id := makeSessionId()
+    c.SetSessionId(id)
+    return id
+}
+
 // 判断Cookie中是否存在制定键名(并且没有过期)
 func (c *Cookie) Contains(key string) bool {
    c.init()
--- a/g/net/ghttp/ghttp_server_graceful.go
+++ b/g/net/ghttp/ghttp_server_graceful.go
@ -84,18 +84,22 @@ func (s *gracefulServer) setFd(fd int) {
 }

 // 执行HTTPS监听
-func (s *gracefulServer) ListenAndServeTLS(certFile, keyFile string) error {
+func (s *gracefulServer) ListenAndServeTLS(certFile, keyFile string, tlsConfig...*tls.Config) error {
    addr   := s.httpServer.Addr
-    config := &tls.Config{}
-    if s.httpServer.TLSConfig != nil {
+    config := (*tls.Config)(nil)
+    if len(tlsConfig) > 0 {
+        config = tlsConfig[0]
+    } else if s.httpServer.TLSConfig != nil {
        *config = *s.httpServer.TLSConfig
    }
    if config.NextProtos == nil {
        config.NextProtos = []string{"http/1.1"}
    }
    err := error(nil)
-    config.Certificates         = make([]tls.Certificate, 1)
-    config.Certificates[0], err = tls.LoadX509KeyPair(certFile, keyFile)
+    if len(config.Certificates) == 0 {
+        config.Certificates         = make([]tls.Certificate, 1)
+        config.Certificates[0], err = tls.LoadX509KeyPair(certFile, keyFile)
+    }
    if err != nil {
        return errors.New(fmt.Sprintf(`open cert file "%s","%s" failed: %s`, certFile, keyFile, err.Error()))
    }
--- a/g/net/ghttp/ghttp_server_router.go
+++ b/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,7 +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, "URI should lead with '/'")
        return
    }
    // 注册地址记录及重复注册判断
@ -80,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
        }
    }
--- a/g/net/ghttp/ghttp_server_session.go
+++ b/g/net/ghttp/ghttp_server_session.go
@ -26,9 +26,9 @@ type Session struct {
    request *Request                 // 关联的请求
 }

-// 生成一个唯一的SessionId字符串，长度16位
+// 生成一个唯一的SessionId字符串，长度18位。
 func makeSessionId() string {
-    return strings.ToUpper(strconv.FormatInt(gtime.Nanosecond(), 32) + grand.RandStr(3))
+    return strings.ToUpper(strconv.FormatInt(gtime.Nanosecond(), 36) + grand.RandStr(6))
 }

 // 获取或者生成一个session对象(延迟初始化)
@ -41,14 +41,24 @@ func GetSession(r *Request) *Session {
    }
 }

-// 执行初始化(用于延迟初始化)
+// 执行初始化(用于延迟初始化).
 func (s *Session) init() {
    if len(s.id) == 0 {
-        s.id     = s.request.Cookie.SessionId()
        s.server = s.request.Server
-        s.data   = s.server.sessions.GetOrSetFuncLock(s.id, func() interface{} {
-            return gmap.NewStringInterfaceMap()
-        }, s.server.GetSessionMaxAge()).(*gmap.StringInterfaceMap)
+        // 根据提交的SESSION ID获取已存在SESSION
+        id := s.request.Cookie.GetSessionId()
+        if id != "" {
+            data := s.server.sessions.Get(id)
+            if data != nil {
+                s.id   = id
+                s.data = data.(*gmap.StringInterfaceMap)
+                return
+            }
+        }
+        // 否则执行初始化创建
+        s.id   = s.request.Cookie.MakeSessionId()
+        s.data = gmap.NewStringInterfaceMap()
+        s.server.sessions.Set(s.id, s.data, s.server.GetSessionMaxAge())
    }
 }

@ -94,8 +104,8 @@ func (s *Session) Contains (key string) bool {
    return false
 }

-// 获取SESSION
-func (s *Session) Get (key string) interface{}  {
+// 获取SESSION变量
+func (s *Session) Get(key string) interface{}  {
    if len(s.id) > 0 || s.request.Cookie.GetSessionId() != "" {
        s.init()
        return s.data.Get(key)
@ -131,112 +141,95 @@ func (s *Session) UpdateExpire() {
    }
 }

-// Deprecated, use GetVar instead.
 func (s *Session) GetString(key string) string {
    return gconv.String(s.Get(key))
 }

-// Deprecated, use GetVar instead.
 func (s *Session) GetBool(key string) bool {
    return gconv.Bool(s.Get(key))
 }

-// Deprecated, use GetVar instead.
 func (s *Session) GetInt(key string) int {
    return gconv.Int(s.Get(key)) }

-// Deprecated, use GetVar instead.
+
 func (s *Session) GetInt8(key string) int8 {
    return gconv.Int8(s.Get(key))
 }

-// Deprecated, use GetVar instead.
 func (s *Session) GetInt16(key string) int16 {
    return gconv.Int16(s.Get(key))
 }

-// Deprecated, use GetVar instead.
 func (s *Session) GetInt32(key string) int32 {
    return gconv.Int32(s.Get(key))
 }

-// Deprecated, use GetVar instead.
 func (s *Session) GetInt64(key string) int64 {
    return gconv.Int64(s.Get(key))
 }

-// Deprecated, use GetVar instead.
 func (s *Session) GetUint(key string) uint {
    return gconv.Uint(s.Get(key))
 }

-// Deprecated, use GetVar instead.
 func (s *Session) GetUint8(key string) uint8 {
    return gconv.Uint8(s.Get(key))
 }

-// Deprecated, use GetVar instead.
 func (s *Session) GetUint16(key string) uint16 {
    return gconv.Uint16(s.Get(key))
 }

-// Deprecated, use GetVar instead.
 func (s *Session) GetUint32(key string) uint32 {
    return gconv.Uint32(s.Get(key))
 }

-// Deprecated, use GetVar instead.
 func (s *Session) GetUint64(key string) uint64 {
    return gconv.Uint64(s.Get(key))
 }

-// Deprecated, use GetVar instead.
 func (s *Session) GetFloat32(key string) float32 {
    return gconv.Float32(s.Get(key))
 }

-// Deprecated, use GetVar instead.
 func (s *Session) GetFloat64(key string) float64 {
    return gconv.Float64(s.Get(key))
 }

-// Deprecated, use GetVar instead.
 func (s *Session) GetBytes(key string) []byte {
    return gconv.Bytes(s.Get(key))
 }

-// Deprecated, use GetVar instead.
 func (s *Session) GetInts(key string) []int {
    return gconv.Ints(s.Get(key))
 }

-// Deprecated, use GetVar instead.
 func (s *Session) GetFloats(key string) []float64 {
    return gconv.Floats(s.Get(key))
 }

-// Deprecated, use GetVar instead.
 func (s *Session) GetStrings(key string) []string {
    return gconv.Strings(s.Get(key))
 }

-// Deprecated, use GetVar instead.
 func (s *Session) GetInterfaces(key string) []interface{} {
    return gconv.Interfaces(s.Get(key))
 }

-// Deprecated, use GetVar instead.
 func (s *Session) GetTime(key string, format...string) time.Time {
    return gconv.Time(s.Get(key), format...)
 }

-// Deprecated, use GetVar instead.
+func (s *Session) GetGTime(key string, format...string) *gtime.Time {
+    return gconv.GTime(s.Get(key), format...)
+}
+
 func (s *Session) GetTimeDuration(key string) time.Duration {
    return gconv.TimeDuration(s.Get(key))
 }

-// Deprecated, use GetVar instead.
-// (已废弃, 请使用GetVar) 将变量转换为对象，注意 objPointer 参数必须为struct指针
+// 将变量转换为对象，注意 objPointer 参数必须为struct指针
 func (s *Session) GetStruct(key string, objPointer interface{}, attrMapping...map[string]string) error {
    return gconv.Struct(s.Get(key), objPointer, attrMapping...)
 }
--- a/g/net/ghttp/ghttp_unit_init_test.go
+++ b/g/net/ghttp/ghttp_unit_init_test.go
@ -17,7 +17,7 @@ var (
 )

 func init() {
-    for i := 8000; i <= 8100; i++ {
+    for i := 8000; i <= 9000; i++ {
        ports.Append(i)
    }
 }
--- a/g/net/ghttp/ghttp_unit_router_exit_test.go
+++ b/g/net/ghttp/ghttp_unit_router_exit_test.go
@ -0,0 +1,126 @@
+// 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 ghttp_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/net/ghttp"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+func Test_Router_Exit(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.BindHookHandlerByMap("/*", map[string]ghttp.HandlerFunc{
+        "BeforeServe"  : func(r *ghttp.Request){ r.Response.Write("1") },
+        "AfterServe"   : func(r *ghttp.Request){ r.Response.Write("2") },
+        "BeforeOutput" : func(r *ghttp.Request){ r.Response.Write("3") },
+        "AfterOutput"  : func(r *ghttp.Request){ r.Response.Write("4") },
+        "BeforeClose"  : func(r *ghttp.Request){ r.Response.Write("5") },
+        "AfterClose"   : func(r *ghttp.Request){ r.Response.Write("6") },
+    })
+    s.BindHandler("/test/test", func(r *ghttp.Request) {
+        r.Response.Write("test-start")
+        r.Exit()
+        r.Response.Write("test-end")
+    })
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),          "123")
+        gtest.Assert(client.GetContent("/test/test"), "1test-start23")
+    })
+}
+
+func Test_Router_ExitHook(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.BindHandler("/priority/show", func(r *ghttp.Request) {
+        r.Response.Write("show")
+    })
+
+    s.BindHookHandlerByMap("/priority/:name", map[string]ghttp.HandlerFunc {
+        "BeforeServe"  : func(r *ghttp.Request) {
+            r.Response.Write("1")
+        },
+    })
+    s.BindHookHandlerByMap("/priority/*any", map[string]ghttp.HandlerFunc {
+        "BeforeServe"  : func(r *ghttp.Request) {
+            r.Response.Write("2")
+        },
+    })
+    s.BindHookHandlerByMap("/priority/show", map[string]ghttp.HandlerFunc {
+        "BeforeServe"  : func(r *ghttp.Request) {
+            r.Response.Write("3")
+            r.ExitHook()
+        },
+    })
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                 "Not Found")
+        gtest.Assert(client.GetContent("/priority/show"),    "3show")
+    })
+}
+
+func Test_Router_ExitAll(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.BindHandler("/priority/show", func(r *ghttp.Request) {
+        r.Response.Write("show")
+    })
+
+    s.BindHookHandlerByMap("/priority/:name", map[string]ghttp.HandlerFunc {
+        "BeforeServe"  : func(r *ghttp.Request) {
+            r.Response.Write("1")
+        },
+    })
+    s.BindHookHandlerByMap("/priority/*any", map[string]ghttp.HandlerFunc {
+        "BeforeServe"  : func(r *ghttp.Request) {
+            r.Response.Write("2")
+        },
+    })
+    s.BindHookHandlerByMap("/priority/show", map[string]ghttp.HandlerFunc {
+        "BeforeServe"  : func(r *ghttp.Request) {
+            r.Response.Write("3")
+            r.ExitAll()
+        },
+    })
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                 "Not Found")
+        gtest.Assert(client.GetContent("/priority/show"),    "3")
+    })
+}
--- a/g/net/ghttp/ghttp_unit_router_hook_test.go
+++ b/g/net/ghttp/ghttp_unit_router_hook_test.go
@ -0,0 +1,87 @@
+// 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 ghttp_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/net/ghttp"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+func Test_Router_Hook_Basic(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.BindHookHandlerByMap("/*", map[string]ghttp.HandlerFunc{
+        "BeforeServe"  : func(r *ghttp.Request){ r.Response.Write("1") },
+        "AfterServe"   : func(r *ghttp.Request){ r.Response.Write("2") },
+        "BeforeOutput" : func(r *ghttp.Request){ r.Response.Write("3") },
+        "AfterOutput"  : func(r *ghttp.Request){ r.Response.Write("4") },
+        "BeforeClose"  : func(r *ghttp.Request){ r.Response.Write("5") },
+        "AfterClose"   : func(r *ghttp.Request){ r.Response.Write("6") },
+    })
+    s.BindHandler("/test/test", func(r *ghttp.Request) {
+        r.Response.Write("test")
+    })
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),          "123")
+        gtest.Assert(client.GetContent("/test/test"), "1test23")
+    })
+}
+
+func Test_Router_Hook_Priority(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.BindHandler("/priority/show", func(r *ghttp.Request) {
+        r.Response.Write("show")
+    })
+
+    s.BindHookHandlerByMap("/priority/:name", map[string]ghttp.HandlerFunc {
+        "BeforeServe"  : func(r *ghttp.Request) {
+            r.Response.Write("1")
+        },
+    })
+    s.BindHookHandlerByMap("/priority/*any", map[string]ghttp.HandlerFunc {
+        "BeforeServe"  : func(r *ghttp.Request) {
+            r.Response.Write("2")
+        },
+    })
+    s.BindHookHandlerByMap("/priority/show", map[string]ghttp.HandlerFunc {
+        "BeforeServe"  : func(r *ghttp.Request) {
+            r.Response.Write("3")
+        },
+    })
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                 "Not Found")
+        gtest.Assert(client.GetContent("/priority/show"),    "312show")
+        gtest.Assert(client.GetContent("/priority/any/any"), "2")
+        gtest.Assert(client.GetContent("/priority/name"),    "12")
+    })
+}
+
--- a/g/net/ghttp/ghttp_unit_router_names_test.go
+++ b/g/net/ghttp/ghttp_unit_router_names_test.go
@ -6,3 +6,107 @@

 package ghttp_test

+import (
+    "fmt"
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/net/ghttp"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+type NamesObject struct {}
+
+func (o *NamesObject) ShowName(r *ghttp.Request) {
+    r.Response.Write("Object Show Name")
+}
+
+func Test_NameToUri_FullName(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.SetNameToUriType(ghttp.NAME_TO_URI_TYPE_FULLNAME)
+    s.BindObject("/{.struct}/{.method}", new(NamesObject))
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetBrowserMode(true)
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+        gtest.Assert(client.GetContent("/"),                     "Not Found")
+        gtest.Assert(client.GetContent("/NamesObject"),          "Not Found")
+        gtest.Assert(client.GetContent("/NamesObject/ShowName"), "Object Show Name")
+    })
+}
+
+
+func Test_NameToUri_AllLower(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.SetNameToUriType(ghttp.NAME_TO_URI_TYPE_ALLLOWER)
+    s.BindObject("/{.struct}/{.method}", new(NamesObject))
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetBrowserMode(true)
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+        gtest.Assert(client.GetContent("/"),                     "Not Found")
+        gtest.Assert(client.GetContent("/NamesObject"),          "Not Found")
+        gtest.Assert(client.GetContent("/namesobject/showname"), "Object Show Name")
+    })
+}
+
+func Test_NameToUri_Camel(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.SetNameToUriType(ghttp.NAME_TO_URI_TYPE_CAMEL)
+    s.BindObject("/{.struct}/{.method}", new(NamesObject))
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetBrowserMode(true)
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+        gtest.Assert(client.GetContent("/"),                     "Not Found")
+        gtest.Assert(client.GetContent("/NamesObject"),          "Not Found")
+        gtest.Assert(client.GetContent("/namesObject/showName"), "Object Show Name")
+    })
+}
+
+func Test_NameToUri_Default(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.SetNameToUriType(ghttp.NAME_TO_URI_TYPE_DEFAULT)
+    s.BindObject("/{.struct}/{.method}", new(NamesObject))
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetBrowserMode(true)
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+        gtest.Assert(client.GetContent("/"),                       "Not Found")
+        gtest.Assert(client.GetContent("/NamesObject"),            "Not Found")
+        gtest.Assert(client.GetContent("/names-object/show-name"), "Object Show Name")
+    })
+}
+
--- a/g/net/ghttp/ghttp_unit_static_test.go
+++ b/g/net/ghttp/ghttp_unit_static_test.go
@ -0,0 +1,272 @@
+// 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 ghttp_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/net/ghttp"
+    "github.com/gogf/gf/g/os/gfile"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+func Test_Static_ServerRoot(t *testing.T) {
+    // SetServerRoot with absolute path
+    gtest.Case(t, func() {
+        p := ports.PopRand()
+        s := g.Server(p)
+        path := fmt.Sprintf(`%s/ghttp/static/test/%d`, gfile.TempDir(), p)
+        defer gfile.Remove(path)
+        gfile.PutContents(path + "/index.htm", "index")
+        s.SetServerRoot(path)
+        s.SetPort(p)
+        s.Start()
+        defer s.Shutdown()
+        time.Sleep(time.Second)
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),            "index")
+        gtest.Assert(client.GetContent("/index.htm"),   "index")
+    })
+
+    // SetServerRoot with relative path
+    gtest.Case(t, func() {
+        p := ports.PopRand()
+        s := g.Server(p)
+        path := fmt.Sprintf(`static/test/%d`, p)
+        defer gfile.Remove(path)
+        gfile.PutContents(path + "/index.htm", "index")
+        s.SetServerRoot(path)
+        s.SetPort(p)
+        s.Start()
+        defer s.Shutdown()
+        time.Sleep(time.Second)
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),            "index")
+        gtest.Assert(client.GetContent("/index.htm"),   "index")
+    })
+}
+
+func Test_Static_Folder_Forbidden(t *testing.T) {
+    gtest.Case(t, func() {
+        p := ports.PopRand()
+        s := g.Server(p)
+        path := fmt.Sprintf(`%s/ghttp/static/test/%d`, gfile.TempDir(), p)
+        defer gfile.Remove(path)
+        gfile.PutContents(path + "/test.html", "test")
+        s.SetServerRoot(path)
+        s.SetPort(p)
+        s.Start()
+        defer s.Shutdown()
+        time.Sleep(time.Second)
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),             "Forbidden")
+        gtest.Assert(client.GetContent("/index.html"),   "Not Found")
+        gtest.Assert(client.GetContent("/test.html"),    "test")
+    })
+}
+
+func Test_Static_IndexFolder(t *testing.T) {
+    gtest.Case(t, func() {
+        p := ports.PopRand()
+        s := g.Server(p)
+        path := fmt.Sprintf(`%s/ghttp/static/test/%d`, gfile.TempDir(), p)
+        defer gfile.Remove(path)
+        gfile.PutContents(path + "/test.html", "test")
+        s.SetIndexFolder(true)
+        s.SetServerRoot(path)
+        s.SetPort(p)
+        s.Start()
+        defer s.Shutdown()
+        time.Sleep(time.Second)
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.AssertNE(client.GetContent("/"),           "Forbidden")
+        gtest.Assert(client.GetContent("/index.html"),   "Not Found")
+        gtest.Assert(client.GetContent("/test.html"),    "test")
+    })
+}
+
+func Test_Static_IndexFiles1(t *testing.T) {
+    gtest.Case(t, func() {
+        p := ports.PopRand()
+        s := g.Server(p)
+        path := fmt.Sprintf(`%s/ghttp/static/test/%d`, gfile.TempDir(), p)
+        defer gfile.Remove(path)
+        gfile.PutContents(path + "/index.html", "index")
+        gfile.PutContents(path + "/test.html", "test")
+        s.SetServerRoot(path)
+        s.SetPort(p)
+        s.Start()
+        defer s.Shutdown()
+        time.Sleep(time.Second)
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),             "index")
+        gtest.Assert(client.GetContent("/index.html"),   "index")
+        gtest.Assert(client.GetContent("/test.html"),    "test")
+    })
+}
+
+func Test_Static_IndexFiles2(t *testing.T) {
+    gtest.Case(t, func() {
+        p := ports.PopRand()
+        s := g.Server(p)
+        path := fmt.Sprintf(`%s/ghttp/static/test/%d`, gfile.TempDir(), p)
+        defer gfile.Remove(path)
+        gfile.PutContents(path + "/test.html", "test")
+        s.SetIndexFiles([]string{"index.html", "test.html"})
+        s.SetServerRoot(path)
+        s.SetPort(p)
+        s.Start()
+        defer s.Shutdown()
+        time.Sleep(time.Second)
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),             "test")
+        gtest.Assert(client.GetContent("/index.html"),   "Not Found")
+        gtest.Assert(client.GetContent("/test.html"),    "test")
+    })
+}
+
+func Test_Static_AddSearchPath1(t *testing.T) {
+    gtest.Case(t, func() {
+        p := ports.PopRand()
+        s := g.Server(p)
+        path1 := fmt.Sprintf(`%s/ghttp/static/test/%d`,    gfile.TempDir(), p)
+        path2 := fmt.Sprintf(`%s/ghttp/static/test/%d/%d`, gfile.TempDir(), p, p)
+        defer gfile.Remove(path1)
+        defer gfile.Remove(path2)
+        gfile.PutContents(path2 + "/test.html", "test")
+        s.SetServerRoot(path1)
+        s.AddSearchPath(path2)
+        s.SetPort(p)
+        s.Start()
+        defer s.Shutdown()
+        time.Sleep(time.Second)
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),             "Forbidden")
+        gtest.Assert(client.GetContent("/test.html"),    "test")
+    })
+}
+
+func Test_Static_AddSearchPath2(t *testing.T) {
+    gtest.Case(t, func() {
+        p := ports.PopRand()
+        s := g.Server(p)
+        path1 := fmt.Sprintf(`%s/ghttp/static/test/%d`,    gfile.TempDir(), p)
+        path2 := fmt.Sprintf(`%s/ghttp/static/test/%d/%d`, gfile.TempDir(), p, p)
+        defer gfile.Remove(path1)
+        defer gfile.Remove(path2)
+        gfile.PutContents(path1 + "/test.html", "test1")
+        gfile.PutContents(path2 + "/test.html", "test2")
+        s.SetServerRoot(path1)
+        s.AddSearchPath(path2)
+        s.SetPort(p)
+        s.Start()
+        defer s.Shutdown()
+        time.Sleep(time.Second)
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),             "Forbidden")
+        gtest.Assert(client.GetContent("/test.html"),    "test1")
+    })
+}
+
+func Test_Static_AddStaticPath(t *testing.T) {
+    gtest.Case(t, func() {
+        p := ports.PopRand()
+        s := g.Server(p)
+        path1 := fmt.Sprintf(`%s/ghttp/static/test/%d`,    gfile.TempDir(), p)
+        path2 := fmt.Sprintf(`%s/ghttp/static/test/%d/%d`, gfile.TempDir(), p, p)
+        defer gfile.Remove(path1)
+        defer gfile.Remove(path2)
+        gfile.PutContents(path1 + "/test.html", "test1")
+        gfile.PutContents(path2 + "/test.html", "test2")
+        s.SetServerRoot(path1)
+        s.AddStaticPath("/my-test", path2)
+        s.SetPort(p)
+        s.Start()
+        defer s.Shutdown()
+        time.Sleep(time.Second)
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                  "Forbidden")
+        gtest.Assert(client.GetContent("/test.html"),         "test1")
+        gtest.Assert(client.GetContent("/my-test/test.html"), "test2")
+    })
+}
+
+func Test_Static_AddStaticPath_Priority(t *testing.T) {
+    gtest.Case(t, func() {
+        p := ports.PopRand()
+        s := g.Server(p)
+        path1 := fmt.Sprintf(`%s/ghttp/static/test/%d/test`,    gfile.TempDir(), p)
+        path2 := fmt.Sprintf(`%s/ghttp/static/test/%d/%d/test`, gfile.TempDir(), p, p)
+        defer gfile.Remove(path1)
+        defer gfile.Remove(path2)
+        gfile.PutContents(path1 + "/test.html", "test1")
+        gfile.PutContents(path2 + "/test.html", "test2")
+        s.SetServerRoot(path1)
+        s.AddStaticPath("/test", path2)
+        s.SetPort(p)
+        s.Start()
+        defer s.Shutdown()
+        time.Sleep(time.Second)
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),               "Forbidden")
+        gtest.Assert(client.GetContent("/test.html"),      "test1")
+        gtest.Assert(client.GetContent("/test/test.html"), "test2")
+    })
+}
+
+func Test_Static_Rewrite(t *testing.T) {
+    gtest.Case(t, func() {
+        p := ports.PopRand()
+        s := g.Server(p)
+        path := fmt.Sprintf(`%s/ghttp/static/test/%d`, gfile.TempDir(), p)
+        defer gfile.Remove(path)
+        gfile.PutContents(path + "/test1.html", "test1")
+        gfile.PutContents(path + "/test2.html", "test2")
+        s.SetServerRoot(path)
+        s.SetRewrite("/test.html", "/test1.html")
+        s.SetRewriteMap(g.MapStrStr{
+            "/my-test1" : "/test1.html",
+            "/my-test2" : "/test2.html",
+        })
+        s.SetPort(p)
+        s.Start()
+        defer s.Shutdown()
+        time.Sleep(time.Second)
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),               "Forbidden")
+        gtest.Assert(client.GetContent("/test.html"),      "test1")
+        gtest.Assert(client.GetContent("/test1.html"),     "test1")
+        gtest.Assert(client.GetContent("/test2.html"),     "test2")
+        gtest.Assert(client.GetContent("/my-test1"),       "test1")
+        gtest.Assert(client.GetContent("/my-test2"),       "test2")
+    })
+}
--- a/g/net/greuseport/greuseport.go
+++ b/g/net/greuseport/greuseport.go
@ -1,59 +0,0 @@
-// Package greuseport provides Listen and Dial functions that set socket
-// options in order to be able to reuse ports. You should only use this
-// package if you know what SO_REUSEADDR and SO_REUSEPORT are.
-//
-// For example:
-//
-//  // listen on the same port.
-//  l1, _ := reuse.Listen("tcp", "127.0.0.1:1234")
-//  l2, _ := reuse.Listen("tcp", "127.0.0.1:1234")
-//
-//  // dial from the same port.
-//  l1, _ := reuse.Listen("tcp", "127.0.0.1:1234")
-//  l2, _ := reuse.Listen("tcp", "127.0.0.1:1235")
-//  c, _ := reuse.Dial("tcp", "127.0.0.1:1234", "127.0.0.1:1235")
-//
-// Note: cant dial self because tcp/ip stacks use 4-tuples to identify connections,
-// and doing so would clash.
-package greuseport
-
-import (
-	"context"
-	"net"
-)
-
-var (
-	Enabled      = false
-	listenConfig = net.ListenConfig {
-		Control: Control,
-	}
-)
-
-// Listen listens at the given network and address. see net.Listen
-// Returns a net.Listener created from a file discriptor for a socket
-// with SO_REUSEPORT and SO_REUSEADDR option set.
-func Listen(network, address string) (net.Listener, error) {
-	return listenConfig.Listen(context.Background(), network, address)
-}
-
-// ListenPacket listens at the given network and address. see net.ListenPacket
-// Returns a net.Listener created from a file discriptor for a socket
-// with SO_REUSEPORT and SO_REUSEADDR option set.
-func ListenPacket(network, address string) (net.PacketConn, error) {
-	return listenConfig.ListenPacket(context.Background(), network, address)
-}
-
-// Dial dials the given network and address. see net.Dialer.Dial
-// Returns a net.Conn created from a file discriptor for a socket
-// with SO_REUSEPORT and SO_REUSEADDR option set.
-func Dial(network, laddr, raddr string) (net.Conn, error) {
-	nla, err := ResolveAddr(network, laddr)
-	if err != nil {
-		return nil, err
-	}
-	d := net.Dialer {
-		Control:   Control,
-		LocalAddr: nla,
-	}
-	return d.Dial(network, raddr)
-}
--- a/g/net/greuseport/greuseport_addr.go
+++ b/g/net/greuseport/greuseport_addr.go
@ -1,20 +0,0 @@
-package greuseport
-
-import (
-	"net"
-)
-
-func ResolveAddr(network, address string) (net.Addr, error) {
-	switch network {
-		case "ip", "ip4", "ip6":
-			return net.ResolveIPAddr(network, address)
-		case "tcp", "tcp4", "tcp6":
-			return net.ResolveTCPAddr(network, address)
-		case "udp", "udp4", "udp6":
-			return net.ResolveUDPAddr(network, address)
-		case "unix", "unixgram", "unixpacket":
-			return net.ResolveUnixAddr(network, address)
-        default:
-            return nil, net.UnknownNetworkError(network)
-	}
-}
--- a/g/net/greuseport/greuseport_other.go
+++ b/g/net/greuseport/greuseport_other.go
@ -1,12 +0,0 @@
-// +build !windows,!linux,!darwin,!dragonfly,!freebsd,!netbsd,!openbsd
-
-package greuseport
-
-import (
-    "syscall"
-)
-
-// See net.RawConn.Control
-func Control(network, address string, c syscall.RawConn) (err error) {
-	return nil
-}
--- a/g/net/greuseport/greuseport_unix.go
+++ b/g/net/greuseport/greuseport_unix.go
@ -1,28 +0,0 @@
-// +build linux darwin dragonfly freebsd netbsd openbsd
-
-package greuseport
-
-import (
-    "github.com/gogf/gf/third/golang.org/x/sys/unix"
-    "syscall"
-)
-
-func init() {
-    Enabled = true
-}
-
-// See net.RawConn.Control
-func Control(network, address string, c syscall.RawConn) (err error) {
-	c.Control(func(fd uintptr) {
-		if err = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEADDR, 1); err != nil {
-            panic(err)
-		    return
-		}
-		if err = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEPORT, 1); err != nil {
-			panic(err)
-		    return
-		}
-
-	})
-	return
-}
--- a/g/net/greuseport/greuseport_windows.go
+++ b/g/net/greuseport/greuseport_windows.go
@ -1,17 +0,0 @@
-// +build windows
-
-package greuseport
-
-import (
-    "github.com/gogf/gf/third/golang.org/x/sys/windows"
-    "syscall"
-)
-
-// See net.RawConn.Control
-func Control(network, address string, c syscall.RawConn) (err error) {
-	return c.Control(func(fd uintptr) {
-        if err = windows.SetsockoptInt(windows.Handle(fd), windows.SOL_SOCKET, windows.SO_REUSEADDR, 1); err != nil {
-            return
-        }
-	})
-}
--- a/g/net/greuseport/greuseport_z_unit_test.go
+++ b/g/net/greuseport/greuseport_z_unit_test.go
@ -1,213 +0,0 @@
-// +build linux darwin dragonfly freebsd netbsd openbsd
-
-package greuseport_test
-
-import (
-	"fmt"
-	"github.com/gogf/gf/g/net/greuseport"
-    "html"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"testing"
-)
-
-const (
-	httpServerOneResponse = "1"
-	httpServerTwoResponse = "2"
-)
-
-var (
-	httpServerOne = NewHTTPServer(httpServerOneResponse)
-	httpServerTwo = NewHTTPServer(httpServerTwoResponse)
-)
-
-func NewHTTPServer(resp string) *httptest.Server {
-	return httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		fmt.Fprint(w, resp)
-	}))
-}
-func TestNewReusablePortListener(t *testing.T) {
-	listenerOne, err := greuseport.Listen("tcp4", "localhost:10081")
-	if err != nil {
-		t.Error(err)
-	}
-	defer listenerOne.Close()
-
-	listenerTwo, err := greuseport.Listen("tcp", "127.0.0.1:10081")
-	if err != nil {
-		t.Error(err)
-	}
-	defer listenerTwo.Close()
-
-	listenerThree, err := greuseport.Listen("tcp6", "[::]:10081")
-	if err != nil {
-		t.Error(err)
-	}
-	defer listenerThree.Close()
-
-	listenerFour, err := greuseport.Listen("tcp6", ":10081")
-	if err != nil {
-		t.Error(err)
-	}
-	defer listenerFour.Close()
-
-	listenerFive, err := greuseport.Listen("tcp4", ":10081")
-	if err != nil {
-		t.Error(err)
-	}
-	defer listenerFive.Close()
-
-	listenerSix, err := greuseport.Listen("tcp", ":10081")
-	if err != nil {
-		t.Error(err)
-	}
-	defer listenerSix.Close()
-}
-
-func TestListen(t *testing.T) {
-	listenerOne, err := greuseport.Listen("tcp4", "localhost:10081")
-	if err != nil {
-		t.Error(err)
-	}
-	defer listenerOne.Close()
-
-	listenerTwo, err := greuseport.Listen("tcp", "127.0.0.1:10081")
-	if err != nil {
-		t.Error(err)
-	}
-	defer listenerTwo.Close()
-
-	listenerThree, err := greuseport.Listen("tcp6", "[::]:10081")
-	if err != nil {
-		t.Error(err)
-	}
-	defer listenerThree.Close()
-
-	listenerFour, err := greuseport.Listen("tcp6", ":10081")
-	if err != nil {
-		t.Error(err)
-	}
-	defer listenerFour.Close()
-
-	listenerFive, err := greuseport.Listen("tcp4", ":10081")
-	if err != nil {
-		t.Error(err)
-	}
-	defer listenerFive.Close()
-
-	listenerSix, err := greuseport.Listen("tcp", ":10081")
-	if err != nil {
-		t.Error(err)
-	}
-	defer listenerSix.Close()
-}
-
-func TestNewReusablePortServers(t *testing.T) {
-	listenerOne, err := greuseport.Listen("tcp4", "localhost:10081")
-	if err != nil {
-		t.Error(err)
-	}
-	defer listenerOne.Close()
-
-	listenerTwo, err := greuseport.Listen("tcp6", ":10081")
-	if err != nil {
-		t.Error(err)
-	}
-	defer listenerTwo.Close()
-
-	httpServerOne.Listener = listenerOne
-	httpServerTwo.Listener = listenerTwo
-
-	httpServerOne.Start()
-	httpServerTwo.Start()
-
-	// Server One — First Response
-	resp1, err := http.Get(httpServerOne.URL)
-	if err != nil {
-		t.Error(err)
-	}
-	body1, err := ioutil.ReadAll(resp1.Body)
-	resp1.Body.Close()
-	if err != nil {
-		t.Error(err)
-	}
-	if string(body1) != httpServerOneResponse && string(body1) != httpServerTwoResponse {
-		t.Errorf("Expected %#v or %#v, got %#v.", httpServerOneResponse, httpServerTwoResponse, string(body1))
-	}
-
-	// Server Two — First Response
-	resp2, err := http.Get(httpServerTwo.URL)
-	if err != nil {
-		t.Error(err)
-	}
-	body2, err := ioutil.ReadAll(resp2.Body)
-	resp1.Body.Close()
-	if err != nil {
-		t.Error(err)
-	}
-	if string(body2) != httpServerOneResponse && string(body2) != httpServerTwoResponse {
-		t.Errorf("Expected %#v or %#v, got %#v.", httpServerOneResponse, httpServerTwoResponse, string(body2))
-	}
-
-	httpServerTwo.Close()
-
-	// Server One — Second Response
-	resp3, err := http.Get(httpServerOne.URL)
-	if err != nil {
-		t.Error(err)
-	}
-	body3, err := ioutil.ReadAll(resp3.Body)
-	resp1.Body.Close()
-	if err != nil {
-		t.Error(err)
-	}
-	if string(body3) != httpServerOneResponse {
-		t.Errorf("Expected %#v, got %#v.", httpServerOneResponse, string(body3))
-	}
-
-	// Server One — Third Response
-	resp5, err := http.Get(httpServerOne.URL)
-	if err != nil {
-		t.Error(err)
-	}
-	body5, err := ioutil.ReadAll(resp5.Body)
-	resp1.Body.Close()
-	if err != nil {
-		t.Error(err)
-	}
-	if string(body5) != httpServerOneResponse {
-		t.Errorf("Expected %#v, got %#v.", httpServerOneResponse, string(body5))
-	}
-
-	httpServerOne.Close()
-}
-
-func BenchmarkNewReusablePortListener(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		listener, err := greuseport.Listen("tcp", ":10081")
-
-		if err != nil {
-			b.Error(err)
-		} else {
-			listener.Close()
-		}
-	}
-}
-
-func ExampleNewReusablePortListener() {
-	listener, err := greuseport.Listen("tcp", ":8881")
-	if err != nil {
-		panic(err)
-	}
-	defer listener.Close()
-
-	server := &http.Server{}
-	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
-		fmt.Println(os.Getgid())
-		fmt.Fprintf(w, "Hello, %q\n", html.EscapeString(r.URL.Path))
-	})
-
-	panic(server.Serve(listener))
-}
--- a/g/net/gtcp/gtcp_server.go
+++ b/g/net/gtcp/gtcp_server.go
@ -31,15 +31,15 @@ var serverMapping = gmap.NewStringInterfaceMap()
 // 获取/创建一个空配置的TCP Server
 // 单例模式，请保证name的唯一性
 func GetServer(name...interface{}) (*Server) {
-    sname := gDEFAULT_SERVER
+    serverName := gDEFAULT_SERVER
    if len(name) > 0 {
-        sname = gconv.String(name[0])
+        serverName = gconv.String(name[0])
    }
-    if s := serverMapping.Get(sname); s != nil {
+    if s := serverMapping.Get(serverName); s != nil {
        return s.(*Server)
    }
    s := NewServer("", nil)
-    serverMapping.Set(sname, s)
+    serverMapping.Set(serverName, s)
    return s
 }

@ -65,19 +65,24 @@ func (s *Server) SetHandler (handler func (*Conn)) {
 // 执行监听
 func (s *Server) Run() error {
    if s.handler == nil {
-        return errors.New("start running failed: socket handler not defined")
-    }
-    tcpaddr, err := net.ResolveTCPAddr("tcp", s.address)
-    if err != nil {
+        err := errors.New("start running failed: socket handler not defined")
+        glog.Error(err)
        return err
    }
-    listen, err := net.ListenTCP("tcp", tcpaddr)
+    addr, err := net.ResolveTCPAddr("tcp", s.address)
    if err != nil {
+        glog.Error(err)
+        return err
+    }
+    listen, err := net.ListenTCP("tcp", addr)
+    if err != nil {
+        glog.Error(err)
        return err
    }
    for  {
        if conn, err := listen.Accept(); err != nil {
            glog.Error(err)
+            return err
        } else if conn != nil {
            go s.handler(NewConnByNetConn(conn))
        }
--- a/g/net/gudp/gudp_server.go
+++ b/g/net/gudp/gudp_server.go
@ -8,6 +8,7 @@
 package gudp

 import (
+    "github.com/gogf/gf/g/os/glog"
    "net"
    "errors"
    "github.com/gogf/gf/g/container/gmap"
@ -30,15 +31,15 @@ var serverMapping = gmap.NewStringInterfaceMap()
 // 获取/创建一个空配置的UDP Server
 // 单例模式，请保证name的唯一性
 func GetServer(name...interface{}) (*Server) {
-    sname := gDEFAULT_SERVER
+    serverName := gDEFAULT_SERVER
    if len(name) > 0 {
-        sname = gconv.String(name[0])
+        serverName = gconv.String(name[0])
    }
-    if s := serverMapping.Get(sname); s != nil {
+    if s := serverMapping.Get(serverName); s != nil {
        return s.(*Server)
    }
    s := NewServer("", nil)
-    serverMapping.Set(sname, s)
+    serverMapping.Set(serverName, s)
    return s
 }

@ -64,14 +65,18 @@ func (s *Server) SetHandler (handler func (*Conn)) {
 // 执行监听
 func (s *Server) Run() error {
    if s.handler == nil {
-        return errors.New("start running failed: socket handler not defined")
+        err := errors.New("start running failed: socket handler not defined")
+        glog.Error(err)
+        return err
    }
    addr, err := net.ResolveUDPAddr("udp", s.address)
    if err != nil {
+        glog.Error(err)
        return err
    }
    conn, err := net.ListenUDP("udp", addr)
    if err != nil {
+        glog.Error(err)
        return err
    }
    for {
--- a/g/os/gcache/gcache_mem_cache.go
+++ b/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})
--- a/g/os/gcfg/gcfg.go
+++ b/g/os/gcfg/gcfg.go
@ -26,7 +26,8 @@ import (
 )

 const (
-    DEFAULT_CONFIG_FILE = "config.toml" // 默认的配置管理文件名称
+    // 默认的配置管理文件名称
+    DEFAULT_CONFIG_FILE = "config.toml"
 )

 // 配置管理对象
@ -65,13 +66,7 @@ func (c *Config) filePath(file...string) (path string) {
    if len(file) > 0 {
        name = file[0]
    }
-    c.paths.RLockFunc(func(array []string) {
-        for _, v := range array {
-            if path, _ = gspath.Search(v, name); path != "" {
-                break
-            }
-        }
-    })
+    path = c.GetFilePath(name)
    if path == "" {
        buffer := bytes.NewBuffer(nil)
        if c.paths.Len() > 0 {
@ -132,7 +127,8 @@ func (c *Config) AddPath(path string) error {
    return nil
 }

-// 获取指定文件的绝对路径，默认获取默认的配置文件路径，当指定的配置文件不存在时，返回空字符串，并且不会报错。
+// 查找配置文件，获取指定配置文件的绝对路径，默认获取默认的配置文件路径；
+// 当指定的配置文件不存在时，返回空字符串，并且不会报错。
 func (c *Config) GetFilePath(file...string) (path string) {
    name := c.name.Val()
    if len(file) > 0 {
@ -140,9 +136,14 @@ func (c *Config) GetFilePath(file...string) (path string) {
    }
    c.paths.RLockFunc(func(array []string) {
        for _, v := range array {
+            // 查找当前目录
            if path, _ = gspath.Search(v, name); path != "" {
                break
            }
+            // 查找当前目录下的config子目录
+            if path, _ = gspath.Search(v, "config" + gfile.Separator + name); path != "" {
+                break
+            }
        }
    })
    return
@ -154,23 +155,38 @@ 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{} {
+        filePath := c.filePath(file...)
+        if filePath == "" {
+            return nil
+        }
+        if j, err := gjson.Load(filePath); err == nil {
+            j.SetViolenceCheck(c.vc.Val())
+            // 添加配置文件监听，如果有任何变化，删除文件内容缓存，下一次查询会自动更新
+            gfsnotify.Add(filePath, func(event *gfsnotify.Event) {
+                c.jsons.Remove(event.Path)
+            })
+            return j
+        } else {
+            glog.Errorfln(`[gcfg] Load config file "%s" failed: %s`, filePath, 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
 }

@ -190,6 +206,14 @@ func (c *Config) GetVar(pattern string, file...string) gvar.VarRead {
    return gvar.New(nil, true)
 }

+// 判断指定的配置项是否存在
+func (c *Config) Contains(pattern string, file...string) bool {
+    if j := c.getJson(file...); j != nil {
+        return j.Contains(pattern)
+    }
+    return false
+}
+
 // 获得一个键值对关联数组/哈希表，方便操作，不需要自己做类型转换
 // 注意，如果获取的值不存在，或者类型与json类型不匹配，那么将会返回nil
 func (c *Config) GetMap(pattern string, file...string)  map[string]interface{} {
@ -353,14 +377,3 @@ 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)
-    })
-}
--- a/g/os/gcfg/gcfg_z_unit_test.go
+++ b/g/os/gcfg/gcfg_z_unit_test.go
@ -0,0 +1,77 @@
+// 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.
+
+// go test *.go -bench=".*" -benchmem
+
+package gcfg_test
+
+import (
+    "github.com/gogf/gf/g/os/gcfg"
+    "github.com/gogf/gf/g/os/gfile"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+func Test_Basic(t *testing.T) {
+    config := `
+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"
+`
+    gtest.Case(t, func() {
+        path := "config.toml"
+        err  := gfile.PutContents(path, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(path)
+
+        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",
+        })
+        gtest.AssertEQ(c.GetFilePath(),    gfile.Pwd() + gfile.Separator + "config.toml")
+
+    })
+}
--- a/g/os/gcron/gcron.go
+++ b/g/os/gcron/gcron.go
@ -29,7 +29,27 @@ var (
    defaultCron = New()
 )

-// 添加执行方法，可以给定名字，以便于后续执行删除
+// 设置日志输出路径
+func SetLogPath(path string) {
+    defaultCron.SetLogPath(path)
+}
+
+// 获取设置的日志输出路径
+func GetLogPath() string {
+    return defaultCron.GetLogPath()
+}
+
+// 设置日志输出等级。
+func SetLogLevel(level int) {
+    defaultCron.SetLogLevel(level)
+}
+
+// 获取日志输出等级。
+func GetLogLevel() int {
+    return defaultCron.GetLogLevel()
+}
+
+// 添加定时任务，可以给定名字，以便于后续执行删除
 func Add(pattern string, job func(), name ... string) (*Entry, error) {
    return defaultCron.Add(pattern, job, name...)
 }
--- a/g/os/gcron/gcron_cron.go
+++ b/g/os/gcron/gcron_cron.go
@ -12,26 +12,51 @@ import (
    "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/os/glog"
    "github.com/gogf/gf/g/os/gtimer"
    "time"
 )

 // 定时任务管理对象
 type Cron struct {
-    idgen    *gtype.Int               // 用于唯一名称生成
-    status   *gtype.Int               // 定时任务状态(0: 未执行; 1: 运行中; 2: 已停止; -1:删除关闭)
-    entries  *gmap.StringInterfaceMap // 所有的定时任务项
+    idGen      *gtype.Int64             // 用于唯一名称生成
+    status     *gtype.Int               // 定时任务状态(0: 未执行; 1: 运行中; 2: 已停止; -1:删除关闭)
+    entries    *gmap.StringInterfaceMap // 所有的定时任务项
+    logPath    *gtype.String            // 日志文件输出目录
+    logLevel   *gtype.Int               // 日志输出等级
 }

 // 创建自定义的定时任务管理对象
 func New() *Cron {
    return &Cron {
-        idgen    : gtype.NewInt(1000000),
-        status   : gtype.NewInt(STATUS_RUNNING),
-        entries  : gmap.NewStringInterfaceMap(),
+        idGen      : gtype.NewInt64(),
+        status     : gtype.NewInt(STATUS_RUNNING),
+        entries    : gmap.NewStringInterfaceMap(),
+        logPath    : gtype.NewString(),
+        logLevel   : gtype.NewInt(glog.LEVEL_PROD),
    }
 }

+// 设置日志输出路径
+func (c *Cron) SetLogPath(path string) {
+    c.logPath.Set(path)
+}
+
+// 获取设置的日志输出路径
+func (c *Cron) GetLogPath() string {
+    return c.logPath.Val()
+}
+
+// 设置日志输出等级。
+func (c *Cron) SetLogLevel(level int) {
+    c.logLevel.Set(level)
+}
+
+// 获取日志输出等级。
+func (c *Cron) GetLogLevel() int {
+    return c.logLevel.Val()
+}
+
 // 添加定时任务
 func (c *Cron) Add(pattern string, job func(), name ... string) (*Entry, error) {
    if len(name) > 0 {
--- a/g/os/gcron/gcron_entry.go
+++ b/g/os/gcron/gcron_entry.go
@ -7,8 +7,11 @@
 package gcron

 import (
+    "github.com/gogf/gf/g/os/glog"
    "github.com/gogf/gf/g/os/gtimer"
-    "strconv"
+    "github.com/gogf/gf/g/util/gconv"
+    "reflect"
+    "runtime"
    "time"
 )

@ -17,6 +20,7 @@ type Entry struct {
    cron       *Cron         // 所属定时任务
    entry      *gtimer.Entry // 定时器任务对象
    schedule   *cronSchedule // 定时任务配置对象
+    jobName    string        // 任务注册方法名称
    Name       string        // 定时任务名称
    Job        func()        // 注册定时任务方法
    Time       time.Time     // 注册时间
@ -31,13 +35,14 @@ func (c *Cron) addEntry(pattern string, job func(), singleton bool, times int, n
    entry := &Entry {
        cron      : c,
        schedule  : schedule,
+        jobName   : runtime.FuncForPC(reflect.ValueOf(job).Pointer()).Name(),
        Job       : job,
        Time      : time.Now(),
    }
    if len(name) > 0 {
        entry.Name = name[0]
    } else {
-        entry.Name = strconv.Itoa(c.idgen.Add(1))
+        entry.Name = "gcron-" + gconv.String(c.idGen.Add(1))
    }
    entry.entry = gtimer.AddEntry(time.Second, entry.check, singleton, times, gtimer.STATUS_STOPPED)
    entry.entry.Start()
@ -89,20 +94,29 @@ func (entry *Entry) Close() {
 // 定时任务检查执行
 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

            case STATUS_CLOSED:
                entry.cron.Remove(entry.Name)
+                glog.Path(path).Level(level).Debugfln("[gcron] %s(%s) %s remove", entry.Name, entry.schedule.pattern, entry.jobName)
                gtimer.Exit()

            case STATUS_READY: fallthrough
            case STATUS_RUNNING:
+                glog.Path(path).Level(level).Debugfln("[gcron] %s(%s) %s start", entry.Name, entry.schedule.pattern, entry.jobName)
                defer func() {
                    if entry.entry.Status() == STATUS_CLOSED {
                        entry.cron.Remove(entry.Name)
                    }
+                    if err := recover(); err != nil {
+                        glog.Path(path).Level(level).Errorfln("[gcron] %s(%s) %s end with error: %v", entry.Name, entry.schedule.pattern, entry.jobName, err)
+                    } else {
+                        glog.Path(path).Level(level).Debugfln("[gcron] %s(%s) %s end", entry.Name, entry.schedule.pattern, entry.jobName)
+                    }
                }()
                entry.Job()
        }
--- a/g/os/gcron/gcron_unit_1_test.go
+++ b/g/os/gcron/gcron_unit_1_test.go
@ -39,14 +39,14 @@ func TestCron_Add_Close(t *testing.T) {
        gtest.AssertNE(err3, nil)
        gtest.Assert(err4, nil)
        gtest.Assert(cron.Size(), 3)
-        time.Sleep(1100*time.Millisecond)
+        time.Sleep(1200*time.Millisecond)
        gtest.Assert(array.Len(), 2)
-        time.Sleep(1100*time.Millisecond)
+        time.Sleep(1200*time.Millisecond)
        gtest.Assert(array.Len(), 5)
        cron.Close()
-        time.Sleep(1100*time.Millisecond)
+        time.Sleep(1200*time.Millisecond)
        fixedLength := array.Len()
-        time.Sleep(1100*time.Millisecond)
+        time.Sleep(1200*time.Millisecond)
        gtest.Assert(array.Len(), fixedLength)
    })
 }
--- a/g/os/gfcache/gfcache.go
+++ b/g/os/gfcache/gfcache.go
@ -10,52 +10,52 @@
 package gfcache

 import (
-    "github.com/gogf/gf/g/container/gmap"
-    "github.com/gogf/gf/g/container/gtype"
    "github.com/gogf/gf/g/internal/cmdenv"
+    "github.com/gogf/gf/g/os/gcache"
+    "github.com/gogf/gf/g/os/gfile"
+    "github.com/gogf/gf/g/os/gfsnotify"
 )

-type Cache struct {
-    cap    *gtype.Int               // 缓存容量(byte)，设置为0表示不限制
-    size   *gtype.Int               // 缓存大小(Byte)
-    cache  *gmap.StringInterfaceMap // 缓存对象
-}
-
 const (
-    // 默认的缓存容量(10MB)
-    gDEFAULT_CACHE_CAP = 10*1024*1024
+    // 默认的缓存超时时间(60秒)
+    gDEFAULT_CACHE_EXPIRE = 60
 )

 var (
-    // 默认的缓存容量
-    cacheCap = cmdenv.Get("gf.gfcache.cap", gDEFAULT_CACHE_CAP).Int()
-    // 默认的文件缓存对象
-    cache    = New()
+    // 默认的缓存时间(秒)
+    cacheExpire = cmdenv.Get("gf.gfcache.expire", gDEFAULT_CACHE_EXPIRE).Int()*1000
 )

-func New(cap ... int) *Cache {
-    c := cacheCap
-    if len(cap) > 0 {
-        c = cap[0]
+// 获得文件内容 string，expire参数为缓存过期时间，单位为秒。
+func GetContents(path string, expire...int) string {
+    return string(GetBinContents(path, expire...))
+}
+
+// 获得文件内容 []byte，expire参数为缓存过期时间，单位为秒。
+func GetBinContents(path string, expire...int) []byte {
+    k := cacheKey(path)
+    e := cacheExpire
+    if len(expire) > 0 {
+        e = expire[0]
    }
-    return &Cache {
-        cap    : gtype.NewInt(c),
-        size   : gtype.NewInt(),
-        cache  : gmap.NewStringInterfaceMap(),
+    r := gcache.GetOrSetFuncLock(k, func() interface{} {
+        b := gfile.GetBinContents(path)
+        if b != nil {
+            // 添加文件监控，如果文件有任何变化，立即清空缓存
+            gfsnotify.Add(path, func(event *gfsnotify.Event) {
+                gcache.Remove(k)
+                gfsnotify.Exit()
+            })
+        }
+        return b
+    }, e*1000)
+    if r != nil {
+        return r.([]byte)
    }
+    return nil
 }

-// 获得已缓存的文件大小(byte)
-func GetSize() int {
-    return cache.GetSize()
-}
-
-// 获得文件内容 string
-func GetContents(path string) string {
-    return cache.GetContents(path)
-}
-
-// 获得文件内容 []byte
-func GetBinContents(path string) []byte {
-    return cache.GetBinContents(path)
+// 生成缓存键名
+func cacheKey(path string) string {
+    return "gf.gfcache:" + path
 }
--- a/g/os/gfcache/gfcache_cache.go
+++ b/g/os/gfcache/gfcache_cache.go
@ -1,62 +0,0 @@
-// 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 gfcache
-
-import (
-    "github.com/gogf/gf/g/os/gfile"
-    "github.com/gogf/gf/g/os/gfsnotify"
-)
-
-// 设置容量大小(byte)
-func (c *Cache) SetCap(cap int) {
-    c.cap.Set(cap)
-}
-
-// 获得缓存容量大小(byte)
-func (c *Cache) GetCap() int {
-    return c.cap.Val()
-}
-
-// 获得已缓存的文件大小(byte)
-func (c *Cache) GetSize() int {
-    return c.size.Val()
-}
-
-// 获得文件内容 string
-func (c *Cache) GetContents(path string) string {
-    return string(c.GetBinContents(path))
-}
-
-// 获得文件内容 []byte
-func (c *Cache) GetBinContents(path string) []byte {
-    if v := c.cache.Get(path); v != nil {
-        return v.([]byte)
-    }
-    b := gfile.GetBinContents(path)
-    // 读取到内容，并且没有超过缓存容量限制时才会执行缓存
-    if len(b) > 0 && (c.cap.Val() == 0 || c.size.Val() < c.cap.Val()) {
-        c.size.Add(len(b))
-        c.addMonitor(path)
-        c.cache.Set(path, b)
-    }
-    return b
-}
-
-// 添加文件监控，一旦文件有变化立即清除缓存，下一次读取的时候再执行缓存。
-func (c *Cache) addMonitor(path string) {
-    // 防止多goroutine同时调用
-    if c.cache.Contains(path) {
-        return
-    }
-    gfsnotify.Add(path, func(event *gfsnotify.Event) {
-        if r := c.cache.Get(path); r != nil {
-            c.cache.Remove(path)
-            c.size.Add(-len(r.([]byte)))
-        }
-    })
-}
--- a/g/os/gfile/gfile.go
+++ b/g/os/gfile/gfile.go
@ -122,11 +122,12 @@ func IsDir(path string) bool {
    return s.IsDir()
 }

-// Get current working absolute directory path.
+// Get current working directory absolute path.
 //
-// 获取当前工作目录(SelfDir()方法的别名)
+// 获取当前工作目录(注意与SelfDir的区别).
 func Pwd() string {
-    return SelfDir()
+    path, _ := os.Getwd()
+    return path
 }

 // Check whether given path a file(not a directory).
@ -140,11 +141,18 @@ func IsFile(path string) bool {
    return !s.IsDir()
 }

-// Info returns a FileInfo describing the named file.
+// See Stat.
+//
+// Stat 方法的别名。
+func Info(path string) (os.FileInfo, error) {
+    return Stat(path)
+}
+
+// Stat returns a FileInfo describing the named file.
 // If there is an error, it will be of type *PathError.
 //
 // 获取文件或目录信息.
-func Info(path string) (os.FileInfo, error) {
+func Stat(path string) (os.FileInfo, error) {
    return os.Stat(path)
 }

--- a/g/os/gfile/gfile_contents.go
+++ b/g/os/gfile/gfile_contents.go
@ -24,7 +24,7 @@ func GetContents(path string) string {
    return string(GetBinContents(path))
 }

-// (二进制)读取文件内容
+// (二进制)读取文件内容，如果文件不存在或者读取失败，返回nil。
 func GetBinContents(path string) []byte {
    data, err := ioutil.ReadFile(path)
    if err != nil {
--- a/g/os/gfsnotify/gfsnotify.go
+++ b/g/os/gfsnotify/gfsnotify.go
@ -59,7 +59,8 @@ const (
 )

 const (
-    REPEAT_EVENT_FILTER_INTERVAL = 1 // (毫秒)重复事件过滤间隔
+    REPEAT_EVENT_FILTER_INTERVAL = 1      // (毫秒)重复事件过滤间隔
+    gFSNOTIFY_EVENT_EXIT         = "exit" // 是否退出回调执行
 )

 var (
@ -113,3 +114,8 @@ func RemoveCallback(callbackId int) error {
    defaultWatcher.RemoveCallback(callbackId)
    return nil
 }
+
+// 在回调方法中调用该方法退出回调注册
+func Exit() {
+    panic(gFSNOTIFY_EVENT_EXIT)
+}
--- a/g/os/gfsnotify/gfsnotify_watcher_loop.go
+++ b/g/os/gfsnotify/gfsnotify_watcher_loop.go
@ -18,7 +18,7 @@ func (w *Watcher) startWatchLoop() {
                // 关闭事件
                case <- w.closeChan: return

-                    // 监听事件
+                // 监听事件
                case ev := <- w.watcher.Events:
                    //fmt.Println("ev:", ev.String())
                    w.cache.SetIfNotExist(ev.String(), func() interface{} {
@ -74,7 +74,7 @@ func (w *Watcher) getCallbacks(path string) (callbacks []*Callback) {
    return
 }

-// 事件循环
+// 事件循环(核心逻辑)
 func (w *Watcher) startEventLoop() {
    go func() {
        for {
@ -126,10 +126,22 @@ func (w *Watcher) startEventLoop() {

                }
                // 执行回调处理，异步处理
-                for _, callback := range callbacks {
-                    go callback.Func(event)
+                for _, v := range callbacks {
+                    go func(callback *Callback) {
+                        defer func() {
+                            // 是否退出监控
+                            if err := recover(); err != nil {
+                                switch err {
+                                    case gFSNOTIFY_EVENT_EXIT:
+                                        w.RemoveCallback(callback.Id)
+                                    default:
+                                        panic(err)
+                                }
+                            }
+                        }()
+                        callback.Func(event)
+                    }(v)
                }
-
            } else {
                break
            }
--- a/g/os/gfsnotify/gfsnotify_z_unit_test.go
+++ b/g/os/gfsnotify/gfsnotify_z_unit_test.go
@ -0,0 +1,155 @@
+// 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=".*" -benchmem
+
+package gfsnotify_test
+
+import (
+    "github.com/gogf/gf/g/container/gtype"
+    "github.com/gogf/gf/g/os/gfile"
+    "github.com/gogf/gf/g/os/gfsnotify"
+    "github.com/gogf/gf/g/os/gtime"
+    "github.com/gogf/gf/g/test/gtest"
+    "github.com/gogf/gf/g/util/gconv"
+    "testing"
+    "time"
+)
+
+func TestWatcher_AddRemove(t *testing.T) {
+    gtest.Case(t, func() {
+        path1 := gconv.String(gtime.Nanosecond())
+        path2 := gconv.String(gtime.Nanosecond()) + "2"
+        gfile.PutContents(path1, "1")
+        defer func() {
+            gfile.Remove(path1)
+            gfile.Remove(path2)
+        }()
+        v := gtype.NewInt(1)
+        callback, err := gfsnotify.Add(path1, func(event *gfsnotify.Event) {
+            if event.IsWrite() {
+                v.Set(2)
+                return
+            }
+            if event.IsRename() {
+                v.Set(3)
+                gfsnotify.Exit()
+                return
+            }
+        })
+        gtest.Assert(err,        nil)
+        gtest.AssertNE(callback, nil)
+
+        gfile.PutContents(path1, "2")
+        time.Sleep(100*time.Millisecond)
+        gtest.Assert(v.Val(), 2)
+
+        gfile.Rename(path1, path2)
+        time.Sleep(100*time.Millisecond)
+        gtest.Assert(v.Val(), 3)
+    })
+
+    gtest.Case(t, func() {
+        path1 := gconv.String(gtime.Nanosecond())
+        gfile.PutContents(path1, "1")
+        defer func() {
+            gfile.Remove(path1)
+        }()
+        v := gtype.NewInt(1)
+        callback, err := gfsnotify.Add(path1, func(event *gfsnotify.Event) {
+            if event.IsWrite() {
+                v.Set(2)
+                return
+            }
+            if event.IsRemove() {
+                v.Set(4)
+                return
+            }
+        })
+        gtest.Assert(err,        nil)
+        gtest.AssertNE(callback, nil)
+
+        gfile.PutContents(path1, "2")
+        time.Sleep(100*time.Millisecond)
+        gtest.Assert(v.Val(), 2)
+
+        gfile.Remove(path1)
+        time.Sleep(100*time.Millisecond)
+        gtest.Assert(v.Val(), 4)
+
+        gfile.PutContents(path1, "1")
+        time.Sleep(100*time.Millisecond)
+        gtest.Assert(v.Val(), 4)
+    })
+}
+
+func TestWatcher_Callback(t *testing.T) {
+    gtest.Case(t, func() {
+        path1 := gconv.String(gtime.Nanosecond())
+        gfile.PutContents(path1, "1")
+        defer func() {
+            gfile.Remove(path1)
+        }()
+        v := gtype.NewInt(1)
+        callback, err := gfsnotify.Add(path1, func(event *gfsnotify.Event) {
+            if event.IsWrite() {
+                v.Set(2)
+                return
+            }
+        })
+        gtest.Assert(err,        nil)
+        gtest.AssertNE(callback, nil)
+
+        gfile.PutContents(path1, "2")
+        time.Sleep(100*time.Millisecond)
+        gtest.Assert(v.Val(), 2)
+
+        v.Set(3)
+        gfsnotify.RemoveCallback(callback.Id)
+        gfile.PutContents(path1, "3")
+        time.Sleep(100*time.Millisecond)
+        gtest.Assert(v.Val(), 3)
+    })
+    // multiple callbacks
+    gtest.Case(t, func() {
+        path1 := gconv.String(gtime.Nanosecond())
+        gfile.PutContents(path1, "1")
+        defer func() {
+            gfile.Remove(path1)
+        }()
+        v1 := gtype.NewInt(1)
+        v2 := gtype.NewInt(1)
+        callback1, err1 := gfsnotify.Add(path1, func(event *gfsnotify.Event) {
+            if event.IsWrite() {
+                v1.Set(2)
+                return
+            }
+        })
+        callback2, err2 := gfsnotify.Add(path1, func(event *gfsnotify.Event) {
+            if event.IsWrite() {
+                v2.Set(2)
+                return
+            }
+        })
+        gtest.Assert(err1,        nil)
+        gtest.Assert(err2,        nil)
+        gtest.AssertNE(callback1, nil)
+        gtest.AssertNE(callback2, nil)
+
+        gfile.PutContents(path1, "2")
+        time.Sleep(100*time.Millisecond)
+        gtest.Assert(v1.Val(), 2)
+        gtest.Assert(v2.Val(), 2)
+
+        v1.Set(3)
+        v2.Set(3)
+        gfsnotify.RemoveCallback(callback1.Id)
+        gfile.PutContents(path1, "3")
+        time.Sleep(100*time.Millisecond)
+        gtest.Assert(v1.Val(), 3)
+        gtest.Assert(v2.Val(), 2)
+    })
+}
--- a/g/os/glog/glog.go
+++ b/g/os/glog/glog.go
@ -18,6 +18,8 @@ import (

 const (
    LEVEL_ALL  = LEVEL_DEBU | LEVEL_INFO | LEVEL_NOTI | LEVEL_WARN | LEVEL_ERRO | LEVEL_CRIT
+    LEVEL_DEV  = LEVEL_ALL
+    LEVEL_PROD = LEVEL_WARN | LEVEL_ERRO | LEVEL_CRIT
    LEVEL_DEBU = 1 << iota
    LEVEL_INFO
    LEVEL_NOTI
@ -141,6 +143,14 @@ func To(writer io.Writer) *Logger {
    return logger.To(writer)
 }

+// Path is a chaining function,
+// which sets the directory path to <path> for current logging content output.
+//
+// 链式操作，设置下一次输出的日志路径。
+func Path(path string) *Logger {
+    return logger.Path(path)
+}
+
 // Cat is a chaining function, 
 // which sets the category to <category> for current logging content output.
 // 
--- a/g/os/glog/glog_logger_chaining.go
+++ b/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 {
@ -26,6 +26,23 @@ func (l *Logger) To(writer io.Writer) *Logger {
    return logger
 }

+// Path is a chaining function,
+// which sets the directory path to <path> for current logging content output.
+//
+// 链式操作，设置下一次输出的日志路径。
+func (l *Logger) Path(path string) *Logger {
+    logger := (*Logger)(nil)
+    if l.pr == nil {
+        logger = l.Clone()
+    } else {
+        logger = l
+    }
+    if path != "" {
+        logger.SetPath(path)
+    }
+    return logger
+}
+
 // Cat is a chaining function, 
 // which sets the category to <category> for current logging content output.
 // 
--- a/g/os/gspath/gspath.go
+++ b/g/os/gspath/gspath.go
@ -7,7 +7,8 @@
 // Package gspath implements file index and search for folders.
 // 
 // 搜索目录管理, 
-// 可以添加搜索目录，按照添加的优先级进行文件检索，并在内部进行高效缓存处理。
+// 可以添加搜索目录，按照添加的优先级进行文件检索，并在内部进行高效缓存处理(可选)。
+// 注意：当开启缓存功能后，在新增/删除文件时，会存在检索延迟。
 package gspath

 import (
@ -16,9 +17,8 @@ import (
    "github.com/gogf/gf/g/container/garray"
    "github.com/gogf/gf/g/container/gmap"
    "github.com/gogf/gf/g/os/gfile"
-    "github.com/gogf/gf/g/os/gfsnotify"
    "github.com/gogf/gf/g/text/gstr"
-    "runtime"
+    "os"
    "sort"
    "strings"
 )
@ -26,7 +26,7 @@ import (
 // 文件目录搜索管理对象
 type SPath struct {
    paths *garray.StringArray    // 搜索路径，按照优先级进行排序
-    cache *gmap.StringStringMap  // 搜索结果缓存map
+    cache *gmap.StringStringMap  // 搜索结果缓存map(如果未nil表示未启用缓存功能)
 }

 // 文件搜索缓存项
@ -37,17 +37,20 @@ type SPathCacheItem struct {

 var (
    // 单个目录路径对应的SPath对象指针，用于路径检索对象复用
-    pathsMap = gmap.NewStringInterfaceMap()
+    pathsMap      = gmap.NewStringInterfaceMap()
+    pathsCacheMap = gmap.NewStringInterfaceMap()
 )

 // 创建一个搜索对象
-func New(path...string) *SPath {
+func New(path string, cache bool) *SPath {
    sp := &SPath {
        paths : garray.NewStringArray(),
-        cache : gmap.NewStringStringMap(),
+    }
+    if cache {
+        sp.cache = gmap.NewStringStringMap()
    }
    if len(path) > 0 {
-        if _, err := sp.Add(path[0]); err != nil {
+        if _, err := sp.Add(path); err != nil {
            //fmt.Errorf(err.Error())
        }
    }
@ -55,17 +58,21 @@ func New(path...string) *SPath {
 }

 // 创建/获取一个单例的搜索对象, root必须为目录的绝对路径
-func Get(root string) *SPath {
+func Get(root string, cache bool) *SPath {
    return pathsMap.GetOrSetFuncLock(root, func() interface{} {
-        return New(root)
+        return New(root, cache)
    }).(*SPath)
 }

 // 检索root目录(必须为绝对路径)下面的name文件的绝对路径，indexFiles用于指定当检索到的结果为目录时，同时检索是否存在这些indexFiles文件
 func Search(root string, name string, indexFiles...string) (filePath string, isDir bool) {
-    return Get(root).Search(name, indexFiles...)
+    return Get(root, false).Search(name, indexFiles...)
 }

+// 检索root目录(必须为绝对路径)下面的name文件的绝对路径，indexFiles用于指定当检索到的结果为目录时，同时检索是否存在这些indexFiles文件
+func SearchWithCache(root string, name string, indexFiles...string) (filePath string, isDir bool) {
+    return Get(root, true).Search(name, indexFiles...)
+}

 // 设置搜索路径，只保留当前设置项，其他搜索路径被清空
 func (sp *SPath) Set(path string) (realPath string, err error) {
@ -88,8 +95,9 @@ func (sp *SPath) Set(path string) (realPath string, err error) {
            }
        }
        sp.paths.Clear()
-        sp.cache.Clear()
-
+        if sp.cache != nil {
+            sp.cache.Clear()
+        }
        sp.paths.Append(realPath)
        sp.updateCacheByPath(realPath)
        sp.addMonitorByPath(realPath)
@ -128,9 +136,39 @@ func (sp *SPath) Add(path string) (realPath string, err error) {
 }

 // 给定的name只是相对文件路径，找不到该文件时，返回空字符串;
-// 当给定indexFiles时，如果name时一个目录，那么会进一步检索其下对应的indexFiles文件是否存在，存在则返回indexFile绝对路径；
+// 当给定indexFiles时，如果name是一个目录，那么会进一步检索其下对应的indexFiles文件是否存在，存在则返回indexFile绝对路径；
 // 否则返回name目录绝对路径。
 func (sp *SPath) Search(name string, indexFiles...string) (filePath string, isDir bool) {
+    // 不使用缓存
+    if sp.cache == nil {
+        sp.paths.LockFunc(func(array []string) {
+            path := ""
+            for _, v := range array {
+                path = v + gfile.Separator + name
+                if stat, err := os.Stat(path); !os.IsNotExist(err) {
+                    filePath = path
+                    isDir    = stat.IsDir()
+                    break
+                }
+            }
+        })
+        if len(indexFiles) > 0 && isDir {
+            if name == "/" {
+                name = ""
+            }
+            path := ""
+            for _, file := range indexFiles {
+                path = filePath + gfile.Separator + file
+                if gfile.Exists(path) {
+                    filePath = path
+                    isDir    = false
+                    break
+                }
+            }
+        }
+        return
+    }
+    // 使用缓存功能
    name = sp.formatCacheName(name)
    if v := sp.cache.Get(name); v != "" {
        filePath, isDir = sp.parseCacheValue(v)
@ -151,6 +189,9 @@ func (sp *SPath) Search(name string, indexFiles...string) (filePath string, isDi
 // 从搜索路径中移除指定的文件，这样该文件无法给搜索。
 // path可以是绝对路径，也可以相对路径。
 func (sp *SPath) Remove(path string) {
+    if sp.cache == nil {
+        return
+    }
    if gfile.Exists(path) {
        for _, v := range sp.paths.Slice() {
            name := gstr.Replace(path, v, "")
@ -170,6 +211,9 @@ func (sp *SPath) Paths() []string {

 // 返回当前对象缓存的所有路径列表
 func (sp *SPath) AllPaths() []string {
+    if sp.cache == nil {
+        return nil
+    }
    paths := sp.cache.Keys()
    if len(paths) > 0 {
        sort.Strings(paths)
@ -181,82 +225,3 @@ func (sp *SPath) AllPaths() []string {
 func (sp *SPath) Size() int {
    return sp.paths.Len()
 }
-
-// 递归添加目录下的文件
-func (sp *SPath) updateCacheByPath(path string) {
-    sp.addToCache(path, path)
-}
-
-// 格式化name返回符合规范的缓存名称，分隔符号统一为'/'，且前缀必须以'/'开头(类似HTTP URI).
-func (sp *SPath) formatCacheName(name string) string {
-    if runtime.GOOS != "linux" {
-        name = gstr.Replace(name, "\\", "/")
-    }
-    return "/" + strings.Trim(name, "./")
-}
-
-// 根据path计算出对应的缓存name, dirPath为检索根目录路径
-func (sp *SPath) nameFromPath(filePath, rootPath string) string {
-    name  := gstr.Replace(filePath, rootPath, "")
-    name   = sp.formatCacheName(name)
-    return name
-}
-
-// 按照一定数据结构生成缓存的数据项字符串
-func (sp *SPath) makeCacheValue(filePath string, isDir bool) string {
-    if isDir {
-        return filePath + "_D_"
-    }
-    return filePath + "_F_"
-}
-
-// 按照一定数据结构解析数据项字符串
-func (sp *SPath) parseCacheValue(value string) (filePath string, isDir bool) {
-    if value[len(value) - 2 : len(value) - 1][0] == 'F' {
-        return value[: len(value) - 3], false
-    }
-    return value[: len(value) - 3], true
-}
-
-// 添加path到缓存中(递归)
-func (sp *SPath) addToCache(filePath, rootPath string) {
-    // 首先添加自身
-    idDir := gfile.IsDir(filePath)
-    sp.cache.SetIfNotExist(sp.nameFromPath(filePath, rootPath), sp.makeCacheValue(filePath, idDir))
-    // 如果添加的是目录，那么需要递归添加
-    if idDir {
-        if files, err := gfile.ScanDir(filePath, "*", true); err == nil {
-            //fmt.Println("gspath add to cache:", filePath, files)
-            for _, path := range files {
-                sp.cache.SetIfNotExist(sp.nameFromPath(path, rootPath), sp.makeCacheValue(path, gfile.IsDir(path)))
-            }
-        } else {
-            //fmt.Errorf(err.Error())
-        }
-    }
-}
-
-// 添加文件目录监控(递归)，当目录下的文件有更新时，会同时更新缓存。
-// 这里需要注意的点是，由于添加监听是递归添加的，那么假如删除一个目录，那么该目录下的文件(包括目录)也会产生一条删除事件，总共会产生N条事件。
-func (sp *SPath) addMonitorByPath(path string) {
-    gfsnotify.Add(path, func(event *gfsnotify.Event) {
-        //glog.Debug(event.String())
-        switch {
-            case event.IsRemove():
-                sp.cache.Remove(sp.nameFromPath(event.Path, path))
-
-            case event.IsRename():
-                if !gfile.Exists(event.Path) {
-                    sp.cache.Remove(sp.nameFromPath(event.Path, path))
-                }
-
-            case event.IsCreate():
-                sp.addToCache(event.Path, path)
-        }
-    }, true)
-}
-
-// 删除监听(递归)
-func (sp *SPath) removeMonitorByPath(path string) {
-    gfsnotify.Remove(path)
-}
--- a/g/os/gspath/gspath_cache.go
+++ b/g/os/gspath/gspath_cache.go
@ -0,0 +1,109 @@
+// 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 gspath implements file index and search for folders.
+// 
+
+package gspath
+
+import (
+    "github.com/gogf/gf/g/os/gfile"
+    "github.com/gogf/gf/g/os/gfsnotify"
+    "github.com/gogf/gf/g/text/gstr"
+    "runtime"
+    "strings"
+)
+
+// 递归添加目录下的文件
+func (sp *SPath) updateCacheByPath(path string) {
+    if sp.cache == nil {
+        return
+    }
+    sp.addToCache(path, path)
+}
+
+// 格式化name返回符合规范的缓存名称，分隔符号统一为'/'，且前缀必须以'/'开头(类似HTTP URI).
+func (sp *SPath) formatCacheName(name string) string {
+    if runtime.GOOS != "linux" {
+        name = gstr.Replace(name, "\\", "/")
+    }
+    return "/" + strings.Trim(name, "./")
+}
+
+// 根据path计算出对应的缓存name, dirPath为检索根目录路径
+func (sp *SPath) nameFromPath(filePath, rootPath string) string {
+    name  := gstr.Replace(filePath, rootPath, "")
+    name   = sp.formatCacheName(name)
+    return name
+}
+
+// 按照一定数据结构生成缓存的数据项字符串
+func (sp *SPath) makeCacheValue(filePath string, isDir bool) string {
+    if isDir {
+        return filePath + "_D_"
+    }
+    return filePath + "_F_"
+}
+
+// 按照一定数据结构解析数据项字符串
+func (sp *SPath) parseCacheValue(value string) (filePath string, isDir bool) {
+    if value[len(value) - 2 : len(value) - 1][0] == 'F' {
+        return value[: len(value) - 3], false
+    }
+    return value[: len(value) - 3], true
+}
+
+// 添加path到缓存中(递归)
+func (sp *SPath) addToCache(filePath, rootPath string) {
+    if sp.cache == nil {
+        return
+    }
+    // 首先添加自身
+    idDir := gfile.IsDir(filePath)
+    sp.cache.SetIfNotExist(sp.nameFromPath(filePath, rootPath), sp.makeCacheValue(filePath, idDir))
+    // 如果添加的是目录，那么需要递归添加
+    if idDir {
+        if files, err := gfile.ScanDir(filePath, "*", true); err == nil {
+            //fmt.Println("gspath add to cache:", filePath, files)
+            for _, path := range files {
+                sp.cache.SetIfNotExist(sp.nameFromPath(path, rootPath), sp.makeCacheValue(path, gfile.IsDir(path)))
+            }
+        } else {
+            //fmt.Errorf(err.Error())
+        }
+    }
+}
+
+// 添加文件目录监控(递归)，当目录下的文件有更新时，会同时更新缓存。
+// 这里需要注意的点是，由于添加监听是递归添加的，那么假如删除一个目录，那么该目录下的文件(包括目录)也会产生一条删除事件，总共会产生N条事件。
+func (sp *SPath) addMonitorByPath(path string) {
+    if sp.cache == nil {
+        return
+    }
+    gfsnotify.Add(path, func(event *gfsnotify.Event) {
+        //glog.Debug(event.String())
+        switch {
+            case event.IsRemove():
+                sp.cache.Remove(sp.nameFromPath(event.Path, path))
+
+            case event.IsRename():
+                if !gfile.Exists(event.Path) {
+                    sp.cache.Remove(sp.nameFromPath(event.Path, path))
+                }
+
+            case event.IsCreate():
+                sp.addToCache(event.Path, path)
+        }
+    }, true)
+}
+
+// 删除监听(递归)
+func (sp *SPath) removeMonitorByPath(path string) {
+    if sp.cache == nil {
+        return
+    }
+    gfsnotify.Remove(path)
+}
--- a/g/os/gspath/gspath_test.go
+++ b/g/os/gspath/gspath_test.go
@ -1,37 +0,0 @@
-// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-package gspath
-
-import (
-    "testing"
-)
-
-var (
-    sp = New()
-)
-
-func init() {
-    sp.Add("/Users/john/Temp")
-}
-
-func Benchmark_Search(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        sp.Search("1")
-    }
-}
-
-func Benchmark_Search_None(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        sp.Search("1000")
-    }
-}
-
-func Benchmark_Search_IndexFiles(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        sp.Search("1", "index.html")
-    }
-}
--- a/g/os/gview/gview.go
+++ b/g/os/gview/gview.go
@ -54,7 +54,7 @@ func checkAndInitDefaultView() {
        // gfile.MainPkgPath() 用以判断是否开发环境
        mainPkgPath := gfile.MainPkgPath()
        if gfile.MainPkgPath() == "" {
-            viewObj = New(gfile.SelfDir())
+            viewObj = New(gfile.Pwd())
        } else {
            viewObj = New(mainPkgPath)
        }
--- a/g/os/gview/internal/text/text.go
+++ b/g/os/gview/internal/text/text.go
@ -1,3 +1,3 @@
-// from golang-1.11.2
+// from golang-1.11.2 text/template
 // 1. remove "<no value>" when template variable does not exist;
 package text
--- a/g/test/gtest/gtest.go
+++ b/g/test/gtest/gtest.go
@ -232,7 +232,7 @@ func AssertNI(value, expect interface{}) {

 // 提示错误不退出进程执行
 func Error(message...interface{}) {
-    fmt.Fprintf(os.Stderr, "[ERROR] %s\n%s", fmt.Sprint(message...), getBacktrace())
+    panic(fmt.Sprintf("[ERROR] %s", fmt.Sprint(message...)))
 }

 // 提示错误并退出进程执行
--- a/g/text/gstr/gstr.go
+++ b/g/text/gstr/gstr.go
@ -59,6 +59,20 @@ func ReplaceI(origin, search, replace string, count...int) string {
    return origin
 }

+// Count counts the number of <substr> appears in <s>. It returns 0 if no <substr> found in <s>.
+//
+// 计算字符串substr在字符串s中出现的次数，如果没有在s中找到substr，那么返回0。
+func Count(s, substr string) int {
+    return strings.Count(s, substr)
+}
+
+// Count counts the number of <substr> appears in <s>, case-insensitive. It returns 0 if no <substr> found in <s>.
+//
+// (非大小写敏感)计算字符串substr在字符串s中出现的次数，如果没有在s中找到substr，那么返回0。
+func CountI(s, substr string) int {
+    return strings.Count(ToLower(s), ToLower(substr))
+}
+
 // Replace string by array/slice.
 //
 // 使用map进行字符串替换(大小写敏感)
@ -574,7 +588,7 @@ func HideStr(str string, percent int, hide string) string {
    buffer.WriteString(string(hideStr))
    buffer.WriteString(string(rs[start + hideLen : ]))
    if len(array) > 1 {
-        buffer.WriteString(array[1])
+        buffer.WriteString("@" + array[1])
    }
    return buffer.String()
 }
--- a/g/text/gstr/gstr_parse.go
+++ b/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
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
John	8e84e5b0f3	update comment of gredis	2019-03-22 11:22:03 +08:00
John	a42e6b0c45	ignore private attribute of struct in gconv/gvalid	2019-03-22 10:12:43 +08:00
John	51bb7a9854	ignore private attribute of struct in gconv/gvalid	2019-03-22 10:12:15 +08:00
John	62580b5719	add examples for gredis	2019-03-21 23:51:57 +08:00
John	15cfd5ce5c	add g.Export	2019-03-21 18:21:53 +08:00
John	11c89c4090	fix issue in GetOrSetFuncLock of gmap/gcache; add gutil.IsEmpty/Export functions	2019-03-21 18:20:20 +08:00
John	4a12cb9f27	version updates	2019-03-21 10:52:12 +08:00
John	32f575eddd	update unit test of gins	2019-03-21 10:36:24 +08:00
John	fbb4cb3b1c	add more unit test cases for gredis	2019-03-21 10:04:53 +08:00
John	c9d2d5e8ab	add configuration support for maxIdle/maxActive/idleTimeout/maxConnLifetime of gredis; update gjson.Append/Len functions; add more unit test cases for gredis/gins/gstr/gjson	2019-03-21 00:14:23 +08:00
John	93763192f2	version updates	2019-03-19 17:55:02 +08:00
John	80e0eae6b0	add TLSConfig support for ghttp.Server	2019-03-19 17:48:37 +08:00
John	4e3d735b90	add logging for gcron	2019-03-19 13:58:18 +08:00
John	60e5a7da28	add more unit test cases for grand/gstr	2019-03-18 23:52:25 +08:00
John	997b5ba889	README updates	2019-03-18 14:10:30 +08:00
John	b3e7ca1963	travis updates	2019-03-18 14:05:46 +08:00
John	5a82d695c1	mv greuseport to a new repo	2019-03-18 13:56:16 +08:00
John	64a0427150	travis updates	2019-03-18 13:34:51 +08:00
John	bca5532df8	version updates	2019-03-17 22:36:58 +08:00
John	72eeadd9aa	Merge branch 'master' into develop	2019-03-17 22:31:15 +08:00
John	0af55794f6	add more unit test cases for gdb	2019-03-17 22:26:41 +08:00
John	25a6c53533	add unit test cases for gfsnotify	2019-03-15 14:54:01 +08:00
John	9f9172c775	update unit test cases of package gconv	2019-03-15 09:05:56 +08:00
John	320e0db417	fix int-overflow issue in gconv.String when converting int64 to string; add more unit test cases for package gconv	2019-03-15 00:22:39 +08:00
John	cb8362d447	update unit test cases of package gins	2019-03-14 23:28:56 +08:00
John	45a83fc53c	unit test cases update for package gins	2019-03-14 00:23:46 +08:00
John	3411bd1c1d	merge master	2019-03-13 22:41:00 +08:00
John	6ab0a77364	add more defaulr searching paths for g.Config()	2019-03-13 22:12:59 +08:00
John	281bae4116	unit test cases update for package gins	2019-03-13 09:11:50 +08:00
John	218c692fe0	update unit test cases	2019-03-12 23:56:09 +08:00
John	fa69b581e1	update unit test cases	2019-03-12 23:50:30 +08:00
John	bd0baceeca	update unit test cases	2019-03-12 23:47:27 +08:00
John	e71c837472	update unit test cases	2019-03-12 23:45:44 +08:00
John	782aaabd07	add more unit test cases for gins; update text/template for gview	2019-03-12 23:26:10 +08:00
John	8ae9276732	add disable cache feature option for package gspath	2019-03-12 00:24:31 +08:00
John	79a3aa5916	add more unit test cases for package gvalid	2019-03-11 22:58:21 +08:00
John	733c5db228	version updates	2019-03-11 22:33:43 +08:00
John	6171c621a7	fix issue in missing customed error messages in package gvalid	2019-03-11 22:33:20 +08:00
John	802568856c	version updates	2019-03-11 16:35:44 +08:00
John	127fb67185	add session id check in session object initialzing	2019-03-11 16:33:51 +08:00
John	5db039bbce	gdb.Model updates, rename Alterable function to Safe, change gdb.Model alterable in default, update Where function to support more cases when using map as its param, add more unit test cases for gdb.Model	2019-03-11 16:14:55 +08:00
John	8a3365d18e	ghttp comment updates	2019-03-10 00:39:34 +08:00
John	2ae5b1a4f8	add more unit test cases for ghttp.Server	2019-03-10 00:35:03 +08:00
John	f9515d7126	version updates	2019-03-09 10:20:11 +08:00
John	b56679a97c	revert g.Map to map[string]interface{}, add g.MapAnyAny	2019-03-09 10:17:21 +08:00
John	d1b123964a	README updates	2019-03-08 21:07:18 +08:00
John	991f7c4958	ghttp.Response updates	2019-03-08 19:03:22 +08:00
John	770619c39e	update unit test cases og gcron	2019-03-08 18:27:11 +08:00
John	4ad5450b80	gtest updates; remove one unit test case of gconv.Struct	2019-03-08 18:18:29 +08:00
John	49ce7fe885	fix data race issue of gqueue	2019-03-08 17:54:50 +08:00
John	e66f63262b	add more unit test cases for ghttp.Server	2019-03-08 17:31:30 +08:00