控制器中展示图片的方法

def image= {
def something = Something.get( params.id )
byte[] image = something.image
response.outputStream << image
}


页面展示

<img src="${createLink(controller:'something', action:'image', id: something.id)}"/>

下载需要的库文件

到https://rome.dev.java.net/下载Rome，之后把rome-xxx.jar放到你的grails项目的lib目录下。这里xxx是版本号。比如我的是rome-1.0RC1.jar

再到http://www.jdom.org/下载JDom。之后同样是把jdom.jar放到lib目录下。

书写代码

创建一个controller，当然你也可以在你已经有的controller里面增加相应方法。这里我们创建一个叫做FeedController的类。

之后访问相应的页面，比如说http://www.ondev.net/feed/rss就可以了

原贴地址： http://www.ondev.net/story/show/75

Installation

To install the YUI plugin type this command from your project's root folder:

grails install-plugin yui

Usage

To use Grails' adaptive AJAX support just add the folowing line in the head section:

<g:javascript library="yui" />

<yui:javascript dir="calendar" file="calendar-min.js" />
<yui:javascript dir="calendar" file="calendar-min.js" version="2.5.2" />
// version to be used in case multiple version installed
<yui:stylesheet dir="calendar/assets" file="calendar.css" />

Overriding default javascript files

By default only yahoo-dom-event.js and connection-min.js are included when using <g:javascript library="yui" />. Adding additional libraries to the default list can be done in a BootStrap (+) class:

import org.codehaus.groovy.grails.plugins.web.taglib.JavascriptTagLib
class BootStrap {
def init = { servletContext ->
JavascriptTagLib.LIBRARY_MAPPINGS.yui += ["yui/2.5.2/calendar/calendar-min",
"yui/2.5.2/container/container-min"]
}
def destroy = {
}
}

import grails.util.GrailsUtil
import org.codehaus.groovy.grails.plugins.web.taglib.JavascriptTagLib
class BootStrap {
def init = { servletContext ->
if (GrailsUtil.isDevelopmentEnv()) {
JavascriptTagLib.LIBRARY_MAPPINGS.yui = ["yui/2.5.2/yahoo/yahoo-debug",
"yui/2.5.2/dom/dom-debug",
"yui/2.5.2/event/event-debug",
"yui/2.5.2/connection/connection-debug"]
}
}
def destroy = {
}
}

Serving YUI Files from Yahoo! Servers

It's also possible to serve the javascript from the Yahoo! servers. First delete the yui folder from web-appjs after installing the plugin. Then, in a BootStrap class, override the mapping which contains the javascript files to include by default:

import org.codehaus.groovy.grails.plugins.web.taglib.JavascriptTagLib
class BootStrap {
def init = { servletContext ->
JavascriptTagLib.LIBRARY_MAPPINGS.yui = []
}
def destroy = {
}
}

Upgrading

If you want to upgrade:

• Delete the plugin from the project's plugins folder
• (Optional) Delete the previous YUI version folder from web-appjsyui
• Re-install the plugin by executing grails install-plugin yui

• The Plug-in Developers Guide

• Phone Number Custom Constraint for Grails

• My first Grails plugin

Between those three, you should have enough to figure things out. I still found it hard, despite those instructions and so to avoid having to figure things out again some time in the future, I'll write absolutely everything here.

Creating the Plugin

1. On the command line, run this:

   grails create-plugin SamplePlugin

   Now you have a Grails plugin. However, at the same time it is just another Grails application, which means you can simply open it in NetBeans IDE. (I.e., there is no import process and no NetBeans artifacts are added to the plugin in order to be able to open it in the IDE.)

    

2. So open the plugin in the IDE. The Projects window isn't very interesting, it just shows you the same as you would normally see for Grails applications:

   

   The Files window (Ctrl-2) however, shows a lot more:

   

   Open the "SamplePluginGrailsPlugin.groovy" file and there you see the following:

   class SamplePluginGrailsPlugin {
       def version = 0.1
       def dependsOn = [:]
       def doWithSpring = {
       // TODO Implement runtime spring config (optional)
       }
       def doWithApplicationContext = { applicationContext ->
       // TODO Implement post initialization spring config (optional)
       }
       def doWithWebDescriptor = { xml ->
       // TODO Implement additions to web.xml (optional)
       }
       def doWithDynamicMethods = { ctx ->
       // TODO Implement registering dynamic methods to classes (optional)
       }
       def onChange = { event ->
       // TODO Implement code that is executed when this class plugin class is changed
       // the event contains: event.application and event.applicationContext objects
       }
       def onApplicationChange = { event ->
       // TODO Implement code that is executed when any class in a GrailsApplication changes
       // the event contain: event.source, event.application and event.applicationContext objects
       }
       }

   I.e., you have hooks for integrating your code into meaningful places in the plugin.

    

