grail

"With frameworks like Grails, you can build working Web applications extremely fast, just as you could with Rails, " he said.

It would be the dawn of a new era of regenerative medicine, one of the holy grails of modern biology .

Those methods are just a small sampling of the many dynamic methods that Grails provides for your domain classes.

This setting allows you to have Grails update your database schema at runtime to synchronize it with your domain classes.

The only project that has more downloads and a busier mailing list is Grails, a popular Web framework implemented in Groovy (see Resources).

Although the standard Grails tags are quite helpful, you'll eventually run into a situation where you want your own custom tags.

Finally, whatever the results are, use the JSON converter from Grails to turn the list into a JSON object.

The constraints we defined represent just a small sample of the validation that Grails offers.

You were able to develop it rapidly and had to write less code because you took advantage of Grails.

The bulk of the method is identical to what you'd see if you typed grails generate-controller Airport at the command prompt.

As a matter of fact, a GSP page is nothing more than standard HTML with some Grails tags mixed in for dynamic content.

Like the Flex-based application, this will be a completely client-side application that will call your Grails-powered services.

Like Maven, Rails, and AppFuse, Grails scaffolds out a standard directory structure for you.

Grails provides a message resources file for you to define your own custom error message.

But seeing how long it takes Grails to spin up to run the integration tests, this option is less than appealing.

Thankfully, a number of URL-shortening Web services are out there practically begging to be integrated with Grails as a custom plug-in.

DK: Grails makes it easy to implement a well-designed web application.

Grails embraces modern practices like the Model-View-Controller separation of concerns and convention over configuration.

Getting back to the hypothetical story of you debugging a live Grails application, you still haven't found what you are looking for yet.

On the front end, Grails handles 1: m relationships with aplomb as well.

Try the Shiro Grails plug-in, which provides a few new scripts that you can run to create different realms and controllers.

But Grails isn't just a simple "me too" port of Rails to the Java platform.

To see both the init and destroy events fire, start up Grails in interactive mode by typing grails interactive.

To do so, you could easily instruct your build script to copy these files from the JEE project into the Grails project at build time.

In " GORM: Funny name, serious technology, " you were introduced to the basics of GORM, including simple one-to-many relationships.

Last month's inaugural Mastering Grails article introduced you to a new Web framework named Grails.

By commenting out this property, we're instructing Grails to leave the schema as is.

Although the semantics of Atom might be new to you, the mechanics of producing an Atom feed using Grails should be pretty straightforward.

To see how Grails creates the select field for Airlines, type grails generate-views Flight.

As you can see, creating a Grails plug-in is not much different from creating a typical Grails application.

All that's left is to finish configuring Grails to use it.

If ShortenUrl were a public plug-in, you could type grails release-plugin to push your changes to the Grails Plugins portal.

In the next Mastering Grails article, you'll flesh out the user authentication and authorization story more fully.

The geonames. org geocoding service you used in " Grails services and Google Maps" offers JSON output as well as XML (see Resources).

Running a Grails application on your existing production server is no problem either.

The first two articles in this series introduced you to the basic building blocks of the Grails Web framework.

And in subsequent installments, I'll explore the Grails plug-in ecosystem further with you.

uses Grails for some of the commercial parts of its site.

Then, enter grails run-app, and we're ready to test the validation.

As different as Grails development is from other typical Java Web frameworks, you still end up with a Java EE-compliant WAR file.

All of the parts of a typical Grails application are right here in this plug-in.

To do this, simply copy it to the web-app folder in the Grails application, as shown in Figure 1.

The reason given was that the grails lead developers feel they can get better "service" on issues from internal tomcat developers.

Type grails run-app and confirm in JConsole that the log4j MBean doesn't show up in development mode.

Many of these plug-ins are community-driven, the result of people wanting to use Grails with their presentation-tier technology of choice.

However, Grails generates the web. xml file each time you start your application, so it isn't necessary to modify a web. xml file by hand.

This method instructs Grails to metaprogram the validation methods onto the specified domain class as it would normally during run time.

You first returned JSON from a Grails controller in " Many-to-many relationships with a dollop of Ajax. "

He cited Grails as an example of a simplified enterprise stack built on top of the Java platform.

Mastering Grails: Read more in this series to gain a further understanding of Grails and all you can do with it.

Now that you have a geocoder in place, the next step is to integrate it with your Grails application.

InfoQ: What is the role of Grails framework in Enterprise Application Development space, especially in terms of scalability and performance?

Grails comes pre-packaged with HSQLDB, but since we're using MySQL, we have a few quick steps to tell Grails how to talk to our database.

Mastering Grails: Scott Davis's companion series focuses on this Groovy-based platform for Web development.

The online Grails documentation lists all the available Grails tags and gives examples of their use (see Resources).

I'll preserve this spirit in next year's columns, but I also want to expand the horizon to include a variety of Grails applications.

