add map key operator support in Where function for gdb

.gitee/ISSUE_TEMPLATE.MD

@@ -0,0 +1,34 @@
+<!-- 为更高效率地交流并解决问题，请按照以下模板提交issue，感谢！ -->
+
+### 1. 您当前使用的`Go`版本，及系统版本、系统架构？
+
+<!-- 使用 `go version` 命令查看，期望的结果如：`go 1.12, linux/amd64` -->
+
+
+### 2. 您当前使用的`GoFrame`框架版本？
+
+<!-- 框架版本可以查看自己项目下的 `go.mod`，或者框架文件 `version.go` -->
+
+
+### 3. 更新到最新的框架版本是否能够解决问题？
+
+<!-- 务必检查是否相同问题已在新版本中已修复 -->
+
+
+### 4. 问题描述？
+
+<!--
+请您尽可能地提供一份最短的，可复现问题的代码。
+代码尽可能地完整，最好是可以直接编译运行。
+-->
+
+
+
+### 5. 您期望得到的结果？
+
+
+
+### 6. 您实际得到的结果？
+
+
+

.github/ISSUE_TEMPLATE.MD

@@ -0,0 +1,36 @@
+<!-- Please answer these questions before submitting your issue. Thanks! -->
+
+### 1. What version of `Go` and system type/arch are you using?
+
+<!-- 
+Please paste the output of command `go version` from your terminal.
+What expect to see is like: `go 1.12, linux/amd64`
+-->
+
+
+### 2. What version of `GoFrame` are you using?
+
+<!-- You can find the GF version from your `go.mod`, or from the `version.go` in `GF` -->
+
+
+### 3. Can this issue be reproduced with the latest release?
+
+
+
+### 4. What did you do?
+
+<!--
+If possible, provide a copy of shortest codes for reproducing the error.
+A complete runnable program is best.
+-->
+
+
+
+### 5. What did you expect to see?
+
+
+
+### 6. What did you see instead?
+
+
+

.travis.yml

@@ -1,7 +1,8 @@
 language: go
 
 go:
-- "1.11.x"
+  - "1.11.x"
+  - "1.12.x"
 
 branches:
   only:
@@ -9,25 +10,28 @@ branches:
   - develop
 
 env:
-- GO111MODULE=on
+  - GO111MODULE=on
 
 services:
-- mysql
+  - mysql
+
+addons:
+  hosts:
+    - local
 
 before_install:
-- pwd
+  - pwd
 
 install:
-- pwd
+  - cat /etc/hosts
 
 script:
-- cd g
-- GOARCH=386 go test -v ./...
-- GOARCH=amd64 go test -v ./... -race -coverprofile=coverage.txt -covermode=atomic
-
+  - cd g
+  - GOARCH=386 go test -v ./...
+  - GOARCH=amd64 go test -v ./... -race -coverprofile=coverage.txt -covermode=atomic
 
 after_success:
-- bash <(curl -s https://codecov.io/bash)
+  - bash <(curl -s https://codecov.io/bash)
 
 
 

README.MD

@@ -4,17 +4,16 @@
 [![Go Doc](https://godoc.org/github.com/gogf/gf?status.svg)](https://godoc.org/github.com/gogf/gf) 
 [![Build Status](https://travis-ci.org/gogf/gf.svg?branch=master)](https://travis-ci.org/gogf/gf) 
 [![Go Report](https://goreportcard.com/badge/github.com/gogf/gf)](https://goreportcard.com/report/github.com/gogf/gf) 
-[![Documents](https://img.shields.io/badge/docs-100%25-green.svg)](https://goframe.org) 
+[![Code Coverage](https://codecov.io/gh/gogf/gf/branch/master/graph/badge.svg)](https://codecov.io/gh/gogf/gf/branch/master)
 [![License](https://img.shields.io/github/license/gogf/gf.svg?style=flat)](https://github.com/gogf/gf)
 [![Language](https://img.shields.io/badge/language-go-blue.svg)](https://github.com/gogf/gf)
 [![Release](https://img.shields.io/github/release/gogf/gf.svg?style=flat)](https://github.com/gogf/gf/releases)
 
 <!--
-[![Code Coverage](https://codecov.io/gh/gogf/gf/branch/master/graph/badge.svg)](https://codecov.io/gh/gogf/gf)
-[![Code Helper](https://www.codetriage.com/gogf/gf/badges/users.svg)](https://www.codetriage.com/gogf/gf) 
---> 
+GoFrame is a modular, loose-coupled, production-ready and most-powerful application development framework of golang. Providing a series of core components and dozens of practical modules, such as: cache, logging, containers, timer, validator, database orm, etc. Supporting web server integrated with router, cookie, session, logger, configure, template, https, hooks, rewrites and many more features. 
+-->
 
-`GF(GoFrame)` is a modular, loose-coupled and production-ready application development framework written in Go. Providing a series of core components and dozens of practical modules, such as: cache, logging, array/queue/set/map, timer/timing tasks, file/memory lock, object pool, validator, database ORM, etc. Supporting web server with graceful server, hot updates, multi-domain, multi-port, multi-service, HTTP/HTTPS, dynamic/hook routing, rewrite rules and many more features. 
+`GF(GoFrame)` is a modular, loose-coupled, production-ready and most-powerful application development framework of golang. Providing a series of core components and dozens of practical modules, such as: memcache, configure, validator, logging, array/queue/set/map containers, timer/timing tasks, file/memory lock, object pool, database ORM, etc. Supporting web server integrated with router, cookie, session, logger, template, https, hooks, rewrites and many more features. 
 
 # Installation
 ```

README_ZH.MD

@@ -81,6 +81,14 @@ func main() {
 
 `GF` 使用非常友好的 [MIT](LICENSE) 开源协议进行发布，永久`100%`开源免费。
 
+# 捐赠
+
+捐赠支持`GF`框架的研发，
+请在捐赠时备注您的`github`/`gitee`账号名称。
+
+<a href="https://goframe.org/images/donate.png" target="_blank">
+<img src="https://goframe.org/images/donate.png" width="300"/>
+</a>
 
 # 贡献者(TOP 10)
 

RELEASE.MD

@@ -1,3 +1,38 @@
+# `v1.5.8` (2019-02-28)
+
+## 新特性
+1. 主库从`gitee`迁移到了`github`( https://github.com/gogf/gf )，`gitee`作为镜像站，用于国内的代码贡献及ISSUE提交，迁移说明详见：https://goframe.org/upgradeto150
+1. 对常用的`container`数组模块: `garray`做了大量改进/完善工作，新增大量常用方法，并完善单元测试用例及方法注释，详见API文档：https://godoc.org/github.com/gogf/gf/g/container/garray
+1. 对常用的`container`集合模块: `gset`做了大量改进/完善工作，新增大量常用方法，并完善单元测试用例及方法注释，详见API文档：https://godoc.org/github.com/gogf/gf/g/container/gset
+1. 对常用的`container`MAP模块: `gmap`做了大量改进/完善工作，新增大量常用方法，并完善单元测试用例及方法注释，详见API文档：https://godoc.org/github.com/gogf/gf/g/container/gmap
+1. 对常用的字符串模块: `gstr`做了大量改进/完善工作，新增大量常用方法，并完善单元测试用例及方法注释，详见API文档：https://godoc.org/github.com/gogf/gf/g/text/gstr
+1. 改进`gform`中对`struct`/`*struct`参数的支持，`*Insert/*Save/*Replace/*Update/Where/Data`方法的参数调整为`interface{}`类型，并支持任意类型的: `string/map/slice/struct/*struct`参数传递，具体请参考：https://goframe.org/database/orm/chaining
+1. 新增/完善若干模块的单元测试用例, 包括：`gvalid`/`gregex`/`garray`/`gset`/`gmap`/`gstr`/`gconv`/`ghttp`/`gdb`；
+1. 由于`gkafka`模块比较重，且不是框架核心模块，因此将该模块迁移到新的仓库中独立管理，并去掉相关依赖包：https://github.com/gogf/gkafka
+1. 新增`greuseport`模块，用以实现TCP的`REUSEPORT`特性：https://godoc.org/github.com/gogf/gf/g/net/greuseport
+
+## 新功能/改进
+1. 去掉模板引擎内置变量中自动初始化`session`对象带来的内存占用问题；
+1. `ghttp.Client`改进，增加若干方法，详见：https://goframe.org/net/ghttp/client 
+1. `ghttp`分组路由增加`COMMON`方法，用以注册常用的`HTTP METHOD`(`GET/PUT/POST/DELETE`)路由；
+1. 更新框架依赖的`golang.org/x/sys`模块；
+1. 改进`gform`的批量操作(`Batch*`操作)返回结果对象，可以通过该结果对象获得批量操作准确的受影响记录行数；
+1. 将`gstr`/`gregex`模块从`util`分类迁移到了`text`分类目录下；
+1. 将`gtest`模块从`util`分类迁移到了`test`分类目录下；
+1. 完善`glog`方法注释；
+
+## Bug Fix
+1. 修复带点的邮件格式,用`gvalid.Check`的"`email`"规则不能匹配成功;
+1. 修复`gvalid.Check`在`regex`规则下的检查失败问题；
+1. 修复`gcron`模块定时规则中天和周不允许`?`符号的问题；
+1. 修复`ghttp.Server`在部分异常情况下仍然返回`200`状态码的问题；
+1. 修复`gfpool`模块中由于原子操作问题造成的高并发"内存泄露"问题；
+1. 修复分组路由注册对象/控制时，方法`Index`的路由仅能通过`/xxx/index`访问的问题；
+1. 修复模板引擎使用中，当不存在`config.toml`(即使没使用)配置文件时的报错问题；
+1. 其他一些修复；
+
+
+
 # `v1.4.6` (2019-01-24)
 
 ## 新特性

TODO.MD

@@ -52,7 +52,11 @@
 1. 从ghttp中剥离SESSION功能构成单独的模块gsession；
 1. 改进gproc进程间通信处理逻辑，提高稳定性，以应对进程间大批量的数据发送/接收；
 1. gdb的Data方法支持struct参数传入；
-
+1. gfcache依旧使用gcache作为缓存控制对象，不要使用gmap；
+1. 增加对ghttp路由注册的{.struct}/{.method}单元测试；
+1. 更新跨域请求CORS相关功能文档；
+1. ghttp的热重启的本地进程端口监听，在不使用该特性时默认关闭掉；
+1. gcfg包目前允许添加重复的目录路径，需要在SetPath/AddPath时判断重复性，不能添加重复的路径；
 
 
 

g/container/garray/garray_func.go

@@ -6,3 +6,15 @@
 
 package garray
 
+
+type apiSliceInterface interface {
+    Slice() []interface{}
+}
+
+type apiSliceInt interface {
+    Slice() []int
+}
+
+type apiSliceString interface {
+    Slice() []string
+}

g/container/garray/garray_normal_int.go

@@ -7,12 +7,12 @@
 package garray
 
 import (
+    "bytes"
     "github.com/gogf/gf/g/internal/rwmutex"
     "github.com/gogf/gf/g/util/gconv"
     "github.com/gogf/gf/g/util/grand"
     "math"
     "sort"
-    "strings"
 )
 
 type IntArray struct {
@@ -53,6 +53,20 @@ func NewIntArrayFrom(array []int, unsafe...bool) *IntArray {
     }
 }
 
+// Create an array from a copy of given slice <array>.
+// The param <unsafe> used to specify whether using array with un-concurrent-safety,
+// which is false in default, means concurrent-safe in default.
+//
+// 通过给定的slice拷贝创建数组对象，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
+func NewIntArrayFromCopy(array []int, unsafe...bool) *IntArray {
+    newArray := make([]int, len(array))
+    copy(newArray, array)
+    return &IntArray{
+        mu    : rwmutex.New(unsafe...),
+        array : newArray,
+    }
+}
+
 // Get value by index.
 //
 // 获取指定索引的数据项, 调用方注意判断数组边界。
@@ -233,13 +247,31 @@ func (a *IntArray) PopRight() int {
     return value
 }
 
-// Pop an random item from array.
+// PopRand picks an random item out of array.
 //
 // 随机将一个数据项移出数组，并返回该数据项。
 func (a *IntArray) PopRand() int {
     return a.Remove(grand.Intn(len(a.array)))
 }
 
+// PopRands picks <size> items out of array.
+//
+// 随机将size个数据项移出数组，并返回该数据项。
+func (a *IntArray) PopRands(size int) []int {
+    a.mu.Lock()
+    defer a.mu.Unlock()
+    if size > len(a.array) {
+        size = len(a.array)
+    }
+    array := make([]int, size)
+    for i := 0; i < size; i++ {
+        index   := grand.Intn(len(a.array))
+        array[i] = a.array[index]
+        a.array  = append(a.array[ : index], a.array[index + 1 : ]...)
+    }
+    return array
+}
+
 // Pop <size> items from the beginning of array.
 //
 // 将最左端(首部)的size个数据项移出数组，并返回该数据项。
@@ -425,17 +457,22 @@ func (a *IntArray) RLockFunc(f func(array []int)) *IntArray {
     return a
 }
 
-// Merge two arrays.
+// Merge two arrays. The parameter <array> can be any garray type or slice type.
+// The difference between Merge and Append is Append supports only specified slice type,
+// but Merge supports more variable types.
 //
-// 合并两个数组.
-func (a *IntArray) Merge(array *IntArray) *IntArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if a != array {
-        array.mu.RLock()
-        defer array.mu.RUnlock()
+// 合并两个数组, 支持任意的garray数组类型及slice类型.
+func (a *IntArray) Merge(array interface{}) *IntArray {
+    switch v := array.(type) {
+        case *Array:             a.Append(gconv.Ints(v.Slice())...)
+        case *IntArray:          a.Append(gconv.Ints(v.Slice())...)
+        case *StringArray:       a.Append(gconv.Ints(v.Slice())...)
+        case *SortedArray:       a.Append(gconv.Ints(v.Slice())...)
+        case *SortedIntArray:    a.Append(gconv.Ints(v.Slice())...)
+        case *SortedStringArray: a.Append(gconv.Ints(v.Slice())...)
+        default:
+            a.Append(gconv.Ints(array)...)
     }
-    a.array = append(a.array, array.array...)
     return a
 }
 
@@ -538,11 +575,19 @@ func (a *IntArray) SubSlice(offset, size int) []int {
     }
 }
 
-// Picks one or more random entries out of an array(a copy),
-// and returns the key (or keys) of the random entries.
+// Rand gets one random entry from array.
 //
-// 从数组中随机取出size个元素项，构成slice返回。
-func (a *IntArray) Rand(size int) []int {
+// 从数组中随机获得1个元素项(不删除)。
+func (a *IntArray) Rand() int {
+    a.mu.RLock()
+    defer a.mu.RUnlock()
+    return a.array[grand.Intn(len(a.array))]
+}
+
+// Rands gets one or more random entries from array(a copy).
+//
+// 从数组中随机拷贝size个元素项，构成slice返回。
+func (a *IntArray) Rands(size int) []int {
     a.mu.RLock()
     defer a.mu.RUnlock()
     if size > len(a.array) {
@@ -588,5 +633,12 @@ func (a *IntArray) Reverse() *IntArray {
 func (a *IntArray) Join(glue string) string {
     a.mu.RLock()
     defer a.mu.RUnlock()
-    return strings.Join(gconv.Strings(a.array), glue)
+    buffer := bytes.NewBuffer(nil)
+    for k, v := range a.array {
+        buffer.WriteString(gconv.String(v))
+        if k != len(a.array) - 1 {
+            buffer.WriteString(glue)
+        }
+    }
+    return buffer.String()
 }

g/container/garray/garray_normal_interface.go

@@ -7,12 +7,13 @@
 package garray
 
 import (
+    "bytes"
+    "fmt"
     "github.com/gogf/gf/g/internal/rwmutex"
     "github.com/gogf/gf/g/util/gconv"
     "github.com/gogf/gf/g/util/grand"
     "math"
     "sort"
-    "strings"
 )
 
 type Array struct {
@@ -30,8 +31,6 @@ func New(unsafe...bool) *Array {
 }
 
 // See New.
-//
-// 同New方法。
 func NewArray(unsafe...bool) *Array {
     return NewArraySize(0, 0, unsafe...)
 }
@@ -48,6 +47,16 @@ func NewArraySize(size int, cap int, unsafe...bool) *Array {
     }
 }
 
+// See NewArrayFrom.
+func NewFrom(array []interface{}, unsafe...bool) *Array {
+    return NewArrayFrom(array, unsafe...)
+}
+
+// See NewArrayFromCopy.
+func NewFromCopy(array []interface{}, unsafe...bool) *Array {
+    return NewArrayFromCopy(array, unsafe...)
+}
+
 // Create an array with given slice <array>.
 // The param <unsafe> used to specify whether using array with un-concurrent-safety,
 // which is false in default, means concurrent-safe in default.
@@ -60,6 +69,20 @@ func NewArrayFrom(array []interface{}, unsafe...bool) *Array {
     }
 }
 
+// Create an array from a copy of given slice <array>.
+// The param <unsafe> used to specify whether using array with un-concurrent-safety,
+// which is false in default, means concurrent-safe in default.
+//
+// 通过给定的slice拷贝创建数组对象，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
+func NewArrayFromCopy(array []interface{}, unsafe...bool) *Array {
+    newArray := make([]interface{}, len(array))
+    copy(newArray, array)
+    return &Array{
+        mu    : rwmutex.New(unsafe...),
+        array : newArray,
+    }
+}
+
 // Get value by index.
 //
 // 获取指定索引的数据项, 调用方注意判断数组边界
@@ -196,13 +219,31 @@ func (a *Array) PushRight(value...interface{}) *Array {
     return a
 }
 
-// Pop an random item from array.
+// PopRand picks an random item out of array.
 //
 // 随机将一个数据项移出数组，并返回该数据项。
 func (a *Array) PopRand() interface{} {
     return a.Remove(grand.Intn(len(a.array)))
 }
 
+// PopRands picks <size> items out of array.
+//
+// 随机将size个数据项移出数组，并返回该数据项。
+func (a *Array) PopRands(size int) []interface{} {
+    a.mu.Lock()
+    defer a.mu.Unlock()
+    if size > len(a.array) {
+        size = len(a.array)
+    }
+    array := make([]interface{}, size)
+    for i := 0; i < size; i++ {
+        index   := grand.Intn(len(a.array))
+        array[i] = a.array[index]
+        a.array  = append(a.array[ : index], a.array[index + 1 : ]...)
+    }
+    return array
+}
+
 // Pop an item from the beginning of array.
 //
 // 将最左端(索引为0)的数据项移出数组，并返回该数据项。
@@ -408,17 +449,22 @@ func (a *Array) RLockFunc(f func(array []interface{})) *Array {
     return a
 }
 
-// Merge two arrays.
+// Merge two arrays. The parameter <array> can be any garray type or slice type.
+// The difference between Merge and Append is Append supports only specified slice type,
+// but Merge supports more variable types.
 //
-// 合并两个数组.
-func (a *Array) Merge(array *Array) *Array {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if a != array {
-        array.mu.RLock()
-        defer array.mu.RUnlock()
+// 合并两个数组, 支持任意的garray数组类型及slice类型.
+func (a *Array) Merge(array interface{}) *Array {
+    switch v := array.(type) {
+        case *Array:             a.Append(gconv.Interfaces(v.Slice())...)
+        case *IntArray:          a.Append(gconv.Interfaces(v.Slice())...)
+        case *StringArray:       a.Append(gconv.Interfaces(v.Slice())...)
+        case *SortedArray:       a.Append(gconv.Interfaces(v.Slice())...)
+        case *SortedIntArray:    a.Append(gconv.Interfaces(v.Slice())...)
+        case *SortedStringArray: a.Append(gconv.Interfaces(v.Slice())...)
+        default:
+            a.Append(gconv.Interfaces(array)...)
     }
-    a.array = append(a.array, array.array...)
     return a
 }
 
@@ -520,11 +566,19 @@ func (a *Array) SubSlice(offset, size int) []interface{} {
     }
 }
 
-// Picks one or more random entries out of an array(a copy),
-// and returns the key (or keys) of the random entries.
+// Rand gets one random entry from array.
 //
-// 从数组中随机取出size个元素项，构成slice返回。
-func (a *Array) Rand(size int) []interface{} {
+// 从数组中随机获得1个元素项(不删除)。
+func (a *Array) Rand() interface{} {
+    a.mu.RLock()
+    defer a.mu.RUnlock()
+    return a.array[grand.Intn(len(a.array))]
+}
+
+// Rands gets one or more random entries from array(a copy).
+//
+// 从数组中随机拷贝size个元素项，构成slice返回。
+func (a *Array) Rands(size int) []interface{} {
     a.mu.RLock()
     defer a.mu.RUnlock()
     if size > len(a.array) {
@@ -570,7 +624,14 @@ func (a *Array) Reverse() *Array {
 func (a *Array) Join(glue string) string {
     a.mu.RLock()
     defer a.mu.RUnlock()
-    return strings.Join(gconv.Strings(a.array), glue)
+    buffer := bytes.NewBuffer(nil)
+    for k, v := range a.array {
+        buffer.WriteString(gconv.String(v))
+        if k != len(a.array) - 1 {
+            buffer.WriteString(glue)
+        }
+    }
+    return buffer.String()
 }
 
 // Counts all the values of an array.
@@ -584,4 +645,13 @@ func (a *Array) CountValues() map[interface{}]int {
         m[v]++
     }
     return m
+}
+
+// String returns current array as a string.
+//
+// 将当前数组转换为字符串返回。
+func (a *Array) String() string {
+    a.mu.RLock()
+    defer a.mu.RUnlock()
+    return fmt.Sprint(a.array)
 }

g/container/garray/garray_normal_string.go

@@ -7,6 +7,7 @@
 package garray
 
 import (
+    "bytes"
     "github.com/gogf/gf/g/internal/rwmutex"
     "github.com/gogf/gf/g/util/gconv"
     "github.com/gogf/gf/g/util/grand"
@@ -53,6 +54,20 @@ func NewStringArrayFrom(array []string, unsafe...bool) *StringArray {
 	}
 }
 
+// Create an array from a copy of given slice <array>.
+// The param <unsafe> used to specify whether using array with un-concurrent-safety,
+// which is false in default, means concurrent-safe in default.
+//
+// 通过给定的slice拷贝创建数组对象，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
+func NewStringArrayFromCopy(array []string, unsafe...bool) *StringArray {
+    newArray := make([]string, len(array))
+    copy(newArray, array)
+    return &StringArray{
+        mu    : rwmutex.New(unsafe...),
+        array : newArray,
+    }
+}
+
 // Get value by index.
 //
 // 获取指定索引的数据项, 调用方注意判断数组边界。
@@ -233,13 +248,31 @@ func (a *StringArray) PopRight() string {
     return value
 }
 
-// Pop an random item from array.
+// PopRand picks an random item out of array.
 //
 // 随机将一个数据项移出数组，并返回该数据项。
 func (a *StringArray) PopRand() string {
     return a.Remove(grand.Intn(len(a.array)))
 }
 
+// PopRands picks <size> items out of array.
+//
+// 随机将size个数据项移出数组，并返回该数据项。
+func (a *StringArray) PopRands(size int) []string {
+    a.mu.Lock()
+    defer a.mu.Unlock()
+    if size > len(a.array) {
+        size = len(a.array)
+    }
+    array := make([]string, size)
+    for i := 0; i < size; i++ {
+        index   := grand.Intn(len(a.array))
+        array[i] = a.array[index]
+        a.array  = append(a.array[ : index], a.array[index + 1 : ]...)
+    }
+    return array
+}
+
 // Pop <size> items from the beginning of array.
 //
 // 将最左端(首部)的size个数据项移出数组，并返回该数据项
@@ -423,17 +456,22 @@ func (a *StringArray) RLockFunc(f func(array []string)) *StringArray {
     return a
 }
 
-// Merge two arrays.
+// Merge two arrays. The parameter <array> can be any garray type or slice type.
+// The difference between Merge and Append is Append supports only specified slice type,
+// but Merge supports more variable types.
 //
-// 合并两个数组.
-func (a *StringArray) Merge(array *StringArray) *StringArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if a != array {
-        array.mu.RLock()
-        defer array.mu.RUnlock()
+// 合并两个数组, 支持任意的garray数组类型及slice类型.
+func (a *StringArray) Merge(array interface{}) *StringArray {
+    switch v := array.(type) {
+        case *Array:             a.Append(gconv.Strings(v.Slice())...)
+        case *IntArray:          a.Append(gconv.Strings(v.Slice())...)
+        case *StringArray:       a.Append(gconv.Strings(v.Slice())...)
+        case *SortedArray:       a.Append(gconv.Strings(v.Slice())...)
+        case *SortedIntArray:    a.Append(gconv.Strings(v.Slice())...)
+        case *SortedStringArray: a.Append(gconv.Strings(v.Slice())...)
+        default:
+            a.Append(gconv.Strings(array)...)
     }
-    a.array = append(a.array, array.array...)
     return a
 }
 
@@ -537,11 +575,19 @@ func (a *StringArray) SubSlice(offset, size int) []string {
     }
 }
 
-// Picks one or more random entries out of an array(a copy),
-// and returns the key (or keys) of the random entries.
+// Rand gets one random entry from array.
 //
-// 从数组中随机取出size个元素项，构成slice返回。
-func (a *StringArray) Rand(size int) []string {
+// 从数组中随机获得1个元素项(不删除)。
+func (a *StringArray) Rand() string {
+    a.mu.RLock()
+    defer a.mu.RUnlock()
+    return a.array[grand.Intn(len(a.array))]
+}
+
+// Rands gets one or more random entries from array(a copy).
+//
+// 从数组中随机拷贝size个元素项，构成slice返回。
+func (a *StringArray) Rands(size int) []string {
     a.mu.RLock()
     defer a.mu.RUnlock()
     if size > len(a.array) {
@@ -587,6 +633,13 @@ func (a *StringArray) Reverse() *StringArray {
 func (a *StringArray) Join(glue string) string {
     a.mu.RLock()
     defer a.mu.RUnlock()
-    return strings.Join(a.array, glue)
+    buffer := bytes.NewBuffer(nil)
+    for k, v := range a.array {
+        buffer.WriteString(gconv.String(v))
+        if k != len(a.array) - 1 {
+            buffer.WriteString(glue)
+        }
+    }
+    return buffer.String()
 }
 

g/container/garray/garray_sorted_int.go

@@ -7,13 +7,13 @@
 package garray
 
 import (
+    "bytes"
     "github.com/gogf/gf/g/container/gtype"
     "github.com/gogf/gf/g/internal/rwmutex"
     "github.com/gogf/gf/g/util/gconv"
     "github.com/gogf/gf/g/util/grand"
     "math"
     "sort"
-    "strings"
 )
 
 // 默认按照从小到大进行排序
@@ -67,6 +67,20 @@ func NewSortedIntArrayFrom(array []int, unsafe...bool) *SortedIntArray {
     return a
 }
 
+// Create an array from a copy of given slice <array>.
+// The param <unsafe> used to specify whether using array with un-concurrent-safety,
+// which is false in default, means concurrent-safe in default.
+//
+// 通过给定的slice拷贝创建数组对象，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
+func NewSortedIntArrayFromCopy(array []int, unsafe...bool) *SortedIntArray {
+    newArray := make([]int, len(array))
+    copy(newArray, array)
+    return &SortedIntArray{
+        mu    : rwmutex.New(unsafe...),
+        array : newArray,
+    }
+}
+
 // Set the underlying slice array with the given <array> param.
 //
 // 设置底层数组变量.
@@ -172,13 +186,31 @@ func (a *SortedIntArray) PopRight() int {
     return value
 }
 
-// Pop an random item from array.
+// PopRand picks an random item out of array.
 //
 // 随机将一个数据项移出数组，并返回该数据项。
 func (a *SortedIntArray) PopRand() int {
     return a.Remove(grand.Intn(len(a.array)))
 }
 
+// PopRands picks <size> items out of array.
+//
+// 随机将size个数据项移出数组，并返回该数据项。
+func (a *SortedIntArray) PopRands(size int) []int {
+    a.mu.Lock()
+    defer a.mu.Unlock()
+    if size > len(a.array) {
+        size = len(a.array)
+    }
+    array := make([]int, size)
+    for i := 0; i < size; i++ {
+        index   := grand.Intn(len(a.array))
+        array[i] = a.array[index]
+        a.array  = append(a.array[ : index], a.array[index + 1 : ]...)
+    }
+    return array
+}
+
 // Pop <size> items from the beginning of array.
 //
 // 将最左端(首部)的size个数据项移出数组，并返回该数据项
@@ -399,18 +431,22 @@ func (a *SortedIntArray) RLockFunc(f func(array []int)) *SortedIntArray {
     return a
 }
 
-// Merge two arrays.
+// Merge two arrays. The parameter <array> can be any garray type or slice type.
+// The difference between Merge and Add is Add supports only specified slice type,
+// but Merge supports more variable types.
 //
-// 合并两个数组.
-func (a *SortedIntArray) Merge(array *SortedIntArray) *SortedIntArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if a != array {
-        array.mu.RLock()
-        defer array.mu.RUnlock()
+// 合并两个数组, 支持任意的garray数组类型及slice类型.
+func (a *SortedIntArray) Merge(array interface{}) *SortedIntArray {
+    switch v := array.(type) {
+        case *Array:             a.Add(gconv.Ints(v.Slice())...)
+        case *IntArray:          a.Add(gconv.Ints(v.Slice())...)
+        case *StringArray:       a.Add(gconv.Ints(v.Slice())...)
+        case *SortedArray:       a.Add(gconv.Ints(v.Slice())...)
+        case *SortedIntArray:    a.Add(gconv.Ints(v.Slice())...)
+        case *SortedStringArray: a.Add(gconv.Ints(v.Slice())...)
+        default:
+            a.Add(gconv.Ints(array)...)
     }
-    a.array = append(a.array, array.array...)
-    sort.Ints(a.array)
     return a
 }
 
@@ -462,11 +498,19 @@ func (a *SortedIntArray) SubSlice(offset, size int) []int {
     }
 }
 
-// Picks one or more random entries out of an array(a copy),
-// and returns the key (or keys) of the random entries.
+// Rand gets one random entry from array.
 //
-// 从数组中随机取出size个元素项，构成slice返回。
-func (a *SortedIntArray) Rand(size int) []int {
+// 从数组中随机获得1个元素项(不删除)。
+func (a *SortedIntArray) Rand() int {
+    a.mu.RLock()
+    defer a.mu.RUnlock()
+    return a.array[grand.Intn(len(a.array))]
+}
+
+// Rands gets one or more random entries from array(a copy).
+//
+// 从数组中随机拷贝size个元素项，构成slice返回。
+func (a *SortedIntArray) Rands(size int) []int {
     a.mu.RLock()
     defer a.mu.RUnlock()
     if size > len(a.array) {
@@ -488,5 +532,12 @@ func (a *SortedIntArray) Rand(size int) []int {
 func (a *SortedIntArray) Join(glue string) string {
     a.mu.RLock()
     defer a.mu.RUnlock()
-    return strings.Join(gconv.Strings(a.array), glue)
+    buffer := bytes.NewBuffer(nil)
+    for k, v := range a.array {
+        buffer.WriteString(gconv.String(v))
+        if k != len(a.array) - 1 {
+            buffer.WriteString(glue)
+        }
+    }
+    return buffer.String()
 }

g/container/garray/garray_sorted_interface.go

@@ -7,13 +7,13 @@
 package garray
 
 import (
+    "bytes"
     "github.com/gogf/gf/g/container/gtype"
     "github.com/gogf/gf/g/internal/rwmutex"
     "github.com/gogf/gf/g/util/gconv"
     "github.com/gogf/gf/g/util/grand"
     "math"
     "sort"
-    "strings"
 )
 
 // 默认按照从小到大进行排序
@@ -69,6 +69,20 @@ func NewSortedArrayFrom(array []interface{}, compareFunc func(v1, v2 interface{}
     return a
 }
 
+// Create an array from a copy of given slice <array>.
+// The param <unsafe> used to specify whether using array with un-concurrent-safety,
+// which is false in default, means concurrent-safe in default.
+//
+// 通过给定的slice拷贝创建数组对象，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
+func NewSortedArrayFromCopy(array []interface{}, unsafe...bool) *SortedArray {
+    newArray := make([]interface{}, len(array))
+    copy(newArray, array)
+    return &SortedArray{
+        mu    : rwmutex.New(unsafe...),
+        array : newArray,
+    }
+}
+
 // Set the underlying slice array with the given <array> param.
 //
 // 设置底层数组变量.
@@ -178,13 +192,31 @@ func (a *SortedArray) PopRight() interface{} {
     return value
 }
 
-// Pop an random item from array.
+// PopRand picks an random item out of array.
 //
 // 随机将一个数据项移出数组，并返回该数据项。
 func (a *SortedArray) PopRand() interface{} {
     return a.Remove(grand.Intn(len(a.array)))
 }
 
+// PopRands picks <size> items out of array.
+//
+// 随机将size个数据项移出数组，并返回该数据项。
+func (a *SortedArray) PopRands(size int) []interface{} {
+    a.mu.Lock()
+    defer a.mu.Unlock()
+    if size > len(a.array) {
+        size = len(a.array)
+    }
+    array := make([]interface{}, size)
+    for i := 0; i < size; i++ {
+        index   := grand.Intn(len(a.array))
+        array[i] = a.array[index]
+        a.array  = append(a.array[ : index], a.array[index + 1 : ]...)
+    }
+    return array
+}
+
 // Pop <size> items from the beginning of array.
 //
 // 将最左端(首部)的size个数据项移出数组，并返回该数据项
@@ -406,20 +438,22 @@ func (a *SortedArray) RLockFunc(f func(array []interface{})) *SortedArray {
     return a
 }
 
-// Merge two arrays.
+// Merge two arrays. The parameter <array> can be any garray type or slice type.
+// The difference between Merge and Add is Add supports only specified slice type,
+// but Merge supports more variable types.
 //
-// 合并两个数组.
-func (a *SortedArray) Merge(array *SortedArray) *SortedArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if a != array {
-        array.mu.RLock()
-        defer array.mu.RUnlock()
+// 合并两个数组, 支持任意的garray数组类型及slice类型.
+func (a *SortedArray) Merge(array interface{}) *SortedArray {
+    switch v := array.(type) {
+        case *Array:             a.Add(gconv.Interfaces(v.Slice())...)
+        case *IntArray:          a.Add(gconv.Interfaces(v.Slice())...)
+        case *StringArray:       a.Add(gconv.Interfaces(v.Slice())...)
+        case *SortedArray:       a.Add(gconv.Interfaces(v.Slice())...)
+        case *SortedIntArray:    a.Add(gconv.Interfaces(v.Slice())...)
+        case *SortedStringArray: a.Add(gconv.Interfaces(v.Slice())...)
+        default:
+            a.Add(gconv.Interfaces(array)...)
     }
-    a.array = append(a.array, array.array...)
-    sort.Slice(a.array, func(i, j int) bool {
-        return a.compareFunc(a.array[i], a.array[j]) < 0
-    })
     return a
 }
 
@@ -471,11 +505,19 @@ func (a *SortedArray) SubSlice(offset, size int) []interface{} {
     }
 }
 
-// Picks one or more random entries out of an array(a copy),
-// and returns the key (or keys) of the random entries.
+// Rand gets one random entry from array.
 //
-// 从数组中随机取出size个元素项，构成slice返回。
-func (a *SortedArray) Rand(size int) []interface{} {
+// 从数组中随机获得1个元素项(不删除)。
+func (a *SortedArray) Rand() interface{} {
+    a.mu.RLock()
+    defer a.mu.RUnlock()
+    return a.array[grand.Intn(len(a.array))]
+}
+
+// Rands gets one or more random entries from array(a copy).
+//
+// 从数组中随机拷贝size个元素项，构成slice返回。
+func (a *SortedArray) Rands(size int) []interface{} {
     a.mu.RLock()
     defer a.mu.RUnlock()
     if size > len(a.array) {
@@ -497,5 +539,12 @@ func (a *SortedArray) Rand(size int) []interface{} {
 func (a *SortedArray) Join(glue string) string {
     a.mu.RLock()
     defer a.mu.RUnlock()
-    return strings.Join(gconv.Strings(a.array), glue)
+    buffer := bytes.NewBuffer(nil)
+    for k, v := range a.array {
+        buffer.WriteString(gconv.String(v))
+        if k != len(a.array) - 1 {
+            buffer.WriteString(glue)
+        }
+    }
+    return buffer.String()
 }

g/container/garray/garray_sorted_string.go

@@ -7,6 +7,7 @@
 package garray
 
 import (
+    "bytes"
     "github.com/gogf/gf/g/container/gtype"
     "github.com/gogf/gf/g/internal/rwmutex"
     "github.com/gogf/gf/g/util/gconv"
@@ -61,6 +62,20 @@ func NewSortedStringArrayFrom(array []string, unsafe...bool) *SortedStringArray
     return a
 }
 
+// Create an array from a copy of given slice <array>.
+// The param <unsafe> used to specify whether using array with un-concurrent-safety,
+// which is false in default, means concurrent-safe in default.
+//
+// 通过给定的slice拷贝创建数组对象，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
+func NewSortedStringArrayFromCopy(array []string, unsafe...bool) *SortedStringArray {
+    newArray := make([]string, len(array))
+    copy(newArray, array)
+    return &SortedStringArray{
+        mu    : rwmutex.New(unsafe...),
+        array : newArray,
+    }
+}
+
 // Set the underlying slice array with the given <array> param.
 //
 // 设置底层数组变量.
@@ -166,13 +181,31 @@ func (a *SortedStringArray) PopRight() string {
     return value
 }
 
-// Pop an random item from array.
+// PopRand picks an random item out of array.
 //
 // 随机将一个数据项移出数组，并返回该数据项。
 func (a *SortedStringArray) PopRand() string {
     return a.Remove(grand.Intn(len(a.array)))
 }
 
+// PopRands picks <size> items out of array.
+//
+// 随机将size个数据项移出数组，并返回该数据项。
+func (a *SortedStringArray) PopRands(size int) []string {
+    a.mu.Lock()
+    defer a.mu.Unlock()
+    if size > len(a.array) {
+        size = len(a.array)
+    }
+    array := make([]string, size)
+    for i := 0; i < size; i++ {
+        index   := grand.Intn(len(a.array))
+        array[i] = a.array[index]
+        a.array  = append(a.array[ : index], a.array[index + 1 : ]...)
+    }
+    return array
+}
+
 // Pop <size> items from the beginning of array.
 //
 // 将最左端(首部)的size个数据项移出数组，并返回该数据项
@@ -393,18 +426,22 @@ func (a *SortedStringArray) RLockFunc(f func(array []string)) *SortedStringArray
     return a
 }
 
-// Merge two arrays.
+// Merge two arrays. The parameter <array> can be any garray type or slice type.
+// The difference between Merge and Add is Add supports only specified slice type,
+// but Merge supports more variable types.
 //
-// 合并两个数组.
-func (a *SortedStringArray) Merge(array *SortedStringArray) *SortedStringArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if a != array {
-        array.mu.RLock()
-        defer array.mu.RUnlock()
+// 合并两个数组, 支持任意的garray数组类型及slice类型.
+func (a *SortedStringArray) Merge(array interface{}) *SortedStringArray {
+    switch v := array.(type) {
+        case *Array:             a.Add(gconv.Strings(v.Slice())...)
+        case *IntArray:          a.Add(gconv.Strings(v.Slice())...)
+        case *StringArray:       a.Add(gconv.Strings(v.Slice())...)
+        case *SortedArray:       a.Add(gconv.Strings(v.Slice())...)
+        case *SortedIntArray:    a.Add(gconv.Strings(v.Slice())...)
+        case *SortedStringArray: a.Add(gconv.Strings(v.Slice())...)
+        default:
+            a.Add(gconv.Strings(array)...)
     }
-    a.array = append(a.array, array.array...)
-    sort.Strings(a.array)
     return a
 }
 
@@ -456,11 +493,19 @@ func (a *SortedStringArray) SubSlice(offset, size int) []string {
     }
 }
 
-// Picks one or more random entries out of an array(a copy),
-// and returns the key (or keys) of the random entries.
+// Rand gets one random entry from array.
 //
-// 从数组中随机取出size个元素项，构成slice返回。
-func (a *SortedStringArray) Rand(size int) []string {
+// 从数组中随机获得1个元素项(不删除)。
+func (a *SortedStringArray) Rand() string {
+    a.mu.RLock()
+    defer a.mu.RUnlock()
+    return a.array[grand.Intn(len(a.array))]
+}
+
+// Rands gets one or more random entries from array(a copy).
+//
+// 从数组中随机拷贝size个元素项，构成slice返回。
+func (a *SortedStringArray) Rands(size int) []string {
     a.mu.RLock()
     defer a.mu.RUnlock()
     if size > len(a.array) {
@@ -482,5 +527,12 @@ func (a *SortedStringArray) Rand(size int) []string {
 func (a *SortedStringArray) Join(glue string) string {
     a.mu.RLock()
     defer a.mu.RUnlock()
-    return strings.Join(a.array, glue)
+    buffer := bytes.NewBuffer(nil)
+    for k, v := range a.array {
+        buffer.WriteString(gconv.String(v))
+        if k != len(a.array) - 1 {
+            buffer.WriteString(glue)
+        }
+    }
+    return buffer.String()
 }

g/container/garray/garray_z_example_test.go

@@ -0,0 +1,111 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package garray_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g/container/garray"
+)
+
+func Example_basic() {
+    // 创建普通的数组，默认并发安全(带锁)
+    a := garray.New()
+
+    // 添加数据项
+    for i := 0; i < 10; i++ {
+        a.Append(i)
+    }
+
+    // 获取当前数组长度
+    fmt.Println(a.Len())
+
+    // 获取当前数据项列表
+    fmt.Println(a.Slice())
+
+    // 获取指定索引项
+    fmt.Println(a.Get(6))
+
+    // 查找指定数据项是否存在
+    fmt.Println(a.Contains(6))
+    fmt.Println(a.Contains(100))
+
+    // 在指定索引前插入数据项
+    a.InsertAfter(9, 11)
+    // 在指定索引后插入数据项
+    a.InsertBefore(10, 10)
+
+    fmt.Println(a.Slice())
+
+    // 修改指定索引的数据项
+    a.Set(0, 100)
+    fmt.Println(a.Slice())
+
+    // 搜索数据项，返回搜索到的索引位置
+    fmt.Println(a.Search(5))
+
+    // 删除指定索引的数据项
+    a.Remove(0)
+    fmt.Println(a.Slice())
+
+    // 清空数组
+    fmt.Println(a.Slice())
+    a.Clear()
+    fmt.Println(a.Slice())
+
+    // Output:
+    // 10
+    // [0 1 2 3 4 5 6 7 8 9]
+    // 6
+    // true
+    // false
+    // [0 1 2 3 4 5 6 7 8 9 10 11]
+    // [100 1 2 3 4 5 6 7 8 9 10 11]
+    // 5
+    // [1 2 3 4 5 6 7 8 9 10 11]
+    // [1 2 3 4 5 6 7 8 9 10 11]
+    // []
+}
+
+func Example_rand() {
+    array := garray.NewFrom([]interface{}{1,2,3,4,5,6,7,8,9})
+    // 随机返回两个数据项(不删除)
+    fmt.Println(array.Rands(2))
+    fmt.Println(array.PopRand())
+}
+
+func Example_pop() {
+    array := garray.NewFrom([]interface{}{1,2,3,4,5,6,7,8,9})
+    fmt.Println(array.PopLeft())
+    fmt.Println(array.PopLefts(2))
+    fmt.Println(array.PopRight())
+    fmt.Println(array.PopRights(2))
+
+    // Output:
+    // 1
+    // [2 3]
+    // 9
+    // [7 8]
+}
+
+func Example_merge() {
+    array1 := garray.NewFrom([]interface{}{1,2})
+    array2 := garray.NewFrom([]interface{}{3,4})
+    slice1 := []interface{}{5,6}
+    slice2 := []int{7,8}
+    slice3 := []string{"9","0"}
+    fmt.Println(array1.Slice())
+    array1.Merge(array1)
+    array1.Merge(array2)
+    array1.Merge(slice1)
+    array1.Merge(slice2)
+    array1.Merge(slice3)
+    fmt.Println(array1.Slice())
+
+    // Output:
+    // [1 2]
+    // [1 2 1 2 3 4 5 6 7 8 9 0]
+}

g/container/garray/garray_z_unit_int_test.go

@@ -161,9 +161,18 @@ func TestIntArray_Rand(t *testing.T) {
     gtest.Case(t, func() {
         a1 := []int{0,1,2,3,4,5,6}
         array1 := garray.NewIntArrayFrom(a1)
-        gtest.Assert(len(array1.Rand(2)),  2)
-        gtest.Assert(len(array1.Rand(10)), 7)
-        gtest.AssertIN(array1.Rand(1)[0], a1)
+        gtest.Assert(len(array1.Rands(2)),  2)
+        gtest.Assert(len(array1.Rands(10)), 7)
+        gtest.AssertIN(array1.Rands(1)[0], a1)
+        gtest.AssertIN(array1.Rand(), a1)
+    })
+}
+
+func TestIntArray_PopRands(t *testing.T) {
+    gtest.Case(t, func() {
+        a1 := []interface{}{100, 200, 300, 400, 500, 600}
+        array := garray.NewFromCopy(a1)
+        gtest.AssertIN(array.PopRands(2), a1)
     })
 }
 

g/container/garray/garray_z_unit_interface_test.go

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

g/container/garray/garray_z_unit_string_test.go

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

g/database/gdb/gdb.go

@@ -37,8 +37,8 @@ type DB interface {
     doQuery(link dbLink, query string, args ...interface{}) (rows *sql.Rows, err error)
     doExec(link dbLink, query string, args ...interface{}) (result sql.Result, err error)
     doPrepare(link dbLink, query string) (*sql.Stmt, error)
-    doInsert(link dbLink, table string, data Map, option int) (result sql.Result, err error)
-    doBatchInsert(link dbLink, table string, list List, batch int, option int) (result sql.Result, err error)
+    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)
 
@@ -47,7 +47,9 @@ type DB interface {
 	GetOne(query string, args ...interface{}) (Record, error)
 	GetValue(query string, args ...interface{}) (Value, error)
     GetCount(query string, args ...interface{}) (int, error)
-    GetStruct(obj interface{}, query string, args ...interface{}) error
+    GetStruct(objPointer interface{}, query string, args ...interface{}) error
+    GetStructs(objPointerSlice interface{}, query string, args ...interface{}) error
+    GetScan(objPointer interface{}, query string, args ...interface{}) error
 
     // 创建底层数据库master/slave链接对象
     Master() (*sql.DB, error)
@@ -61,14 +63,14 @@ type DB interface {
 	Begin() (*TX, error)
 
 	// 数据表插入/更新/保存操作
-	Insert(table string, data Map) (sql.Result, error)
-	Replace(table string, data Map) (sql.Result, error)
-	Save(table string, data Map) (sql.Result, error)
+	Insert(table string, data interface{}, batch...int) (sql.Result, error)
+	Replace(table string, data interface{}, batch...int) (sql.Result, error)
+	Save(table string, data interface{}, batch...int) (sql.Result, error)
 
 	// 数据表插入/更新/保存操作(批量)
-	BatchInsert(table string, list List, batch int) (sql.Result, error)
-	BatchReplace(table string, list List, batch int) (sql.Result, error)
-	BatchSave(table string, list List, batch int) (sql.Result, error)
+	BatchInsert(table string, list interface{}, batch...int) (sql.Result, error)
+	BatchReplace(table string, list interface{}, batch...int) (sql.Result, error)
+	BatchSave(table string, list interface{}, batch...int) (sql.Result, error)
 
 	// 数据修改/删除
 	Update(table string, data interface{}, condition interface{}, args ...interface{}) (sql.Result, error)
@@ -149,8 +151,11 @@ const (
     OPTION_REPLACE = 1
     OPTION_SAVE    = 2
     OPTION_IGNORE  = 3
+    // 默认批量操作的数量值(Batch*操作)
+    gDEFAULT_BATCH_NUM          = 10
     // 默认的连接池连接存活时间(秒)
     gDEFAULT_CONN_MAX_LIFE_TIME = 30
+
 )
 
 // 使用默认/指定分组配置进行连接，数据库集群配置项：default

g/database/gdb/gdb_base.go

@@ -14,8 +14,8 @@ import (
     "github.com/gogf/gf/g/container/gvar"
     "github.com/gogf/gf/g/os/gcache"
     "github.com/gogf/gf/g/os/gtime"
-    "github.com/gogf/gf/g/util/gconv"
     "github.com/gogf/gf/g/text/gregex"
+    "github.com/gogf/gf/g/util/gconv"
     "reflect"
     "strings"
 )
@@ -165,13 +165,44 @@ func (bs *dbBase) GetOne(query string, args ...interface{}) (Record, error) {
     return nil, nil
 }
 
-// 数据库查询，获取查询结果记录，自动映射数据到给定的struct对象中
-func (bs *dbBase) GetStruct(obj interface{}, query string, args ...interface{}) error {
+// 数据库查询，查询单条记录，自动映射数据到给定的struct对象中
+func (bs *dbBase) GetStruct(objPointer interface{}, query string, args ...interface{}) error {
     one, err := bs.GetOne(query, args...)
     if err != nil {
         return err
     }
-    return one.ToStruct(obj)
+    return one.ToStruct(objPointer)
+}
+
+// 数据库查询，查询多条记录，并自动转换为指定的slice对象, 如: []struct/[]*struct。
+func (bs *dbBase) GetStructs(objPointerSlice interface{}, query string, args ...interface{}) error {
+    all, err := bs.GetAll(query, args...)
+    if err != nil {
+        return err
+    }
+    return all.ToStructs(objPointerSlice)
+}
+
+// 将结果转换为指定的struct/*struct/[]struct/[]*struct,
+// 参数应该为指针类型，否则返回失败。
+// 该方法自动识别参数类型，调用Struct/Structs方法。
+func (bs *dbBase) GetScan(objPointer interface{}, query string, args ...interface{}) error {
+    t := reflect.TypeOf(objPointer)
+    k := t.Kind()
+    if k != reflect.Ptr {
+        return fmt.Errorf("params should be type of pointer, but got: %v", k)
+    }
+    k = t.Elem().Kind()
+    switch k {
+        case reflect.Array:
+        case reflect.Slice:
+            return bs.db.GetStructs(objPointer, query, args ...)
+        case reflect.Struct:
+            return bs.db.GetStruct(objPointer, query, args ...)
+        default:
+            return fmt.Errorf("element type should be type of struct/slice, unsupported: %v", k)
+    }
+    return nil
 }
 
 // 数据库查询，获取查询字段值
@@ -234,33 +265,60 @@ func (bs *dbBase) Begin() (*TX, error) {
     }
 }
 
-// CURD操作:单条数据写入, 仅仅执行写入操作，如果存在冲突的主键或者唯一索引，那么报错返回
-func (bs *dbBase) Insert(table string, data Map) (sql.Result, error) {
-    return bs.db.doInsert(nil, table, data, OPTION_INSERT)
+// CURD操作:单条数据写入, 仅仅执行写入操作，如果存在冲突的主键或者唯一索引，那么报错返回。
+// 参数data支持map/struct/*struct/slice类型，
+// 当为slice(例如[]map/[]struct/[]*struct)类型时，batch参数生效，并自动切换为批量操作。
+func (bs *dbBase) Insert(table string, data interface{}, batch...int) (sql.Result, error) {
+    return bs.db.doInsert(nil, table, data, OPTION_INSERT, batch...)
 }
 
-// CURD操作:单条数据写入, 如果数据存在(主键或者唯一索引)，那么删除后重新写入一条
-func (bs *dbBase) Replace(table string, data Map) (sql.Result, error) {
-    return bs.db.doInsert(nil, table, data, OPTION_REPLACE)
+// CURD操作:单条数据写入, 如果数据存在(主键或者唯一索引)，那么删除后重新写入一条。
+// 参数data支持map/struct/*struct/slice类型，
+// 当为slice(例如[]map/[]struct/[]*struct)类型时，batch参数生效，并自动切换为批量操作。
+func (bs *dbBase) Replace(table string, data interface{}, batch...int) (sql.Result, error) {
+    return bs.db.doInsert(nil, table, data, OPTION_REPLACE, batch...)
 }
 
-// CURD操作:单条数据写入, 如果数据存在(主键或者唯一索引)，那么更新，否则写入一条新数据
-func (bs *dbBase) Save(table string, data Map) (sql.Result, error) {
-    return bs.db.doInsert(nil, table, data, OPTION_SAVE)
+// CURD操作:单条数据写入, 如果数据存在(主键或者唯一索引)，那么更新，否则写入一条新数据。
+// 参数data支持map/struct/*struct/slice类型，
+// 当为slice(例如[]map/[]struct/[]*struct)类型时，batch参数生效，并自动切换为批量操作。
+func (bs *dbBase) Save(table string, data interface{}, batch...int) (sql.Result, error) {
+    return bs.db.doInsert(nil, table, data, OPTION_SAVE, batch...)
 }
 
-// insert、replace, save， ignore操作
-// 0: insert:  仅仅执行写入操作，如果存在冲突的主键或者唯一索引，那么报错返回
-// 1: replace: 如果数据存在(主键或者唯一索引)，那么删除后重新写入一条
-// 2: save:    如果数据存在(主键或者唯一索引)，那么更新，否则写入一条新数据
-// 3: ignore:  如果数据存在(主键或者唯一索引)，那么什么也不做
-func (bs *dbBase) doInsert(link dbLink, table string, data Map, option int) (result sql.Result, err error) {
-    var fields []string
-    var values []string
-    var params []interface{}
-    charl, charr := bs.db.getChars()
-    for k, v := range data {
-        fields = append(fields,   charl + k + charr)
+// 支持insert、replace, save， ignore操作。
+// 0: insert:  仅仅执行写入操作，如果存在冲突的主键或者唯一索引，那么报错返回;
+// 1: replace: 如果数据存在(主键或者唯一索引)，那么删除后重新写入一条;
+// 2: save:    如果数据存在(主键或者唯一索引)，那么更新，否则写入一条新数据;
+// 3: ignore:  如果数据存在(主键或者唯一索引)，那么什么也不做;
+//
+// 参数data支持map/struct/*struct/slice类型，
+// 当为slice(例如[]map/[]struct/[]*struct)类型时，batch参数生效，并自动切换为批量操作。
+func (bs *dbBase) doInsert(link dbLink, table string, data interface{}, option int, batch...int) (result sql.Result, err error) {
+    var fields  []string
+    var values  []string
+    var params  []interface{}
+    var dataMap Map
+    // 使用反射判断data数据类型，如果为slice类型，那么自动转为批量操作
+    rv   := reflect.ValueOf(data)
+    kind := rv.Kind()
+    if kind == reflect.Ptr {
+        rv   = rv.Elem()
+        kind = rv.Kind()
+    }
+    switch kind {
+        case reflect.Slice: fallthrough
+        case reflect.Array:
+            return bs.db.doBatchInsert(link, table, data, option, batch...)
+        case reflect.Map:   fallthrough
+        case reflect.Struct:
+            dataMap = Map(gconv.Map(data))
+        default:
+            return result, errors.New(fmt.Sprint("unsupported data type:", kind))
+    }
+    charL, charR := bs.db.getChars()
+    for k, v := range dataMap {
+        fields = append(fields, charL + k + charR)
         values = append(values, "?")
         params = append(params, v)
     }
@@ -268,11 +326,11 @@ func (bs *dbBase) doInsert(link dbLink, table string, data Map, option int) (res
     updateStr := ""
     if option == OPTION_SAVE {
         var updates []string
-        for k, _ := range data {
+        for k, _ := range dataMap {
             updates = append(updates,
                 fmt.Sprintf("%s%s%s=VALUES(%s%s%s)",
-                    charl, k, charr,
-                    charl, k, charr,
+                    charL, k, charR,
+                    charL, k, charR,
                 ),
             )
         }
@@ -290,28 +348,55 @@ func (bs *dbBase) doInsert(link dbLink, table string, data Map, option int) (res
 }
 
 // CURD操作:批量数据指定批次量写入
-func (bs *dbBase) BatchInsert(table string, list List, batch int) (sql.Result, error) {
-    return bs.db.doBatchInsert(nil, table, list, batch, OPTION_INSERT)
+func (bs *dbBase) BatchInsert(table string, list interface{}, batch...int) (sql.Result, error) {
+    return bs.db.doBatchInsert(nil, table, list, OPTION_INSERT, batch...)
 }
 
 // CURD操作:批量数据指定批次量写入, 如果数据存在(主键或者唯一索引)，那么删除后重新写入一条
-func (bs *dbBase) BatchReplace(table string, list List, batch int) (sql.Result, error) {
-    return bs.db.doBatchInsert(nil, table, list, batch, OPTION_REPLACE)
+func (bs *dbBase) BatchReplace(table string, list interface{}, batch...int) (sql.Result, error) {
+    return bs.db.doBatchInsert(nil, table, list, OPTION_REPLACE, batch...)
 }
 
 // CURD操作:批量数据指定批次量写入, 如果数据存在(主键或者唯一索引)，那么更新，否则写入一条新数据
-func (bs *dbBase) BatchSave(table string, list List, batch int) (sql.Result, error) {
-    return bs.db.doBatchInsert(nil, table, list, batch, OPTION_SAVE)
+func (bs *dbBase) BatchSave(table string, list interface{}, batch...int) (sql.Result, error) {
+    return bs.db.doBatchInsert(nil, table, list, OPTION_SAVE, batch...)
 }
 
-// 批量写入数据
-func (bs *dbBase) doBatchInsert(link dbLink, table string, list List, batch int, option int) (result sql.Result, err error) {
-    var keys    []string
-    var values  []string
-    var bvalues []string
-    var params  []interface{}
+// 批量写入数据, 参数list支持slice类型，例如: []map/[]struct/[]*struct。
+func (bs *dbBase) doBatchInsert(link dbLink, table string, list interface{}, option int, batch...int) (result sql.Result, err error) {
+    var keys   []string
+    var values []string
+    var params []interface{}
+    listMap := (List)(nil)
+    switch v := list.(type) {
+        case List:
+            listMap = v
+        case Map:
+            listMap = List{v}
+        default:
+            rv   := reflect.ValueOf(list)
+            kind := rv.Kind()
+            if kind == reflect.Ptr {
+                rv   = rv.Elem()
+                kind = rv.Kind()
+            }
+            switch kind {
+                // 如果是slice，那么转换为List类型
+                case reflect.Slice: fallthrough
+                case reflect.Array:
+                    listMap = make(List, rv.Len())
+                    for i := 0; i < rv.Len(); i++ {
+                        listMap[i] = gconv.Map(rv.Index(i).Interface())
+                    }
+                case reflect.Map:   fallthrough
+                case reflect.Struct:
+                    listMap = List{Map(gconv.Map(list))}
+                default:
+                    return result, errors.New(fmt.Sprint("unsupported list type:", kind))
+            }
+    }
     // 判断长度
-    if len(list) < 1 {
+    if len(listMap) < 1 {
         return result, errors.New("empty data list")
     }
     if link == nil {
@@ -320,14 +405,15 @@ func (bs *dbBase) doBatchInsert(link dbLink, table string, list List, batch int,
         }
     }
     // 首先获取字段名称及记录长度
-    for k, _ := range list[0] {
-        keys   = append(keys,   k)
-        values = append(values, "?")
+    holders := []string(nil)
+    for k, _ := range listMap[0] {
+        keys    = append(keys,   k)
+        holders = append(holders, "?")
     }
     batchResult    := new(batchSqlResult)
-    charl, charr   := bs.db.getChars()
-    keyStr         := charl + strings.Join(keys, charl + "," + charr) + charr
-    valueHolderStr := "(" + strings.Join(values, ",") + ")"
+    charL, charR   := bs.db.getChars()
+    keyStr         := charL + strings.Join(keys, charL + "," + charR) + charR
+    valueHolderStr := "(" + strings.Join(holders, ",") + ")"
     // 操作判断
     operation := getInsertOperationByOption(option)
     updateStr := ""
@@ -336,22 +422,26 @@ func (bs *dbBase) doBatchInsert(link dbLink, table string, list List, batch int,
         for _, k := range keys {
             updates = append(updates,
                 fmt.Sprintf("%s%s%s=VALUES(%s%s%s)",
-                    charl, k, charr,
-                    charl, k, charr,
+                    charL, k, charR,
+                    charL, k, charR,
                 ),
             )
         }
         updateStr = fmt.Sprintf(" ON DUPLICATE KEY UPDATE %s", strings.Join(updates, ","))
     }
     // 构造批量写入数据格式(注意map的遍历是无序的)
-    for i := 0; i < len(list); i++ {
+    batchNum := gDEFAULT_BATCH_NUM
+    if len(batch) > 0 {
+        batchNum = batch[0]
+    }
+    for i := 0; i < len(listMap); i++ {
         for _, k := range keys {
-            params = append(params, list[i][k])
+            params = append(params, listMap[i][k])
         }
-        bvalues = append(bvalues, valueHolderStr)
-        if len(bvalues) == batch {
+        values = append(values, valueHolderStr)
+        if len(values) == batchNum {
             r, err := bs.db.doExec(link, fmt.Sprintf("%s INTO %s(%s) VALUES%s %s",
-                operation, table, keyStr, strings.Join(bvalues, ","),
+                operation, table, keyStr, strings.Join(values, ","),
                 updateStr),
                 params...)
             if err != nil {
@@ -363,14 +453,14 @@ func (bs *dbBase) doBatchInsert(link dbLink, table string, list List, batch int,
                 batchResult.lastResult    = r
                 batchResult.rowsAffected += n
             }
-            params  = params[:0]
-            bvalues = bvalues[:0]
+            params = params[:0]
+            values = values[:0]
         }
     }
     // 处理最后不构成指定批量的数据
-    if len(bvalues) > 0 {
+    if len(values) > 0 {
         r, err := bs.db.doExec(link, fmt.Sprintf("%s INTO %s(%s) VALUES%s %s",
-            operation, table, keyStr, strings.Join(bvalues, ","),
+            operation, table, keyStr, strings.Join(values, ","),
             updateStr),
             params...)
         if err != nil {
@@ -386,8 +476,8 @@ func (bs *dbBase) doBatchInsert(link dbLink, table string, list List, batch int,
     return batchResult, nil
 }
 
-// CURD操作:数据更新，统一采用sql预处理
-// data参数支持字符串或者关联数组类型，内部会自行做判断处理
+// CURD操作:数据更新，统一采用sql预处理。
+// data参数支持string/map/struct/*struct类型。
 func (bs *dbBase) Update(table string, data interface{}, condition interface{}, args ...interface{}) (sql.Result, error) {
     link, err := bs.db.Master()
     if err != nil {
@@ -396,23 +486,30 @@ func (bs *dbBase) Update(table string, data interface{}, condition interface{},
     return bs.db.doUpdate(link, table, data, condition, args ...)
 }
 
-// CURD操作:数据更新，统一采用sql预处理
-// data参数支持字符串或者关联数组类型，内部会自行做判断处理
+// 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)
     updates      := ""
-    charl, charr := bs.db.getChars()
-    refValue     := reflect.ValueOf(data)
-    if refValue.Kind() == reflect.Map {
-        var fields []string
-        keys := refValue.MapKeys()
-        for _, k := range keys {
-            fields = append(fields, fmt.Sprintf("%s%s%s=?", charl, k, charr))
-            params = append(params, gconv.String(refValue.MapIndex(k).Interface()))
-        }
-        updates = strings.Join(fields, ",")
-    } else {
-        updates = gconv.String(data)
+    charL, charR := bs.db.getChars()
+    // 使用反射进行类型判断
+    rv   := reflect.ValueOf(data)
+    kind := rv.Kind()
+    if kind == reflect.Ptr {
+        rv   = rv.Elem()
+        kind = rv.Kind()
+    }
+    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))
+            }
+            updates = strings.Join(fields, ",")
+        default:
+            updates = gconv.String(data)
     }
     for _, v := range args {
         params = append(params, gconv.String(v))

g/database/gdb/gdb_func.go

@@ -12,42 +12,58 @@ import (
     "fmt"
     "github.com/gogf/gf/g/os/glog"
     "github.com/gogf/gf/g/os/gtime"
-    "github.com/gogf/gf/g/util/gconv"
     "github.com/gogf/gf/g/text/gregex"
     "github.com/gogf/gf/g/text/gstr"
+    "github.com/gogf/gf/g/util/gconv"
     _ "github.com/gogf/gf/third/github.com/go-sql-driver/mysql"
     "reflect"
     "strings"
 )
 
 // 格式化SQL查询条件
-func formatCondition(where interface{}, args []interface{}) (string, []interface{}) {
+func formatCondition(where interface{}, args []interface{}) (newWhere string, newArgs []interface{}) {
     // 条件字符串处理
     buffer := bytes.NewBuffer(nil)
-    if reflect.ValueOf(where).Kind() == reflect.Map {
-        ks := reflect.ValueOf(where).MapKeys()
-        vs := reflect.ValueOf(where)
-        for _, k := range ks {
-            key   := gconv.String(k.Interface())
-            value := gconv.String(vs.MapIndex(k).Interface())
-            if buffer.Len() > 0 {
-                buffer.WriteString(" AND ")
+    // 使用反射进行类型判断
+    rv   := reflect.ValueOf(where)
+    kind := rv.Kind()
+    if kind == reflect.Ptr {
+        rv   = rv.Elem()
+        kind = rv.Kind()
+    }
+    switch kind {
+        // 注意当where为map/struct类型时，args参数必须为空。
+        case reflect.Map:   fallthrough
+        case reflect.Struct:
+            for k, v := range gconv.Map(where) {
+                if buffer.Len() > 0 {
+                    buffer.WriteString(" AND ")
+                }
+                // 支持slice键值/属性，这个时候作为IN查询
+                switch reflect.ValueOf(v).Kind() {
+                    case reflect.Slice: fallthrough
+                    case reflect.Array:
+                        buffer.WriteString(k + " IN(?)")
+                    default:
+                        if gstr.Pos(k, "<") == -1 && gstr.Pos(k, ">") == -1 && gstr.Pos(k, "=") == -1 {
+                            buffer.WriteString(k + "=?")
+                        } else {
+                            buffer.WriteString(k + "?")
+                        }
+                }
+                // 当给定的Where参数为map/struct时，args参数必定为空，
+                // 考虑到后续还会对args做处理，特别是判断slice类型，这里直接给args赋值。
+                args = append(args, v)
             }
-            if gstr.IsNumeric(value) || value == "?" {
-                buffer.WriteString(key + "=" + value)
-            } else {
-                buffer.WriteString(key + "='" + value + "'")
-            }
-        }
-    } else {
-        buffer.Write(gconv.Bytes(where))
+            newWhere = buffer.String()
+        default:
+            buffer.WriteString(gconv.String(where))
     }
     if buffer.Len() == 0 {
         buffer.WriteString("1=1")
     }
-    // 查询条件处理
-    newWhere := buffer.String()
-    newArgs  := make([]interface{}, 0)
+    // 查询条件参数处理，主要处理slice参数类型
+    newWhere = buffer.String()
     if len(args) > 0 {
         for index, arg := range args {
             rv   := reflect.ValueOf(arg)
@@ -57,11 +73,14 @@ func formatCondition(where interface{}, args []interface{}) (string, []interface
                 kind = rv.Kind()
             }
             switch kind {
+                // '?'占位符支持slice类型,
+                // 这里会将slice参数拆散，并更新原有占位符'?'为多个'?'，使用','符号连接。
                 case reflect.Slice: fallthrough
                 case reflect.Array:
                     for i := 0; i < rv.Len(); i++ {
                         newArgs = append(newArgs, rv.Index(i).Interface())
                     }
+                    // counter用于匹配该参数的位置(与index对应)
                     counter    := 0
                     newWhere, _ = gregex.ReplaceStringFunc(`\?`, newWhere, func(s string) string {
                         counter++
@@ -75,7 +94,7 @@ func formatCondition(where interface{}, args []interface{}) (string, []interface
             }
         }
     }
-    return newWhere, newArgs
+    return
 }
 
 // 打印SQL对象(仅在debug=true时有效)
@@ -109,13 +128,13 @@ func formatError(err error, query string, args ...interface{}) error {
 
 // 根据insert选项获得操作名称
 func getInsertOperationByOption(option int) string {
-    oper := "INSERT"
+    operator := "INSERT"
     switch option {
         case OPTION_REPLACE:
-            oper = "REPLACE"
+            operator = "REPLACE"
         case OPTION_SAVE:
         case OPTION_IGNORE:
-            oper = "INSERT IGNORE"
+            operator = "INSERT IGNORE"
     }
-    return oper
+    return operator
 }

g/database/gdb/gdb_model.go

@@ -35,6 +35,7 @@ type Model struct {
 	cacheEnabled bool          // 当前SQL操作是否开启查询缓存功能
 	cacheTime    int           // 查询缓存时间
 	cacheName    string        // 查询缓存名称
+    alterable    bool          // 当前模型是否运行可修改模式（默认情况下链式操作不会修改当前模型，而是创建新的模型返回）
 }
 
 // 链式操作，数据表字段，可支持多个表，以半角逗号连接
@@ -79,47 +80,69 @@ func (md *Model) Clone() *Model {
     return newModel
 }
 
+// 标识当前对象可被修改。
+// 1. 默认情况下，模型对象的对象属性无法被修改，
+// 每一次链式操作都是克隆一个新的模型对象，这样所有的操作都不会污染模型对象。
+// 但是链式操作如果需要分开执行，那么需要将新的克隆对象赋值给旧的模型对象继续操作。
+// 2. 当标识模型对象为可修改，那么在当前模型对象的所有链式操作均会影响下一次的链式操作，
+// 即使是链式操作分开执行。
+// 3. 大部分ORM框架默认模型对象是可修改的，但是GF框架的ORM提供给开发者更灵活，更安全的链式操作选项。
+func (md *Model) Alterable() *Model {
+    md.alterable = true
+    return md
+}
+
+// 返回操作的模型对象，可能是当前对象，也可能是新的克隆对象，根据alterable决定。
+func (md *Model) getModel() *Model {
+    if md.alterable {
+        return md
+    } else {
+        return md.Clone()
+    }
+}
+
 // 链式操作，左联表
 func (md *Model) LeftJoin(joinTable string, on string) (*Model) {
-    model        := md.Clone()
+    model        := md.getModel()
     model.tables += fmt.Sprintf(" LEFT JOIN %s ON (%s)", joinTable, on)
 	return model
 }
 
 // 链式操作，右联表
 func (md *Model) RightJoin(joinTable string, on string) (*Model) {
-    model        := md.Clone()
+    model        := md.getModel()
     model.tables += fmt.Sprintf(" RIGHT JOIN %s ON (%s)", joinTable, on)
 	return model
 }
 
 // 链式操作，内联表
 func (md *Model) InnerJoin(joinTable string, on string) (*Model) {
-    model        := md.Clone()
+    model        := md.getModel()
     model.tables += fmt.Sprintf(" INNER JOIN %s ON (%s)", joinTable, on)
 	return model
 }
 
 // 链式操作，查询字段
 func (md *Model) Fields(fields string) (*Model) {
-    model       := md.Clone()
+    model       := md.getModel()
     model.fields = fields
 	return model
 }
 
 // 链式操作，过滤字段
 func (md *Model) Filter() (*Model) {
-    model       := md.Clone()
+    model       := md.getModel()
     model.filter = true
     return model
 }
 
-// 链式操作，condition，支持string & gdb.Map
+// 链式操作，condition，支持string & gdb.Map.
+// 注意，多个Where调用时，会相互覆盖，只有最后一个Where语句生效。
 func (md *Model) Where(where interface{}, args ...interface{}) (*Model) {
-    model             := md.Clone()
+    model             := md.getModel()
     newWhere, newArgs := formatCondition(where, args)
     model.where        = newWhere
-    model.whereArgs    = append(model.whereArgs, newArgs...)
+    model.whereArgs    = newArgs
 	// 支持 Where("uid", 1)这种格式
 	if len(args) == 1 && strings.Index(model.where , "?") < 0 {
         model.where += "=?"
@@ -129,7 +152,7 @@ func (md *Model) Where(where interface{}, args ...interface{}) (*Model) {
 
 // 链式操作，添加AND条件到Where中
 func (md *Model) And(where interface{}, args ...interface{}) (*Model) {
-    model             := md.Clone()
+    model             := md.getModel()
     newWhere, newArgs := formatCondition(where, args)
     model.where       += " AND " + newWhere
     model.whereArgs    = append(model.whereArgs, newArgs...)
@@ -138,7 +161,7 @@ func (md *Model) And(where interface{}, args ...interface{}) (*Model) {
 
 // 链式操作，添加OR条件到Where中
 func (md *Model) Or(where interface{}, args ...interface{}) (*Model) {
-    model             := md.Clone()
+    model             := md.getModel()
     newWhere, newArgs := formatCondition(where, args)
     model.where       += " OR " + newWhere
     model.whereArgs    = append(model.whereArgs, newArgs...)
@@ -147,21 +170,21 @@ func (md *Model) Or(where interface{}, args ...interface{}) (*Model) {
 
 // 链式操作，group by
 func (md *Model) GroupBy(groupBy string) (*Model) {
-    model        := md.Clone()
+    model        := md.getModel()
     model.groupBy = groupBy
 	return model
 }
 
 // 链式操作，order by
 func (md *Model) OrderBy(orderBy string) (*Model) {
-    model        := md.Clone()
+    model        := md.getModel()
     model.orderBy = orderBy
 	return model
 }
 
 // 链式操作，limit
 func (md *Model) Limit(start int, limit int) (*Model) {
-    model      := md.Clone()
+    model      := md.getModel()
     model.start = start
     model.limit = limit
 	return model
@@ -170,7 +193,7 @@ func (md *Model) Limit(start int, limit int) (*Model) {
 // 链式操作，翻页
 // @author ymrjqyy
 func (md *Model) ForPage(page, limit int) (*Model) {
-    model      := md.Clone()
+    model      := md.getModel()
     model.start = (page - 1) * limit
     model.limit = limit
 	return model
@@ -178,7 +201,7 @@ func (md *Model) ForPage(page, limit int) (*Model) {
 
 // 设置批处理的大小
 func (md *Model) Batch(batch int) *Model {
-    model      := md.Clone()
+    model      := md.getModel()
     model.batch = batch
     return model
 }
@@ -188,7 +211,7 @@ func (md *Model) Batch(batch int) *Model {
 // name表示自定义的缓存名称，便于业务层精准定位缓存项(如果业务层需要手动清理时，必须指定缓存名称)，
 // 例如：查询缓存时设置名称，清理缓存时可以给定清理的缓存名称进行精准清理。
 func (md *Model) Cache(time int, name ... string) *Model {
-    model          := md.Clone()
+    model          := md.getModel()
     model.cacheTime = time
     if len(name) > 0 {
         model.cacheName = name[0]
@@ -200,13 +223,14 @@ func (md *Model) Cache(time int, name ... string) *Model {
     return model
 }
 
-// 链式操作，操作数据记录项，可以是string/Map, 也可以是：key,value,key,value,...
-func (md *Model) Data(data ...interface{}) (*Model) {
-    model := md.Clone()
+// 链式操作，操作数据项，参数data类型支持 string/map/slice/struct/*struct ,
+// 也可以是：key,value,key,value,...。
+func (md *Model) Data(data ...interface{}) *Model {
+    model := md.getModel()
 	if len(data) > 1 {
 		m := make(map[string]interface{})
 		for i := 0; i < len(data); i += 2 {
-			m[gconv.String(data[i])] = data[i+1]
+			m[gconv.String(data[i])] = data[i + 1]
 		}
         model.data = m
 	} else {
@@ -223,6 +247,7 @@ func (md *Model) Data(data ...interface{}) (*Model) {
                     kind = rv.Kind()
                 }
                 switch kind {
+                	// 如果是slice，那么转换为List类型
                     case reflect.Slice: fallthrough
                     case reflect.Array:
                         list := make(List, rv.Len())
@@ -230,8 +255,9 @@ func (md *Model) Data(data ...interface{}) (*Model) {
                             list[i] = gconv.Map(rv.Index(i).Interface())
                         }
                         model.data = list
-                    case reflect.Map:
-                        model.data = gconv.Map(data[0])
+                    case reflect.Map:   fallthrough
+                    case reflect.Struct:
+                        model.data = Map(gconv.Map(data[0]))
                     default:
                         model.data = data[0]
                 }
@@ -240,7 +266,9 @@ func (md *Model) Data(data ...interface{}) (*Model) {
 	return model
 }
 
-// 链式操作， CURD - Insert/BatchInsert
+// 链式操作， CURD - Insert/BatchInsert。
+// 根据Data方法传递的参数类型决定该操作是单条操作还是批量操作，
+// 如果Data方法传递的是slice类型，那么为批量操作。
 func (md *Model) Insert() (result sql.Result, err error) {
 	defer func() {
 		if err == nil {
@@ -279,7 +307,9 @@ func (md *Model) Insert() (result sql.Result, err error) {
 	return nil, errors.New("inserting into table with invalid data type")
 }
 
-// 链式操作， CURD - Replace/BatchReplace
+// 链式操作， CURD - Replace/BatchReplace。
+// 根据Data方法传递的参数类型决定该操作是单条操作还是批量操作，
+// 如果Data方法传递的是slice类型，那么为批量操作。
 func (md *Model) Replace() (result sql.Result, err error) {
 	defer func() {
 		if err == nil {
@@ -318,7 +348,9 @@ func (md *Model) Replace() (result sql.Result, err error) {
 	return nil, errors.New("replacing into table with invalid data type")
 }
 
-// 链式操作， CURD - Save/BatchSave
+// 链式操作， CURD - Save/BatchSave。
+// 根据Data方法传递的参数类型决定该操作是单条操作还是批量操作，
+// 如果Data方法传递的是slice类型，那么为批量操作。
 func (md *Model) Save() (result sql.Result, err error) {
 	defer func() {
 		if err == nil {
@@ -330,7 +362,7 @@ func (md *Model) Save() (result sql.Result, err error) {
 	}
 	// 批量操作
 	if list, ok := md.data.(List); ok {
-		batch := 10
+		batch := gDEFAULT_BATCH_NUM
 		if md.batch > 0 {
 			batch = md.batch
 		}
@@ -429,13 +461,44 @@ func (md *Model) Value() (Value, error) {
 	return nil, nil
 }
 
-// 链式操作，查询单条记录，并自动转换为struct对象
-func (md *Model) Struct(obj interface{}) error {
+// 链式操作，查询单条记录，并自动转换为struct对象, 参数必须为对象的指针，不能为空指针。
+func (md *Model) Struct(objPointer interface{}) error {
 	one, err := md.One()
 	if err != nil {
 		return err
 	}
-	return one.ToStruct(obj)
+	return one.ToStruct(objPointer)
+}
+
+// 链式操作，查询多条记录，并自动转换为指定的slice对象, 如: []struct/[]*struct。
+func (md *Model) Structs(objPointerSlice interface{}) error {
+	r, err := md.All()
+	if err != nil {
+		return err
+	}
+	return r.ToStructs(objPointerSlice)
+}
+
+// 链式操作，将结果转换为指定的struct/*struct/[]struct/[]*struct,
+// 参数应该为指针类型，否则返回失败。
+// 该方法自动识别参数类型，调用Struct/Structs方法。
+func (md *Model) Scan(objPointer interface{}) error {
+    t := reflect.TypeOf(objPointer)
+    k := t.Kind()
+    if k != reflect.Ptr {
+        return fmt.Errorf("params should be type of pointer, but got: %v", k)
+    }
+    k = t.Elem().Kind()
+    switch k {
+        case reflect.Array:
+        case reflect.Slice:
+            return md.Structs(objPointer)
+        case reflect.Struct:
+            return md.Struct(objPointer)
+        default:
+            return fmt.Errorf("element type should be type of struct/slice, unsupported: %v", k)
+    }
+    return nil
 }
 
 // 链式操作，查询数量，fields可以为空，也可以自定义查询字段，

g/database/gdb/gdb_mssql.go

@@ -11,6 +11,7 @@
     2.不支持save/replace方法
     3.不支持LastInsertId方法
 */
+
 package gdb
 
 import (

g/database/gdb/gdb_oracle.go

@@ -11,6 +11,7 @@
     2.不支持save/replace方法，可以调用这2个方法估计会报错，还没测试过,(应该是可以通过oracle的merge来实现这2个功能的，还没仔细研究)
     3.不支持LastInsertId方法
 */
+
 package gdb
 
 import (

g/database/gdb/gdb_structure.go

@@ -4,7 +4,6 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
-
 package gdb
 
 import (
@@ -85,8 +84,8 @@ func (bs *dbBase) getTableFields(table string) (fields map[string]string, err er
     // 缓存不存在时会查询数据表结构，缓存后不过期，直至程序重启(重新部署)
     v := bs.cache.GetOrSetFunc("table_fields_" + table, func() interface{} {
         result       := (Result)(nil)
-        charl, charr := bs.db.getChars()
-        result, err   = bs.GetAll(fmt.Sprintf(`SHOW COLUMNS FROM %s%s%s`, charl, table, charr))
+        charL, charR := bs.db.getChars()
+        result, err   = bs.GetAll(fmt.Sprintf(`SHOW COLUMNS FROM %s%s%s`, charL, table, charR))
         if err != nil {
             return nil
         }

g/database/gdb/gdb_transaction.go

@@ -8,8 +8,10 @@ package gdb
 
 import (
     "database/sql"
+    "fmt"
     "github.com/gogf/gf/g/text/gregex"
     _ "github.com/gogf/gf/third/github.com/go-sql-driver/mysql"
+    "reflect"
 )
 
 // 数据库事务对象
@@ -75,6 +77,37 @@ func (tx *TX) GetStruct(obj interface{}, query string, args ...interface{}) erro
     return one.ToStruct(obj)
 }
 
+// 数据库查询，查询多条记录，并自动转换为指定的slice对象, 如: []struct/[]*struct。
+func (tx *TX) GetStructs(objPointerSlice interface{}, query string, args ...interface{}) error {
+    all, err := tx.GetAll(query, args...)
+    if err != nil {
+        return err
+    }
+    return all.ToStructs(objPointerSlice)
+}
+
+// 将结果转换为指定的struct/*struct/[]struct/[]*struct,
+// 参数应该为指针类型，否则返回失败。
+// 该方法自动识别参数类型，调用Struct/Structs方法。
+func (tx *TX) GetScan(objPointer interface{}, query string, args ...interface{}) error {
+    t := reflect.TypeOf(objPointer)
+    k := t.Kind()
+    if k != reflect.Ptr {
+        return fmt.Errorf("params should be type of pointer, but got: %v", k)
+    }
+    k = t.Elem().Kind()
+    switch k {
+        case reflect.Array:
+        case reflect.Slice:
+            return tx.db.GetStructs(objPointer, query, args ...)
+        case reflect.Struct:
+            return tx.db.GetStruct(objPointer, query, args ...)
+        default:
+            return fmt.Errorf("element type should be type of struct/slice, unsupported: %v", k)
+    }
+    return nil
+}
+
 // 数据库查询，获取查询字段值
 func (tx *TX) GetValue(query string, args ...interface{}) (Value, error) {
     one, err := tx.GetOne(query, args ...)
@@ -100,33 +133,33 @@ func (tx *TX) GetCount(query string, args ...interface{}) (int, error) {
 }
 
 // CURD操作:单条数据写入, 仅仅执行写入操作，如果存在冲突的主键或者唯一索引，那么报错返回
-func (tx *TX) Insert(table string, data Map) (sql.Result, error) {
-    return tx.db.doInsert(tx.tx, table, data, OPTION_INSERT)
+func (tx *TX) Insert(table string, data interface{}, batch...int) (sql.Result, error) {
+    return tx.db.doInsert(tx.tx, table, data, OPTION_INSERT, batch...)
 }
 
 // CURD操作:单条数据写入, 如果数据存在(主键或者唯一索引)，那么删除后重新写入一条
-func (tx *TX) Replace(table string, data Map) (sql.Result, error) {
-    return tx.db.doInsert(tx.tx, table, data, OPTION_REPLACE)
+func (tx *TX) Replace(table string, data interface{}, batch...int) (sql.Result, error) {
+    return tx.db.doInsert(tx.tx, table, data, OPTION_REPLACE, batch...)
 }
 
 // CURD操作:单条数据写入, 如果数据存在(主键或者唯一索引)，那么更新，否则写入一条新数据
-func (tx *TX) Save(table string, data Map) (sql.Result, error) {
-    return tx.db.doInsert(tx.tx, table, data, OPTION_SAVE)
+func (tx *TX) Save(table string, data interface{}, batch...int) (sql.Result, error) {
+    return tx.db.doInsert(tx.tx, table, data, OPTION_SAVE, batch...)
 }
 
 // CURD操作:批量数据指定批次量写入
-func (tx *TX) BatchInsert(table string, list List, batch int) (sql.Result, error) {
-    return tx.db.doBatchInsert(tx.tx, table, list, batch, OPTION_INSERT)
+func (tx *TX) BatchInsert(table string, list interface{}, batch...int) (sql.Result, error) {
+    return tx.db.doBatchInsert(tx.tx, table, list, OPTION_INSERT, batch...)
 }
 
 // CURD操作:批量数据指定批次量写入, 如果数据存在(主键或者唯一索引)，那么删除后重新写入一条
-func (tx *TX) BatchReplace(table string, list List, batch int) (sql.Result, error) {
-    return tx.db.doBatchInsert(tx.tx, table, list, batch, OPTION_REPLACE)
+func (tx *TX) BatchReplace(table string, list interface{}, batch...int) (sql.Result, error) {
+    return tx.db.doBatchInsert(tx.tx, table, list, OPTION_REPLACE, batch...)
 }
 
 // CURD操作:批量数据指定批次量写入, 如果数据存在(主键或者唯一索引)，那么更新，否则写入一条新数据
-func (tx *TX) BatchSave(table string, list List, batch int) (sql.Result, error) {
-    return tx.db.doBatchInsert(tx.tx, table, list, batch, OPTION_SAVE)
+func (tx *TX) BatchSave(table string, list interface{}, batch...int) (sql.Result, error) {
+    return tx.db.doBatchInsert(tx.tx, table, list, OPTION_SAVE, batch...)
 }
 
 // CURD操作:数据更新，统一采用sql预处理

g/database/gdb/gdb_type_record.go

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

g/database/gdb/gdb_type_result.go

@@ -7,7 +7,9 @@
 package gdb
 
 import (
+    "fmt"
     "github.com/gogf/gf/g/encoding/gparser"
+    "reflect"
 )
 
 // 将结果集转换为JSON字符串
@@ -96,3 +98,30 @@ func (r Result) ToUintRecord(key string) map[uint]Record {
     }
     return m
 }
+
+// 将结果列表转换为指定对象的slice。
+func (r Result) ToStructs(objPointerSlice interface{}) error {
+    l := len(r)
+    if l == 0 {
+        return nil
+    }
+    t := reflect.TypeOf(objPointerSlice)
+    if t.Kind() != reflect.Ptr {
+        return fmt.Errorf("params should be type of pointer, but got: %v", t.Kind())
+    }
+    a := reflect.MakeSlice(t.Elem(), l, l)
+    itemType := a.Index(0).Type()
+    for i := 0; i < l; i++ {
+        if itemType.Kind() == reflect.Ptr {
+            e := reflect.New(itemType.Elem()).Elem()
+            r[i].ToStruct(e)
+            a.Index(i).Set(e.Addr())
+        } else {
+            e := reflect.New(itemType).Elem()
+            r[i].ToStruct(e)
+            a.Index(i).Set(e)
+        }
+    }
+    reflect.ValueOf(objPointerSlice).Elem().Set(a)
+    return nil
+}

g/database/gdb/gdb_unit_1_test.go

@@ -1,177 +0,0 @@
-// 方法操作
-
-package gdb_test
-
-import (
-    "github.com/gogf/gf/g"
-    "github.com/gogf/gf/g/os/gtime"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
-)
-
-func TestDbBase_Query(t *testing.T) {
-    if _, err := db.Query("SELECT ?", 1); err != nil {
-        gtest.Fatal(err)
-    }
-    if _, err := db.Query("ERROR"); err == nil {
-        gtest.Fatal("FAIL")
-    }
-}
-
-func TestDbBase_Exec(t *testing.T) {
-	if _, err := db.Exec("SELECT ?", 1); err != nil {
-		gtest.Fatal(err)
-	}
-	if _, err := db.Exec("ERROR"); err == nil {
-		gtest.Fatal("FAIL")
-	}
-}
-
-func TestDbBase_Prepare(t *testing.T) {
-    st, err := db.Prepare("SELECT 100")
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    rows, err := st.Query()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    array, err := rows.Columns()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(array[0], "100")
-    if err := rows.Close(); err != nil {
-        gtest.Fatal(err)
-    }
-}
-
-func TestDbBase_Insert(t *testing.T) {
-    if _, err := db.Insert("user", g.Map{
-        "id"          : 1,
-        "passport"    : "t1",
-        "password"    : "25d55ad283aa400af464c76d713c07ad",
-        "nickname"    : "T1",
-        "create_time" : gtime.Now().String(),
-    }); err != nil {
-        gtest.Fatal(err)
-    }
-}
-
-func TestDbBase_BatchInsert(t *testing.T) {
-    if r, err := db.BatchInsert("user", g.List {
-        {
-            "id"          : 2,
-            "passport"    : "t2",
-            "password"    : "25d55ad283aa400af464c76d713c07ad",
-            "nickname"    : "T2",
-            "create_time" : gtime.Now().String(),
-        },
-        {
-            "id"          : 3,
-            "passport"    : "t3",
-            "password"    : "25d55ad283aa400af464c76d713c07ad",
-            "nickname"    : "T3",
-            "create_time" : gtime.Now().String(),
-        },
-    }, 1); err != nil {
-        gtest.Fatal(err)
-    } else {
-        n, _ := r.RowsAffected()
-        gtest.Assert(n, 2)
-    }
-}
-
-func TestDbBase_Save(t *testing.T) {
-    if _, err := db.Save("user", g.Map{
-        "id"          : 1,
-        "passport"    : "t1",
-        "password"    : "25d55ad283aa400af464c76d713c07ad",
-        "nickname"    : "T11",
-        "create_time" : gtime.Now().String(),
-    }); err != nil {
-        gtest.Fatal(err)
-    }
-}
-
-func TestDbBase_Replace(t *testing.T) {
-    if _, err := db.Save("user", g.Map{
-        "id"          : 1,
-        "passport"    : "t1",
-        "password"    : "25d55ad283aa400af464c76d713c07ad",
-        "nickname"    : "T111",
-        "create_time" : gtime.Now().String(),
-    }); err != nil {
-        gtest.Fatal(err)
-    }
-}
-
-func TestDbBase_Update(t *testing.T) {
-    if result, err := db.Update("user", "create_time='2010-10-10 00:00:01'", "id=3"); err != nil {
-        gtest.Fatal(err)
-    } else {
-        n, _ := result.RowsAffected()
-        gtest.Assert(n, 1)
-    }
-}
-
-func TestDbBase_GetAll(t *testing.T) {
-    if result, err := db.GetAll("SELECT * FROM user WHERE id=?", 1); err != nil {
-        gtest.Fatal(err)
-    } else {
-        gtest.Assert(len(result), 1)
-    }
-}
-
-func TestDbBase_GetOne(t *testing.T) {
-    if record, err := db.GetOne("SELECT * FROM user WHERE passport=?", "t1"); err != nil {
-        gtest.Fatal(err)
-    } else {
-        if record == nil {
-            gtest.Fatal("FAIL")
-        }
-        gtest.Assert(record["nickname"].String(), "T111")
-    }
-}
-
-func TestDbBase_GetValue(t *testing.T) {
-    if value, err := db.GetValue("SELECT id FROM user WHERE passport=?", "t3"); err != nil {
-        gtest.Fatal(err)
-    } else {
-        gtest.Assert(value.Int(), 3)
-    }
-}
-
-func TestDbBase_GetCount(t *testing.T) {
-    if count, err := db.GetCount("SELECT * FROM user"); err != nil {
-        gtest.Fatal(err)
-    } else {
-        gtest.Assert(count, 3)
-    }
-}
-
-func TestDbBase_GetStruct(t *testing.T) {
-    type User struct {
-        Id         int
-        Passport   string
-        Password   string
-        NickName   string
-        CreateTime gtime.Time
-    }
-    user := new(User)
-    if err := db.GetStruct(user, "SELECT * FROM user WHERE id=?", 3); err != nil {
-        gtest.Fatal(err)
-    } else {
-        gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
-    }
-}
-
-func TestDbBase_Delete(t *testing.T) {
-    if result, err := db.Delete("user", nil); err != nil {
-        gtest.Fatal(err)
-    } else {
-        n, _ := result.RowsAffected()
-        gtest.Assert(n, 3)
-    }
-}
-

g/database/gdb/gdb_unit_2_test.go

@@ -1,222 +0,0 @@
-// 链式操作
-
-package gdb_test
-
-import (
-    "github.com/gogf/gf/g"
-    "github.com/gogf/gf/g/os/gtime"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
-)
-
-func TestModel_Insert(t *testing.T) {
-    result, err := db.Table("user").Filter().Data(g.Map{
-        "id"          : 1,
-        "uid"         : 1,
-        "passport"    : "t1",
-        "password"    : "25d55ad283aa400af464c76d713c07ad",
-        "nickname"    : "T1",
-        "create_time" : gtime.Now().String(),
-    }).Insert()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    n, _ := result.LastInsertId()
-    gtest.Assert(n, 1)
-}
-
-func TestModel_Batch(t *testing.T) {
-    result, err := db.Table("user").Filter().Data(g.List{
-        {
-            "id"          : 2,
-            "uid"         : 2,
-            "passport"    : "t2",
-            "password"    : "25d55ad283aa400af464c76d713c07ad",
-            "nickname"    : "T2",
-            "create_time" : gtime.Now().String(),
-        },
-        {
-            "id"          : 3,
-            "uid"         : 3,
-            "passport"    : "t3",
-            "password"    : "25d55ad283aa400af464c76d713c07ad",
-            "nickname"    : "T3",
-            "create_time" : gtime.Now().String(),
-        },
-    }).Batch(1).Insert()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    n, _ := result.RowsAffected()
-    gtest.Assert(n, 2)
-}
-
-func TestModel_Replace(t *testing.T) {
-    result, err := db.Table("user").Data(g.Map{
-        "id"          : 1,
-        "passport"    : "t11",
-        "password"    : "25d55ad283aa400af464c76d713c07ad",
-        "nickname"    : "T11",
-        "create_time" : gtime.Now().String(),
-    }).Replace()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    n, _ := result.RowsAffected()
-    gtest.Assert(n, 2)
-}
-
-func TestModel_Save(t *testing.T) {
-    result, err := db.Table("user").Data(g.Map{
-        "id"          : 1,
-        "passport"    : "t111",
-        "password"    : "25d55ad283aa400af464c76d713c07ad",
-        "nickname"    : "T111",
-        "create_time" : gtime.Now().String(),
-    }).Save()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    n, _ := result.RowsAffected()
-    gtest.Assert(n, 2)
-}
-
-func TestModel_Update(t *testing.T) {
-    result, err := db.Table("user").Data("passport", "t22").Where("passport=?", "t2").Update()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    n, _ := result.RowsAffected()
-    gtest.Assert(n, 1)
-}
-
-func TestModel_Clone(t *testing.T) {
-    md := db.Table("user").Where("id IN(?)", g.Slice{1,3})
-    count, err := md.Count()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    record, err := md.OrderBy("id DESC").One()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    result, err := md.OrderBy("id ASC").All()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(count, 2)
-    gtest.Assert(record["id"].Int(), 3)
-    gtest.Assert(len(result), 2)
-    gtest.Assert(result[0]["id"].Int(), 1)
-    gtest.Assert(result[1]["id"].Int(), 3)
-}
-
-func TestModel_All(t *testing.T) {
-    result, err := db.Table("user").All()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(len(result), 3)
-}
-
-func TestModel_One(t *testing.T) {
-    record, err := db.Table("user").Where("id", 1).One()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    if record == nil {
-        gtest.Fatal("FAIL")
-    }
-    gtest.Assert(record["nickname"].String(), "T111")
-}
-
-func TestModel_Value(t *testing.T) {
-    value, err := db.Table("user").Fields("nickname").Where("id", 1).Value()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    if value == nil {
-        gtest.Fatal("FAIL")
-    }
-    gtest.Assert(value.String(), "T111")
-}
-
-func TestModel_Count(t *testing.T) {
-    count, err := db.Table("user").Count()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(count, 3)
-}
-
-func TestModel_Select(t *testing.T) {
-    result, err := db.Table("user").Select()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(len(result), 3)
-}
-
-func TestModel_Struct(t *testing.T) {
-    type User struct {
-        Id         int
-        Passport   string
-        Password   string
-        NickName   string
-        CreateTime gtime.Time
-    }
-    user := new(User)
-    err := db.Table("user").Where("id=1").Struct(user)
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(user.NickName, "T111")
-}
-
-func TestModel_OrderBy(t *testing.T) {
-    result, err := db.Table("user").OrderBy("id DESC").Select()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(len(result), 3)
-    gtest.Assert(result[0]["nickname"].String(), "T3")
-}
-
-func TestModel_GroupBy(t *testing.T) {
-    result, err := db.Table("user").GroupBy("id").Select()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(len(result), 3)
-    gtest.Assert(result[0]["nickname"].String(), "T111")
-}
-
-func TestModel_Where1(t *testing.T) {
-    result, err := db.Table("user").Where("id IN(?)", g.Slice{1,3}).OrderBy("id ASC").All()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(len(result), 2)
-    gtest.Assert(result[0]["id"].Int(), 1)
-    gtest.Assert(result[1]["id"].Int(), 3)
-}
-
-func TestModel_Where2(t *testing.T) {
-    result, err := db.Table("user").Where("nickname=? AND id IN(?)", "T3", g.Slice{1,3}).OrderBy("id ASC").All()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    gtest.Assert(len(result), 1)
-    gtest.Assert(result[0]["id"].Int(), 3)
-}
-
-func TestModel_Delete(t *testing.T) {
-    result, err := db.Table("user").Delete()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    n, _ := result.RowsAffected()
-    gtest.Assert(n, 3)
-}
-
-

g/database/gdb/gdb_unit_init_test.go

@@ -3,6 +3,7 @@ package gdb_test
 import (
     "github.com/gogf/gf/g/database/gdb"
     "github.com/gogf/gf/g/test/gtest"
+	"os"
 )
 
 var (
@@ -13,7 +14,7 @@ var (
 // 初始化连接参数。
 // 测试前需要修改连接参数。
 func init() {
-	gdb.AddDefaultConfigNode(gdb.ConfigNode{
+	node := gdb.ConfigNode{
 		Host:     "127.0.0.1",
 		Port:     "3306",
 		User:     "root",
@@ -22,8 +23,13 @@ func init() {
 		Type:     "mysql",
 		Role:     "master",
 		Charset:  "utf8",
-        Priority: 1,
-	})
+		Priority: 1,
+	}
+	hostname, _ := os.Hostname()
+	if hostname == "ijohn" {
+		node.Pass = "12345678"
+	}
+	gdb.AddDefaultConfigNode(node)
 	if r, err := gdb.New(); err != nil {
         gtest.Fatal(err)
 	} else {

g/database/gdb/gdb_unit_method_test.go

@@ -0,0 +1,432 @@
+// 方法操作
+
+package gdb_test
+
+import (
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/os/gtime"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+func TestDbBase_Query(t *testing.T) {
+    if _, err := db.Query("SELECT ?", 1); err != nil {
+        gtest.Fatal(err)
+    }
+    if _, err := db.Query("ERROR"); err == nil {
+        gtest.Fatal("FAIL")
+    }
+}
+
+func TestDbBase_Exec(t *testing.T) {
+	if _, err := db.Exec("SELECT ?", 1); err != nil {
+		gtest.Fatal(err)
+	}
+	if _, err := db.Exec("ERROR"); err == nil {
+		gtest.Fatal("FAIL")
+	}
+}
+
+func TestDbBase_Prepare(t *testing.T) {
+    st, err := db.Prepare("SELECT 100")
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    rows, err := st.Query()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    array, err := rows.Columns()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    gtest.Assert(array[0], "100")
+    if err := rows.Close(); err != nil {
+        gtest.Fatal(err)
+    }
+}
+
+func TestDbBase_Insert(t *testing.T) {
+    if _, err := db.Insert("user", g.Map{
+        "id"          : 1,
+        "passport"    : "t1",
+        "password"    : "25d55ad283aa400af464c76d713c07ad",
+        "nickname"    : "T1",
+        "create_time" : gtime.Now().String(),
+    }); err != nil {
+        gtest.Fatal(err)
+    }
+    // normal map
+    result, err := db.Insert("user", map[interface{}]interface{} {
+        "id"          : "2",
+        "passport"    : "t2",
+        "password"    : "25d55ad283aa400af464c76d713c07ad",
+        "nickname"    : "T2",
+        "create_time" : gtime.Now().String(),
+    })
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ := result.RowsAffected()
+    gtest.Assert(n, 1)
+
+    // struct
+    type User struct {
+        Id         int    `gconv:"id"`
+        Passport   string `json:"passport"`
+        Password   string `gconv:"password"`
+        Nickname   string `gconv:"nickname"`
+        CreateTime string `json:"create_time"`
+    }
+    result, err = db.Insert("user", User{
+        Id          : 3,
+        Passport    : "t3",
+        Password    : "25d55ad283aa400af464c76d713c07ad",
+        Nickname    : "T3",
+        CreateTime  : gtime.Now().String(),
+    })
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ = result.RowsAffected()
+    gtest.Assert(n, 1)
+    value, err := db.GetValue("select `passport` from `user` where id=?", 3)
+    gtest.Assert(err, nil)
+    gtest.Assert(value.String(), "t3")
+
+    // *struct
+    result, err = db.Insert("user", &User{
+        Id          : 4,
+        Passport    : "t4",
+        Password    : "25d55ad283aa400af464c76d713c07ad",
+        Nickname    : "T4",
+        CreateTime  : gtime.Now().String(),
+    })
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ = result.RowsAffected()
+    gtest.Assert(n, 1)
+    value, err = db.GetValue("select `passport` from `user` where id=?", 4)
+    gtest.Assert(err, nil)
+    gtest.Assert(value.String(), "t4")
+
+    // batch with Insert
+    if r, err := db.Insert("user", []interface{} {
+        map[interface{}]interface{} {
+            "id"          : 200,
+            "passport"    : "t200",
+            "password"    : "25d55ad283aa400af464c76d713c07ad",
+            "nickname"    : "T200",
+            "create_time" : gtime.Now().String(),
+        },
+        map[interface{}]interface{} {
+            "id"          : 300,
+            "passport"    : "t300",
+            "password"    : "25d55ad283aa400af464c76d713c07ad",
+            "nickname"    : "T300",
+            "create_time" : gtime.Now().String(),
+        },
+    }); err != nil {
+        gtest.Fatal(err)
+    } else {
+        n, _ := r.RowsAffected()
+        gtest.Assert(n, 2)
+    }
+
+    // clear unnecessary data
+    result, err = db.Delete("user", "id>?", 1)
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ = result.RowsAffected()
+    gtest.Assert(n, 5)
+}
+
+func TestDbBase_BatchInsert(t *testing.T) {
+    if r, err := db.BatchInsert("user", g.List {
+        {
+            "id"          : 2,
+            "passport"    : "t2",
+            "password"    : "25d55ad283aa400af464c76d713c07ad",
+            "nickname"    : "T2",
+            "create_time" : gtime.Now().String(),
+        },
+        {
+            "id"          : 3,
+            "passport"    : "t3",
+            "password"    : "25d55ad283aa400af464c76d713c07ad",
+            "nickname"    : "T3",
+            "create_time" : gtime.Now().String(),
+        },
+    }, 1); err != nil {
+        gtest.Fatal(err)
+    } else {
+        n, _ := r.RowsAffected()
+        gtest.Assert(n, 2)
+    }
+
+    result, err := db.Delete("user", "id>?", 1)
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ := result.RowsAffected()
+    gtest.Assert(n, 2)
+
+    // []interface{}
+    if r, err := db.BatchInsert("user", []interface{} {
+        map[interface{}]interface{} {
+            "id"          : 2,
+            "passport"    : "t2",
+            "password"    : "25d55ad283aa400af464c76d713c07ad",
+            "nickname"    : "T2",
+            "create_time" : gtime.Now().String(),
+        },
+        map[interface{}]interface{} {
+            "id"          : 3,
+            "passport"    : "t3",
+            "password"    : "25d55ad283aa400af464c76d713c07ad",
+            "nickname"    : "T3",
+            "create_time" : gtime.Now().String(),
+        },
+    }, 1); err != nil {
+        gtest.Fatal(err)
+    } else {
+        n, _ := r.RowsAffected()
+        gtest.Assert(n, 2)
+    }
+}
+
+func TestDbBase_Save(t *testing.T) {
+    if _, err := db.Save("user", g.Map{
+        "id"          : 1,
+        "passport"    : "t1",
+        "password"    : "25d55ad283aa400af464c76d713c07ad",
+        "nickname"    : "T11",
+        "create_time" : gtime.Now().String(),
+    }); err != nil {
+        gtest.Fatal(err)
+    }
+}
+
+func TestDbBase_Replace(t *testing.T) {
+    if _, err := db.Save("user", g.Map{
+        "id"          : 1,
+        "passport"    : "t1",
+        "password"    : "25d55ad283aa400af464c76d713c07ad",
+        "nickname"    : "T111",
+        "create_time" : gtime.Now().String(),
+    }); err != nil {
+        gtest.Fatal(err)
+    }
+}
+
+func TestDbBase_Update(t *testing.T) {
+    if result, err := db.Update("user", "create_time='2010-10-10 00:00:01'", "id=3"); err != nil {
+        gtest.Fatal(err)
+    } else {
+        n, _ := result.RowsAffected()
+        gtest.Assert(n, 1)
+    }
+}
+
+func TestDbBase_GetAll(t *testing.T) {
+    if result, err := db.GetAll("SELECT * FROM user WHERE id=?", 1); err != nil {
+        gtest.Fatal(err)
+    } else {
+        gtest.Assert(len(result), 1)
+    }
+}
+
+func TestDbBase_GetOne(t *testing.T) {
+    if record, err := db.GetOne("SELECT * FROM user WHERE passport=?", "t1"); err != nil {
+        gtest.Fatal(err)
+    } else {
+        if record == nil {
+            gtest.Fatal("FAIL")
+        }
+        gtest.Assert(record["nickname"].String(), "T111")
+    }
+}
+
+func TestDbBase_GetValue(t *testing.T) {
+    if value, err := db.GetValue("SELECT id FROM user WHERE passport=?", "t3"); err != nil {
+        gtest.Fatal(err)
+    } else {
+        gtest.Assert(value.Int(), 3)
+    }
+}
+
+func TestDbBase_GetCount(t *testing.T) {
+    if count, err := db.GetCount("SELECT * FROM user"); err != nil {
+        gtest.Fatal(err)
+    } else {
+        gtest.Assert(count, 3)
+    }
+}
+
+func TestDbBase_GetStruct(t *testing.T) {
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        user := new(User)
+        if err := db.GetStruct(user, "SELECT * FROM user WHERE id=?", 3); err != nil {
+            gtest.Fatal(err)
+        } else {
+            gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
+        }
+    })
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        user := new(User)
+        if err := db.GetStruct(user, "SELECT * FROM user WHERE id=?", 3); err != nil {
+            gtest.Fatal(err)
+        } else {
+            gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
+        }
+    })
+}
+
+func TestDbBase_GetStructs(t *testing.T) {
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        var users []User
+        if err := db.GetStructs(&users, "SELECT * FROM user WHERE id>=?", 1); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  3)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T111")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
+    })
+
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        var users []User
+        if err := db.GetStructs(&users, "SELECT * FROM user WHERE id>=?", 1); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  3)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T111")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
+    })
+}
+
+func TestDbBase_GetScan(t *testing.T) {
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        user := new(User)
+        if err := db.GetScan(user, "SELECT * FROM user WHERE id=?", 3); err != nil {
+            gtest.Fatal(err)
+        } else {
+            gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
+        }
+    })
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        user := new(User)
+        if err := db.GetScan(user, "SELECT * FROM user WHERE id=?", 3); err != nil {
+            gtest.Fatal(err)
+        } else {
+            gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
+        }
+    })
+
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        var users []User
+        if err := db.GetScan(&users, "SELECT * FROM user WHERE id>=?", 1); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  3)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T111")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
+    })
+
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        var users []User
+        if err := db.GetScan(&users, "SELECT * FROM user WHERE id>=?", 1); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  3)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T111")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
+    })
+}
+
+func TestDbBase_Delete(t *testing.T) {
+    if result, err := db.Delete("user", nil); err != nil {
+        gtest.Fatal(err)
+    } else {
+        n, _ := result.RowsAffected()
+        gtest.Assert(n, 3)
+    }
+}
+

g/database/gdb/gdb_unit_model_test.go

@@ -0,0 +1,521 @@
+// 链式操作
+
+package gdb_test
+
+import (
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/os/gtime"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+// 基本测试
+func TestModel_Insert(t *testing.T) {
+    result, err := db.Table("user").Filter().Data(g.Map{
+        "id"          : 1,
+        "uid"         : 1,
+        "passport"    : "t1",
+        "password"    : "25d55ad283aa400af464c76d713c07ad",
+        "nickname"    : "T1",
+        "create_time" : gtime.Now().String(),
+    }).Insert()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ := result.LastInsertId()
+    gtest.Assert(n, 1)
+
+    result, err = db.Table("user").Filter().Data(map[interface{}]interface{} {
+        "id"          : "2",
+        "uid"         : "2",
+        "passport"    : "t2",
+        "password"    : "25d55ad283aa400af464c76d713c07ad",
+        "nickname"    : "T2",
+        "create_time" : gtime.Now().String(),
+    }).Insert()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ = result.RowsAffected()
+    gtest.Assert(n, 1)
+
+    type User struct {
+        Id         int    `gconv:"id"`
+        Uid        int    `gconv:"uid"`
+        Passport   string `json:"passport"`
+        Password   string `gconv:"password"`
+        Nickname   string `gconv:"nickname"`
+        CreateTime string `json:"create_time"`
+    }
+    result, err = db.Table("user").Filter().Data(User{
+        Id          : 3,
+        Uid         : 3,
+        Passport    : "t3",
+        Password    : "25d55ad283aa400af464c76d713c07ad",
+        Nickname    : "T3",
+        CreateTime  : gtime.Now().String(),
+    }).Insert()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ = result.RowsAffected()
+    gtest.Assert(n, 1)
+    value, err := db.Table("user").Fields("passport").Where("id=3").Value()
+    gtest.Assert(err, nil)
+    gtest.Assert(value.String(), "t3")
+
+    result, err = db.Table("user").Filter().Data(&User{
+        Id          : 4,
+        Uid         : 4,
+        Passport    : "t4",
+        Password    : "25d55ad283aa400af464c76d713c07ad",
+        Nickname    : "T4",
+        CreateTime  : gtime.Now().String(),
+    }).Insert()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ = result.RowsAffected()
+    gtest.Assert(n, 1)
+    value, err = db.Table("user").Fields("passport").Where("id=4").Value()
+    gtest.Assert(err, nil)
+    gtest.Assert(value.String(), "t4")
+
+    result, err = db.Table("user").Where("id>?", 1).Delete()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ = result.RowsAffected()
+    gtest.Assert(n, 3)
+}
+
+func TestModel_Batch(t *testing.T) {
+    result, err := db.Table("user").Filter().Data(g.List{
+        {
+            "id"          : 2,
+            "uid"         : 2,
+            "passport"    : "t2",
+            "password"    : "25d55ad283aa400af464c76d713c07ad",
+            "nickname"    : "T2",
+            "create_time" : gtime.Now().String(),
+        },
+        {
+            "id"          : 3,
+            "uid"         : 3,
+            "passport"    : "t3",
+            "password"    : "25d55ad283aa400af464c76d713c07ad",
+            "nickname"    : "T3",
+            "create_time" : gtime.Now().String(),
+        },
+    }).Batch(1).Insert()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ := result.RowsAffected()
+    gtest.Assert(n, 2)
+}
+
+func TestModel_Replace(t *testing.T) {
+    result, err := db.Table("user").Data(g.Map{
+        "id"          : 1,
+        "passport"    : "t11",
+        "password"    : "25d55ad283aa400af464c76d713c07ad",
+        "nickname"    : "T11",
+        "create_time" : "2018-10-10 00:01:10",
+    }).Replace()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ := result.RowsAffected()
+    gtest.Assert(n, 2)
+}
+
+func TestModel_Save(t *testing.T) {
+    result, err := db.Table("user").Data(g.Map{
+        "id"          : 1,
+        "passport"    : "t111",
+        "password"    : "25d55ad283aa400af464c76d713c07ad",
+        "nickname"    : "T111",
+        "create_time" : "2018-10-10 00:01:10",
+    }).Save()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ := result.RowsAffected()
+    gtest.Assert(n, 2)
+}
+
+func TestModel_Update(t *testing.T) {
+    result, err := db.Table("user").Data("passport", "t22").Where("passport=?", "t2").Update()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ := result.RowsAffected()
+    gtest.Assert(n, 1)
+}
+
+func TestModel_Clone(t *testing.T) {
+    md := db.Table("user").Where("id IN(?)", g.Slice{1,3})
+    count, err := md.Count()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    record, err := md.OrderBy("id DESC").One()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    result, err := md.OrderBy("id ASC").All()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    gtest.Assert(count,                 2)
+    gtest.Assert(record["id"].Int(),    3)
+    gtest.Assert(len(result),           2)
+    gtest.Assert(result[0]["id"].Int(), 1)
+    gtest.Assert(result[1]["id"].Int(), 3)
+}
+
+func TestModel_Alterable(t *testing.T) {
+    gtest.Case(t, func() {
+        md := db.Table("user").Alterable().Where("id IN(?)", g.Slice{1,3})
+        count, err := md.Count()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(count, 2)
+        md.And("id = ?", 1)
+        count, err = md.Count()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(count, 1)
+    })
+}
+
+func TestModel_All(t *testing.T) {
+    result, err := db.Table("user").All()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    gtest.Assert(len(result), 3)
+}
+
+func TestModel_One(t *testing.T) {
+    record, err := db.Table("user").Where("id", 1).One()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    if record == nil {
+        gtest.Fatal("FAIL")
+    }
+    gtest.Assert(record["nickname"].String(), "T111")
+}
+
+func TestModel_Value(t *testing.T) {
+    value, err := db.Table("user").Fields("nickname").Where("id", 1).Value()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    if value == nil {
+        gtest.Fatal("FAIL")
+    }
+    gtest.Assert(value.String(), "T111")
+}
+
+func TestModel_Count(t *testing.T) {
+    count, err := db.Table("user").Count()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    gtest.Assert(count, 3)
+}
+
+func TestModel_Select(t *testing.T) {
+    result, err := db.Table("user").Select()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    gtest.Assert(len(result), 3)
+}
+
+func TestModel_Struct(t *testing.T) {
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        user := new(User)
+        err := db.Table("user").Where("id=1").Struct(user)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(user.NickName,            "T111")
+        gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10")
+    })
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        user := new(User)
+        err := db.Table("user").Where("id=1").Struct(user)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(user.NickName,            "T111")
+        gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10")
+    })
+}
+
+func TestModel_Structs(t *testing.T) {
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        var users []User
+        err := db.Table("user").OrderBy("id asc").Structs(&users)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  3)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T111")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
+    })
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        var users []*User
+        err := db.Table("user").OrderBy("id asc").Structs(&users)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  3)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T111")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
+    })
+}
+
+func TestModel_Scan(t *testing.T) {
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        user := new(User)
+        err := db.Table("user").Where("id=1").Scan(user)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(user.NickName,            "T111")
+        gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10")
+    })
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        user := new(User)
+        err := db.Table("user").Where("id=1").Scan(user)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(user.NickName,            "T111")
+        gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10")
+    })
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        var users []User
+        err := db.Table("user").OrderBy("id asc").Scan(&users)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  3)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T111")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
+    })
+    gtest.Case(t, func() {
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        var users []*User
+        err := db.Table("user").OrderBy("id asc").Scan(&users)
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  3)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T111")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
+    })
+}
+
+func TestModel_OrderBy(t *testing.T) {
+    result, err := db.Table("user").OrderBy("id DESC").Select()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    gtest.Assert(len(result), 3)
+    gtest.Assert(result[0]["nickname"].String(), "T3")
+}
+
+func TestModel_GroupBy(t *testing.T) {
+    result, err := db.Table("user").GroupBy("id").Select()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    gtest.Assert(len(result), 3)
+    gtest.Assert(result[0]["nickname"].String(), "T111")
+}
+
+func TestModel_Where(t *testing.T) {
+    // string
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where("id=? and nickname=?", 3, "T3").One()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(result["id"].Int(), 3)
+    })
+    // map
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where(g.Map{"id" : 3, "nickname" : "T3"}).One()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(result["id"].Int(), 3)
+    })
+    // map key operator
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where(g.Map{"id>" : 1, "id<" : 3}).One()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(result["id"].Int(), 2)
+    })
+    // struct
+    gtest.Case(t, func() {
+        type User struct {
+            Id       int    `json:"id"`
+            Nickname string `gconv:"nickname"`
+        }
+        result, err := db.Table("user").Where(User{3, "T3"}).One()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(result["id"].Int(), 3)
+
+        result, err  = db.Table("user").Where(&User{3, "T3"}).One()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(result["id"].Int(), 3)
+    })
+    // slice single
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where("id IN(?)", g.Slice{1, 3}).OrderBy("id ASC").All()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(result), 2)
+        gtest.Assert(result[0]["id"].Int(), 1)
+        gtest.Assert(result[1]["id"].Int(), 3)
+    })
+    // slice + string
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where("nickname=? AND id IN(?)", "T3", g.Slice{1,3}).OrderBy("id ASC").All()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(result), 1)
+        gtest.Assert(result[0]["id"].Int(), 3)
+    })
+    // slice + map
+    gtest.Case(t, func() {
+        result, err := db.Table("user").Where(g.Map{
+            "id"       : g.Slice{1,3},
+            "nickname" : "T3",
+        }).OrderBy("id ASC").All()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(result), 1)
+        gtest.Assert(result[0]["id"].Int(), 3)
+    })
+    // slice + struct
+    gtest.Case(t, func() {
+        type User struct {
+            Ids      []int  `json:"id"`
+            Nickname string `gconv:"nickname"`
+        }
+        result, err := db.Table("user").Where(User{
+            Ids      : []int{1, 3},
+            Nickname : "T3",
+        }).OrderBy("id ASC").All()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(result), 1)
+        gtest.Assert(result[0]["id"].Int(), 3)
+    })
+}
+
+func TestModel_Delete(t *testing.T) {
+    result, err := db.Table("user").Delete()
+    if err != nil {
+        gtest.Fatal(err)
+    }
+    n, _ := result.RowsAffected()
+    gtest.Assert(n, 3)
+}
+
+

