不管怎么样下面介绍一下1.1版本的新特性：

GORM

更好的GORM事件

之前, GORM 只支持 beforeInsert, beforeUpdate 和beforeDelete 事件, 现增加了afterInsert, afterUpdate 和afterDelete 来完成图片操作

基本类型集的持久化

GORM 现在支持基本类型比如String, Integer 等使用一个连接表的持久化。

class  Person {    

static  hasMany = [nicknames:String] 

}  

class Person {

   static hasMany = [nicknames:String]

}

对象的只读访问

现在，持久化实例对象可以使用read 方法以只读状态被加载:

def book = Book.read(1)

默认的排列顺序

现在，关联可以使用一个类级别声明的默认的排列顺序来排序:

class Book {

  String title

  static mapping = {

     sort "title"

  }

}

或在关联级别上:

class Author {

    static hasMany = [books:Book]

    static mapping = {

              books sort:"title"

    }

}

批处理

现在GORM 支持使用ORM DSL 在类级别上配置批处理（batch fetching ）( 延迟加载的优化):

class Book {

  String title

  static mapping = {

     batchSize 15

  }

}

或在关联级别上:

class Author {

    static hasMany = [books:Book]

    static mapping = {

              books batchSize:15

    }

}

动态Finders的改进

动态查询器的新后缀InList 可用：

def groovyBooks = Book.findByAuthorInList(['Dierk Koenig', 'Graeme Rocher'])

现在，Dynamic finders 也能查询缓存:

def books = Book.findByTitle("Groovy in Action", [cache:true] )

可以使用悲观锁:

def books = Book.findByTitle("Groovy in Action", [lock:true] )

单项的One-to-many遗留映射

单项的One-to-many关联关系可以使用joinTable 参数改变它们对底层数据库的映射:

class Book {

  String title

  static belongsTo = Author

  static hasMany = [authors:Author]

  static mapping = {

     authors joinTable :[name:"mm_author_books", key:'mm_book_id' ]

  }

}

class Author {

  String name

  static hasMany = [books:Book]

  static mapping = {

     books joinTable:[name:"mm_author_books", key:'mm_author_id']

  }

}

增强枚举类型的支持

现在，枚举类型使用GORM 调用的getId （）方法来持久化枚举状态。

enum Country {

   AUSTRIA('at'),

   UNITED_STATES('us'),

   GERMANY('de');

   final String id

    Country(String id) { this.id = id }

}

插件

全局插件

现在，安装插件可以给所有的应用程序共享:

grails install-plugin webtest -global

多插件仓库

现在，Grails 支持通过提供多插件仓库配置的能力

使用USER_HOME/.grails/settings.groovy 文件或包含配置好的仓库详情的grails-app/conf/BuildConfig.groovy 文件。

grails.plugin.repos.discovery.myRepository="http://svn.codehaus.org/grails/trunk/grails-test-plugin-repo"

grails.plugin.repos.distribution.myRepository="https://svn.codehaus.org/grails/trunk/grails-test-plugin-repo"

Grails的插件命令如list-plugin和install-plugin会自动使用所有设置的插件仓库，发布一个插件到一个插件仓库可以是用下面的命令：

grails release-plugin -repository=myRepository

自动安装插件方案

插件不再需要到SVN 检出，当应用程序第一次加载时，通过插件元数据会自动安装。另外,插件的依赖关系问题已经解决了。

插件的作用范围和环境

现在，插件可以作用于环境或预置的构建范围内：

def environments = ['dev', 'test']

def scopes = [excludes:'war']

仅在那些环境中加载使用，而不打包到WAR 文件中。这使得产品使用时 "development-only" 的插件不会被打包。

测试

测试框架

现在，作为1.0.x 系列可用插件的新测试框架已集成到 Grails 1.1.

该测试框架增加了模拟所以普通类型包扩控制器，领域类，标签库和url 映射简写的行为，快速运行单元测试。

class SongTests extends grails.test.GrailsUnitTestCase {

    void testMinimumDuration() {

        mockDomain(Song)

        def song = new Song(duration: 0)

        assertFalse 'validation should have failed', song.validate()

        assertEquals "min", song.errors.duration

    }

}