His affable style and dedication to both Groovy and Grails has resonated with a broad swath of readers.

Other topics covered in the book are Grails Security, Integration Testing, AJAX, Custom Tags and Plugins for Grails UI and Twitter website.

For a complete listing of available validation rules, see the Grails online documentation (see Resources).

Recall from the last article that Grails can run in three modes: development, test, and production.

In the second part of this article, you will learn how to integrate memcached into a Grails application.

The resulting directory structure is identical to a typical Grails application.

provide at least a basic level of support for Grails development.

In February, I refreshed my Grails knowledge, later learning that it was tough to teach Grails to developers that didn't know Java.

Interestingly, you don't need a separate Web server installed to run Grails applications.

These parameters, like all request parameters in a Grails application, are exposed through the params object.

This month, I'll round out the MVC triptych with a discussion of Grails views.

To do so, you can use the Grails command create-service and refactor your code to move business logic to the service class.

Be sure to check out the Grails documentation for the complete list of available constraints.

You saw the grails. converters package in action in " Many-to-many relationships with a dollop of Ajax. "

Grails also integrates very nicely with the many Java libraries and frameworks that these enterprises are already using.

Once you find the right geocoder for the job, create a Grails service to encapsulate the remote Web services call in a reusable method call.

You can, of course, type grails test-app -integration to run just the integration tests.

This change simply points a production instance of Grails at an underlying MySQL database running on the same machine (localhost).

You'll see some generic interfaces generated by Grails that support CRUD (create, read, update, delete) on my domain object.

Grails supports Spring configuration through an alternate file: resources. groovy.

You'll revisit the RESTful side of Grails, but in the context of setting up a full Atom infrastructure.

InfoQ: What do you think about the role of Grails as a Domain Driven Development (DDD) framework?

For each new feature you add to your Grails application, you'll most likely touch the model, the view, and the controller.

Grails automatically provides dynamic finders for just about every query combination you can think of!

If necessary, download and install a Grails-compatible version of the JDK (see Resources).

By default, all fields in a domain class are required to be nonnull in Grails.

But because you are in a plug-in instead of a full Grails application, you cannot assume that a database will be in place.

You will kick-start your development using some of the Grails code-generation scripts.

The line in application. properties corresponds to the unzipped directory in your project directory in . grails.

Grails encourages a bottom-up development process, where you usually start by defining your domain models.

In the next article, you'll get a chance to play around with the Grails event model.

If you aren't already in the habit of writing tests, allow Grails to nudge you gently in the right direction. You won't regret it.

When you typed grails create-domain-class Trip, a test was generated on your behalf.

You can find examples of one-to-one and many-to-many relationships in the online Grails documentation; see Resources.

This resets the autonumbering back to 0 when Grails recreates the tables the next time it starts up.

The script compiles code from the grails-app tree and combines it with code from the base Grails ($GRAILS_HOME) directory.

A better solution is to have Grails automatically convert spaces to underscores depending on where the Entry. title is used.

To run the application, simply issue the Grails command run-app.

As I demonstrated in the preceding section, Grails uses select fields by default to display 1: m relationships.

Grails looks for the constraints declarations in the same directory as our domain class.

Grails gives you a place to store commonly used methods that transcend any single domain class: services.

Even if you've never used Hibernate or Grails before, you can quickly get the gist of what's going on here.

Many Grails plugins also provide DSLs to interact with the libraries or frameworks they wrap.

The event handling in Grails can be managed both at macro and micro levels.

Obviously, there's no shortage of alternate view solutions for Grails applications.

Though I don't think any single framework will ever hold the spot that Struts did, I think Grails will become the leading JVM web framework.

We believe this makes Grails development a quite a lot more enjoyable.

The event closures are called by Grails when the corresponding "events" get generated in the Gant script.

The latest improvements in this area added support for Groovy and Grails applications.

This directory is where the compiled classes are stored when you type grails run-app.

Grails takes the lessons learned from Rails and mixes them with the sensibilities of modern Java development.

The Plug-in Developers Guide: Here's the online documentation for Grails plug-in developers.

Type grails generate-views Airport at the command prompt to create the GSP files.

Events throughout Grails can help you further customize the way your application behaves.

Over the past several Mastering Grails articles, you've been building a tiny little blog service ( Blogito) piece by piece.

Grails uses this feature to provide DSLs for ORM mapping, wiring Spring beans, and other configurations.

When you type grails clean, the application directory under projects is deleted.

It also uses the Elvis operator you first saw in " Testing your Grails application. "

If you reboot Grails, it reverts to the persistent settings in Config. groovy.

Type grails create-app foo to create a simple application.

Grails tries to wrap each test in a database transaction.

But rather than talk more about how Grails works, let's see it in action.

Grails will continue to support both jetty and tomcat integrations, but will move to tomcat hosting mode by default.

