book

Groovy in Action

Name: Groovy in Action
ISBN: 9781932394849

by Andrew Glover, Paul King, Dierk Koenig, Erik Pragt, Guillaume Laforge, Jonathan Skeet

December 2006

Beginner to intermediate

696 pages

15h 1m

English

Manning Publications

Read now

Unlock full access

Copyright
Dedication
Foreword
Preface
Acknowledgments
About this Book
RoadmapWho should read this book?Code conventionsKeeping up to dateAuthor Online
About the Authors
About the Title
About the Cover Illustration
1. Your way to Groovy
1.1. The Groovy story1.1.1. What is Groovy?1.1.2. Playing nicely with Java: seamless integrationSeamless integrationSyntax alignment1.1.3. Power in your code: a feature-rich languageListing a file: closures and I/O additionsPrinting a list: collection literals and simplified property accessXML handling the Groovy way: GPath with dynamic properties1.1.4. Community-driven but corporate-backed1.2. What Groovy can do for you1.2.1. Groovy for Java professionals1.2.2. Groovy for script programmers1.2.3. Groovy for pragmatic programmers, extremos, and agilists1.3. Running Groovy1.3.1. Using groovysh for “Hello World”Display commandBinding commandInspect command1.3.2. Using groovyConsole1.3.3. Using groovy1.4. Compiling and running Groovy1.4.1. Compiling Groovy with groovyc1.4.2. Running a compiled Groovy script with Java1.4.3. Compiling and running with Ant1.5. Groovy IDE and editor support1.5.1. IntelliJ IDEA plug-in1.5.2. Eclipse plug-in1.5.3. Groovy support in other editors1.6. Summary
1. The Groovy language