数据绑定

属性子集的数据绑定

现在更容易对属性的自己和进行数据绑定。在之前的版本中你也许会使用:

person.properties = params  

这将会将request中的所有变量绑定到person中。如果你不想绑定所有的数据的话，你可以使用 bindData 方法。现在你可以通过使用subscript operator来绑定部分的变量:

person.properties["firstName","lastName"] = params  

person.properties["firstName","lastName"] = params

要取得domain中的所有属性的一个子集也可以通过这样的方式：

person.properties["firstName","lastName"].each { println it } 

集合类型的数据绑定

Grails已经支持集合类型的数据绑定,例如list、set和map。

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

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

<g:textField name="books[2].title" value="Red Madder" />

脚手架

模板和动态脚手架

现在，动态脚手架使用通过install-templates 命令安装的模板。

支持更多关联类型

现在，Scaffolding 支持 many-to-many 和单项的 one-to-many 关联。

Groovy Server Pages

在JSP中支持JSP标签库

现在，GSP 已经支持JSP 标签库复用的能力:

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

<fmt:formatNumber value="${10}" pattern=".00"/>

JSP 标签也可以像正常的GSP 标签一样调用:

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

${fmt.formatNumber(value:10, pattern:".00")}

工程基本结构

Maven 集成 

Grails 1.1 缘自和 Maven plugin 和archetype 的关联，允许你使用Maven 更容易的构建Grails 工程。根据操作指南here或使用原型来创建一个新的Grails 工程, 或运行:

mvn grails:create-pom

来为已有工程创建一个Maven POM.

环境及元数据API  

使用新 API 来访问当前环境:

import grails.util.Environment

...

switch(Environment.current) {

        case Environment.DEVELOPMENT:

           configureForDevelopment()

        break

        case Environment.PRODUCTION:

           configureForProduction()

        break

}

当然也有一个易于访问应用程序元数据的新类：

def metadata = grails.util.Metadata.current

println metadata.applicationName

println metadata.applicationVersion

Log4j DSL  

新的 Log4j DSL 用于替换以前Log4j 配置的方式:

log4j = {

    error  'org.codehaus.groovy.grails.web.servlet',  //  controllers

               'org.codehaus.groovy.grails.web.pages' //  GSP

    warn   'org.mortbay.log'

}

详见user guide 中Log4j DSL 全部文档。

灵活的构建配置

新的 grails-app/conf/BuildConfig.groovy 文件可用，它允许你配置不同层面的Grails 构建输出路径和服务器使用插件的解决方案：

grails.work.dir="/tmp/work"

grails.plugins.dir="/usr/local/grails/plugins"

grails.project.test.reports.dir="/usr/local/grails/test-reports"

非交互模式 

现在，Grails 支持一种--non-interactive flag ，须键入到命令行，目的是关闭用户提示:

grails run-app --non-interactive

这对服务器持续集成是有帮助的。

加密数据源 

现在，数据源密码可以使用已提供的编码类来加密:

dataSource {

       username = "foo"

       password = "438uodf9s872398783r"

       passwordEncryptionCodec="my.company.encryption.BlowfishCodec"

}

支持的编码使用 Grails' 现存的编码机制。

升级备注

Grails 1.1 有很多改变，但大多是向后兼容1.0.x 系列的。如果有问题请报告。升级时，以下是已知需要注意的问题列表：

Plugins 不保存在你的 USER_HOME 路径下. 你需要重写安装插件或运行:

      grails -Dgrails.plugins.dir=./plugins run-app

现在枚举类型已经被映射到数据库，使用字符串值而不是原始默认的。

jsession id 默认已无效. 详见GRAILS-3364

GSP 空白符处理已经变好很多了，比以前有更多空白符. 详见GRAILS-3277

grails.testing.reports.destDir 配置选项已被替代为grails.project.test.reports.dir

现在，PreInit.groovy 改为BuildConfig.groovy

控制器中的allowedMethod 属性被标识为static 。非 static 版本不推荐使用，尽管它仍然起作用并在控制台产生信息。

