闭包概念

Groovy语言中闭包（closure）是一个非常重要的概念，而且深入的理解了闭包对充分用好Groovy有很大帮助。对闭包比较书面的一种解释“闭包是可以用作函数参数和方法参数的代码块”。其实Groovy的闭包更象是一个“代码块”或者方法指针，代码在某处被定义然后在其后的调用处执行。

现在支持闭包的语言有 Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Perl，Ruby 和 Python 。

闭包基础
来看一个例子：

def square = {it * it} // 定义一个叫square的闭包。it是默认的 参数名称

assert 4 == square(2) // 使用闭包

assert [1,4,9] == [1,2,3].collect(square) // 使用闭包

闭包类似Java的内类，区别是闭包只有单一的方法可以调用，但可以有任意的参数，闭包用“{}”括起，“->”前面是参数，后面是处理语句，可以直接调用，也可以使用call调用。不管那种调用，最后groovy编译器都会把编译成对doCall方法的调用，这是groovy对闭包的一个隐藏方法。

def closure = { param -> println("hello ${param}") }
closure.call("world!")
 
def closure = { greeting, name -> println(greeting + name) }
closure.call("hello ", "world!")

第一个例子演示了在字符串内使用参数的形式：${param}
第二个例子演示了多参数形式：用“，”分隔参数

如果你的参数少于2个，那么它可以直接忽略掉。如果只有一个参数，可以不写，而使用缺省的参数“it”，如下面的例子：

closure = { println "hello " + it }
closure.call("world!")

把闭包当作变量返回的例子：
def localMethod() {
  def localVariable = new java.util.Date()
  return { println localVariable }
}
 
def clos = localMethod()
 
println "Executing the closure:"
clos() 

Groovy闭包中几个隐含变量

it：默认的参数名，调用是如果没有传参数，it为null
this : 跟Java一样，是定义闭包所在类的一个引用，不管有多少层闭包嵌套，this指向的都是最上层的类。
owner : 封闭闭包的对象(如果只有一层闭包就是this，如果有多层闭包嵌套就是含有此闭包的上层闭包)
delegate :缺省值是owner，但是可以改变，后面详说。
看例子：

class Class1 {
  def closure = {
    println " ============================== "
    println "this = "+ this.class.name
    println "owner = " + owner.class.name
    println "delegate = " + delegate.class.name
    def nestedClos = {
        println " ============================== "
        println "this = "+ this.class.name
        println "owner = " + owner.class.name
        println "delegate = " + delegate.class.name
      def thirdClos = {
            println " ============================== "
            println "this = "+ this.class.name
            println "owner = " + owner.class.name
            println "delegate = " + delegate.class.name
      }
      thirdClos() 
    }
    nestedClos()
  }
}
 
def clos = new Class1().closure
//clos.delegate = this
clos()

执行结果：
 ==============================
this = Class1
owner = Class1
delegate = Class1
 ==============================
this = Class1
owner = Class1$_closure1
delegate = Class1$_closure1
 ==============================
this = Class1
owner = Class1$_closure1_closure2
delegate = Class1$_closure1_closure2

闭包实现接口

前面说了用闭包实现类，或继承其他类。现在看看怎么实现接口。

interface Test
{
 def test()
}
 
 
def test = {
 println'ok'
} as Test
    
test.test()
如果接口只有一个方法需要实现，比如Comparator，Runnable等接口就可以直接实现方法后加上 as Runnable接口名就可以。

多方法接口，groovy用Map的方法实现。

interface MultiFuncTest
{
    def test1()
    def test2(str)
}
 
 
def impl = [test1:{println'test'},
        test2:{str -> println str}] as MultiFuncTest

impl.test1()
impl.test2('ok')

delegate委托的用法
delegate委托在是一种常用设计模式，但在java中实现相对比较繁琐，groovy直接在GroovyObject中已经实现了delegate模式，所以在groovy中应用delegate很方便。

class Dog{
    def play = {
      "wang wang!"
    }
    def childmind = {
        println       delegate.play();     
    }
}

class Cat {
    def play = {"mi mi !"}
}

def dog = new Dog()
def cat = new Cat()

dog.childmind()

dog.childmind.delegate  = cat;
dog.childmind()

上面的例子是狗爸爸让老猫帮忙照看他的狗儿子玩游戏。

闭包是Groovy一种核心技术，也是现在比较流行的动态语言的核心技术，所以全面稳定的掌握闭包是非常必要的。

参考：
http://blog.csdn.net/hivon/archive/2008/04/23/2318760.aspx  Groovy探索之闭包 三
http://www.chinagroovy.org/groovywiki/doku.php/wiki:user_guide:closures Groovy文档翻译，什么是闭包

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

 之前有一需求：网站用户线上即时消费扣点，商户可以在线查看其商品的即时在线消费用户情况。目前网上查找到的资料有两种：
一是通过访问数据库，在数据库用户表比如Users表中添加一个字段 bit 当有人用这个用户登录的时候就把它变成1，但这方法会有以下问题：第一数据库更新问题，需要很大的性能而且如果大量用户这样做，后果不堪设想。第二:服务器无法判断设么时候用户推出登录；
二是通过JS来实现，但这种方法无法解决断网问题，还有就是如果一个用户在同一个计算机上登录两次那么第二次将不能登录，如果一个用户关闭浏览器服务器不知道，这个用户还想登录，后果就是登不上去了。

另外有一种个人觉得比较好的方案：
思想:就是用类似QQ的方法，如果一个用户再次登录，退出第一个登录的用户，保留第二个
存储:利用用户池java.util.Map作为用户池容器,里面放着用户标示和sessionId,这个容器放到application对象中介可以;
原理:当用户登录时直接put进去就可以了，如果这个对象存在就会被更新
其他:编写listener用HttpSessionAttributeListener地实现处理session属性的removed在removed的时候清楚这个用户在对象池中的状态
检查:编写一个用户Filter来检查请求的sessionId和用户池是否匹配就可以了如果不匹配清楚这个session中的用户对象迫使下线
针对项目使用的是Grails架构，把实现此功能的过程总结如下：
1、把消费记录记到application中，消费的controller为ConsumController.groovy,即时消费的action为:

