version updates

.travis.yml

@@ -14,6 +14,7 @@ env:
 
 services:
   - mysql
+  - redis-server
 
 addons:
   hosts:

TODO.MD

@@ -57,7 +57,7 @@
 1. 更新跨域请求CORS相关功能文档；
 1. ghttp的热重启的本地进程端口监听，在不使用该特性时默认关闭掉；
 1. gcfg包目前允许添加重复的目录路径，需要在SetPath/AddPath时判断重复性，不能添加重复的路径；
-
+1. gdb执行数据写入时，如果参数为struct/[]struct，自动映射与表字段对应关系，不再使用gconv标签标识；
 
 
 

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
 }

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
 }

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
 }

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
 }

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
 }

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
 }

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

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

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

g/container/gmap/gmap_int_interface_map.go

@@ -231,8 +231,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)
 }
 

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

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

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

g/container/gmap/gmap_string_interface_map.go

@@ -224,15 +224,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)
 }
 

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

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
     }

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
 }

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
 }

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
 }

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)

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...)
 }
 
 // 获得缓存对象

g/database/gdb/gdb_func.go

@@ -78,8 +78,9 @@ func formatCondition(where interface{}, args []interface{}) (newWhere string, ne
         default:
             buffer.WriteString(gconv.String(where))
     }
+    // 没有任何条件查询参数，直接返回
     if buffer.Len() == 0 {
-        buffer.WriteString("1=1")
+        return "", args
     }
     newWhere = buffer.String()
     tmpArgs  = append(tmpArgs, args...)
@@ -125,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,

g/database/gdb/gdb_model.go

@@ -247,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()
@@ -420,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 ...)
 	}
 }
 
@@ -434,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...)
 	}
 }
 

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

g/database/gdb/gdb_unit_init_test.go

@@ -1,11 +1,20 @@
 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 +35,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 +50,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 +76,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
+}

g/database/gdb/gdb_unit_method_test.go

@@ -9,6 +9,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 +153,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) {

g/database/gdb/gdb_unit_model_test.go

@@ -90,29 +90,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 +183,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) {

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"
+    "errors"
+    "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"
+    "strconv"
+    "strings"
+    "time"
 )
 
 const (
@@ -110,11 +110,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,
@@ -546,6 +542,11 @@ func (j *Json) Get(pattern...string) interface{} {
     return nil
 }
 
+// 判断锁给定pattern是否数据存在
+func (j *Json) Contains(pattern...string) bool {
+    return j.Get(pattern...) != nil
+}
+
 // 计算指定pattern的元素长度(pattern对应数据类型为map[string]interface{}/[]interface{}时有效)
 func (j *Json) Len(pattern string) int {
     p := j.getPointerByPattern(pattern)

g/frame/gins/gins.go

@@ -73,7 +73,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) {
@@ -98,32 +98,18 @@ func Config(file...string) *gcfg.Config {
             envPath  := cmdenv.Get("gf.gcfg.path").String()
             selfPath := gfile.SelfDir()
             mainPath := gfile.MainPkgPath()
-
             config   := gcfg.New(pwdPath, configFile)
-            // 添加工作目录下的config目录
-            if path := envPath + gfile.Separator + "config"; gfile.Exists(path) {
-                config.AddPath(path)
-            }
             // 自定义的环境变量/启动参数路径，优先级最高，覆盖默认的工作目录
             if envPath != "" && gfile.Exists(envPath) {
                 config.SetPath(envPath)
-                if path := envPath + gfile.Separator + "config"; gfile.Exists(path) {
-                    config.AddPath(path)
-                }
             }
             // 二进制文件执行目录
             if selfPath != "" && gfile.Exists(selfPath) {
                 config.AddPath(selfPath)
-                if path := selfPath + gfile.Separator + "config"; gfile.Exists(path) {
-                    config.AddPath(path)
-                }
             }
             // 开发环境源码main包目录
             if mainPath != "" && gfile.Exists(mainPath) {
                 config.AddPath(mainPath)
-                if path := mainPath + gfile.Separator + "config"; gfile.Exists(path) {
-                    config.AddPath(path)
-                }
             }
             return config
     }).(*gcfg.Config)

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

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

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

g/frame/gins/gins_redis_test.go

@@ -0,0 +1,78 @@
+// 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_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,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_Redis", gins.Config().Get("test"))
+
+        redisDefault := gins.Redis()
+        redisCache   := gins.Redis("cache")
+        gtest.AssertNE(redisDefault, nil)
+        gtest.AssertNE(redisCache,   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")
+    })
+}
+

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), "中国人")
+    })
+}
+

