如果要列举近些年来Java领域中最令人激动的事件，Grails的诞生绝对应该榜上有名。在打开Grails官方网站时， 你会在浏览器的标题栏上看到这样的内容：“Grails - 寻找就此结束”。虽然这句话不见得适用于所有场合，但对于不少从事Java Web开发的人来说，赞同者恐怕不在少数。由于具备Rails风格的框架、兼容绝大多数Java语法的Groovy动态语言、以业界口碑良好的框架为基 础、对企业现有Java开发资产的保护、Plugin架构等特点，再加上Spring社区的强力介入，Grails行情看涨应该是意料之中的。

然而Grails却没有看上去那么简单，在其包装的糖衣之下，有着许多作为Java Web开发者不得不了解的知识。最近，Peter Delahunty发表了题为Grails开发者需要知道的10个技巧的博文。不要被标题所迷惑了，这里所说的“技巧”可不是那些语言层面的“技巧”，把它们称为“建议”恐怕更合适一些。

技巧1：把Grails的书籍买来读读。对此，Peter Delahunty推荐了已出版的《Definitive Guide to Grails 2nd edition》和《Groovy and Grails Recipes》，以及即将出版的《Grails in Action》。

技巧2：学习Groovy，并按照Groovy进行思考。Peter Delahunty通过一个例子说明了Java思维和Groovy思维的不同。

这儿有个好例子：

传播操作符（spread operator）：*

在Java中，要想遍历一组人并收集人名。我可能得这样写：

List names = new ArrayList();



for (Iterator iterator = people.iterator(); iterator.hasNext();) {



Person person = (Person) iterator.next();



names.add(person.getName());



}



System.out.println(names);

用Groovy，我会这么写：

def names = people*.name



println names

呵呵，简单吧。我还可以这样写：

def names = people.collect {it.name}



println names

在这个建议中，他列举了一些资源：

• Groovy官方网站
• PLEAC

以及一些书籍：

• Programming Groovy
• Groovy Recipies
• Groovy in action

技巧3：了解Grails的各个插件。Peter Delahunty给出的理由：Grails本身是个插件系统，而且现在已经有大量的插件可供下载。在自行实现之前，不妨看看其中是否有称手的。

技巧4：学习Hibernate和Spring。这一点不难理解，既然Grails是建立在这些工具之上的，了解这些工具本身的使用，对于熟练使用Grails自然大有脾益。

技巧5：使单元测试、集成测试和一般测试的自动化。Peter Delahunty在这里推荐了两个Grails的插件：Testing Plugin和Functional testing plugin。前者将成为Grails 1.1的内置插件。

技巧6：使用好的IDE。Peter Delahunty表示，他自己使用的是Intellij，但对于Netbeans也寄予厚望。

技巧7：学习并使用HTML W3C标准。“遵循标准将消除你90%的问题”，Peter Delahunty如是说。

技巧8：看上去不错一定不错。这其实说的是“面子工程”，通过提高应用的外观设计来提高应用的竞争力。Peter Delahunty给出了2个资源：

• 99designs.com
• 圆角矩形产生器

技巧9：使用Firefox上的Firebug。对于浏览器端的调试工作，Firebug绝对是一个必备工具。

技巧10：跟上Groovy和Grails社区的步伐。在这最后一个建议中，Peter Delahunty给出了获取Groovy和Grails信息的主要资源链接：

• Grails官方网站
• Groovy和Grails相关的博客
• Grails创始人Graeme Rocher的Twitter
• Groovy项目领导人Guillaume Laforge的Twitter
• Groovyblogs.org的创始人Glen Smith

请务必阅读Peter Delahunty的原文。对于Grails的新老使用者，你都可以从Peter Delahunty的建议中有所收获。关于InfoQ中文站Groovy和Grails的其它内容，请访问这里和这里。

Grails automatically creates Eclipse project and classpath files for you. The Groovy plugin is helpful for working with Grails projects, but not required in order to import a project: do not rely on it for assistance.To import a Grails project just right-click in the "Package Explorer" and select "Import" then "Existing project into Workspace" and "Browse" to the location of your project.

