8 The Web Layer 3.2.4

(Quick Reference) # 8 The Web Layer Version: 3.2.4 ## Table of Contents # 8 The Web Layer ## 8.1 Controllers A controller handles requests and creates or prepares the response. A controller can generate the response directly or delegate to a view. To create a controller, simply create a class whose name ends with `Controller` in the `grails-app/controllers` directory (in a subdirectory if it’s in a package). The default URL Mapping configuration ensures that the first part of your controller name is mapped to a URI and each action defined within your controller maps to URIs within the controller name URI. ## 8.1.1 Understanding Controllers and Actions #### Creating a controller Controllers can be created with the create-controller or generate-controller command. For example try running the following command from the root of a Grails project:
    grails create-controller book
The command will create a controller at the location `grails-app/controllers/myapp/BookController.groovy`:
    package myapp

    class BookController {

        def index() { }
    }
where "myapp" will be the name of your application, the default package name if one isn’t specified. `BookController` by default maps to the /book URI (relative to your application root).
| The `create-controller` and `generate-controller` commands are just for convenience and you can just as easily create controllers using your favorite text editor or IDE
#### Creating Actions A controller can have multiple public action methods; each one maps to a URI:
    class BookController {

        def list() {

            // do controller logic
            // create model

            return model
        }
    }
This example maps to the `/book/list` URI by default thanks to the property being named `list`. #### The Default Action A controller has the concept of a default URI that maps to the root URI of the controller, for example `/book` for `BookController`. The action that is called when the default URI is requested is dictated by the following rules: If there is only one action, it’s the default If you have an action named `index`, it’s the default Alternatively you can set it explicitly with the `defaultAction` property:
    static defaultAction = "list"
## 8.1.2 Controllers and Scopes #### Available Scopes Scopes are hash-like objects where you can store variables. The following scopes are available to controllers: servletContext - Also known as application scope, this scope lets you share state across the entire web application. The servletContext is an instance of ServletContext session - The session allows associating state with a given user and typically uses cookies to associate a session with a client. The session object is an instance of HttpSession request - The request object allows the storage of objects for the current request only. The request object is an instance of HttpServletRequest params - Mutable map of incoming request query string or POST parameters flash - See below #### Accessing Scopes Scopes can be accessed using the variable names above in combination with Groovy’s array index operator, even on classes provided by the Servlet API such as the HttpServletRequest:
    class BookController {
        def find() {
            def findBy = params["findBy"]
            def appContext = request["foo"]
            def loggedUser = session["logged_user"]
        }
    }
You can also access values within scopes using the de-reference operator, making the syntax even more clear:
    class BookController {
        def find() {
            def findBy = params.findBy
            def appContext = request.foo
            def loggedUser = session.logged_user
        }
    }
This is one of the ways that Grails unifies access to the different scopes. #### Using Flash Scope Grails supports the concept of flash scope as a temporary store to make attributes available for this request and the next request only. Afterwards the attributes are cleared. This is useful for setting a message directly before redirecting, for example:
    def delete() {
        def b = Book.get(params.id)
        if (!b) {
            flash.message = "User not found for id ${params.id}"
            redirect(action:list)
        }
        ... // remaining code
    }
When the `list` action is requested, the `message` value will be in scope and can be used to display an information message. It will be removed from the `flash` scope after this second request. Note that the attribute name can be anything you want, and the values are often strings used to display messages, but can be any object type. #### Scoped Controllers Newly created applications have the `grails.controllers.defaultScope` property set to a value of "singleton" in `application.yml`. You may change this value to any of the supported scopes listed below. If the property is not assigned a value at all, controllers will default to "prototype" scope. Supported controller scopes are: `prototype` (default) - A new controller will be created for each request (recommended for actions as Closure properties) `session` - One controller is created for the scope of a user session `singleton` - Only one instance of the controller ever exists (recommended for actions as methods) To enable one of the scopes, add a static `scope` property to your class with one of the valid scope values listed above, for example
    static scope = "singleton"
You can define the default strategy in `application.yml` with the `grails.controllers.defaultScope` key, for example:
    grails:
        controllers:
            defaultScope: singleton
| Use scoped controllers wisely. For instance, we don’t recommend having any properties in a singleton-scoped controller since they will be shared for all requests.
## 8.1.3 Models and Views #### Returning the Model A model is a Map that the view uses when rendering. The keys within that Map correspond to variable names accessible by the view. There are a couple of ways to return a model. First, you can explicitly return a Map instance:
    def show() {
        [book: Book.get(params.id)]
    }
| The above does not reflect what you should use with the scaffolding views - see the scaffolding section for more details.
A more advanced approach is to return an instance of the Spring ModelAndView class:
    import org.springframework.web.servlet.ModelAndView

    def index() {
        // get some books just for the index page, perhaps your favorites
        def favoriteBooks = ...

        // forward to the list view to show them
        return new ModelAndView("/book/list", [ bookList : favoriteBooks ])
    }
One thing to bear in mind is that certain variable names can not be used in your model: `attributes` `application` Currently, no error will be reported if you do use them, but this will hopefully change in a future version of Grails. #### Selecting the View In both of the previous two examples there was no code that specified which view to render. So how does Grails know which one to pick? The answer lies in the conventions. Grails will look for a view at the location `grails-app/views/book/show.gsp` for this `show` action:
    class BookController {
        def show() {
             [book: Book.get(params.id)]
        }
    }
To render a different view, use the render method:
    def show() {
        def map = [book: Book.get(params.id)]
        render(view: "display", model: map)
    }
In this case Grails will attempt to render a view at the location `grails-app/views/book/display.gsp`. Notice that Grails automatically qualifies the view location with the `book` directory of the `grails-app/views` directory. This is convenient, but to access shared views you need instead you can use an absolute path instead of a relative one:
    def show() {
        def map = [book: Book.get(params.id)]
        render(view: "/shared/display", model: map)
    }
In this case Grails will attempt to render a view at the location `grails-app/views/shared/display.gsp`. Grails also supports JSPs as views, so if a GSP isn’t found in the expected location but a JSP is, it will be used instead. #### Selecting Views For Namespaced Controllers If a controller defines a namespace for itself with the namespace property that will affect the root directory in which Grails will look for views which are specified with a relative path. The default root directory for views rendered by a namespaced controller is `grails-app/views/<namespace name>/<controller name>/`. If the view is not found in the namespaced directory then Grails will fallback to looking for the view in the non-namespaced directory. See the example below.
    class ReportingController {
        static namespace = 'business'

        def humanResources() {
            // This will render grails-app/views/business/reporting/humanResources.gsp
            // if it exists.

            // If grails-app/views/business/reporting/humanResources.gsp does not
            // exist the fallback will be grails-app/views/reporting/humanResources.gsp.

            // The namespaced GSP will take precedence over the non-namespaced GSP.

            [numberOfEmployees: 9]
        }

        def accountsReceivable() {
            // This will render grails-app/views/business/reporting/accounting.gsp
            // if it exists.

            // If grails-app/views/business/reporting/accounting.gsp does not
            // exist the fallback will be grails-app/views/reporting/accounting.gsp.

            // The namespaced GSP will take precedence over the non-namespaced GSP.

            render view: 'numberCrunch', model: [numberOfEmployees: 13]
        }
    }
#### Rendering a Response Sometimes it’s easier (for example with Ajax applications) to render snippets of text or code to the response directly from the controller. For this, the highly flexible `render` method can be used:
    render "Hello World!"
The above code writes the text "Hello World!" to the response. Other examples include:
    // write some markup
    render {
       for (b in books) {
          div(id: b.id, b.title)
       }
    }
    // render a specific view
    render(view: 'show')
    // render a template for each item in a collection
    render(template: 'book_template', collection: Book.list())
    // render some text with encoding and content type
    render(text: "<xml>some xml</xml>", contentType: "text/xml", encoding: "UTF-8")
If you plan on using Groovy’s `MarkupBuilder` to generate HTML for use with the `render` method be careful of naming clashes between HTML elements and Grails tags, for example:
    import groovy.xml.MarkupBuilder
    ...
    def login() {
        def writer = new StringWriter()
        def builder = new MarkupBuilder(writer)
        builder.html {
            head {
                title 'Log in'
            }
            body {
                h1 'Hello'
                form {
                }
            }
        }

        def html = writer.toString()
        render html
    }
This will actually call the form tag (which will return some text that will be ignored by the `MarkupBuilder`). To correctly output a `<form>` element, use the following:
    def login() {
        // ...
        body {
            h1 'Hello'
            builder.form {
            }
        }
        // ...
    }
## 8.1.4 Redirects and Chaining #### Redirects Actions can be redirected using the redirect controller method:
    class OverviewController {

        def login() {}

        def find() {
            if (!session.user)
                redirect(action: 'login')
                return
            }
            ...
        }
    }
Internally the redirect method uses the HttpServletResponse object’s `sendRedirect` method. The `redirect` method expects one of: The name of an action (and controller name if the redirect isn’t to an action in the current controller):
    // Also redirects to the index action in the home controller
    redirect(controller: 'home', action: 'index')
A URI for a resource relative the application context path:
    // Redirect to an explicit URI
    redirect(uri: "/login.html")
Or a full URL:
    // Redirect to a URL
    redirect(url: "http://grails.org")
A domain class instance:
    // Redirect to the domain instance
    Book book = ... // obtain a domain instance
    redirect book
In the above example Grails will construct a link using the domain class `id` (if present). Parameters can optionally be passed from one action to the next using the `params` argument of the method:
    redirect(action: 'myaction', params: [myparam: "myvalue"])
These parameters are made available through the params dynamic property that accesses request parameters. If a parameter is specified with the same name as a request parameter, the request parameter is overridden and the controller parameter is used. Since the `params` object is a Map, you can use it to pass the current request parameters from one action to the next:
    redirect(action: "next", params: params)
Finally, you can also include a fragment in the target URI:
    redirect(controller: "test", action: "show", fragment: "profile")
which will (depending on the URL mappings) redirect to something like "/myapp/test/show#profile". #### Chaining Actions can also be chained. Chaining allows the model to be retained from one action to the next. For example calling the `first` action in this action:
    class ExampleChainController {

        def first() {
            chain(action: second, model: [one: 1])
        }

        def second () {
            chain(action: third, model: [two: 2])
        }

        def third() {
            [three: 3])
        }
    }
results in the model:
    [one: 1, two: 2, three: 3]
The model can be accessed in subsequent controller actions in the chain using the `chainModel` map. This dynamic property only exists in actions following the call to the `chain` method:
    class ChainController {

        def nextInChain() {
            def model = chainModel.myModel
            ...
        }
    }
Like the `redirect` method you can also pass parameters to the `chain` method:
    chain(action: "action1", model: [one: 1], params: [myparam: "param1"])
| The chain method uses the HTTP session and hence should only be used if your application is stateful.
## 8.1.5 Data Binding Data binding is the act of "binding" incoming request parameters onto the properties of an object or an entire graph of objects. Data binding should deal with all necessary type conversion since request parameters, which are typically delivered by a form submission, are always strings whilst the properties of a Groovy or Java object may well not be. #### Map Based Binding The data binder is capable of converting and assigning values in a Map to properties of an object. The binder will associate entries in the Map to properties of the object using the keys in the Map that have values which correspond to property names on the object. The following code demonstrates the basics: grails-app/domain/Person.groovy
    class Person {
        String firstName
        String lastName
        Integer age
    }
    def bindingMap = [firstName: 'Peter', lastName: 'Gabriel', age: 63]

    def person = new Person(bindingMap)

    assert person.firstName == 'Peter'
    assert person.lastName == 'Gabriel'
    assert person.age == 63
To update properties of a domain object you may assign a Map to the `properties` property of the domain class:
    def bindingMap = [firstName: 'Peter', lastName: 'Gabriel', age: 63]

    def person = Person.get(someId)
    person.properties = bindingMap

    assert person.firstName == 'Peter'
    assert person.lastName == 'Gabriel'
    assert person.age == 63
The binder can populate a full graph of objects using Maps of Maps.
    class Person {
        String firstName
        String lastName
        Integer age
        Address homeAddress
    }

    class Address {
        String county
        String country
    }
    def bindingMap = [firstName: 'Peter', lastName: 'Gabriel', age: 63, homeAddress: [county: 'Surrey', country: 'England'] ]

    def person = new Person(bindingMap)

    assert person.firstName == 'Peter'
    assert person.lastName == 'Gabriel'
    assert person.age == 63
    assert person.homeAddress.county == 'Surrey'
    assert person.homeAddress.country == 'England'
#### Binding To Collections And Maps The data binder can populate and update Collections and Maps. The following code shows a simple example of populating a `List` of objects in a domain class:
    class Band {
        String name
        static hasMany = [albums: Album]
        List albums
    }

    class Album {
        String title
        Integer numberOfTracks
    }
    def bindingMap = [name: 'Genesis',
                      'albums[0]': [title: 'Foxtrot', numberOfTracks: 6],
                      'albums[1]': [title: 'Nursery Cryme', numberOfTracks: 7]]

    def band = new Band(bindingMap)

    assert band.name == 'Genesis'
    assert band.albums.size() == 2
    assert band.albums[0].title == 'Foxtrot'
    assert band.albums[0].numberOfTracks == 6
    assert band.albums[1].title == 'Nursery Cryme'
    assert band.albums[1].numberOfTracks == 7
That code would work in the same way if `albums` were an array instead of a `List`. Note that when binding to a `Set` the structure of the `Map` being bound to the `Set` is the same as that of a `Map` being bound to a `List` but since a `Set` is unordered, the indexes don’t necessarily correspond to the order of elements in the `Set`. In the code example above, if `albums` were a `Set` instead of a `List`, the `bindingMap` could look exactly the same but 'Foxtrot' might be the first album in the `Set` or it might be the second. When updating existing elements in a `Set` the `Map` being assigned to the `Set` must have `id` elements in it which represent the element in the `Set` being updated, as in the following example:
    /*
     * The value of the indexes 0 and 1 in albums[0] and albums[1] are arbitrary
     * values that can be anything as long as they are unique within the Map.
     * They do not correspond to the order of elements in albums because albums
     * is a Set.
     */
    def bindingMap = ['albums[0]': [id: 9, title: 'The Lamb Lies Down On Broadway']
                      'albums[1]': [id: 4, title: 'Selling England By The Pound']]

    def band = Band.get(someBandId)

    /*
     * This will find the Album in albums that has an id of 9 and will set its title
     * to 'The Lamb Lies Down On Broadway' and will find the Album in albums that has
     * an id of 4 and set its title to 'Selling England By The Pound'.  In both
     * cases if the Album cannot be found in albums then the album will be retrieved
     * from the database by id, the Album will be added to albums and will be updated
     * with the values described above.  If a Album with the specified id cannot be
     * found in the database, then a binding error will be created and associated
     * with the band object.  More on binding errors later.
     */
    band.properties = bindingMap
When binding to a `Map` the structure of the binding `Map` is the same as the structure of a `Map` used for binding to a `List` or a `Set` and the index inside of square brackets corresponds to the key in the `Map` being bound to. See the following code:
    class Album {
        String title
        static hasMany = [players: Player]
        Map players
    }

    class Player {
        String name
    }
    def bindingMap = [title: 'The Lamb Lies Down On Broadway',
                      'players[guitar]': [name: 'Steve Hackett'],
                      'players[vocals]': [name: 'Peter Gabriel'],
                      'players[keyboards]': [name: 'Tony Banks']]

    def album = new Album(bindingMap)

    assert album.title == 'The Lamb Lies Down On Broadway'
    assert album.players.size() == 3
    assert album.players.guitar.name == 'Steve Hackett'
    assert album.players.vocals.name == 'Peter Gabriel'
    assert album.players.keyboards.name == 'Tony Banks'