def instantPay = {
        def personService = PersonService.get(params.id)
        def user = User.findByUserName(session.userName)
        if(!user){
            render(text:"請登入會員！",contentType:"text/html",encoding:"UTF-8")
        }
        int leftPoint = consumeRecordService.queryLeftPoint(user)
        if(leftPoint < personService?.unitPrice){
            render "對不起，您的點數不夠，請充值！"
        }
        
        String consumeId = session.getAttribute("consumeId")
        Long consumeRecordId = consumeId?.toLong()
        //把該用戶添加到產品服務即時計費列表，列表保存在application当中
        def pscontext = request.session.servletContext

        Map serviceMap = pscontext.getAttribute("serviceMap")
        if(!serviceMap){
            serviceMap = new HashMap()
        }
        ConsumeRecord cvalue = serviceMap.get(consumeRecordId)

        if(!cvalue || cvalue?.member != user){
            serviceMap = presenceService.putPresence(consumeRecordId,serviceMap)
            pscontext.setAttribute ("serviceMap",serviceMap)
            
        }


        Long cid = new Long(0)

        if(consumeId != null && !consumeId.equals("")){
           cid = consumeId.toLong()
        }
        Long id = consumeRecordService.getFirstConsume(cid, personService.id, user.id, 1, personService.unitPrice)

        session.setAttribute ("consumeId", id)
        
        leftPoint = consumeRecordService.queryLeftPoint(user)
        ConsumeRecord consumeRecord = ConsumeRecord.get(id)
        Date startTime = consumeRecord.startTime
        Date endTime = consumeRecord.endTime
        Long leftsec = ((endTime.getTime() - startTime.getTime())/1000)/60
        response.characterEncoding = "utf-8"
        render(text:"您已在線使用該服務時間為：${leftsec}分鐘，剩余點數為：${leftPoint}",contentType:"text/html")
       // render "您已使用的服務時間為：${leftsec}分鐘，剩余點數為：${leftPoint}"
    }

此Controoler当中有用到presenceService来对保存在application中的即时在线消费用户状态的管理，presenceService内容如下：

/**
 * Created by IntelliJ IDEA.
 * User: Administrator
 * Date: 2008-6-12
 * Time: 16:53:54
 * To change this template use File | Settings | File Templates.
 */
class PresenceService {
    boolean transactional = true
    Map allPresencesMap = new HashMap()
//保存到application中
    def Map putPresence(Long consumeId, Map serviceMap){
        ConsumeRecord consumeRecord = new ConsumeRecord()
        if(consumeId){
            consumeRecord = ConsumeRecord.get(consumeId)
        }

        if(serviceMap){
            allPresencesMap = serviceMap
        }
        allPresencesMap.put(consumeId,consumeRecord)
        return allPresencesMap
    }

//从application中删除
    def void removePresence(Long consumeId, Map serviceMap){
        if(serviceMap){
           serviceMap.remove(consumeId)
        }
    }
//从application中删除所有的的在线用户
    def void removePresenceList(Long personServiceId){
        Map ctx = personServices?.personService
        if ( ctx ) {
            personServices.remove( personServiceId );
            ctx.clear();
        }
    }
//从application中取得所有的在线用户
    def List getPresenceList(User SP, Map serviceMap){
        List result = [];
        if(serviceMap){
            for(m in serviceMap){
                ConsumeRecord consumeRecord = m.value
                if(consumeRecord && consumeRecord?.id ){
                    if(consumeRecord?.serviceProvider.userName == SP.userName){
                        result << consumeRecord
                    }
                }

            }

        }
        return result;
    }
//取得指定的在线用户
    def Presence getPresence( String key, Long personServiceId ) {

        Map ctx = personServices?.personService

        if ( !ctx ) {
            ctx = new HashMap();
            personServices.put( personServiceId, ctx );
        }

        Presence result = ( Presence ) ctx.get( key );

        return result;
    }

}

 
2、要即时地把在线消费的用户记录到application中，这里用到了JOB进行定时作业。在Grails中集合了quartz这个plugin，使用grails create-job OnlineCheck，内容如下：

import org.codehaus.groovy.grails.web.context.ServletContextHolder

class OnlineCheckJob {
    def startDelay = 60000
    def timeout = 1000 * 91 // execute job once in 1.5 seconds
    def group = "OnlineStatus"
    PresenceService presenceService
    def execute() {
        println "Job:refresh online status......."
        def cxt = ServletContextHolder.getServletContext()
        //取得保存在application中的serviceMap
        Map serviceMap = cxt.getAttribute("serviceMap")

        Date now = new Date();
        //如果serviceMap在application中存在，则对其进行遍历，取得即时在线消费的用户
        println("presenceService :${presenceService}")
        if(serviceMap){
            for(m in serviceMap){
                // Map comsumeMap = new HashMap();
                ConsumeRecord consumeRecord = m.value
                if(consumeRecord != null && consumeRecord.id != null){
                    Date endTime = consumeRecord.endTime
                   //如果consumeRecord的最后消费时间大于当前时间65秒，则把当前在线消费的用户踢下线
             if(((now?.getTime() - endTime?.getTime()) / 1000 ) > 65){
                        presenceService.removePresence (consumeRecord.id, serviceMap)
                        println("remove online status:consumeRecordId=${consumeRecord.id}")
                    }
                }

            }
        }
        
    }
}

3、记录到application中了之后，就可以从application中读取保存在里面的在线用户了，建立一个controller，读取在线状态的action为：

def onlinestatus= {
        User sp = User.findByUserName(session.userName)  //sp为商户
        def pscontext = request.session.servletContext
        Map serviceMap = pscontext.getAttribute("serviceMap")
        List result = presenceService.getPresenceList(sp,serviceMap)

        request.setAttribute ("resultList",result)
        //[resultList:result]

        [resultList:result]  
    }

 如果要即时获取此在线消费用户的列表，则要使用Ajax来定时执行此action了：

<g:javascript>

function timerUpdater() {
              var myAjax = new Ajax.PeriodicalUpdater(
              {success:'onlinelist'},// 成功或失敗更新的页面div元素
                      '/user/onlinestatus', // 请求的URL
              {
                  asynchronous:true,
                  method: 'post', // HTTP请求的方式为GET
                  evalScripts: true, // 是否执行请求页面中的脚本
                  frequency: 60, // 更新的频率
                  decay: 2 // 衰减系数
              }
                      );
              return false;
          }
