
- •brief contents
- •contents
- •foreword
- •preface
- •acknowledgments
- •about this book
- •Roadmap
- •Code conventions and downloads
- •Author Online
- •About the author
- •about the cover illustration
- •1 Why add Groovy to Java?
- •1.1 Issues with Java
- •1.1.1 Is static typing a bug or a feature?
- •1.1.2 Methods must be in a class, even if you don’t need or want one
- •1.1.3 Java is overly verbose
- •1.1.4 Groovy makes testing Java much easier
- •1.1.5 Groovy tools simplify your build
- •1.2 Groovy features that help Java
- •1.3 Java use cases and how Groovy helps
- •1.3.1 Spring framework support for Groovy
- •1.3.2 Simplified database access
- •1.3.3 Building and accessing web services
- •1.3.4 Web application enhancements
- •1.4 Summary
- •2 Groovy by example
- •2.1 Hello, Groovy
- •2.2 Accessing Google Chart Tools
- •2.2.1 Assembling the URL with query string
- •2.2.2 Transmitting the URL
- •2.2.3 Creating a UI with SwingBuilder
- •2.3 Groovy Baseball
- •2.3.1 Database data and Plain Old Groovy Objects
- •2.3.2 Parsing XML
- •2.3.3 HTML builders and groovlets
- •2.4 Summary
- •3 Code-level integration
- •3.1 Integrating Java with other languages
- •3.2 Executing Groovy scripts from Java
- •3.2.1 Using JSR223 scripting for the Java Platform API
- •3.2.2 Working with the Groovy Eval class
- •3.2.3 Working with the GroovyShell class
- •3.2.4 Calling Groovy from Java the easy way
- •3.2.5 Calling Java from Groovy
- •3.3 Summary
- •4 Using Groovy features in Java
- •4.1 Treating POJOs like POGOs
- •4.2 Implementing operator overloading in Java
- •4.3 Making Java library classes better: the Groovy JDK
- •4.4 Cool AST transformations
- •4.4.1 Delegating to contained objects
- •4.4.2 Creating immutable objects
- •4.4.3 Creating singletons
- •4.5 Working with XML
- •4.6 Working with JSON data
- •4.7 Summary
- •5 Build processes
- •5.1 The build challenge
- •5.2 The Java approach, part 1: Ant
- •5.3 Making Ant Groovy
- •5.3.1 The <groovy> Ant task
- •5.3.2 The <groovyc> Ant task
- •5.3.3 Writing your build in Groovy with AntBuilder
- •5.3.4 Custom build scripts with Gant
- •5.3.5 Ant summary
- •5.4 The Java approach, part 2: Maven
- •5.4.2 The GMaven project
- •5.4.3 Maven summary
- •5.5 Grapes and @Grab
- •5.6 The Gradle build system
- •5.6.1 Basic Gradle builds
- •5.6.2 Interesting configurations
- •5.7 Summary
- •6 Testing Groovy and Java projects
- •6.1 Working with JUnit
- •6.1.1 A Java test for the Groovy implementation
- •6.1.2 A Groovy test for the Java implementation
- •6.1.3 A GroovyTestCase test for a Java implementation
- •6.2 Testing scripts written in Groovy
- •6.2.1 Useful subclasses of GroovyTestCase: GroovyShellTestCase
- •6.2.2 Useful subclasses of GroovyTestCase: GroovyLogTestCase
- •6.3 Testing classes in isolation
- •6.3.1 Coerced closures
- •6.3.2 The Expando class
- •6.3.3 StubFor and MockFor
- •6.4 The future of testing: Spock
- •6.4.1 The Search for Spock
- •6.4.2 Test well, and prosper
- •6.4.4 The trouble with tribbles
- •6.4.5 Other Spock capabilities
- •6.5 Summary
- •7 The Spring framework
- •7.1 A Spring application
- •7.2 Refreshable beans
- •7.3 Spring AOP with Groovy beans
- •7.4 Inline scripted beans
- •7.5 Groovy with JavaConfig
- •7.6 Building beans with the Grails BeanBuilder
- •7.7 Summary
- •8 Database access
- •8.1 The Java approach, part 1: JDBC
- •8.2 The Groovy approach, part 1: groovy.sql.Sql
- •8.3 The Java approach, part 2: Hibernate and JPA
- •8.4 The Groovy approach, part 2: Groovy and GORM
- •8.4.1 Groovy simplifications
- •8.5 Groovy and NoSQL databases
- •8.5.1 Populating Groovy vampires
- •8.5.2 Querying and mapping MongoDB data
- •8.6 Summary
- •9 RESTful web services
- •9.1 The REST architecture
- •9.3 Implementing JAX-RS with Groovy
- •9.4 RESTful Clients
- •9.5 Hypermedia
- •9.5.1 A simple example: Rotten Tomatoes
- •9.5.2 Adding transitional links
- •9.5.3 Adding structural links
- •9.5.4 Using a JsonBuilder to control the output
- •9.6 Other Groovy approaches
- •9.6.1 Groovlets
- •9.6.2 Ratpack
- •9.6.3 Grails and REST
- •9.7 Summary
- •10 Building and testing web applications
- •10.1 Groovy servlets and ServletCategory
- •10.2 Easy server-side development with groovlets
- •10.2.1 A “Hello, World!” groovlet
- •10.2.2 Implicit variables in groovlets
- •10.3.2 Integration testing with Gradle
- •10.3.3 Automating Jetty in the Gradle build
- •10.4 Grails: the Groovy “killer app”
- •10.4.1 The quest for the holy Grails
- •10.5 Summary
- •A.1 Installing a JDK
- •A.2 Installing Groovy
- •A.3 Testing your installation
- •A.4 IDE support
- •A.5 Installing other projects in the Groovy ecosystem
- •B.1 Scripts and the traditional example
- •B.2 Variables, numbers, and strings
- •B.2.1 Numbers
- •B.2.2 Strings and Groovy strings
- •B.3 Plain Old Groovy Objects
- •B.4 Collections
- •B.4.1 Ranges
- •B.4.2 Lists
- •B.4.3 Maps
- •B.5 Closures
- •B.6 Loops and conditionals
- •B.6.1 Loops
- •B.6.2 Conditionals
- •B.6.3 Elvis
- •B.6.4 Safe de-reference
- •B.7 File I/O
- •B.8.1 Parsing and slurping XML
- •B.8.2 Generating XML
- •B.8.3 Validation
- •B.9 JSON support
- •B.9.1 Slurping JSON
- •B.9.2 Building JSON
- •index
- •Symbols