g/database/gdb/gdb_unit_transaction_test.go

@@ -267,6 +267,29 @@ func TestTX_Save(t *testing.T) {
     }
 }
 
+func TestTX_Update(t *testing.T) {
+    gtest.Case(t, func() {
+        tx, err := db.Begin()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        if result, err := db.Update("user", "create_time='2010-10-10 00:00:01'", "id=3"); err != nil {
+            gtest.Fatal(err)
+        } else {
+            n, _ := result.RowsAffected()
+            gtest.Assert(n, 1)
+        }
+        if err := tx.Commit(); err != nil {
+            gtest.Fatal(err)
+        }
+        if value, err := db.Table("user").Fields("create_time").Where("id", 3).Value(); err != nil {
+            gtest.Fatal(err)
+        } else {
+            gtest.Assert(value.String(), "2010-10-10 00:00:01")
+        }
+    })
+}
+
 func TestTX_GetAll(t *testing.T) {
     tx, err := db.Begin()
     if err != nil {
@@ -331,26 +354,215 @@ func TestTX_GetCount(t *testing.T) {
 }
 
 func TestTX_GetStruct(t *testing.T) {
-    tx, err := db.Begin()
-    if err != nil {
-        gtest.Fatal(err)
-    }
-    type User struct {
-        Id         int
-        Passport   string
-        Password   string
-        NickName   string
-        CreateTime gtime.Time
-    }
-    user := new(User)
-    if err := tx.GetStruct(user, "SELECT * FROM user WHERE id=?", 1); err != nil {
-        gtest.Fatal(err)
-    } else {
-        gtest.Assert(user.NickName, "T11")
-    }
-    if err := tx.Commit(); err != nil {
-        gtest.Fatal(err)
-    }
+    gtest.Case(t, func() {
+        tx, err := db.Begin()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        user := new(User)
+        if err := tx.GetStruct(user, "SELECT * FROM user WHERE id=?", 3); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(user.NickName,            "T3")
+        gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
+        if err := tx.Commit(); err != nil {
+            gtest.Fatal(err)
+        }
+    })
+    gtest.Case(t, func() {
+        tx, err := db.Begin()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        user := new(User)
+        if err := tx.GetStruct(user, "SELECT * FROM user WHERE id=?", 3); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(user.NickName,            "T3")
+        gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
+        if err := tx.Commit(); err != nil {
+            gtest.Fatal(err)
+        }
+    })
+}
+
+func TestTX_GetStructs(t *testing.T) {
+    gtest.Case(t, func() {
+        tx, err := db.Begin()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        var users []User
+        if err := tx.GetStructs(&users, "SELECT * FROM user WHERE id>=?", 1); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  4)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T11")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
+        if err := tx.Commit(); err != nil {
+            gtest.Fatal(err)
+        }
+    })
+
+    gtest.Case(t, func() {
+        tx, err := db.Begin()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        var users []User
+        if err := tx.GetStructs(&users, "SELECT * FROM user WHERE id>=?", 1); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  4)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T11")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
+        if err := tx.Commit(); err != nil {
+            gtest.Fatal(err)
+        }
+    })
+}
+
+func TestTX_GetScan(t *testing.T) {
+    gtest.Case(t, func() {
+        tx, err := db.Begin()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        user := new(User)
+        if err := tx.GetScan(user, "SELECT * FROM user WHERE id=?", 3); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(user.NickName,            "T3")
+        gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
+        if err := tx.Commit(); err != nil {
+            gtest.Fatal(err)
+        }
+    })
+    gtest.Case(t, func() {
+        tx, err := db.Begin()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        user := new(User)
+        if err := tx.GetScan(user, "SELECT * FROM user WHERE id=?", 3); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(user.NickName,            "T3")
+        gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
+        if err := tx.Commit(); err != nil {
+            gtest.Fatal(err)
+        }
+    })
+
+    gtest.Case(t, func() {
+        tx, err := db.Begin()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime gtime.Time
+        }
+        var users []User
+        if err := tx.GetScan(&users, "SELECT * FROM user WHERE id>=?", 1); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  4)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T11")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
+        if err := tx.Commit(); err != nil {
+            gtest.Fatal(err)
+        }
+    })
+
+    gtest.Case(t, func() {
+        tx, err := db.Begin()
+        if err != nil {
+            gtest.Fatal(err)
+        }
+        type User struct {
+            Id         int
+            Passport   string
+            Password   string
+            NickName   string
+            CreateTime *gtime.Time
+        }
+        var users []User
+        if err := tx.GetScan(&users, "SELECT * FROM user WHERE id>=?", 1); err != nil {
+            gtest.Fatal(err)
+        }
+        gtest.Assert(len(users),  4)
+        gtest.Assert(users[0].Id, 1)
+        gtest.Assert(users[1].Id, 2)
+        gtest.Assert(users[2].Id, 3)
+        gtest.Assert(users[0].NickName,            "T11")
+        gtest.Assert(users[1].NickName,            "T2")
+        gtest.Assert(users[2].NickName,            "T3")
+        gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
+        if err := tx.Commit(); err != nil {
+            gtest.Fatal(err)
+        }
+    })
 }
 
 func TestTX_Delete(t *testing.T) {

g/g.go

@@ -3,34 +3,50 @@
 // This Source Code Form is subject to the terms of the MIT License.
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
-// 常用数据类型以及对象封装
 
 package g
 
 import "github.com/gogf/gf/g/container/gvar"
 
-// 框架动态变量，可以用该类型替代interface{}类型
-type Var       = gvar.Var
+// Universal variable type, like generics.
+//
+// 动态变量类型，可以用该类型替代interface{}类型
+type Var        = gvar.Var
 
+// Frequently-used map type alias.
+//
 // 常用map数据结构(使用别名)
-type Map        = map[string]interface{}
+type Map        = map[interface{}]interface{}
+type MapAnyStr  = map[interface{}]string
+type MapAnyInt  = map[interface{}]int
+type MapStrAny  = map[string]interface{}
 type MapStrStr  = map[string]string
 type MapStrInt  = map[string]int
+type MapIntAny  = map[int]interface{}
 type MapIntStr  = map[int]string
 type MapIntInt  = map[int]int
 
+// Frequently-used slice type alias.
+//
 // 常用list数据结构(使用别名)
 type List       = []Map
+type ListAnyStr = []map[interface{}]string
+type ListAnyInt = []map[interface{}]int
+type ListStrAny = []map[string]interface{}
 type ListStrStr = []map[string]string
 type ListStrInt = []map[string]int
+type ListIntAny = []map[int]interface{}
 type ListIntStr = []map[int]string
 type ListIntInt = []map[int]int
 
-
+// Frequently-used slice type alias.
+//
 // 常用slice数据结构(使用别名)
 type Slice      = []interface{}
+type SliceAny   = []interface{}
 type SliceStr   = []string
 type SliceInt   = []int
-type Array      = Slice
-type ArrayStr   = SliceStr
-type ArrayInt   = SliceInt
+type Array      = []interface{}
+type ArrayAny   = []interface{}
+type ArrayStr   = []string
+type ArrayInt   = []int

g/g_func.go

@@ -23,27 +23,36 @@ const (
     LOG_LEVEL_CRIT = glog.LEVEL_CRIT
 )
 
+// NewVar creates a *Var.
+//
 // 动态变量
 func NewVar(i interface{}, unsafe...bool) *Var {
     return gvar.New(i, unsafe...)
 }
 
+// Wait blocks until all the web servers shutdown.
+//
 // 阻塞等待HTTPServer执行完成(同一进程多HTTPServer情况下)
 func Wait() {
     ghttp.Wait()
 }
 
+// Dump dumps a variable to stdout with more manually readable.
+//
 // 打印变量
 func Dump(i...interface{}) {
     gutil.Dump(i...)
 }
 
+// Throw throws a exception, which can be caught by Catch function.
+// It always be used in TryCatch function.
+//
 // 抛出一个异常
 func Throw(exception interface{}) {
     gutil.Throw(exception)
 }
 
-// try...catch...
+// TryCatch does the try...catch... logic.
 func TryCatch(try func(), catch ... func(exception interface{})) {
     gutil.TryCatch(try, catch...)
 }

g/g_logger.go

@@ -10,16 +10,22 @@ import (
     "github.com/gogf/gf/g/os/glog"
 )
 
+// Disable/Enabled debug of logging globally.
+//
 // 是否显示调试信息
 func SetDebug(debug bool) {
     glog.SetDebug(debug)
 }
 
+// Set the logging level globally.
+//
 // 设置日志的显示等级
 func SetLogLevel(level int) {
     glog.SetLevel(level)
 }
 
+// Get the global logging level.
+//
 // 获取设置的日志显示等级
 func GetLogLevel() int {
     return glog.GetLevel()

g/g_object.go

@@ -17,42 +17,58 @@ import (
     "github.com/gogf/gf/g/os/gcfg"
 )
 
+// Get an instance of http server with specified name.
+//
 // HTTPServer单例对象
 func Server(name...interface{}) *ghttp.Server {
     return ghttp.GetServer(name...)
 }
 
+// Get an instance of tcp server with specified name.
+//
 // TCPServer单例对象
 func TCPServer(name...interface{}) *gtcp.Server {
     return gtcp.GetServer(name...)
 }
 
+// Get an instance of udp server with specified name.
+//
 // UDPServer单例对象
 func UDPServer(name...interface{}) *gudp.Server {
     return gudp.GetServer(name...)
 }
 
+// Get an instance of template engine object with specified name.
+//
 // 核心对象：View
 func View(name...string) *gview.View {
     return gins.View(name...)
 }
 
-// Config配置管理对象
+// Get an instance of config object with specified default config file name.
+//
+// Config配置管理对象,
 // 配置文件目录查找依次为：启动参数cfgpath、当前程序运行目录
 func Config(file...string) *gcfg.Config {
     return gins.Config(file...)
 }
 
+// Get an instance of database ORM object with specified configuration group name.
+//
 // 数据库操作对象，使用了连接池
 func Database(name...string) gdb.DB {
     return gins.Database(name...)
 }
 
+// Alias of Database.
+//
 // (别名)Database
 func DB(name...string) gdb.DB {
     return gins.Database(name...)
 }
 
+// Get an instance of redis client with specified configuration group name.
+//
 // Redis操作对象，使用了连接池
 func Redis(name...string) *gredis.Redis {
     return gins.Redis(name...)

g/internal/empty/empty.go

@@ -0,0 +1,52 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package empty
+
+import (
+    "reflect"
+)
+
+// 判断给定的变量是否为空。
+// 整型为0, 布尔为false, slice/map长度为0, 其他为nil的情况，都为空。
+// 为空时返回true，否则返回false。
+func IsEmpty(value interface{}) bool {
+    if value == nil {
+        return true
+    }
+    // 优先通过断言来进行常用类型判断
+    switch value := value.(type) {
+        case int:     return value == 0
+        case int8:    return value == 0
+        case int16:   return value == 0
+        case int32:   return value == 0
+        case int64:   return value == 0
+        case uint:    return value == 0
+        case uint8:   return value == 0
+        case uint16:  return value == 0
+        case uint32:  return value == 0
+        case uint64:  return value == 0
+        case float32: return value == 0
+        case float64: return value == 0
+        case bool:    return value == false
+        case string:  return value == ""
+        case []byte:  return len(value) == 0
+        default:
+            // 最后通过反射来判断
+            rv := reflect.ValueOf(value)
+            if rv.IsNil() {
+                return true
+            }
+            kind := rv.Kind()
+            switch kind {
+                case reflect.Map:   fallthrough
+                case reflect.Slice: fallthrough
+                case reflect.Array:
+                    return rv.Len() == 0
+            }
+    }
+    return false
+}

g/net/ghttp/ghttp_request.go

@@ -79,7 +79,7 @@ func (r *Request) GetVar(key string, def ... interface{}) gvar.VarRead {
     return r.GetRequestVar(key, def...)
 }
 
-// 获取原始请求输入字符串
+// 获取原始请求输入二进制。
 func (r *Request) GetRaw() []byte {
     if r.rawContent == nil {
         r.rawContent, _ = ioutil.ReadAll(r.Body)
@@ -87,6 +87,14 @@ func (r *Request) GetRaw() []byte {
     return r.rawContent
 }
 
+// 获取原始请求输入字符串。
+func (r *Request) GetRawString() string {
+    if r.rawContent == nil {
+        r.rawContent, _ = ioutil.ReadAll(r.Body)
+    }
+    return string(r.rawContent)
+}
+
 // 获取原始json请求输入字符串，并解析为json对象
 func (r *Request) GetJson() *gjson.Json {
     data := r.GetRaw()

g/net/ghttp/ghttp_request_query.go

@@ -16,9 +16,10 @@ func (r *Request) initGet() {
     if !r.parsedGet {
         r.queryVars = r.URL.Query()
         if strings.EqualFold(r.Method, "GET") {
-            if raw := r.GetRaw(); len(raw) > 0 {
-                for _, item := range strings.Split(string(raw), "&") {
-                    array                := strings.Split(item, "=")
+            if raw := r.GetRawString(); len(raw) > 0 {
+                var array []string
+                for _, item := range strings.Split(raw, "&") {
+                    array                 = strings.Split(item, "=")
                     r.queryVars[array[0]] = append(r.queryVars[array[0]], array[1])
                 }
             }

g/net/ghttp/ghttp_response.go

@@ -118,15 +118,17 @@ func (r *Response) WriteXml(content interface{}, rootTag...string) error {
     return nil
 }
 
-// 允许AJAX跨域访问
+// Deprecated, please use CORSDefault instead.
+//
+// (已废弃，请使用CORSDefault)允许AJAX跨域访问.
 func (r *Response) SetAllowCrossDomainRequest(allowOrigin string, allowMethods string, maxAge...int) {
     age := 3628800
     if len(maxAge) > 0 {
         age = maxAge[0]
     }
-    r.Header().Set("Access-Control-Allow-Origin",  allowOrigin);
-    r.Header().Set("Access-Control-Allow-Methods", allowMethods);
-    r.Header().Set("Access-Control-Max-Age",       strconv.Itoa(age));
+    r.Header().Set("Access-Control-Allow-Origin",      allowOrigin)
+    r.Header().Set("Access-Control-Allow-Methods",     allowMethods)
+    r.Header().Set("Access-Control-Max-Age",           strconv.Itoa(age))
 }
 
 // 返回HTTP Code状态码
@@ -185,7 +187,8 @@ func (r *Response) ServeFileDownload(path string, name...string) {
     r.Server.serveFile(r.request, path)
 }
 
-// 返回location标识，引导客户端跳转
+// 返回location标识，引导客户端跳转。
+// 注意这里要先把设置的cookie输出，否则会被忽略。
 func (r *Response) RedirectTo(location string) {
     r.Header().Set("Location", location)
     r.WriteHeader(http.StatusFound)
@@ -218,10 +221,19 @@ func (r *Response) ClearBuffer() {
     r.buffer.Reset()
 }
 
-// 输出缓冲区数据到客户端
+// Deprecated.
+//
+// 输出缓冲区数据到客户端.
 func (r *Response) OutputBuffer() {
     r.Header().Set("Server", r.Server.config.ServerAgent)
     //r.handleGzip()
     r.Writer.OutputBuffer()
 }
 
+// 输出缓冲区数据到客户端.
+func (r *Response) Output() {
+    r.Header().Set("Server", r.Server.config.ServerAgent)
+    //r.handleGzip()
+    r.Writer.OutputBuffer()
+}
+

g/net/ghttp/ghttp_response_cors.go

@@ -0,0 +1,62 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+//
+
+package ghttp
+
+import (
+    "github.com/gogf/gf/g/text/gstr"
+    "github.com/gogf/gf/g/util/gconv"
+)
+
+// See https://www.w3.org/TR/cors/ .
+// 服务端允许跨域请求选项
+type CORSOptions struct {
+    AllowOrigin      string // Access-Control-Allow-Origin
+    AllowCredentials string // Access-Control-Allow-Credentials
+    ExposeHeaders    string // Access-Control-Expose-Headers
+    MaxAge           int    // Access-Control-Max-Age
+    AllowMethods     string // Access-Control-Allow-Methods
+    AllowHeaders     string // Access-Control-Allow-Headers
+}
+
+// 默认的CORS配置
+func (r *Response) DefaultCORSOptions() CORSOptions {
+    return CORSOptions {
+        AllowOrigin      : gstr.TrimRight(r.request.Referer(), "/"),
+        AllowMethods     : HTTP_METHODS,
+        AllowCredentials : "true",
+        MaxAge           : 3628800,
+    }
+}
+
+// See https://www.w3.org/TR/cors/ .
+// 允许请求跨域访问.
+func (r *Response) CORS(options CORSOptions) {
+    if options.AllowOrigin != "" {
+        r.Header().Set("Access-Control-Allow-Origin", options.AllowOrigin)
+    }
+    if options.AllowCredentials != "" {
+        r.Header().Set("Access-Control-Allow-Credentials", options.AllowCredentials)
+    }
+    if options.ExposeHeaders != "" {
+        r.Header().Set("Access-Control-Expose-Headers", options.ExposeHeaders)
+    }
+    if options.MaxAge != 0 {
+        r.Header().Set("Access-Control-Max-Age", gconv.String(options.MaxAge))
+    }
+    if options.AllowMethods != "" {
+        r.Header().Set("Access-Control-Allow-Methods", options.AllowMethods)
+    }
+    if options.AllowHeaders != "" {
+        r.Header().Set("Access-Control-Allow-Headers", options.AllowHeaders)
+    }
+}
+
+// 允许请求跨域访问(使用more配置).
+func (r *Response) CORSDefault() {
+    r.CORS(r.DefaultCORSOptions())
+}

g/net/ghttp/ghttp_response_view.go

@@ -65,7 +65,6 @@ func (r *Response) buildInVars(params map[string]interface{}) map[string]interfa
     if params == nil {
         params = make(map[string]interface{})
     }
-
     c := gins.Config()
     if c.GetFilePath() != "" {
         params["Config"]  = c.GetMap("")

g/net/ghttp/ghttp_response_writer.go

@@ -25,16 +25,19 @@ func (w *ResponseWriter) Write(data []byte) (int, error) {
     return len(data), nil
 }
 
-// 覆盖父级的WriteHeader方法
-func (w *ResponseWriter) WriteHeader(code int) {
-    w.Status = code
-    w.ResponseWriter.WriteHeader(code)
+// 覆盖父级的WriteHeader方法, 这里只会记录Status做缓冲处理, 并不会立即输出到HEADER。
+func (w *ResponseWriter) WriteHeader(status int) {
+    w.Status = status
 }
 
-// 输出buffer数据到客户端
+// 输出buffer数据到客户端.
 func (w *ResponseWriter) OutputBuffer() {
+    if w.Status != 0 {
+        w.ResponseWriter.WriteHeader(w.Status)
+    }
     if w.buffer.Len() > 0 {
         w.ResponseWriter.Write(w.buffer.Bytes())
         w.buffer.Reset()
     }
 }
+

g/net/ghttp/ghttp_server.go

@@ -19,8 +19,8 @@ import (
     "github.com/gogf/gf/g/os/glog"
     "github.com/gogf/gf/g/os/gproc"
     "github.com/gogf/gf/g/os/gtimer"
-    "github.com/gogf/gf/g/util/gconv"
     "github.com/gogf/gf/g/text/gregex"
+    "github.com/gogf/gf/g/util/gconv"
     "github.com/gogf/gf/third/github.com/gorilla/websocket"
     "github.com/gogf/gf/third/github.com/olekukonko/tablewriter"
     "net/http"
@@ -39,7 +39,8 @@ type (
         name             string                           // 服务名称，方便识别
         config           ServerConfig                     // 配置对象
         servers          []*gracefulServer                // 底层http.Server列表
-        methodsMap       map[string]struct{}              // 所有支持的HTTP Method(初始化时自动填充)
+        serverCount      *gtype.Int                       // 底层http.Server数量
+        closeChan        chan struct{}                    // 用以关闭事件通知的通道
         servedCount      *gtype.Int                       // 已经服务的请求数(4-8字节，不考虑溢出情况)，同时作为请求ID
         // 服务注册相关
         serveTree        map[string]interface{}           // 所有注册的服务回调函数(路由表，树型结构，哈希表+链表优先级匹配)
@@ -101,8 +102,8 @@ type (
 )
 
 const (
-    SERVER_STATUS_STOPPED      = 0               // Server状态：停止
-    SERVER_STATUS_RUNNING      = 1               // Server状态：运行
+    SERVER_STATUS_STOPPED      = 0 // Server状态：停止
+    SERVER_STATUS_RUNNING      = 1 // Server状态：运行
     HOOK_BEFORE_SERVE          = "BeforeServe"
     HOOK_AFTER_SERVE           = "AfterServe"
     HOOK_BEFORE_OUTPUT         = "BeforeOutput"
@@ -110,7 +111,7 @@ const (
     HOOK_BEFORE_CLOSE          = "BeforeClose"
     HOOK_AFTER_CLOSE           = "AfterClose"
 
-    gHTTP_METHODS              = "GET,PUT,POST,DELETE,PATCH,HEAD,CONNECT,OPTIONS,TRACE"
+    HTTP_METHODS               = "GET,PUT,POST,DELETE,PATCH,HEAD,CONNECT,OPTIONS,TRACE"
     gDEFAULT_SERVER            = "default"
     gDEFAULT_DOMAIN            = "default"
     gDEFAULT_METHOD            = "ALL"
@@ -123,29 +124,39 @@ const (
 )
 
 var (
-    // Server表，用以存储和检索名称与Server对象之间的关联关系
+    // 所有支持的HTTP Method Map(初始化时自动填充),
+    // 用于快速检索需要
+    methodsMap       = make(map[string]struct{})
+
+    // WebServer表，用以存储和检索名称与Server对象之间的关联关系
     serverMapping    = gmap.NewStringInterfaceMap()
 
-    // 正常运行的Server数量，如果没有运行、失败或者全部退出，那么该值为0
+    // 正常运行的WebServer数量，如果没有运行、失败或者全部退出，那么该值为0
     serverRunning    = gtype.NewInt()
 
-    // Web Socket默认配置
+    // WebSocket默认配置
     wsUpgrader       = websocket.Upgrader {
         // 默认允许WebSocket请求跨域，权限控制可以由业务层自己负责，灵活度更高
         CheckOrigin: func(r *http.Request) bool {
             return true
         },
     }
-    // Web Server已完成服务事件通道，当有事件时表示服务完成，当前进程退出
-    doneChan         = make(chan struct{}, 1000)
+    // WebServer已完成服务事件通道，当有事件时表示服务完成，当前进程退出
+    allDoneChan         = make(chan struct{}, 1000)
 
     // 用于服务进程初始化，只能初始化一次，采用“懒初始化”(在server运行时才初始化)
     serverProcessInited = gtype.NewBool()
 
-    // 是否开启WebServer平滑重启特性, 会开启额外的本地端口监听，用于进程管理通信
+    // 是否开启WebServer平滑重启特性, 会开启额外的本地端口监听，用于进程管理通信(默认开启)
     gracefulEnabled     = true
 )
 
+func init() {
+    for _, v := range strings.Split(HTTP_METHODS, ",") {
+        methodsMap[v] = struct{}{}
+    }
+}
+
 // 是否开启平滑重启特性
 func SetGraceful(enabled bool) {
     gracefulEnabled = enabled
@@ -174,6 +185,11 @@ func serverProcessInit() {
     if gracefulEnabled {
         go handleProcessMessage()
     }
+
+    // 是否处于开发环境
+    if gfile.MainPkgPath() != "" {
+        glog.Debug("GF notices that you're in develop environment, so error logs are auto enabled to stdout.")
+    }
 }
 
 // 获取/创建一个默认配置的HTTP Server(默认监听端口是80)
@@ -189,7 +205,8 @@ func GetServer(name...interface{}) (*Server) {
     s := &Server {
         name             : sname,
         servers          : make([]*gracefulServer, 0),
-        methodsMap       : make(map[string]struct{}),
+        closeChan        : make(chan struct{}, 100),
+        serverCount      : gtype.NewInt(),
         statusHandlerMap : make(map[string]HandlerFunc),
         serveTree        : make(map[string]interface{}),
         hooksTree        : make(map[string]interface{}),
@@ -202,9 +219,6 @@ func GetServer(name...interface{}) (*Server) {
     }
     // 日志的标准输出默认关闭，但是错误信息会特殊处理
     s.logger.SetStdPrint(false)
-    for _, v := range strings.Split(gHTTP_METHODS, ",") {
-        s.methodsMap[v] = struct{}{}
-    }
     // 初始化时使用默认配置
     s.SetConfig(defaultServerConfig)
     // 记录到全局ServerMap中
@@ -212,8 +226,8 @@ func GetServer(name...interface{}) (*Server) {
     return s
 }
 
-// 作为守护协程异步执行(当同一进程中存在多个Web Server时，需要采用这种方式执行)
-// 需要结合Wait方式一起使用
+// 作为守护协程异步执行(当同一进程中存在多个Web Server时，需要采用这种方式执行),
+// 需要结合Wait方式一起使用.
 func (s *Server) Start() error {
     // 服务进程初始化，只会初始化一次
     serverProcessInit()
@@ -228,11 +242,12 @@ func (s *Server) Start() error {
         s.config.Handler = http.HandlerFunc(s.defaultHttpHandle)
     }
     // 不允许访问的路由注册(使用HOOK实现)
+    // @TODO 去掉HOOK的实现方式
     if s.config.DenyRoutes != nil {
         for _, v := range s.config.DenyRoutes {
             s.BindHookHandler(v, HOOK_BEFORE_SERVE, func(r *Request) {
                 r.Response.WriteStatus(403)
-                r.Exit()
+                r.ExitAll()
             })
         }
     }
@@ -266,10 +281,6 @@ func (s *Server) Start() error {
             }
         })
     }
-    // 是否处于开发环境
-    if gfile.MainPkgPath() != "" {
-        glog.Debug("GF notices that you're in develop environment, so error logs are auto enabled to stdout.")
-    }
 
     // 打印展示路由表
     s.DumpRoutesMap()
@@ -367,7 +378,7 @@ func (s *Server) Run() error {
         return err
     }
     // 阻塞等待服务执行完成
-    <- doneChan
+    <- s.closeChan
 
     glog.Printfln("%d: all servers shutdown", gproc.Pid())
     return nil
@@ -378,7 +389,7 @@ func (s *Server) Run() error {
 // 这是一个与进程相关的方法
 func Wait() {
     // 阻塞等待服务执行完成
-    <- doneChan
+    <- allDoneChan
 
     glog.Printfln("%d: all servers shutdown", gproc.Pid())
 }
@@ -462,23 +473,28 @@ func (s *Server) startServer(fdMap listenerFdMap) {
         }
     }
     // 开始执行异步监听
+    serverRunning.Add(1)
     for _, v := range s.servers {
         go func(server *gracefulServer) {
-            serverRunning.Add(1)
+            s.serverCount.Add(1)
             err := (error)(nil)
             if server.isHttps {
                 err = server.ListenAndServeTLS(s.config.HTTPSCertPath, s.config.HTTPSKeyPath)
             } else {
                 err = server.ListenAndServe()
             }
-            serverRunning.Add(-1)
             // 如果非关闭错误，那么提示报错，否则认为是正常的服务关闭操作
             if err != nil && !strings.EqualFold(http.ErrServerClosed.Error(), err.Error()) {
                 glog.Fatal(err)
             }
-            // 如果所有异步的Server都已经停止，并且没有在管理操作(重启/关闭)进行中，那么主Server就可以退出了
-            if serverRunning.Val() < 1 && serverProcessStatus.Val() == 0 {
-                doneChan <- struct{}{}
+            // 如果所有异步的http.Server都已经停止，那么WebServer就可以退出了
+            if s.serverCount.Add(-1) < 1 {
+                s.closeChan <- struct{}{}
+                // 如果所有WebServer都退出，那么退出Wait等待
+                if serverRunning.Add(-1) < 1 {
+                    serverMapping.Remove(s.name)
+                    allDoneChan <- struct{}{}
+                }
             }
         }(v)
     }

g/net/ghttp/ghttp_server_admin.go

@@ -8,46 +8,14 @@
 package ghttp
 
 import (
-    "github.com/gogf/gf/g/os/gtimer"
-    "strings"
-    "github.com/gogf/gf/g/os/gview"
     "github.com/gogf/gf/g/os/gproc"
-    "sync"
-    "github.com/gogf/gf/g/os/gtime"
-    "errors"
-    "fmt"
-    "github.com/gogf/gf/g/container/gtype"
-    "github.com/gogf/gf/g/os/glog"
+    "github.com/gogf/gf/g/os/gtimer"
+    "github.com/gogf/gf/g/os/gview"
     "os"
-    "github.com/gogf/gf/g/encoding/gjson"
-    "github.com/gogf/gf/g/util/gconv"
+    "strings"
     "time"
-    "runtime"
-    "bytes"
 )
 
-const (
-    gADMIN_ACTION_INTERVAL_LIMIT = 2000 // (毫秒)服务开启后允许执行管理操作的间隔限制
-    gADMIN_ACTION_NONE           = 0
-    gADMIN_ACTION_RESTARTING     = 1
-    gADMIN_ACTION_SHUTINGDOWN    = 2
-    gADMIN_ACTION_RELOAD_ENVKEY  = "GF_SERVER_RELOAD"
-    gADMIN_ACTION_RESTART_ENVKEY = "GF_SERVER_RESTART"
-    gADMIN_GPROC_COMM_GROUP      = "GF_GPROC_HTTP_SERVER"
-)
-
-// 用于服务管理的对象
-type utilAdmin struct {}
-
-// (进程级别)用于Web Server管理操作的互斥锁，保证管理操作的原子性
-var serverActionLocker sync.Mutex
-
-// (进程级别)用于记录上一次操作的时间(毫秒)
-var serverActionLastTime = gtype.NewInt64(gtime.Millisecond())
-
-// 当前服务进程所处的互斥管理操作状态
-var serverProcessStatus  = gtype.NewInt()
-
 // 服务管理首页
 func (p *utilAdmin) Index(r *Request) {
     data := map[string]interface{}{
@@ -79,9 +47,9 @@ func (p *utilAdmin) Restart(r *Request) {
     }
     // 执行重启操作
     if len(path) > 0 {
-        err = r.Server.Restart(path)
+        err = RestartAllServer(path)
     } else {
-        err = r.Server.Restart()
+        err = RestartAllServer()
     }
     if err == nil {
         r.Response.Write("server restarted")
@@ -93,7 +61,7 @@ func (p *utilAdmin) Restart(r *Request) {
 // 服务关闭
 func (p *utilAdmin) Shutdown(r *Request) {
     r.Server.Shutdown()
-    if err := r.Server.Shutdown(); err == nil {
+    if err := ShutdownAllServer(); err == nil {
         r.Response.Write("server shutdown")
     } else {
         r.Response.Write(err.Error())
@@ -109,222 +77,15 @@ func (s *Server) EnableAdmin(pattern...string) {
     s.BindObject(p, &utilAdmin{})
 }
 
-// 重启Web Server，参数支持自定义重启的可执行文件路径，不传递时默认和原有可执行文件路径一致。
-// 针对*niux系统: 平滑重启
-// 针对windows : 完整重启
-func (s *Server) Restart(newExeFilePath...string) error {
-    serverActionLocker.Lock()
-    defer serverActionLocker.Unlock()
-    if err := s.checkActionStatus(); err != nil {
-        return err
-    }
-    if err := s.checkActionFrequence(); err != nil {
-        return err
-    }
-    return restartWebServers("", newExeFilePath...)
-}
-
-// 关闭Web Server
+// 关闭当前Web Server
 func (s *Server) Shutdown() error {
-    serverActionLocker.Lock()
-    defer serverActionLocker.Unlock()
-    if err := s.checkActionStatus(); err != nil {
-        return err
-    }
-    if err := s.checkActionFrequence(); err != nil {
-        return err
-    }
-    shutdownWebServers("")
-    return nil
-}
-
-// 检测当前操作的频繁度
-func (s *Server) checkActionFrequence() error {
-    interval := gtime.Millisecond() - serverActionLastTime.Val()
-    if interval < gADMIN_ACTION_INTERVAL_LIMIT {
-        return errors.New(fmt.Sprintf("too frequent action, please retry in %d ms", gADMIN_ACTION_INTERVAL_LIMIT - interval))
-    }
-    serverActionLastTime.Set(gtime.Millisecond())
-    return nil
-}
-
-// 检查当前服务进程的状态
-func (s *Server) checkActionStatus() error {
-    status := serverProcessStatus.Val()
-    if status > 0 {
-        switch status {
-            case gADMIN_ACTION_RESTARTING:  return errors.New("server is restarting")
-            case gADMIN_ACTION_SHUTINGDOWN: return errors.New("server is shutting down")
-        }
-    }
-    return nil
-}
-
-// 平滑重启：创建一个子进程，通过环境变量传参
-func forkReloadProcess(newExeFilePath...string) error {
-    path := os.Args[0]
-    if len(newExeFilePath) > 0 {
-        path = newExeFilePath[0]
-    }
-    p   := gproc.NewProcess(path, os.Args, os.Environ())
-    // 创建新的服务进程，子进程自动从父进程复制文件描述来监听同样的端口
-    sfm := getServerFdMap()
-    // 将sfm中的fd按照子进程创建时的文件描述符顺序进行整理，以便子进程获取到正确的fd
-    for name, m := range sfm {
-        for fdk, fdv := range m {
-            if len(fdv) > 0 {
-                s := ""
-                for _, item := range strings.Split(fdv, ",") {
-                    array := strings.Split(item, "#")
-                    fd    := uintptr(gconv.Uint(array[1]))
-                    if fd > 0 {
-                        s += fmt.Sprintf("%s#%d,", array[0], 3 + len(p.ExtraFiles))
-                        p.ExtraFiles = append(p.ExtraFiles, os.NewFile(fd, ""))
-                    } else {
-                        s += fmt.Sprintf("%s#%d,", array[0], 0)
-                    }
-                }
-                sfm[name][fdk] = strings.TrimRight(s, ",")
-            }
-        }
-    }
-    buffer, _ := gjson.Encode(sfm)
-    p.Env = append(p.Env, gADMIN_ACTION_RELOAD_ENVKEY + "=" + string(buffer))
-    if _, err := p.Start(); err != nil {
-        glog.Errorfln("%d: fork process failed, error:%s, %s", gproc.Pid(), err.Error(), string(buffer))
-        return err
-    }
-    return nil
-}
-
-// 完整重启：创建一个新的子进程
-func forkRestartProcess(newExeFilePath...string) error {
-    path := os.Args[0]
-    if len(newExeFilePath) > 0 {
-        path = newExeFilePath[0]
-    }
-    // 去掉平滑重启的环境变量参数
-    os.Unsetenv(gADMIN_ACTION_RELOAD_ENVKEY)
-    env := os.Environ()
-    env  = append(env, gADMIN_ACTION_RESTART_ENVKEY + "=1")
-    p   := gproc.NewProcess(path, os.Args, env)
-    if _, err := p.Start(); err != nil {
-        glog.Errorfln("%d: fork process failed, error:%s", gproc.Pid(), err.Error())
-        return err
-    }
-    return nil
-}
-
-// 获取所有Web Server的文件描述符map
-func getServerFdMap() map[string]listenerFdMap {
-    sfm := make(map[string]listenerFdMap)
-    serverMapping.RLockFunc(func(m map[string]interface{}) {
-        for k, v := range m {
-            sfm[k] = v.(*Server).getListenerFdMap()
+    // 非终端信号下，异步1秒后再执行关闭，
+    // 目的是让接口能够正确返回结果，否则接口会报错(因为web server关闭了)
+    gtimer.SetTimeout(time.Second, func() {
+        // 只关闭当前的Web Server
+        for _, v := range s.servers {
+            v.close()
         }
     })
-    return sfm
-}
-
-// 二进制转换为FdMap
-func bufferToServerFdMap(buffer []byte) map[string]listenerFdMap {
-    sfm := make(map[string]listenerFdMap)
-    if len(buffer) > 0 {
-        j, _ := gjson.LoadContent(buffer, "json")
-        for k, _ := range j.ToMap() {
-            m := make(map[string]string)
-            for k, v := range j.GetMap(k) {
-                m[k] = gconv.String(v)
-            }
-            sfm[k] = m
-        }
-    }
-    return sfm
-}
-
-// Web Server重启
-func restartWebServers(signal string, newExeFilePath...string) error {
-    serverProcessStatus.Set(gADMIN_ACTION_RESTARTING)
-    if runtime.GOOS == "windows" {
-        if len(signal) > 0 {
-            // 在终端信号下，立即执行重启操作
-            forcedlyCloseWebServers()
-            forkRestartProcess(newExeFilePath...)
-        } else {
-            // 非终端信号下，异步1秒后再执行重启，目的是让接口能够正确返回结果，否则接口会报错(因为web server关闭了)
-            gtimer.SetTimeout(time.Second, func() {
-                forcedlyCloseWebServers()
-                forkRestartProcess(newExeFilePath...)
-            })
-        }
-    } else {
-        if err := forkReloadProcess(newExeFilePath...); err != nil {
-            glog.Printfln("%d: server restarts failed", gproc.Pid())
-            serverProcessStatus.Set(gADMIN_ACTION_NONE)
-            return err
-        } else {
-            if len(signal) > 0 {
-                glog.Printfln("%d: server restarting by signal: %s", gproc.Pid(), signal)
-            } else {
-                glog.Printfln("%d: server restarting by web admin", gproc.Pid())
-            }
-
-        }
-    }
     return nil
 }
-
-// Web Server关闭服务
-func shutdownWebServers(signal string) {
-    serverProcessStatus.Set(gADMIN_ACTION_SHUTINGDOWN)
-    if len(signal) > 0 {
-        glog.Printfln("%d: server shutting down by signal: %s", gproc.Pid(), signal)
-        // 在终端信号下，立即执行关闭操作
-        forcedlyCloseWebServers()
-        doneChan <- struct{}{}
-    } else {
-        glog.Printfln("%d: server shutting down by web admin", gproc.Pid())
-        // 非终端信号下，异步1秒后再执行关闭，目的是让接口能够正确返回结果，否则接口会报错(因为web server关闭了)
-        gtimer.SetTimeout(time.Second, func() {
-            forcedlyCloseWebServers()
-            doneChan <- struct{}{}
-        })
-    }
-}
-
-// 关优雅闭进程所有端口的Web Server服务
-// 注意，只是关闭Web Server服务，并不是退出进程
-func gracefulShutdownWebServers() {
-    serverMapping.RLockFunc(func(m map[string]interface{}) {
-        for _, v := range m {
-            for _, s := range v.(*Server).servers {
-                s.shutdown()
-            }
-        }
-    })
-}
-
-// 强制关闭进程所有端口的Web Server服务
-// 注意，只是关闭Web Server服务，并不是退出进程
-func forcedlyCloseWebServers() {
-    serverMapping.RLockFunc(func(m map[string]interface{}) {
-        for _, v := range m {
-            for _, s := range v.(*Server).servers {
-                s.close()
-            }
-        }
-    })
-}
-
-// 异步监听进程间消息
-func handleProcessMessage() {
-    for {
-        if msg := gproc.Receive(gADMIN_GPROC_COMM_GROUP); msg != nil {
-            if bytes.EqualFold(msg.Data, []byte("exit")) {
-                gracefulShutdownWebServers()
-                doneChan <- struct{}{}
-                return
-            }
-        }
-    }
-}

g/net/ghttp/ghttp_server_admin_process.go

@@ -0,0 +1,269 @@
+// 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.
+// pprof封装.
+
+package ghttp
+
+import (
+    "bytes"
+    "errors"
+    "fmt"
+    "github.com/gogf/gf/g/container/gtype"
+    "github.com/gogf/gf/g/encoding/gjson"
+    "github.com/gogf/gf/g/os/glog"
+    "github.com/gogf/gf/g/os/gproc"
+    "github.com/gogf/gf/g/os/gtime"
+    "github.com/gogf/gf/g/os/gtimer"
+    "github.com/gogf/gf/g/util/gconv"
+    "os"
+    "runtime"
+    "strings"
+    "sync"
+    "time"
+)
+
+const (
+    gADMIN_ACTION_INTERVAL_LIMIT = 2000 // (毫秒)服务开启后允许执行管理操作的间隔限制
+    gADMIN_ACTION_NONE           = 0
+    gADMIN_ACTION_RESTARTING     = 1
+    gADMIN_ACTION_SHUTINGDOWN    = 2
+    gADMIN_ACTION_RELOAD_ENVKEY  = "GF_SERVER_RELOAD"
+    gADMIN_ACTION_RESTART_ENVKEY = "GF_SERVER_RESTART"
+    gADMIN_GPROC_COMM_GROUP      = "GF_GPROC_HTTP_SERVER"
+)
+
+// 用于服务管理的对象
+type utilAdmin struct {}
+
+// (进程级别)用于Web Server管理操作的互斥锁，保证管理操作的原子性
+var serverActionLocker sync.Mutex
+
+// (进程级别)用于记录上一次操作的时间(毫秒)
+var serverActionLastTime = gtype.NewInt64(gtime.Millisecond())
+
+// 当前服务进程所处的互斥管理操作状态
+var serverProcessStatus  = gtype.NewInt()
+
+// 重启Web Server，参数支持自定义重启的可执行文件路径，不传递时默认和原有可执行文件路径一致。
+// 针对*niux系统: 平滑重启
+// 针对windows : 完整重启
+func RestartAllServer(newExeFilePath...string) error {
+    serverActionLocker.Lock()
+    defer serverActionLocker.Unlock()
+    if err := checkProcessStatus(); err != nil {
+        return err
+    }
+    if err := checkActionFrequence(); err != nil {
+        return err
+    }
+    return restartWebServers("", newExeFilePath...)
+}
+
+// 关闭所有的WebServer
+func ShutdownAllServer() error {
+    serverActionLocker.Lock()
+    defer serverActionLocker.Unlock()
+    if err := checkProcessStatus(); err != nil {
+        return err
+    }
+    if err := checkActionFrequence(); err != nil {
+        return err
+    }
+    shutdownWebServers()
+    return nil
+}
+
+// 检查当前服务进程的状态
+func checkProcessStatus() error {
+    status := serverProcessStatus.Val()
+    if status > 0 {
+        switch status {
+            case gADMIN_ACTION_RESTARTING:  return errors.New("server is restarting")
+            case gADMIN_ACTION_SHUTINGDOWN: return errors.New("server is shutting down")
+        }
+    }
+    return nil
+}
+
+// 检测当前操作的频繁度
+func checkActionFrequence() error {
+    interval := gtime.Millisecond() - serverActionLastTime.Val()
+    if interval < gADMIN_ACTION_INTERVAL_LIMIT {
+        return errors.New(fmt.Sprintf("too frequent action, please retry in %d ms", gADMIN_ACTION_INTERVAL_LIMIT - interval))
+    }
+    serverActionLastTime.Set(gtime.Millisecond())
+    return nil
+}
+
+// 平滑重启：创建一个子进程，通过环境变量传参
+func forkReloadProcess(newExeFilePath...string) error {
+    path := os.Args[0]
+    if len(newExeFilePath) > 0 {
+        path = newExeFilePath[0]
+    }
+    p   := gproc.NewProcess(path, os.Args, os.Environ())
+    // 创建新的服务进程，子进程自动从父进程复制文件描述来监听同样的端口
+    sfm := getServerFdMap()
+    // 将sfm中的fd按照子进程创建时的文件描述符顺序进行整理，以便子进程获取到正确的fd
+    for name, m := range sfm {
+        for fdk, fdv := range m {
+            if len(fdv) > 0 {
+                s := ""
+                for _, item := range strings.Split(fdv, ",") {
+                    array := strings.Split(item, "#")
+                    fd    := uintptr(gconv.Uint(array[1]))
+                    if fd > 0 {
+                        s += fmt.Sprintf("%s#%d,", array[0], 3 + len(p.ExtraFiles))
+                        p.ExtraFiles = append(p.ExtraFiles, os.NewFile(fd, ""))
+                    } else {
+                        s += fmt.Sprintf("%s#%d,", array[0], 0)
+                    }
+                }
+                sfm[name][fdk] = strings.TrimRight(s, ",")
+            }
+        }
+    }
+    buffer, _ := gjson.Encode(sfm)
+    p.Env = append(p.Env, gADMIN_ACTION_RELOAD_ENVKEY + "=" + string(buffer))
+    if _, err := p.Start(); err != nil {
+        glog.Errorfln("%d: fork process failed, error:%s, %s", gproc.Pid(), err.Error(), string(buffer))
+        return err
+    }
+    return nil
+}
+
+// 完整重启：创建一个新的子进程
+func forkRestartProcess(newExeFilePath...string) error {
+    path := os.Args[0]
+    if len(newExeFilePath) > 0 {
+        path = newExeFilePath[0]
+    }
+    // 去掉平滑重启的环境变量参数
+    os.Unsetenv(gADMIN_ACTION_RELOAD_ENVKEY)
+    env := os.Environ()
+    env  = append(env, gADMIN_ACTION_RESTART_ENVKEY + "=1")
+    p   := gproc.NewProcess(path, os.Args, env)
+    if _, err := p.Start(); err != nil {
+        glog.Errorfln("%d: fork process failed, error:%s", gproc.Pid(), err.Error())
+        return err
+    }
+    return nil
+}
+
+// 获取所有Web Server的文件描述符map
+func getServerFdMap() map[string]listenerFdMap {
+    sfm := make(map[string]listenerFdMap)
+    serverMapping.RLockFunc(func(m map[string]interface{}) {
+        for k, v := range m {
+            sfm[k] = v.(*Server).getListenerFdMap()
+        }
+    })
+    return sfm
+}
+
+// 二进制转换为FdMap
+func bufferToServerFdMap(buffer []byte) map[string]listenerFdMap {
+    sfm := make(map[string]listenerFdMap)
+    if len(buffer) > 0 {
+        j, _ := gjson.LoadContent(buffer, "json")
+        for k, _ := range j.ToMap() {
+            m := make(map[string]string)
+            for k, v := range j.GetMap(k) {
+                m[k] = gconv.String(v)
+            }
+            sfm[k] = m
+        }
+    }
+    return sfm
+}
+
+// Web Server重启
+func restartWebServers(signal string, newExeFilePath...string) error {
+    serverProcessStatus.Set(gADMIN_ACTION_RESTARTING)
+    if runtime.GOOS == "windows" {
+        if len(signal) > 0 {
+            // 在终端信号下，立即执行重启操作
+            forceCloseWebServers()
+            forkRestartProcess(newExeFilePath...)
+        } else {
+            // 非终端信号下，异步1秒后再执行重启，目的是让接口能够正确返回结果，否则接口会报错(因为web server关闭了)
+            gtimer.SetTimeout(time.Second, func() {
+                forceCloseWebServers()
+                forkRestartProcess(newExeFilePath...)
+            })
+        }
+    } else {
+        if err := forkReloadProcess(newExeFilePath...); err != nil {
+            glog.Printfln("%d: server restarts failed", gproc.Pid())
+            serverProcessStatus.Set(gADMIN_ACTION_NONE)
+            return err
+        } else {
+            if len(signal) > 0 {
+                glog.Printfln("%d: server restarting by signal: %s", gproc.Pid(), signal)
+            } else {
+                glog.Printfln("%d: server restarting by web admin", gproc.Pid())
+            }
+
+        }
+    }
+    return nil
+}
+
+// 关闭所有Web Server
+func shutdownWebServers(signal...string) {
+    serverProcessStatus.Set(gADMIN_ACTION_SHUTINGDOWN)
+    if len(signal) > 0 {
+        glog.Printfln("%d: server shutting down by signal: %s", gproc.Pid(), signal[0])
+        // 在终端信号下，立即执行关闭操作
+        forceCloseWebServers()
+        allDoneChan <- struct{}{}
+    } else {
+        glog.Printfln("%d: server shutting down by api", gproc.Pid())
+        // 非终端信号下，异步1秒后再执行关闭，
+        // 目的是让接口能够正确返回结果，否则接口会报错(因为web server关闭了)
+        gtimer.SetTimeout(time.Second, func() {
+            forceCloseWebServers()
+            allDoneChan <- struct{}{}
+        })
+    }
+}
+
+// 关优雅闭进程所有端口的Web Server服务
+// 注意，只是关闭Web Server服务，并不是退出进程
+func gracefulShutdownWebServers() {
+    serverMapping.RLockFunc(func(m map[string]interface{}) {
+        for _, v := range m {
+            for _, s := range v.(*Server).servers {
+                s.shutdown()
+            }
+        }
+    })
+}
+
+// 强制关闭进程所有端口的Web Server服务
+// 注意，只是关闭Web Server服务，并不是退出进程
+func forceCloseWebServers() {
+    serverMapping.RLockFunc(func(m map[string]interface{}) {
+        for _, v := range m {
+            for _, s := range v.(*Server).servers {
+                s.close()
+            }
+        }
+    })
+}
+
+// 异步监听进程间消息
+func handleProcessMessage() {
+    for {
+        if msg := gproc.Receive(gADMIN_GPROC_COMM_GROUP); msg != nil {
+            if bytes.EqualFold(msg.Data, []byte("exit")) {
+                gracefulShutdownWebServers()
+                allDoneChan <- struct{}{}
+                return
+            }
+        }
+    }
+}

g/net/ghttp/ghttp_server_domain.go

@@ -9,7 +9,6 @@ package ghttp
 
 import (
     "strings"
-    "github.com/gogf/gf/g/container/gmap"
 )
 
 // 域名管理器对象
@@ -18,121 +17,80 @@ type Domain struct {
     m map[string]bool // 多域名
 }
 
-// 域名对象表，用以存储和检索域名(支持多域名)与域名对象之间的关联关系
-var domainMap = gmap.NewStringInterfaceMap()
-
-// 生成一个域名对象
+// 生成一个域名对象, 参数 domains 支持给定多个域名。
 func (s *Server) Domain(domains string) *Domain {
-    if r := domainMap.Get(domains); r != nil {
-        return r.(*Domain)
-    }
     d := &Domain{
         s : s,
         m : make(map[string]bool),
     }
-    result := strings.Split(domains, ",")
-    for _, v := range result {
+    for _, v := range strings.Split(domains, ",") {
         d.m[strings.TrimSpace(v)] = true
     }
-    domainMap.Set(domains, d)
     return d
 }
 
 // 注意该方法是直接绑定方法的内存地址，执行的时候直接执行该方法，不会存在初始化新的控制器逻辑
-func (d *Domain) BindHandler(pattern string, handler HandlerFunc) error {
+func (d *Domain) BindHandler(pattern string, handler HandlerFunc) {
     for domain, _ := range d.m {
-        if err := d.s.BindHandler(pattern + "@" + domain, handler); err != nil {
-            return err
-        }
+        d.s.BindHandler(pattern + "@" + domain, handler)
     }
-    return nil
 }
 
 // 执行对象方法
-func (d *Domain) BindObject(pattern string, obj interface{}, methods...string) error {
-    if len(methods) > 0 {
-        return d.BindObjectMethod(pattern, obj, strings.Join(methods, ","))
-    }
+func (d *Domain) BindObject(pattern string, obj interface{}, methods...string) {
     for domain, _ := range d.m {
-        if err := d.s.BindObject(pattern + "@" + domain, obj); err != nil {
-            return err
-        }
+        d.s.BindObject(pattern + "@" + domain, obj, methods...)
     }
-    return nil
 }
 
 // 执行对象方法注册，methods参数不区分大小写
-func (d *Domain) BindObjectMethod(pattern string, obj interface{}, method string) error {
+func (d *Domain) BindObjectMethod(pattern string, obj interface{}, method string) {
     for domain, _ := range d.m {
-        if err := d.s.BindObjectMethod(pattern + "@" + domain, obj, method); err != nil {
-            return err
-        }
+        d.s.BindObjectMethod(pattern + "@" + domain, obj, method)
     }
-    return nil
 }
 
 // RESTful执行对象注册
-func (d *Domain) BindObjectRest(pattern string, obj interface{}) error {
+func (d *Domain) BindObjectRest(pattern string, obj interface{}) {
     for domain, _ := range d.m {
-        if err := d.s.BindObjectRest(pattern + "@" + domain, obj); err != nil {
-            return err
-        }
+        d.s.BindObjectRest(pattern + "@" + domain, obj)
     }
-    return nil
 }
 
 // 控制器注册
-func (d *Domain) BindController(pattern string, c Controller, methods...string) error {
-    if len(methods) > 0 {
-        return d.BindControllerMethod(pattern, c, strings.Join(methods, ","))
-    }
+func (d *Domain) BindController(pattern string, c Controller, methods...string) {
     for domain, _ := range d.m {
-        if err := d.s.BindController(pattern + "@" + domain, c); err != nil {
-            return err
-        }
+        d.s.BindController(pattern + "@" + domain, c, methods...)
     }
-    return nil
 }
 
 // 控制器方法注册，methods参数区分大小写
-func (d *Domain) BindControllerMethod(pattern string, c Controller, method string) error {
+func (d *Domain) BindControllerMethod(pattern string, c Controller, method string) {
     for domain, _ := range d.m {
-        if err := d.s.BindControllerMethod(pattern + "@" + domain, c, method); err != nil {
-            return err
-        }
+        d.s.BindControllerMethod(pattern + "@" + domain, c, method)
     }
-    return nil
 }
 
 // RESTful控制器注册
-func (d *Domain) BindControllerRest(pattern string, c Controller) error {
+func (d *Domain) BindControllerRest(pattern string, c Controller) {
     for domain, _ := range d.m {
-        if err := d.s.BindControllerRest(pattern + "@" + domain, c); err != nil {
-            return err
-        }
+        d.s.BindControllerRest(pattern + "@" + domain, c)
     }
-    return nil
 }
 
 // 绑定指定的hook回调函数, hook参数的值由ghttp server设定，参数不区分大小写
 // 目前hook支持：Init/Shut
-func (d *Domain)BindHookHandler(pattern string, hook string, handler HandlerFunc) error {
+func (d *Domain)BindHookHandler(pattern string, hook string, handler HandlerFunc) {
     for domain, _ := range d.m {
-        if err := d.s.BindHookHandler(pattern + "@" + domain, hook, handler); err != nil {
-            return err
-        }
+        d.s.BindHookHandler(pattern + "@" + domain, hook, handler)
     }
-    return nil
 }
 
 // 通过map批量绑定回调函数
-func (d *Domain)BindHookHandlerByMap(pattern string, hookmap map[string]HandlerFunc) error {
+func (d *Domain)BindHookHandlerByMap(pattern string, hookmap map[string]HandlerFunc) {
     for domain, _ := range d.m {
-        if err := d.s.BindHookHandlerByMap(pattern + "@" + domain, hookmap); err != nil {
-            return err
-        }
+        d.s.BindHookHandlerByMap(pattern + "@" + domain, hookmap)
     }
-    return nil
 }
 
 // 绑定指定的状态码回调函数

g/net/ghttp/ghttp_server_handler.go

@@ -24,7 +24,7 @@ func (s *Server)defaultHttpHandle(w http.ResponseWriter, r *http.Request) {
     s.handleRequest(w, r)
 }
 
-// 执行处理HTTP请求
+// 执行处理HTTP请求，
 // 首先，查找是否有对应域名的处理接口配置；
 // 其次，如果没有对应的自定义处理接口配置，那么走默认的域名处理接口配置；
 // 最后，如果以上都没有找到处理接口，那么进行文件处理；
@@ -55,12 +55,11 @@ func (s *Server)handleRequest(w http.ResponseWriter, r *http.Request) {
         // 输出Cookie
         request.Cookie.Output()
         // 输出缓冲区
-        request.Response.OutputBuffer()
+        request.Response.Output()
         // 事件 - AfterOutput
         if !request.IsExited() {
             s.callHookHandler(HOOK_AFTER_OUTPUT, request)
         }
-
         // 事件 - BeforeClose
         s.callHookHandler(HOOK_BEFORE_CLOSE, request)
         // access log
@@ -92,7 +91,7 @@ func (s *Server)handleRequest(w http.ResponseWriter, r *http.Request) {
 
     // 动态服务检索
     handler := (*handlerItem)(nil)
-    if !request.IsFileRequest() || isStaticDir {
+    if !request.isFileRequest || isStaticDir {
         if parsedItem := s.getServeHandlerWithCache(request); parsedItem != nil {
             handler = parsedItem.handler
             for k, v := range parsedItem.values {
@@ -112,9 +111,9 @@ func (s *Server)handleRequest(w http.ResponseWriter, r *http.Request) {
 
     // 执行静态文件服务/回调控制器/执行对象/方法
     if !request.IsExited() {
-        // 需要再次判断文件是否真实存在，因为文件检索可能使用了缓存，从健壮性考虑这里需要二次判断
+        // 需要再次判断文件是否真实存在，
+        // 因为文件检索可能使用了缓存，从健壮性考虑这里需要二次判断
         if request.isFileRequest /* && gfile.Exists(staticFile) */{
-            // 静态文件
             s.serveFile(request, staticFile)
         } else {
             if handler != nil {

g/net/ghttp/ghttp_server_router.go

@@ -60,10 +60,11 @@ func (s *Server) getHandlerRegisterCallerLine(handler *handlerItem) string {
 
 // 路由注册处理方法。
 // 如果带有hook参数，表示是回调注册方法; 否则为普通路由执行方法。
-func (s *Server) setHandler(pattern string, handler *handlerItem, hook ... string) (resultErr error) {
+func (s *Server) setHandler(pattern string, handler *handlerItem, hook ... string) {
     // Web Server正常运行时无法动态注册路由方法
     if s.Status() == SERVER_STATUS_RUNNING {
-        return errors.New("cannot bind handler while server running")
+        glog.Error("cannot bind handler while server running")
+        return
     }
     var hookName string
     if len(hook) > 0 {
@@ -71,29 +72,18 @@ func (s *Server) setHandler(pattern string, handler *handlerItem, hook ... strin
     }
     domain, method, uri, err := s.parsePattern(pattern)
     if err != nil {
-        return errors.New("invalid pattern")
+        glog.Error("invalid pattern:", pattern)
+        return
     }
     // 注册地址记录及重复注册判断
     regkey := s.handlerKey(hookName, method, uri, domain)
     caller := s.getHandlerRegisterCallerLine(handler)
     if len(hook) == 0 {
         if item, ok := s.routesMap[regkey]; ok {
-            s := fmt.Sprintf(`duplicated route registry "%s", already registered in %s`, pattern, item[0].file)
-            glog.Errorfln(s)
-            return errors.New(s)
+            glog.Errorfln(`duplicated route registry "%s", already registered in %s`, pattern, item[0].file)
+            return
         }
     }
-    defer func() {
-        if resultErr == nil {
-            if _, ok := s.routesMap[regkey]; !ok {
-                s.routesMap[regkey] = make([]registeredRouteItem, 0)
-            }
-            s.routesMap[regkey] = append(s.routesMap[regkey], registeredRouteItem {
-                file    : caller,
-                handler : handler,
-            })
-        }
-    }()
 
     // 路由对象
     handler.router = &Router {
@@ -193,9 +183,15 @@ func (s *Server) setHandler(pattern string, handler *handlerItem, hook ... strin
             l.PushBack(handler)
         }
     }
-    //gutil.Dump(s.serveTree)
-    //gutil.Dump(s.hooksTree)
-    return nil
+    // gutil.Dump(s.serveTree)
+    // gutil.Dump(s.hooksTree)
+    if _, ok := s.routesMap[regkey]; !ok {
+        s.routesMap[regkey] = make([]registeredRouteItem, 0)
+    }
+    s.routesMap[regkey] = append(s.routesMap[regkey], registeredRouteItem {
+        file    : caller,
+        handler : handler,
+    })
 }
 
 // 对比两个handlerItem的优先级，需要非常注意的是，注意新老对比项的参数先后顺序。

g/net/ghttp/ghttp_server_router_hook.go

@@ -18,8 +18,8 @@ import (
 )
 
 // 绑定指定的hook回调函数, pattern参数同BindHandler，支持命名路由；hook参数的值由ghttp server设定，参数不区分大小写
-func (s *Server)BindHookHandler(pattern string, hook string, handler HandlerFunc) error {
-    return s.setHandler(pattern, &handlerItem {
+func (s *Server)BindHookHandler(pattern string, hook string, handler HandlerFunc) {
+    s.setHandler(pattern, &handlerItem {
         name  : runtime.FuncForPC(reflect.ValueOf(handler).Pointer()).Name(),
         ctype : nil,
         fname : "",
@@ -28,13 +28,10 @@ func (s *Server)BindHookHandler(pattern string, hook string, handler HandlerFunc
 }
 
 // 通过map批量绑定回调函数
-func (s *Server)BindHookHandlerByMap(pattern string, hookmap map[string]HandlerFunc) error {
+func (s *Server)BindHookHandlerByMap(pattern string, hookmap map[string]HandlerFunc) {
     for k, v := range hookmap {
-        if err := s.BindHookHandler(pattern, k, v); err != nil {
-            return err
-        }
+        s.BindHookHandler(pattern, k, v)
     }
-    return nil
 }
 
 // 事件回调处理，内部使用了缓存处理.

g/net/ghttp/ghttp_server_service_controller.go

@@ -8,19 +8,19 @@
 package ghttp
 
 import (
-    "errors"
-    "github.com/gogf/gf/g/os/glog"
-    "strings"
-    "reflect"
     "fmt"
     "github.com/gogf/gf/g/os/gfile"
+    "github.com/gogf/gf/g/os/glog"
+    "github.com/gogf/gf/g/text/gregex"
     "github.com/gogf/gf/g/text/gstr"
+    "reflect"
+    "strings"
 )
 
-// 绑定控制器，控制器需要实现gmvc.Controller接口
-// 这种方式绑定的控制器每一次请求都会初始化一个新的控制器对象进行处理，对应不同的请求会话
-// 第三个参数methods用以指定需要注册的方法，支持多个方法名称，多个方法以英文“,”号分隔，区分大小写
-func (s *Server)BindController(pattern string, c Controller, methods...string) error {
+// 绑定控制器，控制器需要实现 gmvc.Controller 接口,
+// 这种方式绑定的控制器每一次请求都会初始化一个新的控制器对象进行处理，对应不同的请求会话,
+// 第三个参数methods用以指定需要注册的方法，支持多个方法名称，多个方法以英文“,”号分隔，区分大小写.
+func (s *Server)BindController(pattern string, c Controller, methods...string) {
     methodMap := (map[string]bool)(nil)
     if len(methods) > 0 {
         methodMap = make(map[string]bool)
@@ -44,11 +44,7 @@ func (s *Server)BindController(pattern string, c Controller, methods...string) e
             continue
         }
         if _, ok := v.Method(i).Interface().(func()); !ok {
-            if methodMap != nil {
-                s := fmt.Sprintf(`invalid medthod definition "%s", while "func()" is required`, v.Method(i).Type().String())
-                glog.Error(s)
-                return errors.New(s)
-            }
+            glog.Errorfln(`invalid method definition "%s", while "func()" is required`, v.Method(i).Type().String())
             continue
         }
         ctlName := gstr.Replace(t.String(), fmt.Sprintf(`%s.`, pkgName), "")
@@ -63,12 +59,17 @@ func (s *Server)BindController(pattern string, c Controller, methods...string) e
             fname : mname,
             faddr : nil,
         }
-        // 如果方法中带有Index方法，那么额外自动增加一个路由规则匹配主URI
-        // 例如: pattern为/user, 那么会同时注册/user及/user/index,
-        // 这里处理新增/user路由绑定
-        if strings.EqualFold(mname, "Index") {
+        // 如果方法中带有Index方法，那么额外自动增加一个路由规则匹配主URI，
+        // 例如: pattern为/user, 那么会同时注册/user及/user/index，
+        // 这里处理新增/user路由绑定。
+        // 注意，当pattern带有内置变量时，不会自动加该路由。
+        if strings.EqualFold(mname, "Index") && !gregex.IsMatchString(`\{\.\w+\}`, pattern) {
             p := gstr.PosR(key, "/index")
-            m[key[0 : p] + key[p + 6 : ]] = &handlerItem {
+            k := key[0 : p] + key[p + 6 : ]
+            if len(k) == 0 || k[0] == '@' {
+                k = "/" + k
+            }
+            m[k] = &handlerItem {
                 name  : fmt.Sprintf(`%s.%s.%s`, pkgPath, ctlName, mname),
                 rtype : gROUTE_REGISTER_CONTROLLER,
                 ctype : v.Elem().Type(),
@@ -77,11 +78,11 @@ func (s *Server)BindController(pattern string, c Controller, methods...string) e
             }
         }
     }
-    return s.bindHandlerByMap(m)
+    s.bindHandlerByMap(m)
 }
 
-// 绑定路由到指定的方法执行
-func (s *Server)BindControllerMethod(pattern string, c Controller, method string) error {
+// 绑定路由到指定的方法执行, 第三个参数method仅支持一个方法注册，不支持多个，并且区分大小写。
+func (s *Server)BindControllerMethod(pattern string, c Controller, method string) {
     m     := make(handlerMap)
     v     := reflect.ValueOf(c)
     t     := v.Type()
@@ -89,12 +90,12 @@ func (s *Server)BindControllerMethod(pattern string, c Controller, method string
     mname := strings.TrimSpace(method)
     fval  := v.MethodByName(mname)
     if !fval.IsValid() {
-        return errors.New("invalid method name:" + mname)
+        glog.Error("invalid method name:" + mname)
+        return
     }
     if _, ok := fval.Interface().(func()); !ok {
-        s := fmt.Sprintf(`invalid medthod definition "%s", while "func()" is required`, fval.Type().String())
-        glog.Error(s)
-        return errors.New(s)
+        glog.Errorfln(`invalid method definition "%s", while "func()" is required`, fval.Type().String())
+        return
     }
     pkgPath := t.Elem().PkgPath()
     pkgName := gfile.Basename(pkgPath)
@@ -110,37 +111,37 @@ func (s *Server)BindControllerMethod(pattern string, c Controller, method string
         fname : mname,
         faddr : nil,
     }
-    return s.bindHandlerByMap(m)
+    s.bindHandlerByMap(m)
 }
 
 // 绑定控制器(RESTFul)，控制器需要实现gmvc.Controller接口
 // 方法会识别HTTP方法，并做REST绑定处理，例如：Post方法会绑定到HTTP POST的方法请求处理，Delete方法会绑定到HTTP DELETE的方法请求处理
 // 因此只会绑定HTTP Method对应的方法，其他方法不会自动注册绑定
 // 这种方式绑定的控制器每一次请求都会初始化一个新的控制器对象进行处理，对应不同的请求会话
-func (s *Server)BindControllerRest(pattern string, c Controller) error {
+func (s *Server)BindControllerRest(pattern string, c Controller) {
     // 遍历控制器，获取方法列表，并构造成uri
     m       := make(handlerMap)
     v       := reflect.ValueOf(c)
     t       := v.Type()
+    sname   := t.Elem().Name()
     pkgPath := t.Elem().PkgPath()
     // 如果存在与HttpMethod对应名字的方法，那么绑定这些方法
     for i := 0; i < v.NumMethod(); i++ {
         mname  := t.Method(i).Name
         method := strings.ToUpper(mname)
-        if _, ok := s.methodsMap[method]; !ok {
+        if _, ok := methodsMap[method]; !ok {
             continue
         }
         if _, ok := v.Method(i).Interface().(func()); !ok {
-            s := fmt.Sprintf(`invalid medthod definition "%s", while "func()" is required`, v.Method(i).Type().String())
-            glog.Error(s)
-            return errors.New(s)
+            glog.Errorfln(`invalid method definition "%s", while "func()" is required`, v.Method(i).Type().String())
+            return
         }
         pkgName := gfile.Basename(pkgPath)
         ctlName := gstr.Replace(t.String(), fmt.Sprintf(`%s.`, pkgName), "")
         if ctlName[0] == '*' {
             ctlName = fmt.Sprintf(`(%s)`, ctlName)
         }
-        key   := mname + ":" + pattern
+        key   := s.mergeBuildInNameToPattern(mname + ":" + pattern, sname, mname, false)
         m[key] = &handlerItem {
             name  : fmt.Sprintf(`%s.%s.%s`, pkgPath, ctlName, mname),
             rtype : gROUTE_REGISTER_CONTROLLER,
@@ -149,5 +150,5 @@ func (s *Server)BindControllerRest(pattern string, c Controller) error {
             faddr : nil,
         }
     }
-    return s.bindHandlerByMap(m)
+    s.bindHandlerByMap(m)
 }

g/net/ghttp/ghttp_server_service_handler.go

@@ -8,17 +8,17 @@
 package ghttp
 
 import (
-    "errors"
-    "strings"
-    "github.com/gogf/gf/g/text/gstr"
     "bytes"
-    "runtime"
+    "github.com/gogf/gf/g/os/glog"
+    "github.com/gogf/gf/g/text/gstr"
     "reflect"
+    "runtime"
+    "strings"
 )
 
 // 注意该方法是直接绑定函数的内存地址，执行的时候直接执行该方法，不会存在初始化新的控制器逻辑
-func (s *Server) BindHandler(pattern string, handler HandlerFunc) error {
-    return s.bindHandlerItem(pattern, &handlerItem {
+func (s *Server) BindHandler(pattern string, handler HandlerFunc) {
+    s.bindHandlerItem(pattern, &handlerItem {
         name  : runtime.FuncForPC(reflect.ValueOf(handler).Pointer()).Name(),
         rtype : gROUTE_REGISTER_HANDLER,
         ctype : nil,
@@ -30,26 +30,24 @@ func (s *Server) BindHandler(pattern string, handler HandlerFunc) error {
 // 绑定URI到操作函数/方法
 // pattern的格式形如：/user/list, put:/user, delete:/user, post:/user@johng.cn
 // 支持RESTful的请求格式，具体业务逻辑由绑定的处理方法来执行
-func (s *Server) bindHandlerItem(pattern string, item *handlerItem) error {
+func (s *Server) bindHandlerItem(pattern string, item *handlerItem) {
     if s.Status() == SERVER_STATUS_RUNNING {
-        return errors.New("server handlers cannot be changed while running")
+        glog.Error("server handlers cannot be changed while running")
+        return
     }
-    return s.setHandler(pattern, item)
+    s.setHandler(pattern, item)
 }
 
 // 通过映射数组绑定URI到操作函数/方法
-func (s *Server) bindHandlerByMap(m handlerMap) error {
+func (s *Server) bindHandlerByMap(m handlerMap) {
     for p, h := range m {
-        if err := s.bindHandlerItem(p, h); err != nil {
-            return err
-        }
+        s.bindHandlerItem(p, h)
     }
-    return nil
 }
 
 // 将内置的名称按照设定的规则合并到pattern中，内置名称按照{.xxx}规则命名。
 // 规则1：pattern中的URI包含{.struct}关键字，则替换该关键字为结构体名称；
-// 规则1：pattern中的URI包含{.method}关键字，则替换该关键字为方法名称；
+// 规则2：pattern中的URI包含{.method}关键字，则替换该关键字为方法名称；
 // 规则2：如果不满足规则1，那么直接将防发明附加到pattern中的URI后面；
 func (s *Server) mergeBuildInNameToPattern(pattern string, structName, methodName string, allowAppend bool) string {
     structName = s.nameToUrlPart(structName)

g/net/ghttp/ghttp_server_service_object.go

@@ -8,18 +8,18 @@
 package ghttp
 
 import (
-    "errors"
-    "github.com/gogf/gf/g/os/glog"
-    "strings"
-    "reflect"
     "fmt"
-    "github.com/gogf/gf/g/text/gstr"
     "github.com/gogf/gf/g/os/gfile"
+    "github.com/gogf/gf/g/os/glog"
+    "github.com/gogf/gf/g/text/gregex"
+    "github.com/gogf/gf/g/text/gstr"
+    "reflect"
+    "strings"
 )
 
 // 绑定对象到URI请求处理中，会自动识别方法名称，并附加到对应的URI地址后面
 // 第三个参数methods用以指定需要注册的方法，支持多个方法名称，多个方法以英文“,”号分隔，区分大小写
-func (s *Server)BindObject(pattern string, obj interface{}, methods...string) error {
+func (s *Server)BindObject(pattern string, obj interface{}, methods...string) {
     methodMap := (map[string]bool)(nil)
     if len(methods) > 0 {
         methodMap = make(map[string]bool)
@@ -51,11 +51,7 @@ func (s *Server)BindObject(pattern string, obj interface{}, methods...string) er
         }
         faddr, ok := v.Method(i).Interface().(func(*Request))
         if !ok {
-            if methodMap != nil {
-                s := fmt.Sprintf(`invalid medthod definition "%s", while "func(*Request))" is required`, v.Method(i).Type().String())
-                glog.Error(s)
-                return errors.New(s)
-            }
+            glog.Errorfln(`invalid method definition "%s", while "func(*Request))" is required`, v.Method(i).Type().String())
             continue
         }
         objName := gstr.Replace(t.String(), fmt.Sprintf(`%s.`, pkgName), "")
@@ -72,10 +68,15 @@ func (s *Server)BindObject(pattern string, obj interface{}, methods...string) er
             finit : finit,
             fshut : fshut,
         }
-        // 如果方法中带有Index方法，那么额外自动增加一个路由规则匹配主URI
-        if strings.EqualFold(mname, "Index") {
+        // 如果方法中带有Index方法，那么额外自动增加一个路由规则匹配主URI。
+        // 注意，当pattern带有内置变量时，不会自动加该路由。
+        if strings.EqualFold(mname, "Index") && !gregex.IsMatchString(`\{\.\w+\}`, pattern) {
             p := gstr.PosR(key, "/index")
-            m[key[0 : p] + key[p + 6 : ]] = &handlerItem {
+            k := key[0 : p] + key[p + 6 : ]
+            if len(k) == 0 || k[0] == '@' {
+                k = "/" + k
+            }
+            m[k] = &handlerItem {
                 name  : fmt.Sprintf(`%s.%s.%s`, pkgPath, objName, mname),
                 rtype : gROUTE_REGISTER_OBJECT,
                 ctype : nil,
@@ -86,12 +87,12 @@ func (s *Server)BindObject(pattern string, obj interface{}, methods...string) er
             }
         }
     }
-    return s.bindHandlerByMap(m)
+    s.bindHandlerByMap(m)
 }
 
-// 绑定对象到URI请求处理中，会自动识别方法名称，并附加到对应的URI地址后面
-// 第三个参数methods支持多个方法注册，多个方法以英文“,”号分隔，区分大小写
-func (s *Server)BindObjectMethod(pattern string, obj interface{}, method string) error {
+// 绑定对象到URI请求处理中，会自动识别方法名称，并附加到对应的URI地址后面，
+// 第三个参数method仅支持一个方法注册，不支持多个，并且区分大小写。
+func (s *Server)BindObjectMethod(pattern string, obj interface{}, method string) {
     m     := make(handlerMap)
     v     := reflect.ValueOf(obj)
     t     := v.Type()
@@ -99,13 +100,13 @@ func (s *Server)BindObjectMethod(pattern string, obj interface{}, method string)
     mname := strings.TrimSpace(method)
     fval  := v.MethodByName(mname)
     if !fval.IsValid() {
-        return errors.New("invalid method name:" + mname)
+        glog.Error("invalid method name:" + mname)
+        return
     }
     faddr, ok := fval.Interface().(func(*Request))
     if !ok {
-        s := fmt.Sprintf(`invalid medthod definition "%s", while "func(*Request)" is required`, fval.Type().String())
-        glog.Error(s)
-        return errors.New(s)
+        glog.Errorfln(`invalid method definition "%s", while "func(*Request)" is required`, fval.Type().String())
+        return
     }
     finit := (func(*Request))(nil)
     fshut := (func(*Request))(nil)
@@ -132,15 +133,16 @@ func (s *Server)BindObjectMethod(pattern string, obj interface{}, method string)
         fshut : fshut,
     }
 
-    return s.bindHandlerByMap(m)
+    s.bindHandlerByMap(m)
 }
 
-// 绑定对象到URI请求处理中，会自动识别方法名称，并附加到对应的URI地址后面
-// 需要注意对象方法的定义必须按照ghttp.HandlerFunc来定义
-func (s *Server)BindObjectRest(pattern string, obj interface{}) error {
+// 绑定对象到URI请求处理中，会自动识别方法名称，并附加到对应的URI地址后面,
+// 需要注意对象方法的定义必须按照 ghttp.HandlerFunc 来定义
+func (s *Server)BindObjectRest(pattern string, obj interface{}) {
     m     := make(handlerMap)
     v     := reflect.ValueOf(obj)
     t     := v.Type()
+    sname := t.Elem().Name()
     finit := (func(*Request))(nil)
     fshut := (func(*Request))(nil)
     if v.MethodByName("Init").IsValid() {
@@ -153,21 +155,20 @@ func (s *Server)BindObjectRest(pattern string, obj interface{}) error {
     for i := 0; i < v.NumMethod(); i++ {
         mname  := t.Method(i).Name
         method := strings.ToUpper(mname)
-        if _, ok := s.methodsMap[method]; !ok {
+        if _, ok := methodsMap[method]; !ok {
             continue
         }
         faddr, ok := v.Method(i).Interface().(func(*Request))
         if !ok {
-            s := fmt.Sprintf(`invalid medthod definition "%s", while "func()" is required`, v.Method(i).Type().String())
-            glog.Error(s)
-            return errors.New(s)
+            glog.Errorfln(`invalid method definition "%s", while "func(*Request)" is required`, v.Method(i).Type().String())
+            continue
         }
         pkgName := gfile.Basename(pkgPath)
         objName := gstr.Replace(t.String(), fmt.Sprintf(`%s.`, pkgName), "")
         if objName[0] == '*' {
             objName = fmt.Sprintf(`(%s)`, objName)
         }
-        key   := mname + ":" + pattern
+        key   := s.mergeBuildInNameToPattern(mname + ":" + pattern, sname, mname, false)
         m[key] = &handlerItem {
             name  : fmt.Sprintf(`%s.%s.%s`, pkgPath, objName, mname),
             rtype : gROUTE_REGISTER_OBJECT,
@@ -178,5 +179,5 @@ func (s *Server)BindObjectRest(pattern string, obj interface{}) error {
             fshut : fshut,
         }
     }
-    return s.bindHandlerByMap(m)
+    s.bindHandlerByMap(m)
 }

g/net/ghttp/ghttp_unit_cookie_test.go

@@ -8,16 +8,17 @@
 package ghttp_test
 
 import (
+    "fmt"
     "github.com/gogf/gf/g"
     "github.com/gogf/gf/g/net/ghttp"
-    "github.com/gogf/gf/g/os/gtime"
     "github.com/gogf/gf/g/test/gtest"
     "testing"
     "time"
 )
 
 func Test_Cookie(t *testing.T) {
-    s := g.Server(gtime.Nanosecond())
+    p := ports.PopRand()
+    s := g.Server(p)
     s.BindHandler("/set", func(r *ghttp.Request){
         r.Cookie.Set(r.Get("k"), r.Get("v"))
     })
@@ -28,19 +29,17 @@ func Test_Cookie(t *testing.T) {
     s.BindHandler("/remove", func(r *ghttp.Request){
         r.Cookie.Remove(r.Get("k"))
     })
-    s.SetPort(8500)
+    s.SetPort(p)
     s.SetDumpRouteMap(false)
-    go s.Run()
-    defer func() {
-        s.Shutdown()
-        time.Sleep(time.Second)
-    }()
+    s.Start()
+    defer s.Shutdown()
+
     // 等待启动完成
     time.Sleep(time.Second)
     gtest.Case(t, func() {
         client := ghttp.NewClient()
         client.SetBrowserMode(true)
-        client.SetPrefix("http://127.0.0.1:8500")
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
         r1, e1 := client.Get("/set?k=key1&v=100")
         if r1 != nil {
             defer r1.Close()

g/net/ghttp/ghttp_unit_init_test.go

@@ -0,0 +1,25 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+// 测试初始化
+package ghttp_test
+
+import (
+    "github.com/gogf/gf/g/container/garray"
+)
+
+var (
+    // 用于测试的端口数组，随机获取
+    ports = garray.NewIntArray()
+)
+
+func init() {
+    for i := 8000; i <= 8100; i++ {
+        ports.Append(i)
+    }
+}
+
+

g/net/ghttp/ghttp_unit_param_json_test.go

@@ -0,0 +1,79 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package ghttp_test
+
+import (
+    "encoding/json"
+    "fmt"
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/net/ghttp"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+func Test_Params_Json(t *testing.T) {
+    type User struct {
+        Uid      int
+        Name     string
+        SiteUrl  string `gconv:"-"`
+        NickName string `gconv:"nickname, omitempty"`
+        Pass1    string `gconv:"password1"`
+        Pass2    string `gconv:"password2"`
+    }
+
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.BindHandler("/json1", func(r *ghttp.Request){
+        r.Response.WriteJson(User{
+            Uid      : 100,
+            Name     : "john",
+            SiteUrl  : "https://goframe.org",
+            Pass1    : "123",
+            Pass2    : "456",
+        })
+    })
+    s.BindHandler("/json2", func(r *ghttp.Request){
+        r.Response.WriteJson(&User{
+            Uid      : 100,
+            Name     : "john",
+            SiteUrl  : "https://goframe.org",
+            Pass1    : "123",
+            Pass2    : "456",
+        })
+    })
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        map1 := make(map[string]interface{})
+        err1 := json.Unmarshal([]byte(client.GetContent("/json1")), &map1)
+        gtest.Assert(err1,      nil)
+        gtest.Assert(len(map1), 4)
+        gtest.Assert(map1["Name"],       "john")
+        gtest.Assert(map1["Uid"],        100)
+        gtest.Assert(map1["password1"],  "123")
+        gtest.Assert(map1["password2"],  "456")
+
+        map2 := make(map[string]interface{})
+        err2 := json.Unmarshal([]byte(client.GetContent("/json1")), &map2)
+        gtest.Assert(err2,      nil)
+        gtest.Assert(len(map2), 4)
+        gtest.Assert(map2["Name"],       "john")
+        gtest.Assert(map2["Uid"],        100)
+        gtest.Assert(map2["password1"],  "123")
+        gtest.Assert(map2["password2"],  "456")
+
+    })
+}

g/net/ghttp/ghttp_unit_param_test.go

@@ -8,22 +8,23 @@
 package ghttp_test
 
 import (
+    "fmt"
     "github.com/gogf/gf/g"
     "github.com/gogf/gf/g/net/ghttp"
-    "github.com/gogf/gf/g/os/gtime"
     "github.com/gogf/gf/g/test/gtest"
     "testing"
     "time"
 )
 
-func Test_Params(t *testing.T) {
+func Test_Params_Basic(t *testing.T) {
     type User struct {
         Id    int
         Name  string
         Pass1 string `params:"password1"`
         Pass2 string `params:"password2"`
     }
-    s := g.Server(gtime.Nanosecond())
+    p := ports.PopRand()
+    s := g.Server(p)
     s.BindHandler("/get", func(r *ghttp.Request){
         if r.GetQuery("slice") != nil {
             r.Response.Write(r.GetQuery("slice"))
@@ -96,18 +97,16 @@ func Test_Params(t *testing.T) {
             r.Response.Write(user.Id, user.Name, user.Pass1, user.Pass2)
         }
     })
-    s.SetPort(8400)
+    s.SetPort(p)
     s.SetDumpRouteMap(false)
-    go s.Run()
-    defer func() {
-        s.Shutdown()
-        time.Sleep(time.Second)
-    }()
+    s.Start()
+    defer s.Shutdown()
+
     // 等待启动完成
     time.Sleep(time.Second)
     gtest.Case(t, func() {
         client := ghttp.NewClient()
-        client.SetPrefix("http://127.0.0.1:8400")
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
         // GET
         gtest.Assert(client.GetContent("/get", "slice=1&slice=2"), `["1","2"]`)
         gtest.Assert(client.GetContent("/get", "bool=1"),          `true`)

g/net/ghttp/ghttp_unit_router_basic_test.go

@@ -8,18 +8,18 @@
 package ghttp_test
 
 import (
+    "fmt"
     "github.com/gogf/gf/g"
     "github.com/gogf/gf/g/net/ghttp"
-    "github.com/gogf/gf/g/os/gtime"
     "github.com/gogf/gf/g/test/gtest"
     "testing"
     "time"
 )
 
-
 // 基本路由功能测试
 func Test_Router_Basic(t *testing.T) {
-    s := g.Server(gtime.Nanosecond())
+    p := ports.PopRand()
+    s := g.Server(p)
     s.BindHandler("/:name", func(r *ghttp.Request){
         r.Response.Write("/:name")
     })
@@ -35,19 +35,16 @@ func Test_Router_Basic(t *testing.T) {
     s.BindHandler("/user/list/{field}.html", func(r *ghttp.Request){
         r.Response.Write(r.Get("field"))
     })
-    s.SetPort(8100)
+    s.SetPort(p)
     s.SetDumpRouteMap(false)
-    go s.Run()
-    defer func() {
-        s.Shutdown()
-        time.Sleep(time.Second)
-    }()
+    s.Start()
+    defer s.Shutdown()
+
     // 等待启动完成
     time.Sleep(time.Second)
     gtest.Case(t, func() {
         client := ghttp.NewClient()
-        client.SetPrefix("http://127.0.0.1:8100")
-        
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
         gtest.Assert(client.GetContent("/john"),               "")
         gtest.Assert(client.GetContent("/john/update"),        "john")
         gtest.Assert(client.GetContent("/john/edit"),          "edit")
@@ -57,25 +54,24 @@ func Test_Router_Basic(t *testing.T) {
 
 // 测试HTTP Method注册.
 func Test_Router_Method(t *testing.T) {
-    s := g.Server(gtime.Nanosecond())
+    p := ports.PopRand()
+    s := g.Server(p)
     s.BindHandler("GET:/get", func(r *ghttp.Request){
 
     })
     s.BindHandler("POST:/post", func(r *ghttp.Request){
 
     })
-    s.SetPort(8105)
+    s.SetPort(p)
     s.SetDumpRouteMap(false)
-    go s.Run()
-    defer func() {
-        s.Shutdown()
-        time.Sleep(time.Second)
-    }()
+    s.Start()
+    defer s.Shutdown()
+
     // 等待启动完成
     time.Sleep(time.Second)
     gtest.Case(t, func() {
         client := ghttp.NewClient()
-        client.SetPrefix("http://127.0.0.1:8105")
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
 
         resp1, err := client.Get("/get")
         defer resp1.Close()
@@ -101,7 +97,8 @@ func Test_Router_Method(t *testing.T) {
 
 // 测试状态返回.
 func Test_Router_Status(t *testing.T) {
-    s := g.Server(gtime.Nanosecond())
+    p := ports.PopRand()
+    s := g.Server(p)
     s.BindHandler("/200", func(r *ghttp.Request){
         r.Response.WriteStatus(200)
     })
@@ -114,18 +111,16 @@ func Test_Router_Status(t *testing.T) {
     s.BindHandler("/500", func(r *ghttp.Request){
         r.Response.WriteStatus(500)
     })
-    s.SetPort(8110)
+    s.SetPort(p)
     s.SetDumpRouteMap(false)
-    go s.Run()
-    defer func() {
-        s.Shutdown()
-        time.Sleep(time.Second)
-    }()
+    s.Start()
+    defer s.Shutdown()
+
     // 等待启动完成
     time.Sleep(time.Second)
     gtest.Case(t, func() {
         client := ghttp.NewClient()
-        client.SetPrefix("http://127.0.0.1:8110")
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
 
         resp1, err := client.Get("/200")
         defer resp1.Close()
@@ -151,25 +146,24 @@ func Test_Router_Status(t *testing.T) {
 
 // 自定义状态码处理.
 func Test_Router_CustomStatusHandler(t *testing.T) {
-    s := g.Server(gtime.Nanosecond())
+    p := ports.PopRand()
+    s := g.Server(p)
     s.BindHandler("/", func(r *ghttp.Request){
         r.Response.Write("hello")
     })
     s.BindStatusHandler(404, func(r *ghttp.Request){
         r.Response.Write("404 page")
     })
-    s.SetPort(8120)
+    s.SetPort(p)
     s.SetDumpRouteMap(false)
-    go s.Run()
-    defer func() {
-        s.Shutdown()
-        time.Sleep(time.Second)
-    }()
+    s.Start()
+    defer s.Shutdown()
+
     // 等待启动完成
     time.Sleep(time.Second)
     gtest.Case(t, func() {
         client := ghttp.NewClient()
-        client.SetPrefix("http://127.0.0.1:8120")
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
 
         gtest.Assert(client.GetContent("/"), "hello")
         resp, err := client.Get("/ThisDoesNotExist")
@@ -182,22 +176,21 @@ func Test_Router_CustomStatusHandler(t *testing.T) {
 
 // 测试不存在的路由.
 func Test_Router_404(t *testing.T) {
-    s := g.Server(gtime.Nanosecond())
+    p := ports.PopRand()
+    s := g.Server(p)
     s.BindHandler("/", func(r *ghttp.Request){
         r.Response.Write("hello")
     })
-    s.SetPort(8130)
+    s.SetPort(p)
     s.SetDumpRouteMap(false)
-    go s.Run()
-    defer func() {
-        s.Shutdown()
-        time.Sleep(time.Second)
-    }()
+    s.Start()
+    defer s.Shutdown()
+
     // 等待启动完成
     time.Sleep(time.Second)
     gtest.Case(t, func() {
         client := ghttp.NewClient()
-        client.SetPrefix("http://127.0.0.1:8130")
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
 
         gtest.Assert(client.GetContent("/"), "hello")
         resp, err := client.Get("/ThisDoesNotExist")

g/net/ghttp/ghttp_unit_router_controller_rest_test.go

@@ -0,0 +1,106 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package ghttp_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/frame/gmvc"
+    "github.com/gogf/gf/g/net/ghttp"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+
+type ControllerRest struct {
+    gmvc.Controller
+}
+
+func (c *ControllerRest) Init(r *ghttp.Request)  {
+    c.Controller.Init(r)
+    c.Response.Write("1")
+}
+
+func (c *ControllerRest) Shut() {
+    c.Response.Write("2")
+}
+
+func (c *ControllerRest) Get() {
+    c.Response.Write("Controller Get")
+}
+
+func (c *ControllerRest) Put() {
+    c.Response.Write("Controller Put")
+}
+
+func (c *ControllerRest) Post() {
+    c.Response.Write("Controller Post")
+}
+
+func (c *ControllerRest) Delete() {
+    c.Response.Write("Controller Delete")
+}
+
+func (c *ControllerRest) Patch() {
+    c.Response.Write("Controller Patch")
+}
+
+func (c *ControllerRest) Options() {
+    c.Response.Write("Controller Options")
+}
+
+func (c *ControllerRest) Head() {
+    c.Response.Header().Set("head-ok", "1")
+}
+
+// 控制器注册测试
+func Test_Router_ControllerRest(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.BindControllerRest("/", new(ControllerRest))
+    s.BindControllerRest("/{.struct}/{.method}", new(ControllerRest))
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),            "1Controller Get2")
+        gtest.Assert(client.PutContent("/"),            "1Controller Put2")
+        gtest.Assert(client.PostContent("/"),           "1Controller Post2")
+        gtest.Assert(client.DeleteContent("/"),         "1Controller Delete2")
+        gtest.Assert(client.PatchContent("/"),          "1Controller Patch2")
+        gtest.Assert(client.OptionsContent("/"),        "1Controller Options2")
+        resp1, err := client.Head("/")
+        if err == nil {
+            defer resp1.Close()
+        }
+        gtest.Assert(err, nil)
+        gtest.Assert(resp1.Header.Get("head-ok"), "1")
+
+        gtest.Assert(client.GetContent("/controller-rest/get"),            "1Controller Get2")
+        gtest.Assert(client.PutContent("/controller-rest/put"),            "1Controller Put2")
+        gtest.Assert(client.PostContent("/controller-rest/post"),          "1Controller Post2")
+        gtest.Assert(client.DeleteContent("/controller-rest/delete"),      "1Controller Delete2")
+        gtest.Assert(client.PatchContent("/controller-rest/patch"),        "1Controller Patch2")
+        gtest.Assert(client.OptionsContent("/controller-rest/options"),    "1Controller Options2")
+        resp2, err := client.Head("/controller-rest/head")
+        if err == nil {
+            defer resp2.Close()
+        }
+        gtest.Assert(err, nil)
+        gtest.Assert(resp2.Header.Get("head-ok"), "1")
+
+        gtest.Assert(client.GetContent("/none-exist"),  "Not Found")
+    })
+}

g/net/ghttp/ghttp_unit_router_controller_test.go

@@ -0,0 +1,130 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package ghttp_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/frame/gmvc"
+    "github.com/gogf/gf/g/net/ghttp"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+// 控制器
+type Controller struct {
+    gmvc.Controller
+}
+
+func (c *Controller) Init(r *ghttp.Request) {
+    c.Controller.Init(r)
+    c.Response.Write("1")
+}
+
+func (c *Controller) Shut() {
+    c.Response.Write("2")
+}
+
+func (c *Controller) Index() {
+    c.Response.Write("Controller Index")
+}
+
+func (c *Controller) Show() {
+    c.Response.Write("Controller Show")
+}
+
+func (c *Controller) Info() {
+    c.Response.Write("Controller Info")
+}
+
+func Test_Router_Controller1(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.BindController("/", new(Controller))
+    s.BindController("/{.struct}/{.method}", new(Controller))
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+        
+        gtest.Assert(client.GetContent("/"),            "1Controller Index2")
+        gtest.Assert(client.GetContent("/init"),        "Not Found")
+        gtest.Assert(client.GetContent("/shut"),        "Not Found")
+        gtest.Assert(client.GetContent("/index"),       "1Controller Index2")
+        gtest.Assert(client.GetContent("/show"),        "1Controller Show2")
+
+        gtest.Assert(client.GetContent("/controller"),             "Not Found")
+        gtest.Assert(client.GetContent("/controller/init"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/shut"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/index"),       "1Controller Index2")
+        gtest.Assert(client.GetContent("/controller/show"),        "1Controller Show2")
+
+        gtest.Assert(client.GetContent("/none-exist"),  "Not Found")
+    })
+}
+
+func Test_Router_Controller2(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.BindController("/controller", new(Controller), "Show, Info")
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                       "Not Found")
+        gtest.Assert(client.GetContent("/controller"),             "Not Found")
+        gtest.Assert(client.GetContent("/controller/init"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/shut"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/index"),       "Not Found")
+        gtest.Assert(client.GetContent("/controller/show"),        "1Controller Show2")
+        gtest.Assert(client.GetContent("/controller/info"),        "1Controller Info2")
+
+        gtest.Assert(client.GetContent("/none-exist"),             "Not Found")
+    })
+}
+
+func Test_Router_ControllerMethod(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.BindControllerMethod("/controller-info", new(Controller), "Info")
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                       "Not Found")
+        gtest.Assert(client.GetContent("/controller"),             "Not Found")
+        gtest.Assert(client.GetContent("/controller/init"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/shut"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/index"),       "Not Found")
+        gtest.Assert(client.GetContent("/controller/show"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/info"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller-info"),        "1Controller Info2")
+
+        gtest.Assert(client.GetContent("/none-exist"),             "Not Found")
+    })
+}

g/net/ghttp/ghttp_unit_router_domain_basic_test.go

@@ -0,0 +1,338 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+// 基本路由功能以及优先级测试
+package ghttp_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/net/ghttp"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+// 基本路由功能测试
+func Test_Router_DomainBasic(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    d := s.Domain("localhost, local")
+    d.BindHandler("/:name", func(r *ghttp.Request){
+        r.Response.Write("/:name")
+    })
+    d.BindHandler("/:name/update", func(r *ghttp.Request){
+        r.Response.Write(r.Get("name"))
+    })
+    d.BindHandler("/:name/:action", func(r *ghttp.Request){
+        r.Response.Write(r.Get("action"))
+    })
+    d.BindHandler("/:name/*any", func(r *ghttp.Request){
+        r.Response.Write(r.Get("any"))
+    })
+    d.BindHandler("/user/list/{field}.html", func(r *ghttp.Request){
+        r.Response.Write(r.Get("field"))
+    })
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+        gtest.Assert(client.GetContent("/john"),               "Not Found")
+        gtest.Assert(client.GetContent("/john/update"),        "Not Found")
+        gtest.Assert(client.GetContent("/john/edit"),          "Not Found")
+        gtest.Assert(client.GetContent("/user/list/100.html"), "Not Found")
+    })
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://localhost:%d", p))
+        gtest.Assert(client.GetContent("/john"),               "")
+        gtest.Assert(client.GetContent("/john/update"),        "john")
+        gtest.Assert(client.GetContent("/john/edit"),          "edit")
+        gtest.Assert(client.GetContent("/user/list/100.html"), "100")
+    })
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://local:%d", p))
+        gtest.Assert(client.GetContent("/john"),               "")
+        gtest.Assert(client.GetContent("/john/update"),        "john")
+        gtest.Assert(client.GetContent("/john/edit"),          "edit")
+        gtest.Assert(client.GetContent("/user/list/100.html"), "100")
+    })
+}
+
+// 测试HTTP Method注册.
+func Test_Router_DomainMethod(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    d := s.Domain("localhost, local")
+    d.BindHandler("GET:/get", func(r *ghttp.Request){
+
+    })
+    d.BindHandler("POST:/post", func(r *ghttp.Request){
+
+    })
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        resp1, err := client.Get("/get")
+        defer resp1.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp1.StatusCode, 404)
+
+        resp2, err := client.Post("/get")
+        defer resp2.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp2.StatusCode, 404)
+
+        resp3, err := client.Get("/post")
+        defer resp3.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp3.StatusCode, 404)
+
+        resp4, err := client.Post("/post")
+        defer resp4.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp4.StatusCode, 404)
+    })
+
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://localhost:%d", p))
+
+        resp1, err := client.Get("/get")
+        defer resp1.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp1.StatusCode, 200)
+
+        resp2, err := client.Post("/get")
+        defer resp2.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp2.StatusCode, 404)
+
+        resp3, err := client.Get("/post")
+        defer resp3.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp3.StatusCode, 404)
+
+        resp4, err := client.Post("/post")
+        defer resp4.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp4.StatusCode, 200)
+    })
+
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://local:%d", p))
+
+        resp1, err := client.Get("/get")
+        defer resp1.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp1.StatusCode, 200)
+
+        resp2, err := client.Post("/get")
+        defer resp2.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp2.StatusCode, 404)
+
+        resp3, err := client.Get("/post")
+        defer resp3.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp3.StatusCode, 404)
+
+        resp4, err := client.Post("/post")
+        defer resp4.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp4.StatusCode, 200)
+    })
+}
+
+// 测试状态返回.
+func Test_Router_DomainStatus(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    d := s.Domain("localhost, local")
+    d.BindHandler("/200", func(r *ghttp.Request){
+        r.Response.WriteStatus(200)
+    })
+    d.BindHandler("/300", func(r *ghttp.Request){
+        r.Response.WriteStatus(300)
+    })
+    d.BindHandler("/400", func(r *ghttp.Request){
+        r.Response.WriteStatus(400)
+    })
+    d.BindHandler("/500", func(r *ghttp.Request){
+        r.Response.WriteStatus(500)
+    })
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        resp1, err := client.Get("/200")
+        defer resp1.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp1.StatusCode, 404)
+
+        resp2, err := client.Get("/300")
+        defer resp2.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp2.StatusCode, 404)
+
+        resp3, err := client.Get("/400")
+        defer resp3.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp3.StatusCode, 404)
+
+        resp4, err := client.Get("/500")
+        defer resp4.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp4.StatusCode, 404)
+    })
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://localhost:%d", p))
+
+        resp1, err := client.Get("/200")
+        defer resp1.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp1.StatusCode, 200)
+
+        resp2, err := client.Get("/300")
+        defer resp2.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp2.StatusCode, 300)
+
+        resp3, err := client.Get("/400")
+        defer resp3.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp3.StatusCode, 400)
+
+        resp4, err := client.Get("/500")
+        defer resp4.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp4.StatusCode, 500)
+    })
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://local:%d", p))
+
+        resp1, err := client.Get("/200")
+        defer resp1.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp1.StatusCode, 200)
+
+        resp2, err := client.Get("/300")
+        defer resp2.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp2.StatusCode, 300)
+
+        resp3, err := client.Get("/400")
+        defer resp3.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp3.StatusCode, 400)
+
+        resp4, err := client.Get("/500")
+        defer resp4.Close()
+        gtest.Assert(err,              nil)
+        gtest.Assert(resp4.StatusCode, 500)
+    })
+}
+
+// 自定义状态码处理.
+func Test_Router_DomainCustomStatusHandler(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    d := s.Domain("localhost, local")
+    d.BindHandler("/", func(r *ghttp.Request){
+        r.Response.Write("hello")
+    })
+    d.BindStatusHandler(404, func(r *ghttp.Request){
+        r.Response.Write("404 page")
+    })
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                 "Not Found")
+        gtest.Assert(client.GetContent("/ThisDoesNotExist"), "Not Found")
+    })
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://localhost:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                 "hello")
+        gtest.Assert(client.GetContent("/ThisDoesNotExist"), "404 page")
+    })
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://local:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                 "hello")
+        gtest.Assert(client.GetContent("/ThisDoesNotExist"), "404 page")
+    })
+}
+
+// 测试不存在的路由.
+func Test_Router_Domain404(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    d := s.Domain("localhost, local")
+    d.BindHandler("/", func(r *ghttp.Request){
+        r.Response.Write("hello")
+    })
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"), "Not Found")
+    })
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://localhost:%d", p))
+
+        gtest.Assert(client.GetContent("/"), "hello")
+    })
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://local:%d", p))
+
+        gtest.Assert(client.GetContent("/"), "hello")
+    })
+}

g/net/ghttp/ghttp_unit_router_domain_controller_rest_test.go

@@ -0,0 +1,127 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package ghttp_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/frame/gmvc"
+    "github.com/gogf/gf/g/net/ghttp"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+type DomainControllerRest struct {
+    gmvc.Controller
+}
+
+func (c *DomainControllerRest) Init(r *ghttp.Request)  {
+    c.Controller.Init(r)
+    c.Response.Write("1")
+}
+
+func (c *DomainControllerRest) Shut() {
+    c.Response.Write("2")
+}
+
+func (c *DomainControllerRest) Get() {
+    c.Response.Write("Controller Get")
+}
+
+func (c *DomainControllerRest) Put() {
+    c.Response.Write("Controller Put")
+}
+
+func (c *DomainControllerRest) Post() {
+    c.Response.Write("Controller Post")
+}
+
+func (c *DomainControllerRest) Delete() {
+    c.Response.Write("Controller Delete")
+}
+
+func (c *DomainControllerRest) Patch() {
+    c.Response.Write("Controller Patch")
+}
+
+func (c *DomainControllerRest) Options() {
+    c.Response.Write("Controller Options")
+}
+
+func (c *DomainControllerRest) Head() {
+    c.Response.Header().Set("head-ok", "1")
+}
+
+// 控制器注册测试
+func Test_Router_DomainControllerRest(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    d := s.Domain("localhost, local")
+    d.BindControllerRest("/", new(DomainControllerRest))
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),            "Not Found")
+        gtest.Assert(client.PutContent("/"),            "Not Found")
+        gtest.Assert(client.PostContent("/"),           "Not Found")
+        gtest.Assert(client.DeleteContent("/"),         "Not Found")
+        gtest.Assert(client.PatchContent("/"),          "Not Found")
+        gtest.Assert(client.OptionsContent("/"),        "Not Found")
+        resp1, err := client.Head("/")
+        if err == nil {
+            defer resp1.Close()
+        }
+        gtest.Assert(err, nil)
+        gtest.Assert(resp1.Header.Get("head-ok"), "")
+        gtest.Assert(client.GetContent("/none-exist"),  "Not Found")
+    })
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://localhost:%d", p))
+
+        gtest.Assert(client.GetContent("/"),            "1Controller Get2")
+        gtest.Assert(client.PutContent("/"),            "1Controller Put2")
+        gtest.Assert(client.PostContent("/"),           "1Controller Post2")
+        gtest.Assert(client.DeleteContent("/"),         "1Controller Delete2")
+        gtest.Assert(client.PatchContent("/"),          "1Controller Patch2")
+        gtest.Assert(client.OptionsContent("/"),        "1Controller Options2")
+        resp1, err := client.Head("/")
+        if err == nil {
+            defer resp1.Close()
+        }
+        gtest.Assert(err, nil)
+        gtest.Assert(resp1.Header.Get("head-ok"), "1")
+        gtest.Assert(client.GetContent("/none-exist"),  "Not Found")
+    })
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://local:%d", p))
+
+        gtest.Assert(client.GetContent("/"),            "1Controller Get2")
+        gtest.Assert(client.PutContent("/"),            "1Controller Put2")
+        gtest.Assert(client.PostContent("/"),           "1Controller Post2")
+        gtest.Assert(client.DeleteContent("/"),         "1Controller Delete2")
+        gtest.Assert(client.PatchContent("/"),          "1Controller Patch2")
+        gtest.Assert(client.OptionsContent("/"),        "1Controller Options2")
+        resp1, err := client.Head("/")
+        if err == nil {
+            defer resp1.Close()
+        }
+        gtest.Assert(err, nil)
+        gtest.Assert(resp1.Header.Get("head-ok"), "1")
+        gtest.Assert(client.GetContent("/none-exist"),  "Not Found")
+    })
+}

g/net/ghttp/ghttp_unit_router_domain_controller_test.go

@@ -0,0 +1,202 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package ghttp_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/frame/gmvc"
+    "github.com/gogf/gf/g/net/ghttp"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+type DomainController struct {
+    gmvc.Controller
+}
+
+func (c *DomainController) Init(r *ghttp.Request) {
+    c.Controller.Init(r)
+    c.Response.Write("1")
+}
+
+func (c *DomainController) Shut() {
+    c.Response.Write("2")
+}
+
+func (c *DomainController) Index() {
+    c.Response.Write("Controller Index")
+}
+
+func (c *DomainController) Show() {
+    c.Response.Write("Controller Show")
+}
+
+func (c *DomainController) Info() {
+    c.Response.Write("Controller Info")
+}
+
+func Test_Router_DomainController1(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.Domain("localhost, local").BindController("/", new(DomainController))
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+        
+        gtest.Assert(client.GetContent("/"),                       "Not Found")
+        gtest.Assert(client.GetContent("/init"),                   "Not Found")
+        gtest.Assert(client.GetContent("/shut"),                   "Not Found")
+        gtest.Assert(client.GetContent("/index"),                  "Not Found")
+        gtest.Assert(client.GetContent("/show"),                   "Not Found")
+        gtest.Assert(client.GetContent("/info"),                   "Not Found")
+        gtest.Assert(client.GetContent("/none-exist"),             "Not Found")
+    })
+
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://localhost:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                       "1Controller Index2")
+        gtest.Assert(client.GetContent("/init"),                   "Not Found")
+        gtest.Assert(client.GetContent("/shut"),                   "Not Found")
+        gtest.Assert(client.GetContent("/index"),                  "1Controller Index2")
+        gtest.Assert(client.GetContent("/show"),                   "1Controller Show2")
+        gtest.Assert(client.GetContent("/info"),                   "1Controller Info2")
+        gtest.Assert(client.GetContent("/none-exist"),             "Not Found")
+    })
+
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://local:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                       "1Controller Index2")
+        gtest.Assert(client.GetContent("/init"),                   "Not Found")
+        gtest.Assert(client.GetContent("/shut"),                   "Not Found")
+        gtest.Assert(client.GetContent("/index"),                  "1Controller Index2")
+        gtest.Assert(client.GetContent("/show"),                   "1Controller Show2")
+        gtest.Assert(client.GetContent("/info"),                   "1Controller Info2")
+        gtest.Assert(client.GetContent("/none-exist"),             "Not Found")
+    })
+}
+
+func Test_Router_DomainController2(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.Domain("localhost, local").BindController("/controller", new(DomainController), "Show, Info")
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                       "Not Found")
+        gtest.Assert(client.GetContent("/controller"),             "Not Found")
+        gtest.Assert(client.GetContent("/controller/init"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/shut"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/index"),       "Not Found")
+        gtest.Assert(client.GetContent("/controller/show"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/info"),        "Not Found")
+        gtest.Assert(client.GetContent("/none-exist"),             "Not Found")
+    })
+
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://localhost:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                       "Not Found")
+        gtest.Assert(client.GetContent("/controller"),             "Not Found")
+        gtest.Assert(client.GetContent("/controller/init"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/shut"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/index"),       "Not Found")
+        gtest.Assert(client.GetContent("/controller/show"),        "1Controller Show2")
+        gtest.Assert(client.GetContent("/controller/info"),        "1Controller Info2")
+        gtest.Assert(client.GetContent("/none-exist"),             "Not Found")
+    })
+
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://local:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                       "Not Found")
+        gtest.Assert(client.GetContent("/controller"),             "Not Found")
+        gtest.Assert(client.GetContent("/controller/init"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/shut"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/index"),       "Not Found")
+        gtest.Assert(client.GetContent("/controller/show"),        "1Controller Show2")
+        gtest.Assert(client.GetContent("/controller/info"),        "1Controller Info2")
+        gtest.Assert(client.GetContent("/none-exist"),             "Not Found")
+    })
+}
+
+func Test_Router_DomainControllerMethod(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.Domain("localhost, local").BindControllerMethod("/controller-info", new(DomainController), "Info")
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                       "Not Found")
+        gtest.Assert(client.GetContent("/controller"),             "Not Found")
+        gtest.Assert(client.GetContent("/controller/init"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/shut"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/index"),       "Not Found")
+        gtest.Assert(client.GetContent("/controller/show"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/info"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller-info"),        "Not Found")
+        gtest.Assert(client.GetContent("/none-exist"),             "Not Found")
+    })
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://localhost:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                       "Not Found")
+        gtest.Assert(client.GetContent("/controller"),             "Not Found")
+        gtest.Assert(client.GetContent("/controller/init"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/shut"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/index"),       "Not Found")
+        gtest.Assert(client.GetContent("/controller/show"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/info"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller-info"),        "1Controller Info2")
+        gtest.Assert(client.GetContent("/none-exist"),             "Not Found")
+    })
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://local:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                       "Not Found")
+        gtest.Assert(client.GetContent("/controller"),             "Not Found")
+        gtest.Assert(client.GetContent("/controller/init"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/shut"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/index"),       "Not Found")
+        gtest.Assert(client.GetContent("/controller/show"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller/info"),        "Not Found")
+        gtest.Assert(client.GetContent("/controller-info"),        "1Controller Info2")
+        gtest.Assert(client.GetContent("/none-exist"),             "Not Found")
+    })
+}

g/net/ghttp/ghttp_unit_router_domain_object_rest_test.go

@@ -0,0 +1,122 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package ghttp_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/net/ghttp"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+type DomainObjectRest struct {}
+
+func (o *DomainObjectRest) Init(r *ghttp.Request) {
+    r.Response.Write("1")
+}
+
+func (o *DomainObjectRest) Shut(r *ghttp.Request) {
+    r.Response.Write("2")
+}
+
+func (o *DomainObjectRest) Get(r *ghttp.Request) {
+    r.Response.Write("Object Get")
+}
+
+func (o *DomainObjectRest) Put(r *ghttp.Request) {
+    r.Response.Write("Object Put")
+}
+
+func (o *DomainObjectRest) Post(r *ghttp.Request) {
+    r.Response.Write("Object Post")
+}
+
+func (o *DomainObjectRest) Delete(r *ghttp.Request) {
+    r.Response.Write("Object Delete")
+}
+
+func (o *DomainObjectRest) Patch(r *ghttp.Request) {
+    r.Response.Write("Object Patch")
+}
+
+func (o *DomainObjectRest) Options(r *ghttp.Request) {
+    r.Response.Write("Object Options")
+}
+
+func (o *DomainObjectRest) Head(r *ghttp.Request) {
+    r.Response.Header().Set("head-ok", "1")
+}
+
+func Test_Router_DomainObjectRest(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    d := s.Domain("localhost, local")
+    d.BindObjectRest("/", new(DomainObjectRest))
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),            "Not Found")
+        gtest.Assert(client.PutContent("/"),            "Not Found")
+        gtest.Assert(client.PostContent("/"),           "Not Found")
+        gtest.Assert(client.DeleteContent("/"),         "Not Found")
+        gtest.Assert(client.PatchContent("/"),          "Not Found")
+        gtest.Assert(client.OptionsContent("/"),        "Not Found")
+        resp1, err := client.Head("/")
+        if err == nil {
+            defer resp1.Close()
+        }
+        gtest.Assert(err, nil)
+        gtest.Assert(resp1.Header.Get("head-ok"), "")
+        gtest.Assert(client.GetContent("/none-exist"),  "Not Found")
+    })
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://localhost:%d", p))
+
+        gtest.Assert(client.GetContent("/"),            "1Object Get2")
+        gtest.Assert(client.PutContent("/"),            "1Object Put2")
+        gtest.Assert(client.PostContent("/"),           "1Object Post2")
+        gtest.Assert(client.DeleteContent("/"),         "1Object Delete2")
+        gtest.Assert(client.PatchContent("/"),          "1Object Patch2")
+        gtest.Assert(client.OptionsContent("/"),        "1Object Options2")
+        resp1, err := client.Head("/")
+        if err == nil {
+            defer resp1.Close()
+        }
+        gtest.Assert(err, nil)
+        gtest.Assert(resp1.Header.Get("head-ok"), "1")
+        gtest.Assert(client.GetContent("/none-exist"),  "Not Found")
+    })
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://local:%d", p))
+
+        gtest.Assert(client.GetContent("/"),            "1Object Get2")
+        gtest.Assert(client.PutContent("/"),            "1Object Put2")
+        gtest.Assert(client.PostContent("/"),           "1Object Post2")
+        gtest.Assert(client.DeleteContent("/"),         "1Object Delete2")
+        gtest.Assert(client.PatchContent("/"),          "1Object Patch2")
+        gtest.Assert(client.OptionsContent("/"),        "1Object Options2")
+        resp1, err := client.Head("/")
+        if err == nil {
+            defer resp1.Close()
+        }
+        gtest.Assert(err, nil)
+        gtest.Assert(resp1.Header.Get("head-ok"), "1")
+        gtest.Assert(client.GetContent("/none-exist"),  "Not Found")
+    })
+}

g/net/ghttp/ghttp_unit_router_domain_object_test.go

@@ -0,0 +1,196 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package ghttp_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/net/ghttp"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+type DomainObject struct {}
+
+func (o *DomainObject) Init(r *ghttp.Request) {
+    r.Response.Write("1")
+}
+
+func (o *DomainObject) Shut(r *ghttp.Request) {
+    r.Response.Write("2")
+}
+
+func (o *DomainObject) Index(r *ghttp.Request) {
+    r.Response.Write("Object Index")
+}
+
+func (o *DomainObject) Show(r *ghttp.Request) {
+    r.Response.Write("Object Show")
+}
+
+func (o *DomainObject) Info(r *ghttp.Request) {
+    r.Response.Write("Object Info")
+}
+
+func Test_Router_DomainObject1(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.Domain("localhost, local").BindObject("/", new(DomainObject))
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),            "Not Found")
+        gtest.Assert(client.GetContent("/init"),        "Not Found")
+        gtest.Assert(client.GetContent("/shut"),        "Not Found")
+        gtest.Assert(client.GetContent("/index"),       "Not Found")
+        gtest.Assert(client.GetContent("/show"),        "Not Found")
+        gtest.Assert(client.GetContent("/none-exist"),  "Not Found")
+    })
+
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://localhost:%d", p))
+
+        gtest.Assert(client.GetContent("/"),            "1Object Index2")
+        gtest.Assert(client.GetContent("/init"),        "Not Found")
+        gtest.Assert(client.GetContent("/shut"),        "Not Found")
+        gtest.Assert(client.GetContent("/index"),       "1Object Index2")
+        gtest.Assert(client.GetContent("/show"),        "1Object Show2")
+        gtest.Assert(client.GetContent("/info"),        "1Object Info2")
+        gtest.Assert(client.GetContent("/none-exist"),  "Not Found")
+    })
+
+    gtest.Case(t, func() {
+       client := ghttp.NewClient()
+       client.SetPrefix(fmt.Sprintf("http://local:%d", p))
+
+       gtest.Assert(client.GetContent("/"),            "1Object Index2")
+       gtest.Assert(client.GetContent("/init"),        "Not Found")
+       gtest.Assert(client.GetContent("/shut"),        "Not Found")
+       gtest.Assert(client.GetContent("/index"),       "1Object Index2")
+       gtest.Assert(client.GetContent("/show"),        "1Object Show2")
+       gtest.Assert(client.GetContent("/info"),        "1Object Info2")
+       gtest.Assert(client.GetContent("/none-exist"),  "Not Found")
+    })
+}
+
+
+func Test_Router_DomainObject2(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.Domain("localhost, local").BindObject("/object", new(DomainObject), "Show, Info")
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                  "Not Found")
+        gtest.Assert(client.GetContent("/object"),            "Not Found")
+        gtest.Assert(client.GetContent("/object/init"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/shut"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/index"),      "Not Found")
+        gtest.Assert(client.GetContent("/object/show"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/info"),       "Not Found")
+        gtest.Assert(client.GetContent("/none-exist"),        "Not Found")
+    })
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://localhost:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                  "Not Found")
+        gtest.Assert(client.GetContent("/object"),            "Not Found")
+        gtest.Assert(client.GetContent("/object/init"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/shut"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/index"),      "Not Found")
+        gtest.Assert(client.GetContent("/object/show"),       "1Object Show2")
+        gtest.Assert(client.GetContent("/object/info"),       "1Object Info2")
+        gtest.Assert(client.GetContent("/none-exist"),        "Not Found")
+    })
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://local:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                  "Not Found")
+        gtest.Assert(client.GetContent("/object"),            "Not Found")
+        gtest.Assert(client.GetContent("/object/init"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/shut"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/index"),      "Not Found")
+        gtest.Assert(client.GetContent("/object/show"),       "1Object Show2")
+        gtest.Assert(client.GetContent("/object/info"),       "1Object Info2")
+        gtest.Assert(client.GetContent("/none-exist"),        "Not Found")
+    })
+}
+
+func Test_Router_DomainObjectMethod(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.Domain("localhost, local").BindObjectMethod("/object-info", new(DomainObject), "Info")
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                  "Not Found")
+        gtest.Assert(client.GetContent("/object"),            "Not Found")
+        gtest.Assert(client.GetContent("/object/init"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/shut"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/index"),      "Not Found")
+        gtest.Assert(client.GetContent("/object/show"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/info"),       "Not Found")
+        gtest.Assert(client.GetContent("/object-info"),       "Not Found")
+        gtest.Assert(client.GetContent("/none-exist"),        "Not Found")
+    })
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://localhost:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                  "Not Found")
+        gtest.Assert(client.GetContent("/object"),            "Not Found")
+        gtest.Assert(client.GetContent("/object/init"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/shut"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/index"),      "Not Found")
+        gtest.Assert(client.GetContent("/object/show"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/info"),       "Not Found")
+        gtest.Assert(client.GetContent("/object-info"),       "1Object Info2")
+        gtest.Assert(client.GetContent("/none-exist"),        "Not Found")
+    })
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://local:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                  "Not Found")
+        gtest.Assert(client.GetContent("/object"),            "Not Found")
+        gtest.Assert(client.GetContent("/object/init"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/shut"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/index"),      "Not Found")
+        gtest.Assert(client.GetContent("/object/show"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/info"),       "Not Found")
+        gtest.Assert(client.GetContent("/object-info"),       "1Object Info2")
+        gtest.Assert(client.GetContent("/none-exist"),        "Not Found")
+    })
+}

g/net/ghttp/ghttp_unit_router_group_rest_test.go

@@ -0,0 +1,173 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+// 分组路由测试
+package ghttp_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/frame/gmvc"
+    "github.com/gogf/gf/g/net/ghttp"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+type GroupCtlRest struct {
+    gmvc.Controller
+}
+
+func (c *GroupCtlRest) Init(r *ghttp.Request)  {
+    c.Controller.Init(r)
+    c.Response.Write("1")
+}
+
+func (c *GroupCtlRest) Shut() {
+    c.Response.Write("2")
+}
+
+func (c *GroupCtlRest) Get() {
+    c.Response.Write("Controller Get")
+}
+
+func (c *GroupCtlRest) Put() {
+    c.Response.Write("Controller Put")
+}
+
+func (c *GroupCtlRest) Post() {
+    c.Response.Write("Controller Post")
+}
+
+func (c *GroupCtlRest) Delete() {
+    c.Response.Write("Controller Delete")
+}
+
+func (c *GroupCtlRest) Patch() {
+    c.Response.Write("Controller Patch")
+}
+
+func (c *GroupCtlRest) Options() {
+    c.Response.Write("Controller Options")
+}
+
+func (c *GroupCtlRest) Head() {
+    c.Response.Header().Set("head-ok", "1")
+}
+
+type GroupObjRest struct {}
+
+func (o *GroupObjRest) Init(r *ghttp.Request) {
+    r.Response.Write("1")
+}
+
+func (o *GroupObjRest) Shut(r *ghttp.Request) {
+    r.Response.Write("2")
+}
+
+func (o *GroupObjRest) Get(r *ghttp.Request) {
+    r.Response.Write("Object Get")
+}
+
+func (o *GroupObjRest) Put(r *ghttp.Request) {
+    r.Response.Write("Object Put")
+}
+
+func (o *GroupObjRest) Post(r *ghttp.Request) {
+    r.Response.Write("Object Post")
+}
+
+func (o *GroupObjRest) Delete(r *ghttp.Request) {
+    r.Response.Write("Object Delete")
+}
+
+func (o *GroupObjRest) Patch(r *ghttp.Request) {
+    r.Response.Write("Object Patch")
+}
+
+func (o *GroupObjRest) Options(r *ghttp.Request) {
+    r.Response.Write("Object Options")
+}
+
+func (o *GroupObjRest) Head(r *ghttp.Request) {
+    r.Response.Header().Set("head-ok", "1")
+}
+
+func Test_Router_GroupRest(t *testing.T) {
+    p   := ports.PopRand()
+    s   := g.Server(p)
+    g   := s.Group("/api")
+    ctl := new(GroupCtlRest)
+    obj := new(GroupObjRest)
+    g.REST("/ctl", ctl)
+    g.REST("/obj", obj)
+    g.REST("/{.struct}/{.method}", ctl)
+    g.REST("/{.struct}/{.method}", obj)
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/api/ctl"),            "1Controller Get2")
+        gtest.Assert(client.PutContent("/api/ctl"),            "1Controller Put2")
+        gtest.Assert(client.PostContent("/api/ctl"),           "1Controller Post2")
+        gtest.Assert(client.DeleteContent("/api/ctl"),         "1Controller Delete2")
+        gtest.Assert(client.PatchContent("/api/ctl"),          "1Controller Patch2")
+        gtest.Assert(client.OptionsContent("/api/ctl"),        "1Controller Options2")
+        resp1, err := client.Head("/api/ctl")
+        if err == nil {
+            defer resp1.Close()
+        }
+        gtest.Assert(err, nil)
+        gtest.Assert(resp1.Header.Get("head-ok"), "1")
+
+        gtest.Assert(client.GetContent("/api/obj"),            "1Object Get2")
+        gtest.Assert(client.PutContent("/api/obj"),            "1Object Put2")
+        gtest.Assert(client.PostContent("/api/obj"),           "1Object Post2")
+        gtest.Assert(client.DeleteContent("/api/obj"),         "1Object Delete2")
+        gtest.Assert(client.PatchContent("/api/obj"),          "1Object Patch2")
+        gtest.Assert(client.OptionsContent("/api/obj"),        "1Object Options2")
+        resp2, err := client.Head("/api/obj")
+        if err == nil {
+            defer resp2.Close()
+        }
+        gtest.Assert(err, nil)
+        gtest.Assert(resp2.Header.Get("head-ok"), "1")
+
+        gtest.Assert(client.GetContent("/api/group-ctl-rest"),                "Not Found")
+        gtest.Assert(client.GetContent("/api/group-ctl-rest/get"),            "1Controller Get2")
+        gtest.Assert(client.PutContent("/api/group-ctl-rest/put"),            "1Controller Put2")
+        gtest.Assert(client.PostContent("/api/group-ctl-rest/post"),          "1Controller Post2")
+        gtest.Assert(client.DeleteContent("/api/group-ctl-rest/delete"),      "1Controller Delete2")
+        gtest.Assert(client.PatchContent("/api/group-ctl-rest/patch"),        "1Controller Patch2")
+        gtest.Assert(client.OptionsContent("/api/group-ctl-rest/options"),    "1Controller Options2")
+        resp3, err := client.Head("/api/group-ctl-rest/head")
+        if err == nil {
+            defer resp3.Close()
+        }
+        gtest.Assert(err, nil)
+        gtest.Assert(resp3.Header.Get("head-ok"), "1")
+
+        gtest.Assert(client.GetContent("/api/group-obj-rest"),                "Not Found")
+        gtest.Assert(client.GetContent("/api/group-obj-rest/get"),            "1Object Get2")
+        gtest.Assert(client.PutContent("/api/group-obj-rest/put"),            "1Object Put2")
+        gtest.Assert(client.PostContent("/api/group-obj-rest/post"),          "1Object Post2")
+        gtest.Assert(client.DeleteContent("/api/group-obj-rest/delete"),      "1Object Delete2")
+        gtest.Assert(client.PatchContent("/api/group-obj-rest/patch"),        "1Object Patch2")
+        gtest.Assert(client.OptionsContent("/api/group-obj-rest/options"),    "1Object Options2")
+        resp4, err := client.Head("/api/group-obj-rest/head")
+        if err == nil {
+            defer resp4.Close()
+        }
+        gtest.Assert(err, nil)
+        gtest.Assert(resp4.Header.Get("head-ok"), "1")
+    })
+}