</g:javascript>

 保存所有之后，即可运行测试了。。。。。。。。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

在Grails安全验证插件分类中有几个和验证码相关的插件。
Simple Captcha Plugin  ： 比较简单的实现了图片显示验证码
JCaptcha Plugin ：基于 JCaptcha 开源图片和音频验证码项目的Grails插件
ReCaptcha Plugin ：基于 ReCaptcha 开源图片和音频验证码项目的Grails插件

这次主要介绍如何使用 JCaptcha 插件，因为JCaptcha相对比较成熟和稳定，功能完善可调整的内容也比较丰富。

安装
在 http://plugins.grails.org 网站下载 JCaptcha 插件。
然后进入你的项目目录， grails install-plugin %path%/grails-jcaptcha-0.2.zip

这里没有使用Grails的自动安装因为那样很慢，而且Grails自己下载也不支持断点，所以还是自己下载来的方便，特别是比较大的插件。

配置

在grails-app/conf/Config.groovy 文件中 定义验证器（captchas），

定义例子如下：

import java.awt.Font
import java.awt.Color
import com.octo.captcha.service.multitype.GenericManageableCaptchaService
import com.octo.captcha.engine.GenericCaptchaEngine
import com.octo.captcha.image.gimpy.GimpyFactory
import com.octo.captcha.component.word.wordgenerator.RandomWordGenerator
import com.octo.captcha.component.image.wordtoimage.ComposedWordToImage
import com.octo.captcha.component.image.fontgenerator.RandomFontGenerator
import com.octo.captcha.component.image.backgroundgenerator.GradientBackgroundGenerator
import com.octo.captcha.component.image.color.SingleColorGenerator
import com.octo.captcha.component.image.textpaster.NonLinearTextPaster
import com.octo.captcha.service.sound.DefaultManageableSoundCaptchaService


jcaptchas {
 imageCaptcha = new GenericManageableCaptchaService(
  new GenericCaptchaEngine(
   new GimpyFactory(
    new RandomWordGenerator(
     "abcdefghijklmnopqrstuvwxyz1234567890"
    ),
    new ComposedWordToImage(
     new RandomFontGenerator(
      20, // min font size
      30, // max font size
      [new Font("Arial", 0, 10)] as Font[]
     ),
     new GradientBackgroundGenerator(
      140, // width
      35, // height
      new SingleColorGenerator(new Color(0, 60, 0)),
      new SingleColorGenerator(new Color(20, 20, 20))
     ),
     new NonLinearTextPaster(
      6, // minimal length of text
      6, // maximal length of text
      new Color(0, 255, 0)
     )
    )
   )
  ),
  180, // minGuarantedStorageDelayInSeconds
  180000 // maxCaptchaStoreSize
 ) 
 soundCaptcha = new DefaultManageableSoundCaptchaService()
}

上面的代码是定义了两个验证器（captcha），一个图形验证器 imageCaptcha ，一个音频验证器 soundCaptcha；
imageCaptcha使用了自定义的方式，配置了很多参数。默认的图像验证器是 DefaultManageableImageCaptchaService
soundCaptcha使用了默认的验证器。

你可以配置更多的验证器以及规则，也可以就配置一个，比如这个音频的验证器一般不需要就可以删除掉。如果因为你的业务需要你要一个六字的验证和一个四字的验证，这样的情况就可以配置两个图像验证器。

ps：我在使用音频验证器时grails报错，因为音频使用到了一些音频处理的API，而我没有这些包，所以删除音频验证器以及涉及音频验证器的包即可。如果你确实需要音频验证器，那就你看错误信息，找到这些包然后放在项目的lib里。

ps：安装 JCaptcha 插件时会在plugins中安装插件的项目结构，其中也会安装conf/Config.groovy文件。如果运行Grails发生Config.groovy错误，删除插件中的配置文件即可plugins\jcaptcha-0.2\grails-app\conf\Config.groovy

显示

完成上面的配置之后，你得到一个验证器名称：imageCaptcha 。然后在需要的gsp页面中使用下面的tag。
<jcaptcha:jpeg name="<captchaname>"  />
 
<captchaname>就是你的验证器名称：imageCaptcha

正常的情况下你就可以看到验证图片了。这个验证图片的颜色，字体，大小，内容都可以通过前面的自定义配置去修改和完善。

验证

在控制器中需要验证用户输入的验证码和验证图片中显示的是否一致。首先要在控制器中声明一个jcaptchaService对象，以便spring依赖注入 jcaptchaService 这个类。
然后在具体的验证Action中使用jcaptchaService.validateResponse("imageCaptcha", session.id, params.code)方法具体验证。
第一个参数是你的验证器名称。
第二个参数是比较固定就是 session.id
第三个参数是 页面中填写验证码输入框的内容，根据你的输入框的名字XXX，params.XXX

def jcaptchaService    
def save = {
 def user = new User(params)
        if (!jcaptchaService.validateResponse("captchaName", session.id, params.captchaResponse))
        {
          flash.message = "认证码错误！"
          return render(view:'index',model:[user:user])  
 }

 // other logic
}

高级玩法
前面在配置图像验证器时我们已经发现，我们可以通过配置改变验证图片的很多特性。现在深入看看我们都能改变什么。

new RandomWordGenerator("") 可以配置随机生成图片内容的字符范围

new ComposedWordToImage(
 new RandomFontGenerator( // 生成图片文字的字体以及字号大小，可以是多种字体，会随机出现。
  20, // min font size
  30, // max font size
  [new Font("Arial", 0, 10)] as Font[]
 ),
 new GradientBackgroundGenerator(// 配置验证图片的大小和背景色以及过渡色
  140, // width
  35, // height
  new SingleColorGenerator(new Color(0, 60, 0)),
  new SingleColorGenerator(new Color(20, 20, 20))
 ),
 new NonLinearTextPaster(
  6, // minimal length of text
  6, // maximal length of text
  new Color(0, 255, 0)
 )
)

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• Functional Testing with Canoo WebTest

• Test Code Coverage Plugin

• Selenium plugin (run functional tests in the browser)

• jsUnit plugin (test javascript)

• DBUnit Plugin    好像很复杂 http://www.grails.org/DBUnit+Plugin
• Debug Plugin Provides useful debug output of request params, model and useful functionality

• DWR Plugin

• Dynamic Javascript Plugin