296 |
APPENDIX B Groovy by feature |
B.1 Scripts and the traditional example
Assuming you already have Groovy installed,2 I’ll start with the traditional “Hello, World!” program, as shown here:
println 'Hello, Groovy!'
That’s the whole program. In Java, you need a main method inside a class, and inside the main method you call System.out.println to write to the console. Java developers are used to it, but there are roughly 8 to 10 different object-oriented concepts involved, depending on how you count them.3 In Groovy, the whole program is a single line.
To demonstrate, consider one of the two execution environments that come with Groovy, the groovysh command, which starts the Groovy shell. The Groovy shell is a REPL4 that allows you to execute Groovy code a line at a time. All of the lines in the following listing produce the same result.
Listing B.1 Running “Hello, World!” in the Groovy shell
$ groovysh |
|
|
|
|
|
|
|
|
||||
Groovy Shell (2.1.5, JVM: 1.7.0_11) |
|
|
|
|
|
|
|
|
||||
Type 'help' or '\h' for help. |
|
|
|
|
|
|
|
Java syntax |
||||
---------------------------------------------- |
|
|
|
|
|
|
|
|||||
groovy:000> System.out.println("Hello, World!"); |
|
|
|
|
|
|||||||
|
|
|
|
|
||||||||
Hello, World! |
|
|
|
|
|
|
Semicolons |
|||||
===> null |
|
|
|
|
|
|
||||||
groovy:000> System.out.println("Hello, World!") |
|
|
|
are optional |
||||||||
|
|
|
|
|
||||||||
Hello, World! |
|
|
|
Default Groovy |
||||||||
===> null |
|
|
|
|||||||||
groovy:000> println("Hello, World!") |
|
|
|
method |
||||||||
|
|
|
|
|
|
|
|
|||||
Hello, World! |
Optional |
|||||||||||
===> null |
|
|
||||||||||
groovy:000> println "Hello, World!" |
|
|
|
|
parentheses |
|||||||
|
|
|
|
|
|
|
|
|
|
|
|
|
Hello, World! |
|
|
|
|
|
|
|
|
||||
===> null |
|
|
|
|
|
|
|
|
||||
groovy:000> println 'Hello, World!' |
|
|
Single-quoted |
|||||||||
Hello, World! |
|
|||||||||||
|
string |
|
|
|
|
|
||||||
===> null |
|
|
|
|
|
|
||||||
|
|
|
|
|
|
|
|
|
||||
groovy:000> |
|
|
|
|
|
|
|
|
In each case the println method prints to the console and returns null. When there’s no ambiguity, the parentheses can be omitted. Semicolons work as in Java, but they’re optional.
2See appendix A for details.
3A rough count includes classes, methods, strings, arrays, public access, static methods and attributes, void return types, overloaded methods like println, and more. It’s no accident that Bruce Eckel’s Thinking in Java (Prentice-Hall, 2002) takes over 100 pages just to get to his first “Hello, World” program.
4Read-Eval-Print Loop; see http://en.wikipedia.org/wiki/REPL for details.
www.it-ebooks.info