2. Overture: The Groovy basics
2.1. General code appearance2.1.1. Commenting Groovy code2.1.2. Comparing Groovy and Java syntax2.1.3. Beauty through brevity2.2. Probing the language with assertions2.3. Groovy at a glance2.3.1. Declaring classes2.3.2. Using scripts2.3.3. GroovyBeans2.3.4. Handling textGStringsRegular expressions2.3.5. Numbers are objects2.3.6. Using lists, maps, and rangesListsSimple mapsRanges2.3.7. Code as objects: closures2.3.8. Groovy control structures2.4. Groovy’s place in the Java environment2.4.1. My class is your class2.4.2. GDK: the Groovy library2.4.3. The Groovy lifecycleGroovy class generation at workGroovy is dynamic2.5. Summary
3. The simple Groovy datatypes
3.1. Objects, objects everywhere3.1.1. Java’s type system—primitives and references3.1.2. Groovy’s answer—everything’s an object3.1.3. Interoperating with Java—automatic boxing and unboxing3.1.4. No intermediate unboxing3.2. The concept of optional typing3.2.1. Assigning types3.2.2. Static versus dynamic typing3.3. Overriding operators3.3.1. Overview of overridable operators3.3.2. Overridden operators in action3.3.3. Making coercion work for youSupported argument typesPromoting more specific argumentsHandling more general arguments with double dispatchGroovy’s conventional behavior3.4. Working with strings3.4.1. Varieties of string literals3.4.2. Working with GStrings3.4.3. From Java to Groovy3.5. Working with regular expressions3.5.1. Specifying patterns in string literalsSymbols3.5.2. Applying patternsCommon regex pitfalls3.5.3. Patterns in action3.5.4. Patterns and performance3.5.5. Patterns for classification3.6. Working with numbers3.6.1. Coercion with numeric operators3.6.2. GDK methods for numbers3.7. Summary
4. The collective Groovy datatypes
4.1. Working with ranges4.1.1. Specifying ranges4.1.2. Ranges are objects4.1.3. Ranges in action4.2. Working with lists4.2.1. Specifying lists4.2.2. Using list operatorsThe subscript operatorAdding and removing itemsControl structures4.2.3. Using list methodsManipulating list contentAccessing list content4.2.4. Lists in action4.3. Working with maps4.3.1. Specifying maps4.3.2. Using map operators4.3.3. Maps in action4.4. Notes on Groovy collections4.4.1. Understanding concurrent modification4.4.2. Distinguishing between copy and modify semantics4.5. Summary
5. Working with closures
5.1. A gentle introduction to closures5.2. The case for closures5.2.1. Using iterators5.2.2. Handling resourcesA common Java approach: use inner classesAn alternative Java approach: the Template Method pattern5.3. Declaring closures5.3.1. The simple declaration5.3.2. Using assignments for declaration5.3.3. Referring to methods as closures5.3.4. Comparing the available options5.4. Using closures5.4.1. Calling a closure5.4.2. More closure methodsReacting on the parameter countHow to curry favor with a closureClassification via the isCase methodRemaining methods5.5. Understanding scoping5.5.1. The simple variable scope5.5.2. The general closure scope5.5.3. Scoping at work: the classic accumulator test5.6. Returning from closures5.7. Support for design patterns5.7.1. Relationship to the Visitor pattern5.7.2. Relationship to the Builder pattern5.7.3. Relationship to other patterns5.8. Summary
6. Groovy control structures
6.1. The Groovy truth6.1.1. Evaluating Boolean tests6.1.2. Assignments within Boolean tests6.2. Conditional execution structures6.2.1. The humble if statement6.2.2. The conditional ?: operator6.2.3. The switch statementThe switch structureSwitch with classifiers6.2.4. Sanity checking with assertionsProducing informative failure messagesInsure code with inline unit testsRelationships to other assertions6.3. Looping6.3.1. Looping with while6.3.2. Looping with for6.4. Exiting blocks and methods6.4.1. Normal termination: return/break/continue6.4.2. Exceptions: throw/try-catch-finally6.5. Summary
7. Dynamic object orientation, Groovy style
7.1. Defining classes and scripts7.1.1. Defining fields and local variablesDeclaring variablesReferencing and dereferencing fields7.1.2. Methods and parametersAdvanced naming7.1.3. Safe dereferencing with the ?. operator7.1.4. ConstructorsPositional parametersNamed parametersImplicit constructors7.2. Organizing classes and scripts7.2.1. File to class relationship7.2.2. Organizing classes in packagesClasspathPackagesImportsType aliasing7.2.3. Further classpath considerations7.3. Advanced OO features7.3.1. Using inheritance7.3.2. Using interfaces7.3.3. Multimethods7.4. Working with GroovyBeans7.4.1. Declaring beans7.4.2. Working with beansAccessor methodsField access with .@Bean-style event handling7.4.3. Using bean methods for any object7.4.4. Fields, accessors, maps, and Expando7.5. Using power features7.5.1. Querying objects with GPaths7.5.2. Injecting the spread operator7.5.3. Mix-in categories with the use keyword7.6. Meta programming in Groovy7.6.1. Understanding the MetaClass concept7.6.2. Method invocation and interception7.6.3. Method interception in action7.7. Summary
2. Around the Groovy library
8. Working with builders
8.1. Learning by example—using a builder8.2. Building object trees with NodeBuilder8.2.1. NodeBuilder in action—a closer look at builder code8.2.2. Understanding the builder concept8.2.3. Smart building with logic8.3. Working with MarkupBuilder8.3.1. Building XML8.3.2. Building HTML8.4. Task automation with AntBuilder8.4.1. From Ant scripts to Groovy scripts8.4.2. How AntBuilder works8.4.3. Smart automation scripts with logic8.5. Easy GUIs with SwingBuilder8.5.1. Reading a password with SwingBuilder8.5.2. Creating Swing widgets8.5.3. Arranging your widgets8.5.4. Referring to widgets8.5.5. Using Swing actions8.5.6. Using models8.5.7. Putting it all togetherGathering requirementsGetting preparedImplementationAssessment8.6. Creating your own builder8.6.1. Subclassing BuilderSupport8.6.2. The DebugBuilder example8.7. Summary
9. Working with the GDK
9.1. Working with Objects9.1.1. Interactive objectsObject information in stringsAccessing propertiesInvoking methods dynamically9.1.2. Convenient Object methods9.1.3. Iterative Object methods9.2. Working with files and I/O9.2.1. Traversing the filesystem9.2.2. Reading from input sources9.2.3. Writing to output destinations9.2.4. Filters and conversions9.2.5. Streaming serialized objects9.3. Working with threads and processes9.3.1. Groovy multithreading9.3.2. Integrating external processes9.4. Working with templates9.4.1. Understanding the template format9.4.2. Templates in action9.4.3. Advanced template issues9.5. Working with Groovlets9.5.1. Starting with “hello world”9.5.2. The Groovlet binding9.5.3. Templating Groovlets9.6. Summary
10. Database programming with Groovy
10.1. Basic database operations10.1.1. Setting up for database accessInstalling a databaseFirst contactDriverManager versus DataSource10.1.2. Executing SQLCreating the database schemaInserting dataUpdating and deleting data10.1.3. Fetching dataFetching a row at a time with eachRowFetching a ResultSet with queryFetching all rows at onceFetching metadata10.1.4. Putting it all together10.2. DataSets for SQL without SQL10.2.1. Using DataSet operations10.2.2. DataSets on database views10.3. Organizing database work10.3.1. Architectural overview10.3.2. Specifying the application behavior10.3.3. Implementing the infrastructureImplementing DbHelperImplementing DataAccessObjectImplementing AthleteDAO10.3.4. Using a transparent domain model10.3.5. Implementing the application layer10.4. Groovy and ORM10.5. Summary
11. Integrating Groovy
11.1. Getting ready to integrate11.1.1. Integrating appropriately11.1.2. Setting up dependencies11.2. Evaluating expressions and scripts with GroovyShell11.2.1. Starting simply11.2.2. Passing parameters within a binding11.2.3. Generating dynamic classes at runtime11.2.4. Parsing scripts11.2.5. Running scripts or classes11.2.6. Further parameterization of GroovyShellChoosing a parent classloaderConfiguring the compilation11.3. Using the Groovy script engine11.3.1. Setting up the engine11.3.2. Running scripts11.3.3. Defining a different resource connector11.4. Working with the GroovyClassLoader11.4.1. Parsing and loading Groovy classes11.4.2. The chicken and egg dependency problemExample problemRemoving the dependency cycleBuilding the solution in phases11.4.3. Providing a custom resource loader11.4.4. Playing it safe in a secured sandboxThe Java security modelGroovyCodeSource and the security managerGroovyShell and GroovyClassLoader with GroovyCodeSource11.5. Spring integration11.5.1. Wiring GroovyBeans11.5.2. Refreshable beans11.5.3. Inline scripts11.6. Riding Mustang and JSR-22311.6.1. Introducing JSR-22311.6.2. The script engine manager and its script engines11.6.3. Compilable and invocable script engines11.7. Choosing an integration mechanism11.8. Summary
12. Working with XML
12.1. Reading XML documents12.1.1. Working with a DOM parserGetting the documentWalking the DOMMaking DOM groovier12.1.2. Reading with a Groovy parserCommonalities between XmlParser and XmlSlurperDifferences between XmlParser and XmlSlurper12.1.3. Reading with a SAX parser12.1.4. Reading with a StAX parser12.2. Processing XML12.2.1. In-place processing12.2.2. Streaming processingUnmodified pipingHeating up to HTML12.2.3. Combining with XPathUnderstanding XPathUsing the XPath APILeveraging additional Java XML processing technologies12.3. Distributed processing with XML12.3.1. An overview of web services12.3.2. Reading RSS and ATOM12.3.3. Using a REST-based API12.3.4. Using XML-RPC12.3.5. Applying SOAPDoing SOAP with plain GroovySimplifying SOAP access with the GroovySOAP modulePublishing a SOAP service with GroovySOAP12.4. Summary
3. Everyday Groovy
13. Tips and tricks
13.1. Things to remember13.1.1. Equality versus identity13.1.2. Using parentheses wisely13.1.3. Returning from methods and closures13.1.4. Calling methods in builder code13.1.5. Qualifying access to “this”Disambiguation in JavaDisambiguation in Groovy13.1.6. Considering number types13.1.7. Leveraging AntUsing Ant from GroovyUsing Groovy from Ant13.1.8. Scripts are classes but differentScript namingScript inclusion13.2. Useful snippets13.2.1. Shuffling a collection13.2.2. Scrambling text with regular expressions13.2.3. Console progress bar13.2.4. Self-commenting single-steps13.2.5. Advanced GString usage13.3. Using groovy on the command line13.3.1. Evaluating a command-line script13.3.2. Using print and line options13.3.3. Using the listen mode13.3.4. In-place editing from the command line13.4. Writing automation scripts13.4.1. Supporting command-line options consistentlyThe standard option handlingDeclaring command-line optionsWorking with optionsThe Mailman example13.4.2. Expanding the classpath with RootLoaderStarting Java is considered trickyGroovy starters13.4.3. Scheduling scripts for execution13.5. Example automation tasks13.5.1. Scraping HTML pages13.5.2. Automating web actions13.5.3. Inspecting version control13.5.4. Pragmatic code analysis13.5.5. More points of interest13.6. Laying out the workspace13.6.1. IDE setup13.6.2. DebuggingExploiting groovycGroovy runtime inspectionUsing debugging toolsJdb session transcript13.6.3. Profiling13.6.4. Refactoring13.7. Summary
14. Unit testing with Groovy
14.1. Getting started14.1.1. Writing tests is easy14.1.2. GroovyTestCase: an introduction14.1.3. Working with GroovyTestCase14.2. Unit-testing Groovy code14.3. Unit-testing Java code14.4. Organizing your tests14.5. Advanced testing techniques14.5.1. Testing made groovy14.5.2. Stubbing and mockingExample problem: collaborator constructionStubbing out the collaboratorStub expectationsComparing stubs and mocks14.5.3. Using GroovyLogTestCase14.6. IDE integration14.6.1. Using GroovyTestSuite14.6.2. Using AllTestSuite14.6.3. Advanced IDE integration14.7. Tools for Groovy testing14.7.1. Code coverage with Groovy14.7.2. JUnit extensions14.8. Build automation14.8.1. Build integration with Ant14.8.2. Build integration with Maven14.9. Summary
15. Groovy on Windows
15.1. Downloading and installing Scriptom15.2. Inside Scriptom15.2.1. Introducing Jacob15.2.2. Instantiating an ActiveX component15.2.3. Invoking methods15.2.4. Accessing properties and return values15.2.5. Event support15.3. Real-world scenario: automating localization15.3.1. Designing our document format15.3.2. Designing the thesaurus spreadsheet15.3.3. Creating a Word document15.3.4. Producing the final document15.4. Further application automation15.4.1. Accessing the Windows registry15.4.2. Rolling out your own automation system15.5. Where to get documentation15.6. Summary
16. Seeing the Grails light
16.1. Setting the stage16.1.1. Installing Grails16.1.2. Getting your feet wet16.2. Laying out the domain model16.2.1. Thinking through the use cases16.2.2. Designing relations16.3. Implementing the domain model16.3.1. Scaffolding domain classes16.3.2. Scaffolding views and controllers16.3.3. Testing the web application16.3.4. Completing the domain model16.4. Customizing the views16.4.1. Bootstrapping data16.4.2. Working with Groovy Server Pages16.4.3. Working with tag libraries16.5. Working with controllers and finder methods16.6. Elaborating the model16.7. Working with the session16.8. Finishing up16.8.1. Validating constraints16.8.2. Deploying the application16.8.3. Farewell
A. Installation and documentation
A.1. InstallationA.2. Obtaining up-to-date documentationA.2.1. Using online resourcesA.2.2. Subscribing to mailing listsA.2.3. Connecting to forum and chat
B. Groovy language info
B.1. Keyword list
C. GDK API quick reference
C.1. Arrays and primitivesC.2. The java.lang packageC.3. The java.math packageC.4. The java.util and java.sql packagesC.5. The java.util.regex packagC.6. The java.io packageC.7. The java.net package
D. Cheat sheets
D.1. ListsD.2. ClosuresD.3. Regular expressionsD.4. Unit testingD.5. Mocks and stubsD.6. XML GPath notation