• Echo2 Plugin echo可以让开发者象开发awt/swing应用程序一样,用面向对象的方式设计web界面.
• GWT Plugin   Google Web Toolkit（GWT）google的ajax framework。
• OpenLaszlo Plugin  OpenLaszlo是一个基于flash和js的富客户端框架，可以生成flash页面和js的页面。
• RichUI Plugin
• ZK Plugin一个丰富用户界面的javascript框架
• Flex Plugin 这个就是Flex的差价，Flex是flash的语言
• ULC Plugin
• ModalBox Plugin javascript框架，一种model窗口
• Yahoo! UI Library (YUI) Plugin
• Ext JavaScript Library Plugin (discontinued) EXT的lib插件，没有什么配置，仅仅是下载了lib文件
• Syntax Highlighter Plugin 语法的高亮插件，貌似不错，还没有看到。网页好慢啊
• J2D Plugin (Java2D+Graphics)

• Google Chart Plugin google的制表制图插件
• JFreeChart Eastwood Plugin 效仿GoogleChartAPI实现的基于JFreeChart的servlet工具插件
• Open Flash Chart Plugin falsh的图表插件

• XFire plugin XFire是一个非常有名的Web Services框架
• Remoting Plugin 字面已经很明显了，让grails方便的使用Remoting
• XML-RPC Plugin  让grails当但一个xml rpc的服务
• Apache Axis2 Plugin Apache 的Web Service实现框架Axis2插件

• Static Resources Plugin

• p6spy plugin (database statement logging) 可以监控你的jdbc连接，并且会生成logs让你方便的再次拿出来放在你使用的数据库客户端工具上，来测试他运行的结果。
• Cacheable Plugin (application level caching) 应用程序级别的缓存插件（如果好用作用大大的）
• Amazon S3 Plugin  Amazon S3服务器的插件，可惜买不起亚马逊的S3...
• WebXML Plugin Allows adding configurable features to the web.xml file without having to write a plugin.

• Jawr plugin&nbsp;Javascript/CSS bundling and compression tool for grails web apps. All the features from the Jawr library ported to Grails.

• Profiler Plugin for monitoring the performance of your Grails application. 应该是一个监控性能的插件
• Compress Plugin - Compress Grails output  压缩输出，至于怎么样用，文档太过简单。

• Quartz plugin 定时器，这个项目中已经再用了。

• AcegiSecurity Plugin 整合Spring的Acegi 安全认证插件
• JSecurity Plugin 一个通用的安全认证框架
• Authentication Plugin 安全认证插件
• Simple Captcha Plugin 简单的说就是提交表单时候的认证图片。
• JCaptcha Plugin 依然是一个表单提交的认证字
• CAS Client Plugin为Web应用系统提供了单点登录服务
• ClamAV Plugin 一个防病毒的，环境是unix下。
• Atlassian Crowd Plugin ？？？？？？？
• OpenID Plugin OpenID 也就是说我们不需要在我们的应用中加入注册等这样的流程，这个插件会生成一个ID并且记录他分配给我们的用户。
• OAuth Plugin OAuth协议致力于使网站和应用程序（统称为消费方）能够在无须用户透露其认证证书的情况下，通过API访问某个web服务（统称为服务提供方）的受保护资源。更一般地说，OAuth为API认证提供了一个可自由实现且通用的方法
• ReCaptcha Plugin 这个嘛，一般来说就不要用了。貌似是一种服务，但是还需要在ReCaptcha的官方站上申请一个什么账号。麻烦
• License Management Plugin 安装 生成license的插件

• sIFR Plugin sIFR表示scalable Inman Flash Replacement，是一种在web上准确发布自定义排版的技术。这种技术的实现方法是，当页面下载时，在一个指定的元素中用Flash渲染的文字来代替一些文本。此插件就是干这个用的
• Skinnable Plugin 这个比较有意思，应该是一个动态换肤（css）的插件，有空研究一下。

• Searchable Plugin - rich search functionality with minimum effort. Built on Compass and Lucene 搜索的插件，应用的是lucene和compass不用说肯定要看看了。

• DjangoTemplates Plugin 模板，呵呵这个就不用说了，不过有什么好处需要试验以后再详说。
• GroovyBinder Plugin 我晕死了，好像是一个很好的东西， dynamic write-only。
• ScaffoldTags Plugin 不用说了，（就是Grails自带的脚手架吗？？）。
• I18n Templates Plugin 这个也不用说了，项目中已经再用了
• Extended Data Binding Plugin

• Explicit Insert Plugin adds an insert method to all domain classes to resolve save() issues with legacy tables with assigned keys and no version or timestamp. 此插件是用在grails 1.0.2之前版本的。所以基本我们是不会用到的。
• Acts As Taggable Plugin add the acts_as_taggable ability to domain class 从Rails来的一个tag（标签）的插件，可以很方便的使用插件。
• Systemi Grails Domain Plugin generates Grails domain classes from a legacy IBM System i (a.k.a. AS/400, a.k.a. iSeries) table

• Grails Audit Logging Plugin track who changed what via Hibernate events, can be optionally configured to log users from multiple security plugins, adds onChange event handler to marked domain classes and exposes old and new values.

• Radeox plugin for the Radeox wiki engine 一个wiki系统Radeox，以后可以用Grails方便的写出wiki程序啦~~
• Mondrian plugin to add Mondrian and JPivot OLAP

• FCK editor plugin - WYSIWYG text editor with buillt in image and flash upload capabilities.

• JMS Plugin to add Message Driven Bean functionality

• Feeds Plugin to generate RSS/Atom feeds easily

• ImageTools plugin provides some JAI helper classes for image handling

• Currencies plugin provide Money and Exchange Rate handling classes.

• Encryption plugin, for Blowfish and PGP encryption, as well as handling salted passwords. 使用Blowfish 和PGP 加密的插件，应该是对字符串加密
• PostCode Plugin provides UK postcode lookup to lat/lon and distance between postcode functionality 邮政编码，还是英国的。暂时没用
• Ref Code Plugin provides funtionality for storing and accessing simple reference data
• Mail Plugin - provides e-mail sending functionality to a Grails application 为你的程序提供邮件发送功能。
• PayPal Plugin - Provides integration with PayPal transactions and the PayPal IPN ，PayPal 的插件，方便加入PayPal 支付代码