Grails1.0的这篇文章也可以作为参考。

1.绑定HTTP参数到Java方法

通过在Java方法中定义和HTTP参数同名的参数就可以方便的取得HTTP中的参数值。

例如：

/articles/archive?date=08/01/08&page=2

你可以通过定义方法参数来获取date和page的值：

也可以直接绑定到类：

HTML中如下定义：

<form action="/Directory/add" >
 Name: <input type="text" name="p.name" />
 Age: <input type="text" name="p.age" />
</form>

2.通过调用Java方法重定向到相应的action

只需要调用相应的Java方法就能方便地重定向到另一个action，Play!会生成正确的redirect response，而不是forward。

public static void show(Long id) {
    Article article = Article.findById(id);
    render(article);
}

public static void edit(Long id, String title) {
    Article article = Article.findById(id);
    article.title = title;
    article.save();
    show(id);
}

注意：在edit action的最后重定向到了show action。

 

在模板中你可以使用类似的符号来生成链接：

<a href="@{Article.show(article.id)}">${article.title}</a>

最终生成的HTML：

<a href="/articles/15">My new article</a>

 

3.直接把Java对象传递到页面模板

在大多数Java框架中，你需要写类似下面代码来把Java对象传递给页面模板：

Article article = Article.findById(id);
User user = User.getConnected();
Map<String, Object> model = new HashMap<String,Object>();
model.put("article", article);
model.put("user", user);
render(model);

在Play!中你只需要这么做：

Article article = Article.findById(id);
User user = User.getConnected();
render(article, user); 

4.方便的文件上传

在Play!框架中实现文件上传很方便：

HTML form ：

<form action="@{Article.uploadPhoto}" method="POST" enctype="multipart/form-data">
    <input type="text" name="title" />
    <input type="file" id="photo" name="photo" />
    <input type="submit" value="Send it " />
</form>

Java代码：

public static void uploadPhoto(String title, File photo) {
   
}

5.不用任何配置就可以把应用分布到多个JVM

由于应用程序被设计成无状态的，所以你可以简单地在多台服务器上启动同一个应用，然后通过HTTP层面的负载均衡来实现分布式应用。不需要设置一个负债的服务器集群。

Play!是一个纯Java实现的Web敏捷开发框架，工程的默认目录结构如下：

构建在HTTP上

Servlet或者Struts之类的Java Web框架对HTTP API进行了抽象和封装，Play!和这些框架的根本上的不同之处就在于Play!提供了对HTTP完全的访问能力。

通过Router绑定URI到Java的方法：

高效的模板引擎

我们喜欢JSP和表达式语言背后的思想，但为什么创建一个taglib需要配置这么多的文件，为什么不能提供对model的完全的访问？JSP有太多的局限性，使用起来很麻烦，那么让我们创建一个更好的模板引擎吧。

如果你想实现下面的JSP代码的功能：

你会喜欢上下面这种写法：

Play!使用Groovy作为模板语言，这是一种和Java语法极为相似的语言，并且可以无缝的使用Java类库，可以将其看作是动态的Java语言。

具有生产效率的Java

众所周知，由于需要编译、部署，Java平台的生产效率比ROR这类动态语言平台低很多。Play!的目标是尽可能的提高Java开发的生产效率。在开发环境下，Play!框架可自动编译和重新装载已改变的源文件。也就是说在保存源代码的改变后，就能立刻通过刷新浏览器看到结果，不需要重新编译、部署、重启服务器。

Play! 具有优秀的错误报告功能。发生异常时，该框架会直接显示出错误的源代码，甚至是模板代码。

Full-stack应用框架

Play!是一个full-stack Java Web应用框架，具有建立一个现代化网络应用所需的一切：

• 通过JBDC支持关系型数据库
• 使用Hibernate作为ORM
• 支持Memcache
• 支持JSON或者XML格式的Web服务
• 支持OpenID
• 图片处理 API
• …

Play!的插件系统可以让你重用其他系统的Java代码、模板甚至JavaScript和CSS。

