• 13.3 controller设计
    • controller作用
    • beego的REST设计
    • 应用指南
    • links

    13.3 controller设计

    传统的MVC框架大多数是基于Action设计的后缀式映射，然而，现在Web流行REST风格的架构。尽管使用Filter或者rewrite能够通过URL重写实现REST风格的URL，但是为什么不直接设计一个全新的REST风格的 MVC框架呢？本小节就是基于这种思路来讲述如何从头设计一个基于REST风格的MVC框架中的controller，最大限度地简化Web应用的开发，甚至编写一行代码就可以实现“Hello, world”。

    controller作用

    MVC设计模式是目前Web应用开发中最常见的架构模式，通过分离 Model（模型）、View（视图）和 Controller（控制器），可以更容易实现易于扩展的用户界面(UI)。Model指后台返回的数据；View指需要渲染的页面，通常是模板页面，渲染后的内容通常是HTML；Controller指Web开发人员编写的处理不同URL的控制器，如前面小节讲述的路由就是URL请求转发到控制器的过程，controller在整个的MVC框架中起到了一个核心的作用，负责处理业务逻辑，因此控制器是整个框架中必不可少的一部分，Model和View对于有些业务需求是可以不写的，例如没有数据处理的逻辑处理，没有页面输出的302调整之类的就不需要Model和View，但是controller这一环节是必不可少的。

    beego的REST设计

    前面小节介绍了路由实现了注册struct的功能，而struct中实现了REST方式，因此我们需要设计一个用于逻辑处理controller的基类，这里主要设计了两个类型，一个struct、一个interface

    2. type Controller struct {
    3.     Ct        *Context
    4.     Tpl       *template.Template
    5.     Data      map[interface{}]interface{}
    6.     ChildName string
    7.     TplNames  string
    8.     Layout    []string
    9.     TplExt    string
    10. }
    12. type ControllerInterface interface {
    13.     Init(ct *Context, cn string)    //初始化上下文和子类名称
    14.     Prepare()                       //开始执行之前的一些处理
    15.     Get()                           //method=GET的处理
    16.     Post()                          //method=POST的处理
    17.     Delete()                        //method=DELETE的处理
    18.     Put()                           //method=PUT的处理
    19.     Head()                          //method=HEAD的处理
    20.     Patch()                         //method=PATCH的处理
    21.     Options()                       //method=OPTIONS的处理
    22.     Finish()                        //执行完成之后的处理        
    23.     Render() error                  //执行完method对应的方法之后渲染页面
    24. }

    那么前面介绍的路由add函数的时候是定义了ControllerInterface类型，因此，只要我们实现这个接口就可以，所以我们的基类Controller实现如下的方法：

    2. func (c *Controller) Init(ct *Context, cn string) {
    3.     c.Data = make(map[interface{}]interface{})
    4.     c.Layout = make([]string, 0)
    5.     c.TplNames = ""
    6.     c.ChildName = cn
    7.     c.Ct = ct
    8.     c.TplExt = "tpl"
    9. }
    11. func (c *Controller) Prepare() {
    13. }
    15. func (c *Controller) Finish() {
    17. }
    19. func (c *Controller) Get() {
    20.     http.Error(c.Ct.ResponseWriter, "Method Not Allowed", 405)
    21. }
    23. func (c *Controller) Post() {
    24.     http.Error(c.Ct.ResponseWriter, "Method Not Allowed", 405)
    25. }
    27. func (c *Controller) Delete() {
    28.     http.Error(c.Ct.ResponseWriter, "Method Not Allowed", 405)
    29. }
    31. func (c *Controller) Put() {
    32.     http.Error(c.Ct.ResponseWriter, "Method Not Allowed", 405)
    33. }
    35. func (c *Controller) Head() {
    36.     http.Error(c.Ct.ResponseWriter, "Method Not Allowed", 405)
    37. }
    39. func (c *Controller) Patch() {
    40.     http.Error(c.Ct.ResponseWriter, "Method Not Allowed", 405)
    41. }
    43. func (c *Controller) Options() {
    44.     http.Error(c.Ct.ResponseWriter, "Method Not Allowed", 405)
    45. }
    47. func (c *Controller) Render() error {
    48.     if len(c.Layout) > 0 {
    49.         var filenames []string
    50.         for _, file := range c.Layout {
    51.             filenames = append(filenames, path.Join(ViewsPath, file))
    52.         }
    53.         t, err := template.ParseFiles(filenames...)
    54.         if err != nil {
    55.             Trace("template ParseFiles err:", err)
    56.         }
    57.         err = t.ExecuteTemplate(c.Ct.ResponseWriter, c.TplNames, c.Data)
    58.         if err != nil {
    59.             Trace("template Execute err:", err)
    60.         }
    61.     } else {
    62.         if c.TplNames == "" {
    63.             c.TplNames = c.ChildName + "/" + c.Ct.Request.Method + "." + c.TplExt
    64.         }
    65.         t, err := template.ParseFiles(path.Join(ViewsPath, c.TplNames))
    66.         if err != nil {
    67.             Trace("template ParseFiles err:", err)
    68.         }
    69.         err = t.Execute(c.Ct.ResponseWriter, c.Data)
    70.         if err != nil {
    71.             Trace("template Execute err:", err)
    72.         }
    73.     }
    74.     return nil
    75. }
    77. func (c *Controller) Redirect(url string, code int) {
    78.     c.Ct.Redirect(code, url)
    79. }

    上面的controller基类已经实现了接口定义的函数，通过路由根据url执行相应的controller的原则，会依次执行如下：

    2. Init()      初始化
    3. Prepare()   执行之前的初始化，每个继承的子类可以来实现该函数
    4. method()    根据不同的method执行不同的函数：GET、POST、PUT、HEAD等，子类来实现这些函数，如果没实现，那么默认都是403
    5. Render()    可选，根据全局变量AutoRender来判断是否执行
    6. Finish()    执行完之后执行的操作，每个继承的子类可以来实现该函数

    应用指南

    上面beego框架中完成了controller基类的设计，那么我们在我们的应用中可以这样来设计我们的方法：

    2. package controllers
    4. import (
    5.     "github.com/astaxie/beego"
    6. )
    8. type MainController struct {
    9.     beego.Controller
    10. }
    12. func (this *MainController) Get() {
    13.     this.Data["Username"] = "astaxie"
    14.     this.Data["Email"] = "astaxie@gmail.com"
    15.     this.TplNames = "index.tpl"
    16. }

    上面的方式我们实现了子类MainController，实现了Get方法，那么如果用户通过其他的方式(POST/HEAD等)来访问该资源都将返回405，而如果是Get来访问，因为我们设置了AutoRender=true，那么在执行完Get方法之后会自动执行Render函数，就会显示如下界面：

    controller设计 - 图1

    index.tpl的代码如下所示，我们可以看到数据的设置和显示都是相当的简单方便：

    2. <!DOCTYPE html>
    3. <html>
    4.   <head>
    5.     <title>beego welcome template</title>
    6.   </head>
    7.   <body>
    8.     <h1>Hello, world!{{.Username}},{{.Email}}</h1>
    9.   </body>
    10. </html>
    • 目录
    • 上一章: 自定义路由器设计
    • 下一节: 日志和配置设计