• Wicket Plugin Wicket也是一种MVC，像JSF一样用前端很多标签堆砌页面
• Struts 1 Plugin  Struts1？？？祖宗辈的MVC框架。

• LiquiBase Plugin 可以记录你的数据库的变更，生成的文件为XML
• dbmigrate Plugin

• LDAP Plugin - Add LDAP connectivity through Gldapo 为Grails加入 目录访问框架Gldapo 的功能

• Jasper Plugin - Add Jasper reports in your web application easily. 不用说他是用来生成报表的

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

本篇介绍groovy 的MetaClasses ，MetaClass 是Groovy 动态编程比较重要的组成。

(以下出现的代码片段是在groovy1.5.3测试通过，希望各位可以运行之)。

1.MetaClass

           groovy中出现的每个类都有其对应的MetaClass。MetaClas是一个接口，该接口扩展了MetaObjectProtocol接口，这就是我们通常所说的MOP协议了。

MetaClass的实现类主要有 

MetaClassImpl 是通用的实现类。ClosureMetaClass是闭包类特有的MetaClass。ExpandoMetaClass是用户扩展groovy类行为时用到的MetaClass

println 'first:---> '+'test'.metaClass

println 'String.metaClass:---> '+String.metaClass

println 'after String.metaClass:--->  '+'test'.metaClass

 对于这样的结果你是不是会感觉到奇怪呢？

下面我将结合Groovy实现代码来解释这个过程

第一句脚本 通过String实例对象来获得，Groovy为其初始化的groovy.lang.MetaClassImpl@183f74d[class java.lang.String]对象。这个对象将在MetaClassRegistryImpl中和String类关联起来。也就是注册了String.class和

groovy.lang.MetaClassImpl的对象关系。

第二句脚本 通过String类去访问 metaClass对象，不过这一次是调用了类DefaultGroovyMethods中的方法

    /**
     * Adds a "metaClass" property to all class objects so you can use the syntax
     * <code>String.metaClass.myMethod = { println "foo" }</code>
     *
     * @param c The java.lang.Class instance
     * @return An MetaClass instance
     */
    public static MetaClass getMetaClass(Class c) {
        MetaClassRegistry metaClassRegistry = GroovySystem.getMetaClassRegistry();
        MetaClass mc = metaClassRegistry.getMetaClass(c);
        if (mc instanceof ExpandoMetaClass
                || mc instanceof DelegatingMetaClass && ((DelegatingMetaClass) mc).getAdaptee() instanceof ExpandoMetaClass)
            return mc;
        else {
            MetaClass emc = ExpandoMetaClassCreationHandle.instance.create(c, metaClassRegistry);
            emc.initialize();
            metaClassRegistry.setMetaClass(c, emc);//并且在metaClassRegistry中注册
            return emc;
        }
    }

 第三句脚本又重新通过String实例对象来获得了，但这一次得到的是groovy.lang.ExpandoMetaClass@8a0d5d，这是因为第二句话中对String和其MetaClass对象进行了重新注册。

自此以后系统中所有的String对象的MetaClass对象都一直市是ExpandoMetaClass对象实例。

由于我们举的String例子有点特殊

我们看看对于自定义类的例子

class Foo{
	
}
def f1 = new Foo();
println f1.metaClass

println Foo.metaClass

println f1.metaClass

def f2 = new Foo()
println f2.metaClass

 结果是不是又不一样了？

f1对象的metaClass是被缓存了，只有在调用过

Foo.metaClass

 之后，new出来的对象才会使用ExpandoMetaClass

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

import java.lang.reflect.Method
import com.pansoft.extjs.DbunitDatabaseTemplateGenerator
import java.sql.Connection
import java.sql.DriverManager

/*
* Copyright 2004-2005 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**
 * Gant script that handles the creation of domain classes from an existing database
 *
 * @author dellsoft
 *
 * @since 1.0
 */

grailsAppName = ""

Ant.property(environment: "env")
grailsHome = Ant.antProject.properties."env.GRAILS_HOME"

includeTargets << new File("${grailsHome}/scripts/Compile.groovy")

//pluginHome = new File("./plugins").listFiles().find {
//    it.name.startsWith('dbmapper-')
//}

target('default': "Generates code for all the domain classes in the database") {
    depends(promptForTableName,generateDomainClasses)
}

target(promptForTableName: "指定表名----") {
    if (!args) {
        Ant.input(addProperty: "artifact.name", message: "请输入表名:\nALL --代表所有")
        args = Ant.antProject.properties."artifact.name"
    }
}

target('generateDomainClasses': "Generate for all all the domain classes in the database") {
    profile("compiling config") {
        compile()
    }

    profile("creating config object") {
        ClassLoader contextLoader = Thread.currentThread().getContextClassLoader()
        classLoader = new URLClassLoader([classesDir.toURL()] as URL[], contextLoader)
        def configSlurper = new ConfigSlurper(grailsEnv)
        def configFile = new File("${basedir}/grails-app/conf/Config.groovy")
        if (configFile.exists()) {
            try {

                config = configSlurper.parse(classLoader.loadClass("Config"))
                config.setConfigFile(configFile.toURL())
            }
            catch (Exception e) {
                e.printStackTrace()

                event("StatusFinal", ["Failed to compile configuration file ${configFile}: ${e.message}"])
                exit(1)
            }

        }
        def dataSourceFile = new File("${basedir}/grails-app/conf/DataSource.groovy")
        if (dataSourceFile.exists()) {
            try {
                def dataSourceConfig = configSlurper.parse(classLoader.loadClass("DataSource"))
                config.merge(dataSourceConfig)
            }
            catch (Exception e) {
                e.printStackTrace()

                event("StatusFinal", ["Failed to compile data source file $dataSourceFile: ${e.message}"])
                exit(1)
            }
        }
        classLoader = contextLoader;
    }

    profile("generate the classes") {
        def username = config.dataSource.username
        def password = config.dataSource.password
        def databaseUrl = config.dataSource.url
        def driver = config.dataSource.driverClassName
        def sqlType
        def tableName = args
        if (driver.indexOf("sybase", 1) > 0) {
            sqlType = "sybase"
        } else if (driver.indexOf("mysql", 1) > 0) {
            sqlType = "mysql"
        } else if (driver.indexOf("oracle", 1) > 0) {
            sqlType = "oracle"
        } else if (driver.indexOf("hsql", 1) > 0) {
            sqlType = "hsql"
        }
        try {
            Class.forName(driver)

            Connection connection = DriverManager.getConnection(databaseUrl, username, password)
            connection.setAutoCommit true
            def generator = new DbunitDatabaseTemplateGenerator()
            println("tableName="+Arrays.asList(tableName).toString())
            println("tableName="+tableName)
            generator.generateDomainClasses(connection,sqlType,'','.',Arrays.asList(tableName))
            println("sqlType="+sqlType)

        } catch (Exception e) {
            e.printStackTrace()

            event("StatusFinal", ["Failed to generate domain classes: ${e.message}"])
            exit(1)
        }
        println("Successfully generated domain classes")
    }
}

