最近弄了个grails tinymce下的代码高亮插件：

界面图：

对话框：

渲染代码：

对文本的处理：

输入文本：

当然这个可能存在很多问题，不过如果大家有这个需要，可以联系我，打包给大家，让大家一起来完善。

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师

网上已经有用dreamweaver 8打开gsp文件 。那么这里我就介绍下用dreamweaver CS3打开gsp文件

基本原理还是一样的，只是修改的文件的位置不同：

1 打开dw CS3安装时的目录
  \Documents and Settings\username\Application Data\Adobe\Dreamweaver 8\Configuration,
在其中的extenstion.txt文件中的第一行，有很多文件后缀的，加入gsp
在最后一行，加入
gsp:grails文件。
  这样以后dw8里，打开的设置里，可以选出gsp的文件来打开
2 打开DW CS3安装路径\Adobe\Adobe Dreamweaver CS3\configuration\DocumentTypes\MMDocumentTypes.xml这个文件
找到"jsp"，加入gsp,如下
<documenttype id="JSP" servermodel="JSP" internaltype="Dynamic" winfileextension="jsp,jst,gsp" macfileextension="jsp,jst" file="Default.jsp" writebyteordermark="false">
这样打开gsp文件后，就可以切换到设计状态了，不用再是只看到代码状态的view了

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

经过我们大家的努力Grails中文文档终于面试了

下载抵制

beta版的url： http://www.chinagroovy.org/grails-doc/index.html ,beta 版下载: http://wiki.redsaga.com/confluence/download/attachments/2458/grails-doc-1.0-beta1.tar.gz

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师

正則表達式就像一把瑞士軍刀。

"potatoe" ==~ /potatoe/

 假如你在groovyConsole運行它，將返回true.這裡有兩件需要注意的事情：

1.==~操作符。它類似于==操作符，但是用於匹配模式而不是計算相等性。

2.正則表達式包含在 '/'中.它會告訴Groovy這是個正則表達式而不是String.

"potatoe" ==~ /potatoe?/

"potato" ==~ /potatoe?/

 這裡?表達的意思是'e'是可選的。

"motato" ==~ /potatoe?/

沒有可匹配的。

現在讓我來看些複雜的，我們定義一個方法用來測試正則表達式：

def checkSpelling(spellingAttempt, spellingRegularExpression)
{
if (spellingAttempt ==~ spellingRegularExpression)
{
println("Congratulations, you spelled it correctly.")
} else {
println("Sorry, try again.")
}
}
theRegularExpression = /Wisniewski/
checkSpelling("Wisniewski", theRegularExpression)
checkSpelling("Wisnewski", theRegularExpression)

這裡有兩件事情需要注意：

1.我們定義了函數

def checkSpelling(spellingAttempt, spellingRegularExpression)

函數是一個類似于閉包的代碼集合。函數通常擁有名字，然而閉包可以是匿名的，一旦我們定義了函數，我們就可以在以後重複使用。

在函數中的if語句中，我們判斷 spellingAttempt 參數時候匹配正則表達式通過使用==~操作符

theRegularExpression = /Wis[abcd]niewski/ // requires one of 'a', 'b', 'c' or 'd'
theRegularExpression = /Wis[abcd]?niewski/ // will allow one of 'a', 'b', 'c' or 'd', but not
required (like above)
theRegularExpression = /Wis[a-zA-Z]niewski/ // requires one of any upper\- or lower-case letter
theRegularExpression = /Wis[^abcd]niewski/ // requires one of any character that is '''not''' 'a',
'b', 'c' or 'd'

 這裡使用了 *[ ]*.用來分組字符

theRegularExpression = /Wis[abcd]niewski/ // requires one of 'a', 'b', 'c' or 'd'

需要'a', 'b', 'c' , 'd'其中的一個。

theRegularExpression = /Wis[abcd]?niewski/ // will allow one of 'a', 'b', 'c' or 'd', but not
required (like above)

需要'a', 'b', 'c' , 'd'其中的一個，但不是必須的，因為在[ ]後面跟隨了一個?

theRegularExpression = /Wis[a-zA-Z]niewski/ // requires one of any upper\- or lower-case letter

需要一個任意的大寫或小寫字符。

theRegularExpression = /Wis[^abcd]niewski/ // requires one of any character that is '''not''' 'a',
'b', 'c' or 'd'

任何一個不是''a', 'b', 'c' , 'd'

更多的正則表達式操作符可以去參考官方文檔。

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

(-)变量
你可以给变量赋值. 像下面:

x = 1
println x
x = new java.util.Date()
println x
x = -3.1499392
println x
x = false
println x
x = "Hi"
println x

 (二)Lists and Maps

Groovy已经内置支持两种重要的数据类型， lists 和maps（(Lists就像java中的数组一样来操作)）Lists用来存储有序集合数据，例如：

myList = [1776, -1, 33, 99, 0, 928734928763]

 你可以使用[]来存取给定的项（索引开始位置为0）：

println myList[0]

 输出结果：

1776

你也可以使用size方法来等到 list 长度：

println myList.size()

  输出结果：

6

但是通常你并不需要List的长度，因为不像Java,循环遍历一个List中的所有元素的首选方法是each(),详细信息在本学习笔记的"Code as Data"章节。

另一个本地数据结构叫 map,map用来存储”关联数组“或”词典“，即无序非均匀的集合，命名数据。例如，我们存储名字的IQ分数：

