Marshal's Blog » groovy

Grails实现zip文件上传及加入文件方案

Marshal — Tue, 19 Jul 2011 02:54:07 +0000

使用Grails和Groovy，实现了这样的需求：

zip文件上传
zip文件上传后，在zip文件中加入自定义文本文件

在Grails实现复杂的数据录入上实现的本示例。示例如图：

准备工作：文件上传

首先说一下文件上传，在Grails中，借助Spring MVC的底层支持，实现还是很容易的。

视图：

在这里hidden了一个参数，是用于服务器端使用的。

在服务器端获取文件对象和id：

def uploadFile={
def id=params.id
def file=request.getFile("myFile")

下面的问题是：

如何异步的处理zip文件，同步处理是不可能的，那样浏览器端可能长期得不到响应
怎样向zip文件中加入文本文件
怎样动态生成文本文件，本例中是xml文件

异步并发的实现

先说异步问题，我希望尽量回避线程，简化开发，这样可以让具体实现人员比较容易上手。这里使用了java的并发api，可参见这里[cref 3801]。

写法类似这样：

class BookController {

ExecutorService executorService=Executors.newFixedThreadPool(2)

创建了个实例变量，允许2个并发。

可这样调用：

executorService.submit(new Runnable(){
public void run() {

如何向zip文件中加入文件

时间原因，没时间看apache commons compress等api是否能实现这个功能了。直接招呼java标准zip的api了。

基本思路是创建新的zip文件，将原zip文件中的各个entry加入到新的zip文件输出流中，最后，将自己的文本文件加入。

这里补充一句，从Grails中得到的file对象，生命周期应该是request作用域的。即，当上传文件请求到达服务器端后，在临时目录创建文件保存请求中的文件流。这个文件不可能长期保存，因为那样系统可能会因为文件增长瘫痪的。一般是通过一个Filter在生成响应发送给浏览器后删除本地的临时文件。

这样的话，异步线程的生命周期肯定会超过这个生命周期，因此要在request作用域内把该临时文件先复制到另外的目录下：

def path=request.session.servletContext.getRealPath("/WEB-INF")

def sourceFile=new File("""${path}/${id}.zip""")
def distFile=new File("""${path}/${id}-dist.zip""")

file.transferTo(sourceFile)

下面是完整的生成新zip文件，并且加入文本文件的代码：

executorService.submit(new Runnable(){
            public void run() {
                ZipFile zipFile=new ZipFile(sourceFile)
                ZipOutputStream outputStream=new ZipOutputStream(new FileOutputStream(distFile))
                Enumeration entries=zipFile.entries()
                while(entries.hasMoreElements()){
                    ZipEntry entry=entries.nextElement()
                    entry=new ZipEntry(entry.name)
                    println entry
                    outputStream.putNextEntry(entry)

                    if(!entry.isDirectory()){
                        InputStream inputStream=zipFile.getInputStream(entry)
                        byte[] buffer=new byte[1024*1024]
                        for(int i=inputStream.read(buffer);i!=-1;i=inputStream.read(buffer)){
                            outputStream.write(buffer,0,i)
                        }
                        inputStream.close()
                    }

                    outputStream.closeEntry()
                }
                zipFile.close()

                ZipEntry attachEntry=new ZipEntry("book.plist")
                outputStream.putNextEntry(attachEntry)

                InputStream inputStream=new FileInputStream(attachedFile)

               outputStream.write(getResults(id).getBytes())

                inputStream.close()

                outputStream.closeEntry()

                outputStream.close()
                println ">>>> zip create ok."
            }
        })

其中黑体中调用的是解决动态生成文本的内容，这里假定write方面里面的参数是String即可，是String.getBytes()。

动态生成自定义xml文本

这里可参阅groovy生成xml，这里使用到了MarkupBuilder。

代码如下：

    def getResults(def bookId){
        def writer=new StringWriter()
        def xmlResults=new MarkupBuilder(writer)

        xmlResults.plist(version:1.0){
            dict{
                key ‘key’
                string ’12′
            }
        }

        def content="""
http://www.apple.com/DTDs/PropertyList-1.0.dtd">
${writer}
        """

        return content
    }

生成的文本类似这样：

http://www.apple.com/DTDs/PropertyList-1.0.dtd">

key
12

完整源代码见：

http://easymorse.googlecode.com/svn/tags/BookProto-0.5/

Grails图书示例纠正bug

Marshal — Tue, 12 Jul 2011 04:39:36 +0000

在Grails实现复杂的数据录入中有一个bug，当新建图书，选择相关图书时，如果选择了相关图书，再次选择，还是出现全部已保存图书。

改动代码见下面：

//对话框获取符合条件的相关图书
def getNotRelatedBooks={
    def bookId=params.id
    def relatedIds=request.getParameterValues(‘related_id’)
    def notRelatedBooks=[]

    def hql=’from Book b ‘

    /*
    if(params.id){
        def relatedIds=request.getParameterValues(‘related_id’)
        hql+=’ where b.id not in (‘

        if(relatedIds && relatedIds.size()>0){
            relatedIds.each { relatedId-> hql<<="""’${relatedId}’,""" }
        }

        hql<<="""’${bookId}’)"""
    }
    */

    if(bookId || relatedIds){
        def idList=[]

        if(bookId){
            idList.add(bookId)
        }

        if(relatedIds){
            idList.addAll(relatedIds)
        }

        def notInIdsString=""
        for(int i=0;i            notInIdsString+="""’${idList[i]}’"""
            if(i                notInIdsString+=","
            }
        }

        hql+=""" where b.id not in ( ${notInIdsString} )"""
    }


    notRelatedBooks=Book.findAll(hql)

    render(contentType:"text/json"){
        array{
            for(b in notRelatedBooks){
                book id:b.id, name:b.name
            }
        }
    }
}

其中注释掉的代码块，是错误的部分。

完整的项目代码，见：

http://easymorse.googlecode.com/svn/tags/BookProto-0.4/

Grails编写断点续传服务器端

Marshal — Mon, 11 Jul 2011 15:18:47 +0000

在测试Tomcat对断点续传的支持中发现，Tomcat是支持静态内容的断点续传的，但是，它无法支持动态内容的断点续传。比如我有一些客户定制化数据，只有登录的用户才能下载。如果放在静态目录下，安全就形同虚设。

因此，在Grails中一般要放在WEB-INF目录的子目录下。比如：

这样的内容需要自己创建文件，然后输出到response的输出流上。因此断点续传必须自己实现。

还是在Grails实现复杂的数据录入基础上做的改动：

class BookController {

    def book

    def image={
        def imageFile=new File(request.session.getServletContext().getRealPath("/WEB-INF/images/grails_logo.png"))
        def range=request.getHeader(‘Range’)
        int rangeValue=0

        if(range){
            rangeValue=Integer.parseInt(range.substring (6, range.length()-1))
            response.setStatus(206)
        }

        def imageData=null

        if(range){
            def inputStream=new FileInputStream(imageFile)
            imageData=new byte[imageFile.length()-rangeValue]
            inputStream.skip(rangeValue)
            inputStream.read(imageData, 0, imageData.length)
        }else{
            imageData=imageFile.readBytes()
        }

        //response.setHeader("Content-disposition", "attachment; filename=grails.png")
        response.contentType =’image/jpeg’
        response.addHeader "Content-Length", ""+(imageData.length)
        response.outputStream<        response.outputStream.flush()
    }

用测试Tomcat对断点续传的支持中的java程序测试，结果分别是：

content length: 10172
status code:200
1:137
2:80
3:78
4:71
5:13
6:10
7:26
8:10
9:0
10:0
11:0

content length: 10169
status code:206
1:71
2:13
3:10
4:26
5:10
6:0
7:0
8:0
9:13
10:73
11:72

和测试Tomcat对断点续传的支持一致，说明实现是成功的。

完整的源代码见：

http://easymorse.googlecode.com/svn/tags/BookProto-0.3/

使用Grails flash作用域

Marshal — Mon, 11 Jul 2011 12:18:54 +0000

Grails引入了flash作用域的概念。这是很多高级web框架都引入的概念了。在Servlet中没有这个作用域。如果要处理这样的场景，比如更新（新建）表单提交，又重定向到表单页面，用户看不到什么变化。

比如这个界面（详见Grails实现复杂的数据录入），保存前后，都是相同的界面和相同的链接。无法让客户看出是否真的更新了。

以前的解决办法，一般有两条：

写个javascript alert，提示客户
在页面中增加提示

那么问题是，如何让这个页面知道是保存过了呢？也有两个办法：

在url中增加内容，比如：http://localhost:8080/BookProto/book/edit/9?message=1，重定向回来就可以根据这个message参数显示了
或者，可以在session作用域存放一个标记，等重定向后取出并删除

其实flash作用域就是基于session作用域做的，但是更方便。

首先在save方法中增加：

def save={
    book=new Book(params)
    book.save()

    flash.message="""图书（${book.name}）已保存。"""
    redirect(action:’edit’,id:book.id)
}

然后，在页面中可通过标签取出来：

这样当保存后重定向就是下面的样子了：

完整的源代码见：

http://easymorse.googlecode.com/svn/tags/BookProto-0.2/

Grails实现复杂的数据录入

Marshal — Mon, 11 Jul 2011 11:50:13 +0000

本示例由Grails实现备选相关图书修改而来。前者存在一些问题，在本示例中进行了纠正。

首先说一下实现的效果，新建图书：

点击增加按钮，可从图书列表中获取相关图书：

确认后并保存的样子：

下面完整的说一下做的过程。

实体关系

首先是分析图书实体的关系。这里应该是一对多关系：

实体只有一个，是自身的关联关系，代码：

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

    static hasMany=[relativeBooks:Book]

    //String id
    String name
    List relativeBooks=[]
}

这里屏蔽了uuid的主键生成（Grails的GORM中使用uuid），是为了测试方便。

为了开发测试方便，编写了加载初始数据代码：

class BootStrap {

    def init = { servletContext ->
        environments{
            development{
                def testBook=new Book(name:"中国史学史")

                testBook.relativeBooks.add(new Book(name:"中国通史"))
                testBook.relativeBooks.add(new Book(name:"中国农业史"))
                testBook.save()

                println """test book: ${testBook}"""
                println """test book relative books:${testBook.relativeBooks}"""

                new Book(name:"中国手工业史").save()
                new Book(name:"中国战争史").save()
                new Book(name:"中国科学技术史").save()
                new Book(name:"中国对外交流史").save()
            }
        }
    }
    def destroy = {
    }
}

详见Grails开发环境下如何生成模拟测试数据。

界面的实现

界面使用了SiteMesh，并在SiteMesh模板中集成了jQuery，详见使用Grails布局功能。

完整的edit.gsp源代码：

编辑图书






                书名：






                相关图书：

注释比较清楚了。这里提个和url有关的事情。资源文件比如图片一般放在wepapp/images目录下，以前jsp是比较麻烦的，gsp的写法：

如果是controller的url，可以类似这样：

var url="${createLink(controller:’book’,action:’getNotRelatedBooks’,id:book?.id)}"

如果是form，也可以使用标签：

下面说说controller部分。

控制器

在本例中，有3个控制器代码：

edit，显示空的图书表单页，如果带id参数则显示填充图书记录的页面
getNotRelatedBooks，用于对话框异步获取可选择的相关图书
save，保存，如果是新记录，创建，已存在的，更新

完整的源代码：

class BookController {

    def book

    //编辑，用于新建和修改
    def edit={
        book=Book.get(params.id)
    }

    //保存，新建和修改的保存
    def save={
        book=new Book(params)
        book.save()

        redirect(action:’edit’,id:book.id)
    }

    //对话框获取符合条件的相关图书
    def getNotRelatedBooks={
        def bookId=params.id
        def notRelatedBooks=[]

        def hql=’from Book b’

        if(params.id){
            def relatedIds=request.getParameterValues(‘related_id’)
            hql+=’ where b.id not in (‘

            if(relatedIds && relatedIds.size()>0){
                relatedIds.each { relatedId-> hql<<="""’${relatedId}’,""" }
            }

            hql<<="""’${bookId}’)"""
        }

        notRelatedBooks=Book.findAll(hql)

        render(contentType:"text/json"){
            array{
                for(b in notRelatedBooks){
                    book id:b.id, name:b.name
                }
            }
        }
    }
}

也可以从这里下载完整的项目：

http://easymorse.googlecode.com/svn/tags/BookProto-0.1

Grails实现备选相关图书

Marshal — Sun, 10 Jul 2011 09:17:01 +0000

比如，由管理员手工挑选图书的相关图书。从用户体验上，这个选择，应该是异步的。即使用ajax。

当用户在图书编辑页面时，点击相关图书的增加按钮，应该弹出对话框，对话框中包含了可选的备选图书。

这里要保证，如果是编辑（不是新的图书），那么不能包含自身，也不能包含已经选择了的相关图书。

这里还是在Grails创建和更新实体使用相同的视图基础上做的修改。

首先，要矫正Grails实现实体自身多对多的变通方案中的一处错误。对SortedSet的错误使用。它并不是为了对集合结果做按照添加次序存储的，而是通过Compare接口比较来做排序的。因此把BookRelation改为：

package bookproto

class BookRelation {

    static constraints = {
    }

    static hasMany=[books:Book]
    static belongsTo=[book:Book]
}

而后，为了制造测试数据，即，测试图书必须包含多个图书，另外，要有一些图书是不属于测试图书的相关图书的。这里需要类似Grails开发环境下如何生成模拟测试数据，做一些改动：

import bookproto.Book
import bookproto.BookRelation;

class BootStrap {

    def init = { servletContext ->
        environments{
            development{
                def testBook=new Book(name:"中国史学史")

                def relatedBooks=[]
                def book=new Book(name:"中国通史")
                book.save()
                println """related book id: ${book.id}"""
                relatedBooks.add(book)

                book=new Book(name:"中国农业史")
                book.save()
                println """related book id: ${book.id}"""
                relatedBooks.add(book)

                testBook.bookRelation=new BookRelation(book:testBook,relatedBooks:relatedBooks)
                testBook.save()
                println """test book id: ${testBook.id}"""

                book=new Book(name:"中国战争史")
                book.save()

                book=new Book(name:"中国商业发展史")
                book.save()

                book=new Book(name:"中国科学技术史")
                book.save()
            }
        }
    }
    def destroy = {
    }
}

下面是编写controller对应的方法：

def getNotRelatedBooks={
    def bookId=params.id
    def notRelatedBooks=[]

    if(params.id){
        def relatedIds=request.getParameterValues(‘related_id’)
        def hql=’from Book b where b.id not in (‘

        if(relatedIds && relatedIds.size()>0){
            relatedIds.each { relatedId-> hql<<="""’${relatedId}’,""" }
        }

        hql<<="""’${bookId}’)"""

        notRelatedBooks=Book.findAll(hql)
    }

    render(contentType:"text/json"){
        array{
            for(b in notRelatedBooks){
                book id:b.id, name:b.name
            }
        }
    }
}

这里需要注意的是以下几个地方：

针对同名的多个参数传递，测试了一下，grails识别的不好，因此直接使用servlet的api，即：request.getParameterValues获取了字符串数组
hql的使用，这里的not in写法，效率不高，因为客户的数据量不大，先这样写
使用render方法，返回json数据

测试是否成功，比如发送get请求，url：

http://localhost:8080/BookProto/book/getNotRelatedBooks?id=4028802c-311343b6-0131-1343c6d7-0003&related_id=4028802c-311343b6-0131-1343c69b-0001&related_id=4028802c-311343b6-0131-1343c6a7-0002

然后，获得的数据类似这样：

[{"id":"4028802c-311343b6-0131-1343c6fa-0004","name":"中国战争史"},{"id":"4028802c-311343b6-0131-1343c6fe-0005","name":"中国商业发展史"},{"id":"4028802c-311343b6-0131-1343c701-0006","name":"中国科学技术史"}]

检查了一下，没有问题。

Grails创建和更新实体使用相同的视图

Marshal — Sun, 10 Jul 2011 07:06:40 +0000

创建和更新实体，是使用相同的视图还是不同的视图。这需要权衡。如果我来写，一般我希望是相同的，即，无论是新建图书还是编辑图书，使用相同的gsp页面。好处是便于维护。如果新建和编辑的流程出入较大，也是出于维护的角度，可能会考虑使用不同的视图。

以下写个简单的使用相同视图实现创建和更新的示例。示例是在Grails开发环境下如何生成模拟测试数据基础上做了改动。

实现的效果类似这样，如果是新增，链接中没有参数，显示空白的表单页面：

否则：

先说一下服务器端代码：

class BookController {

    def book

    def edit={
        book=Book.get(params.id)
    }

很简单，就是根据id从数据库中查找得到book对象。当然get不到book对象，这里和hibernate的get方法类似，是返回null的。

客户端的html页面部分，通过gsp脚本，如果去到book对象，就把它赋值给javascript中的book对象。之后，判断如果js的book对象有值，则用改值初始化表单：

编辑图书

书名：

相关图书：

使用Grails布局功能

Marshal — Sun, 10 Jul 2011 06:52:08 +0000

Grails使用的是SiteMesh。这是最早在WebWork下使用的布局引擎。但是随着Struts的普及，Tiles的使用远远超过了SiteMesh。不过SiteMesh实现的布局很简介优雅，不需要编写很多劳什子的布局xml文件。

现在SiteMesh集成进Grails，使用起来也更简单了。下面的截图，就是使用SiteMesh的页面。

Grails已经生成了默认的布局文件，在这里：

我在这个文件中加上了JQuery的支持：

        <g:layoutTitle default="Grails" />














http://grails.org">

对这部分有不明白的，参加这里Grails从1.4m1版本回退到1.3.7。

如果希望自己的gsp页面，使用这个布局，也很简单：

编辑图书

……

只需加上斜体字部分即可，content的值，对应布局文件的名称。

Grails开发环境下如何生成模拟测试数据

Marshal — Sun, 10 Jul 2011 06:36:52 +0000

开发环境下经常需要一些模拟测试数据。比如数据库中要有一些初始的实体。Grails提供了很好的办法。可在BootStrap.groovy中：

编写只针对开发环境的初始化代码：

import bookproto.Book

class BootStrap {

    def init = { servletContext ->
        environments{
            development{
                def book=new Book(name:"中国史学史")
                book.save()
                println """book id: ${book.id}"""
            }
        }
    }
    def destroy = {
    }
}

以上示例是在Grails的GORM中使用uuid基础上做的处理。

Grails的GORM中使用uuid

Marshal — Fri, 08 Jul 2011 07:22:49 +0000

开发中，有很多情况需要使用不连续的随机生成的唯一标识。好处是：

可以隐藏商业细节，比如生成订单，自增列会暴露商业秘密
另外，自增列往往依赖数据库生成，对集群和分布式部署应用有影响，还有就是导入数据时需要对数据库自增列做设置

因此，使用uuid做实体唯一标识的地方很常见。在Grails实现实体自身多对多的变通方案基础上，把默认的native生成主键的方式改为使用uuid：

class Book {

    static constraints = {
        bookRelation(nullable:true)
    }

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

   String id
    String name
    BookRelation bookRelation
}