Then immediately click "Ok" followed by "Finish" and your project will be set-up. Using other methods of importing the project may prove to be problematic due to compile location.

There is a known issue that Grails will not run properly if you try to use the root directory of your drive as your project, or paths with spaces.

Setting up Eclipse Environment Variables

You will need to create an Eclipse classpath variable called GRAILS_HOME that points to the location where you installed Grails for the project to build successfullly by going to Windows -> Preferences… -> Java -> Build path -> Classpath Variables -> New.

If you don't already have GRAILS_HOME as part of your standard environment, in order to run your Grails project, you will need to establish that value in the Run dialog (Run...) under the Environment tab, to the same value as above.

If your Grails project has Grails plugins installed then you will need to add the directories directly under the plugins/src/ folder to your Eclipse source path. This is done through right clicking on the folder (usually called "Groovy" or "Java") then selecting build path -> source folder. Otherwise you may get errors in the import statements.

Also, if you are using JSP you will need to add your JDK's tools.jar library to your project classpath otherwise jetty will display compilation errors. See this page for info: http://nuin.blogspot.com/2005/05/launch-jetty-from-eclipse-solving.html

If you are using the Eclipse Groovy plugin then make sure you enable the preference 'Disable Groovy Compiler Generating Class Files' (newer versions: Project -> Preferences -> Groovy Project Preferences / older versions: Windows -> Preferences -> Groovy Preferences). By default this option is disabled and generates class files for your groovy files, and stores them in the basedir of your Grails project. When these class files are generated, unexpected behaviour is encountered like not able to generate controllers and views for your domain classes.

THIS DOES NOT APPLY IF YOU INTEND TO USE DEBUGGING (read the section 'Step debugging' below)

Running a Grails application

Grails also automatically creates an Eclipse run configuration for you. To run the project you are in use the "Run" dropdown to open the "Run" dialog then under "Java Applications" find the name of your project select it and click "Run". The Grails application will load embedded inside Eclipse, any changes made inside the Eclipse project can be auto-reloaded.

If you are getting exceptions like

org.mortbay.util.MultiException[java.io.FileNotFoundException: {yourpath}/web-app]

at org.mortbay.http.HttpServer.doStart(HttpServer.java:731)

at org.mortbay.util.Container.start(Container.java:72)

at grails.util.GrailsMain.main(GrailsMain.java:67)

grails dev package

For some other errors or quirky behavior, it is often helpful to run the command

grails clean

Step Debugging with Eclipse

You can step debug a Grails application if you install the latest build of the Groovy Eclipse plug-in.

Eclipse debugging depends on the class files generated by the Groovy compiler, so make sure 'Disable Groovy Compiler Generating Class Files' is not checked (Project -> Properties -> Groovy Project Properties) and the output folder is set to e.g. "bin-groovy". Then edit the ".classpath" file in your project directory and manually remove the entry for "bin-groovy".

• Open up the Groovy file you want to debug (lets say a controller called {{BookController.groovy}}) then set a break point on the line you want to stop at. (set a breakpoint by double clicking in the far left "gutter")
• Now debug the application in the same way as you did in the above section on "Running a Grails application" except with the "Debug" menu.
• Load your browser and navigate to the action that calls the code.

Adding domain classes etc.

You can configure grails as an "External Tool", allowing you to create domain classes etc. from within Eclipse:

1. Select "Run > External Tools > External Tools Configurations...".
2. Double-click "Program"
3. Enter a name of "Grails".
4. Browse the file system for the location of grails or grails.bat.
5. Set the working directory to "${project_loc}".
6. Set the arguments as "${string_prompt}".
7. Under the "Refresh" tab, set to refresh the "project containing the selected resource" upon completion.
8. Under the "Common" tab, tick "Display in favorites menu".

1. Choose "Grails" from the external tools drop-down.
2. Enter "create-domain-class" in the dialogue box.
3. In the console window, follow the prompts as normal.
4. Open your new class from grails-app/domain.

