执行对象注册

执行对象注册是在注册时便给定一个实例化的对象，以后每一个请求都交给该对象(同一对象)处理，该对象常驻内存不释放。由于相比较控制器注册来说，执行对象注册方式在处理请求的时候不需要不停地创建/销毁控制器对象，因此请求处理效率会高很多。

这种注册方式的缺点也很明显，服务端进程在启动时便需要初始化这些执行对象，并且这些对象需要自行负责对自身数据的并发安全维护（往往struct对象的成员变量应当是并发安全的，每个请求执行完毕后struct对象不会销毁，其成员变量也不会释放）。

执行对象的定义没有严格要求，也没有强行要求继承gmvc.Controller控制器基类，因为在请求进入时没有自动初始化流程，内部的成员变量需要自行维护（包括变量初始化，变量销毁等）。

执行对象注册

我们可以通过ghttp.BindObject方法完成执行对象的注册。

gitee.com/johng/gf/blob/master/geg/frame/mvc/controller/demo/object.go

  1. package demo
  3. import (
  4.     "gitee.com/johng/gf/g"
  5.     "gitee.com/johng/gf/g/net/ghttp"
  6. )
  8. type Object struct {}
  10. func init() {
  11.     g.Server().BindObject("/object", new(Object))
  12. }
  14. func (o *Object) Index(r *ghttp.Request) {
  15.     r.Response.Write("object index")
  16. }
  18. func (o *Object) Show(r *ghttp.Request) {
  19.     r.Response.Write("object show")
  20. }

可以看到，执行对象在进行服务注册时便生成了一个对象(执行对象在Web Server启动时便生成)，此后不管多少请求进入，Web Server都是将请求转交给该对象对应的方法进行处理。需要注意的是，公开方法的定义，必须为以下形式：

  1. func(r *ghttp.Request)

否则无法完成注册，调用注册方法时会有错误提示，例如：

  1. panic: interface conversion: interface {} is xxx, not func(*ghttp.Request)

该示例执行后可以通过，可以通过http://127.0.0.1:8199/object/show查看效果。

默认路由方法

控制器中的Index方法是一个特殊的方法，例如，当注册的路由规则为/user时，HTTP请求到/user时，将会自动映射到控制器的Index方法。也就是说，访问地址/user和/user/index将会达到相同的执行效果。对后续的控制器注册方式同理。

路由内置变量

当使用BindObject方法进行执行对象注册时，在路由规则中可以使用两个内置的变量：{.struct}和{.method}，前者表示当前对象名称，后者表示当前注册的方法名。这两个内置变量使得开发者可以非常灵活地自定义路由规则。

我们来看一个例子：
gitee.com/johng/gf/blob/master/geg/frame/mvc/controller/demo/buildin-vars.go

  1. package demo
  3. import (
  4.     "gitee.com/johng/gf/g"
  5.     "gitee.com/johng/gf/g/net/ghttp"
  6. )
  8. type Order struct { }
  10. func init() {
  11.     g.Server().BindObject("/{.struct}-{.method}", new(Order))
  12. }
  14. func (o *Order) List(r *ghttp.Request) {
  15.     r.Response.Write("List")
  16. }

启动外层的main.go，我们尝试着访问http://127.0.0.1:8199/order-list，可以看到页面输出List。如果路由规则中不使用内置变量，那么默认的情况下，方法将会被追加到指定的路由规则末尾。

命名风格规则

当方法名称带有多个单词(按照字符大写区分单词)时，路由控制器默认会自动使用英文连接符号-进行拼接，因此访问的时候方法名称需要带-号。例如，方法名为UserName时，生成的URI地址为user-name；方法名为ShowListItems时，生成的URI地址为show-list-items；以此类推。对后续的控制器注册方式同理。

