version updates

.gitee/ISSUE_TEMPLATE.MD

@@ -1,17 +1,18 @@
 <!-- 为更高效率地交流并解决问题，请按照以下模板提交issue，感谢！ -->
-### 1. 您当前使用的`Go`版本（将终端`go version`指令结果粘贴到下面）？
 
-<pre>
-$ go version
+### 1. 您当前使用的`Go`版本，及系统版本、系统架构？
 
-</pre>
+<!-- 使用 `go version` 命令查看，期望的结果如：`go 1.12, linux/amd64` -->
 
-### 2. 您当前使用的`GoFrame`版本（可以查看`go.mod`/`version.go`/`gf.VERSION`）？
 
+### 2. 您当前使用的`GoFrame`框架版本？
+
+<!-- 框架版本可以查看自己项目下的 `go.mod`，或者框架文件 `version.go` -->
 
 
 ### 3. 更新到最新的框架版本是否能够解决问题？
 
+<!-- 务必检查是否相同问题已在新版本中已修复 -->
 
 
 ### 4. 问题描述？

.github/ISSUE_TEMPLATE.MD

@@ -1,16 +1,19 @@
 <!-- Please answer these questions before submitting your issue. Thanks! -->
-### 1. What version of `Go` are you using (`go version`)?
 
-<pre>
-$ go version
+### 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`
+-->
 
-</pre>
 
 ### 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. Does this issue reproduce with the latest release?
+### 3. Can this issue be reproduced with the latest release?
 
 
 

.travis.yml

@@ -1,7 +1,8 @@
 language: go
 
 go:
-- "1.11.x"
+  - "1.11.x"
+  - "1.12.x"
 
 branches:
   only:
@@ -9,25 +10,25 @@ branches:
   - develop
 
 env:
-- GO111MODULE=on
+  - GO111MODULE=on
 
 services:
-- mysql
+  - mysql
 
 before_install:
-- pwd
+  - pwd
 
 install:
-- pwd
+  - pwd
 
 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)
 
 
 

TODO.MD

@@ -53,8 +53,8 @@
 1. 改进gproc进程间通信处理逻辑，提高稳定性，以应对进程间大批量的数据发送/接收；
 1. gdb的Data方法支持struct参数传入；
 1. gfcache依旧使用gcache作为缓存控制对象，不要使用gmap；
-
-
+1. 增加对ghttp路由注册的{.struct}/{.method}单元测试；
+1. 更新跨域请求CORS相关功能文档；
 
 
 

g/database/gdb/gdb_func.go

@@ -12,16 +12,15 @@ 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)
     // 使用反射进行类型判断
@@ -32,29 +31,25 @@ func formatCondition(where interface{}, args []interface{}) (string, []interface
         kind = rv.Kind()
     }
     switch kind {
+        // 注意当where为map/struct类型时，args参数必须为空。
         case reflect.Map:   fallthrough
         case reflect.Struct:
             for k, v := range gconv.Map(where) {
-                key   := gconv.String(k)
-                value := gconv.String(v)
                 if buffer.Len() > 0 {
                     buffer.WriteString(" AND ")
                 }
-                if gstr.IsNumeric(value) || value == "?" {
-                    buffer.WriteString(key + "=" + value)
-                } else {
-                    buffer.WriteString(key + "='" + value + "'")
-                }
+                buffer.WriteString(k + "=?")
+                newArgs = append(newArgs, v)
             }
+            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)
@@ -64,7 +59,8 @@ func formatCondition(where interface{}, args []interface{}) (string, []interface
                 kind = rv.Kind()
             }
             switch kind {
-                // Where条件参数支持slice类型
+                // '?'占位符支持slice类型,
+                // 这里会将slice参数拆散，并更新原有占位符'?'为多个'?'，使用','符号连接。
                 case reflect.Slice: fallthrough
                 case reflect.Array:
                     for i := 0; i < rv.Len(); i++ {
@@ -83,7 +79,7 @@ func formatCondition(where interface{}, args []interface{}) (string, []interface
             }
         }
     }
-    return newWhere, newArgs
+    return
 }
 
 // 打印SQL对象(仅在debug=true时有效)

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_model_test.go

@@ -255,8 +255,51 @@ func TestModel_GroupBy(t *testing.T) {
     gtest.Assert(result[0]["nickname"].String(), "T111")
 }
 
-// slice
-func TestModel_Where1(t *testing.T) {
+// where string
+func TestModel_WhereString(t *testing.T) {
+    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)
+    })
+}
+
+// where map
+func TestModel_WhereMap(t *testing.T) {
+    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)
+    })
+}
+
+// where struct
+func TestModel_WhereStruct(t *testing.T) {
+    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)
+    })
+}
+
+// where slice
+func TestModel_WhereSlice1(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)
@@ -266,8 +309,8 @@ func TestModel_Where1(t *testing.T) {
     gtest.Assert(result[1]["id"].Int(), 3)
 }
 
