Reclaiming Productivity for faster Java Web Development Ideal for Java developers new to Groovy and Grails--this book will teach you all you need to create web applications with Grails Create, develop, test, and deploy a web application in Grails Take a step further into Web 2.0 using AJAX and the RichUI plug-in in Grails Packed with examples and clear instructions to lead you through the development and deployment of a Grails web application
In Detail
Web development is tricky--even a simple web application has a number of context changes ready to trip up the unwary. Grails takes the everyday pain out of web application development, allowing us to focus on delivering real application logic and create seamless experiences that will address the needs of our users. This book will take the pain out of Grails by showing you exactly how to build a web application with a minimum of fuss.
With this book, even if you are new to Grails, you will be up and running before you know it. You will be able to code faster and your code will be better. This clear and concise book is packed with examples and clear instructions to help you build your first Grails application and gives you the skills to speed up your application development by adding a different angle for learning about the topic. After a brief introduction to the dynamic JVM-based Groovy programming language, which teaches you enough about Groovy to understand the relationship between Grails and the Groovy scripting language, it shows how to use Grails and a number of key plug-ins to deliver valuable web applications. It also takes you through creating, developing, testing, and deploying an example team collaboration application in Grails.
Using an incremental and iterative approach you will learn how to build a basic web application with secure authentication and different levels of authorization. You will learn how to handle file upload allowing users to share files. Some advanced features of object-oriented persistence will be introduced through adding tags for messages and files to giving users a robust categorization system.
You will then build on the basic application to enhance the user experience through AJAX and the RichUI plug-in. You will take a further step into the world of Web 2.0 by adding an RSS feed and a REST service to the application. Once the entire application is up and running, you will learn how to create your own plug-in for tagging. Finally, you will learn how to deploy this application to a production environment.
What you will learn from this book? Understand the relationship between Grails and the Groovy scripting language Learn enough about Groovy to get you writing your first Grails applications Use the built-in AJAX support to enhance user interaction and create slick user interfaces with the RichUI plug-in Develop and use a REST service interface and provide an API through REST Handle file upload and versioning allowing users to share files Use Grails scaffolding to generate a user interface to allow management of users and roles within the application. Secure your application with the JSecurity plug-in and use plug-ins to solve common problems Reduce object persistence issues using Grails Object-Relational Mapper Create your own Grails plug-in for tagging to limit the amount of data that is displayed on your home page Get to grips with automated testing to write functional tests that drive the application Expose your application to other developers with a RESTful API
Approach
This book is a guide to building a rich web application using Grails. The approach taken for building the application is incremental and iterative; each chapter will produce a working addition to the application, or iterate over existing features, as well as introduce and carefully explain the new part of the Grails framework used. The book does not go into exhaustive descriptions of every detail of Grails. While there is a lot of code in the book, there are very few large code listings. As you will find, it is not necessary to write reams of code to get results using Groovy and Grails.
Who this book is written for?
This book is aimed at Java web developers looking for ways to build web applications quickly, and wanting to find out how it's done quickly. If you are frustrated with integrating the many different frameworks that are available for web development and want to get on with building slick web applications for your users, then this book is for you. Grails is built on the Groovy language, but experience in Groovy is not required, as you will learn enough about Groovy to understand how to use Grails.
User review
Grails 1.1 Web Application Development
Read more here : [,,.]
Tag Line: Reclaiming Productivity for Faster Java Web Development
The target audience are Java developers looking for ways to develop web applications faster and more easy without throwing away their previous knowledge or leaving the java platform. Grails utilizes Java and other related proven technical libraries under the covers. With very simple explanation of basics the author tries to lure the average Java programmer to take a second look. But the book gets too technical and complex in some parts as it touches unwanted territory. Prior knowledge of java web application development is required.
Chapter 1: Getting Started with Grails
Right upfront an argument is given as to why Grails should be used and how it is based on proved technologies like Hibernate and Spring. The chapter lists the following important points in favor of Grails:-
Requiring less configuration
Faster setup
Shorter develop/test cycle
Consistent development environment
Domain-specific language for web development
Fewer dependencies
Perhaps some of the points would have been Grails v Java or Grails v Rails.
This is followed by installation of Grails. I think this is a very important and many books do not cover such topics. This part is has Windows and Mac screen shots. This follows creation of a new application called teamwork using create-app command. This creates the skeleton for domain, views, controller, conf, i18n, helper services, taglibs. To run this application run-app command is used.
Throughout the book a team communication portal application is used. The requirements and architecture of this application is explained in brief.
Chapter 2: Managing Users with Scaffolding
This explains the use of scaffolding and what pages and actions to expect as a result. Domain classes are created for the application using create-domain-class command. Controllers are created for all the domain classes using create-controller command. The def scaffold =DomainClassName magically creates all the CRUD code necessary for the application to work.
Grails uses in-memory HSQLDB database by default and at this point no configuration is necessary to get this started. Introducing static constraints helps in basic validation of data and to determine which input type is used when rendering a form. This is to get your application running quick but I hardly find a real-life example of this. Most databases are full of complex composite keys and foreign keys which cannot be modeled with scaffolding and need a lot of customization in Grails.
Relationships are created in this application. Since Grails uses hibernate under the covers the supported types of relationships are: One-to-one, One-to-many, Many-to-many, Many-to-many. Bootstrapping of data is done though grails-app/conf/BootStrap class which helps in loading data into the application on start up.
In short a fully loaded chapter to get started.
Chapter 3: Posting Messages
I find the title of this chapter irrelevant to Grails. Chapters should be given names relevant to Grails context and not application/example context. In this chapter the author talks about basic building blocks of grails - more domain classes, respective controllers and views, validation and GORM (Grail's Object Relational Mapping). dateCreated and lastUpdated are very special properties of type Date in Grails and they are handled automatically. This time the controller is not created with create-controller command but rather a file is directly created in the appropriate directory.
Groovy Server Pages (GSP) are introduced as being similar to JSP. The view code is then provided and again the command is not used for create.gsp. Grails uses simple yet powerful SiteMesh layout mechanism which uses tags g:layoutTitle, g:layoutHead, and g:layoutBody. There is more manual code to get the form appropriately displayed along with a short note about grails form tags g:form
The Grails input form, Grails form binding, validation and save cycle of Grails is explained briefly. The flash scope which holds the success or failure message between two consecutive HTTP requests is added. redirect is used to forward the user after a successful operation while render is used to show error information back to the user in order to correct it and re-send it.
The application home page creation is explained - domain, controller and views. Detailed explanation is provided of listing all messages by querying the database as well as the valid parameters for the list method. The author then explains how to change the default home page to go through the home controller index action. This is important when using plug-ins like cas for Single Sign On. The css style sheets are updated with the code available with the book. The author ends with an excellent section on cross-site scripting and validation. Grails provides a g:message tag that is used to look up messages in a message bundle based on a message code. This explains how i18n can be used in Grails.
Chapter 4: Introduction to Groovy
Groovy is the primary language used in Grails. This chapter covers some high level basics of Groovy with respect to Java, installation, data structures, closures, POGO, metaprogramming, builders. Definition of Groovy along with explanation of its properties are explained - Object Oriented, Dynamic and functional loosely typed. Similarly there are questions why Groovy makes software development simpler : familiar syntax like Java & direct integration into Java. The next phase takes us into how to install and configure Groovy on local PC and Mac. Groovy shell is a command line where you can type up some Groovy code. The Groovy console is a Swing application which allows user to write and execute Groovy scripts. This follows an explanation of difference between Groovy classes v scripts - Groovy scripts having less overhead and simpler to write.
All the basic features of Groovy language are explained including-
Optional Semicolons, different ways to express String, Numbers and utility methods, easier way to work with List, enhanced Maps, Range - which is a new data type to simplify iteration and work with collections, slightly different way to operate with Truth and equality, Closures - blocks of code which can be passed as arguments and executed, Plain Old Groovy Objects (POGO) whose properties are published as getters and setters automatically, Metaprogramming - also called Dynamic Groovy or compile-time metaprogramming and builders. All these features are well explained with simple examples which makes for good understanding of concepts.
This chapter was a welcome adding to the Grails book.
Chapter 5: Authentication with JSecurity Plug-in
This is where the power of Grails lies - the plug-ins! Some basic functionality would be developed as modules by programmers and made available to the world as plug-in. Installing a plug-in and following some simple configuration would give your Grails application some new features with cheap coding. Firstly, I would advise you to be careful of plug-ins since they are a double edged sword - in terms of who have developed them and the testing. Secondly, some plug-ins just don't work as advertised!!
The author has given example of JSecurity plug-in. This can be an excellent start for someone who is yet to think of a security strategy. Honestly it is scary for those who are new to plug-ins and find it so many pages to go through to get started. I would have loved to play with simple plug-ins like searchable, cas, filter pane. Such plug-ins are more commonly used. The author has used basic idea of users and roles. JSecurity system covers users, roles, permissions, subject, principle and realms (Realm class) . A method is defined to allow authentication. This is where the concept of dynamic finders is introduced. These methods do not exist but the name of method is used by Grails to query against database. There is good coverage of this topic including the operators that can be used for constructing the method name and their limitations. Querying by Criteria is explained with hasRole method which tests if a user has a particular role. Such queries are more complex and more widely used. But the explanation is short. Authentication is added to the Grails application using a Grails Filters which is quick and easy. Password encryption is achieved through Sha1Hash. This spins my head into thinking whether I want to really learn JSecurity or stick with my good old cas filter. It feels I am learning cryptography and not grails! Three more things are discussed which are: 1. Encryption of users' password: This uses the 'Open Session in View' pattern of hibernate which means the object is not persisted until all server-side operations have finished and the author actually changes the password after calling save method - Neat! 2. Permission denied page: This is done by implementing the unauthorized action in AuthController and creating unauthorized.gsp view. 3. Sign Out: This uses the signout tag provided by JSecurity which leads to a table listing of all JSecurity tags. The service layer of Grails and how to inject the service is discussed very briefly.
Hibernate's lazy loading property and how it affects the relationships in an application is discussed. The n+ 1 problem can be solved with eager loading (lazy:false)
In short, I feel this chapter was more a case study. There is a potpourri of new topics which are all discussed in short - plug-ins, JSecurity, authentication, authorization, encryption of passwords, services, lazy loading, eager loading, relationships to name a few - phew!
Chapter 6: Testing
This chapter starts with a background of testing. A couple of the links were very weird - pointing to a yahoo group? The chapter then goes on to define why tests are needed and how to write tests. There is a basic review of JUnit concepts before diving into how Grails leverages JUnit and extends it with some useful methods. The focus of the chapter is on unit testing, mocks, integration and functional testing (Functional Test plug-in) The author goes into detail to explain what makes a good test which touches the assumption of your libraries to be perfect, testing production code and using descriptive test names. A listing of all assertion methods and Grails provided assertion methods are provided. Most of this is self-descriptive but the shouldFail and shouldFailWithCause are explained with examples since they take a closure. When create commands are executed a test case is automatically created. A testcase is created by extending GrailsUnitTestCase. Running the test creates an HTML report.
An important point brought out is that the dynamic methods and properties supported by Grails framework are not available when running unit tests since they do not run within the Grails container. Mocking support helps us solve this issue. An in-depth example explains this behavior. This example also uses the delegate property on the closure. After testing the metacontroller the next test is of validations. Unit testing limitations are explained which leads to Integration testing. Integration testing is explained with only one example.
Limitations of Integrations test brings us to functional test. Functional testing is achieved in Grails through plug-ins eg. HtmlUnit. The book takes us through the installation of the functional-test plug-in and creation of functional test case for login.
I had a few issues getting the code to work. But overall a good attempt has been made to demystify the details of why we need tests, what are the different types of tests available and how to best take advantage of them.
Chapter 7: File Sharing
Grails has good support for file upload and download. To accomplish this a File domain is created with necessary attributes like data, name, size etc. Two methods of uploading are discussed 1. Using data binding, 2. Using Spring MultipartFile interface. The code uses the latter to achieve desired results. This model results in a file being loaded into the memory. Using the fact that relationships between domain objects are lazy by default the author then creates a more efficient model by extracting data out of the model thus creating a new domain called FileData containing this binary data. Thus FileData belongsto File. The last piece is the downloading controller and gsp. I found some glitches in the code.
Chapter 8: More GORM and Criteria
This talks about maintaining version history and advanced query techniques through GORM. Through Data Modeling, existing responsibilities of File class are extracted into FileVersion domain and FileData now belongsTo FileVersion. This makes the File class simply a container of FileVersion. (hasMany FileVersion). The explicit declaration of the version property as a SortedSet tells Grails that the items contained in this relationship must be ordered. This moves the discussion to criteria queries which help to retrieve data. This is where Grails taps into the power Hibernate (HibernateCriteriaBuilder) which is built on top of Hibernate criteria API. Dynamic finders in Chapter 5 are replaced with criteria equivalents. Each node is used to build on the criteria. Logical operators and Querying across relationships is explained next. The change in code affect the Hibernate EAGER fetch. There is discussion of fetchMode.EAGER which can be used to restore it. Table containing a full list of available criteria and logical operators for nodes is listed. There is not a lot of discussion of properties of criteria except for maxResults but links to Projections and Scrollable Results are provided.
This discussion leads to code changes in other layers. Updates to create method in controller and view are explained. Due to the domain changes, the save method in controller also needs to be changed. I observed that there is no error handling in the code and view.
Chapter 9: Services
Introduction explains why we need the service layer so that we can leave the controller to just handling the control of flow. This makes the service layer more testable and reusable and there is clear boundary where the business logic is placed. The command to create a Service is given which results in a Service class in appropriate directory. Grails uses Spring's declarative transactions. boolean transactional = false removes this transactional behavior. Similarly, Grails uses Dependency Injection mechanism to inject services into domain objects. This is an interesting and detailed discussion since Grails uses convention over configuration. It is so simple to write def fileService and inject an instance of FileService using loose typing without reloading application.
Strongly typed property FileService fileService can be injected but needs application restart. Services by default are singletons, and hence not thread-safe. Scopes of the Service can be changed using property static scope='prototype'. There is a table listing all scopes. The code is then modified to extract as much business logic from Controller into service as possible. How and why this is extracted and modified is explained. Thus the Controller is simplified.
Chapter 10: Managing Content through Tagging (sample chapter)
Being a Grails book, I would have thought of a better Chapter title. Check out this chapter online with the link given above.
The concepts discussed here are :
Working with inheritance in the domain classes, and looking at which strategies GORM supports for persistence
Using polymorphic queries over a domain inheritance hierarchy
Encapsulating view-rendering logic in GSP templates
Manipulating collections with the Groovy collect and sort methods
The Tagging Domain model is discussed and a new directory is created to separate the tagging classes from application domain classes.
Tag--to store the name of the tag
Tagger--to store the relationship from domain objects to a tag.
The domain classes are created and a service is created TagService having methods to create tag relationships. The collect method is used here as explained in Chapter 4. Elvis operator of Groovy is used in one of the methods.
Integration tests are created to make sure the relationships are working before introducing in application. During the integration tests the setUp method id overloaded and BootStrap class is used to create test data. Relationship with Message is created and TagService is injected. This is a very good and simple example of running Integration test.
Chapter 11: AJAX and RIA Frameworks
AJAX and rich applications have been the buzz word recently. This chapter touches on some plug-ins used for UI design in Grails. Grails uses Prototype framework for this support. remoteLink and formRemote tags of Grails are introduced and a complete listing of attributes and usage is provided. For inline editing of tags in the application Taggable controller is created. The author then takes us through the explanation of how this is to be done. I think this is an excellent start.
The next trick in UI design is the auto-complete of tags. There are two plug-ins: GrailsUI and RichUI out of which RichUI is explained in detail. Both these are developed on top of YUI. After installation, dynamic finder is used to match partial tag and come up with options. These options are converted to XML using renderAsXml method which take in a closure. This output is then used by the RichUI auto-complete widget richUI:autoComplete to create the autocomplete input field. Required gsps are created we are up and running. Beautiful example!
Another fashion is the the cloud of tags representing popularity. RichUI provides a component that handles all the client-side presentation work. The tag is richui:tagCloud. After a look at the available options we conclude that we need a map of tag and occurrences for this functionality. By adding another method to the service layer we get this matrix and controllers are changed to reflect this. listDistinct method is used on CriteriaBuilder inorder to get a distinct list. Clouds are then rendered using richui:tagCloud in appropriate gsps.
This chapter is beautifully written to capture user attention by tagging and then using these tags for auto-complete and clouds. This also helps in organizing and filtering content.
Chapter 12: Searching, RSS, and REST Services
This chapter introduces some more excellent techniques to help customers. Grails has an excellent plug-in for search : searchable plug-in which uses Lucene as the back-bone. This plug-in is easy to install and use. But people have just seen the tip of the iceberg. When I tried this plug-in on some complex projects with composite key relationships it wouldn't work. The project is pretty active and I hope all bugs get fixed. But by just including one line in the domain we can make a class searchable static searchable = true. Honestly, I used this section to make my first site-wide search and integrate it into my grails application. I was very pleased with the explanation. The trick is to create a search box in main.gsp and then create search controller which uses the search service to provide results. The results can be viewed by creating index.gsp in the search directory. The book then takes us into how to integrate this search in the application by adding code to main.gsp which is shared across pages as a header and creating a search controller which get its results from a search service. This SearchableService (provided by the plug-in) is injected into the controller. There are further changes to views and templates to display the search results.
This takes us into RSS feeds which is useful for customers to track new content. Grails has a Feeds plug-in built on ROME API. But the author takes this opportunity to introduce Builders in Grails rather than using this plug-in. Surprisingly, there is no definition about builders or why we use them!! To get around the problem of dynamic methods in controllers a separate utility class is created with a collection of items and closure. This is then called the controller to achieve desired results. Authorization is removed from this RSS which in terms of design seems wrong.
The last part takes us through REST support in Grails which is url based. This just involves tweaking the url mappings, controllers and security for handling HTTP method and XML data. Various URL mapping configurations in Grails are explained by snippets of code. The controller makes use of Grails converters (as XML). This should be used carefully when providing interfaces to clients. This follows a scheme for authentication of REST API messages through the same JSecurity scheme. The credentials are passed in the header of the request through the Spring application context. A script is used to test REST.
Chapter 13: Build Your Own Plug-in
Plug-ins are the selling point of Grails and they want you to write plug-ins! The book takes you into how to develop a tagger plug-in. Grails plug-ins are created similar to an application using grails create-plug-in command which creates a directory structure of an application plus a configuration file for the plug-in. This configuration file contains version, author and lifecycle details. The code previously used in the application is stripped out and plugged into this plug-in application. The plug-in templates are then exposed as tag libraries to applications so that the GSPs can render the appropriate templates. Similarly these templates can also be rendered through controllers.
The author then exposes an ugly flaw in the plug-in which is the domain classes need to extend the Taggable class for the plug-in to work. Later we are taught how to package a plug-in and create a distributable zip file which can then be installed using install-plug-in command.
The rest of the chapter talks about how to tap into the lifecycle events- (build time and run time) through Grails plug-ins. The Build events are not described in detail but the runtime events are explored in detail with regards to what they do and how they can be used. Runtime event handlers are enabled by declaring a closure with the relavant name in *Plugin descriptor class. The book then talks about inspecting Grails artifacts in this case all Grails classes to find a static property value of taggable. If found means the domain is taggable. The rest of the chapter talks about how to re-model the relationships between a domain object and its tags to remove the dependency and how to add taggable behavior into the application. This gets very complex and is beyond the scope if you are new to Grails.
I wish writing plug-ins was as easy as described in this chapter! Writing plug-ins is a major investment and even I would say half of the Grails plug-ins have unsolved issues with them. This also requires deep understanding of Groovy and meta-programming. The benefit is of course you have made a reusable component for the future.
Chapter 14: Deployment and the Real World
This chapter deals with installing and configuring MySQL and Tomcat to run on your system. The DataSource definitions in Grails are extracted out to DataSource.groovy with clear distinction between development, test, production.
To summarize, it was a good read. There are simple running examples of code tutorials. I would have liked advanced examples of the plug-ins like searchable. Filter pane which is an important plug-in is missing in the book. The Grails web site also has pretty simple and straightforward examples to learn from. Unfortunately for the book, plug-ins are the heart of Grails and keep updating. I wouldn't be surprised if the code runs out of date in a short period. I would have definitely liked more structured matter. Working in Grails - I find the biggest challenge is interacting with legacy database. There might be doubts about the correctness of the code and pattern used but it is important to remember that this is a starter book.
Who can use the book:
Starters who want to learn Grails. It assumes prior web development experience with Java & web applications. It contains a robust example of a web application being developed - a team communication portal.
You can visit [,,.]-development to directly download the example codes in the book
User review
Pragmatic approach to learn Grails while developing a Team portal
When I first received the book I was pretty sceptical if I could learn anything from another book about Grails right after having read 3 before. What made me think it was worth giving it a try was that the author is a British and that the reviewers are a Java champion and PhD. Hence, even though I could probably not have learned a lot about Grails or Groovy themselves, I would at the very least have learnt a bit of English. It didn't take me long to find out how much I was mistaken. The book was different than the others I read as its main concern was to combine designing and developing an web application being a team communication portal with Grails/Groovy lessons. From the very beginning to its end it's clear that the idea to convey was not how to write another book about Grails with its foundation based on proven solutions like Groovy, Hibernate and Spring Framework covered, but for its simplicity to build a modern web application. Every chapter was about some part of the web application and how it was to implement it in Grails. I'd say it was about how to make your projects more agile and goal-oriented (which was to build a fully functional application) rather than to show how sexy your project could be right after introducing Grails. Every chapter started with some intro to the issues Grails developers would face when our web apps were of more use and their solutions. The author called us `the pragmatic user-centered people`.
The book begun with presenting available projects and acronyms overwhelming Java newcomers (which certainly is the reason why so many say Java is tough). There's a place for Ruby on Rails, Hibernate, Spring Framework, Groovy and DSL. It's clear that we're approaching a moment in Java ecosystem lifecycle where having so many means one can still not find the one. At some point, the author mentioned about Stripes, but not Wicket or JBoss Seam, which I thought were better recognized as web application frameworks. It turned out that it was just at the final chapter where Wicket and Google Web Toolkit found their place in the book, but JBoss Seam didn't.
In the 2nd chapter I found a very interesting explanation about no package classes in Java and although I had known it's not a good practice to create ones I didn't know what the real issue was. Even after having read the Grails books earlier I didn't know that the names of the Groovy class properties were important and the scaffolding uses them to construct human-readable names for the views. It's clear now, but it had not been until I found it explained in this book. That's these gems which made the book worth its time. How many of us know that the scaffolding uses only 6 columns to build views? I didn't. The chapter 2 finished as early as it had started. It was quick and easy, perhaps too fast for Grails novices, but enough to let them create their first Grails webapp.
In the 3rd chapter I was pleasantly surprised when I had made a comment to myself about manual handling the lastUpdated and dateCreated properties after which came the author's comment that Grails takes care of it and we don't have to. Nice surprises come at a cost (of heart attacks or coffee on your keyboard). It was the time when one could read much about controllers, actions, views, taglibs, templates and models. With the explanation of the parameters of the dynamically-added save() method and the issue addressed by the redirect-after-save solution I knew I was learning Grails more and more. A couple of words about the XSS attack and how Grails takes care of it summed up the chapter.
The Grails operator overloading made an entrance to the 4th chapter. Java pros who are looking for leveraging Grails in their projects will certainly appreciate it. While the other books covered a lot about this topic, this one laid out just enough to add some new features to the web application. What I was pleasantly surprised by were the two methods - redirect() and render() which I had known existed in the Grails controllers, but had never understood they're added dynamically exactly as the methods of Grails domain classes. I didn't know that defining Groovy variables with the def keyword creates GroovyObject instances either. I had thought it's merely an Object instance. The other interesting points were about scripts in packages and asserts in Groovy turned on by default and out of the sudden (as it was not enough about Groovy) the author presented Groovy in more details. The so-called `whirwind tour of the Groovy language` was very informatory yet it made a gentle entry into the world of Groovy programming. The basics were laid out in a comprehensible manner.
The 5th chapter made a good point about grails.project.plugins.dir in BuildConfig.groovy so it's not an issue anymore to upgrade Grails while developing your applications with plugins. It was then when the first plugin in this book - JSecurity - was presented and why the dynamic finders are called dynamic. It's not that they're added dynamically, but,,.well, I'm sure you don't want me to spoil it. Read about it in the book. It's clear that the book was written by a Groovy/Grails practitioner at the very least (if not a Groovy/Grails guru). While presenting JSecurity there're the tip and trick block about accessControl in filters. I was about to have complained it's not fully explained when the block appeared. Exactly when needed. When it was clear that the controllers were doing too much work, the author showed Grails services. Keeping the pace was not an issue at all. Again, exactly in time when the different parts of Grails were presented. The book answered some of the questions which every web application developer has to work out and so did for the `n+1 queries` issue.
The 6th chapter made valid points about testing approaches and why they're necessary. I'd call it a testing refresher. Testing is quite often considered as an added benefit and only a few can take hassle to write them, but Grails simplifies it to an extreme minimum. The book presented it well and I'm sure that after having read the chapter nobody will ever be able to ignore it.
What I didn't like in the chapter 7. was the decision about storing the files in the database without much explanation why. I could find one myself, but I wish I had read about the author's take on it.
The chapter 9. turned its attention to the issue of developing controllers with too much business logic instead of just controlling the flow and using Grails services for it. Again, it's easy to repeat what's generally considered as a best practice, but it was this book that explained it to me clearly so it eventually became obvious. The part of the chapter about loosely- vs strongly-typed parameters was very informatory too. I'm not sure I could read about it in the other books.
The chapter 10. mentioned a bit about folksonomy which I had never heard before. Explaining the collect() method and the Elvis operator briefly was just enough to implement the necessary features in the web app. The author paid much attention to learning by mistakes and test-driven development. GORM inheritance was explained briefly with unimportant stuff left out. Grails 1.1 new feature - the template namespaces - was very precious addition.
The chapter 11. presented Prototype and RichUI plugins whereas the chapter 12. came with the Searchable plugin. As the author said it was `one more, but this time we can use this as an opportunity to become more familiar with Groovy builders, rather than instantly another plugin`. Quite a pragmatic approach, isn't it? It was again explained what the differences between Grails controllers and services are. Enough to keep that in mind for the rest of my life. Good design was a foundation for the book and the author never forgot to point out its benefits. New REST service mapping in Grails 1.1 was explained too. As the wrap-up for the chapter the author showed how to create a simple command for GAnt, which was just on a single page without even mentioning GAnt by its name.
In the chapter 13. the author took `a closer look at how other plug-ins work so we could borrow some ideas from them`. Taking it all in small steps helped a lot. There was a plan laid out, small discussion and implementation afterwards. It seems a lot of work, but the book made it very slick. It was however a very tough chapter which I barely understood. These advanced topics about developing your own Grails plugin were beyond my mental capabilities.
The last chapter was about setting up an environment with MySQL and Tomcat. I was glad to have read the Next Steps chapter about GORM-JPA, integration with other presentation frameworks and data migration. I wish the chapter about presentation frameworks with GWT and Wicket mentioned had been longer. Perhaps a good idea for the next book about Grails?
As the summary goes: `Each chapter builds on a sample application so that everything you learn about Grails is in the context of real examples`. I could only add that the sample app turned out to be a fully-fledged webapp. There're some typos in the book too, but they're harmless and one should not even take it into account while making a decision to read it or not. You should definitely read it and I wish you find the book as much informative as I did.