此外，我们可以通过ghttp.Server.SetNameToUriType方法来设置struct/method名称与uri的转换方式。支持的方式目前有4种，对应4个常量定义：

  1. NAME_TO_URI_TYPE_DEFAULT  = 0      // 服务注册时对象和方法名称转换为URI时，全部转为小写，单词以'-'连接符号连接
  2. NAME_TO_URI_TYPE_FULLNAME = 1      // 不处理名称，以原有名称构建成URI
  3. NAME_TO_URI_TYPE_ALLLOWER = 2      // 仅转为小写，单词间不使用连接符号
  4. NAME_TO_URI_TYPE_CAMEL    = 3      // 采用驼峰命名方式

我们来看一个示例：
gitee.com/johng/gf/blob/master/geg/net/ghttp/server/name.go

  1. package main
  3. import (
  4.     "gitee.com/johng/gf/g"
  5.     "gitee.com/johng/gf/g/net/ghttp"
  6. )
  8. type User struct {}
  10. func (u *User) ShowList(r *ghttp.Request) {
  11.     r.Response.Write("list")
  12. }
  14. func main() {
  15.     s1 := g.Server(1)
  16.     s2 := g.Server(2)
  17.     s3 := g.Server(3)
  18.     s4 := g.Server(4)
  20.     s1.SetNameToUriType(ghttp.NAME_TO_URI_TYPE_DEFAULT)
  21.     s2.SetNameToUriType(ghttp.NAME_TO_URI_TYPE_FULLNAME)
  22.     s3.SetNameToUriType(ghttp.NAME_TO_URI_TYPE_ALLLOWER)
  23.     s4.SetNameToUriType(ghttp.NAME_TO_URI_TYPE_CAMEL)
  25.     s1.BindObject("/{.struct}/{.method}", new(User))
  26.     s2.BindObject("/{.struct}/{.method}", new(User))
  27.     s3.BindObject("/{.struct}/{.method}", new(User))
  28.     s4.BindObject("/{.struct}/{.method}", new(User))
  30.     s1.SetPort(8100)
  31.     s2.SetPort(8200)
  32.     s3.SetPort(8300)
  33.     s4.SetPort(8400)
  35.     s1.Start()
  36.     s2.Start()
  37.     s3.Start()
  38.     s4.Start()
  40.     g.Wait()
  41. }

这个示例采用了多Server运行方式，将不同的名称转换方式使用了不同的Server来配置运行，因此我们可以方便地在同一个程序中，访问不同的Server（通过不同的端口绑定）看到不同的结果。执行以上示例后，可以分别访问以下URL地址得到期望的结果：

  1. http://127.0.0.1:8100/user/show-list
  2. http://127.0.0.1:8200/User/ShowList
  3. http://127.0.0.1:8300/user/showlist
  4. http://127.0.0.1:8300/user/showList

对象方法注册

假如控制器中有若干公开方法，但是我只想注册其中几个，其余的方法我不想对外公开，怎么办？

我们可以通过BindObject传递第三个非必需参数替换实现，参数支持传入多个方法名称，多个名称以英文,号分隔（方法名称参数区分大小写）。

示例：

  1. package demo
  3. import (
  4.     "gitee.com/johng/gf/g"
  5.     "gitee.com/johng/gf/g/net/ghttp"
  6. )
  8. type Object struct {}
  10. func init() {
  11.     obj := new(Object)
  12.     g.Server().BindObject("/object", obj)
  13.     g.Server().BindObjectMethod("/object-show", obj, "Show")
  14. }
  16. func (o *Object) Index(r *ghttp.Request) {
  17.     r.Response.Write("object index")
  18. }
  20. func (o *Object) Show(r *ghttp.Request) {
  21.     r.Response.Write("object show")
  22. }

绑定路由方法

我们可以通过BindObjectMethod方法绑定指定的路由到指定的方法执行（方法名称参数区分大小写）。

注意BindObjectMethod和BindObject的区别：BindObjectMethod只是将对象中的指定方法与指定路由规则进行绑定；BindObject是注册执行对象，会生成一系列默认的路由规则(URI后缀形式)，并且可以使用内置变量。