一直想比较一下几种常见的Java服务器的性能，除了上面提到的几种服务器外，还可以加上Jetty和JBossWeb，先做个记号，有时间自己测一下。

Tomcat就不多说了。

Glassfish是一个免费，开源的Java EE5应用服务器。

Resin的免费版好像性能比较低。

Jetty 主要是作为企业级产品的嵌入式组件来设计的，可以非常方便地嵌入到其它产品中。而且 Jetty 是作为单独的 Http Server 来设计的，据 Jetty 开发人员的测试，Jetty 的性能几乎与 Apache 相当，生产环境，尤其是高负载的环境中还是使用 Jetty 更好。Jetty适合快速部署测试开发，Grails就内置了Jetty。据说，jetty的优势是集群，很适合云计算的环境。

另外，JBossWeb好像性能也不错。

• 动态类型或者自动类型转换
• 快速反馈，改变代码后马上可以看到运行效果
• 基于虚拟机
• 开放源代码
• 支持分布式、多核计算

// environment specific settings 
environments { 
  development { 
    dataSource { 
      dbCreate = "update"  
      url = "jdbc:hsqldb:mem:devDB" 
      logSql = true 
    } 
  } 
} 

<html> 
    <head> 
        <title>Welcome to Grails</title> 
    <meta name="layout" content="main" /> 
    </head> 
    <body> 
    Hello World! 
    </body> 
</html> 

刷新后主页变成了Hello World!

好了，本文结束，接下来的工作就是你的了。慢着，如果不想重新编写一个主页，而是想把它重定向到一个controller怎么办？

Grails 是建立在Java的基础之上的，在Grails项目中我们可以很方便的使用Java的各种技术，包括JSP。现在把index.gsp重新命名为 index.jsp，内容改为<% response.sendRedirect("yourController/yourAction"); %>，刷新后主页就重定向到了你定义的路径。

事实上GSP是JSP的扩展，这意味着你同样可以在GSP中使用session、 servletContext,、request和response对象。把index.jsp重新改回index.gsp，内容改 为${response.sendRedirect("yourController/yourAction")}同样可以达到重定向效果。

还可以自定义一个Tag来实现重定向：

def redirectPage={attrs-> 
  def url=attrs.get('url') 
  response.sendRedirect("${request.contextPath}"+url) 
} 

最后介绍最简单的解决方法：
打开grails-app/conf/UrlMappings.groovy，这是Grails中URL映射的配置文件，相当于Rails中的routes.rb，把它作如下修改即可：

class UrlMappings { 
    static mappings = { 
      "/"(controller:"yourController",action:"yourAction") 
      "/$controller/$action?/$id?"{ 
          constraints { 
           // apply constraints here 
          } 
       } 
    } 
} 

Grails的官方文档中提到：默认情况下，GORM 集合使用延迟加载的并且可以通过fetchMode来配置或者是使用mapping来配置 。并给出了一段在domain中配置的样例代码。

但从我的使用经验来看，不推荐在domain类中配置延迟加载。原因如下：
1、在domain类中配置延迟加载是全局性的，有可能造成不需要开销。
2、目前在domain类中配置延迟加载存在Bug，只对one-to-many的关系才有效。

例如论坛的列表页面，需要显示topic的分页列表，其中每条topic需要显示作者的名字，topic最后回复帖子的作者。

按照官方文档，可以在Topic类中如下配置，查询结果为1条topic，理论上结果应该执行一条SQL语句：

class   Topic       { 
    String title 
    String body 
    Date createTime  =   new  Date() 
    User author 
    Integer viewNum  =   0 
    Integer postNum  =   0 
    Date lastUpdateTime 
    User lastUpdateBy 
    static  hasMany  =  [ posts : Post ] 
    static  fetchMode  =  [author: ' eager ' , lastUpdateBy: ' eager ' ] 
} 

但从SQL Log来看，Grails还是执行了3条SQL：

select ... from topic where id  = ? 
select ... from user where id  = ? 
select ... from user where id  = ? 

也就是说在domain类中配置延迟加载存在对one-to-one, many-to-one是无效的。

如果这样配置：