scores = [ "Brett":100, "Pete":"Did not finish", "Andrew":86.87934 ]

 注意，每个存储在map中的值都是不同的类型， Brett'是 integer，Pete是string, Andrew是floating 。

我们可以使用两种方法来访问map中的值：

println scores["Pete"]
println scores.Pete

 输出结果：

Did not finish
Did not finish

为map添加数据，语法与给list添加值类似，例如：

scores["Pete"] = 3

 随后取得其值：

println scores["Pete"]

 输出结果：

 3.

另外，你可以像下面这样创建空map和list:

emptyMap = [:](Map)
emptyList = [](List)

为了确定它们为空，可以像下列这样：

println emptyMap.size()
println emptyList.size()

 输出结果为0。

（三）Conditional Execution

任何一种语言的重要特性是在不同的条件下执行不懂的代码，简单的方法是使用"if":

amPM = Calendar.getInstance().get(Calendar.AM_PM)
if (amPM == Calendar.AM)
{
println("Good morning")
} else {
println("Good evening")
}

上面的结果是:首先，他会判断（）中表达式，随后依据结果是否为"true"或"false"来执行第一个或第2个代码块。注意"else"代码块不是必须的：

amPM = Calendar.getInstance().get(Calendar.AM_PM)
if (amPM == Calendar.AM)
{
println("Have another cup of coffee.")
}

（四）Boolean Expressions

在很多编程语言中这个是很特别的数据类型，它用来表示真实值，”true“或"false".Boolean就像其他数据类型一样可以储存在一个变量中：

myBooleanVariable = true

 更多Boolean表达式操作符:

* ==
* !=
* >
* >=
* <
* <=

 他们相当直观：

titanicBoxOffice = 1234600000
titanicDirector = "James Cameron"
trueLiesBoxOffice = 219000000
trueLiesDirector = "James Cameron"
returnOfTheKingBoxOffice = 752200000
returnOfTheKingDirector = "Peter Jackson"
theTwoTowersBoxOffice = 581200000
theTwoTowersDirector = "PeterJackson"
titanicBoxOffice > returnOfTheKingBoxOffice  // evaluates to true
titanicBoxOffice >= returnOfTheKingBoxOffice // evaluates to true
titanicBoxOffice >= titanicBoxOffice         // evaulates to true
titanicBoxOffice > titanicBoxOffice          // evaulates to false
titanicBoxOffice + trueLiesBoxOffice < returnOfTheKingBoxOffice + theTwoTowersBoxOffice  //
evaluates to false
titanicDirector > returnOfTheKingDirector    // evaluates to false, because "J" is before "P"
titanicDirector < returnOfTheKingDirector    // evaluates to true
titanicDirector >= "James Cameron"           // evaluates to true
titanicDirector == "James Cameron"           // evaluates to true

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛

关于Grails乱码的问题

个人测试了以后

还是属于编辑器的问题

对于IDEA来说安装后，默认的使用系统编码（GB2312），我们最好是设置成UTF-8

其实挺简单的

按照下面图中的步骤，就可以在IDEA中解决Grails乱码的问题

选择Settings-->General修改下图的编码设置就OK了！

对于其他网站说的修改文件，在这里就没有必要了，不需要修改任何文件

如果你把grails.views.gsp.encoding="UTF-8"修改成GBK的话，编辑器里不会出现乱码，但是网页中显示的将会是乱码，毕竟你设置了两个不同的编码！

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛

翻译自《Groovy in action》，如有不准确之处，希望指教！

closures（闭包）很重要，非常的重要！！！可以被认为是Groovy中一个非常有用的特性。同时，在你没有完全了解它之前会是一个陌生的概念。为了发挥Groovy最大功效，或者了解任何其他Groovy代码，它将肯定让你感觉轻松。不只是“一次婚礼上遇见它们”的轻松，而是“邀请它们参加周末烧烤”的轻松。（注原文： Not just
“met them once at a wedding” comfortable, but “invite them over for a barbecue on
the weekend” comfortable.）

此刻，我不是想吓跑你，closures（闭包）并不难---它只是不同于任何你过去习惯的事物。某种程度上，它是陌生的，因为在面向对象中一个首要的原则是对象拥有行为和数据。closures（闭包）是对象，在它的生命里最主要的目的是它们的行为---这几乎是他们的所有。

在这节我们将介绍closures（闭包）的基本概念，阐明它们的好处。然后，展示他们是怎样被定义和调用的。讨论基础之后，我们将更深入的探讨closures（闭包）中使用其他的方法和closures（闭包）的范围---即，它内部数据和成员的访问---以及，考虑closures（闭包）使用什么方法来返回。本节结尾，我们将讨论closures（闭包）怎样用于实现多数普通的设计模式和通过不同的解决方式来减轻另外某些需要。

因此，不再啰嗦，首先，让我们来看下实际中的closures（闭包）。

让我们以一个简单的closures（闭包）定义开始，然后，我们通过一个示例来扩展它。closures（闭包）作为一个对象包装在一个代码块中。closures（闭包）的作用就像一个方法，因为，它可以获取参数并能返回值。它是一个普通的对象，因为，你可以给他传递一个引用，就如你可以引用任何其他对象一样。别忘了，JVM不会知道你正在运行Groovy代码，因此，你可以使用一个closures（闭包）对象也就没有什么特别奇怪的了，它只是个对象。Groovy提供了一个非常简单的方法来创建closures（闭包）并赋予一些非常敏捷的行为。