3. Now we'll create code that will let our plugin provide a new "constraint". (If you don't know what that is, you will know by the time you finish reading all this.) To do so, we will need to extend org.codehaus.groovy.grails.validation.AbstractConstraint, in a package within src/groovy:

   import org.codehaus.groovy.grails.validation.AbstractConstraint
       import org.springframework.validation.Errors
       class BestFrameworkConstraint extends AbstractConstraint {
       private static final String DEFAULT_MESSAGE_CODE = "default.answer.invalid.message";
       public static final String NAME = "oneCorrectResponse";
       private boolean validateConstraint
       //The parameter which the constraint is validated against:
       @Override
       public void setParameter(Object constraintParameter) {
       if (!(constraintParameter instanceof Boolean))
       throw new IllegalArgumentException("Parameter for constraint ["
       + NAME + "] of property ["
       + constraintPropertyName + "] of class ["
       + constraintOwningClass + "] must be a boolean value");
       this.validateConstraint = ((Boolean) constraintParameter).booleanValue()
       super.setParameter(constraintParameter);
       }
       //Returns the default message for the given message code in the current locale:
       @Override
       protected void processValidate(Object target, Object propertyValue, Errors errors) {
       if (validateConstraint && !validate(target, propertyValue)) {
       def args = (Object[]) [constraintPropertyName, constraintOwningClass,
       propertyValue]
       super.rejectValue(target, errors, DEFAULT_MESSAGE_CODE,
       "not." + NAME, args);
       }
       }
       //Returns whether the constraint supports being applied against the specified type:
       @Override
       boolean supports(Class type) {
       return type != null && String.class.isAssignableFrom(type);
       }
       //The name of the constraint, which the user of the plugin will use
       //when working with your plugin.
       @Override
       String getName() {
       return NAME;
       }
       //Validate this constraint against a property value,
       //In this case, ONLY "Grails" is valid, everything else will cause an error:
       @Override
       boolean validate(target, propertyValue) {
       propertyValue ==~ /^Grails$/
       }
       }

    

4. Next, back in the Groovy plugin class that we looked at earlier, hook the above class into the plugin, using the "doWithSpring" closure to do so:

   def doWithSpring = {
       org.codehaus.groovy.grails.validation.ConstrainedProperty.registerNewConstraint(
       BestFrameworkConstraint.NAME,
       BestFrameworkConstraint.class);
       }

    

5. Now, back on the command line, navigate to within the "SamplePlugin" folder. There, run the following:

   grails package-plugin

   Back in the IDE, examine the ZIP file that the above command created:

   

That ZIP file is your Grails plugin.

Installing the Plugin

Now we will install our plugin in a new application.

1. First, create a new Grails application by going to the New Project wizard (Ctrl-Shift-N) and choosing Groovy | Grails Application. Click Next and type "SampleApplication" and then click Finish.

    

2. After the IDE has finished running the "grails create-app" command for you, you will see the new application open in the IDE. Right-click it and choose "Plugins", as shown here:

   

    

3. In the Grails Plugins dialog, notice that the list gets filled with many potential plugins that you might want to install, from the Grails plugins repository. Instead, we'll install our own. Click Browse and browse to the ZIP file that we created three steps ago and notice that it appears in the text field at the bottom of the dialog:

   

    

4. Click "Install" and then a progress bar appears, ending with the plugin being installed. Notice that you can also uninstall it:

   

    

5. Take a look at your application and notice (in the Files window) what's happened to the plugin. It's been unzipped, plus the ZIP file is still there. And all that's been done in the "plugins" folder. Nothing else has changed, which means that uninstallation is as simple as removing the folder from the "plugins" folder:

   

   Thanks to "convention over configuration", Grails knows exactly where everything is—so that, for example, the "plugin.xml" file that you see above, if found within the folder structure you see above, is the indicator to Grails that a plugin is available for use.

Using the Functionality Provided By the Plugin

1. Let's now use our plugin. Create a domain class called "Quiz", after right-clicking the "Domain Classes" node and choosing "Create new Domain Class":

   

    