Editing GSP files

The gsp files are just jsp files with a special taglib. The extension gsp has to be added as follows:

• General -> Editors -> File Associations: add *.gsp and link the JSP Editor to it.
• General -> Content Types Fold out Text -> JSP and add *.gsp

<%@ taglib prefix="g" uri="/web-app/WEB-INF/tld/grails.tld" %>

Unit Tests

To run Grails/Groovy unit tests, the easiest way is just to create a junit run configuration, but specifying "groovy.util.AllTestSuite" as the main class. More info on general groovy unit testing in grails here

To run a single test, create a run-config as described above or duplicate an existing entry. Select "Run a single test", select your project and the test class. Save and test your config. You can also rerun a single test in the (g)unit test view by clicking with the right mouse button on an single test and selecting "Run".

Troubleshooting

1. If you getting the following error every time you save *.groovy file in your project:

An internal error occurred during: "Building workspace".

BUG! exception in phase 'conversion' in source unit '...' Error:

duplicate class declaration for name: … and class:

org.codehaus.groovy.ast.ClassNode@...[name:...]

• Right click on package explorer's project name and open "Properties..." dialog.
• Select "Builders" and make sure that "Groovy Builder" is checked.
• Select "Java Compiler/Building" and check "Enable project specific settings".
• Append "*.groovy" to "Filtered Resources" text field, to prevent ".groovy" files being copied to the output directory. Note that the path separator is "," not ";"
• Apply changes and close dialog.
• Clean your project. Make sure that the output directory doesn't contain "*.groovy" files
1. If Eclipse complains that it can not find the sources where breakpoints are set ensure the following:
• Step filtering is enabled for groovy.*, org.codehaus.* (more about this http://groovy.codehaus.org/Debugging+with+Eclipse )
• Build out put for the project is in a separate folder (say /bin ). Make sure this is present for Project->Properties->Groovy Project Properties
2. Few other recommendations:
• Make sure to add all the libraries from grails-app/lib folder to the project
• Using verbose logging/tracing through log4j.properties until everything works from the Eclipse IDE. Sometimes if some library is not found, unless it is printed in the console, it is difficult to find out what went wrong.
• Make sure to use the same JDK for tools.jar as well as the runtime jar rt.jar. Do note sometimes using the JRE instead of rt.jar causes problems.
• Sometimes "launch configuration" generated by grails is not in sync with the way ant's build.xml works. In Grails 0.3 ensure that following VM parameters (do note not program arguments, but VM arguments ) are set "-Dorg.mortbay.xml.XmlParser.NotValidating=true". Without this there will be XML Parser exception thrown when launched from the IDE.

Brute Force method:

If running from IDE has issues, most likely it is because some library is missing. Ensure that all libraries under GRAILS_HOME/dist, GRAILS_HOME/ant/lib, GRAILS_HOME/lib and your project folder/lib are added to the build path of the project.

class   User {

String name

String password



String toString() {

" $name : $password "

}



static  constraints  =  {

name(blank:  false )

password(blank:  false , size:  6 .. 16 )

}

class LoginController {

def loginService



def index = { }



def login = {

User u = new User()

u.properties = params

if (params.name && params.password) {



def user = loginService.check(u)



if (user) {

flash.message = "Welcome ${user.name}"

render(view: "ok", model: [user: user])

} else {

flash.error = "Invalid ${u.name} with ${u.password}"

render(view: "login", model: [user: u])

}

} else {

render(view: "login", model: [user: u])

}

}

}

class LoginService {



boolean transactional = true



def check(User u) {

def user = User.findWhere(name: u.name, password: u.password)

return user

}



def serviceMethod() {

// TODO

}

}

12、修改demo\grails-app\conf\ApplicationBootStrap.groovy，将一个User实例保存到数据库(grails自带hsqldb和jetty)中，内容如下：

class ApplicationBootStrap {



def init = { servletContext ->

new User(name: "demo", password: "123456").save()

}

def destroy = {

}

}

13、在“命令行”中，输入“grails run-app”，运行我们的Web应用