Table of Contents

Copyright

Brief Table of Contents

Table of Contents

Foreword

Preface

Acknowledgments

About this Book

About the Cover Illustration

1. Up to speed with Groovy

Chapter 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

Chapter 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

Chapter 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

Chapter 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

2. Groovy tools

Chapter 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.1. The Groovy-Eclipse plugin for 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

Chapter 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.3. Data-driven specifications

6.4.4. The trouble with tribbles

6.4.5. Other Spock capabilities

6.5. Summary

3. Groovy in the real world

Chapter 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

Chapter 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.4.2. Grails Object-Relational Mapping (GORM)

8.5. Groovy and NoSQL databases

8.5.1. Populating Groovy vampires

8.5.2. Querying and mapping MongoDB data

8.6. Summary

Chapter 9. RESTful web services

9.1. The REST architecture

9.2. The Java approach: JAX-RS

9.2.1. JAX-RS resource and tests

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

Chapter 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. Unit-and integration-testing web components

10.3.1. Unit-testing servlets with Spring

10.3.2. Integration testing with Gradle

10.3.3. Automating Jetty in the Gradle build

10.3.4. Using an integration-test source tree

10.4. Grails: the Groovy “killer app”

10.4.1. The quest for the holy Grails

10.5. Summary

Appendix A. Installing Groovy

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

Appendix B. Groovy by feature

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. XML

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

List of Figures

List of Tables

List of Listings