Overview

Groovy, the brand-new language for the Java platform, brings to Java many of the features that have made Ruby popular. Groovy in Action is a comprehensive guide to Groovy programming, introducing Java developers to the new dynamic features that Groovy provides. To bring you Groovy in Action, Manning again went to the source by working with a team of expert authors including both members and the manager of the Groovy Project team. The result is the true definitive guide to the new Groovy language.

About the Technology

About the Book

Groovy in Action introduces Groovy by example, presenting lots of reusable code while explaining the underlying concepts. Java developers new to Groovy find a smooth transition into the dynamic programming world. Groovy experts gain a solid reference that challenges them to explore Groovy deeply and creatively.

Because Groovy is so new, most readers will be learning it from scratch. Groovy in Action quickly moves through the Groovy basics, including

Simple and collective Groovy data types
Working with closures and Groovy control structures
Dynamic Object Orientation, Groovy style

Readers are presented with rich and detailed examples illustrating Groovy's enhancements to Java, including

How to work with builders and the GDK
Database programming with Groovy

Groovy in Action then demonstrates how to Integrate Groovy with XML, and provides,

Tips and Tricks
Unit testing and build support
Groovy on Windows

An additional bonus is a chapter dedicated to Grails, the Groovy web application framework.

What's Inside

A comprehensive Groovy language tutorial
Explore the benefits of dynamic programming
Tackle day-to-day tasks like shell scripting and build support
Grails, the Groovy web development framework
Dozens of reusable examples