g/net/ghttp/ghttp_unit_router_group_test.go

@@ -8,55 +8,73 @@
 package ghttp_test
 
 import (
+    "fmt"
     "github.com/gogf/gf/g"
     "github.com/gogf/gf/g/frame/gmvc"
     "github.com/gogf/gf/g/net/ghttp"
-    "github.com/gogf/gf/g/os/gtime"
     "github.com/gogf/gf/g/test/gtest"
     "testing"
     "time"
 )
 
 // 执行对象
-type Object struct {}
+type GroupObject struct {}
 
-func (o *Object) Index(r *ghttp.Request) {
+func (o *GroupObject) Init(r *ghttp.Request) {
+    r.Response.Write("1")
+}
+
+func (o *GroupObject) Shut(r *ghttp.Request) {
+    r.Response.Write("2")
+}
+
+func (o *GroupObject) Index(r *ghttp.Request) {
     r.Response.Write("Object Index")
 }
 
-func (o *Object) Show(r *ghttp.Request) {
+func (o *GroupObject) Show(r *ghttp.Request) {
     r.Response.Write("Object Show")
 }
 
-func (o *Object) Delete(r *ghttp.Request) {
-    r.Response.Write("Object REST Delete")
+func (o *GroupObject) Delete(r *ghttp.Request) {
+    r.Response.Write("Object Delete")
 }
 
 // 控制器
-type Controller struct {
+type GroupController struct {
     gmvc.Controller
 }
 
-func (c *Controller) Index() {
+func (c *GroupController) Init(r *ghttp.Request) {
+    c.Controller.Init(r)
+    c.Response.Write("1")
+}
+
+func (c *GroupController) Shut() {
+    c.Response.Write("2")
+}
+
+func (c *GroupController) Index() {
     c.Response.Write("Controller Index")
 }
 
-func (c *Controller) Show() {
+func (c *GroupController) Show() {
     c.Response.Write("Controller Show")
 }
 
-func (c *Controller) Post() {
-    c.Response.Write("Controller REST Post")
+func (c *GroupController) Post() {
+    c.Response.Write("Controller Post")
 }
 
 func Handler(r *ghttp.Request) {
     r.Response.Write("Handler")
 }
 
-func Test_Router_Group1(t *testing.T) {
-    s   := g.Server(gtime.Nanosecond())
-    obj := new(Object)
-    ctl := new(Controller)
+func Test_Router_GroupBasic1(t *testing.T) {
+    p   := ports.PopRand()
+    s   := g.Server(p)
+    obj := new(GroupObject)
+    ctl := new(GroupController)
     // 分组路由方法注册
     g := s.Group("/api")
     g.ALL ("/handler",     Handler)
@@ -66,48 +84,44 @@ func Test_Router_Group1(t *testing.T) {
     g.ALL ("/obj",         obj)
     g.GET ("/obj/my-show", obj, "Show")
     g.REST("/obj/rest",    obj)
-    s.SetPort(8200)
+    s.SetPort(p)
     s.SetDumpRouteMap(false)
-    go s.Run()
-    defer func() {
-        s.Shutdown()
-        time.Sleep(time.Second)
-    }()
+    s.Start()
+    defer s.Shutdown()
+
     time.Sleep(time.Second)
     gtest.Case(t, func() {
         client := ghttp.NewClient()
-        client.SetPrefix("http://127.0.0.1:8200")
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
 
         gtest.Assert(client.GetContent ("/api/handler"),     "Handler")
 
-        gtest.Assert(client.GetContent ("/api/ctl"),         "Controller Index")
-        gtest.Assert(client.GetContent ("/api/ctl/"),        "Controller Index")
-        gtest.Assert(client.GetContent ("/api/ctl/index"),   "Controller Index")
-        gtest.Assert(client.GetContent ("/api/ctl/my-show"), "Controller Show")
-        gtest.Assert(client.GetContent ("/api/ctl/post"),    "Controller REST Post")
-        gtest.Assert(client.GetContent ("/api/ctl/show"),    "Controller Show")
-        gtest.Assert(client.PostContent("/api/ctl/rest"),    "Controller REST Post")
+        gtest.Assert(client.GetContent ("/api/ctl"),         "1Controller Index2")
+        gtest.Assert(client.GetContent ("/api/ctl/"),        "1Controller Index2")
+        gtest.Assert(client.GetContent ("/api/ctl/index"),   "1Controller Index2")
+        gtest.Assert(client.GetContent ("/api/ctl/my-show"), "1Controller Show2")
+        gtest.Assert(client.GetContent ("/api/ctl/post"),    "1Controller Post2")
+        gtest.Assert(client.GetContent ("/api/ctl/show"),    "1Controller Show2")
+        gtest.Assert(client.PostContent("/api/ctl/rest"),    "1Controller Post2")
 
-        gtest.Assert(client.GetContent ("/api/obj"),         "Object Index")
-        gtest.Assert(client.GetContent ("/api/obj/"),        "Object Index")
-        gtest.Assert(client.GetContent ("/api/obj/index"),   "Object Index")
-        gtest.Assert(client.GetContent ("/api/obj/delete"),  "Object REST Delete")
-        gtest.Assert(client.GetContent ("/api/obj/my-show"), "Object Show")
-        gtest.Assert(client.GetContent ("/api/obj/show"),    "Object Show")
-        gtest.Assert(client.DeleteContent("/api/obj/rest"),  "Object REST Delete")
+        gtest.Assert(client.GetContent ("/api/obj"),         "1Object Index2")
+        gtest.Assert(client.GetContent ("/api/obj/"),        "1Object Index2")
+        gtest.Assert(client.GetContent ("/api/obj/index"),   "1Object Index2")
+        gtest.Assert(client.GetContent ("/api/obj/delete"),  "1Object Delete2")
+        gtest.Assert(client.GetContent ("/api/obj/my-show"), "1Object Show2")
+        gtest.Assert(client.GetContent ("/api/obj/show"),    "1Object Show2")
+        gtest.Assert(client.DeleteContent("/api/obj/rest"),  "1Object Delete2")
 
-        // 测试404
-        resp, err := client.Get("/ThisDoesNotExist")
-        defer resp.Close()
-        gtest.Assert(err,             nil)
-        gtest.Assert(resp.StatusCode, 404)
+        gtest.Assert(client.DeleteContent("/ThisDoesNotExist"),     "Not Found")
+        gtest.Assert(client.DeleteContent("/api/ThisDoesNotExist"), "Not Found")
     })
 }
 
-func Test_Router_Group2(t *testing.T) {
-    s   := g.Server(gtime.Nanosecond())
-    obj := new(Object)
-    ctl := new(Controller)
+func Test_Router_Basic2(t *testing.T) {
+    p   := ports.PopRand()
+    s   := g.Server(p)
+    obj := new(GroupObject)
+    ctl := new(GroupController)
     // 分组路由批量注册
     s.Group("/api").Bind("/api", []ghttp.GroupItem{
         {"ALL",  "/handler",     Handler},
@@ -118,34 +132,61 @@ func Test_Router_Group2(t *testing.T) {
         {"GET",  "/obj/my-show", obj, "Show"},
         {"REST", "/obj/rest",    obj},
     })
-    s.SetPort(8300)
+    s.SetPort(p)
     s.SetDumpRouteMap(false)
-    go s.Run()
-    defer func() {
-        s.Shutdown()
-        time.Sleep(time.Second)
-    }()
+    s.Start()
+    defer s.Shutdown()
+
     time.Sleep(time.Second)
     gtest.Case(t, func() {
         client := ghttp.NewClient()
-        client.SetPrefix("http://127.0.0.1:8300")
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
 
         gtest.Assert(client.GetContent ("/api/handler"),     "Handler")
 
-        gtest.Assert(client.GetContent ("/api/ctl/my-show"), "Controller Show")
-        gtest.Assert(client.GetContent ("/api/ctl/post"),    "Controller REST Post")
-        gtest.Assert(client.GetContent ("/api/ctl/show"),    "Controller Show")
-        gtest.Assert(client.PostContent("/api/ctl/rest"),    "Controller REST Post")
+        gtest.Assert(client.GetContent ("/api/ctl/my-show"), "1Controller Show2")
+        gtest.Assert(client.GetContent ("/api/ctl/post"),    "1Controller Post2")
+        gtest.Assert(client.GetContent ("/api/ctl/show"),    "1Controller Show2")
+        gtest.Assert(client.PostContent("/api/ctl/rest"),    "1Controller Post2")
 
-        gtest.Assert(client.GetContent ("/api/obj/delete"),  "Object REST Delete")
-        gtest.Assert(client.GetContent ("/api/obj/my-show"), "Object Show")
-        gtest.Assert(client.GetContent ("/api/obj/show"),    "Object Show")
-        gtest.Assert(client.DeleteContent("/api/obj/rest"),  "Object REST Delete")
+        gtest.Assert(client.GetContent ("/api/obj/delete"),  "1Object Delete2")
+        gtest.Assert(client.GetContent ("/api/obj/my-show"), "1Object Show2")
+        gtest.Assert(client.GetContent ("/api/obj/show"),    "1Object Show2")
+        gtest.Assert(client.DeleteContent("/api/obj/rest"),  "1Object Delete2")
 
-        // 测试404
-        resp, err := client.Get("/ThisDoesNotExist")
-        defer resp.Close()
-        gtest.Assert(err,             nil)
-        gtest.Assert(resp.StatusCode, 404)
+        gtest.Assert(client.DeleteContent("/ThisDoesNotExist"),     "Not Found")
+        gtest.Assert(client.DeleteContent("/api/ThisDoesNotExist"), "Not Found")
     })
 }
+
+func Test_Router_GroupBuildInVar(t *testing.T) {
+    p   := ports.PopRand()
+    s   := g.Server(p)
+    obj := new(GroupObject)
+    ctl := new(GroupController)
+    // 分组路由方法注册
+    g := s.Group("/api")
+    g.ALL ("/{.struct}/{.method}", ctl)
+    g.ALL ("/{.struct}/{.method}", obj)
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent ("/api/group-controller/index"),   "1Controller Index2")
+        gtest.Assert(client.GetContent ("/api/group-controller/post"),    "1Controller Post2")
+        gtest.Assert(client.GetContent ("/api/group-controller/show"),    "1Controller Show2")
+
+        gtest.Assert(client.GetContent ("/api/group-object/index"),   "1Object Index2")
+        gtest.Assert(client.GetContent ("/api/group-object/delete"),  "1Object Delete2")
+        gtest.Assert(client.GetContent ("/api/group-object/show"),    "1Object Show2")
+
+        gtest.Assert(client.DeleteContent("/ThisDoesNotExist"),     "Not Found")
+        gtest.Assert(client.DeleteContent("/api/ThisDoesNotExist"), "Not Found")
+    })
+}

g/net/ghttp/ghttp_unit_router_names_test.go

@@ -0,0 +1,8 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package ghttp_test
+

g/net/ghttp/ghttp_unit_router_object_rest_test.go

@@ -0,0 +1,100 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package ghttp_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/net/ghttp"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+type ObjectRest struct {}
+
+func (o *ObjectRest) Init(r *ghttp.Request) {
+    r.Response.Write("1")
+}
+
+func (o *ObjectRest) Shut(r *ghttp.Request) {
+    r.Response.Write("2")
+}
+
+func (o *ObjectRest) Get(r *ghttp.Request) {
+    r.Response.Write("Object Get")
+}
+
+func (o *ObjectRest) Put(r *ghttp.Request) {
+    r.Response.Write("Object Put")
+}
+
+func (o *ObjectRest) Post(r *ghttp.Request) {
+    r.Response.Write("Object Post")
+}
+
+func (o *ObjectRest) Delete(r *ghttp.Request) {
+    r.Response.Write("Object Delete")
+}
+
+func (o *ObjectRest) Patch(r *ghttp.Request) {
+    r.Response.Write("Object Patch")
+}
+
+func (o *ObjectRest) Options(r *ghttp.Request) {
+    r.Response.Write("Object Options")
+}
+
+func (o *ObjectRest) Head(r *ghttp.Request) {
+    r.Response.Header().Set("head-ok", "1")
+}
+
+func Test_Router_ObjectRest(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.BindObjectRest("/", new(ObjectRest))
+    s.BindObjectRest("/{.struct}/{.method}", new(ObjectRest))
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),            "1Object Get2")
+        gtest.Assert(client.PutContent("/"),            "1Object Put2")
+        gtest.Assert(client.PostContent("/"),           "1Object Post2")
+        gtest.Assert(client.DeleteContent("/"),         "1Object Delete2")
+        gtest.Assert(client.PatchContent("/"),          "1Object Patch2")
+        gtest.Assert(client.OptionsContent("/"),        "1Object Options2")
+        resp1, err := client.Head("/")
+        if err == nil {
+            defer resp1.Close()
+        }
+        gtest.Assert(err, nil)
+        gtest.Assert(resp1.Header.Get("head-ok"), "1")
+
+        gtest.Assert(client.GetContent("/object-rest/get"),            "1Object Get2")
+        gtest.Assert(client.PutContent("/object-rest/put"),            "1Object Put2")
+        gtest.Assert(client.PostContent("/object-rest/post"),          "1Object Post2")
+        gtest.Assert(client.DeleteContent("/object-rest/delete"),      "1Object Delete2")
+        gtest.Assert(client.PatchContent("/object-rest/patch"),        "1Object Patch2")
+        gtest.Assert(client.OptionsContent("/object-rest/options"),    "1Object Options2")
+        resp2, err := client.Head("/object-rest/head")
+        if err == nil {
+            defer resp2.Close()
+        }
+        gtest.Assert(err, nil)
+        gtest.Assert(resp2.Header.Get("head-ok"), "1")
+
+        gtest.Assert(client.GetContent("/none-exist"),  "Not Found")
+    })
+}

g/net/ghttp/ghttp_unit_router_object_test.go

@@ -0,0 +1,126 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package ghttp_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/net/ghttp"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+    "time"
+)
+
+type Object struct {}
+
+func (o *Object) Init(r *ghttp.Request) {
+    r.Response.Write("1")
+}
+
+func (o *Object) Shut(r *ghttp.Request) {
+    r.Response.Write("2")
+}
+
+func (o *Object) Index(r *ghttp.Request) {
+    r.Response.Write("Object Index")
+}
+
+func (o *Object) Show(r *ghttp.Request) {
+    r.Response.Write("Object Show")
+}
+
+func (o *Object) Info(r *ghttp.Request) {
+    r.Response.Write("Object Info")
+}
+
+func Test_Router_Object1(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.BindObject("/", new(Object))
+    s.BindObject("/{.struct}/{.method}", new(Object))
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),            "1Object Index2")
+        gtest.Assert(client.GetContent("/init"),        "Not Found")
+        gtest.Assert(client.GetContent("/shut"),        "Not Found")
+        gtest.Assert(client.GetContent("/index"),       "1Object Index2")
+        gtest.Assert(client.GetContent("/show"),        "1Object Show2")
+
+        gtest.Assert(client.GetContent("/object"),            "Not Found")
+        gtest.Assert(client.GetContent("/object/init"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/shut"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/index"),      "1Object Index2")
+        gtest.Assert(client.GetContent("/object/show"),       "1Object Show2")
+
+        gtest.Assert(client.GetContent("/none-exist"),  "Not Found")
+    })
+}
+
+
+func Test_Router_Object2(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.BindObject("/object", new(Object), "Show, Info")
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                  "Not Found")
+        gtest.Assert(client.GetContent("/object"),            "Not Found")
+        gtest.Assert(client.GetContent("/object/init"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/shut"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/index"),      "Not Found")
+        gtest.Assert(client.GetContent("/object/show"),       "1Object Show2")
+        gtest.Assert(client.GetContent("/object/info"),       "1Object Info2")
+
+        gtest.Assert(client.GetContent("/none-exist"),  "Not Found")
+    })
+}
+
+func Test_Router_ObjectMethod(t *testing.T) {
+    p := ports.PopRand()
+    s := g.Server(p)
+    s.BindObjectMethod("/object-info", new(Object), "Info")
+    s.SetPort(p)
+    s.SetDumpRouteMap(false)
+    s.Start()
+    defer s.Shutdown()
+
+    // 等待启动完成
+    time.Sleep(time.Second)
+    gtest.Case(t, func() {
+        client := ghttp.NewClient()
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
+
+        gtest.Assert(client.GetContent("/"),                  "Not Found")
+        gtest.Assert(client.GetContent("/object"),            "Not Found")
+        gtest.Assert(client.GetContent("/object/init"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/shut"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/index"),      "Not Found")
+        gtest.Assert(client.GetContent("/object/show"),       "Not Found")
+        gtest.Assert(client.GetContent("/object/info"),       "Not Found")
+        gtest.Assert(client.GetContent("/object-info"),       "1Object Info2")
+
+        gtest.Assert(client.GetContent("/none-exist"),        "Not Found")
+    })
+}