假如，它能帮助你用类似于真实世界的方式来思考，假设，一个信封中的一张信纸，信纸上可能写着变量的值：“x=5, y=10”等等。对于closures（闭包）来说，信纸可能拥有一个指令列表，你可以把信封给某人，某人可能依照信纸上的指令来做决定，或者他可能同样把这个信封给其他人。每次根据不同的上下文，可能会按照信纸上面的指令来做决定很多次。例如：信纸上写着：”给你心里想着的人写一封信“，然后，他会在他的地址簿里寻找他心里想着的一系列的人，最后，根据上面的指令，一个一个的给他们写信。

closures（闭包）等同于上面真实生活的示例，可以表示成如下的形式：

Closure envelope = { person -> new Letter(person).send() }
addressBook.each (envelope)

addressBook.each { new Letter(it).send() }

• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师

h4. Using the render method to output XML
h4. 使用render输出XML
Grails' supports a few different ways to produce XML and JSON responses. The first one covered is via the [render|controllers] method. 
Grails提供一些不同的方法来产生XML和JSON响应。第一个是隐式的通过[render|controllers]方法。
The @render@ method can be passed a block of code to do mark-up building in XML:
@render@方法可以传递一个代码块来执行标记生成器产生XML
{code}
def list = {
	def results = Book.list()
	render(contentType:"text/xml") {
		books {
			for(b in results) {
				book(title:b.title)
			}
		}	
	}
}
{code}                            

The result of this code would be something like:
这段代码的结果将会像这样：
{code:xml}
<books>
	  <book title="The Stand" />
	  <book title="The Shining" />	
</books>
{code}

Note that you need to be careful to avoid naming conflicts when using mark-up building. For example this code would produce an error:
 注意，当你使用标记生成器时，必须小心避免命名冲突。例如，这段代码将产生一个错误：
{code}
def list = {
	def books = Book.list()  // naming conflict here
	render(contentType:"text/xml") {
		books {
			for(b in results) {
				book(title:b.title)
			}
		}	
	}
}
{code} 

The reason is that there is local variable @books@ which Groovy attempts to invoke as a method.
原因是，这里的一个本地变量@books@企图作为方法被调用。

h4. Using the render method to output JSON
h4. 使用 render 方法 输出 JSON
The @render@ method can also be used to output JSON:
@render@ 方法可以同样被用于输出JSON:
{code}
def list = {
	def results = Book.list()
	render(contentType:"text/json") {
		books {
			for(b in results) {
				book(title:b.title)
			}
		}	
	}
}
{code}     

In this case the result would be something along the lines of:
在这种情况下，结果就会是大致相同的：
{code}
[
	{title:"The Stand"}, 
	{title:"The Shining"}
]
{code}

Again the same dangers with naming conflicts apply to JSON building.
同样的命名冲突危险适用于JSON生成器。
h4. Automatic XML Marshalling
h4. 自动 XML 列集(Marshalling)（在此附上对于列集(Marshalling)解释：对函数参数进行打包处理得过程，因为指针等数据，必须通过一定得转换，才能被另一组件所理解。可以说列集(Marshalling)是一种数据格式的转换方法。）
Grails also supports automatic marshaling of [domain classes|guide:gorm] to XML via special converters.
Grails同样支持自动列集(Marshalling)[domain classes|guide:gorm]为XML通过特定的转换器。
To start off with import the @grails.converters@ package into your controller:                                     
首先，导入@grails.converters@ 类包到你的控制器（Controllers）中：            
{code}
import grails.converters.*
{code}

Now you can use the following highly readable syntax to automatically convert domain classes to XML:
现在，你可以使用下列高度易读的语法来自动转换领域类成XML：
{code}
render Book.list() as XML
{code}

The resulting output would look something like the following::
输出结果看上去会像下列这样：
{code}
<?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>                          
{code}     

An alternative to using the converters is to use the [codecs|guide:codecs] feature of Grails. The codecs feature provides [encodeAsXML|guide:codecs] and [encodeAsJSON|guide:codecs] methods:
一个使用转换器的替代方法是使用Grails的[codecs|guide:codecs]特性。codecs特性提供了[encodeAsXML|guide:codecs]和[encodeAsJSON|guide:codecs]方法:
{code}
def xml = Book.list().encodeAsXML()
render xml
{code}

For more information on XML marshaling see the section on [REST|guide:REST]
更多的XML 列集(Marshalling)信息见[REST|guide:REST]部分
h4. Automatic JSON Marshalling
h4. 自动JSON列集(Marshalling)
Grails also supports automatic marshaling to JSON via the same mechanism. Simply substitute @XML@ with @JSON@:
Grails同样支持自动列集(Marshalling)为JSON通过同样的机制。简单替代@XML@ 为@JSON@
{code}
render Book.list() as JSON
{code}

The resulting output would look something like the following:
输出结果看上去会像下列这样：
{code}
[
	{"id":1,
	 "class":"Book",
	 "author":"Stephen King",
	 "title":"The Stand"},
	{"id":2,
	 "class":"Book",
	 "author":"Stephen King",
	 "releaseDate":new Date(1194127343161),
	 "title":"The Shining"}
 ]
{code}

Again as an alternative you can use the @encodeAsJSON@ to achieve the same effect.
再次作为一种替代，你可以使用@encodeAsJSON@达到相同的效果

• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛

用现实生活中的示例来说明闭包

现在，让我们来考虑放在信封里的信纸。信纸里可能写着“x=5, y=10”等等一些内容。对于一个闭包（closure），信纸上可能写着一系列的指令。你可以把信封交给其他人，这个人可能会按照信纸上面的指令来做决定，当然，他也可能同样会把这个信封交给其他人。每次根据不同的上下文，他们可能多次的根据信纸的指令做出决定。比如：

