all-IT

Within the MVC design pattern takes the controller requests (requests) and generates the opposite responses (responses) and forwards the data (model) to the view. The following should you know about Grails controller:

1. Naming convention
2. Creating controllers
3. Creating actions (Actions)
4. Query parameters from the request and the session
5. Take advantage of flash scopes
6. Processing of the data (models)
7. Generate the response (response)
8. Forwarding and chaining of actions (Actions)

Creating controllers / naming convention

Grails controllers are in the grails-app\controller . They end up in the file name always managed to controllers such as controller users. Groovy. The first part of the name is part of the URI (eg managed user), via which the Actions are addressed.
Controllers can also use the command grails create-controller can be created.

Creating actions (Actions)

Actions (actions) are defined as properties of a controller and mapped to a URI. Thus the action of the controller's list for the user on the managed URI managedUser/list mentioned

 class ManagedUserController { def list = { if(!params.max)params.max = 10 [ managedUserList: ManagedUser.list( params ) ] } } 

If only the controller in the URI addressed, then the "Default Action" is executed. This index can be set on the property.

 def index = { redirect(action:list,params:params) } 

Query parameters from the request and the session

Each controller has a number of predefined properties that can be supplied dynamically at run time with values. These include:

• nuri actio
• controllerUri
• actionName
• controllerName
• flash
• grailsApplication
• grailsAttributes
• log
• params
• session
• request
• response
• ServletContext

If one wants to access the parameters from the request or the session, one accesses the properties params or session to:

 def findBy = params["findBy"] def loggedUser = session["logged_user"] 

Take advantage of flash scopes

With Flash it is possible a scope attribute for the next request (request) to provide. This functionality is used to inform the user about the status of actions, such that the deletion was successful.

 flash.message = "ManagedUser ${params.id} deleted." 

Processing of the data (models)

The parameters in Web applications are passed as strings, so it is necessary to map them to the data objects (models). In Grails, this is done very simply by assigning the parameters to the characteristic properties of each model.

 managedUser.properties = params 

Models are implemented in Grails as maps. Forward the simplest way a model Object to the view is, the instance returned.

 def managedUser = new ManagedUser() managedUser.properties = params return ['managedUser':managedUser] 

Generate the response (response)

To render a specific view or pieces of code from the controller out of Grails is the function render made ​​available.

 render(view:'edit',model:[managedUser:managedUser]) 

To render a specific view or pieces of code from the controller out of Grails is the function render made ​​available.

Forwarding and chaining of actions (Actions)

Forwarding to another action takes place via the redirect . The optional parameters Forwarding Web can thereby be added. In other action controller is referenced by a string.

 // einfache Weiterleitung redirect(action:list) // Weiterleitung, mit Parametern redirect(action:show,id:managedUser.id) // Weiterleitung auf einen anderen Controller redirect(action:"/address/list") 

Actions can also be chained, of course, is given to the model objects that are added during the concatenation, and other actions of the chain. This is useful, for example in the implementation of wizards.

 class WizzardsController { def firstStep = { chain(action:secondStep,model:["step1":new Object()]) } def secondStep = { chain(action:thirdStep,model:["step2":new Object()]) }; def thirdStep= { return ["step3":new Object()]) }; } 

Update: the latest version of the paper I have to improve maintainability as part of a small tutorial to Grails, and outsourced direct links in the right sidebar.

Within the MVC design pattern takes the controller requests (requests) and generates the opposite responses (responses) and forwards the data (model) to the view. The following should you know about Grails controller: naming convention creating controllers creating actions (actions) query parameters from the request and the session utility of flash scopes processing of the data (models) generate the response (response) forwarding and chaining of actions (Actions ) Creating controllers / naming convention for Grails controllers are in grails-app \ controllers. They end up in the file name always as ManagedUserController.groovy controller. The first part of the name is part of the URI (eg managed user), via which the Actions are addressed. Controllers can create-controller can be created with the command grails. Creating actions (actions) actions (actions) are defined as properties of a controller and mapped to a URI. Thus, the action list {[Managed userlist: ManagedUser.list (params)] def list = {if params.max = 10 (params.max!)}} Of the controller for the user managed addressed via the URI managed user / list class managed UserController is only the controller in the URI addressed, then the "Default Action" is executed. This index can be set on the property. def index = {redirect (action: list, params: params)} query parameters from the request and the session Each controller has a number of predefined properties that can be supplied dynamically at run time with values. These include: actio nuri controllerUri actionName controllerName flash grailsApplication grailsAttributes log params session request response ServletContext you want now access the parameters from the request or the session so we picks params to the properties or session to: def findBy = params ["findBy"] loggedUser def = session ["logged_user"] benefits of Flash Scopes Scope With Flash it is possible for an attribute of the next request (request) to provide. This functionality is used to inform the user about the status of actions, such that the deletion was successful. flash.message = "$ {user managed params.id} deleted." Processing of the data (model) parameters in the Web applications are passed as strings, so it is necessary to map them to the data objects (models). In Grails, this is done very simply by assigning the parameters to the characteristic properties of each model. managedUser.properties = params models are implemented in Grails as maps. Forward the simplest way a model Object to the view is, the instance returned. def managed user = new managed user () managedUser.properties = params return ['managed user': managed user] generate the response (Response) To render a specific view or pieces of code from the controller out is, of Grails, the feature set render available. render (view: 'edit', model: [user managed: Managed user]) To render a specific view or pieces of code from the controller out of Grails will render the feature set available. Forwarding and chaining of actions (Actions) The forwarding to another action takes place on the redirect function. The optional parameters Forwarding Web can thereby be added. In other action controller is referenced by a string. / / Simple forwarding redirect (action: list) / / redirect redirect with parameters (action: show, id: managedUser.id) / / redirect redirect to another controller (action: '/ address / list') actions can also are concatenated, is given to the model objects that are added during the concatenation, and other actions of the chain. This is useful, for example in the implementation of wizards. chain ([new Object () "step1"] action: second step, model)} def second step = {(action: third step, model: ["step2": new Object ()]) class WizzardsController {def first step = {chain ;} def third step = {return ["step3": new Object ()])};} Update: the latest version of the article, I have to improve maintainability as part of a small Tutorial outsourced to Grails, and direct links in the right sidebar.

gklinkmann written by \ \ tags: Grails