Grails 2快速入门：实战向导

5星 · 超过95%的资源需积分: 10 65 浏览量更新于2024-07-22 收藏 12.75MB PDF 举报

"Grails 2 A Quick-Start Guide 是一本专为初学者设计的Grails框架入门指南，通过一个完整的工程实例，作者Dave Klein和Ben Klein提供了深入浅出的讲解。书中通过迭代的方式，逐步带领读者构建一个令人印象深刻的Grails应用，同时也提供了丰富的学习资源，帮助读者在完成项目的过程中掌握Grails开发。这本书受到了业界专家的高度评价，被誉为快速从Java转向Grails高效开发的理想读物。作者以实用和迭代的方式，指导读者构建一个完整的Grails应用，包括开发和生产环境的建议。这使得读者能够迅速提升Grails的学习速度。其中，软件作曲家Michael Easter称赞这本书像是一次友好的导师指导下的编程之旅，让人在轻松愉快的氛围中了解Grails。而CTO Ken Sipe认为，对于希望尽快从Java过渡到Grails生产力的人来说，这本书是最好的选择，它提供了一条快速学习Grails的途径。敏捷教练Jared Richardson则认为《Grails 2 快速启动指南》是送给新Grails开发者最好的礼物，它结合了理论教学和实践操作，是开始或提升Grails技能的绝佳资源。 Grails是一种基于Groovy语言的开源Web应用程序框架，它旨在提高开发效率，提供简洁的语法，以及与Spring、Hibernate等Java生态系统组件的紧密集成。这本书将帮助读者理解Grails的核心概念，如领域建模、GORM（Grails Object-Relational Mapping）、Controllers、Views和Templates，以及Grails插件系统。通过本书，读者可以学习到如何使用Grails构建RESTful API，处理HTTP请求，进行数据库交互，实现动态和静态页面的渲染，以及如何进行测试和部署。此外，书中还可能涵盖了Grails的安全性、性能优化和社区支持等相关话题，为初学者提供了全面的Grails开发基础。《Grails 2 快速启动指南》是一本适合初学者的实战型教材，通过实际项目经验的分享，让读者在实践中学习，从而快速掌握Grails框架的使用，提升开发技能。"

The previous snippet shows a few other differences in Groovy. First, all Groovy

classes automatically get a named-args constructor. This is a constructor

that takes a

Map

and calls the

set

method for each key that corresponds to a

property.

You can easily see how this might save several lines of code with

larger classes. Grails takes advantage of this feature to assign the values from

a web page to a new object instance. Second, in Groovy, types are optional.

Instead of giving a variable an explicit type, we can use the

def

keyword to

designate that this variable will be dynamically typed. The third difference is

the use of

in the

assert

statements. In Groovy,

is the same as calling the

equals()

method on the left operand.

Now, the

toUpperCase()

method we just used is the same as in Java. But for a

little fun, we can modify that last example to try one of the many methods

that Groovy adds to the

String

class.

introduction.2/reverse.groovy

