Grails 2速成指南：打造高效应用

需积分: 6 124 浏览量更新于2024-07-22 收藏 13.11MB PDF 举报

"《Grails 2快速入门指南》是一本由Pragmatic Bookshelf出版的专业书籍，旨在为读者提供最直接且高效的Grails 2框架学习路径。该书以一种亲切而智慧的方式引导新手入门，通过一系列循序渐进的项目练习，仿佛有一位友善的导师陪伴着读者共同成长。作者采用迭代式的教学方法，让学习者在实践中逐步构建一个功能强大的应用程序，体验到Grails的强大功能。这本书的独特之处在于它的实践导向，强调了"边学边做"的学习方式。读者不仅能够学习理论知识，还能在实际开发环境中掌握技能，这使得学习过程更具深度和效率。书中不仅涵盖了Java基础到Grails应用开发的全面迁移，还提供了针对开发和生产环境的实用建议，帮助读者迅速提升Grails技能。读者们对这本书赞誉有加，Michael Easter评价它为"软件创作的乐趣"，认为它是帮助读者尽快从Java过渡到Grails的最佳选择。Ken Sipe，作为CodeMentor Inc.的CTO，也赞赏其为新Grails开发者准备的优质资源，指出这本书在指导和实践结合上做得非常出色，非常适合初学者和进阶者使用。 Jared Richardson，作为一名敏捷教练，同样认可了《Grails 2快速入门指南》的价值，认为它为Grails开发者提供了理想的学习起点或提升工具。这本书以其实用、直观和富有实践性的内容，成为理解和掌握Grails 2框架的理想读物，对于想要步入Web开发领域的专业人士来说，是不容错过的宝贵资源。"

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

Download from Wow! eBook <www.wowebook.com>

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

Download from Wow! eBook <www.wowebook.com>

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

Download from Wow! eBook <www.wowebook.com>

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

Download from Wow! eBook <www.wowebook.com>

剩余213页未读，继续阅读

anewy

粉丝: 0
资源: 1

Grails 2速成指南：打造高效应用

OpenGL ES 2 for Android_ A Quick-Start Guide （OpenGL ES2 应用开发指南）中文+英文

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

有关面向对象思想的文献

Django first

python Django

pragmatic指令

the pragmatic programmer pdf

怎样查看django的安装路径

the pragmatic programmerpdf

typescript编程 电子书下载

最新资源

typescript编程电子书下载