Grails supports two basic types of tests: unit and integration.

To embed a Google Map in your Grails application, the first thing you need to do is get a free API key.

In the next article, you will learn how to deal with legacy databases in Grails.

If you are using Grails in front of a legacy database, I highly recommend commenting the dbCreate value out altogether.

Finally, the columns block maps the Grails names to the database names.

Type grails test-app -unit to run just the unit tests.

You'll get a brief introduction to Spring configuration in Grails.

Grails produces a standard JEE WAR that can be deployed to their existing application servers.

Type grails test-app -unit User to target the specific test class you are interested in.

The mapping block is especially helpful if you have existing legacy tables that you'd like to use in your new Grails application.

The trouble with this implicit constraint is that you usually interact with Grails via an HTML form.

DK: Tool support for Groovy and Grails is constantly improving.

By simply having a member variable following the xyzService convention, Grails knows to inject the xyzService singleton.

DK: Grails borrows many principles and ideas from Rails, as does Lift.

The event handlers for Gant scripts, available since version 0. 5, are triggered during execution of Grails target and plugin scripts.

To begin, type grails create-tag-lib Login at the command prompt.

We're using the Grails tag library to help us out here.

I can also call commands inside the IDE coming from Grails plugins, which I can install from within the IDE too.

You should see Grails in the list of local JMX agents, as shown in Figure 1.

In the next Mastering Grails installment, I'll turn my attention to testing.

When you run this test by typing grails test-app -unit AdminService at the command prompt, it fails.

However, the problem with that approach is that you must migrate your customizations each time you upgrade Grails.

The def scaffold = Trip line instructs Grails to generate the GSPs dynamically at run time.

This naked objects pattern of decorating the domain object (see Resources) is used extensively throughout Grails.

In addition to build events, Grails developers can also catch application events for customization of the application logic.

Obviously Grails builds on Spring so the acquision made a lot of sense from an infrastructure perspective.

Restart Grails and upload the Grails logo once again.

You now have Grails using a database other than HSQLDB.

Type grails run-app to verify that your mapping block works.

In order to answer the challenge of "Agile" or "Rapid" development, technical solutions like Ruby on Rails and Grails emerged.

Restart Grails with these new settings.

life cycle events of Grails domain classes.

My examples use the Grails logo; you can use any image file you'd like.

If you have more trips to display, Grails creates previous and next pagination links automatically.

Type grails test-app and verify that your test passes.

I'm often asked if I think that Grails is enterprise-ready. The short answer is yes.

Specifically, all Grails artifacts get a log object injected into them at run time so that they can easily log messages for later review.

This article shows you how to optimize your Grails applications for mobile browsers.

When you type grails war, the web. xml file found here is what gets included in the resulting WAR.

The grails test-app command, in addition to running the tests, creates a nice HTML report.

InfoQ: Are there any features that currently don't exist in Grails framework you would like see added?

Anyone could then type grails install-plugin shortenurl to integrate it with their project.

But to appreciate Grails fully, you have to experience it first-hand.

To start Grails in beta mode, type grails -Dgrails. env=beta run-app.

Grails recently released version 0. 5, with improved performance, custom URLs, enhancements to GORM and more.

There are Grails plugins that allow for easily adding features such as caching, clustering, security, search, web services, etc.

In the book, Dave explains how to use Grails by iteratively building a sample web application called TekDays. com.

DK: Grails is a great fit for any enterprise that is already using Java.

This will guarantee that the Grails versions of these classes are loaded and we will not have any nasty class-loader conflicts.

This is really more of a personal desire, I think that Grails support or any of the other points I have listed would affect far more people.

Make sure you're in the project's root directory - in our case, it's ejb3_grails.

And finally, you'll explore the life cycle events of Grails domain classes.

This example shows how to use the filters in Grails.

This is what I use in most cases because it feels the most Grails-like.

Well, Grails doesn't require that you have an EJB3 application as your starting point.

So, let's see what it takes to build a Grails application backed by EJB3 entity beans.

The static mapping block is the easiest way to accomplish this task because it is the most Grails-like.

Grails: This article uses Grails Version 1. 0. 3.

What is important is that your application is set up according to the Grails conventions.

Finally, Grails copies and unzips the plug-in from the local cache to your project, as shown in Listing 9

To run the failing test, type grails test-app at the command prompt. You should see the results shown in Listing 5

Add three new lines to your Grails startup script, as shown in Listing 4

Deploying a Grails application via Tomcat's management interface

You should see Grails output a few lines ending in something like

Okay, you do need to have a JDK installed. (Grails is good, but it's not that good. )

When you type grails clean and choose the local version of the script, you should see

Accessing a database pool from Grails

If you forget this final step (I do nearly every time I use EJB3 annotations in Grails), you'll get the following error message

On convincing someone to try Grails for the first time