Scripts and the traditional example |
297 |
This is an example of a Groovy script. A script is a code listing that doesn’t explicitly include a class definition. In Java, everything has to be inside a class. Groovy is able to work with both scripts and classes.
A Groovy script is a form of syntactic sugar.5 A class is, in fact, involved. If I compile this script and then run the javap command on it, I get the following response:
>groovyc hello_world.groovy
>javap hello_world
Compiled from "hello_world.groovy"
public class hello_world extends groovy.lang.Script{ public static transient boolean __$stMC;
public static long __timeStamp;
public static long __timeStamp__239_neverHappen1309544582162; public hello_world();
public hello_world(groovy.lang.Binding); public static void main(java.lang.String[]); public java.lang.Object run();
...
There are about 30 more lines of output from the javap command, mostly involving superclass methods. The interesting part is that the groovy command generates a class called hello_world, along with a pair of constructors and a main method. The class is generated at compile time and extends a class from the Groovy library called groovy.lang.Script. In effect, scripts in Groovy become classes in Java, where the code in the script ultimately (after a few layers of indirection) is executed by the main method. I don’t want to give the impression that Groovy is generating Java, however. Groovy code is compiled directly into bytecodes for the JVM.
COMPILED GROOVY Groovy is compiled, not interpreted. It’s not a code generator; the compiler generates Java bytecodes directly.
Because the bytecodes run on the JVM, you can execute Groovy scripts using the java command as long as you include the necessary JAR file in your classpath:
> java –cp .;%GROOVY_HOME%\embeddable\groovy-all-2.1.5.jar hello_world Hello, World!
EXECUTING GROOVY At runtime, Groovy is just another JAR file. As long as the groovy-all JAR file is in the classpath, Java is perfectly happy to execute compiled Groovy code.
The groovy command is used to execute Groovy programs. It can be used with either the compiled code (similar to the java command) or Groovy source. If you use the source, the groovy command first compiles the code and then executes it.
5Syntactic sugar is syntax that simplifies writing code but doesn’t change anything under the hood. There may be some evidence that an overuse of syntactic sugar leads to syntactic diabetes.
www.it-ebooks.info