2. Right-click the "Controllers" node and choose "Create new controller". Type "Quiz" and then click Finish. Use the Groovy editor to add one line for adding the scaffolding (and uncomment the other line):

   

    

3. Back in the "Quiz" domain class, add your property and use the "oneCorrectResponse" constraint defined in your plugin, as shown here:

   

   Note: The "oneCorrectResponse" constraint that you see above is the name of the constraint defined in the plugin.

    

4. And then add the message to the messages.properties file, which is within the "Messages Bundles" node:

   

    

5. Run the application and you will see that your constraint will prevent anything other than "Grails" from being considered acceptable, when "Create" is clicked below:

   

Congratulations, you've created, installed, and used your first Grails plugin!

static constraints = {
login(length:5..15,blank:false,unique:true)
password(length:5..15,blank:false)
email(email:true,blank:false)
age(min:new Date(),nullable:false)
}
}

constraints必须声明为static。

同时，每个属性的约束属性都有与之对应的错误消息（Error message code），当表单未能通过验证的时候，将会返回这些错误消息。
这些错误消息在grails-app/i18n/message.properties里定义。
例如我们要让User的email为空时返回"Please enter your email"，则可以在message.properties定义：
user.email.blank=Please enter your email
如果用户没有自定义错误消息，系统则会用默认的设置。当然默认的消息肯定不会是你想要的……

Grails提供很多验证属性，可以满足一些基本的验证需求：

blank
验证属性能否为空，不允许为空则设为false。
Note: 如果在form里为空而提交，则属性的值是一个空字符串，而不是null。
Example: login(blank:false)
Error message code: className.propertyName.blank

creditCard
如果要求属性为信用卡号码，则设为true。
Example: cardNumber(creditCard:true)
Error message code: className.propertyName.creditCard.invalid

email
如果要求属性为emial地址，则设为true。
Example: contactEmail(email:true)
Error message code: className.propertyName.email.invalid

inList
如果要求属性的值必须为规定的值，则定义规定的值。
Example: name(inList:["Joe", "Fred", "Bob"] )
Error message code: className.propertyName.not.inList

length
约束字符串或者数组的长度。
这个约束属性在0.5版本是被取消，用size代替。
Example: login(length:5..15)
Error message code:
className.propertyName.length.toolong
className.propertyName.length.tooshort

matches
应用正则表达式对字符串进行验证。
Example: login(matches:"[a-zA-Z]+")
Error message code: className.propertyName.matches.invalid

max
设定属性的最大值，值的类型必须跟属性一样。
Example:
age(max:new Date())
price(max:999F)
Error message code: className.propertyName.max.exceeded

maxLength
设定字符串或者数组的最大长度。
在0.5版本中被取消，由maxSize代替。
Example: login(maxLength:5)
Error message code: className.propertyName.maxLength.exceeded

maxSize
设定一个数字或者集合的最大大小。
在0.5版本中不被建议用在数字上，改用max。
Example: children(maxSize:25)
Error message code: className.propertyName.maxSize.exceeded

min
设定属性的最小值。类型必须跟属性一致。
Example:
age(min:new Date())
price(min:0F)
Error message code: className.propertyName.min.notmet

minLength
设定字符串属性或者数组属性的最小长度。
在0.5版本中被取消，由minSize代替。
Example: login(minLength:5)
Error message code: className.propertyName.minLength.notmet

minSize
设定一个数字或者集合的最小大小。
在0.5版本中不被建议用在数字属性上，改用min。
Example: children(minSize:5)
Error message code: className.propertyName.minSize.notmet

notEqual
验证属性的值是否跟指定的值相等。
Example: login(notEqual:"Bob")
Error message code: className.propertyName.notEqual

nullable
如果属性不可以为null，则设为false。
Note: 如果在表单里未填任何东西而提交时，则作为request parameter，属性的值为一个空字符串，而不是null。
Example: age(nullable:false)
Error message code: className.propertyName.nullable

range
限制属性的值在指定的范围里。
Example: age(range:minAge..maxAge)
Error message code:
className.propertyName.range.toosmall
className.propertyName.range.toobig

scale
版本0.4才开始出现的约束属性。
根据设定的scale数值，自动把浮点型数字小数点后的位数调整为设定的值。
适用于以下数值类型：java.lang.Float, Java.lang.Double, and Java.math.BigDecimal (and its subclasses)。
Example: salary(scale:2)
Error message code: 不返回错误信息

