Grails (Framework)
From Wikipedia, the free encyclopedia
Grails is an open source web application framework for high productivity. It's based on the Groovy programming language and is part of the Java platform. Grails has been created to attract new users to the Java platform and to give Java developers capabilities for building web based applications that never have been available before.
It's a web framework meaning no provisions are made to serve other architectures. Although the 0.1 release has only been released on March 29, 2006 work has started in July 2005.
Contents |
[edit] Overview
Grails has been developed with a number of goals in mind:
- Provide a high-productivity web framework for the Java platform.
- Offer a consistent framework that takes away confusion and is easy to learn.
- Offer documentation for those parts of the framework that matter for its users.
- Provide what users expect in areas that are often complex and inconsistent:
- Powerful and consistent persistence framework.
- Powerful and easy to use view templates using GSP (Groovy Server Pages).
- Dynamic tag libraries to easily create web page components.
- Good Ajax support that is easy to extend and customize.
- Provide sample applications that demonstrate the power of the framework.
- Provide a complete development mode, including web server and automatic reload of resources.
Grails has been designed to be easy to learn, easy to develop applications and extensible. It attempts to offer the right balance between consistency and powerful features.
[edit] High productivity
Grails has three properties that increase developer productivity significantly when compared to traditional Java web frameworks:
- No XML configuration
- Ready-to-use development environment
- Functionality available through mixins
[edit] No XML configuration
Creating web applications in Java traditionally involves configuring environments and frameworks at the start and during development. This configuration is very often externalized in XML files to ease configuration and avoid embedding configuration in application code.
XML was initially welcomed as it provided greater consistency to configure applications. In recent years however it has become apparent that although XML is great for configuration it can be tedious to set up an environment. This may take away productivity as developers spend time understanding and maintaining framework configuration as the application grows. Adding or changing functionality in applications that use XML configuration adds an extra step to the change process next to writing application code which slows down productivity and may take away the agility of the entire process.
Grails takes away the need to add configuration in XML files. Instead the framework uses a set of rules or conventions while inspecting the code of Grails-based applications. For example, a class name that ends with Controller (for example BookController) is considered a web controller.
[edit] Ready-to-use development environment
When using traditional Java web toolkits, it's up to developers to assemble deployment units which can be tedious. Grails comes with a complete development environment that includes a web server to get developers started right away. All required libraries are part of the Grails distribution and Grails prepares the Java web environment for deployment automatically.
[edit] Functionality available through mixins
Grails features dynamic methods on several classes through mixins. A mixin is functionality (in the case of Grails mixins are methods) that is added to classes dynamically as if the functionality is compiled in the program.
These dynamic methods allow developers to perform operations without having to implement interfaces or extend base classes. Grails provides dynamic methods based on the type of class. For example domain classes have methods to automate persistence operations like save, delete and find.
[edit] Web framework
The Grails web framework has been designed according to the MVC paradigm.
[edit] Controllers
Grails uses controllers to implement the behaviour of a web pages. Below is an example of a controller:
class BookController {
def list = {
[ books: Book.findAll() ]
}
}
The controller above has a list action that returns a Model containing all books in the database. To create this controller the grails command is used, as shown below:
grails create-controller
This command requests the controller name and creates a class in the grails-app/controller directory of the Grails project. Creating the controller class is sufficient to have is recognized by Grails. The list action maps to http://localhost:8080/book/list in development mode.
[edit] Views
Grails supports JSP and GSP. The example below shows a view written in GSP that lists the books in the model prepared by the controller above:
<html>
<head>
<title>Our books</title>
</head>
<body>
<ul>
<g:each in="books">
<li>${it.title} (${it.author.name})</li>
</g:each>
</ul>
</body>
</html>
This view should be saved as grails-app/views/book/list.gsp of the Grails project. This location maps to the BookController and list action. Placing the file in this location is sufficient to have it recognized by Grails.
There is also a GSP tag reference available.
[edit] Ajax support
Grails supports several Ajax libraries including OpenRico, Prototype and Yahoo! UI library. You can use existing tag libraries that create HTML with Ajax code. You can also easily create your own tag libraries.
[edit] Dynamic tag libraries
Grails provides a large number of tag libraries out of the box. However you can also create and reuse your own tag libraries easily:
def dateFormat = { attrs ->
out << new java.text.SimpleDateFormat(attrs.format).format(attrs.date)
}
The dateFormat tag library above formats a java.util.Date object to a String. This tag library should be added to the grails-app/taglib/ApplicationTagLib.groovy file or in a file ending with TagLib.groovy in the grails-app/taglib directory.
Below is a snippet from a GSP file that uses the dateFormat tag library:
<g:dateFormat format="yyyyMMdd" date="${myDate}"/>
To use a dynamic tag library in a GSP no import tags have to be used. Dynamic tag libraries can also be used in JSP files although this requires a little more work. [1]
[edit] Persistence
[edit] Model
The domain model in Grails is persisted to the database using GORM (Grails Object Relational Mapping). Domain classes are saved in the grails-app/domain directory and can be created using the grails command as shown below:
grails create-domain-class
This command requests the domain class name and creates the appropriate file. Below the code of the Book class is shown:
class Book {
Long id
Long version
String title
Person author
}
Creating this class is all that is required to have it managed for persistence by Grails. With Grails 0.3, GORM has been improved and e.g. adds the properties id and version itself to the domain class if they are not present.
[edit] Methods
The domain classes managed by GORM have 'magic' dynamic and static methods to perform persistence operations on these classes and its objects. [2]
[edit] Dynamic methods
The save() method saves an object to the database:
def book = new Book(title:"The Da Vinci Code", author:Author.findByName("Dan Brown"))
book.save()
The delete() method deletes an object from the database:
def book = Book.findByTitle("The Da Vinci Code")
book.delete()
The refresh() method refreshes the state of an object from the database:
def book = Book.findByTitle("The Da Vinci Code")
book.refresh()
The ident() method retrieves the objects identity assigned from the database:
def book = Book.findByTitle("The Da Vinci Code")
def id = book.ident()
[edit] Static methods
The count() method returns the number of records in the database for a given class:
def bookCount = Book.count()
The exists() method returns true is an object exists in the database with a given identifier:
def bookExists = Book.exists(1)
The find() method returns the first object from the database based on an object query statement:
def book = Book.find("from Book b where b.title = ?", [ 'The Da Vinci Code' ])
The findAll() method returns all objects existing in the database:
def books = Book.findAll()
The findAll() method can also take an object query statement for returning a list of objects:
def books = Book.findAll("from Book")
The findBy*() methods return the first object from the database that matches a specific pattern:
def book = Book.findByTitle("The Da Vinci Code")
Also:
def book = Book.findByTitleLike("%Da Vinci%")
The findAllBy*() methods return a list of objects from the database that match a specific pattern:
def books = Book.findAllByTitleLike("The%")
The findWhere*() methods return the first object from the database that matches a set of named parameters:
def book = Book.findWhere(title:"The Da Vinci Code")
[edit] Scaffolding
Grails supports scaffolding to support CRUD operations (Create,Read,Update,Delete). Any domain class can be scaffolded by creating a scaffolding controller as shown below:
class BookController {
scaffold = true
}
By creating this class you can perform CRUD operations on http://localhost:8080/book.
[edit] Creating a Grails project
A Grails project is created as follows:
- Follow the download and installation guidelines on the Grails web site. [3]
- Open a command prompt and type:
grails create-app
This command will request the name of the project and will create a project directory with the same name. Change to this directory to use the grails command.
By running the grails run-app you can now try the http://localhost:8080/ URL.
[edit] Target audience
The target audience for Grails is:
- Java developers that are looking for an integrated development environment to create web based application.
- Developers without Java experience looking for a high-productivity environment to build web based applications.
[edit] Integration with the Java platform
Grails is built on top of and is part of the Java platform meaning it's very easy to integrate with Java libraries, frameworks and existing code bases. The most prominent feature Grails offers in this area is the transparent integration of classes that are mapped with the Hibernate ORM framework. This means existing applications that use Hibernate can use Grails without recompiling the code or reconfiguring the Hibernate classes while using the dynamic persistence methods discussed above. [4]
One consequence of this is that scaffolding can be configured for Java classes mapped with Hibernate. Another consequence is that the capabilities of the Grails web framework are fully available for these classes and the applications that use them.
[edit] Trivia
Grails was previously known as Groovy On Rails. The name was dropped after a request by David Heinemeier Hansson, founder of the Ruby On Rails framework.[5]