About the Reader

About the Authors

Dierk Koenig is a senior software developer, mentor and coach. He publishes in leading German magazines on software development and speaks at international conferences. He works at Canoo Engineering AG, Basel, Switzerland, where he is the founding partner and member of the executive board. He joined the Groovy project in 2004 working as a committer ever since.

Andrew Glover is the President of Stelligent Incorporated which helps companies address software quality with effective developer testing strategies and continuous integration techniques that enable teams to monitor code quality early and often. He actively blogs about software quality at thediscoblog.com and testearly.com.

Dr Paul King is Managing Director and Principal Consultant for ASERT, an Australian company specialising in helping its customers leverage emerging technologies. He has provided technical and strategic consulting to hundreds of organizations throughout the U.S. and Asia Pacific and is an active contributor to many open source projects. When not being a taxi service for his seven children, you will find Paul tinkering with the latest Agile or enterprise technologies.

As the official Groovy Project Manager and member of the JSR-241 Expert Group standardizing the Groovy Scripting Language, Guillaume Laforge is a passionate Groovy developer. In his professional career, Guillaume is a software architect and Open Source consultant, working for OCTO Technology, a company focusing on architecture of software and information systems

Jon Skeet is a software engineer and inveterate technological dabbler who happens to specialise in Java and C# development. A recent convert to Groovy, Jon is fanatical about using smarter ways to write cleaner, more readable code.

Quotes
Excellent code samples ... very readable.
- Scott Shaw, ThoughtWorks

Top of my list.
- Samuel Pullara, VP Technology Strategy, Yahoo, Inc.

Collects in one place details of the language and its libraries—a valuable resource.
- John Wilson, The Wilson Partnership

Great, logical focus on language features.
- Norman Richards, JBoss Developer, author of "XDoclet in Action"

Destined to be the definitive guide. First rate!
- Glen Smith, Bytecode Pty Ltd

You want to learn Groovy? This book has all you need.
- Stuart Caborn, ThoughtWorks

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781932394849Publisher Support Publisher Website

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills