Buy New

or
Sign in to turn on 1-Click ordering.
Buy Used
Used - Very Good See details
Price: £5.52

or
 
   
Trade in Yours
For a £0.25 Gift Card
Trade in
More Buying Choices
Have one to sell? Sell yours here
Sorry, this item is not available in
Image not available for
Colour:
Image not available

 
Tell the Publisher!
I’d like to read this book on Kindle

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Grails in Action [Paperback]

Glen Smith , Peter Ledbrook
4.5 out of 5 stars  See all reviews (4 customer reviews)
RRP: £28.99
Price: £23.06 & FREE Delivery in the UK. Details
You Save: £5.93 (20%)
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Only 1 left in stock (more on the way).
Dispatched from and sold by Amazon. Gift-wrap available.
Want it tomorrow, 27 Oct.? Choose Express delivery at checkout. Details
Trade In this Item for up to £0.25
Trade in Grails in Action for an Amazon Gift Card of up to £0.25, which you can then spend on millions of items across the site. Trade-in values may vary (terms apply). Learn more
There is a newer edition of this item:
Grails in Action Grails in Action 5.0 out of 5 stars (2)
£27.99
In stock.

Book Description

20 Jun 2009 1933988932 978-1933988931 1

For web developers used to wrestling with Java and XML, Grails is a breath of fresh air. Developers are instantly productive, picking up all the benefits of the Ruby-based Rails framework without giving up any of the power of Java.

Grails in Action is a comprehensive look at Grails for Java developers. It covers the nuts and bolts of the core Grails components and is jam-packed with tutorials, techniques, and insights from the trenches.

The book starts with an overview of Grails and how it can help you get your web dev mojo back. Then it walks readers through a Twitter-style social networking app-built in Grails, of course-where they implement high-interest features like mashups, AJAX/JSON, animation effects, full text search, rounded corners, and lots of visual goodness. The book also covers using Grails with existing Java technology, like Spring, Hibernate, and EJBs.

Purchase of the print book comes with an offer of a free PDF, ePub, and Kindle eBook from Manning. Also available is all code from the book.


Special Offers and Product Promotions

  • Between 20-26 October 2014, spend £10 in a single order on item(s) dispatched from and sold by Amazon.co.uk and receive a £2 promotional code to spend in the Amazon Appstore. Here's how (terms and conditions apply)

Frequently Bought Together

Grails in Action + Groovy in Action
Price For Both: £55.05

Buy the selected items together
  • Groovy in Action £31.99


Product details

  • Paperback: 520 pages
  • Publisher: Manning Publications; 1 edition (20 Jun 2009)
  • Language: English
  • ISBN-10: 1933988932
  • ISBN-13: 978-1933988931
  • Product Dimensions: 23.3 x 18.6 x 2.6 cm
  • Average Customer Review: 4.5 out of 5 stars  See all reviews (4 customer reviews)
  • Amazon Bestsellers Rank: 352,789 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, and more.

Product Description

About the Author

Glen Smith has been involved in the Grails community since Grails 0.1 and launched the first public-facing Grails app (an SMS Gateway) on Grails 0.2. He is a regular on the Groovy and Grails speaking circuit, the co-host of the Grails podcast, and the man behind groovyblogs.org.


Inside This Book (Learn More)
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index | Back Cover
Search inside this book:

Sell a Digital Version of This Book in the Kindle Store

If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store. Learn more

What Other Items Do Customers Buy After Viewing This Item?


Customer Reviews

4 star
0
2 star
0
1 star
0
4.5 out of 5 stars
4.5 out of 5 stars
Most Helpful Customer Reviews
2 of 2 people found the following review helpful
5.0 out of 5 stars A great learning aid and reference 16 Dec 2009
Format:Paperback
I own three books on Grails, and find myself referring to this one the most. I tend to want to know how to do
a particular thing - eg, "get a controller" going or "test that domain constraint" and have found the book to be
very good at answering those questions. In comparison, I personally found the other books dry and - while I'm sure the material is in them - found it difficult to find what I needed to answer my questions. I wish I'd bought this one first!
Comment | 
Was this review helpful to you?
1 of 1 people found the following review helpful
5.0 out of 5 stars Great book ... great application. 16 Sep 2009
Format:Paperback
The "In Action" are just so well presented and this book follows suit.