class Person {

String name

void setName(String val){

name = val.toUpperCase().reverse()

}

Person p = new Person(name:'Hannah')

assert p.name == 'HANNAH'

It worked. (Trust us.)

Not only does Groovy enhance the

java.lang.String

class, but it also adds an

entirely new one.

Groovy Strings

Groovy adds a new string known as a

GString

. A

GString

can be created by

declaring a literal with double quotes; a string literal with single quotes is a

java.lang.String

. A

GString

can be used in place of a Java

String

. If a method is

expecting a

String

and is given a

GString

, it will be cast at runtime.

The beauty and power of the

GString

is its ability to evaluate embedded Groovy

expressions. Groovy expressions can be designated in two ways. For simple

3. Any elements in the map that do not correspond to a property are ignored by the

named-args constructor.

4. You can find more goodies in the API docs at

http://groovy.codehaus.org/groovy-jdk/java/lang/

String.html

report erratum • discuss

Groovy Strings • 3

values that are not directly adjacent to any plain text, you can just use a

dollar sign, like this:

"Hello $name"

For more involved expressions, you can use the dollar sign and a pair of curly

braces:

"The 5th letter in 'Encyclopedia' is ${'Encyclopedia'[4]}"

There can be any number of expressions in a given

GString

, and single quotes

can be embedded without any escaping. This comes in handy when generating

HTML, as we’ll see later. For now, let’s take a look at the

GString

in action.

introduction.2/hello_groovy_string.groovy

def name = 'Zachary'

def x = 3

def y = 7

def groovyString = "Hello ${name}, did you know that $x x $y equals ${x*y}?"

assert groovyString == 'Hello Zachary, did you know that 3 x 7 equals 21?'

Groovy Closures

A Groovy closure, in simple terms, is an executable block of code that can be

assigned to a variable, passed to a method, and executed.

Many of the

enhancements Groovy has made to the standard Java libraries involved adding

methods that take a closure as a parameter.

A closure is declared by placing code between curly braces. It can be declared

as it is being passed to a method call, or it can be assigned to a variable and

used later. A closure can take parameters by listing them after the opening

curly brace and separating them from the code with a dash-rocket (

), like

so:

def c = {a, b -> a + b}

If no parameters are declared in a closure, then one is implicitly provided:

it’s called

. Take a look at the following example:

introduction.2/closure_times.groovy

def name = 'Dave'

def c = {println "$name called this closure ${it+1} time${it > 0 ? 's' : ''}"}

assert c instanceof Closure

5.times(c)

5. There has been much discussion and some confusion over the definition of a “closure”

in programming languages. Some argue that what Groovy defines as a closure isn’t.

If you’re ever in town, we can discuss it over a cup of coffee, but for our purposes, we’ll

be referring to closures as defined at

http://groovy.codehaus.org/Closures

Chapter 1. Enough Groovy to Be Dangerous • 4

report erratum • discuss

There’s a fair bit of new stuff in these three lines of code. Let’s start at the

top. The variable

name

is available when the closure is executed. Anything

that is in scope when the closure is created will be available when it is execut-

ed, even if it is being executed by code in a different class. This closure is

being assigned to the variable

and has no declared parameters. It does have

and use the implicit parameter

. The code in this closure takes advantage

of another Groovy shortcut. What would be in Java

System.out.println()

is now

just

println()

. When you look at the text of the

GString

that follows, it becomes

obvious that this code will work only if whatever calls this closure passes it

a single parameter that is a number. That’s just what the

times()

method,

which Groovy adds to

Integer

, does. The parentheses are not required for the

times()

method, but we added them to emphasize that the closure was being

passed in as a parameter. The output from this code looks like this:

Dave called this closure 1 time

Dave called this closure 2 times

Dave called this closure 3 times

Dave called this closure 4 times

Dave called this closure 5 times

There is much more to the Groovy closure than we can cover here, and we

highly recommend the coverage of this topic in Venkat Subramaniam’s

Programming Groovy 2 [Sub13]. We will see more examples of the closure in

action as we look at Groovy collection classes.

Groovy Collections

Groovy offers many enhancements to the standard Java collection classes.

We’ll take a look at the three collection types that are most used in Grails.

The

List

Map

, and

Set

are powerful tools, and Groovy gives them a new edge.

We know—technically

Map

is not a collection; that is, it does not implement

the

Collection

interface. But for our purposes, it is a collection in that it holds

objects. So, leaving semantic sensitivities aside, let’s look at what Groovy has

done for these classes.

List

One of the first interesting things to learn about the

List

in Groovy is that it

can be created with a literal declaration.

introduction.2/groovy_list.groovy

def colors = ['Red', 'Green', 'Blue', 'Yellow']

def empty = []

assert colors instanceof List

assert empty instanceof List

assert empty.class.name == 'java.util.ArrayList'

report erratum • discuss

Groovy Collections • 5

A comma-separated list inside square brackets is an initialized

List

. It can

contain literal numbers, strings, or any other objects. This is a good time to

point out that in Groovy, everything is an object. Even simple data types such

int

boolean

are autoboxed objects. (That’s why we were able to call the

times()

method on the literal

in our earlier example.) The last line of this

example shows that the default

List

implementation in Groovy is

java.util.ArrayList

Groovy has also added a host of helpful methods to the

List

interface. One of

the most useful is

each()

. This method is actually added to all objects in Groovy,

but it is most useful with collection types. The

each()

method on

List

takes a

closure as a parameter and calls that closure for each element in the

List

passing in the element as the single

parameter.

introduction.2/groovy_list.groovy

def names = ['Nate', 'Matthew', 'Craig', 'Amanda']

names.each{

println "The name $it contains ${it.size()} characters."

}

This example will print the following output to the console:

The name Nate contains 4 characters.

The name Matthew contains 7 characters.

The name Craig contains 5 characters.

The name Amanda contains 6 characters.

Two handy methods added by Groovy are

min()

and

max()

introduction.2/groovy_list.groovy

assert names.min() == 'Amanda'

assert names.max() == 'Nate'

Groovy also provides a few easy ways to sort a

List

. The simple

sort()

method

will provide a natural sort of the elements in the

List

. It can also take a closure.

If the closure has no explicit parameters, then the implied

parameter can

be used in an expression to sort on. You can also give the closure two

parameters to represent two

List

elements, and then use those parameters in

a comparison expression. Here are some examples:

introduction.2/groovy_list.groovy

def sortedNames = names.sort()

assert sortedNames == ['Amanda','Craig','Matthew','Nate']

sortedNames = names.sort{it.size()}

assert sortedNames == ['Nate','Craig','Amanda','Matthew']

sortedNames = names.sort{obj1, obj2 ->

obj1[2] <=> obj2[2]

}

assert sortedNames == ['Craig','Amanda','Nate','Matthew']

Chapter 1. Enough Groovy to Be Dangerous • 6

report erratum • discuss

剩余213页未读，继续阅读

硅晶动力

粉丝: 6
资源: 15

Grails 2快速入门：实战向导

Grails.2.A.Quick-Start.Guide.pdf

Grails : A Quick-Start Guide

Grails 2 A Quick-Start Guide (Pragmatic Programmers 2013)

Grails A Quick-Start Guide:Dave Klein (DK)

Domain-Driven Design Using Naked Objects

Grails速成指南：高效构建全栈应用

若依管理存在任何文件读取漏洞检测系统，渗透测试.zip

【java毕业设计】学生社团管理系统源码（完整前后端+说明文档+LW）.zip

【java毕业设计】音乐+商城的设计与实现源码（完整前后端+说明文档+LW）.zip

基于JAVA+SpringBoot+MySQL的网上图书商城设计与实现.docx

最新资源