When updating an existing `Map`, if the key specified in the binding `Map` does not exist in the `Map` being bound to then a new value will be created and added to the `Map` with the specified key as in the following example:
    def bindingMap = [title: 'The Lamb Lies Down On Broadway',
                      'players[guitar]': [name: 'Steve Hackett'],
                      'players[vocals]': [name: 'Peter Gabriel']
                      'players[keyboards]': [name: 'Tony Banks']]

    def album = new Album(bindingMap)

    assert album.title == 'The Lamb Lies Down On Broadway'
    assert album.players.size() == 3
    assert album.players.guitar == 'Steve Hackett'
    assert album.players.vocals == 'Peter Gabriel'
    assert album.players.keyboards == 'Tony Banks'

    def updatedBindingMap = ['players[drums]': [name: 'Phil Collins'],
                             'players[keyboards]': [name: 'Anthony George Banks']]

    album.properties = updatedBindingMap

    assert album.title == 'The Lamb Lies Down On Broadway'
    assert album.players.size() == 4
    assert album.players.guitar.name == 'Steve Hackett'
    assert album.players.vocals.name == 'Peter Gabriel'
    assert album.players.keyboards.name == 'Anthony George Banks'
    assert album.players.drums.name == 'Phil Collins'
#### Binding Request Data to the Model The params object that is available in a controller has special behavior that helps convert dotted request parameter names into nested Maps that the data binder can work with. For example, if a request includes request parameters named `person.homeAddress.country` and `person.homeAddress.city` with values 'USA' and 'St. Louis' respectively, `params` would include entries like these:
    [person: [homeAddress: [country: 'USA', city: 'St. Louis']]]
There are two ways to bind request parameters onto the properties of a domain class. The first involves using a domain classes' Map constructor:
    def save() {
        def b = new Book(params)
        b.save()
    }
The data binding happens within the code `new Book(params)`. By passing the params object to the domain class constructor Grails automatically recognizes that you are trying to bind from request parameters. So if we had an incoming request like:
    /book/save?title=The%20Stand&author=Stephen%20King
Then the `title` and `author` request parameters would automatically be set on the domain class. You can use the properties property to perform data binding onto an existing instance:
    def save() {
        def b = Book.get(params.id)
        b.properties = params
        b.save()
    }
This has the same effect as using the implicit constructor. When binding an empty String (a String with no characters in it, not even spaces), the data binder will convert the empty String to null. This simplifies the most common case where the intent is to treat an empty form field as having the value null since there isn’t a way to actually submit a null as a request parameter. When this behavior is not desirable the application may assign the value directly. The mass property binding mechanism will by default automatically trim all Strings at binding time. To disable this behavior set the `grails.databinding.trimStrings` property to false in `grails-app/conf/application.groovy`.
    // the default value is true
    grails.databinding.trimStrings = false

    // ...
The mass property binding mechanism will by default automatically convert all empty Strings to null at binding time. To disable this behavior set the `grails.databinding.convertEmptyStringsToNull` property to false in `grails-app/conf/application.groovy`.
    // the default value is true
    grails.databinding.convertEmptyStringsToNull = false

    // ...
The order of events is that the String trimming happens and then null conversion happens so if `trimStrings` is `true` and `convertEmptyStringsToNull` is `true`, not only will empty Strings be converted to null but also blank Strings. A blank String is any String such that the `trim()` method returns an empty String.
| These forms of data binding in Grails are very convenient, but also indiscriminate. In other words, they will bind all non-transient, typed instance properties of the target object, including ones that you may not want bound. Just because the form in your UI doesn’t submit all the properties, an attacker can still send malign data via a raw HTTP request. Fortunately, Grails also makes it easy to protect against such attacks - see the section titled "Data Binding and Security concerns" for more information.
#### Data binding and Single-ended Associations If you have a `one-to-one` or `many-to-one` association you can use Grails' data binding capability to update these relationships too. For example if you have an incoming request such as:
    /book/save?author.id=20
Grails will automatically detect the `.id` suffix on the request parameter and look up the `Author` instance for the given id when doing data binding such as:
    def b = new Book(params)
An association property can be set to `null` by passing the literal `String` "null". For example:
    /book/save?author.id=null
#### Data Binding and Many-ended Associations If you have a one-to-many or many-to-many association there are different techniques for data binding depending of the association type. If you have a `Set` based association (the default for a `hasMany`) then the simplest way to populate an association is to send a list of identifiers. For example consider the usage of `<g:select>` below:
    <g:select name="books"
              from="${Book.list()}"
              size="5" multiple="yes" optionKey="id"
              value="${author?.books}" />
This produces a select box that lets you select multiple values. In this case if you submit the form Grails will automatically use the identifiers from the select box to populate the `books` association. However, if you have a scenario where you want to update the properties of the associated objects the this technique won’t work. Instead you use the subscript operator:
    <g:textField name="books[0].title" value="the Stand" />
    <g:textField name="books[1].title" value="the Shining" />
However, with `Set` based association it is critical that you render the mark-up in the same order that you plan to do the update in. This is because a `Set` has no concept of order, so although we’re referring to `books[0]` and `books[1]` it is not guaranteed that the order of the association will be correct on the server side unless you apply some explicit sorting yourself. This is not a problem if you use `List` based associations, since a `List` has a defined order and an index you can refer to. This is also true of `Map` based associations. Note also that if the association you are binding to has a size of two and you refer to an element that is outside the size of association:
    <g:textField name="books[0].title" value="the Stand" />
    <g:textField name="books[1].title" value="the Shining" />
    <g:textField name="books[2].title" value="Red Madder" />
Then Grails will automatically create a new instance for you at the defined position. You can bind existing instances of the associated type to a `List` using the same `.id` syntax as you would use with a single-ended association. For example:
    <g:select name="books[0].id" from="${bookList}"
              value="${author?.books[0]?.id}" />

    <g:select name="books[1].id" from="${bookList}"
              value="${author?.books[1]?.id}" />

    <g:select name="books[2].id" from="${bookList}"
              value="${author?.books[2]?.id}" />
Would allow individual entries in the `books List` to be selected separately. Entries at particular indexes can be removed in the same way too. For example:
    <g:select name="books[0].id"
              from="${Book.list()}"
              value="${author?.books[0]?.id}"
              noSelection="['null': '']"/>
Will render a select box that will remove the association at `books[0]` if the empty option is chosen. Binding to a `Map` property works the same way except that the list index in the parameter name is replaced by the map key:
    <g:select name="images[cover].id"
              from="${Image.list()}"
              value="${book?.images[cover]?.id}"
              noSelection="['null': '']"/>
This would bind the selected image into the `Map` property `images` under a key of `"cover"`. When binding to Maps, Arrays and Collections the data binder will automatically grow the size of the collections as necessary.
| The default limit to how large the binder will grow a collection is 256. If the data binder encounters an entry that requires the collection be grown beyond that limit, the entry is ignored. The limit may be configured by assigning a value to the `grails.databinding.autoGrowCollectionLimit` property in `application.groovy`.
grails-app/conf/application.groovy
    // the default value is 256
    grails.databinding.autoGrowCollectionLimit = 128

    // ...
#### Data binding with Multiple domain classes It is possible to bind data to multiple domain objects from the params object. For example so you have an incoming request to:
    /book/save?book.title=The%20Stand&author.name=Stephen%20King
You’ll notice the difference with the above request is that each parameter has a prefix such as `author.` or `book.` which is used to isolate which parameters belong to which type. Grails' `params` object is like a multi-dimensional hash and you can index into it to isolate only a subset of the parameters to bind.
    def b = new Book(params.book)
Notice how we use the prefix before the first dot of the `book.title` parameter to isolate only parameters below this level to bind. We could do the same with an `Author` domain class:
    def a = new Author(params.author)
#### Data Binding and Action Arguments Controller action arguments are subject to request parameter data binding. There are 2 categories of controller action arguments. The first category is command objects. Complex types are treated as command objects. See the Command Objects section of the user guide for details. The other category is basic object types. Supported types are the 8 primitives, their corresponding type wrappers and java.lang.String. The default behavior is to map request parameters to action arguments by name:
    class AccountingController {

       // accountNumber will be initialized with the value of params.accountNumber
       // accountType will be initialized with params.accountType
       def displayInvoice(String accountNumber, int accountType) {
           // ...
       }
    }
For primitive arguments and arguments which are instances of any of the primitive type wrapper classes a type conversion has to be carried out before the request parameter value can be bound to the action argument. The type conversion happens automatically. In a case like the example shown above, the `params.accountType` request parameter has to be converted to an `int`. If type conversion fails for any reason, the argument will have its default value per normal Java behavior (null for type wrapper references, false for booleans and zero for numbers) and a corresponding error will be added to the `errors` property of the defining controller.
    /accounting/displayInvoice?accountNumber=B59786&accountType=bogusValue
Since "bogusValue" cannot be converted to type int, the value of accountType will be zero, the controller’s `errors.hasErrors()` will be true, the controller’s `errors.errorCount` will be equal to 1 and the controller’s `errors.getFieldError('accountType')` will contain the corresponding error. If the argument name does not match the name of the request parameter then the `@grails.web.RequestParameter` annotation may be applied to an argument to express the name of the request parameter which should be bound to that argument:
    import grails.web.RequestParameter

    class AccountingController {

       // mainAccountNumber will be initialized with the value of params.accountNumber
       // accountType will be initialized with params.accountType
       def displayInvoice(@RequestParameter('accountNumber') String mainAccountNumber, int accountType) {
           // ...
       }
    }
#### Data binding and type conversion errors Sometimes when performing data binding it is not possible to convert a particular String into a particular target type. This results in a type conversion error. Grails will retain type conversion errors inside the errors property of a Grails domain class. For example:
    class Book {
        ...
        URL publisherURL
    }
Here we have a domain class `Book` that uses the `java.net.URL` class to represent URLs. Given an incoming request such as:
    /book/save?publisherURL=a-bad-url
it is not possible to bind the string `a-bad-url` to the `publisherURL` property as a type mismatch error occurs. You can check for these like this:
    def b = new Book(params)

    if (b.hasErrors()) {
        println "The value ${b.errors.getFieldError('publisherURL').rejectedValue}" +
                " is not a valid URL!"
    }
Although we have not yet covered error codes (for more information see the section on validation), for type conversion errors you would want a message from the `grails-app/i18n/messages.properties` file to use for the error. You can use a generic error message handler such as:
    typeMismatch.java.net.URL=The field {0} is not a valid URL
Or a more specific one:
    typeMismatch.Book.publisherURL=The publisher URL you specified is not a valid URL
#### The BindUsing Annotation The BindUsing annotation may be used to define a custom binding mechanism for a particular field in a class. Any time data binding is being applied to the field the closure value of the annotation will be invoked with 2 arguments. The first argument is the object that data binding is being applied to and the second argument is DataBindingSource which is the data source for the data binding. The value returned from the closure will be bound to the property. The following example would result in the upper case version of the `name` value in the source being applied to the `name` field during data binding.
    import grails.databinding.BindUsing

    class SomeClass {
        @BindUsing({obj, source ->

            //source is DataSourceBinding which is similar to a Map
            //and defines getAt operation but source.name cannot be used here.
            //In order to get name from source use getAt instead as shown below.

            source['name']?.toUpperCase()
        })
        String name
    }
| Note that data binding is only possible when the name of the request parameter matches with the field name in the class. Here, `name` from request parameters matches with `name` from `SomeClass`.
The BindUsing annotation may be used to define a custom binding mechanism for all of the fields on a particular class. When the annotation is applied to a class, the value assigned to the annotation should be a class which implements the BindingHelper interface. An instance of that class will be used any time a value is bound to a property in the class that this annotation has been applied to.
    @BindUsing(SomeClassWhichImplementsBindingHelper)
    class SomeClass {
        String someProperty
        Integer someOtherProperty
    }
#### Custom Data Converters The binder will do a lot of type conversion automatically. Some applications may want to define their own mechanism for converting values and a simple way to do this is to write a class which implements ValueConverter and register an instance of that class as a bean in the Spring application context.
    package com.myapp.converters

    import grails.databinding.converters.ValueConverter

    /**
     * A custom converter which will convert String of the
     * form 'city:state' into an Address object.
     */
    class AddressValueConverter implements ValueConverter {

        boolean canConvert(value) {
            value instanceof String
        }

        def convert(value) {
            def pieces = value.split(':')
            new com.myapp.Address(city: pieces[0], state: pieces[1])
        }

        Class<?> getTargetType() {
            com.myapp.Address
        }
    }
An instance of that class needs to be registered as a bean in the Spring application context. The bean name is not important. All beans that implemented ValueConverter will be automatically plugged in to the data binding process. grails-app/conf/spring/resources.groovy
    beans = {
        addressConverter com.myapp.converters.AddressValueConverter
        // ...
    }
    class Person {
        String firstName
        Address homeAddress
    }

    class Address {
        String city
        String state
    }

    def person = new Person()
    person.properties = [firstName: 'Jeff', homeAddress: "O'Fallon:Missouri"]
    assert person.firstName == 'Jeff'
    assert person.homeAddress.city = "O'Fallon"
    assert person.homeAddress.state = 'Missouri'
#### Date Formats For Data Binding A custom date format may be specified to be used when binding a String to a Date value by applying the BindingFormat annotation to a Date field.
    import grails.databinding.BindingFormat

    class Person {
        @BindingFormat('MMddyyyy')
        Date birthDate
    }
A global setting may be configured in `application.groovy` to define date formats which will be used application wide when binding to Date. grails-app/conf/application.groovy
    grails.databinding.dateFormats = ['MMddyyyy', 'yyyy-MM-dd HH:mm:ss.S', "yyyy-MM-dd'T'hh:mm:ss'Z'"]
The formats specified in `grails.databinding.dateFormats` will be attempted in the order in which they are included in the List. If a property is marked with `@BindingFormat`, the `@BindingFormat` will take precedence over the values specified in `grails.databinding.dateFormats`. The formats configured by default are: `yyyy-MM-dd HH:mm:ss.S` `yyyy-MM-dd’T’hh:mm:ss’Z'` `yyyy-MM-dd HH:mm:ss.S z` `yyyy-MM-dd’T’HH:mm:ss.SSSX` #### Custom Formatted Converters You may supply your own handler for the BindingFormat annotation by writing a class which implements the FormattedValueConverter interface and registering an instance of that class as a bean in the Spring application context. Below is an example of a trivial custom String formatter that might convert the case of a String based on the value assigned to the BindingFormat annotation.
    package com.myapp.converters

    import grails.databinding.converters.FormattedValueConverter

    class FormattedStringValueConverter implements FormattedValueConverter {
        def convert(value, String format) {
            if('UPPERCASE' == format) {
                value = value.toUpperCase()
            } else if('LOWERCASE' == format) {
                value = value.toLowerCase()
            }
            value
        }

        Class getTargetType() {
            // specifies the type to which this converter may be applied
            String
        }
    }
An instance of that class needs to be registered as a bean in the Spring application context. The bean name is not important. All beans that implemented FormattedValueConverter will be automatically plugged in to the data binding process. grails-app/conf/spring/resources.groovy
    beans = {
        formattedStringConverter com.myapp.converters.FormattedStringValueConverter
        // ...
    }
With that in place the `BindingFormat` annotation may be applied to String fields to inform the data binder to take advantage of the custom converter.
    import grails.databinding.BindingFormat

    class Person {
        @BindingFormat('UPPERCASE')
        String someUpperCaseString

        @BindingFormat('LOWERCASE')
        String someLowerCaseString

        String someOtherString
    }
#### Localized Binding Formats The `BindingFormat` annotation supports localized format strings by using the optional `code` attribute. If a value is assigned to the code attribute that value will be used as the message code to retrieve the binding format string from the `messageSource` bean in the Spring application context and that lookup will be localized.
    import grails.databinding.BindingFormat

    class Person {
        @BindingFormat(code='date.formats.birthdays')
        Date birthDate
    }
    # grails-app/conf/i18n/messages.properties
    date.formats.birthdays=MMddyyyy
    # grails-app/conf/i18n/messages_es.properties
    date.formats.birthdays=ddMMyyyy
#### Structured Data Binding Editors A structured data binding editor is a helper class which can bind structured request parameters to a property. The common use case for structured binding is binding to a `Date` object which might be constructed from several smaller pieces of information contained in several request parameters with names like `birthday_month`, `birthday_date` and `birthday_year`. The structured editor would retrieve all of those individual pieces of information and use them to construct a `Date`. The framework provides a structured editor for binding to `Date` objects. An application may register its own structured editors for whatever types are appropriate. Consider the following classes: src/main/groovy/databinding/Gadget.groovy
    package databinding

    class Gadget {
        Shape expandedShape
        Shape compressedShape
    }
src/main/groovy/databinding/Shape.groovy
    package databinding

    class Shape {
        int area
    }
A `Gadget` has 2 `Shape` fields. A `Shape` has an `area` property. It may be that the application wants to accept request parameters like `width` and `height` and use those to calculate the `area` of a `Shape` at binding time. A structured binding editor is well suited for that. The way to register a structured editor with the data binding process is to add an instance of the grails.databinding.TypedStructuredBindingEditor interface to the Spring application context. The easiest way to implement the `TypedStructuredBindingEditor` interface is to extend the org.grails.databinding.converters.AbstractStructuredBindingEditor abstract class and override the `getPropertyValue` method as shown below: src/main/groovy/databinding/converters/StructuredShapeEditor.groovy
    package databinding.converters

    import databinding.Shape

    import org.grails.databinding.converters.AbstractStructuredBindingEditor

    class StructuredShapeEditor extends AbstractStructuredBindingEditor<Shape> {

        public Shape getPropertyValue(Map values) {
            // retrieve the individual values from the Map
            def width = values.width as int
            def height = values.height as int

            // use the values to calculate the area of the Shape
            def area = width * height

            // create and return a Shape with the appropriate area
            new Shape(area: area)
        }
    }
An instance of that class needs to be registered with the Spring application context: grails-app/conf/spring/resources.groovy
    beans = {
        shapeEditor databinding.converters.StructuredShapeEditor
        // ...
    }
When the data binder binds to an instance of the `Gadget` class it will check to see if there are request parameters with names `compressedShape` and `expandedShape` which have a value of "struct" and if they do exist, that will trigger the use of the `StructuredShapeEditor`. The individual components of the structure need to have parameter names of the form propertyName_structuredElementName. In the case of the `Gadget` class above that would mean that the `compressedShape` request parameter should have a value of "struct" and the `compressedShape_width` and `compressedShape_height` parameters should have values which represent the width and the height of the compressed `Shape`. Similarly, the `expandedShape` request parameter should have a value of "struct" and the `expandedShape_width` and `expandedShape_height` parameters should have values which represent the width and the height of the expanded `Shape`. grails-app/controllers/demo/DemoController.groovy
    class DemoController {

        def createGadget(Gadget gadget) {
            /*
            /demo/createGadget?expandedShape=struct&expandedShape_width=80&expandedShape_height=30
                              &compressedShape=struct&compressedShape_width=10&compressedShape_height=3

            */

            // with the request parameters shown above gadget.expandedShape.area would be 2400
            // and gadget.compressedShape.area would be 30
            // ...
        }
    }
Typically the request parameters with "struct" as their value would be represented by hidden form fields. #### Data Binding Event Listeners The DataBindingListener interface provides a mechanism for listeners to be notified of data binding events. The interface looks like this:
    package grails.databinding.events;

    import grails.databinding.errors.BindingError;

    /**
     * A listener which will be notified of events generated during data binding.
     *
     * @author Jeff Brown
     * @since 3.0
     * @see DataBindingListenerAdapter
     */
    public interface DataBindingListener {

        /**
         * @return true if the listener is interested in events for the specified type.
         */
        boolean supports(Class<?> clazz);

        /**
         * Called when data binding is about to start.
         *
         * @param target The object data binding is being imposed upon
         * @param errors the Spring Errors instance (a org.springframework.validation.BindingResult)
         * @return true if data binding should continue
         */
        Boolean beforeBinding(Object target, Object errors);

        /**
         * Called when data binding is about to imposed on a property
         *
         * @param target The object data binding is being imposed upon
         * @param propertyName The name of the property being bound to
         * @param value The value of the property being bound
         * @param errors the Spring Errors instance (a org.springframework.validation.BindingResult)
         * @return true if data binding should continue, otherwise return false
         */
        Boolean beforeBinding(Object target, String propertyName, Object value, Object errors);

        /**
         * Called after data binding has been imposed on a property
         *
         * @param target The object data binding is being imposed upon
         * @param propertyName The name of the property that was bound to
         * @param errors the Spring Errors instance (a org.springframework.validation.BindingResult)
         */
        void afterBinding(Object target, String propertyName, Object errors);

        /**
         * Called after data binding has finished.
         *
         * @param target The object data binding is being imposed upon
         * @param errors the Spring Errors instance (a org.springframework.validation.BindingResult)
         */
        void afterBinding(Object target, Object errors);

        /**
         * Called when an error occurs binding to a property
         * @param error encapsulates information about the binding error
         * @param errors the Spring Errors instance (a org.springframework.validation.BindingResult)
         * @see BindingError
         */
        void bindingError(BindingError error, Object errors);
    }
Any bean in the Spring application context which implements that interface will automatically be registered with the data binder. The DataBindingListenerAdapter class implements the `DataBindingListener` interface and provides default implementations for all of the methods in the interface so this class is well suited for subclassing so your listener class only needs to provide implementations for the methods your listener is interested in. #### Using The Data Binder Directly There are situations where an application may want to use the data binder directly. For example, to do binding in a Service on some arbitrary object which is not a domain class. The following will not work because the `properties` property is read only. src/main/groovy/bindingdemo/Widget.groovy
    package bindingdemo

    class Widget {
        String name
        Integer size
    }
grails-app/services/bindingdemo/WidgetService.groovy
    package bindingdemo

    class WidgetService {

        def updateWidget(Widget widget, Map data) {
            // this will throw an exception because
            // properties is read-only
            widget.properties = data
        }
    }
An instance of the data binder is in the Spring application context with a bean name of `grailsWebDataBinder`. That bean implements the DataBinder interface. The following code demonstrates using the data binder directly. grails-app/services/bindingdmeo/WidgetService
    package bindingdemo

    import grails.databinding.SimpleMapDataBindingSource

    class WidgetService {

        // this bean will be autowired into the service
        def grailsWebDataBinder

        def updateWidget(Widget widget, Map data) {
            grailsWebDataBinder.bind widget, data as SimpleMapDataBindingSource
        }

    }
See the DataBinder documentation for more information about overloaded versions of the `bind` method. #### Data Binding and Security Concerns When batch updating properties from request parameters you need to be careful not to allow clients to bind malicious data to domain classes and be persisted in the database. You can limit what properties are bound to a given domain class using the subscript operator:
    def p = Person.get(1)

    p.properties['firstName','lastName'] = params
In this case only the `firstName` and `lastName` properties will be bound. Another way to do this is is to use Command Objects as the target of data binding instead of domain classes. Alternatively there is also the flexible bindData method. The `bindData` method allows the same data binding capability, but to arbitrary objects:
    def p = new Person()
    bindData(p, params)
The `bindData` method also lets you exclude certain parameters that you don’t want updated:
    def p = new Person()
    bindData(p, params, [exclude: 'dateOfBirth'])
Or include only certain properties:
    def p = new Person()
    bindData(p, params, [include: ['firstName', 'lastName']])
| If an empty List is provided as a value for the `include` parameter then all fields will be subject to binding if they are not explicitly excluded.
The bindable constraint can be used to globally prevent data binding for certain properties. ## 8.1.6 Responding with JSON #### Using the respond method to output JSON The `respond` method is the preferred way to return JSON and integrates with Content Negotiation and JSON Views. The `respond` method provides content negotiation strategies to intelligently produce an appropriate response for the given client. For example given the following controller and action: grails-app/controllers/example/BookController.groovy
    package example

    class BookController {
        def index() {
            respond Book.list()
        }
    }
The `respond` method will take the followings steps: If the client `Accept` header specifies a media type (for example `application/json`) use that If the file extension of the URI (for example `/books.json`) includes a format defined in the `grails.mime.types` property of `grails-app/conf/application.yml` use the media type defined in the configuration The `respond` method will then look for an appriopriate Renderer for the object and the calculated media type from the RendererRegistry. Grails includes a number of pre-configured `Renderer` implementations that will produce default representations of JSON responses for the argument passed to `respond`. For example going to the `/book.json` URI will produce JSON such as:
    [
        {id:1,"title":"The Stand"},
        {id:2,"title":"Shining"}
    ]
#### Controlling the Priority of Media Types By default if you define a controller there is no priority in terms of which format is sent back to the client and Grails assumes you wish to serve HTML as a response type. However if your application is primarily an API, then you can specify the priorty using the `responseFormats` property: grails-app/controllers/example/BookController.groovy
    package example

    class BookController {
        static responseFormats = ['json', 'html']
        def index() {
            respond Book.list()
        }
    }
In the above example Grails will respond by default with `json` if the media type to respond with cannot be calculated from the `Accept` header or file extension. #### Using Views to Output JSON Responses If you define a view (either a GSP or a JSON View) then Grails will render the view when using the `respond` method by calculating a model from the argument passed to `respond`. For example, in the previous listing, if you were to define `grails-app/views/index.gson` and `grails-app/views/index.gsp` views, these would be used if the client requested `application/json` or `text/html` media types respectively. Thus allowing you to define a single backend capible of serving responses to a web browser or representing your application’s API. When rendering the view, Grails will calculate a model to pass to the view based on the type of the value passed to the `respond` method. The following table summarizes this convention:
Example | Argument Type | Calculated Model Variable
--- | --- | ---
`respond Book.list()` | `java.util.List` | `bookList`
`respond( [] )` | `java.util.List` | `emptyList`
`respond Book.get(1)` | `example.Book` | `book`
`respond( [1,2] )` | `java.util.List` | `integerList`
`respond( [1,2] as Set )` | `java.util.Set` | `integerSet`
`respond( [1,2] as Integer[] )` | `Integer[]` | `integerArray`
Using this convention you can reference the argument passed to `respond` from within your view: grails-app/views/book/index.gson
    @Field List<Book> bookList = []

    json bookList, { Book book ->
        title book.title
    }
You will notice that if `Book.list()` returns an empty list then the model variable name is translated to `emptyList`. This is by design and you should provide a default value in the view if no model variable is specified, such as the `List` in the example above: grails-app/views/book/index.gson
    // defaults to an empty list
    @Field List<Book> bookList = []
    ...
There are cases where you may wish to be more explicit and control the name of the model variable. For example if you have a domain inheritance hierarchy where a call to `list()` my return different child classes relying on automatic calculation may not be reliable. In this case you should pass the model directly using `respond` and a map argument:
    respond bookList: Book.list()
| When responding with any kind of mixed argument types in a collection, always use an explicit model name.
If you simply wish to augment the calculated model then you can do so by passing a `model` argument:
    respond Book.list(), [model: [bookCount: Book.count()]]
The above example will produce a model like `[bookList:books, bookCount:totalBooks]`, where the calculated model is combined with the model passed in the `model` argument. #### Using the render method to output JSON The `render` method can also be used to output JSON, but should only be used for simple cases that don’t warrant the creation of a JSON view:
    def list() {

        def results = Book.list()

        render(contentType: "application/json") {
            books(results) { Book b ->
                title b.title
            }
        }
    }
In this case the result would be something along the lines of:
    [
        {"title":"The Stand"},
        {"title":"Shining"}
    ]
| This technique for rendering JSON may be ok for very simple responses, but in general you should favour the use of JSON Views and use the view layer rather than embedding logic in your application.
The same dangers with naming conflicts described above for XML also apply to JSON building. ## 8.1.7 More on JSONBuilder The previous section on on XML and JSON responses covered simplistic examples of rendering XML and JSON responses. Whilst the XML builder used by Grails is the standard XmlSlurper found in Groovy. For JSON, since Grails 3.1, Grails uses Groovy’s StreamingJsonBuilder by default and you can refer to the Groovy documentation and StreamingJsonBuilder API documentation on how to use it. In older version of Grails a custom JSON builder was used called grails.web.JSONBuilder. This class is considered deprecated. However, if you are upgrading an application you can re-enable it with the following configuration in `application.groovy`:
    grails.json.legacy.builder = false
## 8.1.8 Responding with XML ## 8.1.9 Uploading Files #### Programmatic File Uploads Grails supports file uploads using Spring’s MultipartHttpServletRequest interface. The first step for file uploading is to create a multipart form like this:
    Upload Form: <br />
        <g:uploadForm action="upload">
            <input type="file" name="myFile" />
            <input type="submit" />
        </g:uploadForm>
The `uploadForm` tag conveniently adds the `enctype="multipart/form-data"` attribute to the standard `<g:form>` tag. There are then a number of ways to handle the file upload. One is to work with the Spring MultipartFile instance directly:
    def upload() {
        def f = request.getFile('myFile')
        if (f.empty) {
            flash.message = 'file cannot be empty'
            render(view: 'uploadForm')
            return
        }

        f.transferTo(new File('/some/local/dir/myfile.txt'))
        response.sendError(200, 'Done')
    }
This is convenient for doing transfers to other destinations and manipulating the file directly as you can obtain an `InputStream` and so on with the MultipartFile interface. #### File Uploads through Data Binding File uploads can also be performed using data binding. Consider this `Image` domain class:
    class Image {
        byte[] myFile

        static constraints = {
            // Limit upload file size to 2MB
            myFile maxSize: 1024 * 1024 * 2
        }
    }
If you create an image using the `params` object in the constructor as in the example below, Grails will automatically bind the file’s contents as a `byte[]` to the `myFile` property:
    def img = new Image(params)
It’s important that you set the size or maxSize constraints, otherwise your database may be created with a small column size that can’t handle reasonably sized files. For example, both H2 and MySQL default to a blob size of 255 bytes for `byte[]` properties. It is also possible to set the contents of the file as a string by changing the type of the `myFile` property on the image to a String type:
    class Image {
       String myFile
    }
## 8.1.10 Command Objects Grails controllers support the concept of command objects. A command object is a class that is used in conjunction with data binding, usually to allow validation of data that may not fit into an existing domain class.
| A class is only considered to be a command object when it is used as a parameter of an action.
#### Declaring Command Objects Command object classes are defined just like any other class.
    class LoginCommand implements grails.validation.Validateable {
        String username
        String password

        static constraints = {
            username(blank: false, minSize: 6)
            password(blank: false, minSize: 6)
        }
    }
