Grails 1.1 Web Application Development

Grails 1.1 Web Application Development

The expectations of our users are increasing, and rightly so. The Internet is no longer the playground of geeks and nerds. Businesses use it to communicate with and support their customers; families use it to keep in touch while whole communities share their experiences with like-minded people. The democratization of the Internet has brought a new wave of software into the lives of people who would otherwise rarely use computers. The most successful of the new generation of web applications have not been written for the expert user, but for the casual user, focusing on ease of use. Web application development frameworks that focus on developer productivity have improved the ability of developers to respond to the demands of their users. Simpler and more intuitive frameworks have allowed the rapid development and refinement of new features.

Java web application development has something of a checkered history; simple isn't it. There may be more than one way to skin a cat, but there are almost infinite numbers of ways to build a Java web application. The options that are available are mind-boggling. Which database server to use? What about the application server? You also better choose an MVC framework while you're at it. Should you use a persistence framework, or hand code SQL statements? If you use an ORM framework, which one is best? Don't forget to choose a logging library. How should the project be laid out? Once you've finished making all these decisions, it's time to start on the configuration to get all of these disparate frameworks working together. Now, eventually you are ready to start coding! No wonder the latest and greatest web applications are built in PHP and Ruby on Rails.

Java still has a lot to offer. It is faster than most other languages that are used for web application development. It is an extremely mature platform, with lots of high quality libraries available. Moreover, its static, strong typing gives you less rope to hang yourself with. However, Java developers need to find technologies that deal with the common activities of web development. Sometimes we need a few choices taken away to help us focus on the problem at hand, creating great software that provides value to our users at less cost to the people paying the bills.

Grails does just this. It removes the need for reams of configuration through a convention-based approach that constrains developers in a healthy way. The decisions concerning project layout and which frameworks to use are removed. This leaves the developers free to use their creative talents for producing great software, rather than tweaking configuration files.

Throughout this book, you will learn how to build a web application using Grails and a number of key plug-ins. You will see that it is possible to achieve a great deal with very little code. Who knows, you may even rediscover your passion for web development on the Java platform!

What This Book Covers

Chapter 1 presents a short state of the nation of Java web development and makes the case for a framework like Grails. At the end of the chapter, we will install and create a Grails project.

Chapter 2 covers the use of Grails scaffolding to generate some simple pages to manage users and roles for our application.

Chapter 3 shows how to post messages, where we write the first basic functionality for the application by allowing users to post messages that can be shared with other users. This chapter introduces a number of basic concepts for Grails development including: controllers, validation, Groovy Server Pages (GSP), and Grails Object-Relational Mapping (GORM).

Chapter 4 covers an introduction to Groovy. Here we take a short break from the Grails framework to get a better understanding of the Groovy programming language. We will cover just enough of the language to be able to proceed through the rest of the book.

Chapter 5 shows how to use our first external plug-in to add authentication and authorization to the application.

Chapter 6 covers testing, where we introduce the different levels of automated testing that are available in the Grails framework. We see how to write, unit tests with new support for testing in Grails 1.1. We also cover integration tests, and install a functional testing plug-in.

Chapter 7 covers file sharing, where we allow users to share files through the application by introducing file uploads.

Chapter 8 covers some advanced querying techniques, using Hibernate criteria support in GORM, to implement file version history.

Chapter 9 introduces Grails services in more depth. We see how to extract logic from our controllers into services to keep the application maintainable.

Chapter 10 introduces more advanced GORM techniques, such as: persisting inheritance and performing polymorphic queries to enable tagging. We also delve into GSP a bit more by using templates to encapsulate view components.

Chapter 11 covers AJAX and RIA Frameworks—Where we improve the user experience with AJAX to allow users to edit tags in-line and use the RichUI plug-in to create tag clouds and perform auto suggestion when editing tags.

Chapter 12 shows us how to use the Searchable plug-in to add a search feature to our site in a matter of minutes. We also provide an RSS feed and a REST based API for managing messages.