package com.pansoft.extjs

import org.codehaus.groovy.grails.scaffolding.DefaultGrailsTemplateGenerator
import org.codehaus.groovy.grails.commons.GrailsDomainClass
import groovy.text.*;
import org.apache.commons.logging.Log;
import org.springframework.core.io.*
import org.apache.commons.logging.LogFactory;
import org.codehaus.groovy.grails.commons.GrailsDomainClass;
import org.codehaus.groovy.grails.commons.GrailsApplication;
import org.codehaus.groovy.grails.scaffolding.GrailsTemplateGenerator;
import org.codehaus.groovy.grails.commons.GrailsClassUtils as GCU
import org.codehaus.groovy.grails.commons.ApplicationHolder
import java.sql.Connection
import org.dbunit.database.IDatabaseConnection
import org.dbunit.ext.mssql.MsSqlConnection
import org.dbunit.dataset.IDataSet
import org.dbunit.ext.mysql.MySqlConnection
import org.dbunit.ext.oracle.OracleConnection
import org.dbunit.ext.hsqldb.HsqldbConnection
import org.dbunit.dataset.ITableMetaData
import org.dbunit.database.DatabaseConnection;
import org.dbunit.dataset.datatype.*
import java.sql.DatabaseMetaData
import java.sql.ResultSet;
/**
 * Created by IntelliJ IDEA.
 * User: dellsoft
 * Date: 2008-5-21
 * Time: 10:18:13
 * To change this template use File | Settings | File Templates.
 */
class DbunitDatabaseTemplateGenerator extends DefaultGrailsTemplateGenerator {
    static final Log Dbunitlog = LogFactory.getLog(DbunitDatabaseTemplateGenerator.class);

    public IDatabaseConnection conn
    public IDataSet dataSet
//    public String[] tables
    def tables = []
    public DatabaseMetaData databaseMetaData
    def indexColumns = []
    public ResultSet resultSet

    // 定义对应的数据类型
    def dataType = {column ->
//        def column = property
//        def cp = domainClass.constrainedProperties[property.name]

        if (!renderEditorTemplate) {
            // create template once for performance
            def templateText = getTemplateText("dataType.template")
            renderEditorTemplate = engine.createTemplate(templateText)
            Dbunitlog.info("templateText=" + templateText)
        }


        def binding = [column: column]
        Dbunitlog.info("binding=" + binding)
        return renderEditorTemplate.make(binding).toString()
    }

//    public DbunitDatabaseTemplateGenerator(Connection con,String sqlType) {
//
//
//
//    }

    // get the tables from the dataset
    public void generateDomainClasses(Connection conn, String sqlType, String pkg, String destDir, List tableName) {
        switch (sqlType) {
            case 'sybase': this.conn = new MsSqlConnection(conn, null)
                break
            case 'mysql': this.conn = new MySqlConnection(conn, null)
                break
            case 'oracle': this.conn = new OracleConnection(conn, null)
                break
            case 'hsql': this.conn = new HsqldbConnection(conn, null)
                break

        }

        dataSet = this.conn.createDataSet()
        tables = Arrays.asList(dataSet.getTableNames())
        def tableTmp = []
        if (tableName.size() > 0) {
            tableName.each {
                tableTmp << it.toLowerCase()
            }
        }

        if (tableTmp.contains("all")) {

        } else {
            def tmp = [] 
            tmp = tables.findAll {
                tableTmp.contains(it.toLowerCase())
            }.asList()
            tables = tmp
        }

        databaseMetaData = this.conn.getConnection().getMetaData()
        tables.each {
            indexColumns.clear()
            resultSet = databaseMetaData.getIndexInfo(null, this.conn.schema, it, true, false)
//            resultSet = databaseMetaData.getBestRowIdentifier(null, this.conn.schema, it, DatabaseMetaData.bestRowSession, true)
            while (resultSet.next()) {
//                indexColumns['table'] = resultSet.getString(3)
//                indexColumns['unique'] = resultSet.getString(6)
//                indexColumns['type'] = resultSet.getString(7)
                if (resultSet.getString(9) != 'null' && !resultSet.getString(9).is(null)) {
                    indexColumns << resultSet.getString(9)
                }

            }
            generateDomain(dataSet.getTableMetaData(it), pkg, destDir)
        }
        this.conn.close()
    }
    // generate domains from the tables
    public void generateDomain(ITableMetaData tableMetaData, String pkg, String destdir) {
        if (!destdir)
            throw new IllegalArgumentException("Argument [destdir] not specified")

        if (tableMetaData.tableName) {
            Dbunitlog.info("Domain generated at ${tableMetaData.tableName}")
            System.out.println("tableName=" + tableMetaData.tableName)
//            def fullName = domainClass.fullName
//            def pkg = ""
//            def pos = fullName.lastIndexOf('.')
//            if (pos != -1) {
//                // Package name with trailing '.'
//                pkg = fullName[0..pos]
//            }

            def destFile = new File("${destdir}/grails-app/domain/${tableMetaData.tableName[0] + tableMetaData.tableName[1..-1].toLowerCase()}.groovy")
            if (canWrite(destFile)) {
                destFile.parentFile.mkdirs()

                destFile.withWriter {w ->
                    generateDomain(tableMetaData, w)
                }

                Dbunitlog.info("Domain generated at ${destFile}")
            }
        }
    }

    public void generateDomain(ITableMetaData tableMetaData, Writer out) {
        def templateText = getTemplateText("Domain.groovy")

        def binding = [
                tableName: tableMetaData.tableName[0] + tableMetaData.tableName[1..-1].toLowerCase(),
                columns: tableMetaData.columns,
                primaryKeys: tableMetaData.primaryKeys,
                indexColumns: indexColumns,
                dataType: dataType,
                comparator: org.codehaus.groovy.grails.scaffolding.DomainClassPropertyComparator.class]

        def t = engine.createTemplate(templateText)
        t.make(binding).writeTo(out)
    }



    private canWrite(testFile) {
        if (!overwrite && testFile.exists()) {
            try {
                ant.input(message: "File ${testFile} already exists. Overwrite?", "y,n,a", addproperty: "overwrite.${testFile.name}")
                overwrite = (ant.antProject.properties."overwrite.${testFile.name}" == "a") ? true : overwrite
                return overwrite || ((ant.antProject.properties."overwrite.${testFile.name}" == "y") ? true : false)
            } catch (Exception e) {
                // failure to read from standard in means we're probably running from an automation tool like a build server
                return true
            }
        }
        return true
    }

    private getTemplateText(String template) {
        def application = ApplicationHolder.getApplication()
        // first check for presence of template in application
        if (resourceLoader && application?.warDeployed) {
            return resourceLoader.getResource("/WEB-INF/templates/scaffolding/${template}").inputStream.text
        }
        else {
            def templateFile = "${basedir}/src/templates/scaffolding/${template}"
            if (!new File(templateFile).exists()) {
                // template not found in application, use default template
                def ant = new AntBuilder()
                ant.property(environment: "env")
                def grailsHome = ant.antProject.properties."env.GRAILS_HOME"
                templateFile = "${grailsHome}/src/grails/templates/scaffolding/${template}"
            }
            return new File(templateFile).getText()
        }
    }


}

<% import org.codehaus.groovy.grails.orm.hibernate.support.ClosureEventTriggeringInterceptor as Events %>
<% import org.dbunit.dataset.datatype.* %>
class ${tableName} {
<%
    def excludedColumns = ['id', 'version']
    //out put the column
    String omitPrefix = "F_"
    def outColumns = []
    def primaryFields = []
    def mappingFields = [:]
    def constraintsFields = [:]
    def idColumn = ["F_ID"]
    def isUseIdColumn = true
    def isUseVersionColumn = true
    outColumns = columns.findAll {!excludedColumns.contains(it.columnName)}
    outColumns.each {p ->
        def outName
        outName = getOmitPrefixColumn(p.columnName,omitPrefix)
        mappingFields[outName] = p.columnName
        constraintsFields[outName] = p.nullable
%>
    ${dataType(p)} ${outName}
<%
    }
    primaryKeys.each {p ->
        primaryFields << getOmitPrefixColumn(p.columnName,omitPrefix)
    }

    if (primaryFields.isEmpty()) {
        primaryFields = indexColumns
    }

    public String getOmitPrefixColumn(String orignalColumn,String omitPrefixString) {
        String  omitPrefixColumn
        if (orignalColumn.contains(omitPrefixString)){
            omitPrefixColumn = orignalColumn[omitPrefixString.length()..-1].toLowerCase()
        }else {
            omitPrefixColumn = orignalColumn.toLowerCase()
        }
        return   omitPrefixColumn
    }
    if (isUseIdColumn) {
        primaryFields = idColumn
    }


%>
    static mapping = {
       // table '${tableName}'
      <% if ( !isUseVersionColumn ){ %>
        version false
       <% } %>
      //  id composite: ['${primaryFields.join(', ')}']
<%
    mappingFields.each {key,value ->
%>
        ${key} column: '${value}'
<%
    }
%>                                                      
    }

    static constraints = {
<%
    constraintsFields.each {column ->
    if ("${column.value}" == "noNulls") {
%>
        ${column.key} (nullable: false)
<%
        }
    }
%>
    }
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

import org.codehaus.groovy.grails.commons.*
import org.apache.poi.hssf.usermodel.HSSFWorkbook
import org.apache.poi.hssf.usermodel.HSSFSheet
import org.apache.poi.hssf.usermodel.HSSFRow
import org.apache.poi.hssf.usermodel.HSSFCell
import org.codehaus.groovy.grails.commons.GrailsDomainClass
import org.codehaus.groovy.grails.web.converters.ConverterUtil
import org.springframework.web.servlet.support.RequestContextUtils as RCU
import org.codehaus.groovy.grails.scaffolding.DomainClassPropertyComparator;
import org.springframework.context.MessageSource
import org.apache.poi.hssf.usermodel.HSSFCellStyle
import org.apache.poi.hssf.usermodel.HSSFFont
import org.apache.poi.hssf.util.HSSFColor;

class XlsExportService {

//    def messageSource
    MessageSource messageSource
    boolean transactional = true
//    def config = ConfigurationHolder.config
//    def domainName
    def xlsExport(out, request, domain, datas) {
        def excludedProps = ['id', 'version']
        def column = []
        def titles = []
        def outProperties
        def locale = RCU.getLocale(request)
//        def text
        def args
        def domainName = domain.toLowerCase()
        GrailsDomainClass domainClass = ConverterUtil.getDomainClass(domain)
        if (domainClass != null) {
            outProperties = domainClass.properties.findAll {!excludedProps.contains(it.name)}
        }
        Collections.sort(outProperties, new DomainClassPropertyComparator(domainClass))
        outProperties.each {
            column << "${it.name}"
            def text = messageSource.getMessage(
                    "${domainName}.${it.name}".toString(),
                    args == null ? null : args.toArray(),
                    "${domainName}.${it.name}".toString(),
                    locale)
            titles << text
        }
        HSSFWorkbook wb = new HSSFWorkbook();
        HSSFSheet sheet = wb.createSheet("new sheet");
        HSSFRow row
        HSSFCell cell
        HSSFCellStyle style = wb.createCellStyle()
        HSSFFont font   =   wb.createFont()
        font.setFontHeightInPoints((short)12)
        font.setFontName("宋体")
        font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD) 
        style.setFont(font)
        style.setAlignment(HSSFCellStyle.ALIGN_CENTER)
        style.setFillBackgroundColor(HSSFColor.ORANGE.index)
//        style.setFillPattern(HSSFCellStyle.)
        // set the title
        row = sheet.createRow((short) 0);
        titles.eachWithIndex {title, i ->
            cell = row.createCell((short) (i));
            cell.setCellStyle(style)
            cell.setCellValue(title);
        }

        // set the data
        datas.eachWithIndex {data, i ->
            row = sheet.createRow((short) (i+1));
            column.eachWithIndex {p, j ->
                row.createCell((short) (j)).setCellValue(data."${p}");

            }

        }

        // Write the output to a file
        wb.write(out);
        out.close()

    }


}

 def exportXls = {
//        def excludedProps = ['id', 'version']
//        def column = []
//        def titles = []
//        def outProperties = []
//        GrailsDomainClass domainClass = ConverterUtil.getDomainClass("Person");
//        if (domainClass != null) {
//            domainClass.persistentProperties.each {p ->
//                outProperties << p.name
//            };
//
//        }
//        outProperties.each {
//            column << "${it}"
//            titles << message(code: "person.${it}")
//        }
        response.setHeader("Content-disposition", "attachment; filename=person.xls")
        response.setContentType("application/vnd.ms-excel")
//        ServletOutputStream f = response.getOutputStream();
        xlsExportService.xlsExport(response.outputStream, request,"Person", Person.list())
//        render(contextType:"application/vnd.ms-excel")


    }

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

    下载下面提供的压缩包,grails-fckeditor-0.6.zip.直接在命令行下输入:grails install-plugin "插件所在的路径"/grails-fckeditor-0.6.zip.安装成功之后我们就可以直接使用了.

<fckeditor:editor id="content" name="content" width="600" height="400">
       ${article?.content?.encodeAsHTML()}
</fckeditor:editor>

还可以为fckeditor加入代码高亮显示,我用的是SyntaxHighlighter.

使用方法：
1、在您的FCKeditor的配置文件中（一般为fckconfig.js或custom.config.js）
配置其中的FCKConfig.ToolbarSets，添加HighLighter。
如：
    FCKConfig.ToolbarSets["review"] = [
        ['HighLighter','Bold','Italic','Underline','StrikeThrough','Link','Unlink','Image','Rule','Smiley','TextColor','BGColor']
    ];
当然，你可以放到别的工具栏，不过记得注意大小写。
 
2、根据你指定的plugin目录，注册plugin
如：
    // 代码语法高亮插件
    FCKConfig.Plugins.Add( 'highlighter', 'zh-cn,en' ) ;

3、OK,你会发现你的FCK工具栏的图片多了一个带有"ab"字母，黄底的图标。你就可以使用语法高亮显示功能了。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

此文仅为本人初次学习和实践G&G的心得体会以及开发经验的记录，旨在将我的感受保留下来以备未来查阅。欢迎大家指正和补充：）

一、Domain Class

1. 对于一个领域类对应一个表的情况最好解决，每一个字段对应一列，是最爽的形式

2. 每个领域类最好重写toString()方法，目的在于关联的显示时展现有意义的文字而不是简单的ID

3. static constraints = {}有两个作用，一是规定了字段在页面中的顺序；另外就是数据约束在这里定义。PS：一定要保证拼写正确，我就因为拼写错误导师运行不成功，郁闷了很久才找到错误原因。

4. 在字段定义是一定要保证其不是数据库中的关键字！！这点很重要，我已经两次在这方面出错了。一次是desc，一次是order

5. 在数据验证中，blank是针对String类型的不为空，而其他类型不为空则要用nullable，如Integer。常用的还有maxSize，也是针对String类型的长度。如无必需最好不要大于255，若大于则数据库中类型不是Varchar了。

6. 在一对多关系中，一方要有hasMany闭包，这样可以在内容显示时包括多方的链接；多方中belongsTo是可选的，如果加上则会被级联删除。

7. static mapping 闭包可以修改默认的字段与表的对应方式，尤其在处理遗留数据库时有用

二、数据库访问

1. 数据源配置：在grails-app/conf/DataSource.groovy里配置，dbCreate 的值在不同的环境下会产生不同的行为。它是底层的 hibernate.hbm2ddl.auto 设置的别名，负责指定 Hibernate 在幕后如何管理表。将 dbCreate 设为 create-drop create ，那么 Hibernate 会在需要的时候创建新表和修改现有表，但是重新启动之间的所有记录都会被删除。production 模式的默认值 — update — 会在重新启动之间保持所有数据，也会在需要的时候创建或修改表。 ，就是告诉在启动的时候创建表，在关闭的时候删除表。如果将值改为

2. 注意要把访问数据的jar包拷贝到lib目录中。

3. 可添加自定义环境，如beta，同development等设置，在启动程序时grails -Dgrails.env=beta run-app

4. 数据库模式还是要先建立好的，Grails只能修改表而不是数据库

5. 一般的run-app使用development数据配置，打成war包后使用production配置。要保证lib中有数据访问驱动

6. 数据库连接字符串要写对格式，如mysql的：jdbc:mysql://localhost:3306/trip

三、页面修改

1. 页面跟普通JSP页面没有太多区别，一般内置标签<g:**>无需导入就可直接使用，自己编写的Tag只要按照规约放在指定的目录下即可直接使用。

2. 最爽的一点是页面修改无需重启服务器，因而修改后直接刷新就能看到效果

3. 一般生成的页面上都有ID这个字段，最好都删去避免出错

四、控制器及业务逻辑

1. 有两种默认控制器执行，一是转到index闭包；另外就是直接指定

2. 不是所有闭包都要有对应的视图，可以转到任何试图，render是渲染的意思，redirect是重定向 。这两种方式都可以用flash.message来显示提示信息

3. 可以直接使用Java语言中的类库或Groovy语言。在访问数据库方面还是Groovy比较方便，例子如下：

    首先要import groovy.sql.Sql

      def db = Sql.newInstance(DB,ID,PASSWORD,DRIVER)
      def result = db.execute("DELETE FROM member WHERE id=${m.homeId}")

4. 保持Domain时hasErrors()只是检查对象是否构造无误，而save()才是真正进行约束检查

五、其他

1. 所有文件最好都用utf-8格式保存，这样能对中文友好支持！

2. i18n文件已经有多个语言版本，根据本机配置会自动选择，在中国就使用messages_zh_CN.properties

3. 如User中的username的非空提示就应为：User.username.blank = 用户名不能为空。无需自己进行本地转化，启动时系统会自动为你转换。具体参考官方文档

version 1.1

未完待续...

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师