In this example, the command object class implements the `Validateable` trait. The `Validateable` trait allows the definition of Constraints just like in domain classes. If the command object is defined in the same source file as the controller that is using it, Grails will automatically make it `Validateable`. It is not required that command object classes be validateable. By default, all `Validateable` object properties which are not instances of `java.util.Collection` or `java.util.Map` are `nullable: false`. Instances of `java.util.Collection` and `java.util.Map` default to `nullable: true`. If you want a `Validateable` that has `nullable: true` properties by default, you can specify this by defining a `defaultNullable` method in the class:
    class AuthorSearchCommand implements grails.validation.Validateable {
        String  name
        Integer age

        static boolean defaultNullable() {
            true
        }
    }
In this example, both `name` and `age` will allow null values during validation. #### Using Command Objects To use command objects, controller actions may optionally specify any number of command object parameters. The parameter types must be supplied so that Grails knows what objects to create and initialize. Before the controller action is executed Grails will automatically create an instance of the command object class and populate its properties by binding the request parameters. If the command object class is marked with `Validateable` then the command object will be validated. For example:
    class LoginController {

        def login(LoginCommand cmd) {
            if (cmd.hasErrors()) {
                redirect(action: 'loginForm')
                return
            }

            // work with the command object data
        }
    }
If the command object’s type is that of a domain class and there is an `id` request parameter then instead of invoking the domain class constructor to create a new instance a call will be made to the static `get` method on the domain class and the value of the `id` parameter will be passed as an argument. Whatever is returned from that call to `get` is what will be passed into the controller action. This means that if there is an `id` request parameter and no corresponding record is found in the database then the value of the command object will be `null`. If an error occurs retrieving the instance from the database then `null` will be passed as an argument to the controller action and an error will be added the controller’s `errors` property. If the command object’s type is a domain class and there is no `id` request parameter or there is an `id` request parameter and its value is empty then `null` will be passed into the controller action unless the HTTP request method is "POST", in which case a new instance of the domain class will be created by invoking the domain class constructor. For all of the cases where the domain class instance is non-null, data binding is only performed if the HTTP request method is "POST", "PUT" or "PATCH". #### Command Objects And Request Parameter Names Normally request parameter names will be mapped directly to property names in the command object. Nested parameter names may be used to bind down the object graph in an intuitive way. In the example below a request parameter named `name` will be bound to the `name` property of the `Person` instance and a request parameter named `address.city` will be bound to the `city` property of the `address` property in the `Person`.
    class StoreController {
        def buy(Person buyer) {
            // ...
        }
    }

    class Person {
        String name
        Address address
    }

    class Address {
        String city
    }
A problem may arise if a controller action accepts multiple command objects which happen to contain the same property name. Consider the following example.
    class StoreController {
        def buy(Person buyer, Product product) {
            // ...
        }
    }

    class Person {
        String name
        Address address
    }

    class Address {
        String city
    }

    class Product {
        String name
    }
If there is a request parameter named `name` it isn’t clear if that should represent the name of the `Product` or the name of the `Person`. Another version of the problem can come up if a controller action accepts 2 command objects of the same type as shown below.
    class StoreController {
        def buy(Person buyer, Person seller, Product product) {
            // ...
        }
    }

    class Person {
        String name
        Address address
    }

    class Address {
        String city
    }

    class Product {
        String name
    }
To help deal with this the framework imposes special rules for mapping parameter names to command object types. The command object data binding will treat all parameters that begin with the controller action parameter name as belonging to the corresponding command object. For example, the `product.name` request parameter will be bound to the `name` property in the `product` argument, the `buyer.name` request parameter will be bound to the `name` property in the `buyer` argument the `seller.address.city` request parameter will be bound to the `city` property of the `address` property of the `seller` argument, etc…​ #### Command Objects and Dependency Injection Command objects can participate in dependency injection. This is useful if your command object has some custom validation logic which uses a Grails service:
    class LoginCommand implements grails.validation.Validateable {

        def loginService

        String username
        String password

        static constraints = {
            username validator: { val, obj ->
                obj.loginService.canLogin(obj.username, obj.password)
            }
        }
    }
In this example the command object interacts with the `loginService` bean which is injected by name from the Spring `ApplicationContext`. #### Binding The Request Body To Command Objects When a request is made to a controller action which accepts a command object and the request contains a body, Grails will attempt to parse the body of the request based on the request content type and use the body to do data binding on the command object. See the following example. grails-app/controllers/bindingdemo/DemoController.groovy
    package bindingdemo

    class DemoController {

        def createWidget(Widget w) {
            render "Name: ${w?.name}, Size: ${w?.size}"
        }
    }

    class Widget {
        String name
        Integer size
    }
    $ curl -H "Content-Type: application/json" -d '{"name":"Some Widget","42"}'[size] localhost:8080/demo/createWidget
     Name: Some Widget, Size: 42

    $ curl -H "Content-Type: application/xml" -d '<widget><name>Some Other Widget</name><size>2112</size></widget>' localhost:8080/bodybind/demo/createWidget
     Name: Some Other Widget, Size: 2112
| The request body will not be parsed under the following conditions: * The request method is GET * The request method is DELETE * The content length is 0
Note that the body of the request is being parsed to make that work. Any attempt to read the body of the request after that will fail since the corresponding input stream will be empty. The controller action can either use a command object or it can parse the body of the request on its own (either directly, or by referring to something like request.JSON), but cannot do both. grails-app/controllers/bindingdemo/DemoController.groovy
    package bindingdemo

    class DemoController {

        def createWidget(Widget w) {
            // this will fail because it requires reading the body,
            // which has already been read.
            def json = request.JSON

            // ...

        }
    }
#### Working with Lists of Command Objects A common use case for command objects is a Command Object that contains a collection of another:
    class DemoController {

        def createAuthor(AuthorCommand command) {
            // ...

        }

        class AuthorCommand {
            String fullName
            List<BookCommand> books
        }

        class BookCommand {
            String title
            String isbn
        }
    }
On this example, we want to create an Author with multiple Books. In order to make this work from the UI layer, you can do the following in your GSP:
    <g:form name="submit-author-books" controller="demo" action="createAuthor">
        <g:fieldValue name="fullName" value=""/>
        <ul>
            <li>
                <g:fieldValue name="books[0].title" value=""/>
                <g:fieldValue name="books[0].isbn" value=""/>
            </li>

            <li>
                <g:fieldValue name="books[1].title" value=""/>
                <g:fieldValue name="books[1].isbn" value=""/>
            </li>
        </ul>
    </g:form>
There is also support for JSON, so you can submit the following with correct databinding
    {
        "fullName": "Graeme Rocher",
        "books": [{
            "title": "The Definitive Guide to Grails",
            "isbn": "1111-343455-1111"
        }, {
            "title": "The Definitive Guide to Grails 2",
            "isbn": "1111-343455-1112"
        }],
    }
## 8.1.11 Handling Duplicate Form Submissions Grails has built-in support for handling duplicate form submissions using the "Synchronizer Token Pattern". To get started you define a token on the form tag:
    <g:form useToken="true" ...>
Then in your controller code you can use the withForm method to handle valid and invalid requests:
    withForm {
       // good request
    }.invalidToken {
       // bad request
    }
If you only provide the withForm method and not the chained `invalidToken` method then by default Grails will store the invalid token in a `flash.invalidToken` variable and redirect the request back to the original page. This can then be checked in the view:
    <g:if test="${flash.invalidToken}">
      Don't click the button twice!
    </g:if>
| The withForm tag makes use of the session and hence requires session affinity or clustered sessions if used in a cluster.
## 8.1.12 Simple Type Converters ### Type Conversion Methods If you prefer to avoid the overhead of data binding and simply want to convert incoming parameters (typically Strings) into another more appropriate type the params object has a number of convenience methods for each type:
    def total = params.int('total')
The above example uses the `int` method, and there are also methods for `boolean`, `long`, `char`, `short` and so on. Each of these methods is null-safe and safe from any parsing errors, so you don’t have to perform any additional checks on the parameters. Each of the conversion methods allows a default value to be passed as an optional second argument. The default value will be returned if a corresponding entry cannot be found in the map or if an error occurs during the conversion. Example:
    def total = params.int('total', 42)
These same type conversion methods are also available on the `attrs` parameter of GSP tags. ### Handling Multi Parameters A common use case is dealing with multiple request parameters of the same name. For example you could get a query string such as `?name=Bob&name=Judy`. In this case dealing with one parameter and dealing with many has different semantics since Groovy’s iteration mechanics for `String` iterate over each character. To avoid this problem the params object provides a `list` method that always returns a list:
    for (name in params.list('name')) {
        println name
    }
## 8.1.13 Declarative Controller Exception Handling Grails controllers support a simple mechanism for declarative exception handling. If a controller declares a method that accepts a single argument and the argument type is `java.lang.Exception` or some subclass of `java.lang.Exception`, that method will be invoked any time an action in that controller throws an exception of that type. See the following example. grails-app/controllers/demo/DemoController.groovy
    package demo

    class DemoController {

        def someAction() {
            // do some work
        }

        def handleSQLException(SQLException e) {
            render 'A SQLException Was Handled'
        }

        def handleBatchUpdateException(BatchUpdateException e) {
            redirect controller: 'logging', action: 'batchProblem'
        }

        def handleNumberFormatException(NumberFormatException nfe) {
            [problemDescription: 'A Number Was Invalid']
        }
    }
That controller will behave as if it were written something like this…​ grails-app/controllers/demo/DemoController.groovy
    package demo

    class DemoController {

        def someAction() {
            try {
                // do some work
            } catch (BatchUpdateException e) {
                return handleBatchUpdateException(e)
            } catch (SQLException e) {
                return handleSQLException(e)
            } catch (NumberFormatException e) {
                return handleNumberFormatException(e)
            }
        }

        def handleSQLException(SQLException e) {
            render 'A SQLException Was Handled'
        }

        def handleBatchUpdateException(BatchUpdateException e) {
            redirect controller: 'logging', action: 'batchProblem'
        }

        def handleNumberFormatException(NumberFormatException nfe) {
            [problemDescription: 'A Number Was Invalid']
        }
    }
The exception handler method names can be any valid method name. The name is not what makes the method an exception handler, the `Exception` argument type is the important part. The exception handler methods can do anything that a controller action can do including invoking `render`, `redirect`, returning a model, etc. One way to share exception handler methods across multiple controllers is to use inheritance. Exception handler methods are inherited into subclasses so an application could define the exception handlers in an abstract class that multiple controllers extend from. Another way to share exception handler methods across multiple controllers is to use a trait, as shown below…​ src/main/groovy/com/demo/DatabaseExceptionHandler.groovy
    package com.demo

    trait DatabaseExceptionHandler {
        def handleSQLException(SQLException e) {
            // handle SQLException
        }

        def handleBatchUpdateException(BatchUpdateException e) {
            // handle BatchUpdateException
        }
    }
grails-app/controllers/com/demo/DemoController.groovy
    package com.demo

    class DemoController implements DatabaseExceptionHandler {

        // all of the exception handler methods defined
        // in DatabaseExceptionHandler will be added to
        // this class at compile time
    }
Exception handler methods must be present at compile time. Specifically, exception handler methods which are runtime metaprogrammed onto a controller class are not supported. ## 8.2 Groovy Server Pages Groovy Servers Pages (or GSP for short) is Grails' view technology. It is designed to be familiar for users of technologies such as ASP and JSP, but to be far more flexible and intuitive.
| Although GSP can render any format, not just HTML, it is more designed around rendering markup. If you are looking for a way to simplify JSON responses take a look at JSON Views.
GSPs live in the `grails-app/views` directory and are typically rendered automatically (by convention) or with the render method such as:
    render(view: "index")
A GSP is typically a mix of mark-up and GSP tags which aid in view rendering.
| Although it is possible to have Groovy logic embedded in your GSP and doing this will be covered in this document, the practice is strongly discouraged. Mixing mark-up and code is a bad thing and most GSP pages contain no code and needn’t do so.
A GSP typically has a "model" which is a set of variables that are used for view rendering. The model is passed to the GSP view from a controller. For example consider the following controller action:
    def show() {
        [book: Book.get(params.id)]
    }
This action will look up a `Book` instance and create a model that contains a key called `book`. This key can then be referenced within the GSP view using the name `book`:
    ${book.title}
| Embedding data received from user input has the risk of making your application vulnerable to an Cross Site Scripting (XSS) attack. Please read the documentation on XSS prevention for information on how to prevent XSS attacks.
## 8.2.1 GSP Basics In the next view sections we’ll go through the basics of GSP and what is available to you. First off let’s cover some basic syntax that users of JSP and ASP should be familiar with. GSP supports the usage of `<% %>` scriptlet blocks to embed Groovy code (again this is discouraged):
    <html>
       <body>
         <% out << "Hello GSP!" %>
       </body>
    </html>
You can also use the `<%= %>` syntax to output values:
    <html>
       <body>
         <%="Hello GSP!" %>
       </body>
    </html>
GSP also supports JSP-style server-side comments (which are not rendered in the HTML response) as the following example demonstrates:
    <html>
       <body>
         <%-- This is my comment --%>
         <%="Hello GSP!" %>
       </body>
    </html>
| Embedding data received from user input has the risk of making your application vulnerable to an Cross Site Scripting (XSS) attack. Please read the documentation on XSS prevention for information on how to prevent XSS attacks.
## 8.2.1.1 Variables and Scopes Within the `<% %>` brackets you can declare variables:
    <% now = new Date() %>
and then access those variables later in the page:
    <%=now%>
Within the scope of a GSP there are a number of pre-defined variables, including: `application` - The ServletContext instance `applicationContext` The Spring ApplicationContext instance `flash` - The flash object `grailsApplication` - The GrailsApplication instance `out` - The response writer for writing to the output stream `params` - The params object for retrieving request parameters `request` - The HttpServletRequest instance `response` - The HttpServletResponse instance `session` - HttpSession instance `webRequest` - The GrailsWebRequest instance ## 8.2.1.2 Logic and Iteration Using the `<% %>` syntax you can embed loops and so on using this syntax:
    <html>
       <body>
          <% [1,2,3,4].each { num -> %>
             <p><%="Hello ${num}!" %></p>
          <%}%>
       </body>
    </html>
As well as logical branching:
    <html>
       <body>
          <% if (params.hello == 'true')%>
          <%="Hello!"%>
          <% else %>
          <%="Goodbye!"%>
       </body>
    </html>
## 8.2.1.3 Page Directives GSP also supports a few JSP-style page directives. The import directive lets you import classes into the page. However, it is rarely needed due to Groovy’s default imports and GSP Tags:
    <%@ page import="java.awt.*" %>
GSP also supports the contentType directive:
    <%@ page contentType="application/json" %>
The contentType directive allows using GSP to render other formats. ## 8.2.1.4 Expressions In GSP the `<%= %>` syntax introduced earlier is rarely used due to the support for GSP expressions. A GSP expression is similar to a JSP EL expression or a Groovy GString and takes the form `${expr}`:
    <html>
      <body>
        Hello ${params.name}
      </body>
    </html>