Chapter 13 show us how to build our own plug-in, where we follow the example of the Grails plug-in community and extract our tagging code into a plug-in that we can use on future projects.

Chapter 14 shows how to package and deploy the application to a production ready for use in a production environment. We then discuss some next steps that may be worth investigating to handle real world situations.

Managing Content through Tagging

Over the last few chapters, we added the ability for our users to upload and share files with their teammates. As with messages, files are displayed on the home page in the order they are added to the system. Currently all messages and files are displayed on the home page. Over time, our home page is going to become rather large and unwieldy. We need a user's home page to show only the files and messages that they are interested in. To do this, users need to be able to tag their content.

We will implement a simple tagging solution, restructure the home page and then add some new pages to the application for viewing all of the messages and files.

The new Grails concepts that will be introduced in this chapter 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

Add basic tagging

Tagging is a loose, community-based way of categorizing content. It allows a group of people to categorize by consensus. Anyone is able to tag a piece of content. The more a tag is used, the more meaning it takes on and the more widely used it becomes. This categorization by consensus has been dubbed as folksonomy (http://en.wikipedia.org/wiki/Folksonomy) in recent times.

So let's get started by building our tagging support.

Tagging domain model

When implementing tagging in our system, we need to consider the following:

• We must be able to have many tags in our system
• We must be able to associate a single tag with many different files and messages
• We need to make sure that new domain objects can be easily tagged without having to change the tagging logic
• We want to know when a domain object was tagged

To satisfy these requirements, we need to create the following new domain classes:

• Tag—to store the name of the tag. There is one instance of this class per unique tag name in the application.
• Tagger—to store the relationship from domain objects to a tag. This allows us to store the date a tag was added to a domain object.

Let's create these domain classes and then write a test to prove that we can tag a message using this tagging structure.

The Tag class

We are going to separate the tagging classes out from our application domain classes. Create a folder under grails-app/domain called tagging. This is where we will put the domain model to implement tagging.

Our Tag class is extremely simple and holds only a name property:

	package tagging
	class Tag {
		String name
		static constrains = {
			name( blank: false )
		}
	}

The Tagger class

The next class that we are going to create is the Tagger class. In relational terms, this object represents a link table between a Tag and any other domain class. It is important that the relationship between tagged domain classes and the Tagger relationship class is unidirectional. By this, we mean the domain classes are allowed to know that they can be tagged, but tags do not know which domain classes can be tagged, otherwise every tagged domain class would need a special relationship class.

Create the Tagger class as a domain class in the tagging package as follows:

	package tagging
	class Tagger {
		Tag tag
		static constraints = {
			tag( nullable: false )
		}
	}

The basics of our tagging model are complete! We now need some logic to allow tags to be created. Create a new service class called TagService under grails-app/ services/tagging, as shown below:

	package tagging
		class TagService {
			boolean transactional = true
			def createTagRelationships(String spaceDelimitedTags) {
				return spaceDelimitedTags?.split(' ')?.collect { tagName ->
					createTagRelationship( tagName )
				}
			}
			def createTagRelationship(String tagName) {
				def tag = Tag.findByName(tagName)?:
				new Tag(name: tagName).save()
				return new Tagger( tag: tag )
			}

This service provides two utility methods to create new relationships by tag name or by a space delimited string of tag names. The important behavior of these two methods is that they do not allow duplicate tags to be created in the application. If a tag name already exists, the tag will be retrieved from the database and used as the tag in the relationship.

Notice that the createTagRelationships method is using the collect method to simplify what would normally take a few more lines of code to achieve. We did briefl y cover the collect method back in our introduction to Groovy in Chapter 4, but to reiterate: the collect method is dynamically added to any object that can be iterated over. For example, collections, arrays, strings and so on. It takes a closure as its argument and executes this closure for each item in the collection. The return value from each execution of the closure is added to a new collection that the collect method builds up and then returns once it has finished iterating the original collection.

In createTagRelationship, we are using another neat language feature of Groovy called the "Elvis operator". It is named so, as it looks like Elvis' hair style. This is a shorter version of the normal Java ternary operator. If the operand being checked is true then the checked operand will be returned as the default, otherwise the alternative operand will be used. So in our example:

	def tag = Tag.findByName(tagName) ?: new Tag(name: tagName).save()

If a tag can be found from the database then it is used, otherwise a new tag is created.

Tagging a message

The next step is to allow a message to be tagged. Write some integration tests to make sure the relationships are working before using tagging in the application.

In the folder test/integration/app, create the file TaggableIntegrationTests. groovy and add the following code:

	package app
	import tagging.Tag
	class TaggableIntegrationTest extends GroovyTestCase {
		User flancelot
		protected void setUp() {
			flancelot = User.findByUsername('flancelot')
			Tag.list().each { it.delete() }
			Message.list().each { it.delete() }
		}
	}

The code above sets up the test data needed to create messages and associate tags to messages. Remember that the flancelot user already exists because it was created by the BootStrap class.

The first test will determine that we can add tags to a message and then retrieve messages by tag. Add the following test method to your test class:

	void testCanRetrieveMessagesByTags() {
		Message message = new Message(user: flancelot, title: 'tagged',
			detail: "I've been tagged.").save(flush: true)
		Message secondMessage = new Message(user: flancelot,
			title: 'other tagged',
			detail: "I've been tagged.").save(flush: true)
		message.addTag('urgent')
		message.addTag('late')
		secondMessage.addTag('urgent')
		def taggedMessages = Message.withTag( 'urgent' )
		assertEquals(2, taggedMessages.size())
		assertEquals(2, Tag.list().size())
		def secondMessages = Message.withTag( 'late' )
		assertEquals(1, secondMessages.size())
		assertEquals(2, Tag.list().size())
	}

The test above does the following:

• Creates two new messages
• Adds the urgent tag to both messages
• Adds the late tag to one message
• Checks if we can retrieve both messages by using the urgent tag
• Checks if only one message is returned for the late tag

Notice that the highlighted lines of code have not been implemented yet. To allow this test to pass, we need to add the following methods to the Message domain class:

• addTag—instance method to allow a message to be tagged
• withTag— class method to retrieve all messages with a particular tag

Add the following method to the Message class (don't forget to import tagging.Tagger):

	def addTag(String tagName) {
		tags = (tags)?:[]
		tags << tagService.createTagRelationship( tagName )
	}

This method simply delegates the creation of the tag relationship off to the TagService class, and then stores the relationship in the tags list.

Add the following method to the Message class that retrieves all messages with a given tag name:

	def static withTag(String tagName) {
		return Message.withCriteria {
			tags {
				tag {
					eq('name', tagName )
				}
			}
		}
	}

This method must be static on the Message class, as it is used to load message instances for a given tag. We do not want to have to instantiate a message before we can perform the search.

Before running the test, you will notice both of these new methods assume that there is a property on the Message class called tags. This has not yet been created. We need to create a one-to-many relationship from Message to Tagger that will allow messages to be tagged. We also need to inject the TagService into new instances of the Message class so the work for creating a new tag relationship can be delegated. Add the relationship to the Message class and inject TagService as shown below:

	class Message {
		def tagService
		static hasMany = [tags:Tagger]
		…
	}

Now we can run our tests by entering the following on the command line:

grails test-app

We should see some output in the command line similar to:

Running test app.TaggableTest...
			testCanRetrieveMessagesByTags...SUCCESS

Tagging a file

Now that we have implemented tagging for messages, we need to make tagging available for files.

Currently the logic for creating and fetching tags is in the Message domain class. We need to extract this logic so the File domain class can reuse it. It's time to look at how GORM supports inheritance.