Grails 1.2参考文档速读（10）：Controller

从本篇起，我们将开始进入Grails的Web层，首先让我们从Controller说起。

Grails中Controller的特点：

• 线程安全：每次请求创建新实例
• Controller �C Action两级
• 缺省URL Mapping：/controller/action
• 文件名以Controller结尾
• 文件位置：grails-app/controllers
• 创建命令：grails create-controller
• 在Controller文件内，Action是闭包

Controller的例子：

class BookController {
    def list = {
        ...
    }
}

做过Web的开发的都知道，缺省情况下是显示应用的index.jsp或者类似的东西。在Grails中也有类似的概念：如果url中只指出了Controller但没说明action，那么缺省将定位到controller的缺省action。缺省Action的规则如下：

• 如果Controller只有一个action，那么它就是缺省action
• 使用defaultAction属性指定action名字
• 名字为index的action

Web应用中常见的servletContext、session、request、params等范围在Grails中依然存在，同时Grails还增加了flash范围，表示当前request和下个request，常用于redirect。对于这些范围的访问：scope['attr']或scope.attr，如params["findBy"]。

Grails Web层的基础是Spring MVC，它当然也无法脱离MVC架构。对于Model，在Grails中就是Map。返回Model的方式有：

• 返回Map：[ book : Book.get( params.id ) ]
• 不明确指明返回一个Model，那么Model就由Controller的属性组成。注意，正是因为Grails保证了Controller对于每一个请求都会新创建一个实例，我们才能利用这种实例变量。
• 返回Spring的ModelAndView：return new ModelAndView("/book/list", [ bookList : favoriteBooks ])

View承担了显示用户界面的任务，在Grails中的规则如下：

• 没有指定View，那么就查找（jsp文件优先）grails-app/views/controller/action.gsp
• 指定View：render(view:“view名”, model:模型)。如：render(view:“display”, model:map)，查找grails-app/views/当前controller/display.gsp；render(view:“/shared/display”, model:map)，查找grails-app/views/shared/display.gsp。

其他的render例子：

