Creating a simple Grails application with IntelliJ IDEA

From IntelliJ-Wiki

Jump to: navigation, search

Contents

Overview

IntelliJ IDEA tightly integrates with Grails http://www.grails.org, and makes it possible to work with Grails applications from within the IDE, sparing you from the need to use command line. Grails support in IntelliJ IDEA lets you do the following:

  • Create a Grails application using the New Project wizard.
  • Explore a Grails application as a tree-view of files and folders, or as a collection of models, controllers, and views.
  • Create elements in your Grails application (domain classes, controllers, and views).
  • Run your Grails application.

This tutorial will walk you step by step through developing and launching a simple library management system.

Prerequisites

Creating a new project

Let’s start from the very beginning, that is, create a new project from scratch. To do that, choose File | New Project on the main menu, or click the New Project icon on the Welcome screen. On the first page of the New Project wizard, in the selector pane, choose Grails Module. On the right part of the page, enter the necessary information, such as project's name, its location and click Next:

File:NewProjectGrails1.png

On the next page of the wizard, specify Grails SDK and click Finish. For more information, refer to Creating Grails Application Module page:


File:NewProjectGrails2.png

Now, IntelliJ IDEA lets you choose to create either Grails application or Grails plugin:

File:NewProjectGrails3.png


In our case, lets go ahead and click Run grails-app


IntelliJ IDEA executes the create-app target, which generates the directory structure of a Grails application. All output information is displayed in the Console:

File:GrailsConsoleOutput.png

Exploring Grails application

IntelliJ IDEA enables you to explore your Grails application from two different viewpoints:

  • The Project tool window shows the typical Grails directory structure.
  • The Grails tool window shows the logical set of Grails application elements (Domain classes, Controllers, Views, etc.)

See the difference:

File:GrailsProjectView.png

The project is now ready. All you have to do is to add some meaningful contents to it, which will be described in the next section.

Creating elements in your Grails project

To illustrate IntelliJ IDEA's abilities, we'll start developing a very basic library management system. To start with, let’s create a domain class for that system. This class will represent a book within a library. There are two possible ways of doing that in IntelliJ IDEA:

  • Execute a Grails target. Press Ctrl+Alt+G, and enter Grails target name. Note that code completion Ctrl+Space is available in the Run Grails target dialog box:

File:GrailsRunTarget.png

  • Right-click the Grails tool window background, and choose New |Grails Domain class on the context menu:

File:GrailsRunTarget1.png

As a result, two stub classes are created in the project:

  • Domain class Book.groovy
  • Test class BookTests.groovy

Note that IntelliJ IDEA diligently shows all output messages in the console. For the purposes of our short guide, we’ll continue working with the domain class Book.groovy. Now it is just a stub, and we want to add the following fields to it:

  • Book title
  • Author name (may be two author names?)
  • Description
  • Publisher
  • Date published
  • Copyright
  • ISBN
  • Reader name
  • Date taken

Open Book.groovy for editing (F4), and type these fields in your code, using the code completion (Ctrl + Space):

File:GrailsBook.png

The next step is to provide a controller and views. Again, you can do it in two ways: either run the Grails target generate-all Book, or use Scaffolding - the handy tool that you can find at the top of the domain class editor:

File:GrailsGenerateController.png

IntelliJ IDEA works hard (you can see that in the console), and produces the BookController.groovy class:

File:GrailsController1.png

Next, create views the same way:

File:GrailsGenerateViews.png

For each method of the controller, IntelliJ IDEA generates a file with the .gsp extention (create.gsp, edit.gsp, list.gsp, show.gsp). www.animation-enfant.org

File:GrailsGspFile.png

Running the application

There are more things you might want to do to make your application useful, but let’s try to run it straight away with the default settings. To do that, press Shift+F10 – after turmoil of messages in the Console, your application starts in your default browser, with the following URL in the address bar: http://localhost:8080/MyGrailsProject/.

On that page, you will see something like this:

File:GrailsControllerLink.png

Click the controller link to open the list of books, which is empty by default. Now, you can try to fill out the entries of your library management system, for example, click the New Book button to add a book:

File:GrailBookView.png

As you see, our basic library management system is ready. If you want to extend its functionality, or you are not very happy with the code generated by Grails, you can modify the files in the IntelliJ IDEA editor to fit your particular needs, and rerun the application.

Finally, if you want to evaluate your effort for creating and running your Grails application under IntelliJ IDEA, view the number of files and lines of source code. Press Ctrl+Alt+G, type stats in the pop-up window, and see the results in the Console:

File:GrailsStats.png

More information

Managing Grails plugins: http://wiki.jetbrains.net/intellij/Managing_Grails_plugins

Personal tools