来看一个例子：

  1. package demo
  3. import (
  4.     "gitee.com/johng/gf/g"
  5.     "gitee.com/johng/gf/g/net/ghttp"
  6. )
  8. type ObjectMethod struct {}
  10. func init() {
  11.     obj := &ObjectMethod{}
  12.     g.Server().BindObjectMethod("/object-method-show1", obj, "Show1")
  13.     g.Server().Domain("localhost").BindObjectMethod("/object-method-show2", obj, "Show2")
  14. }
  16. func (o *ObjectMethod) Show1(r *ghttp.Request) {
  17.     r.Response.Write("show 1")
  18. }
  20. func (o *ObjectMethod) Show2(r *ghttp.Request) {
  21.     r.Response.Write("show 2")
  22. }
  24. func (o *ObjectMethod) Show3(r *ghttp.Request) {
  25.     r.Response.Write("show 3")
  26. }

这个例子比较简单，同时也演示了域名绑定路由到执行对象的指定方法负责执行。

RESTful对象注册

RESTful设计方式的控制器，通常用于API服务。在这种模式下，HTTP的Method将会映射到控制器对应的方法名称，例如：POST方式将会映射到控制器的Post方法中(公开方法，首字母大写)，DELETE方式将会映射到控制器的Delete方法中,以此类推。其他非HTTP Method命名的方法，即使是定义的包公开方法，将无法完成自动注册，对于应用端不可见。当然，如果控制器并未定义对应HTTP Method的方法，该Method请求下将会返回 HTTP Status 404。

我们可以通过ghttp.BindObjectRest方法完成REST对象的注册。

gitee.com/johng/gf/blob/master/geg/frame/mvc/controller/demo/object_rest.go

  1. package demo
  3. import "gitee.com/johng/gf/g/net/ghttp"
  5. // 测试绑定对象
  6. type ObjectRest struct {}
  8. func init() {
  9.     ghttp.GetServer().BindObjectRest("/object-rest", &ObjectRest{})
  10. }
  12. // RESTFul - GET
  13. func (o *ObjectRest) Get(r *ghttp.Request) {
  14.     r.Response.Write("RESTFul HTTP Method GET")
  15. }
  17. // RESTFul - POST
  18. func (c *ObjectRest) Post(r *ghttp.Request) {
  19.     r.Response.Write("RESTFul HTTP Method POST")
  20. }
  22. // RESTFul - DELETE
  23. func (c *ObjectRest) Delete(r *ghttp.Request) {
  24.     r.Response.Write("RESTFul HTTP Method DELETE")
  25. }
  27. // 该方法无法映射，将会无法访问到
  28. func (c *ObjectRest) Hello(r *ghttp.Request) {
  29.     r.Response.Write("Hello")
  30. }

Init与Shut回调方法

执行对象中的Init和Shut是两个在HTTP请求流程中被Web Server自动调用的特殊方法(类似构造函数和析构函数的作用)。当struct对象中定义了这两个方法名称时，使用执行对象方式进行服务注册时将会被自动注册到路由表中。

  1. Init回调方法

    执行对象收到请求时的初始化方法，在服务接口调用之前被回调执行。

    方法定义：

    1.  // "构造函数"执行对象方法
    2.  func (obj *Object) Init(r *ghttp.Request) {
    4.  }

  2. Shut回调方法

    当请求结束时被Web Server自动调用，可以用于执行对象执行一些收尾处理的操作。

    方法定义：

    1.  // "析构函数"执行对象方法
    2.  func (obj *Object) Shut(r *ghttp.Request) {
    4.  }

Exit方法

ghttp.Request对象中提供了Exit()方法，供业务层直接调用，该方法的作用是标识该请求已退出，不再执行后续的服务处理（但是不影响事件回调处理）。它仅仅是做一个标识作用，并不会马上停止服务执行。假如在Init回调方法中调用Exit，那么后续的服务逻辑将不会执行。假如在Shut方法中调用Exit，如果事件回调方法不做任何处理的话，那么该标识操作其实没有任何意义。