g/net/ghttp/ghttp_server_session.go

@@ -104,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)
@@ -141,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...)
 }

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

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 {

g/os/gcfg/gcfg.go

@@ -66,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 {
@@ -133,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 {
@@ -141,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
@@ -191,6 +191,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{} {

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
 }

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

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

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 {

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

g/os/gfsnotify/gfsnotify_watcher_loop.go

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

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

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

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

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

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

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

g/text/gstr/gstr_z_unit_basic_test.go

@@ -235,39 +235,6 @@ func Test_Shuffle(t *testing.T) {
     })
 }
 
-func Test_Trim(t *testing.T) {
-    gtest.Case(t, func() {
-        gtest.Assert(gstr.Trim(" 123456\n "), "123456")
-        gtest.Assert(gstr.Trim("#123456#;", "#;"), "123456")
-    })
-}
-
-func Test_TrimRight(t *testing.T) {
-    gtest.Case(t, func() {
-        gtest.Assert(gstr.TrimRight(" 123456\n "), " 123456")
-        gtest.Assert(gstr.TrimRight("#123456#;", "#;"), "#123456")
-    })
-}
-
-func Test_TrimRightStr(t *testing.T) {
-    gtest.Case(t, func() {
-        gtest.Assert(gstr.TrimRightStr("gogo我爱gogo", "go"), "gogo我爱")
-    })
-}
-
-func Test_TrimLeft(t *testing.T) {
-    gtest.Case(t, func() {
-        gtest.Assert(gstr.TrimLeft(" \r123456\n "), "123456\n ")
-        gtest.Assert(gstr.TrimLeft("#;123456#;", "#;"), "123456#;")
-    })
-}
-
-func Test_TrimLeftStr(t *testing.T) {
-    gtest.Case(t, func() {
-        gtest.Assert(gstr.TrimLeftStr("gogo我爱gogo", "go"), "我爱gogo")
-    })
-}
-
 func Test_Split(t *testing.T) {
     gtest.Case(t, func() {
         gtest.Assert(gstr.Split("1.2", "."), []string{"1", "2"})
@@ -335,4 +302,24 @@ func Test_QuoteMeta(t *testing.T) {
     gtest.Case(t, func() {
         gtest.Assert(gstr.QuoteMeta(`.\+*?[^]($)`), `\.\\\+\*\?\[\^\]\(\$\)`)
     })
+}
+
+func Test_Count(t *testing.T) {
+    gtest.Case(t, func() {
+        s := "abcdaAD"
+        gtest.Assert(gstr.Count(s, "0"), 0)
+        gtest.Assert(gstr.Count(s, "a"), 2)
+        gtest.Assert(gstr.Count(s, "b"), 1)
+        gtest.Assert(gstr.Count(s, "d"), 1)
+    })
+}
+
+func Test_CountI(t *testing.T) {
+    gtest.Case(t, func() {
+        s := "abcdaAD"
+        gtest.Assert(gstr.CountI(s, "0"), 0)
+        gtest.Assert(gstr.CountI(s, "a"), 3)
+        gtest.Assert(gstr.CountI(s, "b"), 1)
+        gtest.Assert(gstr.CountI(s, "d"), 2)
+    })
 }

g/text/gstr/gstr_z_unit_trim_test.go

@@ -0,0 +1,48 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+// go test *.go -bench=".*"
+
+package gstr_test
+
+import (
+    "github.com/gogf/gf/g/test/gtest"
+    "github.com/gogf/gf/g/text/gstr"
+    "testing"
+)
+
+func Test_Trim(t *testing.T) {
+    gtest.Case(t, func() {
+        gtest.Assert(gstr.Trim(" 123456\n "), "123456")
+        gtest.Assert(gstr.Trim("#123456#;", "#;"), "123456")
+    })
+}
+
+func Test_TrimRight(t *testing.T) {
+    gtest.Case(t, func() {
+        gtest.Assert(gstr.TrimRight(" 123456\n "), " 123456")
+        gtest.Assert(gstr.TrimRight("#123456#;", "#;"), "#123456")
+    })
+}
+
+func Test_TrimRightStr(t *testing.T) {
+    gtest.Case(t, func() {
+        gtest.Assert(gstr.TrimRightStr("gogo我爱gogo", "go"), "gogo我爱")
+    })
+}
+
+func Test_TrimLeft(t *testing.T) {
+    gtest.Case(t, func() {
+        gtest.Assert(gstr.TrimLeft(" \r123456\n "), "123456\n ")
+        gtest.Assert(gstr.TrimLeft("#;123456#;", "#;"), "123456#;")
+    })
+}
+
+func Test_TrimLeftStr(t *testing.T) {
+    gtest.Case(t, func() {
+        gtest.Assert(gstr.TrimLeftStr("gogo我爱gogo", "go"), "我爱gogo")
+    })
+}

g/util/gconv/gconv.go

@@ -13,6 +13,7 @@ package gconv
 import (
     "encoding/json"
     "github.com/gogf/gf/g/encoding/gbinary"
+    "reflect"
     "strconv"
     "strings"
 )
@@ -22,6 +23,16 @@ type apiString interface {
     String() string
 }
 
+var (
+    // 为空的字符串
+    emptyStringMap = map[string]struct{}{
+        ""      : struct {}{},
+        "0"     : struct {}{},
+        "off"   : struct {}{},
+        "false" : struct {}{},
+    }
+)
+
 // 将变量i转换为字符串指定的类型t，非必须参数extraParams用以额外的参数传递
 func Convert(i interface{}, t string, extraParams...interface{}) interface{} {
     switch t {
@@ -63,6 +74,7 @@ func Convert(i interface{}, t string, extraParams...interface{}) interface{} {
     }
 }
 
+// 转换为二进制[]byte
 func Bytes(i interface{}) []byte {
     if i == nil {
         return nil
@@ -80,11 +92,11 @@ func String(i interface{}) string {
         return ""
     }
     switch value := i.(type) {
-        case int:     return strconv.Itoa(value)
+        case int:     return strconv.FormatInt(int64(value), 10)
         case int8:    return strconv.Itoa(int(value))
         case int16:   return strconv.Itoa(int(value))
         case int32:   return strconv.Itoa(int(value))
-        case int64:   return strconv.Itoa(int(value))
+        case int64:   return strconv.FormatInt(int64(value), 10)
         case uint:    return strconv.FormatUint(uint64(value), 10)
         case uint8:   return strconv.FormatUint(uint64(value), 10)
         case uint16:  return strconv.FormatUint(uint64(value), 10)
@@ -107,7 +119,7 @@ func String(i interface{}) string {
     }
 }
 
-//false: "", 0, false, off
+//false: false, "", 0, "false", "off", empty slice/map
 func Bool(i interface{}) bool {
     if i == nil {
         return false
@@ -115,10 +127,27 @@ func Bool(i interface{}) bool {
     if v, ok := i.(bool); ok {
         return v
     }
-    if s := String(i); s != "" && s != "0" && s != "false" && s != "off" {
+    if s, ok := i.(string); ok {
+        if _, ok := emptyStringMap[s]; ok {
+            return false
+        }
         return true
     }
-    return false
+    rv := reflect.ValueOf(i)
+    switch rv.Kind() {
+        case reflect.Ptr:    return !rv.IsNil()
+        case reflect.Map:    fallthrough
+        case reflect.Array:  fallthrough
+        case reflect.Slice:  return rv.Len() != 0
+        case reflect.Struct: return true
+        default:
+            s := String(i)
+            if _, ok := emptyStringMap[s]; ok {
+                return false
+            }
+            return true
+
+    }
 }
 
 func Int(i interface{}) int {

g/util/gconv/gconv_slice.go

@@ -320,4 +320,24 @@ func Interfaces(i interface{}) []interface{} {
         }
         return array
     }
+}
+
+// 将类型转换为[]map[string]interface{}类型.
+func Maps(i interface{}) []map[string]interface{} {
+    if i == nil {
+        return nil
+    }
+    if r, ok := i.([]map[string]interface{}); ok {
+        return r
+    } else {
+        array := Interfaces(i)
+        if len(array) == 0 {
+            return nil
+        }
+        list := make([]map[string]interface{}, len(array))
+        for k, v := range array {
+            list[k] = Map(v)
+        }
+        return list
+    }
 }

g/util/gconv/gconv_z_unit_basic_test.go

@@ -15,20 +15,23 @@ import (
 
 func Test_Basic(t *testing.T) {
     gtest.Case(t, func() {
-        value := 123.456
-        gtest.AssertEQ(gconv.Int(value),     int(123))
-        gtest.AssertEQ(gconv.Int8(value),    int8(123))
-        gtest.AssertEQ(gconv.Int16(value),   int16(123))
-        gtest.AssertEQ(gconv.Int32(value),   int32(123))
-        gtest.AssertEQ(gconv.Int64(value),   int64(123))
-        gtest.AssertEQ(gconv.Uint(value),    uint(123))
-        gtest.AssertEQ(gconv.Uint8(value),   uint8(123))
-        gtest.AssertEQ(gconv.Uint16(value),  uint16(123))
-        gtest.AssertEQ(gconv.Uint32(value),  uint32(123))
-        gtest.AssertEQ(gconv.Uint64(value),  uint64(123))
-        gtest.AssertEQ(gconv.Float32(value), float32(123.456))
-        gtest.AssertEQ(gconv.Float64(value), float64(123.456))
-        gtest.AssertEQ(gconv.Bool(value),    true)
-        gtest.AssertEQ(gconv.String(value),  "123.456")
+        vint   := float32(123.456)
+        vint64 := int64(1552578474888)
+        gtest.AssertEQ(gconv.Int(vint),       int(123))
+        gtest.AssertEQ(gconv.Int8(vint),      int8(123))
+        gtest.AssertEQ(gconv.Int16(vint),     int16(123))
+        gtest.AssertEQ(gconv.Int32(vint),     int32(123))
+        gtest.AssertEQ(gconv.Int64(vint),     int64(123))
+        gtest.AssertEQ(gconv.Int64(vint),     int64(123))
+        gtest.AssertEQ(gconv.Uint(vint),      uint(123))
+        gtest.AssertEQ(gconv.Uint8(vint),     uint8(123))
+        gtest.AssertEQ(gconv.Uint16(vint),    uint16(123))
+        gtest.AssertEQ(gconv.Uint32(vint),    uint32(123))
+        gtest.AssertEQ(gconv.Uint64(vint),    uint64(123))
+        gtest.AssertEQ(gconv.Float32(vint),   float32(123.456))
+        gtest.AssertEQ(gconv.Float64(vint),   float64(123.456))
+        gtest.AssertEQ(gconv.Bool(vint),      true)
+        gtest.AssertEQ(gconv.String(vint),    "123.456")
+        gtest.AssertEQ(gconv.String(vint64),  "1552578474888")
     })
 }

g/util/gconv/gconv_z_unit_bool_test.go

@@ -0,0 +1,42 @@
+// 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 gconv_test
+
+import (
+    "github.com/gogf/gf/g/util/gconv"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+type boolStruct struct {
+
+}
+
+func Test_Bool(t *testing.T) {
+    gtest.Case(t, func() {
+        var i interface{} = nil
+        gtest.AssertEQ(gconv.Bool(i),          false)
+        gtest.AssertEQ(gconv.Bool(false),      false)
+        gtest.AssertEQ(gconv.Bool(nil),        false)
+        gtest.AssertEQ(gconv.Bool(0),          false)
+        gtest.AssertEQ(gconv.Bool("0"),        false)
+        gtest.AssertEQ(gconv.Bool(""),         false)
+        gtest.AssertEQ(gconv.Bool("false"),    false)
+        gtest.AssertEQ(gconv.Bool("off"),      false)
+        gtest.AssertEQ(gconv.Bool([]byte{}),   false)
+        gtest.AssertEQ(gconv.Bool([]string{}), false)
+        gtest.AssertEQ(gconv.Bool([]interface{}{}), false)
+        gtest.AssertEQ(gconv.Bool([]map[int]int{}), false)
+
+        gtest.AssertEQ(gconv.Bool("1"),           true)
+        gtest.AssertEQ(gconv.Bool("on"),          true)
+        gtest.AssertEQ(gconv.Bool(1),             true)
+        gtest.AssertEQ(gconv.Bool(123.456),       true)
+        gtest.AssertEQ(gconv.Bool(boolStruct{}),  true)
+        gtest.AssertEQ(gconv.Bool(&boolStruct{}), true)
+    })
+}

g/util/gconv/gconv_z_unit_string_test.go

@@ -0,0 +1,65 @@
+// 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 gconv_test
+
+import (
+    "github.com/gogf/gf/g/util/gconv"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+
+type stringStruct1 struct {
+    Name string
+}
+
+type stringStruct2 struct {
+    Name string
+}
+
+func (s *stringStruct1) String() string {
+    return s.Name
+}
+
+func Test_String(t *testing.T) {
+    gtest.Case(t, func() {
+        gtest.AssertEQ(gconv.String(int(123)),     "123")
+        gtest.AssertEQ(gconv.String(int(-123)),    "-123")
+        gtest.AssertEQ(gconv.String(int8(123)),    "123")
+        gtest.AssertEQ(gconv.String(int8(-123)),   "-123")
+        gtest.AssertEQ(gconv.String(int16(123)),   "123")
+        gtest.AssertEQ(gconv.String(int16(-123)),  "-123")
+        gtest.AssertEQ(gconv.String(int32(123)),   "123")
+        gtest.AssertEQ(gconv.String(int32(-123)),  "-123")
+        gtest.AssertEQ(gconv.String(int64(123)),   "123")
+        gtest.AssertEQ(gconv.String(int64(-123)),  "-123")
+        gtest.AssertEQ(gconv.String(int64(1552578474888)), "1552578474888")
+        gtest.AssertEQ(gconv.String(int64(-1552578474888)), "-1552578474888")
+
+        gtest.AssertEQ(gconv.String(uint(123)),   "123")
+        gtest.AssertEQ(gconv.String(uint8(123)),  "123")
+        gtest.AssertEQ(gconv.String(uint16(123)), "123")
+        gtest.AssertEQ(gconv.String(uint32(123)), "123")
+        gtest.AssertEQ(gconv.String(uint64(155257847488898765)), "155257847488898765")
+
+        gtest.AssertEQ(gconv.String(float32(123.456)),  "123.456")
+        gtest.AssertEQ(gconv.String(float32(-123.456)), "-123.456")
+        gtest.AssertEQ(gconv.String(float64(1552578474888.456)),  "1552578474888.456")
+        gtest.AssertEQ(gconv.String(float64(-1552578474888.456)), "-1552578474888.456")
+
+        gtest.AssertEQ(gconv.String(true),  "true")
+        gtest.AssertEQ(gconv.String(false), "false")
+
+        gtest.AssertEQ(gconv.String([]byte("bytes")), "bytes")
+
+        gtest.AssertEQ(gconv.String(stringStruct1{"john"}),  `{"Name":"john"}`)
+        gtest.AssertEQ(gconv.String(&stringStruct1{"john"}), "john")
+
+        gtest.AssertEQ(gconv.String(stringStruct2{"john"}),  `{"Name":"john"}`)
+        gtest.AssertEQ(gconv.String(&stringStruct2{"john"}), `{"Name":"john"}`)
+    })
+}

geg/other/test.go

@@ -2,10 +2,11 @@ package main
 
 import (
     "fmt"
+    "github.com/gogf/gf/g/os/gtime"
     "github.com/gogf/gf/g/util/gconv"
 )
 
 func main() {
-    t := gconv.GTime("2010-10-10 00:00:01")
-    fmt.Println(t.String())
+    //t := gconv.GTime("2010-10-10 00:00:01")
+    fmt.Println(gconv.String(gtime.Millisecond()))
 }

version.go

@@ -1,5 +1,5 @@
 package gf
 
-const VERSION  = "v1.5.15"
+const VERSION  = "v1.5.16"
 const AUTHORS  = "john<john@goframe.org>"