size
规定一个数值，集合或者字符串长度的大小。
在版本0.5中不被建议用在数字类型的属性上，改用range。
Example: children(size:5..15)
Note: 不能使用这个约束属性如果blank设为true或者nullable设为true。
Error message code:
className.propertyName.size.toosmall
className.propertyName.size.toobig

unique
如果属性必须为唯一，则设为true。
Example: login(unique:true)
Note: 有可能会发生通过unique验证但是在随后的数据库储存出现错误的情况。预防这种情况发生的方法是使用连续事务隔离级别或者进行eception的处理。
从版本0.5开始，unique的范围（Scope）可以被指定。"Scope"是同一个类里其他属性的名字，或者这些属性名字的一个list。
Example: group(unique:'department')
上面的例子里group名在一个department里是唯一的，但是可能在其他department里有相同名字的groups。
Another Example: login(unique:['group','department'])
在这个例子，login在group和department里必须是唯一的。可能在不同等group和department里会有相同的login。
Error message code: className.propertyName.unique

url
如果属性为一个URL地址，则设为true。
Example: homePage(url:true)
Error message code: className.propertyName.url.invalid

validator
在闭包里设定自定义的验证。
Example:
even( validator: {
return (it % 2) == 0
})
Error message code (default): className.propertyName.validator.invalid
将会在另外的文章里进行介绍。

class UserService {

    boolean transactional = true

    public boolean register(User user, UserInfo userInfo) throws RuntimeException {
        if (user.save()) {
            userInfo.user = user
            if (userInfo.save()) {
                return true
            } else {
                throw new RuntimeException ('ServiceException: UserService.register()...');
            }
        } else {
            throw new RuntimeException ('ServiceException: UserService.register()...');
        }
    }
}

class User {

...

    static constraints = {

userName(size:5..15, blank:false, unique:true)

password(size:5..15, blank:false)

email(email:true, blank:false)

age(min:18, nullable:false)

}

}

这样在你每次保存一个对象的时候都回去调用validate方法来验证.

当然你可以在任何实例上调用其validate方法去验证领域类.

def user = new User(params)

if(user.validate()) {

// do something with user

} else {

    user.errors.allErrors.each {

println it

}

}

如果你在注册的时候, 比如要输入两次密码, 这时候想把错误消息也放入领域类的errors属性里面, 由于领域类的 errors属性是Spring的Errors接口实例，

Errors接口提供了访问这些验证错误的方法，并且还可以取得原始的值。

具体使用的实现类是BeanPropertyBindingResult

Java.lang.Object

org.springframework.validation.AbstractErrors

org.springframework.validation.AbstractBindingResult

org.springframework.validation.AbstractPropertyBindingResult

org.springframework.validation.BeanPropertyBindingResult

每一个消息对应一个org.springframework.validation.ObjectError对象.所有可以想领域类的errors属性里面直接添加ObjectError对象就可以了.

 def error = new ObjectError('password', message(code:'pinpin.register.valid.password.notequal'))

 user.errors.addError(error)

def dataSource
    def list = {
      def template = new JdbcTemplate(dataSource)
      def userList = template.queryForList("select ui.name as name, u.password as password, ui.age as age, ui.email as email, ui.address as address  from user u, user_info ui where u.id = ui.id");
      def map = [userList : userList]

      render(view:"list", model:map)
    }

<table>
                    <thead>
                        <tr>
                            <g:sortableColumn property="name" title="Name" />

                            <g:sortableColumn property="password" title="Password" />

                                <g:sortableColumn property="email" title="Emial" />

                                <g:sortableColumn property="age" title="Age" />

                                <g:sortableColumn property="address" title="Address" />

                        </tr>
                    </thead>
                    <tbody>
                    <g:each in="${userList}" status="i" var="user">
                        <tr class="${(i % 2) == 0 ? 'odd' : 'even'}">
                            <td>${user.name}</td>
                            <td>${user.password}</td>
                            <td>${user.email}</td>
                            <td>${user.age}</td>
                            <td>${user.address}</td>
                        </tr>
                    </g:each>
                    </tbody>
                </table>

在特殊情况下，grails应用需要调用数据库的存储过程，这在grails的官方文档里边好像没有提到过，在james的blog里介绍如何解决这个问题。
    代码转贴如下

Java 代码