g/net/ghttp/ghttp_unit_session_test.go

@@ -8,16 +8,17 @@
 package ghttp_test
 
 import (
+    "fmt"
     "github.com/gogf/gf/g"
     "github.com/gogf/gf/g/net/ghttp"
-    "github.com/gogf/gf/g/os/gtime"
     "github.com/gogf/gf/g/test/gtest"
     "testing"
     "time"
 )
 
 func Test_Session(t *testing.T) {
-    s := g.Server(gtime.Nanosecond())
+    p := ports.PopRand()
+    s := g.Server(p)
     s.BindHandler("/set", func(r *ghttp.Request){
         r.Session.Set(r.Get("k"), r.Get("v"))
     })
@@ -30,19 +31,17 @@ func Test_Session(t *testing.T) {
     s.BindHandler("/clear", func(r *ghttp.Request){
         r.Session.Clear()
     })
-    s.SetPort(8600)
+    s.SetPort(p)
     s.SetDumpRouteMap(false)
-    go s.Run()
-    defer func() {
-        s.Shutdown()
-        time.Sleep(time.Second)
-    }()
+    s.Start()
+    defer s.Shutdown()
+
     // 等待启动完成
     time.Sleep(time.Second)
     gtest.Case(t, func() {
         client := ghttp.NewClient()
         client.SetBrowserMode(true)
-        client.SetPrefix("http://127.0.0.1:8600")
+        client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", p))
         r1, e1 := client.Get("/set?k=key1&v=100")
         if r1 != nil {
             defer r1.Close()

g/os/gcfg/gcfg.go

@@ -37,6 +37,8 @@ type Config struct {
     vc     *gtype.Bool              // 层级检索是否执行分隔符冲突检测(默认为false，检测会比较影响检索效率)
 }
 
+// New returns a new configuration management object.
+//
 // 生成一个配置管理对象
 func New(path string, file...string) *Config {
     name := DEFAULT_CONFIG_FILE
@@ -55,6 +57,8 @@ func New(path string, file...string) *Config {
     return c
 }
 
+// filePath returns the absolute configuration file path for the given filename by <file>.
+//
 // 判断从哪个配置文件中获取内容，返回配置文件的绝对路径
 func (c *Config) filePath(file...string) (path string) {
     name := c.name.Val()
@@ -63,24 +67,23 @@ func (c *Config) filePath(file...string) (path string) {
     }
     c.paths.RLockFunc(func(array []string) {
         for _, v := range array {
-            //fmt.Println("search:", v, name)
             if path, _ = gspath.Search(v, name); path != "" {
                 break
-            } else {
-                //if strings.EqualFold(v, "/Users/john/Temp/config") {
-                //    gutil.Dump(gspath.Get(v).AllPaths())
-                //}
             }
         }
     })
     if path == "" {
         buffer := bytes.NewBuffer(nil)
-        buffer.WriteString(fmt.Sprintf("[gcfg] cannot find config file \"%s\" in following paths:", name))
-        c.paths.RLockFunc(func(array []string) {
-            for k, v := range array {
-                buffer.WriteString(fmt.Sprintf("\n%d. %s",k + 1,  v))
-            }
-        })
+        if c.paths.Len() > 0 {
+            buffer.WriteString(fmt.Sprintf("[gcfg] cannot find config file \"%s\" in following paths:", name))
+            c.paths.RLockFunc(func(array []string) {
+                for k, v := range array {
+                    buffer.WriteString(fmt.Sprintf("\n%d. %s",k + 1,  v))
+                }
+            })
+        } else {
+            buffer.WriteString(fmt.Sprintf("[gcfg] cannot find config file \"%s\" with no path set/add", name))
+        }
         glog.Error(buffer.String())
     }
     return path
@@ -94,10 +97,14 @@ func (c *Config) SetPath(path string) error {
         glog.Error(fmt.Sprintf(`[gcfg] SetPath failed: %s`, err.Error()))
         return err
     }
+    // 重复判断
+    if c.paths.Search(realPath) != -1 {
+        return nil
+    }
     c.jsons.Clear()
     c.paths.Clear()
     c.paths.Append(realPath)
-    glog.Debug("[gcfg] SetPath:", realPath)
+    //glog.Debug("[gcfg] SetPath:", realPath)
     return nil
 }
 
@@ -116,19 +123,34 @@ func (c *Config) AddPath(path string) error {
         glog.Error(fmt.Sprintf(`[gcfg] AddPath failed: %s`, err.Error()))
         return err
     }
+    // 重复判断
+    if c.paths.Search(realPath) != -1 {
+        return nil
+    }
     c.paths.Append(realPath)
-    glog.Debug("[gcfg] AddPath:", realPath)
+    //glog.Debug("[gcfg] AddPath:", realPath)
     return nil
 }
 
-// 获取指定文件的绝对路径，默认获取默认的配置文件路径
-func (c *Config) GetFilePath(file...string) string {
-    return c.filePath(file...)
+// 获取指定文件的绝对路径，默认获取默认的配置文件路径，当指定的配置文件不存在时，返回空字符串，并且不会报错。
+func (c *Config) GetFilePath(file...string) (path string) {
+    name := c.name.Val()
+    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
+            }
+        }
+    })
+    return
 }
 
 // 设置配置管理对象的默认文件名称
 func (c *Config) SetFileName(name string) {
-    glog.Debug("[gcfg] SetFileName:", name)
+    //glog.Debug("[gcfg] SetFileName:", name)
     c.name.Set(name)
 }
 

g/os/gtimer/gtimer_z_unit_1_test.go

@@ -235,7 +235,7 @@ func TestTimer_AddLeveledEntry1(t *testing.T) {
         })
         time.Sleep(1500*time.Millisecond)
         gtest.Assert(array.Len(), 0)
-        time.Sleep(1200*time.Millisecond)
+        time.Sleep(1300*time.Millisecond)
         //glog.Println("check")
         gtest.Assert(array.Len(), 1)
     })