However, unlike JSP EL you can have any Groovy expression within the `${..}` block.
| Embedding data received from user input has the risk of making your application vulnerable to an Cross Site Scripting (XSS) attack. Please read the documentation on XSS prevention for information on how to prevent XSS attacks.
## 8.2.2 GSP Tags Now that the less attractive JSP heritage has been set aside, the following sections cover GSP’s built-in tags, which are the preferred way to define GSP pages.
| The section on Tag Libraries covers how to add your own custom tag libraries.
All built-in GSP tags start with the prefix `g:`. Unlike JSP, you don’t specify any tag library imports. If a tag starts with `g:` it is automatically assumed to be a GSP tag. An example GSP tag would look like:
    <g:example />
GSP tags can also have a body such as:
    <g:example>
       Hello world
    </g:example>
Expressions can be passed into GSP tag attributes, if an expression is not used it will be assumed to be a String value:
    <g:example attr="${new Date()}">
       Hello world
    </g:example>
Maps can also be passed into GSP tag attributes, which are often used for a named parameter style syntax:
    <g:example attr="${new Date()}" attr2="[one:1, two:2, three:3]">
       Hello world
    </g:example>
Note that within the values of attributes you must use single quotes for Strings:
    <g:example attr="${new Date()}" attr2="[one:'one', two:'two']">
       Hello world
    </g:example>
With the basic syntax out the way, the next sections look at the tags that are built into Grails by default. ## 8.2.2.1 Variables and Scopes Variables can be defined within a GSP using the set tag:
    <g:set var="now" value="${new Date()}" />
Here we assign a variable called `now` to the result of a GSP expression (which simply constructs a new `java.util.Date` instance). You can also use the body of the `<g:set>` tag to define a variable:
    <g:set var="myHTML">
       Some re-usable code on: ${new Date()}
    </g:set>
The assigned value can also be a bean from the applicationContext:
    <g:set var="bookService" bean="bookService" />
Variables can also be placed in one of the following scopes: `page` - Scoped to the current page (default) `request` - Scoped to the current request `flash` - Placed within flash scope and hence available for the next request `session` - Scoped for the user session `application` - Application-wide scope. To specify the scope, use the `scope` attribute:
    <g:set var="now" value="${new Date()}" scope="request" />
## 8.2.2.2 Logic and Iteration GSP also supports logical and iterative tags out of the box. For logic there are if, else and elseif tags for use with branching:
    <g:if test="${session.role == 'admin'}">
       <%-- show administrative functions --%>
    </g:if>
    <g:else>
       <%-- show basic functions --%>
    </g:else>
Use the each and while tags for iteration:
    <g:each in="${[1,2,3]}" var="num">
       <p>Number ${num}</p>
    </g:each>

    <g:set var="num" value="${1}" />
    <g:while test="${num < 5 }">
        <p>Number ${num++}</p>
    </g:while>
## 8.2.2.3 Search and Filtering If you have collections of objects you often need to sort and filter them. Use the findAll and grep tags for these tasks:
    Stephen King's Books:
    <g:findAll in="${books}" expr="it.author == 'Stephen King'">
         <p>Title: ${it.title}</p>
    </g:findAll>
The `expr` attribute contains a Groovy expression that can be used as a filter. The grep tag does a similar job, for example filtering by class:
    <g:grep in="${books}" filter="NonFictionBooks.class">
         <p>Title: ${it.title}</p>
    </g:grep>
Or using a regular expression:
    <g:grep in="${books.title}" filter="~/.*?Groovy.*?/">
         <p>Title: ${it}</p>
    </g:grep>
The above example is also interesting due to its usage of GPath. GPath is an XPath-like language in Groovy. The `books` variable is a collection of `Book` instances. Since each `Book` has a `title`, you can obtain a list of Book titles using the expression `books.title`. Groovy will auto-magically iterate the collection, obtain each title, and return a new list! ## 8.2.2.4 Links and Resources GSP also features tags to help you manage linking to controllers and actions. The link tag lets you specify controller and action name pairing and it will automatically work out the link based on the URL Mappings, even if you change them! For example:
    <g:link action="show" id="1">Book 1</g:link>

    <g:link action="show" id="${currentBook.id}">${currentBook.name}</g:link>

    <g:link controller="book">Book Home</g:link>

    <g:link controller="book" action="list">Book List</g:link>

    <g:link url="[action: 'list', controller: 'book']">Book List</g:link>

    <g:link params="[sort: 'title', order: 'asc', author: currentBook.author]"
            action="list">Book List</g:link>
## 8.2.2.5 Forms and Fields #### Form Basics GSP supports many different tags for working with HTML forms and fields, the most basic of which is the form tag. This is a controller/action aware version of the regular HTML form tag. The `url` attribute lets you specify which controller and action to map to:
    <g:form name="myForm" url="[controller:'book',action:'list']">...</g:form>
In this case we create a form called `myForm` that submits to the `BookController’s `list` action. Beyond that all of the usual HTML attributes apply. #### Form Fields In addition to easy construction of forms, GSP supports custom tags for dealing with different types of fields, including: textField - For input fields of type 'text' passwordField - For input fields of type 'password' checkBox - For input fields of type 'checkbox' radio - For input fields of type 'radio' hiddenField - For input fields of type 'hidden' select - For dealing with HTML select boxes Each of these allows GSP expressions for the value:
    <g:textField name="myField" value="${myValue}" />
GSP also contains extended helper versions of the above tags such as radioGroup (for creating groups of radio tags), localeSelect, currencySelect and timeZoneSelect (for selecting locales, currencies and time zones respectively). #### Multiple Submit Buttons The age old problem of dealing with multiple submit buttons is also handled elegantly with Grails using the actionSubmit tag. It is just like a regular submit, but lets you specify an alternative action to submit to:
    <g:actionSubmit value="Some update label" action="update" />
## 8.2.2.6 Tags as Method Calls One major different between GSP tags and other tagging technologies is that GSP tags can be called as either regular tags or as method calls from controllers, tag libraries or GSP views. #### Tags as method calls from GSPs Tags return their results as a String-like object (a `StreamCharBuffer` which has all of the same methods as String) instead of writing directly to the response when called as methods. For example:
    Static Resource: ${createLinkTo(dir: "images", file: "logo.jpg")}
This is particularly useful for using a tag within an attribute:
    <img src="${createLinkTo(dir: 'images', file: 'logo.jpg')}" />
In view technologies that don’t support this feature you have to nest tags within tags, which becomes messy quickly and often has an adverse effect of WYSIWYG tools such as Dreamweaver that attempt to render the mark-up as it is not well-formed:
    <img src="<g:createLinkTo dir="images" file="logo.jpg" />" />
#### Tags as method calls from Controllers and Tag Libraries You can also invoke tags from controllers and tag libraries. Tags within the default `g:` namespace can be invoked without the prefix and a `StreamCharBuffer` result is returned:
    def imageLocation = createLinkTo(dir:"images", file:"logo.jpg").toString()
Prefix the namespace to avoid naming conflicts:
    def imageLocation = g.createLinkTo(dir:"images", file:"logo.jpg").toString()
For tags that use a custom namespace, use that prefix for the method call. For example (from the FCK Editor plugin):
    def editor = fckeditor.editor(name: "text", width: "100%", height: "400")
## 8.2.3 Views and Templates Grails also has the concept of templates. These are useful for partitioning your views into maintainable chunks, and combined with Layouts provide a highly re-usable mechanism for structured views. #### Template Basics Grails uses the convention of placing an underscore before the name of a view to identify it as a template. For example, you might have a template that renders Books located at `grails-app/views/book/_bookTemplate.gsp`:
    <div class="book" id="${book?.id}">
       <div>Title: ${book?.title}</div>
       <div>Author: ${book?.author?.name}</div>
    </div>
Use the render tag to render this template from one of the views in `grails-app/views/book`:
    <g:render template="bookTemplate" model="[book: myBook]" />
Notice how we pass into a model to use using the `model` attribute of the `render` tag. If you have multiple `Book` instances you can also render the template for each `Book` using the render tag with a `collection` attribute:
    <g:render template="bookTemplate" var="book" collection="${bookList}" />
#### Shared Templates In the previous example we had a template that was specific to the `BookController` and its views at `grails-app/views/book`. However, you may want to share templates across your application. In this case you can place them in the root views directory at grails-app/views or any subdirectory below that location, and then with the template attribute use an absolute location starting with `/` instead of a relative location. For example if you had a template called `grails-app/views/shared/_mySharedTemplate.gsp`, you would reference it as:
    <g:render template="/shared/mySharedTemplate" />
You can also use this technique to reference templates in any directory from any view or controller:
    <g:render template="/book/bookTemplate" model="[book: myBook]" />
#### The Template Namespace Since templates are used so frequently there is template namespace, called `tmpl`, available that makes using templates easier. Consider for example the following usage pattern:
    <g:render template="bookTemplate" model="[book:myBook]" />
This can be expressed with the `tmpl` namespace as follows:
    <tmpl:bookTemplate book="${myBook}" />
#### Templates in Controllers and Tag Libraries You can also render templates from controllers using the render controller method. This is useful for JavaScript heavy applications where you generate small HTML or data responses to partially update the current page instead of performing new request:
    def bookData() {
        def b = Book.get(params.id)
        render(template:"bookTemplate", model:[book:b])
    }
The render controller method writes directly to the response, which is the most common behaviour. To instead obtain the result of template as a String you can use the render tag:
    def bookData() {
        def b = Book.get(params.id)
        String content = g.render(template:"bookTemplate", model:[book:b])
        render content
    }
Notice the usage of the `g` namespace which tells Grails we want to use the tag as method call instead of the render method. ## 8.2.4 Layouts with Sitemesh #### Creating Layouts Grails leverages Sitemesh, a decorator engine, to support view layouts. Layouts are located in the `grails-app/views/layouts` directory. A typical layout can be seen below:
    <html>
        <head>
            <title><g:layoutTitle default="An example decorator" /></title>
            <g:layoutHead />
        </head>
        <body onload="${pageProperty(name:'body.onload')}">
            <div class="menu"><!--my common menu goes here--></div>
            <div class="body">
                <g:layoutBody />
            </div>
        </body>
    </html>
The key elements are the layoutHead, layoutTitle and layoutBody tag invocations: `layoutTitle` - outputs the target page’s title `layoutHead` - outputs the target page’s head tag contents `layoutBody` - outputs the target page’s body tag contents The previous example also demonstrates the pageProperty tag which can be used to inspect and return aspects of the target page. #### Triggering Layouts There are a few ways to trigger a layout. The simplest is to add a meta tag to the view:
    <html>
        <head>
            <title>An Example Page</title>
            <meta name="layout" content="main" />
        </head>
        <body>This is my content!</body>
    </html>
In this case a layout called `grails-app/views/layouts/main.gsp` will be used to layout the page. If we were to use the layout from the previous section the output would resemble this:
    <html>
        <head>
            <title>An Example Page</title>
        </head>
        <body onload="">
            <div class="menu"><!--my common menu goes here--></div>
            <div class="body">
                This is my content!
            </div>
        </body>
    </html>
#### Specifying A Layout In A Controller Another way to specify a layout is to specify the name of the layout by assigning a value to the "layout" property in a controller. For example, if you have a controller such as:
    class BookController {
        static layout = 'customer'

        def list() { ... }
    }
You can create a layout called `grails-app/views/layouts/customer.gsp` which will be applied to all views that the `BookController` delegates to. The value of the "layout" property may contain a directory structure relative to the `grails-app/views/layouts/` directory. For example:
    class BookController {
        static layout = 'custom/customer'

        def list() { ... }
    }
Views rendered from that controller would be decorated with the `grails-app/views/layouts/custom/customer.gsp` template. #### Layout by Convention Another way to associate layouts is to use "layout by convention". For example, if you have this controller:
    class BookController {
        def list() { ... }
    }
You can create a layout called `grails-app/views/layouts/book.gsp`, which will be applied to all views that the `BookController` delegates to. Alternatively, you can create a layout called `grails-app/views/layouts/book/list.gsp` which will only be applied to the `list` action within the `BookController`. If you have both the above mentioned layouts in place the layout specific to the action will take precedence when the list action is executed. If a layout may not be located using any of those conventions, the convention of last resort is to look for the application default layout which is `grails-app/views/layouts/application.gsp`. The name of the application default layout may be changed by defining a property in `grails-app/conf/application.groovy` as follows:
    grails.sitemesh.default.layout = 'myLayoutName'
With that property in place, the application default layout will be `grails-app/views/layouts/myLayoutName.gsp`. #### Inline Layouts Grails' also supports Sitemesh’s concept of inline layouts with the applyLayout tag. This can be used to apply a layout to a template, URL or arbitrary section of content. This lets you even further modularize your view structure by "decorating" your template includes. Some examples of usage can be seen below:
    <g:applyLayout name="myLayout" template="bookTemplate" collection="${books}" />

    <g:applyLayout name="myLayout" url="http://www.google.com" />

    <g:applyLayout name="myLayout">
    The content to apply a layout to
    </g:applyLayout>
#### Server-Side Includes While the applyLayout tag is useful for applying layouts to external content, if you simply want to include external content in the current page you use the include tag:
    <g:include controller="book" action="list" />
You can even combine the include tag and the applyLayout tag for added flexibility:
    <g:applyLayout name="myLayout">
       <g:include controller="book" action="list" />
    </g:applyLayout>
Finally, you can also call the include tag from a controller or tag library as a method:
    def content = include(controller:"book", action:"list")
The resulting content will be provided via the return value of the include tag. ## 8.2.5 Static Resources Grails 3 integrates with the Asset Pipeline plugin to provide sophisticated static asset management. This plugin is installed by default in new Grails applications. The basic way to include a link to a static asset in your application is to use the resource tag. This simple approach creates a URI pointing to the file. However modern applications with dependencies on multiple JavaScript and CSS libraries and frameworks (as well as dependencies on multiple Grails plugins) require something more powerful. The issues that the Asset-Pipeline plugin tackles are: Reduced Dependence - The plugin has compression, minification, and cache-digests built in. Easy Debugging - Makes for easy debugging by keeping files separate in development mode. Asset Bundling using require directives. Web application performance tuning is difficult. The need for a standard way to expose static assets in plugins and applications. The need for extensible processing to make languages like LESS or Coffee first class citizens. The asset-pipeline allows you to define your javascript or css requirements right at the top of the file and they get compiled on War creation. Take a look at the documentation for the asset-pipeline to get started. If you do not want to use the Asset-Pipeline plugin, you can serve the static assets from directories `src/main/resources/public` or `src/main/webapp`, but the latter one only gets included in WAR packaging but not in JAR packaging. ## 8.2.6 Sitemesh Content Blocks Although it is useful to decorate an entire page sometimes you may find the need to decorate independent sections of your site. To do this you can use content blocks. To get started, partition the page to be decorated using the `<content>` tag:
    <content tag="navbar">
    ... draw the navbar here...
    </content>

    <content tag="header">
    ... draw the header here...
    </content>

    <content tag="footer">
    ... draw the footer here...
    </content>

    <content tag="body">
    ... draw the body here...
    </content>
Then within the layout you can reference these components and apply individual layouts to each:
    <html>
        <body>
            <div id="header">
                <g:applyLayout name="headerLayout">
                    <g:pageProperty name="page.header" />
                </g:applyLayout>
            </div>
            <div id="nav">
                <g:applyLayout name="navLayout">
                    <g:pageProperty name="page.navbar" />
                </g:applyLayout>
            </div>
            <div id="body">
                <g:applyLayout name="bodyLayout">
                    <g:pageProperty name="page.body" />
                </g:applyLayout>
            </div>
            <div id="footer">
                <g:applyLayout name="footerLayout">
                    <g:pageProperty name="page.footer" />
                </g:applyLayout>
            </div>
        </body>
    </html>
## 8.2.7 Making Changes to a Deployed Application One of the main issues with deploying a Grails application (or typically any servlet-based one) is that any change to the views requires that you redeploy your whole application. If all you want to do is fix a typo on a page, or change an image link, it can seem like a lot of unnecessary work. For such simple requirements, Grails does have a solution: the `grails.gsp.view.dir` configuration setting. How does this work? The first step is to decide where the GSP files should go. Let’s say we want to keep them unpacked in a `/var/www/grails/my-app` directory. We add these two lines to `grails-app/conf/application.groovy` :
    grails.gsp.enable.reload = true
    grails.gsp.view.dir = "/var/www/grails/my-app/"
The first line tells Grails that modified GSP files should be reloaded at runtime. If you don’t have this setting, you can make as many changes as you like but they won’t be reflected in the running application until you restart. The second line tells Grails where to load the views and layouts from.
| The trailing slash on the `grails.gsp.view.dir` value is important! Without it, Grails will look for views in the parent directory.
Setting "grails.gsp.view.dir" is optional. If it’s not specified, you can update files directly to the application server’s deployed war directory. Depending on the application server, these files might get overwritten when the server is restarted. Most application servers support "exploded war deployment" which is recommended in this case. With those settings in place, all you need to do is copy the views from your web application to the external directory. On a Unix-like system, this would look something like this:
    mkdir -p /var/www/grails/my-app/grails-app/views
    cp -R grails-app/views/* /var/www/grails/my-app/grails-app/views
The key point here is that you must retain the view directory structure, including the `grails-app/views` bit. So you end up with the path `/var/www/grails/my-app/grails-app/views/…​` . One thing to bear in mind with this technique is that every time you modify a GSP, it uses up permgen space. So at some point you will eventually hit "out of permgen space" errors unless you restart the server. So this technique is not recommended for frequent or large changes to the views. There are also some System properties to control GSP reloading:
Name | Description | Default
--- | --- | ---
grails.gsp.enable.reload | alternative system property for enabling the GSP reload mode without changing `application.groovy` | grails.gsp.reload.interval
interval between checking the lastmodified time of the gsp source file | unit is milliseconds | 5000
grails.gsp.reload.granularity | the number of milliseconds leeway to give before deciding a file is out of date. this is needed because different roundings usually cause a 1000ms difference in lastmodified times | 1000
GSP reloading is supported for precompiled GSPs since Grails 1.3.5 . ## 8.2.8 GSP Debugging #### Viewing the generated source code Adding "?showSource=true" or "&showSource=true" to the url shows the generated Groovy source code for the view instead of rendering it. It won’t show the source code of included templates. This only works in development mode The saving of all generated source code can be activated by setting the property "grails.views.gsp.keepgenerateddir" (in `application.groovy`) . It must point to a directory that exists and is writable. During "grails war" gsp pre-compilation, the generated source code is stored in grails.project.work.dir/gspcompile (usually in ~/.grails/(grails_version)/projects/(project name)/gspcompile). #### Debugging GSP code with a debugger See Debugging GSP in STS #### Viewing information about templates used to render a single url GSP templates are reused in large web applications by using the `g:render` taglib. Several small templates can be used to render a single page. It might be hard to find out what GSP template actually renders the html seen in the result. The debug templates -feature adds html comments to the output. The comments contain debug information about gsp templates used to render the page. Usage is simple: append "?debugTemplates" or "&debugTemplates" to the url and view the source of the result in your browser. "debugTemplates" is restricted to development mode. It won’t work in production. Here is an example of comments added by debugTemplates :
    <!-- GSP #2 START template: /home/.../views/_carousel.gsp
         precompiled: false lastmodified: ... -->
    .
    .
    .
    <!-- GSP #2 END template: /home/.../views/_carousel.gsp
         rendering time: 115 ms -->
Each comment block has a unique id so that you can find the start & end of each template call. ## 8.3 Tag Libraries Like Java Server Pages (JSP), GSP supports the concept of custom tag libraries. Unlike JSP, Grails' tag library mechanism is simple, elegant and completely reloadable at runtime. Quite simply, to create a tag library create a Groovy class that ends with the convention `TagLib` and place it within the `grails-app/taglib` directory:
    class SimpleTagLib {

    }
Now to create a tag create a Closure property that takes two arguments: the tag attributes and the body content:
    class SimpleTagLib {
        def simple = { attrs, body ->

        }
    }
The `attrs` argument is a Map of the attributes of the tag, whilst the `body` argument is a Closure that returns the body content when invoked:
    class SimpleTagLib {
        def emoticon = { attrs, body ->
           out << body() << (attrs.happy == 'true' ? " :-)" : " :-(")
        }
    }
As demonstrated above there is an implicit `out` variable that refers to the output `Writer` which you can use to append content to the response. Then you can reference the tag inside your GSP; no imports are necessary:
    <g:emoticon happy="true">Hi John</g:emoticon>
| To help IDEs like Spring Tool Suite (STS) and others autocomplete tag attributes, you should add Javadoc comments to your tag closures with `@attr` descriptions. Since taglibs use Groovy code it can be difficult to reliably detect all usable attributes.
For example:
    class SimpleTagLib {

        /**
         * Renders the body with an emoticon.
         *
         * @attr happy whether to show a happy emoticon ('true') or
         * a sad emoticon ('false')
         */
        def emoticon = { attrs, body ->
           out << body() << (attrs.happy == 'true' ? " :-)" : " :-(")
        }
    }
and any mandatory attributes should include the REQUIRED keyword, e.g.
    class SimpleTagLib {

        /**
         * Creates a new password field.
         *
         * @attr name REQUIRED the field name
         * @attr value the field value
         */
        def passwordField = { attrs ->
            attrs.type = "password"
            attrs.tagName = "passwordField"
            fieldImpl(out, attrs)
        }
    }
## 8.3.1 Variables and Scopes Within the scope of a tag library there are a number of pre-defined variables including: `actionName` - The currently executing action name `controllerName` - The currently executing controller name `flash` - The flash object `grailsApplication` - The GrailsApplication instance `out` - The response writer for writing to the output stream `pageScope` - A reference to the pageScope object used for GSP rendering (i.e. the binding) `params` - The params object for retrieving request parameters `pluginContextPath` - The context path to the plugin that contains the tag library `request` - The HttpServletRequest instance `response` - The HttpServletResponse instance `servletContext` - The ServletContext instance `session` - The HttpSession instance ## 8.3.2 Simple Tags As demonstrated in the previous example it is easy to write simple tags that have no body and just output content. Another example is a `dateFormat` style tag:
    def dateFormat = { attrs, body ->
        out << new java.text.SimpleDateFormat(attrs.format).format(attrs.date)
    }
The above uses Java’s `SimpleDateFormat` class to format a date and then write it to the response. The tag can then be used within a GSP as follows:
    <g:dateFormat format="dd-MM-yyyy" date="${new Date()}" />
With simple tags sometimes you need to write HTML mark-up to the response. One approach would be to embed the content directly:
    def formatBook = { attrs, body ->
        out << "<div id=\"${attrs.book.id}\">"
        out << "Title : ${attrs.book.title}"
        out << "</div>"
    }
Although this approach may be tempting it is not very clean. A better approach would be to reuse the render tag:
    def formatBook = { attrs, body ->
        out << render(template: "bookTemplate", model: [book: attrs.book])
    }
And then have a separate GSP template that does the actual rendering. ## 8.3.3 Logical Tags You can also create logical tags where the body of the tag is only output once a set of conditions have been met. An example of this may be a set of security tags:
    def isAdmin = { attrs, body ->
        def user = attrs.user
        if (user && checkUserPrivs(user)) {
            out << body()
        }
    }
The tag above checks if the user is an administrator and only outputs the body content if he/she has the correct set of access privileges:
    <g:isAdmin user="${myUser}">
        // some restricted content
    </g:isAdmin>
## 8.3.4 Iterative Tags Iterative tags are easy too, since you can invoke the body multiple times:
    def repeat = { attrs, body ->
        attrs.times?.toInteger()?.times { num ->
            out << body(num)
        }
    }
In this example we check for a `times` attribute and if it exists convert it to a number, then use Groovy’s `times` method to iterate the specified number of times:
    <g:repeat times="3">
    <p>Repeat this 3 times! Current repeat = ${it}</p>
    </g:repeat>
Notice how in this example we use the implicit `it` variable to refer to the current number. This works because when we invoked the body we passed in the current value inside the iteration:
    out << body(num)
That value is then passed as the default variable `it` to the tag. However, if you have nested tags this can lead to conflicts, so you should instead name the variables that the body uses:
    def repeat = { attrs, body ->
        def var = attrs.var ?: "num"
        attrs.times?.toInteger()?.times { num ->
            out << body((var):num)
        }
    }
Here we check if there is a `var` attribute and if there is use that as the name to pass into the body invocation on this line:
    out << body((var):num)
| Take notice to the usage of the parenthesis around the variable name. If you omit these Groovy assumes you are using a String key and not referring to the variable itself.
Now we can change the usage of the tag as follows:
    <g:repeat times="3" var="j">
    <p>Repeat this 3 times! Current repeat = ${j}</p>
    </g:repeat>
Notice how we use the `var` attribute to define the name of the variable `j` and then we are able to reference that variable within the body of the tag. ## 8.3.5 Tag Namespaces By default, tags are added to the default Grails namespace and are used with the `g:` prefix in GSP pages. However, you can specify a different namespace by adding a static property to your `TagLib` class:
    class SimpleTagLib {
        static namespace = "my"

        def example = { attrs ->
            ...
        }
    }
Here we have specified a `namespace` of `my` and hence the tags in this tag lib must then be referenced from GSP pages like this:
    <my:example name="..." />
where the prefix is the same as the value of the static `namespace` property. Namespaces are particularly useful for plugins. Tags within namespaces can be invoked as methods using the namespace as a prefix to the method call:
    out << my.example(name:"foo")
This works from GSP, controllers or tag libraries ## 8.3.6 Using JSP Tag Libraries In addition to the simplified tag library mechanism provided by GSP, you can also use JSP tags from GSP. To do so simply declare the JSP to use with the `taglib` directive:
    <%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
Besides this you have to configure Grails to scan for the JSP tld files. This is configured with the `grails.gsp.tldScanPattern` setting. It accepts a comma separated String value. Spring’s PathMatchingResourcePatternResolver is used to resolve the patterns. For example you could scan for all available tld files by adding this to `application.groovy`:
    grails.gsp.tldScanPattern='classpath*:/META-INF/*.tld,/WEB-INF/tld/*.tld'
JSTL standard library is no more added as a dependency by default. In case you are using JSTL, you should also add these dependencies to `build.gradle`:
    runtime 'javax.servlet:jstl:1.1.2'
            runtime 'taglibs:standard:1.1.2'
Then you can use JSP tags like any other tag:
    <fmt:formatNumber value="${10}" pattern=".00"/>
With the added bonus that you can invoke JSP tags like methods:
    ${fmt.formatNumber(value:10, pattern:".00")}
## 8.3.7 Tag return value A taglib can be used in a GSP as an ordinary tag or it might be used as a function in other taglibs or GSP expressions. Internally Grails intercepts calls to taglib closures. The "out" that is available in a taglib is mapped to a `java.io.Writer` implementation that writes to a buffer that "captures" the output of the taglib call. This buffer is the return value of a tag library call when it’s used as a function. If the tag is listed in the library’s static `returnObjectForTags` array, then its return value will written to the output when it’s used as a normal tag. The return value of the tag lib closure will be returned as-is if it’s used as a function in GSP expressions or other taglibs. If the tag is not included in the returnObjectForTags array, then its return value will be discarded. Using "out" to write output in returnObjectForTags is not supported. Example:
    class ObjectReturningTagLib {
        static namespace = "cms"
        static returnObjectForTags = ['content']

        def content = { attrs, body ->
            CmsContent.findByCode(attrs.code)?.content
        }
    }
Given this example cms.content(code:'something') call in another taglib or GSP expression would return the value "CmsContent.content" directly to the caller without wrapping the return value in a buffer. It might be worth doing so also because of performance optimization reasons. There is no need to wrap the tag return value in an output buffer in such cases. ## 8.4 URL Mappings Throughout the documentation so far the convention used for URLs has been the default of `/controller/action/id`. However, this convention is not hard wired into Grails and is in fact controlled by a URL Mappings class located at `grails-app/controllers/mypackage/UrlMappings.groovy`. The `UrlMappings` class contains a single property called `mappings` that has been assigned a block of code:
    package mypackage

    class UrlMappings {
        static mappings = {
        }
    }
## 8.4.1 Mapping to Controllers and Actions To create a simple mapping simply use a relative URL as the method name and specify named parameters for the controller and action to map to:
    "/product"(controller: "product", action: "list")
In this case we’ve mapped the URL `/product` to the `list` action of the `ProductController`. Omit the action definition to map to the default action of the controller:
    "/product"(controller: "product")
An alternative syntax is to assign the controller and action to use within a block passed to the method:
    "/product" {
        controller = "product"
        action = "list"
    }
Which syntax you use is largely dependent on personal preference. If you have mappings that all fall under a particular path you can group mappings with the `group` method:
    group "/product", {
        "/apple"(controller:"product", id:"apple")
        "/htc"(controller:"product", id:"htc")
    }
You can also create nested `group` url mappings:
    group "/store", {
        group "/product", {
            "/$id"(controller:"product")
        }
    }
To rewrite one URI onto another explicit URI (rather than a controller/action pair) do something like this:
    "/hello"(uri: "/hello.dispatch")
Rewriting specific URIs is often useful when integrating with other frameworks. ## 8.4.2 Mapping to REST resources Since Grails 2.3, it possible to create RESTful URL mappings that map onto controllers by convention. The syntax to do so is as follows:
    "/books"(resources:'book')
You define a base URI and the name of the controller to map to using the `resources` parameter. The above mapping will result in the following URLs:
HTTP Method | URI | Grails Action
--- | --- | ---
GET | /books | index
GET | /books/create | create
POST | /books | save
GET | /books/${id} | show
GET | /books/${id}/edit | edit
PUT | /books/${id} | update
DELETE | /books/${id} | delete
If you are not sure which mapping will be generated for your case just run the command `url-mappings-report` in your grails console. It will give you a really neat report for all the url mappings. If you wish to include or exclude any of the generated URL mappings you can do so with the `includes` or `excludes` parameter, which accepts the name of the Grails action to include or exclude:
    "/books"(resources:'book', excludes:['delete', 'update'])

    or

    "/books"(resources:'book', includes:['index', 'show'])
#### Explicit REST Mappings As of Grails 3.1, if you prefer not to rely on a `resources` mapping to define your mappings then you can prefix any URL mapping with the HTTP method name (in lower case) to indicate the HTTP method it applies to. The following URL mapping:
    "/books"(resources:'book')
Is equivalent to:
    get "/books"(controller:"book", action:"index")
    get "/books/create"(controller:"book", action:"create")
    post "/books"(controller:"book", action:"save")
    get "/books/$id"(controller:"book", action:"show")
    get "/books/$id/edit"(controller:"book", action:"edit")
    put "/books/$id"(controller:"book", action:"update")
    delete "/books/$id"(controller:"book", action:"delete")
Notice how the HTTP method name is prefixed prior to each URL mapping definition. #### Single resources A single resource is a resource for which there is only one (possibly per user) in the system. You can create a single resource using the `resource` parameter (as opposed to `resources`):
    "/book"(resource:'book')
This results in the following URL mappings:
HTTP Method | URI | Grails Action
--- | --- | ---
GET | /book/create | create
POST | /book | save
GET | /book | show
GET | /book/edit | edit
PUT | /book | update
DELETE | /book | delete
The main difference is that the id is not included in the URL mapping. #### Nested Resources You can nest resource mappings to generate child resources. For example:
    "/books"(resources:'book') {
      "/authors"(resources:"author")
    }
The above will result in the following URL mappings:
HTTP Method | URL | Grails Action
--- | --- | ---
GET | /books/${bookId}/authors | index
GET | /books/${bookId}/authors/create | create
POST | /books/${bookId}/authors | save
GET | /books/${bookId}/authors/${id} | show
GET | /books/${bookId}/authors/edit/${id} | edit
PUT | /books/${bookId}/authors/${id} | update
DELETE | /books/${bookId}/authors/${id} | delete
You can also nest regular URL mappings within a resource mapping:
    "/books"(resources: "book") {
        "/publisher"(controller:"publisher")
    }
This will result in the following URL being available:
HTTP Method | URL | Grails Action
--- | --- | ---
GET | /books/1/publisher | index
To map a URI directly below a resource then use a collection:
    "/books"(resources: "book") {
        collection {
            "/publisher"(controller:"publisher")
        }
    }
This will result in the following URL being available (without the ID):
HTTP Method | URL | Grails Action
--- | --- | ---
GET | /books/publisher | index
#### Linking to RESTful Mappings You can link to any URL mapping created with the `g:link` tag provided by Grails simply by referencing the controller and action to link to:
    <g:link controller="book" action="index">My Link</g:link>
As a convenience you can also pass a domain instance to the `resource` attribute of the `link` tag:
    <g:link resource="${book}">My Link</g:link>
This will automatically produce the correct link (in this case "/books/1" for an id of "1"). The case of nested resources is a little different as they typically required two identifiers (the id of the resource and the one it is nested within). For example given the nested resources:
    "/books"(resources:'book') {
      "/authors"(resources:"author")
    }
If you wished to link to the `show` action of the `author` controller, you would write:
    // Results in /books/1/authors/2
    <g:link controller="author" action="show" method="GET" params="[bookId:1]" id="2">The Author</g:link>
However, to make this more concise there is a `resource` attribute to the link tag which can be used instead:
    // Results in /books/1/authors/2
    <g:link resource="book/author" action="show" bookId="1" id="2">My Link</g:link>
The resource attribute accepts a path to the resource separated by a slash (in this case "book/author"). The attributes of the tag can be used to specify the necessary `bookId` parameter. ## 8.4.3 Redirects In URL Mappings Since Grails 2.3, it is possible to define URL mappings which specify a redirect. When a URL mapping specifies a redirect, any time that mapping matches an incoming request, a redirect is initiated with information provided by the mapping. When a URL mapping specifies a redirect the mapping must either supply a String representing a URI to redirect to or must provide a Map representing the target of the redirect. That Map is structured just like the Map that may be passed as an argument to the `redirect` method in a controller.
    "/viewBooks"(redirect: '/books/list')
    "/viewAuthors"(redirect: [controller: 'author', action: 'list'])
    "/viewPublishers"(redirect: [controller: 'publisher', action: 'list', permanent: true])
Request parameters that were part of the original request will be included in the redirect. ## 8.4.4 Embedded Variables #### Simple Variables The previous section demonstrated how to map simple URLs with concrete "tokens". In URL mapping speak tokens are the sequence of characters between each slash, '/'. A concrete token is one which is well defined such as as `/product`. However, in many circumstances you don’t know what the value of a particular token will be until runtime. In this case you can use variable placeholders within the URL for example:
    static mappings = {
      "/product/$id"(controller: "product")
    }
In this case by embedding a $id variable as the second token Grails will automatically map the second token into a parameter (available via the params object) called `id`. For example given the URL `/product/MacBook`, the following code will render "MacBook" to the response:
    class ProductController {
         def index() { render params.id }
    }
You can of course construct more complex examples of mappings. For example the traditional blog URL format could be mapped as follows:
    static mappings = {
       "/$blog/$year/$month/$day/$id"(controller: "blog", action: "show")
    }
The above mapping would let you do things like:
    /graemerocher/2007/01/10/my_funky_blog_entry
The individual tokens in the URL would again be mapped into the params object with values available for `year`, `month`, `day`, `id` and so on. #### Dynamic Controller and Action Names Variables can also be used to dynamically construct the controller and action name. In fact the default Grails URL mappings use this technique:
    static mappings = {
        "/$controller/$action?/$id?"()
    }
Here the name of the controller, action and id are implicitly obtained from the variables `controller`, `action` and `id` embedded within the URL. You can also resolve the controller name and action name to execute dynamically using a closure:
    static mappings = {
        "/$controller" {
            action = { params.goHere }
        }
    }
#### Optional Variables Another characteristic of the default mapping is the ability to append a ? at the end of a variable to make it an optional token. In a further example this technique could be applied to the blog URL mapping to have more flexible linking:
    static mappings = {
        "/$blog/$year?/$month?/$day?/$id?"(controller:"blog", action:"show")
    }
With this mapping all of these URLs would match with only the relevant parameters being populated in the params object:
    /graemerocher/2007/01/10/my_funky_blog_entry
    /graemerocher/2007/01/10
    /graemerocher/2007/01
    /graemerocher/2007
    /graemerocher
#### Optional File Extensions If you wish to capture the extension of a particular path, then a special case mapping exists:
    "/$controller/$action?/$id?(.$format)?"()
By adding the `(.$format)?` mapping you can access the file extension using the `response.format` property in a controller:
    def index() {
        render "extension is ${response.format}"
    }
#### Arbitrary Variables You can also pass arbitrary parameters from the URL mapping into the controller by just setting them in the block passed to the mapping:
    "/holiday/win" {
         id = "Marrakech"
         year = 2007
    }
This variables will be available within the params object passed to the controller. #### Dynamically Resolved Variables The hard coded arbitrary variables are useful, but sometimes you need to calculate the name of the variable based on runtime factors. This is also possible by assigning a block to the variable name:
    "/holiday/win" {
         id = { params.id }
         isEligible = { session.user != null } // must be logged in
    }
In the above case the code within the blocks is resolved when the URL is actually matched and hence can be used in combination with all sorts of logic. ## 8.4.5 Mapping to Views You can resolve a URL to a view without a controller or action involved. For example to map the root URL `/` to a GSP at the location `grails-app/views/index.gsp` you could use:
    static mappings = {
        "/"(view: "/index")  // map the root URL
    }
Alternatively if you need a view that is specific to a given controller you could use:
    static mappings = {
       "/help"(controller: "site", view: "help") // to a view for a controller
    }
## 8.4.6 Mapping to Response Codes Grails also lets you map HTTP response codes to controllers, actions or views. Just use a method name that matches the response code you are interested in:
    static mappings = {
       "403"(controller: "errors", action: "forbidden")
       "404"(controller: "errors", action: "notFound")
       "500"(controller: "errors", action: "serverError")
    }
Or you can specify custom error pages:
    static mappings = {
       "403"(view: "/errors/forbidden")
       "404"(view: "/errors/notFound")
       "500"(view: "/errors/serverError")
    }
#### Declarative Error Handling In addition you can configure handlers for individual exceptions:
    static mappings = {
       "403"(view: "/errors/forbidden")
       "404"(view: "/errors/notFound")
       "500"(controller: "errors", action: "illegalArgument",
             exception: IllegalArgumentException)
       "500"(controller: "errors", action: "nullPointer",
             exception: NullPointerException)
       "500"(controller: "errors", action: "customException",
             exception: MyException)
       "500"(view: "/errors/serverError")
    }
With this configuration, an `IllegalArgumentException` will be handled by the `illegalArgument` action in `ErrorsController`, a `NullPointerException` will be handled by the `nullPointer` action, and a `MyException` will be handled by the `customException` action. Other exceptions will be handled by the catch-all rule and use the `/errors/serverError` view. You can access the exception from your custom error handing view or controller action using the request’s `exception` attribute like so:
    class ErrorController {
        def handleError() {
            def exception = request.exception
            // perform desired processing to handle the exception
        }
    }
| If your error-handling controller action throws an exception as well, you’ll end up with a `StackOverflowException`.
## 8.4.7 Mapping to HTTP methods URL mappings can also be configured to map based on the HTTP method (GET, POST, PUT or DELETE). This is very useful for RESTful APIs and for restricting mappings based on HTTP method. As an example the following mappings provide a RESTful API URL mappings for the `ProductController`:
    static mappings = {
       "/product/$id"(controller:"product", action: "update", method: "PUT")
    }
Note that if you specify a HTTP method other than GET in your URL mapping, you also have to specify it when creating the corresponding link by passing the `method` argument to `g:link` or `g:createLink` to get a link of the desired format. ## 8.4.8 Mapping Wildcards Grails' URL mappings mechanism also supports wildcard mappings. For example consider the following mapping:
    static mappings = {
        "/images/*.jpg"(controller: "image")
    }
This mapping will match all paths to images such as `/image/logo.jpg`. Of course you can achieve the same effect with a variable:
    static mappings = {
        "/images/$name.jpg"(controller: "image")
    }
However, you can also use double wildcards to match more than one level below:
    static mappings = {
        "/images/**.jpg"(controller: "image")
    }
In this cases the mapping will match `/image/logo.jpg` as well as `/image/other/logo.jpg`. Even better you can use a double wildcard variable:
    static mappings = {
        // will match /image/logo.jpg and /image/other/logo.jpg
        "/images/$name**.jpg"(controller: "image")
    }
In this case it will store the path matched by the wildcard inside a `name` parameter obtainable from the params object:
    def name = params.name
    println name // prints "logo" or "other/logo"
If you use wildcard URL mappings then you may want to exclude certain URIs from Grails' URL mapping process. To do this you can provide an `excludes` setting inside the `UrlMappings.groovy` class:
    class UrlMappings {
        static excludes = ["/images/*", "/css/*"]
        static mappings = {
            ...
        }
    }
In this case Grails won’t attempt to match any URIs that start with `/images` or `/css`. ## 8.4.9 Automatic Link Re-Writing Another great feature of URL mappings is that they automatically customize the behaviour of the link tag so that changing the mappings don’t require you to go and change all of your links. This is done through a URL re-writing technique that reverse engineers the links from the URL mappings. So given a mapping such as the blog one from an earlier section:
    static mappings = {
       "/$blog/$year?/$month?/$day?/$id?"(controller:"blog", action:"show")
    }
If you use the link tag as follows:
    <g:link controller="blog" action="show"
            params="[blog:'fred', year:2007]">
        My Blog
    </g:link>

    <g:link controller="blog" action="show"
            params="[blog:'fred', year:2007, month:10]">
        My Blog - October 2007 Posts
    </g:link>
Grails will automatically re-write the URL in the correct format:
    <a href="/fred/2007">My Blog</a>
    <a href="/fred/2007/10">My Blog - October 2007 Posts</a>
## 8.4.10 Applying Constraints URL Mappings also support Grails' unified validation constraints mechanism, which lets you further "constrain" how a URL is matched. For example, if we revisit the blog sample code from earlier, the mapping currently looks like this:
    static mappings = {
       "/$blog/$year?/$month?/$day?/$id?"(controller:"blog", action:"show")
    }
This allows URLs such as:
    /graemerocher/2007/01/10/my_funky_blog_entry
However, it would also allow:
    /graemerocher/not_a_year/not_a_month/not_a_day/my_funky_blog_entry
This is problematic as it forces you to do some clever parsing in the controller code. Luckily, URL Mappings can be constrained to further validate the URL tokens:
    "/$blog/$year?/$month?/$day?/$id?" {
         controller = "blog"
         action = "show"
         constraints {
              year(matches:/\\\d{4}/)
              month(matches:/\\\d{2}/)
              day(matches:/\\\d{2}/)
         }
    }
In this case the constraints ensure that the `year`, `month` and `day` parameters match a particular valid pattern thus relieving you of that burden later on. ## 8.4.11 Named URL Mappings URL Mappings also support named mappings, that is mappings which have a name associated with them. The name may be used to refer to a specific mapping when links are generated. The syntax for defining a named mapping is as follows:
    static mappings = {
       name <mapping name>: <url pattern> {
          // ...
       }
    }
For example:
    static mappings = {
        name personList: "/showPeople" {
            controller = 'person'
            action = 'list'
        }
        name accountDetails: "/details/$acctNumber" {
            controller = 'product'
            action = 'accountDetails'
        }
    }
The mapping may be referenced in a link tag in a GSP.
    <g:link mapping="personList">List People</g:link>
That would result in:
    <a href="/showPeople">List People</a>
Parameters may be specified using the params attribute.
    <g:link mapping="accountDetails" params="[acctNumber:'8675309']">
        Show Account
    </g:link>
That would result in:
    <a href="/details/8675309">Show Account</a>
Alternatively you may reference a named mapping using the link namespace.
    <link:personList>List People</link:personList>
That would result in:
    <a href="/showPeople">List People</a>
The link namespace approach allows parameters to be specified as attributes.
    <link:accountDetails acctNumber="8675309">Show Account</link:accountDetails>
That would result in:
    <a href="/details/8675309">Show Account</a>
To specify attributes that should be applied to the generated `href`, specify a `Map` value to the `attrs` attribute. These attributes will be applied directly to the href, not passed through to be used as request parameters.
    <link:accountDetails attrs="[class: 'fancy']" acctNumber="8675309">
        Show Account
    </link:accountDetails>
That would result in:
    <a href="/details/8675309" class="fancy">Show Account</a>
## 8.4.12 Customizing URL Formats The default URL Mapping mechanism supports camel case names in the URLs. The default URL for accessing an action named `addNumbers` in a controller named `MathHelperController` would be something like `/mathHelper/addNumbers`. Grails allows for the customization of this pattern and provides an implementation which replaces the camel case convention with a hyphenated convention that would support URLs like `/math-helper/add-numbers`. To enable hyphenated URLs assign a value of "hyphenated" to the `grails.web.url.converter` property in `grails-app/conf/application.groovy`. grails-app/conf/application.groovy
    grails.web.url.converter = 'hyphenated'
Arbitrary strategies may be plugged in by providing a class which implements the UrlConverter interface and adding an instance of that class to the Spring application context with the bean name of `grails.web.UrlConverter.BEAN_NAME`. If Grails finds a bean in the context with that name, it will be used as the default converter and there is no need to assign a value to the `grails.web.url.converter` config property. src/main/groovy/com/myapplication/MyUrlConverterImpl.groovy
    package com.myapplication

    class MyUrlConverterImpl implements grails.web.UrlConverter {

        String toUrlElement(String propertyOrClassName) {
            // return some representation of a property or class name that should be used in URLs...
        }
    }
grails-app/conf/spring/resources.groovy
    beans = {
        "${grails.web.UrlConverter.BEAN_NAME}"(com.myapplication.MyUrlConverterImpl)
    }
## 8.4.13 Namespaced Controllers If an application defines multiple controllers with the same name in different packages, the controllers must be defined in a namespace. The way to define a namespace for a controller is to define a static property named `namespace` in the controller and assign a String to the property that represents the namespace. grails-app/controllers/com/app/reporting/AdminController.groovy
    package com.app.reporting

    class AdminController {

        static namespace = 'reports'

        // ...
    }
grails-app/controllers/com/app/security/AdminController.groovy
    package com.app.security

    class AdminController {

        static namespace = 'users'

        // ...
    }
When defining url mappings which should be associated with a namespaced controller, the `namespace` variable needs to be part of the URL mapping. grails-app/controllers/UrlMappings.groovy
    class UrlMappings {

        static mappings = {
            '/userAdmin' {
                controller = 'admin'
                namespace = 'users'
            }

            '/reportAdmin' {
                controller = 'admin'
                namespace = 'reports'
            }

            "/$namespace/$controller/$action?"()
        }
    }
Reverse URL mappings also require that the `namespace` be specified.
    <g:link controller="admin" namespace="reports">Click For Report Admin</g:link>
    <g:link controller="admin" namespace="users">Click For User Admin</g:link>
When resolving a URL mapping (forward or reverse) to a namespaced controller, a mapping will only match if the `namespace` has been provided. If the application provides several controllers with the same name in different packages, at most 1 of them may be defined without a `namespace` property. If there are multiple controllers with the same name that do not define a `namespace` property, the framework will not know how to distinguish between them for forward or reverse mapping resolutions. It is allowed for an application to use a plugin which provides a controller with the same name as a controller provided by the application and for neither of the controllers to define a `namespace` property as long as the controllers are in separate packages. For example, an application may include a controller named `com.accounting.ReportingController` and the application may use a plugin which provides a controller named `com.humanresources.ReportingController`. The only issue with that is the URL mapping for the controller provided by the plugin needs to be explicit in specifying that the mapping applies to the `ReportingController` which is provided by the plugin. See the following example.
    static mappings = {
        "/accountingReports" {
            controller = "reporting"
        }
        "/humanResourceReports" {
            controller = "reporting"
            plugin = "humanResources"
        }
    }
With that mapping in place, a request to `/accountingReports` will be handled by the `ReportingController` which is defined in the application. A request to `/humanResourceReports` will be handled by the `ReportingController` which is provided by the `humanResources` plugin. There could be any number of `ReportingController` controllers provided by any number of plugins but no plugin may provide more than one `ReportingController` even if they are defined in separate packages. Assigning a value to the `plugin` variable in the mapping is only required if there are multiple controllers with the same name available at runtime provided by the application and/or plugins. If the `humanResources` plugin provides a `ReportingController` and there is no other `ReportingController` available at runtime, the following mapping would work.
    static mappings = {
        "/humanResourceReports" {
            controller = "reporting"
        }
    }
It is best practice to be explicit about the fact that the controller is being provided by a plugin. ## 8.5 CORS Spring Boot provides CORS support out of the box, but it is difficult to configure in a Grails application due to the way UrlMappings are used instead of annotations that define URLs. Starting with Grails 3.2.1, we have added a way to configure CORS that makes sense in a Grails application. Once enabled, the default setting is "wide open". application.yml
    grails:
        cors:
            enabled: true
That will produce a mapping to all urls `/**` with:
allowedOrigins | `['*']`
allowedMethods | `['*']`
allowedHeaders | `['*']`
exposedHeaders | `null`
maxAge | `1800`
allowCredentials | true
Some of these settings come directly from Spring Boot and can change in future versions. DEFAULT_ORIGINS DEFAULT_ALLOWED_HEADERS DEFAULT_MAX_AGE DEFAULT_ALLOW_CREDENTIALS All of those settings can be easily overridden. application.yml
    grails:
        cors:
            enabled: true
            allowedOrigins: [http://localhost:5000]
In the example above, the `allowedOrigins` setting will replace `[*]`. You can also configure different URLs. application.yml
    grails:
        cors:
            enabled: true
            allowedHeaders: [Content-Type]
            mappings:
                /api/**:
                    allowedOrigins: [http://localhost:5000]
                    //Other configurations not specified default to the global config
| Specifying at least one mapping will disable the creation of the global mapping (`/**`). If you wish to keep that setting, you should specify it along with your other mappings.
The settings above will produce a single mapping of `/api/**` with the following settings:
allowedOrigins | `['http://localhost:5000']`
allowedMethods | `['*']`
allowedHeaders | `['Content-Type']`
exposedHeaders | `null`
maxAge | `1800`
allowCredentials | true
If you don’t wish to override any of the default settings, but only want to specify URLs, you can do so like this example: application.yml
    grails:
        cors:
            enabled: true
            mappings:
                /api/**: {}
## 8.6 Interceptors Grails provides standalone Interceptors using the create-interceptor command:
    $ grails create-interceptor MyInterceptor
The above command will create an Interceptor in the `grails-app/controllers` directory with the following default contents:
    class MyInterceptor {

      boolean before() { true }

      boolean after() { true }

      void afterView() {
        // no-op
      }

    }
#### Interceptors vs Filters In versions of Grails prior to Grails 3.0, Grails supported the notion of filters. These are still supported for backwards compatibility but are considered deprecated. The new interceptors concept in Grails 3.0 is superior in a number of ways, most significantly interceptors can use Groovy’s `CompileStatic` annotation to optimize performance (something which is often critical as interceptors can be executed for every request.) ## 8.6.1 Defining Interceptors By default interceptors will match the controllers with the same name. For example if you have an interceptor called `BookInterceptor` then all requests to the actions of the `BookController` will trigger the interceptor. An `Interceptor` implements the Interceptor trait and provides 3 methods that can be used to intercept requests:
    /**
     * Executed before a matched action
     *
     * @return Whether the action should continue and execute
     */
    boolean before() { true }

    /**
     * Executed after the action executes but prior to view rendering
     *
     * @return True if view rendering should continue, false otherwise
     */
    boolean after() { true }

    /**
     * Executed after view rendering completes
     */
    void afterView() {}
As described above the `before` method is executed prior to an action and can cancel the execution of the action by returning `false`. The `after` method is executed after an action executes and can halt view rendering if it returns false. The `after` method can also modify the view or model using the `view` and `model` properties respectively:
    boolean after() {
      model.foo = "bar" // add a new model attribute called 'foo'
      view = 'alternate' // render a different view called 'alternate'
      true
    }
The `afterView` method is executed after view rendering completes. If an exception occurs, the exception is available using the `throwable` property of the Interceptor trait. ## 8.6.2 Matching Requests with Inteceptors As mention in the previous section, by default an interceptor will match only requests to the associated controller by convention. However you can configure the interceptor to match any request using the `match` or `matchAll` methods defined in the Interceptor API. The matching methods return a Matcher instance which can be used to configure how the interceptor matches the request. For example the following interceptor will match all requests except those to the `login` controller:
    class AuthInterceptor {
      AuthInterceptor() {
        matchAll()
        .excludes(controller:"login")
      }

      boolean before() {
        // perform authentication
      }
    }
You can also perform matching using named argument:
    class LoggingInterceptor {
      LoggingInterceptor() {
        match(controller:"book", action:"show") // using strings
        match(controller: ~/(author|publisher)/) // using regex
      }

      boolean before() {
        ...
      }
    }
You can use any number of matchers defined in your interceptor. They will be executed in the order in which they have been defined. For example the above interceptor will match for all of the following: when the `show` action of `BookController` is called when `AuthorController` or `PublisherController` is called All named arguments except for `uri` accept either a String or a Regex expression. The `uri` argument supports a String path that is compatible with Spring’s AntPathMatcher. The possible named arguments are: `namespace` - The namespace of the controller `controller` - The name of the controller `action` - The name of the action `method` - The HTTP method `uri` - The URI of the request. If this argument is used then all other arguments will be ignored and only this will be used. ## 8.6.3 Ordering Interceptor Execution Interceptors can be ordered by defining an `order` property that defines a priority. For example:
    class AuthInterceptor {

      int order = HIGHEST_PRECEDENCE

      ...
    }
The default value of the `order` property is 0. The values `HIGHEST_PRECEDENCE` and `LOWEST_PRECEDENCE` can be used to define filters that should should run first or last respectively. Note that if you write an interceptor that is to be used by others it is better increment or decrement the `HIGHEST_PRECEDENCE` and `LOWEST_PRECEDENCE` to allow other interceptors to be inserted before or after the interceptor you are authoring:
    int order = HIGHEST_PRECEDENCE + 50

    // or

    int order = LOWEST_PRECEDENCE - 50
To find out the computed order of interceptors you can add a debug logger to `logback.groovy` as follows:
    logger 'grails.artefact.Interceptor', DEBUG, ['STDOUT'], false
You can override any interceptors default order by using bean override configuration in `grails-app/conf/application.yml`:
    beans:
      authInterceptor:
        order: 50
Or in `grails-app/conf/application.groovy`:
    beans {
      authInterceptor {
        order = 50
      }
    }
Thus giving you complete control over interceptor execution order. ## 8.7 Content Negotiation Grails has built in support for Content negotiation using either the HTTP `Accept` header, an explicit format request parameter or the extension of a mapped URI. #### Configuring Mime Types Before you can start dealing with content negotiation you need to tell Grails what content types you wish to support. By default Grails comes configured with a number of different content types within `grails-app/conf/application.yml` using the `grails.mime.types` setting:
    grails:
        mime:
            types:
                all: '*/*'
                atom: application/atom+xml
                css: text/css
                csv: text/csv
                form: application/x-www-form-urlencoded
                html:
                  - text/html
                  - application/xhtml+xml
                js: text/javascript
                json:
                  - application/json
                  - text/json
                multipartForm: multipart/form-data
                rss: application/rss+xml
                text: text/plain
                hal:
                  - application/hal+json
                  - application/hal+xml
                xml:
                  - text/xml
                  - application/xml
The setting can also be done in `grails-app/conf/application.groovy` as shown below:
    grails.mime.types = [ // the first one is the default format
        all:           '*/*', // 'all' maps to '*' or the first available format in withFormat
        atom:          'application/atom+xml',
        css:           'text/css',
        csv:           'text/csv',
        form:          'application/x-www-form-urlencoded',
        html:          ['text/html','application/xhtml+xml'],
        js:            'text/javascript',
        json:          ['application/json', 'text/json'],
        multipartForm: 'multipart/form-data',
        rss:           'application/rss+xml',
        text:          'text/plain',
        hal:           ['application/hal+json','application/hal+xml'],
        xml:           ['text/xml', 'application/xml']
    ]
The above bit of configuration allows Grails to detect to format of a request containing either the 'text/xml' or 'application/xml' media types as simply 'xml'. You can add your own types by simply adding new entries into the map. The first one is the default format. #### Content Negotiation using the format Request Parameter Let’s say a controller action can return a resource in a variety of formats: HTML, XML, and JSON. What format will the client get? The easiest and most reliable way for the client to control this is through a `format` URL parameter. So if you, as a browser or some other client, want a resource as XML, you can use a URL like this:
    http://my.domain.org/books?format=xml
The result of this on the server side is a `format` property on the `response` object with the value `xml` . You can also define this parameter in the URL Mappings definition:
    "/book/list"(controller:"book", action:"list") {
        format = "xml"
    }
You could code your controller action to return XML based on this property, but you can also make use of the controller-specific `withFormat()` method:
    import grails.converters.JSON
    import grails.converters.XML

    class BookController {

        def list() {
            def books = Book.list()

            withFormat {
                html bookList: books
                json { render books as JSON }
                xml { render books as XML }
                '*' { render books as JSON }
            }
        }
    }
In this example, Grails will only execute the block inside `withFormat()` that matches the requested content type. So if the preferred format is `html` then Grails will execute the `html()` call only. Each 'block' can either be a map model for the corresponding view (as we are doing for 'html' in the above example) or a closure. The closure can contain any standard action code, for example it can return a model or render content directly. When no format matches explicitly, a `*` (wildcard) block can be used to handle all other formats. There is a special format, "all", that is handled differently from the explicit formats. If "all" is specified (normally this happens through the Accept header - see below), then the first block of `withFormat()` is executed when there isn’t a `*` (wildcard) block available. You should not add an explicit "all" block. In this example, a format of "all" will trigger the `html` handler (`html` is the first block and there is no `*` block).
    withFormat {
        html bookList: books
        json { render books as JSON }
        xml { render books as XML }
    }
| When using withFormat make sure it is the last call in your controller action as the return value of the `withFormat` method is used by the action to dictate what happens next.
#### Using the Accept header Every incoming HTTP request has a special Accept header that defines what media types (or mime types) a client can "accept". In older browsers this is typically:
    */*
which simply means anything. However, newer browsers send more interesting values such as this one sent by Firefox:
    text/xml, application/xml, application/xhtml+xml, text/html;q=0.9, \
        text/plain;q=0.8, image/png, */*;q=0.5
This particular accept header is unhelpful because it indicates that XML is the preferred response format whereas the user is really expecting HTML. That’s why Grails ignores the accept header by default for browsers. However, non-browser clients are typically more specific in their requirements and can send accept headers such as
    application/json
As mentioned the default configuration in Grails is to ignore the accept header for browsers. This is done by the configuration setting `grails.mime.disable.accept.header.userAgents`, which is configured to detect the major rendering engines and ignore their ACCEPT headers. This allows Grails' content negotiation to continue to work for non-browser clients:
    grails.mime.disable.accept.header.userAgents = ['Gecko', 'WebKit', 'Presto', 'Trident']
For example, if it sees the accept header above ('application/json') it will set `format` to `json` as you’d expect. And of course this works with the `withFormat()` method in just the same way as when the `format` URL parameter is set (although the URL parameter takes precedence). An accept header of '*/\*' results in a value of `all` for the `format` property.
| If the accept header is used but contains no registered content types, Grails will assume a broken browser is making the request and will set the HTML format - note that this is different from how the other content negotiation modes work as those would activate the "all" format!
#### Request format vs. Response format As of Grails 2.0, there is a separate notion of the request format and the response format. The request format is dictated by the `CONTENT_TYPE` header and is typically used to detect if the incoming request can be parsed into XML or JSON, whilst the response format uses the file extension, format parameter or ACCEPT header to attempt to deliver an appropriate response to the client. The withFormat available on controllers deals specifically with the response format. If you wish to add logic that deals with the request format then you can do so using a separate `withFormat` method available on the request:
    request.withFormat {
        xml {
            // read XML
        }
        json {
            // read JSON
        }
    }
#### Content Negotiation with URI Extensions Grails also supports content negotiation using URI extensions. For example given the following URI:
    /book/list.xml
This works as a result of the default URL Mapping definition which is:
    "/$controller/$action?/$id?(.$format)?"{
Note the inclusion of the `format` variable in the path. If you do not wish to use content negotiation via the file extension then simply remove this part of the URL mapping:
    "/$controller/$action?/$id?"{
#### Testing Content Negotiation To test content negotiation in a unit or integration test (see the section on Testing) you can either manipulate the incoming request headers:
    void testJavascriptOutput() {
        def controller = new TestController()
        controller.request.addHeader "Accept",
                  "text/javascript, text/html, application/xml, text/xml, */*"

        controller.testAction()
        assertEquals "alert('hello')", controller.response.contentAsString
    }
Or you can set the format parameter to achieve a similar effect:
    void testJavascriptOutput() {
        def controller = new TestController()
        controller.params.format = 'js'

        controller.testAction()
        assertEquals "alert('hello')", controller.response.contentAsString
    }
| Quick Reference (hide)