1. class MainController {  
2.   
3.   def dataSource // using the datasource we define in the spring's resources.xml  
4.   
5.   def index = {  
6.       Sql sql = new Sql(dataSource)  
7.       def row = sql.execute("call create_daily_hours(${new Date()+1})")  
8.   }  
9. }  

 需要说明的一些是：grails本身没有提供访问存储过程的便捷方法，而groovy的GSQL提供了，因此grails可以直接拿过来用了，当然也可以用spring的JdbcTemplate。
  希望对grails用户有点用。

原文地址：http://grails.group.javaeye.com/group/blog/86666



My experience with grails is getting richer the longer I use it for web application developing. It's very nice that grails is built on top of spring framework which we can take advantage of. I am not a spring user before but with a help from the nice people at the grails forum I was able to achieve what I want to do.

Calling a stored procedure from a MySQL database or any other database is simple. First we need a datasource which spring could provide for us. I have the following code place in the resources.xml found in the spring folder in your grails folder.

<bean id="dataSource" class=" org.apache.commons.dbcp.BasicDataSource ">
<property name="driverClassName">
    <value>org.hsqldb.jdbcDriver</value>
</property>
<property name="url">
    <value>jdbc:hsqldb:hsql://localhost</value>
</property>
<property name="username">
    <value>sa</value>
</property>
<property name="password">
    <value></value>
</property>
</bean>

I use connection pooling for better performance. In my controller here is how I use the datasource to call a store procedure.

class MainController {

 def dataSource // using the datasource we define in the spring's resources.xml

 def index = {
      Sql sql = new Sql(dataSource)
      def row = sql.execute("call create_daily_hours(${new Date()+1})")
 }
}

That's it! Notice that I am using Groovy SQL instead of Spring JDBCTemplate. It's a lot more friendlier for a beginner.

Grails really makes everything easy here and provides a lot of flexibility thanks to it's nice integration with spring. From here everything is possible.

原文地址：http://james-says.blogspot.com/2007/03/grails-little-of-spring-framework.html

先说一下grails的web.xml的产生过程

Grails的web.xml是在Package.groovy的generateWebXml target中生成的。可以在%Grails_Home%/scripts下找到它。其实在运行grails war时也是先走的这一步。

在generateWebXml里

1.先判断有没有config.grails.config.base.webXml属性，如果有，则使用指定的config.grails.config.base.webXml值作为最终的web.xml

2.如果没有config.grails.config.base.webXml属性。再判断是否存在%Project_Home%/src/templates/war/web.xml，如果存在就使用这个作为最终的web.xml

3.如果上面两个都没有，就使用%Grails_Home%/src/war/WEB-INF/web${servletVersion}.template.xml作为最终的web.xml

根据上面的顺序，我们有3个方法来指定web.xml

第一，可以修改 %Project_Home%/grails-app/conf/Config.groovy 文件，在文件中添加
grails.config.base.webXml = "file:${basedir}/web.xml"
其中${basedir}代表%Project_Home%，就是说会将%Project_Home%/web.xml作为最终的web.xml。

第二，使用 grails install-templates 命令，它会创建%Project_Home%/src/templates/war/web.xml 文件。这样只要修改这个web.xml就行了。

第三，修改%Grails_Home%/src/war/WEB-INF/web${servletVersion}.template.xml文件，但是最好不要这样做。

这里使用Grails 1.0.1

    static mapping = {
         id generator:'uuid.hex', params:[separator:'-']
    }
}

class Country {
    String id
    String name
    Boolean active = true

    static mapping = {
         id generator:'uuid.hex'
    }
}
这样就生成格式为: 2c9d004d1b247311011b2473ebf90003

Grails支持一些不同的方法来产生XML和JSON响应。第一个是隐式的通过render方法。

render方法可以传递一个代码块来执行标记生成器产生XML

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

这段代码的结果将会像这样：

<books>
<book title="The Stand" />
<book title="The Shining" />
</books>

注意，当你使用标记生成器时，必须小心避免命名冲突。例如，这段代码将产生一个错误：

def list = {
def books = Book.list()  // naming conflict here
render(contentType:"text/xml") {
books {
for(b in results) {
book(title:b.title)
}
}
}
}

原因是，这里的一个本地变量books企图作为方法被调用。

使用render方法输出JSON

render 方法可以同样被用于输出JSON:

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

在这种情况下，结果就会是大致相同的：

[
{title:"The Stand"},
{title:"The Shining"}
]

同样的命名冲突危险适用于JSON生成器。