g/os/gview/gview.go

@@ -115,9 +115,13 @@ func (view *View) SetPath(path string) error {
         glog.Error(fmt.Sprintf(`[gview] SetPath failed: %s`, err.Error()))
         return err
     }
+    // 重复判断
+    if view.paths.Search(realPath) != -1 {
+        return nil
+    }
     view.paths.Clear()
     view.paths.Append(realPath)
-    glog.Debug("[gview] SetPath:", realPath)
+    //glog.Debug("[gview] SetPath:", realPath)
     return nil
 }
 
@@ -132,8 +136,12 @@ func (view *View) AddPath(path string) error {
         glog.Error(fmt.Sprintf(`[gview] AddPath failed: %s`, err.Error()))
         return err
     }
+    // 重复判断
+    if view.paths.Search(realPath) != -1 {
+        return nil
+    }
     view.paths.Append(realPath)
-    glog.Debug("[gview] AddPath:", realPath)
+    //glog.Debug("[gview] AddPath:", realPath)
     return nil
 }
 
@@ -165,12 +173,16 @@ func (view *View) Parse(file string, params Params, funcmap...map[string]interfa
     })
     if path == "" {
         buffer := bytes.NewBuffer(nil)
-        buffer.WriteString(fmt.Sprintf("[gview] cannot find template file \"%s\" in following paths:", file))
-        view.paths.RLockFunc(func(array []string) {
-            for k, v := range array {
-                buffer.WriteString(fmt.Sprintf("\n%d. %s",k + 1,  v))
-            }
-        })
+        if view.paths.Len() > 0 {
+            buffer.WriteString(fmt.Sprintf("[gview] cannot find template file \"%s\" in following paths:", file))
+            view.paths.RLockFunc(func(array []string) {
+                for k, v := range array {
+                    buffer.WriteString(fmt.Sprintf("\n%d. %s",k + 1,  v))
+                }
+            })
+        } else {
+            buffer.WriteString(fmt.Sprintf("[gview] cannot find template file \"%s\" with no path set/add", file))
+        }
         glog.Error(buffer.String())
         return nil, errors.New(fmt.Sprintf(`tpl "%s" not found`, file))
     }