After following the Grails tutorials and documentation online, this book really is the perfect guide to getting things done!
Within a few days of purchase I was building an application which is now available for international users.
After years of java/struts devlopment, using Grails to build data interfaces makes web site development both truly enjoyable and productive!
Comment | 
Was this review helpful to you?
1 of 1 people found the following review helpful
5.0 out of 5 stars Very well written with great examples. 10 May 2010
Format:Paperback
I have used the Definitive Guide to Grails for quite some time now and I think it is a great book..... it is however, a little disjointed. I noticed this when I wanted to teach myself the in's and out's of testing in Grails. That's when I picked this up... the testing section alone is very well written and it is clear that the authors are very passionate about this stuff. The authors take a TDD approach... exactly what I was looking for. I have used the book as a reference ever since and it is great, I would recommend it to everyone.
Comment | 
Was this review helpful to you?
3.0 out of 5 stars Great book, now dated 8 April 2013
Format:Paperback|Verified Purchase
This is an excellent book, being both comprehensive and well written. Sadly it suffers from the Achilles heel of many technical books: the product it describes has changed radically since it was written. E.g. the example application, based on Grails 1.x, needs major surgery to work on 2.x, and the referenced version of Spring Security is obsolete.

That said, it is still a decent introduction to an amazing framework. To get the best from it, I recommend using Grails 1.1.2 while working through the example application, then installing the latest version (currently 2.2.1) and reworking the code until it works again. You will learn (and swear) a lot.
Comment | 
Was this review helpful to you?
Most Helpful Customer Reviews on Amazon.com (beta)
Amazon.com: 4.1 out of 5 stars  15 reviews
14 of 14 people found the following review helpful
5.0 out of 5 stars The best way to get started with Grails 13 July 2009
By Trevor Burnham - Published on Amazon.com
Format:Paperback|Verified Purchase
I've read both this book and the older Definitive Guide to Grails, Second Edition, and I'm happy to report that Grails in Action is both more concise and better-organized than that other (nonetheless excellent) tome. It is also slightly cheaper and, until Grails 1.2 is released (it's in early milestone as of this writing, so I wouldn't expect it to be production-ready before 2010), pleasingly up-to-date. There are very few errors, and if you find any, the authors will be happy to help you sort them out in the book's official forum.

The book's great strength is its organization. There's all kinds of online documentation for Grails, including a decent reference manual at grails.org, but searching through the mailing lists and the JIRA when the framework does something unexpected is no fun at all. Grails in Action starts off right with a primer on Groovy (which I found refreshing, even though I've read Groovy in Action), then jumps into practical Grails concepts, which it teaches by example. (The central project of the book, a low-budget Twitter clone, is an excellent showcase for Grails.) The later chapters introduce advanced concepts that are extremely useful but not covered (or not covered well) in Grails' documentation. For example, Chapter 13 tells you how to improve database performance by setting up and enabling EhCache; how to use p6spy and sqlprofiler to easily time your database queries; and how to migrate your database using Liquibase. Other chapters talk about concepts like REST and JMS with surprising clarity.

Whether you're a beginner or an experienced Grails developer, I'd say that this is the only Grails book you need.
10 of 10 people found the following review helpful
5.0 out of 5 stars Grails developers spoiled for choice 3 Aug 2009
By Michael G. Kimsal - Published on Amazon.com
Format:Paperback
I've been following Groovy and Grails books for a couple years now, and own nearly all of them. Each one has filled a niche, and almost all have been great in letting the voice of the authors come through while keeping the style of the publisher (Manning books have a different feel from Apress, for example).

I had high hopes for this book, and wasn't disappointed. It had tough competition from the recent The Definitive Guide to Grails, Second Edition (Expert's Voice in Web Development) but I think this book *slightly* edges out that one as a Grails resource. Why? It's slightly more up to date, for starters. The chapters on dealing with legacy databases and on adding security to an app were both a bit more informative, or at least I found them a bit easier to follow. This is not to detract from the DGG. If you *can*, I'd recommend owning both, as each presents similar information in a unique style. The Grails in Action book feels somewhat more conversational, which made the reading easier for me.

There's a lot more substance other reviewers have given on this book - I'm not sure I'm going to go in to as much detail as they have. Suffice it to say that this is currently my book of choice for working with Grails these days. Glen and Peter have packed an incredible amount of information in to 500 pages, with concise writing, useful examples, and just enough humor to keep it entertaining without losing its utility.

For most of 2008, I was recommending Beginning Groovy and Grails: From Novice to Professional (Beginning from Novice to Professional) from Christopher Judd and company. For my money it was *the* book for 2008 for Grails developers. I think given the advances in the past several months, both the new DGG and this new Grails In Action book deserve to share the title of "Best Grails Book". You can't go wrong with either book.