-// slice
-func TestModel_Where2(t *testing.T) {
+// where slice
+func TestModel_WhereSlice2(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)

g/internal/empty/empty.go

@@ -0,0 +1,49 @@
+// 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)
+            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_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状态码

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_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,21 +124,25 @@ 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()
@@ -146,6 +151,12 @@ var (
     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_service_controller.go

@@ -10,6 +10,7 @@ package ghttp
 import (
     "errors"
     "github.com/gogf/gf/g/os/glog"
+    "github.com/gogf/gf/g/text/gregex"
     "strings"
     "reflect"
     "fmt"
@@ -63,10 +64,11 @@ 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")
             k := key[0 : p] + key[p + 6 : ]
             if len(k) == 0 {
@@ -126,12 +128,13 @@ func (s *Server)BindControllerRest(pattern string, c Controller) error {
     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 {
@@ -144,7 +147,7 @@ func (s *Server)BindControllerRest(pattern string, c Controller) error {
         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,

g/net/ghttp/ghttp_server_service_handler.go

@@ -49,7 +49,7 @@ func (s *Server) bindHandlerByMap(m handlerMap) error {
 
 // 将内置的名称按照设定的规则合并到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

@@ -10,6 +10,7 @@ package ghttp
 import (
     "errors"
     "github.com/gogf/gf/g/os/glog"
+    "github.com/gogf/gf/g/text/gregex"
     "strings"
     "reflect"
     "fmt"
@@ -72,8 +73,9 @@ 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")
             k := key[0 : p] + key[p + 6 : ]
             if len(k) == 0 {
@@ -145,6 +147,7 @@ func (s *Server)BindObjectRest(pattern string, obj interface{}) error {
     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() {
@@ -157,7 +160,7 @@ 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))
@@ -171,7 +174,7 @@ func (s *Server)BindObjectRest(pattern string, obj interface{}) error {
         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,

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_test.go

@@ -8,9 +8,9 @@
 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"
@@ -23,7 +23,8 @@ func Test_Params_Basic(t *testing.T) {
         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_Basic(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,73 @@
+// 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 Test_Router_Controller(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")
+    })
+}

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_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,67 @@
+// 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 Test_Router_Object(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")
+    })
+}

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

@@ -70,12 +70,16 @@ func (c *Config) filePath(file...string) (path string) {
     })
     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
@@ -96,7 +100,7 @@ func (c *Config) SetPath(path string) error {
     c.jsons.Clear()
     c.paths.Clear()
     c.paths.Append(realPath)
-    glog.Debug("[gcfg] SetPath:", realPath)
+    //glog.Debug("[gcfg] SetPath:", realPath)
     return nil
 }
 
@@ -120,7 +124,7 @@ func (c *Config) AddPath(path string) error {
         return nil
     }
     c.paths.Append(realPath)
-    glog.Debug("[gcfg] AddPath:", realPath)
+    //glog.Debug("[gcfg] AddPath:", realPath)
     return nil
 }
 
@@ -142,7 +146,7 @@ func (c *Config) GetFilePath(file...string) (path string) {
 
 // 设置配置管理对象的默认文件名称
 func (c *Config) SetFileName(name string) {
-    glog.Debug("[gcfg] SetFileName:", name)
+    //glog.Debug("[gcfg] SetFileName:", name)
     c.name.Set(name)
 }
 

g/os/gview/gview.go

@@ -121,7 +121,7 @@ func (view *View) SetPath(path string) error {
     }
     view.paths.Clear()
     view.paths.Append(realPath)
-    glog.Debug("[gview] SetPath:", realPath)
+    //glog.Debug("[gview] SetPath:", realPath)
     return nil
 }
 
@@ -141,7 +141,7 @@ func (view *View) AddPath(path string) error {
         return nil
     }
     view.paths.Append(realPath)
-    glog.Debug("[gview] AddPath:", realPath)
+    //glog.Debug("[gview] AddPath:", realPath)
     return nil
 }
 
@@ -173,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/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_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_map.go

@@ -7,111 +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++ {
-                        // 检查tag, 支持gconv, json标签, 优先使用gconv
-                        if len(noTagCheck) == 0 || !noTagCheck[0] {
-                            tag := rt.Field(i).Tag
-                            if name = tag.Get("gconv"); name == "" {
-                                if name = 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()
+                        }
+                    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()
                         }
-                        m[name] = rv.Field(i).Interface()
-                    }
-                } else {
-                    return nil
+                    default:
+                        return nil
                 }
         }
         return m

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

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

geg/other/test.go

@@ -1,14 +1,13 @@
 package main
 
-import (
-    "fmt"
-)
+import "fmt"
 
 func main() {
-    s := "abc我是中国人é"
-    fmt.Println(len(s))
-
-    for i := 0; i < len(s); i++ {
-        fmt.Println(s[i])
+    for i := 0; i < 10; i++ {
+        switch 1 {
+            default:
+                //continue
+        }
+        fmt.Println(i)
     }
 }

version.go

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