g/test/gtest/gtest.go

@@ -181,14 +181,22 @@ func AssertLTE(value, expect interface{}) {
 }
 
 
-// 断言判断, value IN expect; 注意: expect必须为slice类型
+// 断言判断, value IN expect; 注意: expect必须为slice类型。
+// 注意：value参数可以为普通变量，也可以为slice类型。
 func AssertIN(value, expect interface{}) {
-    passed := false
+    passed := true
     switch reflect.ValueOf(expect).Kind() {
         case reflect.Slice, reflect.Array:
-            for _, v := range gconv.Interfaces(expect) {
-                if v == value {
-                    passed = true
+            for _, v1 := range gconv.Interfaces(value) {
+                result := false
+                for _, v2 := range gconv.Interfaces(expect) {
+                    if v1 == v2 {
+                        result = true
+                        break
+                    }
+                }
+                if !result {
+                    passed = false
                     break
                 }
             }
@@ -200,17 +208,24 @@ func AssertIN(value, expect interface{}) {
 
 // 断言判断, value NOT IN expect; 注意: expect必须为slice类型
 func AssertNI(value, expect interface{}) {
-    passed := false
+    passed := true
     switch reflect.ValueOf(expect).Kind() {
         case reflect.Slice, reflect.Array:
-            for _, v := range gconv.Interfaces(expect) {
-                if v == value {
-                    passed = true
+            for _, v1 := range gconv.Interfaces(value) {
+                result := true
+                for _, v2 := range gconv.Interfaces(expect) {
+                    if v1 == v2 {
+                        result = false
+                        break
+                    }
+                }
+                if !result {
+                    passed = false
                     break
                 }
             }
     }
-    if passed {
+    if !passed {
         panic(fmt.Sprintf(`[ASSERT] EXPECT %v NOT IN %v`, value, expect))
     }
 }
@@ -238,14 +253,21 @@ func compareMap(value, expect interface{}) error {
     if rvExpect.Kind() == reflect.Map {
         if rvValue.Kind() == reflect.Map {
             if rvExpect.Len() == rvValue.Len() {
+                // 将两个map类型转换为同一个map类型, 才能执行比较,
+                // 直接使用 rvValue.MapIndex(key).Interface() 当key类型不一致时会报错。
+                mValue   := make(map[string]string)
+                mExpect  := make(map[string]string)
+                ksValue  := rvValue.MapKeys()
                 ksExpect := rvExpect.MapKeys()
+                for _, key := range ksValue {
+                    mValue[gconv.String(key.Interface())] = gconv.String(rvValue.MapIndex(key).Interface())
+                }
                 for _, key := range ksExpect {
-                    if fmt.Sprintf("%v", rvValue.MapIndex(key).Interface()) != fmt.Sprintf("%v", rvExpect.MapIndex(key).Interface()) {
-                        return fmt.Errorf(`[ASSERT] EXPECT VALUE map["%v"]:%v == %v`,
-                            key,
-                            rvValue.MapIndex(key).Interface(),
-                            rvExpect.MapIndex(key).Interface(),
-                        )
+                    mExpect[gconv.String(key.Interface())] = gconv.String(rvExpect.MapIndex(key).Interface())
+                }
+                for k, v := range mExpect {
+                    if v != mValue[k] {
+                        return fmt.Errorf(`[ASSERT] EXPECT VALUE map["%v"]:%v == %v`, k, mValue[k], v)
                     }
                 }
             } else {

g/text/gstr/gstr.go

@@ -31,15 +31,78 @@ func Replace(origin, search, replace string, count...int) string {
     return strings.Replace(origin, search, replace, n)
 }
 
+// Replace returns a copy of the string <origin> with string <search> replaced by <replace>
+// with case-insensitive.
+//
+// 字符串替换(大小写不敏感)
+func ReplaceI(origin, search, replace string, count...int) string {
+    n := -1
+    if len(count) > 0 {
+        n = count[0]
+    }
+    if n == 0 {
+        return origin
+    }
+    length      := len(search)
+    searchLower := strings.ToLower(search)
+    for {
+        originLower := strings.ToLower(origin)
+        if pos := strings.Index(originLower, searchLower); pos != -1 {
+            origin = origin[ : pos] + replace + origin[pos + length : ]
+            if n -= 1; n == 0 {
+                break
+            }
+        } else {
+            break
+        }
+    }
+    return origin
+}
+
+// Replace string by array/slice.
+//
+// 使用map进行字符串替换(大小写敏感)
+func ReplaceByArray(origin string, array []string) string {
+    for i := 0; i < len(array); i += 2 {
+        if i + 1 >= len(array) {
+            break
+        }
+        origin = Replace(origin, array[i], array[i + 1])
+    }
+    return origin
+}
+
+// Replace string by array/slice with case-insensitive.
+//
+// 使用map进行字符串替换(大小写不敏感)
+func ReplaceIByArray(origin string, array []string) string {
+    for i := 0; i < len(array); i += 2 {
+        if i + 1 >= len(array) {
+            break
+        }
+        origin = ReplaceI(origin, array[i], array[i + 1])
+    }
+    return origin
+}
+
 // Replace string by map.
 //
 // 使用map进行字符串替换(大小写敏感)
 func ReplaceByMap(origin string, replaces map[string]string) string {
-    result := origin
     for k, v := range replaces {
-        result = strings.Replace(result, k, v, -1)
+        origin = Replace(origin, k, v)
     }
-    return result
+    return origin
+}
+
+// Replace string by map with case-insensitive.
+//
+// 使用map进行字符串替换(大小写不敏感)
+func ReplaceIByMap(origin string, replaces map[string]string) string {
+    for k, v := range replaces {
+        origin = ReplaceI(origin, k, v)
+    }
+    return origin
 }
 
 // ToLower returns a copy of the string s with all Unicode letters mapped to their lower case.

g/text/gstr/gstr_pos.go

@@ -9,6 +9,7 @@ package gstr
 import "strings"
 
 // Find the position of the first occurrence of a substring in a string.
+// It returns -1, if none found.
 //
 // 返回 needle 在 haystack 中首次出现的数字位置，找不到返回-1。
 func Pos(haystack, needle string, startOffset...int) int {
@@ -32,6 +33,7 @@ func Pos(haystack, needle string, startOffset...int) int {
 }
 
 // Find the position of the first occurrence of a case-insensitive substring in a string.
+// It returns -1, if none found.
 //
 // 返回在字符串 haystack 中 needle 首次出现的数字位置（不区分大小写），找不到返回-1。
 func PosI(haystack, needle string, startOffset...int) int {
@@ -56,6 +58,7 @@ func PosI(haystack, needle string, startOffset...int) int {
 }
 
 // Find the position of the last occurrence of a substring in a string.
+// It returns -1, if none found.
 //
 // 查找指定字符串在目标字符串中最后一次出现的位置，找不到返回-1。
 func PosR(haystack, needle string, startOffset...int) int {
@@ -81,6 +84,7 @@ func PosR(haystack, needle string, startOffset...int) int {
 }
 
 // Find the position of the last occurrence of a case-insensitive substring in a string.
+// It returns -1, if none found.
 //
 // 以不区分大小写的方式查找指定字符串在目标字符串中最后一次出现的位置，找不到返回-1。
 func PosRI(haystack, needle string, startOffset...int) int {

g/text/gstr/gstr_z_unit_test.go

@@ -21,6 +21,13 @@ func Test_Replace(t *testing.T) {
         gtest.Assert(gstr.Replace(s1, "ab", "AB"), "ABcdEFG乱入的中文ABcdefg")
         gtest.Assert(gstr.Replace(s1, "EF", "ef"), "abcdefG乱入的中文abcdefg")
         gtest.Assert(gstr.Replace(s1, "MN", "mn"), s1)
+
+        gtest.Assert(gstr.ReplaceByArray(s1, g.ArrayStr {
+            "a" , "A",
+            "A" , "-",
+            "a",
+        }), "-bcdEFG乱入的中文-bcdefg")
+
         gtest.Assert(gstr.ReplaceByMap(s1, g.MapStrStr{
             "a" : "A",
             "G" : "g",
@@ -28,6 +35,36 @@ func Test_Replace(t *testing.T) {
     })
 }
 
+func Test_ReplaceI_1(t *testing.T) {
+    gtest.Case(t, func() {
+        s1 := "abcd乱入的中文ABCD"
+        s2 := "a"
+        gtest.Assert(gstr.ReplaceI(s1, "ab", "aa"),     "aacd乱入的中文aaCD")
+        gtest.Assert(gstr.ReplaceI(s1, "ab", "aa", 0),  "abcd乱入的中文ABCD")
+        gtest.Assert(gstr.ReplaceI(s1, "ab", "aa", 1),  "aacd乱入的中文ABCD")
+
+        gtest.Assert(gstr.ReplaceI(s1, "abcd", "-"),     "-乱入的中文-")
+        gtest.Assert(gstr.ReplaceI(s1, "abcd", "-", 1),  "-乱入的中文ABCD")
+
+        gtest.Assert(gstr.ReplaceI(s1, "abcd乱入的", ""), "中文ABCD")
+        gtest.Assert(gstr.ReplaceI(s1, "ABCD乱入的", ""), "中文ABCD")
+
+        gtest.Assert(gstr.ReplaceI(s2, "A", "-"), "-")
+        gtest.Assert(gstr.ReplaceI(s2, "a", "-"), "-")
+
+        gtest.Assert(gstr.ReplaceIByArray(s1, g.ArrayStr {
+            "abcd乱入的" , "-",
+            "-" , "=",
+            "a",
+        }), "=中文ABCD")
+
+        gtest.Assert(gstr.ReplaceIByMap(s1, g.MapStrStr {
+            "ab" : "-",
+            "CD" : "=",
+        }), "-=乱入的中文-=")
+    })
+}
+
 func Test_ToLower(t *testing.T) {
     gtest.Case(t, func() {
         s1 := "abcdEFG乱入的中文abcdefg"

g/util/gconv/gconv.go

@@ -47,7 +47,16 @@ func Convert(i interface{}, t string, extraParams...interface{}) interface{} {
                 return Time(i, String(extraParams[0]))
             }
             return Time(i)
-
+        case "gtime.Time":
+            if len(extraParams) > 0 {
+                return GTime(i, String(extraParams[0]))
+            }
+            return *GTime(i)
+        case "*gtime.Time":
+            if len(extraParams) > 0 {
+                return GTime(i, String(extraParams[0]))
+            }
+            return GTime(i)
         case "time.Duration":   return TimeDuration(i)
         default:
             return i

g/util/gconv/gconv_map.go

@@ -7,108 +7,135 @@
 package gconv
 
 import (
+    "github.com/gogf/gf/g/internal/empty"
     "reflect"
+    "strings"
 )
 
 // 任意类型转换为 map[string]interface{} 类型,
 // 如果给定的输入参数i不是map类型，那么转换会失败，返回nil.
 // 当i为struct对象时，第二个参数noTagCheck表示不检测json标签，否则将会使用json tag作为map的键名。
-func Map(i interface{}, noTagCheck...bool) map[string]interface{} {
-    if i == nil {
+func Map(value interface{}, noTagCheck...bool) map[string]interface{} {
+    if value == nil {
         return nil
     }
-    if r, ok := i.(map[string]interface{}); ok {
+    if r, ok := value.(map[string]interface{}); ok {
         return r
     } else {
         // 仅对常见的几种map组合进行断言，最后才会使用反射
         m := make(map[string]interface{})
-        switch i.(type) {
+        switch value.(type) {
             case map[interface{}]interface{}:
-                for k, v := range i.(map[interface{}]interface{}) {
+                for k, v := range value.(map[interface{}]interface{}) {
                     m[String(k)] = v
                 }
             case map[interface{}]string:
-                for k, v := range i.(map[interface{}]string) {
+                for k, v := range value.(map[interface{}]string) {
                     m[String(k)] = v
                 }
             case map[interface{}]int:
-                for k, v := range i.(map[interface{}]int) {
+                for k, v := range value.(map[interface{}]int) {
                     m[String(k)] = v
                 }
             case map[interface{}]uint:
-                for k, v := range i.(map[interface{}]uint) {
+                for k, v := range value.(map[interface{}]uint) {
                     m[String(k)] = v
                 }
             case map[interface{}]float32:
-                for k, v := range i.(map[interface{}]float32) {
+                for k, v := range value.(map[interface{}]float32) {
                     m[String(k)] = v
                 }
             case map[interface{}]float64:
-                for k, v := range i.(map[interface{}]float64) {
+                for k, v := range value.(map[interface{}]float64) {
                     m[String(k)] = v
                 }
 
             case map[string]bool:
-                for k, v := range i.(map[string]bool) {
+                for k, v := range value.(map[string]bool) {
                     m[k] = v
                 }
             case map[string]int:
-                for k, v := range i.(map[string]int) {
+                for k, v := range value.(map[string]int) {
                     m[k] = v
                 }
             case map[string]uint:
-                for k, v := range i.(map[string]uint) {
+                for k, v := range value.(map[string]uint) {
                     m[k] = v
                 }
             case map[string]float32:
-                for k, v := range i.(map[string]float32) {
+                for k, v := range value.(map[string]float32) {
                     m[k] = v
                 }
             case map[string]float64:
-                for k, v := range i.(map[string]float64) {
+                for k, v := range value.(map[string]float64) {
                     m[k] = v
                 }
 
             case map[int]interface{}:
-                for k, v := range i.(map[int]interface{}) {
+                for k, v := range value.(map[int]interface{}) {
                     m[String(k)] = v
                 }
             case map[int]string:
-                for k, v := range i.(map[int]string) {
+                for k, v := range value.(map[int]string) {
                     m[String(k)] = v
                 }
             case map[uint]string:
-                for k, v := range i.(map[uint]string) {
+                for k, v := range value.(map[uint]string) {
                     m[String(k)] = v
                 }
             // 不是常见类型，则使用反射
             default:
-                rv   := reflect.ValueOf(i)
+                rv   := reflect.ValueOf(value)
                 kind := rv.Kind()
                 // 如果是指针，那么需要转换到指针对应的数据项，以便识别真实的类型
                 if kind == reflect.Ptr {
                     rv   = rv.Elem()
                     kind = rv.Kind()
                 }
-                if kind == reflect.Map {
-                    ks := rv.MapKeys()
-                    for _, k := range ks {
-                        m[String(k.Interface())] = rv.MapIndex(k).Interface()
-                    }
-                } else if kind == reflect.Struct {
-                    rt   := rv.Type()
-                    name := ""
-                    for i := 0; i < rv.NumField(); i++ {
-                        // 检查json tag
-                        if len(noTagCheck) == 0 || !noTagCheck[0] {
-                            if name = rt.Field(i).Tag.Get("json"); name == "" {
-                                name = rt.Field(i).Name
-                            }
+                switch kind {
+                    case reflect.Map:
+                        ks := rv.MapKeys()
+                        for _, k := range ks {
+                            m[String(k.Interface())] = rv.MapIndex(k).Interface()
                         }
-                        m[name] = rv.Field(i).Interface()
-                    }
-                } else {
-                    return nil
+                    case reflect.Struct:
+                        rt   := rv.Type()
+                        name := ""
+                        for i := 0; i < rv.NumField(); i++ {
+                            name = ""
+                            // 检查tag, 支持gconv, json标签, 优先使用gconv
+                            if len(noTagCheck) == 0 || !noTagCheck[0] {
+                                tag := rt.Field(i).Tag
+                                if name = tag.Get("gconv"); name == "" {
+                                    name = tag.Get("json")
+                                }
+                            }
+                            if name == "" {
+                                name = strings.TrimSpace(rt.Field(i).Name)
+                            } else {
+                                // 支持标准库json特性: -, omitempty
+                                name = strings.TrimSpace(name)
+                                if name == "-" {
+                                    continue
+                                }
+                                array := strings.Split(name, ",")
+                                if len(array) > 1 {
+                                    switch strings.TrimSpace(array[1]) {
+                                        case "omitempty":
+                                            if empty.IsEmpty(rv.Field(i).Interface()) {
+                                                continue
+                                            } else {
+                                                name = strings.TrimSpace(array[0])
+                                            }
+                                        default:
+                                            name = strings.TrimSpace(array[0])
+                                    }
+                                }
+                            }
+                            m[name] = rv.Field(i).Interface()
+                        }
+                    default:
+                        return nil
                 }
         }
         return m

g/util/gconv/gconv_struct.go

@@ -15,68 +15,60 @@ import (
     "strings"
 )
 
-// 将params键值对参数映射到对应的struct对象属性上，第三个参数mapping为非必需，表示自定义名称与属性名称的映射关系。
+// 将params键值对参数映射到对应的struct对象属性上，
+// 第三个参数mapping为非必需，表示自定义名称与属性名称的映射关系。
 // 需要注意：
 // 1、第二个参数应当为struct对象指针；
 // 2、struct对象的**公开属性(首字母大写)**才能被映射赋值；
 // 3、map中的键名可以为小写，映射转换时会自动将键名首字母转为大写做匹配映射，如果无法匹配则忽略；
 func Struct(params interface{}, objPointer interface{}, attrMapping...map[string]string) error {
     if params == nil {
-        return nil
+        return errors.New("params cannot be nil")
     }
-    isParamMap := true
-    paramsMap  := (map[string]interface{})(nil)
-    // 先将参数转为 map[string]interface{} 类型
-    if m, ok := params.(map[string]interface{}); ok {
-        paramsMap = m
-    } else {
-        paramsMap = make(map[string]interface{})
-        if reflect.ValueOf(params).Kind() == reflect.Map {
-            ks := reflect.ValueOf(params).MapKeys()
-            vs := reflect.ValueOf(params)
-            for _, k := range ks {
-                paramsMap[String(k.Interface())] = vs.MapIndex(k).Interface()
-            }
-        } else {
-            isParamMap = false
-        }
+    if objPointer == nil {
+        return errors.New("object pointer cannot be nil")
+    }
+    paramsMap := Map(params)
+    if paramsMap == nil {
+        return fmt.Errorf("invalid params: %v", params)
     }
     // struct的反射对象
     elem := reflect.Value{}
     if v, ok := objPointer.(reflect.Value); ok {
         elem = v
     } else {
-        elem = reflect.ValueOf(objPointer).Elem()
-    }
-    // 如果给定的参数不是map类型，那么直接将参数值映射到第一个属性上
-    if !isParamMap {
-        if err := bindVarToStructByIndex(elem, 0, params); err != nil {
-            return err
+        rv := reflect.ValueOf(objPointer)
+        if kind := rv.Kind(); kind != reflect.Ptr {
+            return fmt.Errorf("object pointer should be type of: %v", kind)
         }
-        return nil
+        if !rv.IsValid() || rv.IsNil() {
+            return errors.New("object pointer cannot be nil")
+        }
+        elem = rv.Elem()
     }
-    // 已执行过转换的属性，只执行一次转换
-    dmap := make(map[string]bool)
+    // 已执行过转换的属性，只执行一次转换。
+    // 或者是已经执行过转换检查的属性(即使不进行转换), 以便重复判断。
+    doneMap := make(map[string]bool)
     // 首先按照传递的映射关系进行匹配
     if len(attrMapping) > 0 && len(attrMapping[0]) > 0 {
-        for mappingk, mappingv := range attrMapping[0] {
-            if v, ok := paramsMap[mappingk]; ok {
-                dmap[mappingv] = true
-                if err := bindVarToStructAttr(elem, mappingv, v); err != nil {
+        for mapK, mapV := range attrMapping[0] {
+            if v, ok := paramsMap[mapK]; ok {
+                doneMap[mapV] = true
+                if err := bindVarToStructAttr(elem, mapV, v); err != nil {
                     return err
                 }
             }
         }
     }
-    // 其次匹配对象定义时绑定的属性名称
+    // 其次匹配对象定义时绑定的属性名称,
     // 标签映射关系map，如果有的话
-    tagmap := getTagMapOfStruct(objPointer)
-    for tagk, tagv := range tagmap {
-        if _, ok := dmap[tagv]; ok {
+    tagMap := getTagMapOfStruct(objPointer)
+    for tagk, tagv := range tagMap {
+        if _, ok := doneMap[tagv]; ok {
             continue
         }
         if v, ok := paramsMap[tagk]; ok {
-            dmap[tagv] = true
+            doneMap[tagv] = true
             if err := bindVarToStructAttr(elem, tagv, v); err != nil {
                 return err
             }
@@ -88,19 +80,19 @@ func Struct(params interface{}, objPointer interface{}, attrMapping...map[string
     for i := 0; i < elem.NumField(); i++ {
         attrMap[elemType.Field(i).Name] = struct{}{}
     }
-    for mapk, mapv := range paramsMap {
+    for mapK, mapV := range paramsMap {
         name := ""
         for _, checkName := range []string {
-            gstr.UcFirst(mapk),
-            gstr.ReplaceByMap(mapk, map[string]string{
+            gstr.UcFirst(mapK),
+            gstr.ReplaceByMap(mapK, map[string]string{
                 "_" : "",
                 "-" : "",
                 " " : "",
-            })} {
-            if _, ok := dmap[checkName]; ok {
+            })}  {
+            if _, ok := doneMap[checkName]; ok {
                 continue
             }
-            if _, ok := tagmap[checkName]; ok {
+            if _, ok := tagMap[checkName]; ok {
                 continue
             }
             // 循环查找属性名称进行匹配
@@ -114,6 +106,7 @@ func Struct(params interface{}, objPointer interface{}, attrMapping...map[string
                     break
                 }
             }
+            doneMap[checkName] = true
             if name != "" {
                 break
             }
@@ -122,7 +115,7 @@ func Struct(params interface{}, objPointer interface{}, attrMapping...map[string
         if name == "" {
             continue
         }
-        if err := bindVarToStructAttr(elem, name, mapv); err != nil {
+        if err := bindVarToStructAttr(elem, name, mapV); err != nil {
             return err
         }
     }

g/util/gconv/gconv_time.go

@@ -22,7 +22,7 @@ func TimeDuration(i interface{}) time.Duration {
     return time.Duration(Int64(i))
 }
 
-// 将变量i转换为time.Time类型
+// 将变量i转换为time.Time类型, 自动识别i为时间戳或者标准化的时间字符串。
 func GTime(i interface{}, format...string) *gtime.Time {
     s := String(i)
     if len(s) == 0 {

g/util/gconv/gconv_z_unit_map_test.go

@@ -14,7 +14,7 @@ import (
 )
 
 
-func Test_Map(t *testing.T) {
+func Test_Map_Basic(t *testing.T) {
     gtest.Case(t, func() {
         m1 := map[string]string{
             "k" : "v",
@@ -36,3 +36,79 @@ func Test_Map(t *testing.T) {
         })
     })
 }
+
+func Test_Map_StructWithGconvTag(t *testing.T) {
+    gtest.Case(t, func() {
+        type User struct {
+            Uid      int
+            Name     string
+            SiteUrl  string `gconv:"-"`
+            NickName string `gconv:"nickname, omitempty"`
+            Pass1    string `gconv:"password1"`
+            Pass2    string `gconv:"password2"`
+        }
+        user1 := User{
+            Uid      : 100,
+            Name     : "john",
+            SiteUrl  : "https://goframe.org",
+            Pass1    : "123",
+            Pass2    : "456",
+        }
+        user2 := &user1
+        map1  := gconv.Map(user1)
+        map2  := gconv.Map(user2)
+        gtest.Assert(map1["Uid"],       100)
+        gtest.Assert(map1["Name"],      "john")
+        gtest.Assert(map1["SiteUrl"],   nil)
+        gtest.Assert(map1["NickName"],  nil)
+        gtest.Assert(map1["nickname"],  nil)
+        gtest.Assert(map1["password1"], "123")
+        gtest.Assert(map1["password2"], "456")
+
+        gtest.Assert(map2["Uid"],       100)
+        gtest.Assert(map2["Name"],      "john")
+        gtest.Assert(map2["SiteUrl"],   nil)
+        gtest.Assert(map2["NickName"],  nil)
+        gtest.Assert(map2["nickname"],  nil)
+        gtest.Assert(map2["password1"], "123")
+        gtest.Assert(map2["password2"], "456")
+    })
+}
+
+func Test_Map_StructWithJsonTag(t *testing.T) {
+    gtest.Case(t, func() {
+        type User struct {
+            Uid      int
+            Name     string
+            SiteUrl  string `json:"-"`
+            NickName string `json:"nickname, omitempty"`
+            Pass1    string `json:"password1"`
+            Pass2    string `json:"password2"`
+        }
+        user1 := User{
+            Uid      : 100,
+            Name     : "john",
+            SiteUrl  : "https://goframe.org",
+            Pass1    : "123",
+            Pass2    : "456",
+        }
+        user2 := &user1
+        map1  := gconv.Map(user1)
+        map2  := gconv.Map(user2)
+        gtest.Assert(map1["Uid"],       100)
+        gtest.Assert(map1["Name"],      "john")
+        gtest.Assert(map1["SiteUrl"],   nil)
+        gtest.Assert(map1["NickName"],  nil)
+        gtest.Assert(map1["nickname"],  nil)
+        gtest.Assert(map1["password1"], "123")
+        gtest.Assert(map1["password2"], "456")
+
+        gtest.Assert(map2["Uid"],       100)
+        gtest.Assert(map2["Name"],      "john")
+        gtest.Assert(map2["SiteUrl"],   nil)
+        gtest.Assert(map2["NickName"],  nil)
+        gtest.Assert(map2["nickname"],  nil)
+        gtest.Assert(map2["password1"], "123")
+        gtest.Assert(map2["password2"], "456")
+    })
+}

g/util/gvalid/gvalid_check.go

@@ -105,16 +105,20 @@ var (
 )
 
 // 检测单条数据的规则:
-// value为需要校验的数据，可以为任意基本数据类型；
-// msgs为自定义错误信息，由于同一条数据的校验规则可能存在多条，为方便调用，参数类型支持 string/map[string]string ，允许传递多个自定义的错误信息，如果类型为string，那么中间使用"|"符号分隔多个自定义错误；
-// params参数为联合校验参数，对于需要联合校验的规则有效，如：required-*、same、different；
-func Check(value interface{}, rules string, msgs interface{}, params...map[string]interface{}) *Error {
+//
+// 1. value为需要校验的数据，可以为任意基本数据类型；
+//
+// 2. msgs为自定义错误信息，由于同一条数据的校验规则可能存在多条，为方便调用，参数类型支持 string/map/struct/*struct,
+// 允许传递多个自定义的错误信息，如果类型为string，那么中间使用"|"符号分隔多个自定义错误；
+//
+// 3. params参数为联合校验参数，支持任意的map/struct/*struct类型，对于需要联合校验的规则有效，如：required-*、same、different；
+func Check(value interface{}, rules string, msgs interface{}, params...interface{}) *Error {
     // 内部会将参数全部转换为字符串类型进行校验
     val       := strings.TrimSpace(gconv.String(value))
     data      := make(map[string]string)
     errorMsgs := make(map[string]string)
     if len(params) > 0 {
-        for k, v := range params[0] {
+        for k, v := range gconv.Map(params[0]) {
             data[k] = gconv.String(v)
         }
     }
@@ -122,11 +126,12 @@ func Check(value interface{}, rules string, msgs interface{}, params...map[strin
     msgArray     := make([]string, 0)
     customMsgMap := make(map[string]string)
     switch v := msgs.(type) {
-        case map[string]string:
-            customMsgMap = v
-
         case string:
             msgArray = strings.Split(v, "|")
+        default:
+            for k, v := range gconv.Map(msgs) {
+                data[k] = gconv.String(v)
+            }
     }
     ruleItems := strings.Split(strings.TrimSpace(rules), "|")
     // 规则项预处理, 主要解决规则中存在的"|"关键字符号

geg/net/ghttp/server/domain.go

@@ -13,7 +13,7 @@ func Hello2(r *ghttp.Request) {
 func main() {
     s := ghttp.GetServer()
     s.Domain("127.0.0.1").BindHandler("/", Hello1)
-    s.Domain("localhost").BindHandler("/", Hello2)
+    s.Domain("localhost, local").BindHandler("/", Hello2)
     s.SetPort(8199)
     s.Run()
 }

geg/net/ghttp/server/hooks/cors2.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/frame/gmvc"
+    "github.com/gogf/gf/g/net/ghttp"
+)
+
+type Order2 struct {
+    gmvc.Controller
+}
+
+func (o *Order2) Get() {
+    o.Response.Write("GET")
+}
+
+func main() {
+    s := g.Server()
+    s.BindHookHandlerByMap("/api.v2/*any", map[string]ghttp.HandlerFunc {
+       "BeforeServe"  : func(r *ghttp.Request) {
+           r.Response.CORSDefault()
+       },
+    })
+    s.BindControllerRest("/api.v2/{.struct}", new(Order2))
+    s.SetPort(8199)
+    s.Run()
+}

geg/net/ghttp/server/reload/multi_port.go

@@ -1,23 +0,0 @@
-package main
-
-import (
-    "github.com/gogf/gf/g"
-    "github.com/gogf/gf/g/net/ghttp"
-)
-
-func main() {
-    s := g.Server()
-    s.BindHandler("/", func(r *ghttp.Request){
-        r.Response.Writeln("hello")
-    })
-    s.BindHandler("/restart", func(r *ghttp.Request){
-        r.Response.Writeln("restart server")
-        r.Server.Restart()
-    })
-    s.BindHandler("/shutdown", func(r *ghttp.Request){
-        r.Response.Writeln("shutdown server")
-        r.Server.Shutdown()
-    })
-    s.SetPort(8199, 8200)
-    s.Run()
-}

geg/net/ghttp/server/session/session.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/frame/gmvc"
+)
+
+type Controller struct {
+    gmvc.Controller
+}
+
+func (c *Controller) Login() {
+    c.Session.Id()
+    c.Response.Write("这个页面用户填写信息执行登录")
+}
+
+func (c *Controller) DoLogin() {
+    c.Session.Set("key", "value")
+    //c.Response.Header().Set("Set-Cookie", "myid=1B27UGQGCIBP0P70; Path=/; Domain=127.0.0.1; Expires=Wed, 04 Mar 2020 07:12:05 GMT")
+
+    c.Response.RedirectTo("/main")
+}
+
+func (c *Controller) Main() {
+    c.Response.WriteJson(c.Session.Data())
+}
+
+func main() {
+    s := g.Server()
+    s.BindController("/", new(Controller))
+    s.SetPort(8199)
+    s.Run()
+}

geg/net/ghttp/server/template/layout/main.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/net/ghttp"
+)
+
+func main() {
+    s := g.Server()
+    s.BindHandler("/main1", func(r *ghttp.Request) {
+        r.Response.WriteTpl("layout.html", g.Map{
+            "mainTpl" : "main/main1.html",
+        })
+    })
+    s.BindHandler("/main2", func(r *ghttp.Request) {
+        r.Response.WriteTpl("layout.html", g.Map{
+            "mainTpl" : "main/main2.html",
+        })
+    })
+    g.View().SetPath("template")
+    s.SetPort(8199)
+    s.Run()
+}

geg/net/ghttp/server/template/layout/template/footer.html

@@ -0,0 +1 @@
+<h1>FOOTER</h1>

geg/net/ghttp/server/template/layout/template/header.html

@@ -0,0 +1 @@
+<h1>HEADER</h1>

geg/net/ghttp/server/template/layout/template/layout.html

@@ -0,0 +1,3 @@
+{{include "header.html" .}}
+{{include .mainTpl .}}
+{{include "footer.html" .}}

geg/net/ghttp/server/template/layout/template/main/main1.html

@@ -0,0 +1 @@
+<h1>MAIN1</h1>

geg/net/ghttp/server/template/layout/template/main/main2.html

@@ -0,0 +1 @@
+<h1>MAIN2</h1>

geg/net/gtcp/gtcp_server_client1.go

@@ -15,9 +15,11 @@ func main() {
         for {
             data, err := conn.Recv(-1)
             if len(data) > 0 {
-                  fmt.Println(string(data))
+                fmt.Println(string(data))
             }
             if err != nil {
+                // client closed, err will be: EOF
+                fmt.Println(err)
                 break
             }
         }
@@ -36,5 +38,12 @@ func main() {
             glog.Error(err)
         }
         time.Sleep(time.Second)
+        if i == 5 {
+            conn.Close()
+            break
+        }
     }
+
+    // exit after 5 seconds
+    time.Sleep(5*time.Second)
 }

geg/net/gtcp/server_client/gtcp_client.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+    "github.com/gogf/gf/g/net/gtcp"
+    "github.com/gogf/gf/g/os/glog"
+    "github.com/gogf/gf/g/util/gconv"
+    "time"
+)
+
+func main() {
+    // Client
+    conn, err := gtcp.NewConn("127.0.0.1:8999")
+    if err != nil {
+        panic(err)
+    }
+    defer conn.Close()
+    for i := 0; i < 3; i++ {
+        if err := conn.Send([]byte(gconv.String(i))); err != nil {
+            glog.Error(err)
+        }
+        time.Sleep(time.Second)
+    }
+}

geg/net/gtcp/server_client/gtcp_server.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g/net/gtcp"
+)
+
+func main() {
+    // Server
+    gtcp.NewServer("127.0.0.1:8999", func(conn *gtcp.Conn) {
+        defer conn.Close()
+        for {
+            data, err := conn.Recv(-1)
+            if len(data) > 0 {
+                fmt.Println(string(data))
+            }
+            if err != nil {
+                // client closed, err will be: EOF
+                fmt.Println(err)
+                break
+            }
+        }
+    }).Run()
+}