信纸上可能写着”给你心里想着的人写一封信“，然后他会在他的地址簿里寻找他心里想着的一系列的人，最后，根据上面的指令，一个一个的给他们写信。

闭包（closure）等同于上面真实生活的示例，可以表示成如下的形式：

Closure envelope = { person -> new Letter(person).send() }
addressBook.each (envelope)

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

首先，Grails是一个信奉“规约重于配置”的框架，这一点是来自现在流行的Rails.使用Grails的默认设置进行开发，你不需要任何的配置。Grilas装备有一个内置的容器和一个HSQLDB物理内存数据库。

不过有时，你也需要在实际的项目中使用相应的数据库，下面介绍Grails的一些配置（很简单的，这里我用自己的一些项目来说明）：

对于普通的配置 Grails 提供了一个路径为 grails-app/conf/Config.groovy的配置文件。

注意看Config.groovy

// locations to search for config files that get merged into the main config
// config files can either be Java properties files or ConfigSlurper scripts

// grails.config.locations = [ "classpath:${appName}-config.properties",
//                             "classpath:${appName}-config.groovy",
//                             "file:${userHome}/.grails/${appName}-config.properties",
//                             "file:${userHome}/.grails/${appName}-config.groovy"]

// if(System.properties["${appName}.config.location"]) {
//    grails.config.locations << "file:" + System.properties["${appName}.config.location"]
// }
grails.mime.file.extensions = true // enables the parsing of file extensions from URLs into the request format
grails.mime.types = [ html: ['text/html','application/xhtml+xml'],
                      xml: ['text/xml', 'application/xml'],
                      text: 'text-plain',
                      js: 'text/javascript',
                      rss: 'application/rss+xml',
                      atom: 'application/atom+xml',
                      css: 'text/css',
                      csv: 'text/csv',
                      all: '*/*',
                      json: ['application/json','text/json'],
                      form: 'application/x-www-form-urlencoded',
                      multipartForm: 'multipart/form-data'
                    ]
// The default codec used to encode data with ${}
grails.views.default.codec="none" // none, html, base64

// enabled native2ascii conversion of i18n properties files
grails.enable.native2ascii = true

// log4j configuration
log4j {
    appender.stdout = "org.apache.log4j.ConsoleAppender"
    appender.'stdout.layout'="org.apache.log4j.PatternLayout"
    appender.'stdout.layout.ConversionPattern'='[%r] %c{2} %m%n'
    appender.errors = "org.apache.log4j.FileAppender"
    appender.'errors.layout'="org.apache.log4j.PatternLayout"
    appender.'errors.layout.ConversionPattern'='[%r] %c{2} %m%n'
    appender.'errors.File'="stacktrace.log"
    rootLogger="error,stdout"
    logger {
        grails="error"
        StackTrace="error,errors"
        org {
            codehaus.groovy.grails.web.servlet="error"  //  controllers
            codehaus.groovy.grails.web.pages="error" //  GSP
            codehaus.groovy.grails.web.sitemesh="error" //  layouts
            codehaus.groovy.grails."web.mapping.filter"="error" // URL mapping
            codehaus.groovy.grails."web.mapping"="error" // URL mapping
            codehaus.groovy.grails.commons="info" // core / classloading
            codehaus.groovy.grails.plugins="error" // plugins
            codehaus.groovy.grails.orm.hibernate="error" // hibernate integration
            springframework="off"
            hibernate="off"
        }
    }
    additivity.StackTrace=false
}

// WAR dependency config
grails.war.dependencies = [
    "ant.jar",
    "ant-launcher.jar",
    "hibernate3.jar",
    "jdbc2_0-stdext.jar",
    "jta.jar",
    "groovy-all-*.jar",
    "springmodules-sandbox.jar",
    "standard-${servletVersion}.jar",
    "jstl-${servletVersion}.jar",
    "antlr-*.jar",
    "cglib-*.jar",
    "dom4j-*.jar",
    "ehcache-*.jar",
    "junit-*.jar",
    "commons-logging-*.jar",
    "sitemesh-*.jar",
    "spring-*.jar",
    "log4j-*.jar",
    "ognl-*.jar",
    "hsqldb-*.jar",
    "commons-lang-*.jar",
    "commons-collections-*.jar",
    "commons-beanutils-*.jar",
    "commons-pool-*.jar",
    "commons-dbcp-*.jar",
    "commons-cli-*.jar",
    "commons-validator-*.jar",
    "commons-fileupload-*.jar",
    "commons-io-*.jar",
    "commons-io-*.jar",
    "*oro-*.jar",
    "jaxen-*.jar",
    "xercesImpl.jar",
    "xstream-1.2.1.jar",
    "xpp3_min-1.1.3.4.O.jar"
]

grails.war.java5.dependencies = [
    "hibernate-annotations.jar",
    "ejb3-persistence.jar",
]

 上面是源代码.它使用了Groovy's ConfigSlurper，类似于Java的属性文件，只不过他是使用纯粹的Groovy文件，你可以重复使用变量和正确的Java类型。

你可以在这里添加你自己的配置, for example:

foo.bar.hello = "world"

assert "world" == grailsApplication.config.foo.bar.hello

Grails也提供下面这些配置选项:

1. grails.enable.native2ascii - 设置为false 你将不要求 native2ascii 转换Grails i18n 属性文件。

   grails.enable.native2ascii = true

    默认为true.