class   Topic       { 
    String title 
    String body 
    Date createTime  =   new  Date() 
    User author 
    Integer viewNum  =   0 
    Integer postNum  =   0 
    Date lastUpdateTime 
    User lastUpdateBy 
     static  hasMany  =  [ posts : Post ] 
     static  fetchMode  =  [posts: ' eager ' ] 
}  

执行Topic.get(id)来加载1条Topic，执行结果为1条SQL：

select ... from topic left outer join post on topic.id = posttopic_id where topic.id = ?  

也就是说在domain类中配置延迟加载存在对one-to-many是有效的。以上结论对使用mapping来配置也是一样的。

这无疑是一个尴尬的结论，适用全局立即加载的author和lastUpdateBy不能在domain类中通过配置事先，不适用全局立即加载的posts却可以。看来GROM对Hibernate的包装还存在问题。

目前的解决方法是不要在domain类中配置立即加载，而是在取数据的方法中按需要配置，例如Topic.list(fetch:[author:'eager', lastUpdateBy:'eager'])

另外，可以参考一下这里关于立即加载和N+1次查询性能的争论。

• 简单的开发周期。该框架可自动编译和重新装载已改变的源文件。也就是说在保存源代码的改变后，就能立刻从浏览器中看到结果，不需要重新编译、部署、重启服务器。
• 约定优于配置。
• 智能绑定HTTP参数到Java方法参数。
• 无状态的模型，无共享架构（Share-Nothing Architecture），为REST做好了准备（未来的目标是RESTful架构），具有很好的伸缩性。
• 一个基于Groovy的强大的模板引擎，可实现多层继承，定制用户标签等功能。
• 包含了很多开发Web应用需要的功能整合，如Memcached、OpenID、插件系统等。
• 优秀的错误报告功能：发生异常时，该框架会直接显示出错误的源代码，甚至是模板代码。
• 纯Java，能够使用任何Java类库，能够很好的生成eclipse和netbeans项目文件。
• 速度很快。

初步看了下文档，应该是目前最接近Rails的Java framework，整个框架和我最近设想的一个框架差不多，很多简化 Java Web开发会遇到的问题，play!都给出了一个尽可能的解决方法，比如HTTP参数绑定、属性get/set等等，局限于java语言本身，目前也只能 这样了。play!目前还没有集成验证功能，也没有一些诸如HTML encode的工具库，和spring的集成也好像还在开发中，不过这些都应该很容易解决。

该项目是开源的，您可以在http://www.playframework.org上查看更多！

在使用displaytag显示数字时，如果对数字进行了HTML包装，那么就有可能造成排序结果的不正确。

displaytag排序的方法是：compare(Object object1, Object object2)
1.如果object1,object2都是String，则按String排序；
2.如果object1,object2实现了Comparable接口，则compareTo方法比较，这样纯数字排序因为能够转换成实现Comparable接口的数字类型所以排序结果正确；
3.其他情况转换成String比较。

因此，组装成HTML的列就默认按String来比较，造成排序结果与预期不符。
例如需要排序displaytag中带超级链接的数字列：
s1: <a href="www.example.com?id=53">53</a>
s2: <a href="www.example.com?id=9">9</a>
则比较结果s1 < s2，显然和我们预期的相反。

解决的方法:
1.自定义一个Comparator类，实现你自己的比较规则，在页面需要的列中配置<display:column title="..." property="..." comparator="你实现的Comparator类名">
2.外排序
3.如果只是需要把数字排正确，更简单的方法是写一个数字的format类，在decorator组装HTML时在数字前补0对齐：
s1: <a href="www.example.com?id=00053">53</a>
s2: <a href="www.example.com?id=00009">9</a>

另外，如果每列需要比较数字前的HTML不是相同的，可以添加隐藏域来解决。例如：
s1: <a href="www.example.com?id=100">53</a>
s2: <a href="www.example.com?id=200">9</a>
修改为：
s1: <input type="hidden" name="sortValue" value="00053"><a href="www.example.com?id=100">53</a>
s2: <input type="hidden" name="sortValue" value="00009"><a href="www.example.com?id=200">9</a>