Grails(6)Guide Book Chapter 7 The Web Layer

Grails(6)Guide Book Chapter 7 The Web Layer
7 The Web Layer
7.1 Controllers
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.

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 the URIs within the controller name URI.

7.1.1 Understanding Controllers and Actions
Creating a controller
There are 2 commands create-controller and generate-controller
>grails create-controller book
To create a file /grails-app/controllers/myapp/BookController.groovy

Creating Actions
A controller can have multiple public action methods, each one maps to a URI
class BookController {
     def list(){
          //do controller logic, get a model
          return model
     }
}
This method will map to the URI /book/list

Public Methods as Actions

The Default Action
The default action of the Controller, for example, if /book is hit, the action that is called when the default URI is requested is dictated by the following rules.
1. If there is only one action, it is the default
2. If you have an action named index, it is the default
3. Alternatively you can set it explicitly with the defaultAction property.
static defaultAction = "list"

7.1.2 Controllers and Scopes
Available Scopes
Scopes are hash-like objects where you can store variables.

servletContext - application scope, instance of SevletContent

session - an instance of HttpSession

request - an instance of HttpServletRequest

params - mutable map of incoming request query string or POST parameters

flash -

Accessing Scopes
class BookController {
     def find(){
          def findBy = params["findBy"]
          def appContext = request["foo"]
          def loggedUser = session["logged_user"]
     }
}

Or we can visit the parameters like this
def find(){
     def findBy = params.findBy
     def appContext = request.foo
     def loggedUser = session.logged_user
}

Using Flash Scope
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 really useful for setting a message directly before redirecting.

def delete(){
     def b = Book.get(params.id)
     if(!b){
          flash.message = "User not found for id ${params.id}"
          redirect(action:list)
     }    
     …snip...
}

Scoped Controllers
There are several scopes supported by grails:
prototype (default) - A new controller will be created for each request.
session - One controller is created for the scope of a user session
singleton - Only one instance of the controller ever exists

To configure that in controller
static scope = "singleton"

To configure that for all the controllers in Config.groovy
grails.controllers.defaultScope = "singleton"

7.1.3 Models and Views
Returning the Model
A model is a Map that the view uses when rendering.

def show(){
     [book: Book.get(params.id)]
}

class BookController {
     List books
     List authors
     def list(){
          books = Book.list()
          authors = Author.list()
     }
}

These are for default settings, we can use ModelAndView directly.

def index(){
     def favoriteBooks = …
     return new ModelAndView("/book/list", [bookList: favoriteBooks])
}

One thing to bear in mind is that certain variable names can not be used
attributes, application

Selecting the View
For the show Action,
class BookController {
     def show(){
          [book: Book.get(params.id)]
     }
}
Grails will look for a view at the location grails-app/views/book/show.gsp

If we want to control that, we need to render to a different view, we use render method:
def show(){
     def map = [book: Book.get(params.id)]
     render(view: "display", model:map) //grails-app/views/book/display.gsp
}

def show(){
     def map = [book: Book.get(params.id)]
     render(view: "/shared/display", model:map) // grails-app/views/shared/display.gsp
}

Rendering a Response
Render snippets of text or codes to the response directly from the controller.

render "Hello Sillycat!"

render(text:"<xml>Some Xml</xml>", contentType: "text/xml", encoding: "UTF-8")

References:
http://grails.org/doc/latest/guide/index.html
http://grails.org/doc/latest/guide/theWebLayer.html