2. grails.views.default.codec - 设置GSP的默认编码方式 - 可以为这些中的其中一个（ 'none', 'html',  'base64' (default: 'none')）. 为了 减少XSS攻击的风险, 设置为 'html'.

   grails.views.default.codec="none"

    默认为none。

log4j {
    appender.stdout = "org.apache.log4j.ConsoleAppender"
    appender.'stdout.layout'="org.apache.log4j.PatternLayout"
    appender.'stdout.layout.ConversionPattern'='[%r] %c{2} %m%n'
    appender.errors = "org.apache.log4j.FileAppender"
    appender.'errors.layout'="org.apache.log4j.PatternLayout"
    appender.'errors.layout.ConversionPattern'='[%r] %c{2} %m%n'
    appender.'errors.File'="stacktrace.log"
    rootLogger="error,stdout"
    logger {
        grails="error"
        StackTrace="error,errors"
        org {
            codehaus.groovy.grails.web.servlet="error"  //  controllers
            codehaus.groovy.grails.web.pages="error" //  GSP
            codehaus.groovy.grails.web.sitemesh="error" //  layouts
            codehaus.groovy.grails."web.mapping.filter"="error" // URL mapping
            codehaus.groovy.grails."web.mapping"="error" // URL mapping
            codehaus.groovy.grails.commons="info" // core / classloading
            codehaus.groovy.grails.plugins="error" // plugins
            codehaus.groovy.grails.orm.hibernate="error" // hibernate integration
            springframework="off"
            hibernate="off"
        }
    }

log4j = '''
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
# ...remaining configuration
'''

 注意：Groovy的多行String是

 '''  '''

的形式。

一些有用的 loggers：

• org.codehaus.groovy.grails.commons - 核心工件（ artefact）信息 比如 class loading 等等.
• org.codehaus.groovy.grails.web - Grails web 请求处理
• org.codehaus.groovy.grails.web.mapping - URL mapping调试
• org.codehaus.groovy.grails.plugins - 记录插件行为
• org.springframework - 观察spring正在干什么。
• org.hibernate -观察Hibernate正在干什么。

当有异常抛出，full trace 总是会写入 StackTrace logger，文件名叫做 stacktrace.log--当然你可以做任何你喜欢的改变通过grails-app/conf/Config.groovy文件，例如：

StackTrace="error,errors"

 你可以改变成：

StackTrace="error,stdout"

 可以完全废除stacktrace filtering 通过设置 grails.full.stacktrace VM 属性为 true:

grails -Dgrails.full.stacktrace=true run-app

Logging通过规约：

所用的应用程序工件（ artefacts）可以动态的添加 log 属性. 包括 domain classes, controllers, tag libraries 等等. 例如:

def foo = "bar"
log.debug "The value of foo is $foo"

 Logs命名 使用 规约 grails.app.<artefactType>.ClassName，例如：

# Set level for all application artefacts
log4j.logger.grails.app="info, stdout"

# Set for a specific controller log4j.logger.grails.app.controller.YourController="debug, stdout"

# Set for a specific domain class log4j.logger.grails.app.domain.Book="debug, stdout"

# Set for a specific taglib log4j.logger.grails.app.tagLib.FancyAjax="debug, stdout"

# Set for all taglibs log4j.logger.grails.app.tagLib="info, stdout"

 工件（artefacts） 名字通过规约来规定:

• bootstrap - For bootstrap classes
• dataSource - For data sources
• tagLib - For tag libraries
• service - For service classes
• controller - For controllers
• domain - For domain entities

 因为Grails 是构建在Java 技术 之上，配置data source 要求一些JDBC知识(并不是替代  Java Database Connectivity).

本质上, 如果你使用除HSQLDB以外的database ， 你需要其对应的JDBC driver 。这里我们使用MySql。

首先你的下载JDBC driver,并把他放在项目中的lib目录下。

其次你得修改位于项目中的grails-app/conf/DataSource.groovy文件。

主要包括一下设置：

• driverClassName -  JDBC driver的class name.
• username - username 为你的数据库用户名
• password - password 为你的数据库密码
• url -  数据库的JDBC URL
• dbCreate - 是否从domain model 自动生成数据库。
• pooling - 是否使用连接池 (默认为true)
• logSql - SQL logging

附上源代码：

dataSource {
	pooled = false
	driverClassName = "org.hsqldb.jdbcDriver"
	username = "sa"
	password = ""
}
hibernate {
    cache.use_second_level_cache=true
    cache.use_query_cache=true
    cache.provider_class='org.hibernate.cache.EhCacheProvider'
}
// environment specific settings
environments {
	development {
		dataSource {
			dbCreate = "create-drop" // one of 'create', 'create-drop','update'
			url = "jdbc:hsqldb:mem:devDB"
		}
	}
	test {
		dataSource {
			dbCreate = "update"
			url = "jdbc:hsqldb:mem:testDb"
		}
	}
	production {
		dataSource {
			dbCreate = "update"
			url = "jdbc:hsqldb:file:prodDb;shutdown=true"
		}
	}
}

典型的MySQ配置：

dataSource {
	pooling = true
	dbCreate = "update"
	url = "jdbc:mysql://localhost/yourDB"
	driverClassName = "com.mysql.jdbc.Driver"
	username = "yourUser"
	password = "yourPassword"	
}

JNDI DataSources

有时你需要使用JNDI，Grails支持JNDI：

dataSource {
    jndiName = "java:comp/env/myDataSource"
}

 DataSource 的dbCreate 属性定义是非常重要的 ，因为他规定了Grails 在运行时怎样尝试数据库表格 ，可选的操作:

• create-drop - 当Grails运行时自动销毁和产生数据库表格。
• create - 假如不存在就创建它,但不是修改它。
• update -假如不存在就创建它, 假如存在就修改它。

dataSource {
	dbCreate = "create-drop" // one of 'create', 'create-drop','update'
}

 当然，假如你不想使用上面所说的配置，你可以删除

dataSource {
	dbCreate = "create-drop" // one of 'create', 'create-drop','update'
}

就可以了。

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

使用最简单的术语，a variable（变量）： 变量名引用的值关联着物理内存的某个位置。和Java一样，Groovy拥有 local variables（本地变量），fields（字段）：local variables他们的范围定义为方法的一部分存在。fields的存在范围为类或者对象中。Fields and local variables有太多相同的声明方式，所以同时讲解他们。

• Declaring variables

1. Fields and local variables 使用前必须被声明 。
2. 声明包括：指定变量名, 可选的类型声明和 修饰符,分配初始值.
3. 一旦被定义，变量将通过变量名来引用。
4. Groovy 使用Java’的修饰符— private, protected, public ，final（不允许在分配值），static（为类变量），这些修饰符和Java中的意思相同。
5. 非静态变量被看到对象变量。
6. 在Groovy中，  fields 默认的修饰符有着特别的意义（在GroovyBeans中讲解）。
7. 变量类型的定义是可选的：但是假如你没有给出类型定义和修饰符定义，你必须使用def来定义变量，来说明此变量为未知类型（哈哈，希望大家能有点思维能力，其实外国人的东西都是套公式的东西，灵活运用在于你的思维能力了。前面说过Groovy一切都是对象，你用def关键字定义的变量，实际是默认值为Object）
8. 下面给出一些示例：
   

   class SomeClass {
   public fieldWithModifier
   String typedField
   def untypedField
   protected field1, field2, field3
   private assignedField = new Date()
   static classField
   public static final String CONSTA = 'a', CONSTB = 'b'
   def someMethod(){
   def localUntypedMethodVar = 1
   int localTypedMethodVar = 1
   def localVarWithoutAssignment, andAnotherOne
   }
   }
   def localvar = 1
   boundvar1 = 1
   def someMethod(){
   localMethodVar = 1
   boundvar2 = 1
   }

    
9. 注意，这里有个规则：在Groovy中，比如你给一个动态类型分配了number类型的值，就不能再用String的类型了 ，反之亦然（在后面的章节会说明原因）。

• Referencing and dereferencing fields

1. 在Groovy中你可以通过obj.fieldName来引用变量，同时他提供了额外的能力，你可以使用下标运算符来引用，示例：

   class Counter {
   public count = 0
   }
   def counter = new Counter()
   counter.count = 1
   assert counter.count == 1
   def fieldName = 'count'
   counter[fieldName] = 2
   assert counter['count'] == 2

    

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

• Java’s type system—primitives and references(原始值和引用)

1. 在Groovy中，一切都是对象。
2. Java 区分primitive types (比如：int, double, char, and byte) and reference types (比如: Object and String)。
3. 对于primitive types (比如：int, double, char, and byte)，他们只能定义相应的变量类型，而且不会存在方法。
4. reference types（除了primitive types的任何类型）。
5. 另一方面，操作符，比如a+b,a*b..只支持原始类型而不支持引用类型（当然也有例外，比如”+“支持String）。
6. 对于primitive types类型的操作，他们有相应的包装类型，当你从int到Integer,或者其他类型，都需要进行转换。

   // Java code!
   ArrayList results = new ArrayList();
   for (int i=0; i < listOne.size(); i++)
   {
   Integer first = (Integer)listOne.get(i);
   Integer second = (Integer)listTwo.get(i);
   int sum = first.intValue()+second.intValue();
   results.add (new Integer(sum));
   }

    上面的代码进行了转换，得到相应的结果。那么看下Groovy对于一些都是对象这句话，是怎么做的，稍后会跟大家说下其中的原理。

   results.add (first.plus(second))

    上面的代码，其实没有任何的转换操作，很简单的运用了Groovy内置的方法来实现。

   // Java
   int sum = first.intValue()+second.intValue();
   results.add (new Integer(sum));

    

   //Groovy Code
   
   results.add (first + second)

    
7. 为了使Groovy完全面向对象，Groovy中移除了primitive types，任何时候，你在Groovy代码中看到类似于primitive types的变量，比如： number值为 5, 或者 Boolean 值为true，这些都是引用了适当的包装类型。

• automatic boxing and unboxing（自动装箱，拆箱）

1. 或许automatic boxing and unboxing你在使用C#或者其他语言中碰到过。
2. 转换primitive value 到包装类型实例i叫boxing。
3. 倒转过来从一个包装类型到primitive value叫unboxing。
4. Groovy完成这些操作都是自动的。
5. 你已经知道，Groovy被设计成能和Java很好一起工作的语言。因此当Java方法取得primitive参数或者返回primitive发生了什么？我们该怎样从Groovy中调用那些方法？考虑已存在的方法java.lang.String class: int indexOf (int ch).在Groovy中你可以这样来使用：

   assert 'ABCDE'.indexOf(67) == 2

    以Groovy的观点来看，上面传递了包含67的Integer，虽然方法中希望的值类型为int.其实这也就是Groovy中的装箱和拆箱自动完成的效果
6. 通过图，我们来更好的理解他们之间的自动装箱和拆箱机制：
7. 同时附上Groovy类型图标：
8. 因为上面图表的都是Object,你就可以使用它们的方法了，同时，Groovy也支持操作符重载，你既可以使用方法来让两个数相加，同时也可以使用”+“实现两数相加，这些都是允许的。当然还有更多运算符。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

任何面向对象语言，不管是桌面，Server,Mobile 应用程序，Domain在程序中都是重要的。

Domain是任何企业应用的核心，比如在书店应用中需要Book,在购物应用中需要Order，这些企业实体相互关联着，他们的状态可以被保存，或者在以后的某个时刻被取回。

在OOP中，Object拥有属性，字段，方法。数据库中的表格拥有Columns和primary keys。如果你使用过ORM，那么对象与数据库的映射将非常的简单。

Grails是构建在Spring+Hibernate之上的,不过他提供了一种更简单的映射Grails Object-Relational
Mapping (GORM)。

Grails使用Hibernate’高度定制配置APIs，考虑更加容易使用ORM映射， 通过运用规约的力量使用新的映射战略叫Grails Object-relational Mapping (GORM)。

Domain class 可以通过命令行 create-domain-class创建:

grails create-domain-class Person

 他将创建一个路径为 grails-app/domain/Person.groovy 的类：

class Person {	
}

  假如你在 DataSource设置了 dbCreate property 为 "update", "create" or "create-drop"  , Grails w将自动产生修改你的数据表格。

你可以通过添加属性来定制你的Domain class：

class Person {	
	String name
	Integer age
	Date lastVisit
}

•  Basic CRUD

基本的CRUD (Create/Read/Update/Delete) 操作. 

1. Create：设置Domain属性 然后调用 save方法保存到数据库中（利用潜在的hibernate ORM层）:

   def p = new Person(name:"Fred", age:40, lastVisit:new Date())
   p.save()

    注意Groovy中new一个对象与Java中的差别，这点，会在相应的Groovy系列教材中讲到。

2. Read：Grails 会自动添加一个  id property 在你的 domain class ，通过id来取得对应的Domain class:

   def p = Person.get(1)
   assert 1 == p.id

3. Update：更新某个实体, 先设置其属性然后再次调用 save 方法:

   def p = Person.get(1)
   p.name = "Bob"
   p.save()

    

4. Delete：删除实体通过 delete 方法:

   def p = Person.get(1)
   p.delete()

    

• Domain Modelling in GORM

下面我们来看下怎么样设计 domain in GORM.

1. 创建a domain class 你可以在命令行提示符中运行 create-domain-class （必须在项目路径下使用此命令行，谨记！！！）:
   

   grails create-domain-class Book

    结果一个 class 将在你的项目路径grails-app/domain/Book.groovy下被创建:

   class Book {	
   }

    注：假如你想创建packages，只需要把class移动到你相应的packages中，不过必须是在grails-app/domain下，然后按照Java的packages规则来声明packages。上面的Class被自动映射到一个名为book的数据表格中 (和class同样的名字，当然它是小写的).上面这些都是通过ORM Domain Specific Language规约产生的。
2. 现在可以使用 Java类型来定义你的 properties

   class Book {
   	String title
   	Date releaseDate
   	String ISBN
   }

   每个属性将被映射到 数据库对应表格的column中。这里有个规约：每个 column名字都是小写的，除了class的 properties使用的“驼峰”书写方式的 properties名字就需要使用“—”符号了。比如： releaseDate将被自动写成 release_date。但是你也可以通过Constraints or  ORM DSL.定制。 

• GORM中的关联：

1. One-to-one

class Face {
    Nose nose
}
class Nose {	
}

class Face {
    Nose nose
}
class Nose {	
	Face face
}

class Face {
    Nose nose
}
class Nose {	
	static belongsTo = [face:Face]
}

上面我们使用了“ belongsTo ”，设置 Nose "属于" Face.

new Face(nose:new Nose()).save()

保存Face的同时，必须要保存Nose，因为这里是一个“ belongsTo ”关系，假如你使用下面的代码：

new Nose(face:new Face()).save() // will cause an error

将会产生错误。

就拿客户和订单来做比较，当然这里是使用一对一的，一个客户对应一个订单，保存客户的同时，你得把它的订单一起保存，因为这个订单是属于某个客户的，倒转过来思维，因为订单没有设置belongsTo，也就是说他不会关心他的客户是谁，可以把belongsTo这个看作是某个class的属性，如果你保存一个没有的属性当然会出错，不知道大家能不能理解，这个是我自己的意思。

继续：

def f = Face.get(1)
f.delete() // both Face and Nose deleted

删除某个Faces会同时删除对应的Nose,反过来不成立。就如上面所说的，既然某个Nose是某个Face的属性，因为设置了belongsTo，我们暂时这样来理解，如果客户都不存在，订单还有存在的价值吗，其实也就是一个class被删除了，属于他的属性还会继续存在吗？

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛

Class是OOP编程的基础。

现在我们开始Class。

下面我们定义一个简单的Groovy类：

class Book {
private String title
Book (String theTitle) {
title = theTitle
}
String getTitle(){
return title
}
}

在上面的Book类中，其实和我们平常的Java类没什么区别，定义了title属性，构造函数，get方法，完全是Java中的一个简单JavaBean.当然，Groovy中的类远不止这么简单，因为我在前面说过，学习一种编程语言，就如学习一门新的外语，假如，你所学的外语接近你的母语，相信，你能更快的熟悉这门语言。

对于脚本语言可能存在一种误解，因为脚本语言提供一种宽松的类型定义和让人感到惊奇的简短语法，它可能更适合作为黑客们（Hackers）的玩具而不是严谨的OOP语言。这种声音可能源于使用shell scripts或者早期的Perl，对于封装的缺乏，对于OOP代码管理上的缺乏，代码的频繁复制，隐藏的模糊不清的Bugs.不能帮助我们使用已有的代码来运用组合继承。

随着时间的推移，脚本语言的前景开始引人注目了。Perl添加了对OOP的支持，Python扩展了对OOP的支持，最近的Ruby,也成为完全的OOP语言。

当然我们的Groovy也是一种完全的OOP语言。它不但增强了Java的脚本语言能力，而且带来了新的OOP特性。比如Java的原始类型在Groovy中的改变，引入了Ranges和closures（闭包），为Collections的使用提供了更简单的方法。

Groovy中定义Class和Java差不多，通过class关键字来定义Class.Class中包含了contain fields, constructors, initializers,  methods。而对于Scripts（脚本）不同（哈哈，现在才开始说道Scripts（脚本）），提供了额外的灵活度也带来了一定的限制，它即包含了代码，变量的定义，方法的定义又包含了Class定义。

在Java,Groovy都拥有local variables，他们作为方法一部分存在。

对于variables（变量）它必须在使用前被声明（除了Scripts），这样可以强制范围和拼写错误。声明variables（变量）包括指定name，可选的类型声明，修饰符，赋原始值，定义了变量后，就可以通过他们的名字来引用了。

而在Scripts（脚本）中可以使用未声明的variables（变量）。（待续，今天没多少时间）

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师

假如你使用过JDK1.4或者更高版本，你一定熟悉assertions（断言）。。通常，他会在你的代码中测试你的逻辑是否矛盾和正确。

接下来我们通过实例来学习Groovy中的断言，在学习之前，请务必记住assert这个关键字。

assert(true) 
assert 1 == 1
def x = 1
assert x == 1
def y = 1 ; assert y == 1

请注意，def关键字类似与JavaScript中的var.用来定义动态变量。

下面我们来一行一行的解释：

assert(true)

 传递一个参数给断言，这里返回true;

assert 1 == 1

 在这里我们省略了圆括号，因为这个是可选的，注意Groovy的“==”与Java中的含义不同，留在后面的教材里讲解。

def x = 1
assert x == 1

 先定义一个变量x，赋值1，判断x是否为1.

def y = 1 ; assert y == 1

 同上。

 assertions的目的：

• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

学习一门新的编程语言，就像学习一门新的外语。你必须面对新的词汇量，语法，方言。而Groovy能和Java无缝的结合在一起，Java能调用Groovy,Groovy能调用Java,而且语法上是类似而友好的，这为你学习Groovy无疑平滑的。那么现在我们就开始Groovy的学习吧。

• Commenting Groovy code

1. 单行注释和多行注释就和Java一样，唯一不同的是Groovy多了一个首行注释。

   #!/usr/bin/groovy（首行注释，必须出现在第一行）
   
   // some line comment（单行注释）
   
   /*                              （多行注释）
   some multiline
   comment
   */

    
2. 一些指导方针来书写注释.
   

   ■  #! 注释只允许出现在第一行 ，允许Unix shells 定位 Groovy bootstrap script  通过它来运行代码 ■ // 单行注释 ■/* … */ 多行注释. ■ /** … */ Javadoc，Groovydoc注释。

3. 一些Groovy代码--但不完全是--看上去完全像Java代码。这经常导致一些错误的结论---Groovy语法是Java语法的扩展子集。尽管类似，但他们谁也不是谁的子集。例如，Groovy不支持Java中的for(init;test;inc)
4. 相对于稍微的不同，其实Java的绝大部分语法是Groovy语法的一部分：

   ■ 普通的包导入机制 ■ Statements (i包括 package and import 语句) ■ Class and method 定义 (除了嵌套Class) ■ 控制结构 (除了for(init;test;inc) ) ■ 操作符, 表达式, and 赋值 ■ 异常处理 ■ 字符声明 ■ 对象实例化, 应用， 解除对象, 方法调用

5. Groovy增加的语法部分，这些添加的部分是Groovy代码更简洁易懂

   ■ 通过新的表达式和操作符更加容易的访问对象 ■ 允许更多的方法声明对象 ■ 提供新的控制结构使用高级流控制 ■ 引入新的数据类型与表达式和操作符一起工作 ■Groovy中的一切都是对象

• 通过简洁让语法更美好

1. Groovy允许你省略掉一些Java中必须的语法。省略这些使语法更简洁，不冗长，更具有表达力，例如：

   Java:
   java.net.URLEncoder.encode("a b");

    

   Groovy:
   URLEncoder.encode 'a b'

    上面的代码不单是简洁了，而且更直接的方式的表达了我们的意思，省略了包导入机制，圆括号，分号。代码最小化了。然而，这可能对我们习惯使用Java语法的人来说，直觉上有点不舒服（也有可能产生语法上的误解，比如优先机制），而Groovy看出了我们的心思，上面这些都是可选的，意思就是，你可以使用或者不使用。
2. Groovy自动导入下面的类包：
   

   groovy.lang.* groovy.util.* java.lang.* java.util.* java.net.* java.io.* java.math.BigInteger java.math.BigDecimal

   这样你可以使用这些包，而不用再去导入了。

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