• 文本：render "Hello World!"
• view：render(view:'show')
• Template：render(template:'book_template', collection:Book.list())
• XML：render(text:“some xml", contentType:"text/xml",encoding:"UTF-8")
• HTML片段，由于Grails中Tag可以象方法一样调用，在使用这种方式时，要注意避免跟这些Tag产生名字冲突，导致产生结果无意间调用了Tag。在使用时，应使用全限定名。如：builder.form
  

  render {
          builder.form{
             for(b in books) {
                div(id:b.id, b.title)
             }
          }
      }

重定向一个请求使用redirect：

• redirect(action:'login')
• redirect(controller:'home',action:'index')
• redirect(uri:"/login.html")
• redirect(action:myaction, params:[p:"v"])
• redirect(action:"next", params:params)
• redirect(controller: "test", action: "show", fragment: "profile")，对应/myapp/test/show#profile

Chaining的特点：

• 在Action转移时，Model被保存
• 后续Action可以访问前一个Action的Model

使用：

• chain(action:"a", model:[one:1],params:[p:"v"])
• 访问前一个Action传来的Model，使用chainModel。如：chainModel.one

例子如下，下例的最终结果是[one:1, two:2, three:3]：

class ExampleChainController {
    def first = {
        chain(action:second,model:[one:1])
    }
    def second  = {
        chain(action:third,model:[two:2])
    }
    def third = {
         [three:3]
    }
}

谈到拦截器，这里需要注意，Grails的拦截器和Spring的拦截器不是一个概念：它只拦截Action，如果要拦截Controller用Filter。拦截器有两种：before和after，定义在Controller中。

def beforeInterceptor = {  //before返回false，后续action不执行
       println "Tracing action ${actionUri}"
}
//入参还可是ModelAndView
def afterInterceptor = { model ->
       println "Tracing action ${actionUri}"
}

除了直接指定闭包，还可以使用表达式来指定拦截哪些Action。表示式的形式：[实现拦截器的方法, 拦截器条件]。

//auth实现拦截器，except指明拦截器应用的条件
def beforeInterceptor = [action:this.&auth,except:'login']
def auth() {
     ...
}
def login = {
     // display login page
}

条件类型：except，only，使用如下：

• [action:this.&auth,except:'login']
• [action:this.&auth,except:['login','register']]
• [action:this.&auth,only:['secure']]

对于Grails中的数据绑定，它是以Spring的数据绑定为基础，将请求参数与对象属性绑定到一起：

• 绑定新对象：new Book(params)
• 绑定已有对象：
  

  def b = Book.get(params.id)
      b.properties = params

Grails的绑定会自动对关联进行处理。

绑定1端关联：one-to-one和many-to-one，那么url采用形如/book/save?author.id=20，grails自动检测.id后缀，在绑定（如： new Book(params) ）时，自动按id加载Author对象。

绑定多端：one-many和many-to-many，有多种方法：

• 方法1：<g:select name="books" from="${Book.list()}" size="5" multiple="yes" optionKey="id" value="${author?.books}" />，Grails会自动根据select的值来绑定。
• 方法2：如果要更新关联的某些属性，那么就采用：
  

  <g:textField name="books[0].title" value="..." />
      <g:textField name="books[1].title" value="..." />

  Grails会自动绑定，但是要保证更新顺序和显示顺序的一致性，对于List和Map不存在问题，对于Set要小心。如果显示的textField比实际关联的个数多，且数组编号连续，如最后加一个“books[2].title”，Grails会自动给关联新增一个实例。如果显示的textField比实际关联的个数多，且数组编号不连续，如最后加一个“books[5].title”，Grails会自动补齐中间的空缺。本例中会再添加4个：2、3、4、5。

绑定多个domain class同样也是在url上做文章，如/book/save?book.title=Title1&author.name=Author1。这时就使用params[‘前缀名’]分别取出数据：

def b = new Book(params['book'])
def a = new Author(params['author'])

对于数据绑定发生的错误，则是通过hasErrors来判断的。显示错误消息已经考虑的i18n，对应的消息键值以typeMismatch为前缀：

• 按类名（通用）： typeMismatch.java.net.URL
• 按属性（特殊）： typeMismatch.Book.publisherURL

上述各例都是针对Domain Class，但绑定同样也可针对属性单独进行：

def p = Person.get(1)
p.properties['firstName','lastName'] = params

绑定还可以发生在其他类型的对象上，使用bindData(sc, params)：

• params也可使用Map代替
• 排除某属性绑定：bindData(sc, params, [exclude:'prop'])
• 只包含指定属性：bindData(sc, params, [include:'prop'])

对于不想直接暴露Domain Class的场合，可以使用Command Object来代替。

对于XML和JSON响应，Grails还有一种简单的方法（JSON的话把XML换成JSON即可）：render Book.list() as XML。或者你可以使用Builder：

def books = Book.list()
//json则为text/json
render(contentType:"text/xml") {
    books {
        for(b in results) {
            book(title:b.title)
        }
    }   
}

Grails 1.2提供了新的JSONBuilder，缺省它会使用老的，如想使用新的，在config.groovy中：grails.json.legacy.builder=false。整个用法依旧如上：

render(contentType:"text/json") {
    ...
}

新JSONBuilder的语法：

• 输出简单对象（{"hello":"world"}）：hello = "world"
• 输出数组（{"categories": ["a","b","c"]}）：categories = ['a', 'b', 'c']
• 输出对象数组（{"categories":[ {"a":"A"} , {"b":"B"}] }）：categories = [ { a = "A" }, { b = "B" } ]
• 只输出数组（[1,2,3]）：
  

  render(contentType:"text/json") {
          element 1
          element 2
          element 3       
      }

• 输出复杂对象（{"categories":["a","b","c"],"title":"Hello JSON","information":{"pages":10}}）：
  

  render(contentType:"text/json") {
          categories = ['a', 'b', 'c']
          title ="Hello JSON"
          information = {
              pages = 10
          }
      }

• 动态输出复杂对象：
  

  def results = Book.list()
      render(contentType:"text/json") {
          books = array {
              for(b in results) {
                  book title:b.title
              }
          }   
      }

除了在render中使用，你还可以直接调用它：

def builder = new JSONBuilder()
def result = builder.build {
    categories = ['a', 'b', 'c']
    title ="Hello JSON"
    information = {
        pages = 10
    }
}
println result.toString()
def sw = new StringWriter()
result.render sw

再来看看最常见的文件上载，前台页面如下：

<g:form action="upload" method="post" 
               enctype="multipart/form-data">
    <input type="file" name="myFile" />
    <input type="submit" />
</g:form>

后台的处理有两种选择：

• 直接使用MultipartFile
  

  def  f = request.getFile('myFile')
      if(!f.empty) {
           f.transferTo( new File('/some/local/dir/myfile.txt') )
      }

• 数据绑定
  

  class Image {
         byte[] myFile
      }
      def img = new Image(params)

如果想知道上传的文件名，使用MultipartFile.originalFilename。

Grails的Command Object跟Spring MVC中的没什么区别，是一个View Object。特点如下：

• 使用上相当于简版Domain Class（不要误解，Command Object和Domain Class是两回事）。
• 它在Controller目录中定义，一般包含在使用它的Controller文件中，但也可单独抽出。
• 它还可以使用约束，但不能使用那些要查找数据库的约束，如unique。
• 它也支持依赖注入。

使用例子：

class LoginController {
  def login = { LoginCommand cmd ->
         if(cmd.hasErrors()) {
                redirect(action:'loginForm')
         }
         else {
            // do something else
        }
  }
}
class LoginCommand {
   String username
   String password
   static constraints = {
           username(blank:false, minSize:6)
           password(blank:false, minSize:6)
   }
}

重复提交对于Web开发是个老问题了，Grails对此也提供了应对措施：

• 前台页面： <g:form useToken="true" ...>
• Controller：
  

  withForm {
         // good request
      }.invalidToken {
         // bad request
      }

• 如果没有invalidToken，则可通过flash.invalidToken访问
• 注意：withForm需要用到 session，因此，在集群环境下，要设置“session affinity”。这同样也适用于任何使用session的程序

params提供了类型转换方法，可用于简单场合：params.int('total')。当某参数对应有多个值时，如?name=a&name=b，对其处理需小心。因为params.name缺省返回字符串，而字符串在Groovy中也可以在循环中使用，这样，导致处理逻辑错误。为了确保总是获得List，需使用params的list方法：params.list('name')。