As an aside, I'd also recommend Groovy and Grails Recipes from Bashar Abdul-Jawad if you're looking for a companion piece to Grails In Action. It provides a 'recipe' approach to quickly finding the code snippets you need to solve a particular problem.
9 of 9 people found the following review helpful
5.0 out of 5 stars An Excellent Book! 2 July 2009
By Surya Suravarapu - Published on Amazon.com
Format:Paperback
I've written this review on my blog, reproducing it here:
-------

The book is organized into four parts:
* Introduction: The very first chapter is aptly titled as `Grails In a Hurry'. If you are a complete beginner to Grails you will be blown away with the productivity and the powerful feature set of Grails on display. Many concepts explained in detail in the later chapters are summarized with a simple example. Second chapter goes over Groovy basics, which is adequate.
* Fundamentals: I think taking up a non-trivial example to explain the concepts of a framework is nice. A Twitter-like application is built during the course of this part of the book. This part explains about using GORM (Grails Object Relational Mapping Library), techniques for using Constraints for validation, power of Grails scaffolding, usage of dynamic queries, controlling application flow and the usage of services, introduction to GSPs and the discussion about views and layouts (along with AJAX stuff).
* Building more features into your applications: How well different levels of testing (unit, integration, functional) are integrated into the framework is discussed. This part then continues with the basics of plugins and their usage. One of my favorite chapters in this book follows next, workflow with Grails Webflow. Security is discussed in some detail, but the chapter that follows really stands out (especially for a huge REST fan like me) -- explains how to design and implement a RESTful API showcasing Grails support for this architectural pattern.
* What you need to know for real work: The last part of the book explains about -- messaging and scheduling, some advanced GORM concepts, how to use Spring and transactions with Grails, and about plugin development. The chapter on advanced GORM concepts is well written; folks who intend to use Grails for enterprise-level applications will certainly benefit from this chapter.

This is my first formal reading of a Grails book, but have some decent exposure to the concepts of Grails (from the available documentation, and by the presentations that I attended in the past). So for me, introductory chapters and some of the fundamentals are well-needed refreshers, but the last two parts really stand out. Some points from my notes:
* For integration tests, Grails bootstrap the database and wires up all components just as it would for a running web app.
* Domain class relationships (1:1, 1:M, M:N) are explained quite well from the Grails point of view -- belongsTo variations, hasMany and GORM magic of automatically adding new methods to account for the defined relationships.
* Groovy querying with dynamic finders: Dynamic finders take advantage of funky Groovy metaclass magic to intercept all method calls on a domain object; leverages Groovy's methodMissing feature.
* Use flash scope for passing messages to the user when a redirect is involved.
* Extensive discussion on the Grails form taglibs, and on creating your own tags.
* Mocking is built-in the framework for productive unit testing.
* Webflow introduces a new scope: flow scope. Items put in flow scope live for the life of the flow. Favor flow scope over session scope -- Webflow will cleanup the storage for you and give you more efficient server memory.
* The chapter on implementing the REST architectural pattern is a must read; Grails supports the pattern out-of-the-box.
* Grails uses OSCache as its default cache library (for Hibernate's second-level cache). The reason suggested was that it plays well with Grails developer restarts, something I would like to understand further in reference to Ehcache. But the authors actually used Ehcache in the book suggesting that it is a better library (I agree!).
* So easy to declare caching at the domain level:
static mapping = {
cache: "read-write"
}
* Discussion on integrating with legacy databases is interesting, but would like to see some case studies to understand the real pain involved.
* Transactional services are implemented using Spring's AOP mechanism (Spring's TransactionProxyFactoryBean).
* Integration tests run inside a transaction by default, which is then rolled back after each test finishes. This ensures that data changes don't affect other tests, but it means you can't check whether transactions are rolled back or not. If you want to test transactional behavior then you need to add a static transactional property to your test.

Conclusion
----------
The book is very well organized and the topics chosen are well thought of. An easy conversational tone is used through out the book. In my opinion, this book succeeds in building a sustained interest about the framework. It is also an excellent reference book on the topic. Strongly recommend the book for all Grails enthusiasts.
7 of 7 people found the following review helpful
3.0 out of 5 stars a good introduction to Grails, but not for front-end devs 5 Dec 2010
By R. Friesel Jr. - Published on Amazon.com
Format:Paperback|Verified Purchase
Not to be too much of a self-apologist, but let me preface this review by indicating that my frustration (and hence my lower rating) comes largely from gaps in my own knowledge. But as a result of those gaps, I wasn't able to reap this book's full benefits. So first, what was my impression:

Grails in Action is a fast-paced overview of the Grails platform, with an even quicker overview of the Java-based Groovy language that powers it, and some at-a-glance discussions of some other underlying frameworks and technologies (e.g., Spring, Hibernate, SiteMesh). The book's approach is to take you through the platform in a learn-by-doing approach, walking you through the major language features by building an application in Grails that takes advantage of all (or at least most of) its major features. By building the application alongside the authors' text, you get yourself familiar with those features, their syntax, and the philosophy behind it all.

Sounds great; but, a brief segue on why I didn't reap the full benefits:

My work is mostly on the front-end, and over the past couple years I've been writing object-oriented JavaScript almost exclusively. But as Grails has been getting introduced into the mix for a lot of new projects, it was time to dive in. And despite my excitement about making the transition into a more full-stack role, my day-to-day would still be mostly on the front-end. When Grails got onto my radar, I knew right away that most of the work I would do was going to be in the controllers, views, and layouts. So that's what I wanted to learn about; I wanted the best possible introduction to Grails for front-end engineers.

So why the disappointment? Grails in Action wasn't really written for front-end developers. I suppose I could have figured this out if I'd taken a look at the pedigrees of either of the authors--there's a lot of Groovy and Java there. But that colors the approach, and when they say "previous experience with Java web development is an advantage"--they mean it. Not knowing Java--and/or not doing much work on the band end--will slow down your understanding.

With that out of the way, what were the good and the bad?

THE GOOD:

(1) I agree that the "learn by doing" approach is the best way to go. Nothing helps it "stick" quite like getting your hands dirty. That said, this particular learn-by-doing was a strange mix of hand-holding (e.g., "Right, OK that was obvious.") followed by cavalier glossings-over of other aspects (e.g., "Wait--what?--where did that come from?").

(2) Part 1 ("Introducing Grails") and Part 2 ("Core Grails") are fantastic overviews of the core "90% of your time" features in the Grails platforms. There are some outstanding and very clear explanations of those features, the philosophies that guided the implementations of those features, and how best to apply them in a given context. By the end of Chapter 6, you'll be in a decent position to start banging away on your own apps.

(3) The chapters on build systems, writing your own Grails scripts, and plugin development are very informative and show the kind of real power that lives under the Grails covers.

THE BAD:
And/or, the critiques both big and small, and a few other things that couldn't be helped:

(1) The Grails community is moving fast, and though I would not call the book "out of date", there were some quirky differences between Grails 1.1 (the current version when they wrote it) and 1.3.5 (the version I had installed during my reading). One example that came up during the first chapter: their exercise on pages 19-20 said to type "new Quote" when what was really needed was the namespaced version ("new qotd.Quote").

(2) As I already mentioned, the emphasis on the book is much more about what's going on in the back end and so front-end developers (like myself) may find themselves a bit lost or otherwise not getting what they came for. The authors write "some experience with web development (in particular CSS, HTML, and JavaScript) is assumed"--but I felt like you could get by without really having much more than a cursory knowledge of these. (JavaScript and CSS really didn't come up in any substantive at all.)

(3) There's an awful lot of time given to writing tests and testing. OK, I get it--testing is important and can help you save yourself from yourself. But there were quite a few features of the language that got not-as-much (e.g., "At what point is UrlMappings.groovy parsed? processed? How does that work?") or else not-at-all (e.g., "What's supposed to go in that 'src' directory?") coverage that would have been nice to see instead of that whole chapter on testing.

(4) Plugins, plugins, plugins... Again: "OK, I get it..." As a platform, Grails is all about plugins--it's a conglomeration of plugins to start with, and it has a vibrant community of plugin writers. And that is marvelous. But once plugins are introduced (in (surprise!) the chapter on tests and testing), every chapter after that includes a line that reads "grails install-plugin name-of-plugin". Perhaps that is (shall we say) idiomatic Grails development, and perhaps the implied take-away is "install the plugin and examine its source code", but that time might have been better spent discussing the problem and the "how" of the solution instead of just dropping one in.

TO CONCLUDE:

I would stand by Grails in Action as an excellent primer on the major features of Grails, and its hands-on approach should help you get comfortable with the key features quickly. But if you're a front-end developer looking to get started with Grails, this probably is not the best introduction. It seems to skip over some aspects of the platform or else give only cursory explanations, but then it spends a lot of time talking about and working with domain classes and the technologies behind them. Again, this is probably fine if you're already a seasoned Java or Groovy programmer on the back-end, or already fancy yourself an adept full-stack developer--but if you've spent most of your time in the browser, you may find it tough to wade through some of what's in here.

For my money, I'm still looking for that good introductory book on Grails. Grails in Action was worth the read, but I think I'll need to give it a second pass after I've found my feet.
6 of 6 people found the following review helpful
5.0 out of 5 stars The concise definitive guide to Grails 24 Sep 2009
By Jacek Laskowski - Published on Amazon.com
Format:Paperback
I was very pleased when I received a copy of the "Grails in Action" book by Glen Smith and Peter Ledbrook from Manning. I heard that it was really a good book and it didn't take long to prove so. It's my fourth book about Grails after "Beginning Groovy and Grails: From Novice to Professional", "The Definitive Guide to Grails, 2nd Ed." and "Grails 1.1 Web Application Development", so I didn't expect much new. It was meant to be a time well spent with Grails which I'd thought I'd already knew. I couldn't have been mistaken more.

I started reading the book right after having finished "Grails 1.1 Web Application Development" from Packt and if I had to suggest any reading order it'd be exactly as I followed with a small exception of "The Definitive Guide to Grails, 2nd Ed." being before the last one, i.e. "Beginning Groovy and Grails: From Novice to Professional", "Grails 1.1 Web Application Development", "The Definitive Guide to Grails, 2nd Ed." and "Grails in Action" for letting your Grails knowledge settle down a little. If you don't fancy reading books you can even skip the first two and rest assured you will get much if not all about Grails. They're written by people who not only participate actively in Grails development itself, but even know how to write about it with much fun.

Glen and Peter are active Grails developers. They write about themselves "we're practitioners, not theorists" (page 66) so it shouldn't come as a surprise that their book is all about what every Grails practitioner would anticipate and appreciate - what Grails is, how one should approach Web 2.0 projects with it under his/her belt and how to extend its capabilities while developing "a simple microblogging application in the style of Twitter". There're a lot of pages how Grails works behind the scenes without more ado. Every piece of Grails is laid out and discussed with enough details to make anyone a Grails pro. Every now and then, they point out an interesting piece that can only please readers by giving them what one must otherwise have dug in the Grails sources. It's succinct and to the point. It kept me reading for almost a week and each and every chapter gave me more and more reasons to develop applications in Grails only (it scares me a lot too, to be honest). Not only do the authors mean to present all the Grails features, but they do it with a great sense of humour. One of the most valueable parts of the book are the tests to show how exactly a given feature works. Hate it or love it, but the authors drew enough attention so they're not forgotten as a good practice in our development endeavors. There're lots of unit, integration and even integration tests. I must also admit that some parts of the book I didn't like much. I'm not really sure if it was because I was simply swamped with the intricacies of Grails or the pace which I considered too fast in some parts of the book or yet it was something else not necessarily Grails-wise. Even though there were pages I didn't like I couldn't resist reading the book further.

"Grails in Action" is made up of 4 parts. The very first one is to introduce you to Grails as a web framework developing a simple web application with scaffolding and other basic stuff accompanied by the chapter about Groovy, the Grails language. It could seem it is not worth its time, but I strongly recommend reading it. It is not just an introductory material for newbies, but comprehensive introduction to Grails basic features and Groovy. Part 2 covers core Grails features like domain classes, controllers, views, taglibs (with iteration tags), command objects and services whereas Part 3 uses plenty of plugins for real Web 2.0 application development. Part 4 is not meant for faint-hearted and describes the Grails foundation - Hibernate and Spring Framework - focusing on their use by Grails. The chapters begin with a very short and concise introduction to the features at hand, say 2-3 pages, and out of the sudden you're engaged in a real Grails development. 15 or 20 pages after and you're out with a couple of guidelines to wrap things up, ready to roll your sleeves up and dive into projects hoping Grails will make them finished faster.

Even after "The Definitive Guide to Grails, 2nd Ed.", you can find a lot about Grails and it's hardly possible not to take some additional notes. I'm used to take some and believe me or not, that book made me stunned for quite a while very often. I thought no other book could've beat "The Definitive Guide to Grails, 2nd Ed." by Graeme Rocher and Jeff Brown, which is truly the definitive guide to Grails, but it was just "Grails in Action" which I read with my mouth opened experiencing the beloved "Aha!" moments quite often. It is now my book number one about Grails 1.1. With the recent changes in Grails 1.2 I hope it's not the last book by Glen and Peter.
Were these reviews helpful?   Let us know
Search Customer Reviews
Only search this product's reviews

Customer Discussions

This product's forum
Discussion Replies Latest Post
No discussions yet

Ask questions, Share opinions, Gain insight
Start a new discussion
Topic:
First post:
Prompts for sign-in
 

Search Customer Discussions
Search all Amazon discussions
   


Look for similar items by category


Feedback