assert "$nick is $book" == 'ReGina is Groovy in Action, 2nd ed.' Chapter 3 provides To download their free eBook in PDF, ePub, and Kindle formats, owners. Selection from Groovy in Action, Second Edition [Book] ISBN: Written by core members of the Groovy language team, this book presents. a Groovy script that produces this book from docbook format to PDF. assert "$ nick is $book" == 'ReGina is Groovy in Action, 2nd ed.'.
|Language:||English, Spanish, Dutch|
|ePub File Size:||29.46 MB|
|PDF File Size:||18.78 MB|
|Distribution:||Free* [*Sign up for free]|
Contribute to clojurians-org/groovy-ebook development by creating an account on GitHub. June ; ISBN ; pages; printed in black & white Groovy in Action, Second Edition is a thoroughly revised, comprehensive guide to. NodeBuilder in action—a closer look at builder code .. From the beginning, it was clear that Groovy would need a book like Groovy in Action to introduce.
It introduces Java developers to the dynamic features that Groovy provides, and shows how to apply Groovy to a range of tasks including building new apps, integration with existing code, and DSL development. Covers Groovy 2. About the Technology In the last ten years, Groovy has become an integral part of a Java developer's toolbox. Its comfortable, common-sense design, seamless integration with Java, and rich ecosystem that includes the Grails web framework, the Gradle build system, and Spock testing platform have created a large Groovy community About the Book Groovy in Action, Second Edition is the undisputed definitive reference on the Groovy language. Written by core members of the Groovy language team, this book presents Groovy like no other can—from the inside out. With relevant examples, careful explanations of Groovy's key concepts and features, and insightful coverage of how to use Groovy in-production tasks, including building new applications, integration with existing code, and DSL development, this is the only book you'll need.
Using bean methods for any object. Fields, accessors, maps, and Expando. Using advanced syntax features 7. Querying objects with GPaths. Injecting the spread operator. Concise syntax with command chains. Dynamic programming with Groovy 8. What is dynamic programming? Customizing the MOP with hook methods 8.
Customizing methodMissing. Using closures for dynamic hooks. Customizing GroovyObject methods. Modifying behavior through the metaclass 8. MetaClass knows it all. How to find the metaclass and invoke methods. Temporary MOP modifications using category classes.
Using the Category annotation. Real-world dynamic programming in action 8. Calculating with metrics. Replacing constructors with factory methods. Fooling IDEs for fun and profit. Undoing metaclass modifications. Compile-time metaprogramming and AST transformations 9. A brief history 9. Generating bytecode, not source code. Putting the power of code generation in the hands of developers. Making Groovy cleaner and leaner 9. Code-generation transformations. Class design and design pattern annotations.
Easier cloning and externalizing. Exploring AST 9.
Tools of the trade. AST by example: Creating by hand. Limitations 9. Groovy as a static language Motivation for optional static typing The role of types in Groovy. Type checking a dynamic language? Using TypeChecked Finding typos. Revisiting dynamic features in light of type checking. Mixing type-checked code with dynamic code.
Flow typing Least upper bound. Static compilation Static type checking extensions DelegatesTo revisited.
Type checking extension scripts. Working with builders Learning by example: Using a builder. Building object trees with NodeBuilder NodeBuilder in action: Understanding the builder concept. Working with MarkupBuilder Building XML. Working with StreamingMarkupBuilder. Task automation with AntBuilder From Ant scripts to Groovy scripts. Smart automation scripts with logic.
Reading a password with SwingBuilder. Application design with FXML. Creating your own builder Subclassing BuilderSupport. Subclassing FactoryBuilderSupport. Working with the GDK Working with objects Interactive objects. Traversing the filesystem. Writing to output destinations. Streaming serialized objects. Working with threads and processes Groovy multithreading. Integrating external processes. Working with templates Understanding the template format. Working with Groovlets Starting with "Hello world".
Database programming with Groovy Groovy SQL: Setting up for database access. Advanced Groovy SQL Performing transactional updates. Working with named and named-ordinal parameters.
Using DataSet operations. Organizing database work Architectural overview. Specifying the application behavior. Implementing the infrastructure. Using a transparent domain model.
Implementing the application layer. Groovy and NoSQL A document-style database. Reading XML documents Working with a DOM parser. Reading with a Groovy parser.
Processing XML In-place processing. Parsing and building JSON Parsing JSON. Interacting with Web Services An overview of Web Services. Applying SOAP Simplifying SOAP access using groovy-wslite.
Integrating Groovy Prelude to integration Integrating appropriately. Evaluating expressions and scripts with GroovyShell Starting simply. Passing parameters within a binding. Generating dynamic classes at runtime. Further parameterization of GroovyShell. Using the Groovy script engine Setting up the engine. Defining a different resource connector. Working with the GroovyClassLoader Parsing and loading Groovy classes. The chicken and egg dependency problem. Providing a custom resource loader.
Playing it safe in a secured sandbox. Spring integration Wiring GroovyBeans. Riding Mustang and JSR Introducing JSR The script engine manager and its script engines. Compilable and invocable script engines.
Mastering CompilerConfiguration The import customizer. The configscript compilation option. Choosing an integration mechanism. Unit testing with Groovy Getting started Writing tests is easy. Organizing your tests Test suites. Parameterized or data-driven testing.
Advanced testing techniques Testing made groovy. IDE integration Using GroovyTestSuite. Testing with the Spock framework Testing with mocks. Build automation Build integration with Gradle. Build integration with Maven. Concurrent Groovy with GPars Concurrency for the rest of us Concurrent collection processing Transparently concurrent collections.
Dataflow for implicit task coordination Testing for deadlocks. Dataflow on sequential datatypes.
Actors for explicit task coordination Using the strengths of Groovy. Agents for delegated task coordination.
Domain-specific languages Back to omitting parentheses. Variables, constants, and method injection Injecting constants through the binding.
Injecting methods into a script. Adding imports and static imports automatically. Injecting methods revisited. Adding closures to the binding. Defining your own control structures.
Context switching with closures. Another technique for builders. Securing your DSLs Stopping the execution of your programs. Preventing cheating with metaprogramming. Little did I know that it would take another 2 years of a huge combined effort to get the book out.
Maybe not surprising for other authors, and it has been mentioned many times before, but yet; it was an effort. It was quite a time-consuming process to write a book, coordinate with your co-authors, the editors and the publisher, while also keeping in touch with you, the reader, who come up with a lot of greats ideas and publish errata on the forums.
If feels like I can finally check one the things on my bucket list, and that is to have my name on the cover of an amazing book. Topic like functional programming, using collections, testing your software, and more advanced topics like ASTs, creating DSLs, etc are all covered in the book, and provide a great help for beginners in programming as well as advanced software developers.
Not only about the Groovy programming language, and how to convey our message to our audience, but also about the writing process and the technologies used to write the book. For example, we are using GitHub to store the book, which is a perfect way of keeping track who worked on what, restore versions, etc. However, the book is written in Word. Which is probably the single most horrible way to write a book in.
Instead, choose a more open format like AsciiDoc , which is a text document format for writing notes, documentation, articles, books, ebooks, and much more. Find a publisher which supports plain text publishing, and preferably AsciiDoc! Secondly, writing with a distributed!