自动XML列集(Marshalling)

（译者注：在此附上对于列集(Marshalling)解释：对函数参数进行打包处理得过程，因为指针等数据，必须通过一定得转换，才能被另一组件所理解。可以说列集(Marshalling)是一种数据格式的转换方法。）

Grails同样支持自动列集(Marshalling)领域类为XML通过特定的转换器。

首先，导入grails.converters 类包到你的控制器（Controllers）中：

import grails.converters.*

现在，你可以使用下列高度易读的语法来自动转换领域类成XML：

render Book.list() as XML

输出结果看上去会像下列这样：

<?xml version="1.0" encoding="ISO-8859-1"?>
<list>
<book id="1">
<author>Stephen King</author>
<title>The Stand</title>
</book>
<book id="2">
<author>Stephen King</author>
<title>The Shining</title>
</book>
</list>

一个使用转换器的替代方法是使用Grails的codecs特性。codecs特性提供了encodeAsXML和encodeAsJSON方法:

def xml = Book.list().encodeAsXML()
render xml

自动JSON列集(Marshalling)

Grails同样支持自动列集(Marshalling)为JSON通过同样的机制。简单替代XML 为JSON

render Book.list() as JSON

输出结果看上去会像下列这样：

[
{"id":1,
"class":"Book",
"author":"Stephen King",
"title":"The Stand"},
{"id":2,
"class":"Book",
"author":"Stephen King",
"releaseDate":new Date(1194127343161),
"title":"The Shining"}
]

再次作为一种替代，你可以使用encodeAsJSON达到相同的效果

<bean class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<property name="maxUploadSize">
<value>1000000</value>
</property>
</bean>

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

import org.springframework.web.multipart.MultipartHttpServletRequest
import org.springframework.web.multipart.commons.CommonsMultipartFile

class UploadController {
    static String uploadDir = "uploadfile"
    def index = {
        render(view:"upload")
    }
    def save = {
        if (request instanceof MultipartHttpServletRequest) {
            MultipartHttpServletRequest multiRequest = (MultipartHttpServletRequest) request
            CommonsMultipartFile orginalFile = (CommonsMultipartFile) multiRequest.getFile("file")
            // 判断是否上传文件
            if (orginalFile != null && !orginalFile.isEmpty()) {
                // 获取系统默认文件路径分隔符
                def separator = System.getProperty("file.separator")
                println "file separator is ${separator} "
                // 获取原文件名称
                String originalFilename = orginalFile.getOriginalFilename()
                // 获取上传文件扩展名
                def extension = originalFilename.substring(originalFilename.indexOf(".") + 1)
                println "extension is ${extension}"
                def name = ".." + separator + uploadDir + separator + orginalFile.getOriginalFilename()
                println "file name is : ${name}"
                // 使用存放文件的绝对路径创建输出流
                 /**
                DataOutputStream out = new DataOutputStream(new FileOutputStream(name))
                InputStream is = null
                try {
                    is = orginalFile.getInputStream()
                    byte[] buffer = new byte[1024]
                    while (is.read(buffer) > 0) {
                      out.write(buffer) // 写入磁盘
                    }
                } catch (IOException exception) {
                    exception.printStackTrace()
                } finally {
                    if (is != null) {
                        is.close()
                    }
                    if (out != null) {
                        out.close()
                    }
                }
                */
                orginalFile.transferTo(new File(name))
                render(view:"success")
            }
          
        } else {
            println "No multipart"
        }
    }
}

  def format = attrs.get('format')
  if (!format) {
   format = "yyyy-MM-dd HH:mm:ss z"
  }

  out << new Java.text.SimpleDateFormat(format).format(date)
 }

 def formatNumber = { attrs ->
  def number = attrs.get('number')
  
  if (!number) {
   number = new Double(0)
  }

  def format = attrs.get('format')
  if (!format) {
   format = "0"
  }

  out << new Java.text.DecimalFormat(format).format((Double)number)
 }
}

• 要求安装JDK1.4或以上版本
• 设置JAVA_HOME环境变量，指向JDK安装位置

2、安装Grails

• http://grails.codehaus.org/下载最新的Grails版本 
• 将压缩包解压到合适的位置
•  设置GRAILS_HOME环境变量，指向Grails安装位置
• 将%GRAILS_HOME%\bin追加到PATH环境变量中
• 在命令行执行grails，如果显示Grails的版本信息，表示安装成功！