Groovy & Grails

Migration to Grails 3

noreply@blogger.com (EduSanz) — Wed, 24 May 2017 10:01:00 +0000

After many years with no posting I dare creating my first entry in English. A few months ago I was playing around Grails 3 migration from a Grails 2.3.11 project and these were my steps to finish the process:

Create a new project via Intellij with Grails 3.2.9 and Java 8

grails create-app education

When executing create-app command, by default the "web" profile is used.

Place all files from Grails 2 project to Grails 3 project respecting packages

Old Location	New Location	Description
`grails-app/conf/BuildConfig.groovy`	`build.gradle`	Build time configuration is now defined in a Gradle build file
`grails-app/conf/Config.groovy`	`grails-app/conf/application.groovy`	Renamed for consistency with Spring Boot
`grails-app/conf/UrlMappings.groovy`	`grails-app/controllers/UrlMappings.groovy`	Moved since grails-app/conf is not a source directory anymore
`grails-app/conf/BootStrap.groovy`	`grails-app/init/BootStrap.groovy`	Moved since grails-app/conf is not a source directory anymore
`scripts`	`src/main/scripts`	Moved for consistency with Gradle
`src/groovy`	`src/main/groovy`	Moved for consistency with Gradle
`src/java`	`src/main/groovy` (yes, groovy!)	Moved for consistency with Gradle
`test/unit`	`src/test/groovy`	Moved for consistency with Gradle
`test/integration`	`src/integration-test/groovy`	Moved for consistency with Gradle
`web-app`	`src/main/webapp` or `src/main/resources/`	Moved for consistency with Gradle
`\*GrailsPlugin.groovy`	`src/main/groovy`	The plugin descriptor moved to a source directory

src/main/resources/public is recommended as src/main/webapp only gets included in WAR packaging but not in JAR packaging.

It is recommended to merge Java source files from src/java into src/main/groovy. You can create a src/main/java directory if you want to and it will be used but it is generally better to combine the folders. (The Groovy and Java sources compile together.)

Our BuildConfig.groovy in Grails 2 project will be our build.gradle in Grails 3 project

buildscript {
   repositories {
     mavenLocal()
     maven { url "https://repo.grails.org/grails/core" }
   }
   dependencies {
     classpath "org.grails:grails-gradle-plugin:$grailsVersion"
     classpath "com.bertramlabs.plugins:asset-pipeline-gradle:2.14.1"
     classpath "org.grails.plugins:hibernate5:${gormVersion-".RELEASE"}"
     classpath "org.grails.plugins:database-migration:3.0.0"
   }
}

version "1.1"
group "education"

apply plugin:"eclipse"
apply plugin:"idea"
apply plugin:"war"
apply plugin:"org.grails.grails-web"
apply plugin:"org.grails.grails-gsp"
apply plugin:"asset-pipeline"

repositories {
   mavenLocal()
   maven { url "https://repo.grails.org/grails/core" }
}

dependencies {
   compile "org.springframework.boot:spring-boot-starter-logging"
   compile "org.springframework.boot:spring-boot-autoconfigure"
   compile "org.grails:grails-core"
   compile "org.springframework.boot:spring-boot-starter-actuator"
   compile "org.springframework.boot:spring-boot-starter-tomcat"
   compile "org.grails:grails-dependencies"
   compile "org.grails:grails-web-boot"
   compile "org.grails.plugins:cache"
   compile "org.grails.plugins:scaffolding"
   compile "org.grails.plugins:hibernate5"
   compile "org.hibernate:hibernate-core:5.1.3.Final"
   compile "org.hibernate:hibernate-ehcache:5.1.3.Final"
   console "org.grails:grails-console"
   profile "org.grails.profiles:web"
   runtime "com.bertramlabs.plugins:asset-pipeline-grails:2.14.1"
   runtime "com.h2database:h2"
   testCompile "org.grails:grails-plugin-testing"
   testCompile "org.grails.plugins:geb"
   testRuntime "org.seleniumhq.selenium:selenium-htmlunit-driver:2.47.1"
   testRuntime "net.sourceforge.htmlunit:htmlunit:2.18"

   // MySQL 5 Driver
   runtime "mysql:mysql-connector-java:5.1.36"

   // Ajax Tags
   compile "org.grails.plugins:ajax-tags:1.0.1.BUILD-SNAPSHOT"

   // Joda Time
   compile "joda-time:joda-time:2.9.6"

   // Rest Client Builder
   compile "org.grails:grails-datastore-rest-client"

   // Database Migration
   compile "org.grails.plugins:database-migration:3.0.0"
   compile "org.liquibase:liquibase-core:3.5.3"

   // Spring Security Core
   compile "org.grails.plugins:spring-security-core:3.1.1"

   // Spring Security ACL
   compile "org.grails.plugins:spring-security-acl:3.1.0"

   // Spring Security Rest
   //compile "org.grails.plugins:spring-security-rest:2.0.0.M2"

   // Email
   compile "org.grails.plugins:mail:2.0.0.RC6"

   // Export
   compile "org.grails.plugins:export:2.0.0"

   // Google Visualization
   compile "org.grails.plugins:grails-google-visualization:2.2"

   // CKEditor
   compile "org.grails.plugins:ckeditor:4.5.9.0"
}

bootRun {
   jvmArgs('-Dspring.output.ansi.enabled=always')
   addResources = true
}

sourceSets {
   main {
     resources {
       srcDir 'grails-app/migrations'
     }
   }
}

assets {
   minifyJs = true
   minifyCss = true
}

There will be plugins already created for Grails 3 distribution but others don't. For these ones we must look for a workaround:

Convert them by ourselves to Grails 3
Get rid of them and implement them by code

Our Datasource.groovy in Grails 2 project will be in our application.yml in Grails 3 project

---
grails:
    profile: web
    codegen:
        defaultPackage: net.rdcstudios.core
    spring:
        transactionManagement:
            proxies: false
    gorm:
        # Whether to autowire entities. 
        # Disabled by default for performance reasons.
        autowire: true # Changed to true to be able to inject services into domain classes         
        reactor:
            # Whether to translate GORM events into Reactor events
            # Disabled by default for performance reasons
            events: false
info:
    app:
        name: '@info.app.name@'
        version: '@info.app.version@'
        grailsVersion: '@info.app.grailsVersion@'
spring:
    main:
        banner-mode: "off"
    groovy:
        template:
            check-template-location: false

# Spring Actuator Endpoints are Disabled by Default
endpoints:
    enabled: false
    jmx:
        enabled: true

---
grails:
    mime:
        disable:
            accept:
                header:
                    userAgents:
                        - Gecko
                        - WebKit
                        - Presto
                        - Trident
        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
            pdf: application/pdf
            rss: application/rss+xml
            text: text/plain
            hal:
              - application/hal+json
              - application/hal+xml
            xml:
              - text/xml
              - application/xml
    urlmapping:
        cache:
            maxsize: 1000
    controllers:
        defaultScope: singleton
    converters:
        encoding: UTF-8
    views:
        default:
            codec: html
        gsp:
            encoding: UTF-8
            htmlcodec: xml
            codecs:
                expression: html
                scriptlets: html
                taglib: none
                staticparts: none
endpoints:
    jmx:
        unique-names: true

---
hibernate:
    cache:
        queries: false
        use_second_level_cache: true
        use_query_cache: false
        region.factory_class: org.hibernate.cache.ehcache.SingletonEhCacheRegionFactory

dataSource:
    pooled: true
    jmxExport: true
    driverClassName: com.mysql.jdbc.Driver
    dialect: org.hibernate.dialect.MySQL5InnoDBDialect
    # dialect: net.rdcstudios.mysql.dialect.MySQLUTF8MB4InnoDBDialect
    username: core
    password: core

environments:
    development:
            dataSource:
                dbCreate: none
    internaldemo:
            dataSource:
                dbCreate: none
    demo:
            dataSource:
                dbCreate: none
    client:
            dataSource:
                dbCreate: none
    test:
            dataSource:
                dbCreate: create-drop
    uat:
            dataSource:
                dbCreate: none
    production:
        dataSource:
            dbCreate: none
            properties:
                jmxEnabled: true
                initialSize: 5
                maxActive: 50
                minIdle: 5
                maxIdle: 25
                maxWait: 10000
                maxAge: 600000
                timeBetweenEvictionRunsMillis: 5000
                minEvictableIdleTimeMillis: 60000
                validationQuery: SELECT 1
                validationQueryTimeout: 3
                validationInterval: 15000
                testOnBorrow: true
                testWhileIdle: true
                testOnReturn: false
                jdbcInterceptors: ConnectionState
                defaultTransactionIsolation: 2 # TRANSACTION_READ_COMMITTED

Our log4j which is inside Config.groovy in Grails 2 project will be our logback.groovy in Grails 3 project

import grails.util.BuildSettings
import grails.util.Environment
import org.springframework.boot.logging.logback.ColorConverter
import org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter

conversionRule 'clr', ColorConverter
conversionRule 'wex', WhitespaceThrowableProxyConverter

// See http://logback.qos.ch/manual/groovy.html for details on configuration
//statusListener(OnConsoleStatusListener)

def appenderList = ["ROLLING"]
def LOG_DIR = "."
def consoleAppender = true

def targetDir = BuildSettings.TARGET_DIR

if (targetDir != null) {
    appenderList.add("CONSOLE")
    LOG_DIR = "/var/log/education/${Environment.currentEnvironment.name}"
} else {
    LOG_DIR = "/var/log/education/${Environment.currentEnvironment.name}"
    consoleAppender = false
}

if (consoleAppender) {
    appender("CONSOLE", ConsoleAppender) {
        encoder(PatternLayoutEncoder) {
            pattern = "%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"
        }
    }
}

appender("ROLLING", RollingFileAppender) {
    encoder(PatternLayoutEncoder) {
        Pattern = "%d %level %thread %mdc %logger - %m%n"
    }
    rollingPolicy(SizeAndTimeBasedRollingPolicy) {
        MaxFileSize = "5MB"
        FileNamePattern = "${LOG_DIR}/log.%d{yyyy-MM-dd}.%i"
    }
}

logger 'grails.app.services', INFO, appenderList
logger 'grails.app.controllers', INFO, appenderList
logger 'net.rdcstudios.core', INFO, appenderList

//root(INFO, appenderList)

// Spring Security
//logger 'grails.plugin.springsecurity.web.filter.DebugFilter', INFO, ['STDOUT']

// Hibernate Logs
//logger 'org.hibernate.SQL', DEBUG, ['STDOUT']
//logger 'org.hibernate.type.descriptor.sql.BasicBinder', TRACE, ['STDOUT']

In Grails 3.x all internal APIs can be found in the org.grails package and public facing APIs in the grails package. The org.codehaus.groovy.grails package no longer exists. All package declaration in sources should be modified for the new location of the respective classes. Examples

org.codehaus.groovy.grails.commons.GrailsApplication --> grails.core.GrailsApplication
org.codehaus.groovy.grails.core.io.ResourceLocator --> org.grails.core.io.ResourceLocator
org.codehaus.groovy.grails.web.mapping.LinkGenerator --> grails.web.mapping.LinkGenerator
org.codehaus.groovy.grails.web.binding.DataBindingUtils --> grails.web.databinding.DataBindingUtils
org.codehaus.groovy.grails.web.servlet.mvc.GrailsParameterMap --> grails.web.servlet.mvc.GrailsParameterMap

In unit or integration tests...
org.codehaus.groovy.grails.plugins.testing.GrailsMockMultipartFile --> org.grails.plugins.testing.GrailsMockMultipartFile

As of now Grails 3 uses Pipeline Plugin to work with assets instead of Resource Plugin in Grails 2. Therefore, we have to move all assets:
1. web-app/css --> grails-app/assets/stylesheets
2. web-app/images --> grails-app/assets/images
3. web-app/js --> grails-app/assets/javascripts

Create application.js as an index of all js files

// This is a manifest file that'll be compiled into application.js.
//
// Any JavaScript file within this directory can be referenced here using a relative path.
//
// You're free to add application-wide JavaScript to this file, but it's generally better
// to create separate JavaScript files as needed.
//
//= require jquery-2.2.0.min
//= require ie10-viewport-bug-workaround
//= require rs-plugin/js/jquery.themepunch.tools.min
//= require rs-plugin/js/jquery.themepunch.revolution.min
//= require custom
//= require menu/jquery.mmenu.min.all
//= require bootstrap/bootstrap.min
//= require bootstrap/moment
//= require bootstrap/bootstrap-datetimepicker
//= require bootstrap/bootstrap-switch.min
//= require bootstrap/bootstrap-wizard
//= require bootstrap/bootstrap-combobox
//= require fullcalendar/fullcalendar.min
//= require fullcalendar/lang-all
//= require_self

if (typeof jQuery !== 'undefined') {
    (function($) {
        $(document).ajaxStart(function() {
            $('#spinner').fadeIn();
        }).ajaxStop(function() {
            $('#spinner').fadeOut();
        });
    })(jQuery);
}

Create application.css as an index of all css files

/*
* This is a manifest file that'll be compiled into application.css, which will include all the files
* listed below.
*
* Any CSS file within this directory can be referenced here using a relative path.
*
* You're free to add application-wide styles to this file and they'll appear at the top of the
* compiled file, but it's generally better to create a new file per style scope.
*
*= encoding UTF-8
*= require bootstrap/bootstrap-responsive
*= require pure-drawer
*= require style
*= require font-awesome/css/font-awesome.min
*= require menu/jquery.mmenu.all
*= require rs-plugin/css/extralayers
*= require rs-plugin/css/settings
*= require bootstrap/bootstrap-datetimepicker
*= require bootstrap/bootstrap-switch.min
*= require bootstrap/bootstrap-wizard
*= require bootstrap/bootstrap-combobox
*= require fullcalendar/fullcalendar.min
*= require_self
*/

Add application.js and application.css to main.gsp

<asset:stylesheet src="application.css"/>
<asset:javascript src="application.js"/>

Change all <img> and <g:img> to <asset:image src="" />
Change all <script>, <g:script> and <r:script> to <asset:script type="text/javascript">
I had to add this line just before </body> in the outer main template to make javascript code embedded in views or templates work

 <asset:deferredScripts/>

Change all ${resource()} methods to ${assetPath(src: ''}
Change all <link> related to css to <asset:link>
Change all path in templates from ../ to /

<g:render template="../layouts/bottomBar"/>
to
<g:render template="/layouts/bottomBar"/>

Remove all grailsApplication beans from Controllers as Grails 3 imports them automatically

def grailsApplication

Install new plugin called ajax-tags as Grails 3 removes all taglibs related to remote and to keep using them we will need to have it installed

// Ajax Tags plugin
compile "org.grails.plugins:ajax-tags:1.0.1.BUILD-SNAPSHOT"

Change all prefixes about respond method convention

Example	Argument Type	Calculated Model Variable
`respond Book.list()`	`java.util.List`	`bookList`
`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`

// course/_grid
<g:each in="${courseInstanceList}" status="i" var="courseInstance">
to
<g:each in="${courseList}" status="i" var="courseInstance">

Change all references to config

grailsApplication.config.net.rdcstudios.pagination.size
to
grailsApplication.config.getProperty('net.rdcstudios.pagination.size')

Change all references to grailsResourceLocator

grailsResourceLocator.findResourceForURI()
to
assetResourceLocator.findAssetForURI()

Change all references to domainClass

instance.domainClass.propertyName
to
grails.util.GrailsNameUtils.getPropertyName(instance.class)

To make external config properties work, we will need to modify the class Application.groovy

import grails.boot.GrailsApp
import grails.boot.config.GrailsAutoConfiguration
import org.springframework.context.EnvironmentAware
import org.springframework.core.env.Environment
import org.springframework.core.env.MapPropertySource

class Application extends GrailsAutoConfiguration implements EnvironmentAware {
    static void main(String[] args) {
        GrailsApp.run(Application, args)
    }

    @Override
    void setEnvironment(Environment environment) {
        def file = new File("/etc/core/core-${grails.util.Environment.getCurrent().name}-config.properties")
        if(file.exists()) {
            def config = new ConfigSlurper().parse(file.text)
            environment.propertySources.addFirst(new MapPropertySource(grails.util.Environment.getCurrent().name, config))
        }
    }
}

Plus to escape all values from external config properties we will need to add quotes "..." as YAML Parser launches :, . and / values as yml values

dataSource.url = jdbc:mysql://localhost/rdcstudios_dev
to
dataSource.url = "jdbc:mysql://localhost/rdcstudios_dev"

Move all global constraints from Config.groovy to application.groovy

// Shared constraints
grails.gorm.default.constraints = {
    codeConstraint(blank: false, nullable: true, size: 1..4, unique: 'country')
}

Don't forget to change empty constraints from () to [:]

static constraints = {
  name nullable: true, blank: false
  mySimpleProperty()                  // <- A field that has no constraints. This syntax is not supported in Grails 3.
  anotherProperty unique: true
}
to
static constraints = {
  name nullable: true, blank: false
  mySimpleProperty [:]                // <- Empty map argument instead of ()
  anotherProperty unique: true
}

All services injected into domain classes don't work. Why? In Grails 2 projects they were working property. The reason is that in Grails 3 there is a property called grails.gorm.autowired in application.yml set to false by default. This property is disabled by default for performance reasons.

Further info
http://stackoverflow.com/questions/43059313/grails-3-2-8-dependency-injection-in-domain-classes
https://gist.github.com/erichelgeson/be2f9f62ab63d989f2ec962ae7001f21

Every time app throws an exception is displayed the following:

Caused by: groovy.lang.MissingMethodException: No signature of method: ch.qos.logback.classic.Logger.error() is applicable for argument types: (org.springframework.dao.DataIntegrityViolationException)

Why? This is because the default logger that is added to Grails artefacts is now an instance of SLF4J, and not JCL. Unlike JCL, none of the SLF4J logging methods take a single Object argument. Therefore we need to do some changes:

catch (DataIntegrityViolationException dive) {
    log.error(dive)
    flash.error = message(code: 'default.not.deleted.message', args: ["User", id], default: "User could not be deleted")
    redirect(action: 'show', id: userInstance?.id)
}

to

catch (DataIntegrityViolationException dive) {
    log.error(dive.toString())
    flash.error = message(code: 'default.not.deleted.message', args: ["User", id], default: "User could not be deleted")
    redirect(action: 'show', id: userInstance?.id)
}

Further info
https://github.com/grails/grails-core/issues/9971
http://docs.grails.org/3.2.8/guide/single.html#upgrading31x (See Slf4j now default section)

UNIT TESTS

No changes

INTEGRATION TESTS

I changed extends IntegrationSpec to Specification from all tests to keep rules as per Grails 3 doc.

I added @Integration and @Rollback annotation at class level.

@Integration
@Rollback
class ActivityServiceIntegrationSpec extends Specification {
...
}

I had to change some load methods to get method as in Grails 3 data binding is more stricted.

def setupData() {
    def user = User.load(1)
    def course = new Course(shortName: 'Test shortname', summary: 'Test summary', owner: user).save() -> LazyInitializationException
}

to 

def setupData() {
    def user = User.get(1)
    def course = new Course(shortName: 'Test shortname', summary: 'Test summary', owner: user).save() -> Works fine
}

As per Grails 3 it's not allowed to save any instance in setup method when @Rollback annotation is not added as app will throw HibernateException: No Session found. To solve this it's recommended to added @Rollback annotation and separate setup method (for non transactional operations) from setupData method (for transactional operations). Don't forget calling setupData method from given block

def setup() {
    alfrescoService.metaClass.uploadFile = { Object resource, MultipartFile resourceFile -> "1" }
    alfrescoService.metaClass.deleteFileByNodeRef = { String nodeRef -> true }
}

def setupData() {
    def user = User.get(1)
    def course = new Course(shortName: 'Test shortname', summary: 'Test summary', owner: user).save()
}

...

void "test save method"() {
    given:
    setupData()
...
}

You have two possibilities:

Adding @Rollback you will have Hibernate session in setup method but once finished test there will be no rollback. If you split it in setup method for non transactional operations and setupData method for transactional operations, you will get rollback.
Without adding @Rollback you will get no Hibernate session in setup method.

DEPLOYMENT ON JENKINS

Below I'll paste changes I had to do in order to migrate deployment to Grails 3 on Jenkins job

	Grails 2 job	Grails 3 job
GENERATE WAR FILE	grails war education.war	grails war
RUN TESTS	grails test-app -coverage -xml	grails test-app
GENERATE DOC	grails doc	grails docs

PUBLISH COVERAGE REPORTS	target/test-reports/cobertura/coverage.xml	build/reports/cobertura/coverage.xml
DEPLOY TO TOMCAT	(no changes)	(no changes)
EMAIL	(no changes)	(no changes)

On Grails 2 war file was generated under project root path but on Grails 3 war file is generated in build / libs path so I had to add some lines to change path in build.gradle

// build.gradle file
war {
    archiveName "${baseName}.war" // This line for not adding version to war file name
    destinationDir project.projectDir // This line for setting path to project root path and not in build / libs
}

When deploying to Tomcat Jenkins threw this weird error

java.lang.NoSuchMethodError: org.apache.tomcat.util.res.StringManager.getManager(Ljava/lang/Class;)Lorg/apache/tomcat/util/res/StringManager;

After googling a little bit, I figured out it was due to use different Tomcat versions among embed Tomcat used by Spring Boot (version 8) and Tomcat used by Jenkins (version 7). As a workaround I changed this

// build.gradle file
compile "org.springframework.boot:spring-boot-starter-tomcat"
to
provided "org.springframework.boot:spring-boot-starter-tomcat"

Further info -> http://www.tothenew.com/blog/grails-3-and-deployment-to-tomcat-container/

To keep using coverage plugin as of now you can use Gradle plugin. For it the only thing you need to do is to add some lines to build.gradle file

buildscript {
  repositories {
    maven {
      url "https://plugins.gradle.org/m2/"
    }
  }
  dependencies {
    classpath "net.saliman:gradle-cobertura-plugin:2.4.0"
  }
}

apply plugin: "net.saliman.cobertura"

Further info -> https://plugins.gradle.org/plugin/net.saliman.cobertura

Also you will need to add cobertura after running tests

// Cobertura configuration
cobertura {
    coverageFormats = ['xml']

    coverageExcludes = ['.*Application.*',
                        '.*BootStrap.*',
                        '.*UrlMappings.*']
}

test.finalizedBy(project.tasks.cobertura)

INTELLIJ IDEA 2017

Execute all tests under JUnit not under Grails environment, otherwise Intellij IDEA will execute all tests.

Sometimes Intellij IDEA executes the test under production or development env instead of test env. To amend it you just have to add -Dgrails.env=production to command line from Run / Debug configuration

// Test log trace
The following profiles are active: production

Sometimes test throws an error related to Cannot add Domain Class [class ...] It is not a Domain!. To fix it,

grails clean

SPRING SECURITY CORE

Our Config.groovy in Grails 2 project contained all configuration properties related to plugin. As of now we will have to create a new file called application.groovy to put them in

// Added by the Spring Security Core plugin:
grails.plugin.springsecurity.debug.useFilter = true
grails.plugin.springsecurity.securityConfigType = "Annotation"
grails.plugin.springsecurity.logout.postOnly = false
grails.plugin.springsecurity.userLookup.userDomainClassName = "net.rdcstudios.core.security.User"
grails.plugin.springsecurity.userLookup.authorityJoinClassName = "net.rdcstudios.core.security.UserRole"
grails.plugin.springsecurity.authority.className = "net.rdcstudios.core.security.Role"
grails.plugin.springsecurity.adh.errorPage = null
grails.plugin.springsecurity.rejectIfNoRule = false
grails.plugin.springsecurity.fii.rejectPublicInvocations = false
grails.plugin.springsecurity.controllerAnnotations.staticRules = [
        [pattern: '/',                              access: ['permitAll']],
        [pattern: '/index',                         access: ['permitAll']],
        [pattern: '/index.gsp',                     access: ['permitAll']],
        [pattern: '/assets/**',                     access: ['permitAll']]
]

grails.plugin.springsecurity.useSecurityEventListener = true

Plus as we need to load an event related to plugin at runtime, we will create other file called runtime.groovy to define it

grails.plugin.springsecurity.onInteractiveAuthenticationSuccessEvent = { e, appCtx ->
    // Setting language by country and language fields from user domain class
    net.rdcstudios.core.security.User.withSession {
        net.rdcstudios.core.security.User user = net.rdcstudios.core.security.User.get(e.source.principal.id)
        def languageCode = user?.language?.code
        def countryCode = user?.country?.code
        def request = grails.plugin.springsecurity.web.SecurityRequestHolder.getRequest()
        if (languageCode && countryCode && request) {
            def locale = new Locale(languageCode, countryCode)
            if (locale) {
                org.grails.web.util.WebUtils.setSessionAttribute(request, org.springframework.web.servlet.i18n.SessionLocaleResolver.LOCALE_SESSION_ATTRIBUTE_NAME, locale)
            }
        }
    }
}

DATABASE MIGRATION

We could not install the new plugin for Grails 3 as we were working with Java 7 and app threw this error,

Unsupported major.minor version 52.0

INFO
J2SE 8 = 52
J2SE 7 = 51 
J2SE 6.0 = 50  
J2SE 5.0 = 49
JDK 1.4 = 48
JDK 1.3 = 47
JDK 1.2 = 46
JDK 1.1 = 45

When upgrading to Java 8 error disappeared.

EXPORT

I found an error to display export buttons. In Grails 2 projects you set it by adding Resource plugin tag

<r:require module="export"/>

But in Grails 3 projects we use Asset Pipeline so no way to reference resources belonging to plugins. I realized manifest file from Export plugin was called application.css (the same name as my app one). So as a workaround I had to rename my app manifest to app.css and leave application.css for Export plugin one.

<asset:stylesheet src="application.css"/>

I had to add this line just on views where it was used.

Plus I had to add the following line to build.gradle

assets {
    minifyJs = true
    minifyCss = true
    packagePlugin = true 
}

ASSET PIPELINE DOCUMENTATION
Plugins also can have the same "grails-app/assets" folder and their URL mapping is also the same. This means it can be more important to ensure unique naming / path mapping between plugins. This is also powerful in the sense that a plugin can add helper manifests to be used within your apps like jquery, bootstrap, font-awesome, and more.

Plugins should make sure that the assets { packagePlugin } property is set to true in their build.gradle file otherwise assets will not properly be packaged into the plugin for use by the application.

JASPER

I found no plugin compatible for Grails 3 so I had to do the following:
1. Import JasperController to my controllers folder
2. Import JasperService to my services folder
3. Import JasperTagLib to my taglib folder (changing all g.resource references to asset.assetPath)
4. Import all Jasper images to my assets/images folder
5. Import JasperExportFormat and JasperReportDef to src/main/groovy
Plus I had to add the following lines to build.gradle

// Jasper
compile "com.lowagie:itext:2.1.7"

compile("net.sf.jasperreports:jasperreports:5.6.1") {
    exclude group: 'antlr', module: 'antlr'
    exclude group: 'commons-logging', module: 'commons-logging'
    exclude group: 'org.apache.ant', module: 'ant'
    exclude group: 'mondrian', module: 'mondrian'
    exclude group: 'commons-javaflow', module: 'commons-javaflow'
    exclude group: 'net.sourceforge.barbecue', module: 'barbecue'
    exclude group: 'xml-apis', module: 'xml-apis'
    exclude group: 'xalan', module: 'xalan'
    exclude group: 'org.codehaus.groovy', module: 'groovy-all'
    exclude group: 'org.hibernate ', module: 'hibernate'
    exclude group: 'javax.xml.soap', module: 'saaj-api'
    exclude group: 'javax.servlet', module: 'servlet-api'
    exclude group: 'org.springframework', module: 'spring-core'
    exclude group: 'org.beanshell', module: 'bsh'
    exclude group: 'org.springframework', module: 'spring-beans'
    exclude group: 'jaxen', module: 'jaxen'
    exclude group: 'net.sf.barcode4j ', module: 'barcode4j'
    exclude group: 'org.apache.xmlgraphics', module: 'batik-svg-dom'
    exclude group: 'org.apache.xmlgraphics', module: 'batik-xml'
    exclude group: 'org.apache.xmlgraphics', module: 'batik-awt-util'
    exclude group: 'org.apache.xmlgraphics', module: 'batik-dom'
    exclude group: 'org.apache.xmlgraphics', module: 'batik-css'
    exclude group: 'org.apache.xmlgraphics', module: 'batik-gvt'
    exclude group: 'org.apache.xmlgraphics', module: 'batik-script'
    exclude group: 'org.apache.xmlgraphics', module: 'batik-svggen'
    exclude group: 'org.apache.xmlgraphics', module: 'batik-util'
    exclude group: 'org.apache.xmlgraphics', module: 'batik-bridge'
    exclude group: 'javax.persistence', module: 'persistence-api'
    exclude group: 'eclipse', module: 'jdtcore'
    exclude group: 'org.olap4j', module: 'olap4j'
}

compile "org.apache.poi:poi:3.10-FINAL"
compile "commons-io:commons-io:2.5"

BULK DATA IMPORTS

I found no plugin compatible for Grails 3 so I had to do the following:
1. Import ImportsController to my controllers folder
2. Import ImportsService to my services folder
3. Import DefaultImporter and ImportsException to src/main/groovy. Plus logging folder (with all Logguers) to src/main/groovy too.
Plus I had to copy all code from doWithSpring closure of BulkDataImportsGrailsPlugin in Grails 2 to doWithSpring closure of Application in Grails 3

class Application extends GrailsAutoConfiguration implements EnvironmentAware {
    static void main(String[] args) {
        GrailsApp.run(Application, args)
    }

    @Override
    void setEnvironment(Environment environment) {
        def file = new File("/etc/core/core-${grails.util.Environment.getCurrent().name}-config.properties")
        if(file.exists()) {
            def config = new ConfigSlurper().parse(file.text)
            environment.propertySources.addFirst(new MapPropertySource(grails.util.Environment.getCurrent().name, config))
        }
    }

    @Override
    Closure doWithSpring() {
        def loggingProvider = Holders.config.grails.plugins.imports.containsKey('loggingProvider') ? Holders.config.grails.plugins.imports.loggingProvider : 'default'

        def loggingProviderClass = null
        if (loggingProvider == 'mongo') {
            loggingProviderClass = MongoLogger
        } else if (loggingProvider == 'mem') {
            loggingProviderClass = InMemoryLogger
        } else if (loggingProvider == 'default') {
            loggingProviderClass = DefaultLogger
        } else {
            Class clazz = Class.forName(loggingProvider, true, Thread.currentThread().contextClassLoader)
            loggingProviderClass = clazz
        }

        def beans = {
            importsLogger(loggingProviderClass)
        }

        for(service in Holders.grailsApplication.serviceClasses) {
            if (service.hasProperty('imports')) {
                def entityName,
                    imports = service.getPropertyValue('imports')
                if (imports instanceof Class || imports instanceof String) {
                    entityName = GrailsNameUtils.getPropertyName(imports)
                }
                if (entityName) {
                    def found = Holders.grailsApplication.domainClasses?.find { GrailsNameUtils.getPropertyName(it.name) == entityName} != null
                    if (!found  && !service.hasMetaMethod('processRow', getArgs(5)) ) {
                        log.warn('\n    BulkDataImports: could not configure importer '+service.shortName+'... no domain class found and missing processRow method')
                    } else {
                        DefaultImporter.SERVICE_METHODS.each { k, v->
                            if (!service.hasMetaMethod(k, getArgs(v))) service.metaClass."${k}" = DefaultImporter."${k}"
                        }
                        def props = DefaultImporter.SERVICE_PROPERTIES.clone()
                        props.entityName = entityName
                        props.each {k, v->
                            if (!service.hasMetaMethod(k)) service.metaClass."${k}" = { ->  v }
                        }
                        ImporterService.IMPORT_CONFIGURATIONS[entityName] = GrailsNameUtils.getPropertyNameRepresentation(service.shortName)
                    }
                } else {
                    log.warn('\n    BulkDataImports: invalid imports configuration for '+service.shortName+' :'+imports)
                }
            }

        }

        ImporterService.IMPORT_CONFIGURATIONS.each { k, v-> log.info('\n    BulkDataImports:'+ k + ' imported by '+v) }

        return beans
    }

    private getArgs(ct) {
        (1..ct).collect { Object.class }.toArray()
    }
}

Hope this helps.

Buenas practicas en Servicios

noreply@blogger.com (EduSanz) — Fri, 01 Nov 2013 12:37:00 +0000

Muchas veces no hemos encontrado en la situacion de hacer un servicio que guarde las buenas practicas en Grails, en definitiva que guarde la transaccionalidad si ocurre una excepcion dentro de el.
A continuacion vamos a hacer una serie de reglas para seguir haciendo buen codigo Grails:
- Grails solo hace rollback cuando se lanza una unchecked (Runtime) exception. Es decir, la mejor manera de controlar esto es crearse una exception en tu proyecto que extienda de Runtime Exception.

class BaseException extends RuntimeException {
...
}

class HolidayService {
    static transactional = true
    def saveHoliday(holidayInstance){
        ...intermediate saves before saving holiday... 
        if (holidayInstance.save()) {
            return holidayInstance
        } else {
            throw new BaseException()
        }
    }
}

class HolidayController {    
    def holidayService
    def save(){
        def holidayInstance = new Holiday(params)
        try{
            def holidaySaved = holidayService.saveHoliday(holidayInstance)
            if(holidaySaved){
                flash.message = message(code: 'default.created.message', args: [message(code: 'holiday.label', default: 'Holiday'), holidayInstance?.id])
                redirect(action: "list")
            }else{
                flash.errors = message(code: 'default.not.created.message', args: [message(code: 'holiday.label', default: 'Holiday'), holidayInstance?.id])
                render(view: "create", model: [holidayInstance: holidayInstance])
            }
        }catch(BaseException e){
            flash.errors = e.getErrors()
            return render(view: "create", model: [holidayInstance: holidayInstance])
        }
    }
}

- Si os veis mejor con las anotaciones de Spring, podeis usar @Transactional(rollbackFor=Exception.class), siempre seteando antes tu servicio con static transactional = false. Si necesitas tambien que alguna exception NO haga el rollback puedes utilizar @Transactional(noRollbackFor=AnotherException.class)

class HolidayService {
    static transactional = false
    @Transactional(rollbackFor=BaseException.class,noRollbackFor=AnotherException.class)
    def saveHoliday(holidayInstance){
        ...intermediate saves before saving holiday... 
        if (holidayInstance.save()) {
            return holidayInstance
        } else {
            throw new BaseException()
        }
    }
}

- Si quereis por algun caso especial poner una checked exception en vuestro codigo del Servicio, teneis que hacer lo siguiente ya que Spring por defecto no hace el rollback para las checked exception.

class HolidayService {
    static transactional = false
    @Transactional(rollbackFor=Exception.class)
    def saveHoliday(holidayInstance){
        try{
          ...intermediate saves before saving holiday... 
          if (holidayInstance.save()) {
              return holidayInstance
          } else {
              return null
          }
       }catch(Exception e){
          e.printStackTrace()
       }
    }
}

- Por defecto la anotacion @Transactional tiene los siguientes parametros:
1) propagation -> por defecto es PROPAGATION_REQUIRED.
2) isolation -> por defecto es ISOLATION_DEFAULT.
3) readOnly -> por defecto es false, es decir read/write.
4) timeout

NOTA: Mucho cuidado si usais el plugin de Audit Logging ya que con este plugin la transaccionalidad en los servicios fallara si teneis en el Config esta linea.

      auditLog.transactional=true

La solucion es ponerlo a false.

Greach 2.0 - Groovy Spanish Conference

noreply@blogger.com (EduSanz) — Fri, 23 Nov 2012 09:29:00 +0000

Ya podeis comprar los tickets para la Greach o lo que es lo mismo la Groovy Spanish Conference que se celebrará en Madrid los días 25 y 26 de Enero del 2013.
Ya están confirmados algunos de los speakers que darán charlas como Graeme Rocher, Cedric Champeau, Andres Almiray, Sebastian Blanch, Corinne Krych, Russel Winder, Burt Beckwith, Marcin Erdmann...
El precio de los tickets varía ya que si lo comprais antes del 12 de Diciembre os costará 90 euros y sino el precio es de 120 euros.

Cambio de look en grails.org

noreply@blogger.com (EduSanz) — Fri, 23 Nov 2012 09:19:00 +0000

Ya podeis echarle un vistazo a la nueva web que nos han dejado los miembros de grails.org

Lo nuevo de Groovy 2.0

noreply@blogger.com (EduSanz) — Fri, 26 Oct 2012 15:26:00 +0000

Recordaremos primero lo que llevaba Groovy 1.8:

– Mejores DSLs con command chains
Una sintaxis mejorada en donde puedes eliminar puntos y paréntesis cuando encadenas varias llamadas a métodos.
– Mejoras en el rendimiento en tiempo de ejecución
– GPars está ya agrupado dentro de la distribución de Groovy
– Mejoras en las Closures
Anotaciones con closures como parámetros y método memoize() en closures para cachear un número de invocaciones.
– Soporte mejorado para la producción, construcción e impresión de JSON
– Nuevas transformaciones AST
4 loggers diferentes pueden ser inyectados (@Log, @Commons, @Log4j y @Slf4j) o posiblidad de implementar tu propia estrategia.

import groovy.util.logging.*

@Log
class Car{
  Car() {
     log.info 'Car constructed'
  }
}

def car = new Car()

@Field
@AutoClone y @AutoExternalizable
@Canonical
@toString: para crear un método toString() a tus tipos.

import groovy.transform.ToString

@ToString
class Person {
  String name
  int age
}

println new Person(name:'Edu', age:31)
// => Person(Edu,31)

@EqualsAndHashCode: para crear una implemetación por defecto de equals() y hashCode()

import groovy.transform.EqualsAndHashCode

@EqualsAndHashCode
class Coord {
  int x, y
}

def c1 = new Coord(x:20,y:10)
def c2 = new Coord(x:20,y:10)

assert c1==c2
assert c1.hashCode()==c2.hashCode()

@TupleConstructor: crea un clásico constructor con todas las propiedades

import groovy.transform.TupleConstructor

class Person {
  String name
  int age
}

def person = new Person(name:'Edu', age:31)
assert person.name=='Edu'
assert person.age==31

Controlar la ejecución del código para cuando el código entra en un bucle infinito o consume muchos recursos. Se hace con las 3 nuevas anotaciones: @ThreadInterrupt, @TimeInterrupt y @ConditionalInterrupt.

import groovy.transform.ThreadInterrupt

@ThreadInterrupt
void main(){
  while(true){
    if(Thread.currentThread().isInterrupted())
      throw new InterruptedException()
    //eat lots of CPU
  }
}

@InheritConstructor: para que se pinten todos los constructores heredados
@WithReadLock y @WithWriteLock
@ListenerList

Lo nuevo de Groovy 2.0 (NO INCLUIDO EN GRAILS 2):

– Alineaciones con JDK 7: Proyecto Coin (Binary literals, Underscore en literales y Multicatch) y InvokeDynamic ()

//Ejemplo de Multicatch
  try{
      ...
  }catch(IOException | NullPointerException e){
    //Un bloque para tratar 2 excepciones
  }

– Continuan las mejoras de rendimiento en tiempo de ejecución
– Modularidad (todos los jars de Groovy pesan 6 Mb, con un pequeño core (3 Mb) y un pequeño jar por feature)
console – jsr-223 – test – docgenerator – jmx – testng – groovydoc – sql – json – groovysh – swing – xml – ant – servlet – bsf – templates.
Dejaremos las dos más importantes features para el final: static type checking y static compilation.

@TypeChecked
Puede estar a nivel de clase o de método. Ayuda a comprobar errores de compilación (no en tiempo de ejecución). No todo el tiempo necesitas las features dinámicas. Comprueba tipos en métodos y variables, asignaciones erroneas, tipos devueltos erroneos y tipos heredados.

import  groovy.transform.TypeChecked

void  method() { ... }   

@TypeChecked  
test() {
  // No se puede encontrar el método  metthhoood()        
  metthhoood()          
  def  name  =  "Eduuuuuu"        
  // Variable  naamme  no está declarada       
  println  naamme 
}

La anotación @TypeChecked funciona en tiempo de compilación y no cambia el comportamiento del código. La mayoría de las features dinámicas no pueden ser @TypeChecked. Sin embargo, la metaprogramación funciona en tiempo de compilación.

@CompileStatic
Esto quiere decir que todo el código se compila estáticamente, es decir genera el mismo byte code que si lo compilásemos con javac.
Ventajas que consigues:
- Tipado seguro
- Código más rápido (casi a la altura de Java)
- Código inmune
- Byte code generado más pequeño
Desventajas
- Pierdes las features dinámicas
- Pierdes el método dispatch

import  groovy.transform.CompileStatic  

@CompileStatic
test() { ... }

Diferencia entre el método addTo y el operador << (leftShift)

noreply@blogger.com (EduSanz) — Thu, 25 Oct 2012 14:50:00 +0000

Sabemos que cuando creas una clase de dominio en Grails con una relación hasMany, automáticamente te crearán dos métodos para añadir o borrar instancias a la relación (addTo... y removeFrom...)

class Book {
  static hasMany = [authors: Author]

}

Para añadir una instancia author dentro de Book habría dos formas de hacerlo,

def author = Author.get(1)
def book = Book.get(3)

book.addToAuthors(author) //La colección authors ya está inicializada
ó
book.authors << author //La colección tiene que estar inicializada antes con book.authors = []

Múltiples datasources

noreply@blogger.com (EduSanz) — Wed, 24 Oct 2012 14:56:00 +0000

En Grails 2 uno de los plugins que ya vienen instalados es el Multiple Datasources Plugin. Muy interesante si tienes más de una BBDD a la que atacar.
Por defecto todas las clases de dominio atacan a la misma BBDD configurada en tu Config.groovy,

dataSource {
    pooled = true
    driverClassName = "org.h2.Driver"
    username = "sa"
    password = ""
}
hibernate {
    cache.use_second_level_cache = true
    cache.use_query_cache = true
    cache.provider_class = 'net.sf.ehcache.hibernate.EhCacheProvider'
}

environments {
  development {
    dataSource {
      dbCreate = "create-drop" 
      url = "jdbc:h2:mem:devDb" 
    } 
  } 
  test {
    dataSource {
      dbCreate = "update"
      url = "jdbc:h2:mem:testDb"
    }
  }
  production {
    dataSource {
      dbCreate = "update"
      url = "jdbc:h2:prodDb" 
    }
  } 
}

Si quieres configurar otra BBDD, la tendrás que definir al mismo nivel que dataSource, sólo que cambiándole el nombre, en este caso dataSource_lookup,

dataSource {
    pooled = true
    driverClassName = "org.h2.Driver"
    username = "sa"
    password = ""
}
hibernate {
    cache.use_second_level_cache = true
    cache.use_query_cache = true
    cache.provider_class = 'net.sf.ehcache.hibernate.EhCacheProvider'
}

environments {
  development {
    dataSource {
      dbCreate = "create-drop" 
      url = "jdbc:h2:mem:devDb" 
    }
    dataSource_lookup {
            dialect = org.hibernate.dialect.MySQLInnoDBDialect
            driverClassName = 'com.mysql.jdbc.Driver'
            username = 'lookup'
            password = 'secret'
            url = 'jdbc:mysql://localhost/lookup'
            dbCreate = 'update'
    } 
  } 
  test {
    dataSource {
      dbCreate = "update"
      url = "jdbc:h2:mem:testDb"
    }
  }
  production {
    dataSource {
      dbCreate = "update"
      url = "jdbc:h2:prodDb" 
    }
  } 
}

El siguiente paso sería configurar las clases de dominio. Habría varias posibilidades:
- Que ataque a la nueva BBDD

class ZipCode {

  String code

  static mapping = { datasource 'lookup' } 
}

- Que ataque a varias BBDD

class ZipCode {

  String code

  static mapping = { datasources(['lookup', 'auditing']) } 
}

- Que ataque a varias BBDD, entre ellas la de por defecto

class ZipCode {

  String code

  static mapping = { datasources(['lookup', 'DEFAULT']) } 
}

- Que ataque a todas las BBDD

class ZipCode {

  String code

  static mapping = { datasource 'ALL' } 
}

Luego a la hora de hacer save, delete o cualquier método GORM, tendremos que construirlo con un namespace para decirle a qué BBDD tiene que ir.

def zipCode = ZipCode.auditing.get(42)
…
zipCode.auditing.save()

En el ejemplo anterior, le estaremos diciendo que la instancia de la clase ZipCode tiene que hacer el get y el save en la BBDD "auditing".

El argumento "failOnError"

noreply@blogger.com (EduSanz) — Tue, 23 Oct 2012 14:49:00 +0000

A veces cuando hacemos un save de una clase de dominio, no sabemos por qué no se han persistido los datos en la BBDD. La mayoría de las veces es porque se nos olvida que todas las clases de dominio tienen una constraint implícita con un nullable: false.

def book = new Book(params)
if (!book.save()) {
    // Save falla!
    ...
}

Para solucionarlo y ver más claro donde ha fallado podemos utilizar el argumento "failOnError". De esta manera cuando haya un error en la validación, nos lanzará una excepción para verlo más claramente.

book.save(failOnError: true)

También se puede definir de forma general para que lo haga con todos los "save" lanzados en la aplicación, configurándolo en nuestro grails-app/conf/Config.groovy,

grails.gorm.failOnError = true

También podemos presentar los errores de la siguiente manera,

def book = new Book(params)
if (!book.save() && book.hasErrors()) {
    // Save falla! Presenta los errores.
    book.errors.allErrors.each{ println it }
    ...
}

Inyectando beans adicionales

noreply@blogger.com (EduSanz) — Mon, 22 Oct 2012 14:30:00 +0000

Por convención de Grails, todos los servicios metidos en nuestra carpeta "services" serán inyectados automáticamente por el framework ayudándose de las bondades de Spring.
Pero habrá otros casos en donde definamos un bean en src/groovy o en src/java que vayamos a tener que utilizar en cualquiera de nuestros artefactos más adelante.
Se puede inyectar de dos maneras: usando Spring Bean DSL o por XML.
- Por Spring Bean DSL: modificando el archivo grails-app/conf/spring/resources.groovy y añadiendo el bean dentro de la clousure beans.

import my.company.MyBeanImpl

beans = {
 myBean(MyBeanImpl) { 
   someProperty = 42 
   otherProperty = "blue" 
 } 
}

- Usando XML: modificando el archivo grails-app/conf/spring/resources.xml (lo tienes que crear tu a mano primero) y añadiendo el bean como lo definirías en el applicationContext.xml con Spring.

<bean id="myBean" class="my.company.MyBeanImpl">
    <property name="someProperty" value="42" />
    <property name="otherProperty" value="blue" />
</bean>

Una vez configurado, el bean estará disponible para ser inyectado en cualquiera de los artefactos de Grails, así como en clases que soportan la inyección de depedencias (como puede ser Bootstrap o test de integración)

class ExampleController {

  def myBean … 

}

NOTA: Si defines un bean en el fichero resources.groovy con el mismo nombre que uno que se haya configurado previamente por Grails o por un plugin instalado, tu bean reemplazará al bean previamente registrado. Esto es una forma conveniente de customizar el comportamiento sin recurrir a editar el código del plugin u otra clase que pudiera afectar a la mantenibilidad de la aplicación.

Consumir servicios web con el Plugin WS-Client

noreply@blogger.com (EduSanz) — Mon, 08 Oct 2012 15:18:00 +0000

En la entrada anterior veíamos cómo exponer servicios web a través del Plugin CXF de Grails de una manera rápida y sencilla. Ahora nos toca ver cómo consumir un servicio web de un tercero.
Para consumir servicios web, usaremos el Plugin WS-Client basado en GroovyWS.
Lo primero de todo instalaremos el plugin añadiendo esta linea en tu BuildConfig,

compile ":ws-client:1.0"

Ahora sólo tendremos que crear un controlador para consumir ese servicio web con la url del WSDL donde esté publicado.

import org.grails.plugins.wsclient.service.WebService

class ClienteController {
    WebService webService

    def index = {
        def wsdlUrl = "http://ejemplo.com/services/pruebas?wsdl"
        def proxy = webService.getClient(wsdlUrl)
        
        String resul = proxy.saluda("Eylen")
        ...
    }
}

En este ejemplo sólo se ejecuta el método "saluda" del WSDL donde se construye un XML de entrada con un sólo nivel de tipo String y nos devuelve un XML de salida con un sólo nivel también de tipo String.
Habrá XML de salida muchos más complicados que éste, donde habrá que ir navegando por los diferentes niveles consultando la información.

import org.grails.plugins.wsclient.service.WebService

class ClienteController {
    WebService webService

    def index = {
        def wsdlUrl = "http://ejemplo.com/services/pruebas?wsdl"
        def proxy = webService.getClient(wsdlUrl)
        
        def libros = proxy.getLibros()
        libros.libro.each{
           println it.campo
        }
        ...
    }
}

También se puede dar la situación en la que tenemos que construir un XML de entrada con más niveles. Esto se hace construyendo proxies. Tened cuidado con los namespace de los WSDL que puede dar más de un dolor de cabeza. Y también prestad atención si la entrada del WSDL es de tipo String o es una lista.

import org.grails.plugins.wsclient.service.WebService

class ClienteController {
    WebService webService

    def index = {
        def wsdlUrl = "http://ejemplo.com/services/pruebas?wsdl"
        def proxy = webService.getClient(wsdlUrl)

        def libro = proxy.create("defaultnamespace.Libro")

        libro.titulo= "Groovy in Action"
        libro.autor = "Dierk"
        libro.isbn = "123"

        //Detalles es una lista!!!
        def detalle1 = proxy.create("defaultnamespace.Detalles")       
        detalle1.paginas = "150"
        detalle1.indice = "S" 
        libro.detalles << detalle1

        proxy.addLibro(libro)
        ...
    }
}

Para poder debuguear en todos estas construcciones, es mejor que tengais puesto en el Config,

log4j = {
    …
    debug  'org.apache.cxf'
}

Como nota final decir que si teneis instalados en el mismo proyecto los plugins ws-client y cxf puede haber conflictos con la librería cxf. Se recomienda instalar primero el CXF y luego el WS-CLIENT y eliminar de ésta última el jar cxf.

Exponer servicios Grails a través de SOAP con CXF

noreply@blogger.com (EduSanz) — Mon, 08 Oct 2012 09:50:00 +0000

Una de las facilidades de Grails es que tiene plugins para casi todo. Y uno de los mejores a la hora de exponer servicios web de tipo SOAP es el CXF plug-in for Grails. La única dependencia que teneis que añadir a vuestro BuildConfig es,

compile ":cxf:0.9.0"

Con esta línea, cuando arranqueis vuestra aplicación otra vez, te instalará el plugin. La instalación ya te meterá las librerías necesarias de CXF. La última versión que han sacado ya es compatible para Grails 2.
Para configurarlo se puede hacer de dos formas diferentes:

1. Con la propiedad estática "expose" igual a "cxf"

class TestService {

  static expose=['cxf'] 
  static exclude=["ignoredMethod"]

  boolean serviceMethod(YourDomainClass dc){ return true; }

  boolean ignoredMethod() { return "you shouldn't see me" }

}

Si queremos que algún método del servicio sea ignorado y no se exponga lo declararemos con la propiedad estática "exclude" y el nombre del método.
Todos los métodos que no estén en el exclude serán expuestos y serán accesibles para terceros a través de su url "http://127.0.0.1:8080/nombreApp/services/miServicio?wsdl"
Todas las clases de dominio que sean pasadas o devueltas como parámetros en los servicios web deberán llevar la anotación JAXB @XmlAccessorType(XmlAccessType.FIELD). Esto hará que todos los campos públicos y privados sean serializables. Más info de las anotaciones JAXB aquí.

@XmlAccessorType(XmlAccessType.FIELD)
class YourDomainClass {
  ...
}

2. Con la propiedad estática "expose" igual a "cxfjax". Configurado esto, ya podemos utilizar las anotaciones JaxWS para tener más control sobre tu WSDL.

import javax.jws.*

class TestService { static expose=['cxfjax']

  @WebResult(name="addResult") 
  @WebMethod(operationName="add") 
  int add(@WebParam(name="a")int a, @WebParam(name="b")int b) { 
    return a + b 
  } 
}

Con cxfjax, tienes que poner la anotación @WebMethod en el método del servicio que quieres exponer. Con la anotación @WebResult, le decimos el nombre del parámetro que devuelve el servicio en el WSDL y con @WebParam definimos el nombre del parámetro de entrada que está definido en el WSDL.

Anotaciones de JAXWS:
- @WebService indica que una clase Java está implementando un servicio Web o indica que una SEI (Service Endpoint Interface) está implementando una interfaz de servicio Web. Destino de anotación: Type. Parámetros que permite:

name="" -> El nombre de wsdl:portType. El valor por omisión es el nombre sin calificar de la interfaz o clase Java. (String)

targetNamespace="" -> Especifica el espacio de nombres XML o los elementos WSDL y XML generados a partir del servicio Web. El valor por omisión es el espacio de nombres correlacionado a partir del nombre del paquete que contiene el servicio Web. (String)

serviceName="" -> Especifica el nombre de servicio del servicio Web: wsdl:service. El valor por omisión es el nombre sencillo de la clase java más Service. (String)

endpointInterface="" -> Especifica el nombre calificado de la interfaz de punto final de servicio que define el contrato de servicio web abstracto de los servicios. Si se especifica, se utiliza la interfaz de punto final de servicio para determinar el contrato WSDL abstracto. (String)

portName="" -> wsdl:portName. El valor por omisión es WebService.name más Port. (String)

wsdlLocation="" -> Especifica la dirección Web del documento WSDL que define el servicio Web. La dirección Web puede ser relativa o absoluta. (String)

- @WebMethod indica un método que es una operación de servicio Web. Destino de anotación: Method. Parámetros que permite:

operationName="" -> Especifica el nombre de wsdl:operation que coincide con este método. El valor por omisión es el nombre del método Java. (String)

action="" -> Define la acción de esta operación. En los enlaces SOAP, este valor determina el valor de la cabecera SOAPAction. El valor por omisión es el nombre del método Java. (String)

exclude="" -> Especifica si se ha de excluir un método del servicio Web. El valor por omisión es false.(Boolean)

- @Oneway indica un método como una operación unidireccional de servicio Web que sólo tiene un mensaje de entrada y ningún mensaje de salida. Destino de anotación: Method. No hay parámetros.

- @WebParam personaliza la correlación de un parámetro individual con una parte de mensaje de servicio Web y un elemento XML. Destino de anotación: Parameter. Parámetros que permite:

name="" -> El nombre del parámetro. Si la operación es una RPC (Remote Procedure Call) y no se especifica el atributo partName, este es el nombre del atributo wsdl:part que representa el parámetro. Si la operación es de estilo documento o si el parámetro se correlaciona con una cabecera, -name es el nombre local del elemento XML que representa el parámetro. Este atributo es necesario si la operación es de estilo documento, el estilo de parámetro es BARE, y la modalidad OUT o INOUT. (String)

partName="" -> Define el nombre del atributo wsdl:part que representa este parámetro. Sólo se utiliza si la operación es de estilo RPC o si el estilo de documento y el estilo de parámetro es BARE. (String)

targetNamespace="" -> Especifica el espacio de nombres XML del elemento XML del parámetro. Se aplica únicamente a los enlaces de documentos cuando el atributo se correlaciona con un elemento XML. El valor por omisión es el targetNamespace del servicio Web. (String)

mode="" -> El valor representa la dirección en que fluye el parámetro para este método. Los valores válidos son IN, INOUT y OUT. (String)

header="" -> Especifica si el parámetro es una cabecera de mensaje y no el cuerpo de un mensaje. El valor por omisión es false. (Boolean)

- @WebResult personaliza la correlación de un valor de retorno con una parte WSDL o elemento XML. Destino de anotación: Method. Parámetros que permite:

name="" -> Especifica el nombre del valor de retorno como figura en el archivo WSDL y aparece en los mensajes de la comunicación. Para los enlaces RPC, este es el nombre del atributo wsdl:part que representa el valor de retorno. Para los enlaces de documentos, el parámetro -name es el nombre local del elemento XML que representa el valor de retorno. El valor por omisión es return para enlaces RPC y DOCUMENT/WRAPPED. El valor por omisión es el nombre de método más Response para enlaces DOCUMENT/BARE. (String)

targetNamespace="" -> Especifica el espacio de nombres XML para el valor de retorno. Este parámetro sólo se utiliza si la operación es de estilo RPC o si la operación es de estilo DOCUMENT y el estilo de parámetro es BARE. (String)

header="" -> Especifica si el resultado se lleva a cabo en una cabecera. El valor por omisión es false. (Boolean)

partName="" -> Especifica el nombre de la parte para el resultado con las operaciones RPC o DOCUMENT/BARE. El valor por omisión es @WebResult.name. (String)

- @HandlerChain asocia el servicio Web con una cadena de manejadores definida externamente. Destino de anotación: Type. Parámetros que permite:

file="" -> Especifica la ubicación del archivo de la cadena de manejadores. La ubicación del archivo es un java.net.URL absoluto con forrmato externo o una vía de acceso relativa al archivo de clases. (String)

name="" -> Especifica el nombre de la cadena de manejadores en el archivo de configuración. (String)

- @SOAPBinding especifica la correlación del servicio Web en el protocolo de mensajes SOAP. Destino de anotación: Type o Method. Parámetros que permite:

style="" -> Define el estilo de codificación para los mensajes enviados a y desde el servicio Web. Los valores válidos son DOCUMENT y RPC. El valor por omisión es DOCUMENT. (String)

use="" -> Define el formato utilizado para los mensajes enviados a y desde el servicio Web. El valor por omisión es LITERAL. ENCODED no está soportado en Feature Pack for Web Services. (String)

parameterStyle="" -> Determina si los parámetros del método representan todo el cuerpo del mensaje o si los parámetros son elementos envueltos en un elemento de nivel superior con el nombre de la operación. Los valores válidos son WRAPPED o BARE. Sólo puede utilizar el valor BARE con los enlaces de estilo DOCUMENT. El valor por omisión es WRAPPED.(String)

Mas info en Web Services Metadata Annotations (JSR 181)

Error de sincronización Grails 2.1.1 con Intellij IDEA 11.1.1

noreply@blogger.com (EduSanz) — Fri, 05 Oct 2012 11:15:00 +0000

En uno de mis proyectos personales, teniendo instalado la version de Grails 2.1.1 me salía el siguiente error cuando añadía una dependencia en el BuildConfig.groovy,

IDEA hook: Grails not found!
| Error java.lang.reflect.InvocationTargetException
| Error
 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
| Error
 at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
| Error
 at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
| Error
 at java.lang.reflect.Method.invoke(Method.java:601)
| Error
 at org.jetbrains.groovy.grails.rt.Agent$2.run(Agent.java:73)
| Error at java.lang.Thread.run(Thread.java:722)
| Error Caused by: java.lang.NullPointerException
| Error at org.jetbrains.groovy.grails.rt.GrailsSettingsGetter.printSettings(GrailsSettingsGetter.java:62)

Después de volverme loco durante una hora, encontré la solución. Y es que es un bug en la versión 11.1.1 del Intellij IDEA. La solución hacer un upgrade a las versión 11.1.3 y todo solucionado.

Todos las opciones del database mapping

noreply@blogger.com (EduSanz) — Thu, 04 Oct 2012 11:31:00 +0000

En esta entrada trataremos de explicar todas las features que tiene Grails 2 para customizar el mapeo con la base de datos.
Primero de todo diremos que todo esto se puede definir en dos sitios:
- De una manera específica en una clase de dominio

 
 (static mapping = { ... })

-De forma general definiendolo en el Config.groovy con

 
grails.gorm.default.mapping = { ... }

1) AUTOIMPORT
Permite importar o no la clase de dominio en las queries HQL. Por defecto está a true, es decir las clases de dominio por defecto son auto-importadas en las queries HQL, así que sólo con poner el nombre ya es suficiente. Si ponemos esta característica a false, para formar una query habrá que incluir su paquete también para poder identificar la clase de dominio. Esto es una buena solución para cuando tienes dos clases de dominio con el mismo nombre en distintos paquetes y te da un org.hibernate.DuplicateMappingException.

static mapping = {
        autoImport false
    }

2) AUTO TIMESTAMP
Habilitar o no el auto Timestamping, es decir, cuando queremos guardar su dateCreated y su lastUpdated de una clase de dominio automáticamente deberemos tenerlo a true. Si lo quieres deshabilitado para guardar tus propias fechas ponerlo a false.

static mapping = {
        autoTimestamp false
    }

3) BATCH SIZE
Customizar cuántos resultados queremos cuando capturamos datos de la BBDD en una carga lazy.

static mapping = {
        batchSize 10
    }

4) CACHE
Habilitar la cache de segundo nivel de Hibernate.

static mapping = {
        cache true
    }

5) CACHE
Configurar el comportamiento en cascada de la asociación.

static hasMany = [books: Book]

static mapping = { books cascade: 'all-delete-orphan' }

Aquí podemos definir uno o varios comportamientos separados por coma. Hay varios tipos: all, merge, save-update, delete, lock, refresh, evict, replicate or all-delete-orphan (sólo para relaciones one-to-many)
GORM por defecto configura la política de cascada save-update.

6) COLUMN
Customiza la definición de una columna.

static mapping = {
        currency column: "currency", sqlType: "char", length: 3
    }

Primero se define el nombre del atributo seguido de los siguientes parámetros a cambiar:
- column - nombre de la columna como String
- sqlType (optional) - tipo SQL
- enumType (optional) - tipo de enumerado para las propiedades Enum. (ordinal o string)
- index (optional) - nombre del índice
- unique (optional) - si es único
- length (optional) - longitud de la columna
- precision (optional) - nº de posiciones de la parte entera de la columna
- scale (optional) - nº de decimales de la columna

7) DATASOURCE
Configura qué datasource está relacionada la clase de dominio.

static mapping = {
      datasource 'lookup'
   }

environments {
    development {
        dataSource {
            dbCreate = "create-drop"
            url = "jdbc:h2:mem:devDb"
        }
        dataSource_lookup {
            dialect = org.hibernate.dialect.MySQLInnoDBDialect
            driverClassName = 'com.mysql.jdbc.Driver'
            username = 'lookup'
            password = 'secret'
            url = 'jdbc:mysql://localhost/lookup'
            dbCreate = 'update'
        }
    }
}

Si una clase de dominio no tiene una configuración de DataSource, tirará por defecto del DataSource configurado en el Config.groovy.

8) DISCRIMINATOR
Customiza el discriminador de columna cuando se mapea una herencia tipo "table-per-subclass".

class PodCast extends Content {
    …
    static mapping = {
        discriminator "audio"
    }
}

9) DYNAMIC INSERT
Para construir dinamicamente queries INSERT.

static mapping = {
        dynamicInsert true
    }

Por defecto Hibernate genera todas las queries al principio y las cachea. Esto ayuda a que el rendimiento para los insert, update y delete queries no tengan que ser generadas dinámicamente en tiempo de ejecución. Sin embargo, hay ciertas circunstancias donde las queries dinámicas son útiles.

10) DYNAMIC UPDATE
Para construir dinamicamente queries UPDATE.

static mapping = {
        dynamicUpdate true
    }

11) FETCH
Configura el comportamiento de carga de datos de una asociación.

static hasMany = [books: Book]

static mapping = { books fetch: 'select' }

Se define con el nombre de las asociación seguida del parámetro:
- fetch - Estrategia a usar. (join o select)
Por defecto GORM asume que la carga de asociaciones está hecha con una SELECT cuando se accede a la asociación. Si prefieres que la asociación sea cargada de modo eager, puedes cambiarlo sobreescribiendo:

static hasMany = [books: Book]

static mapping = { books fetch: 'join' }

12) ID
Customizar la forma en que el identificador es generado para un dominio.

static mapping = {
        id generator: 'hilo',
           params: [table: 'hi_value', column: 'next_value', max_lo: 100]
    }

Se define poniendo el id seguido de los siguientes parámetros:
- generator (optional) - nombre del generador a usar. Puede ser increment, identity, sequence, hilo, seqhilo, uuid, guid, native, assigned, select, foreign o sequence-identity.
- composite (optional) - coge una lista de propiedades a usar para formar la clave compuesta.
- name (optional) - nombre de la propiedad a usar como identificador.
- params (optional) - algún parámetro para pasar a un generador de identificadores definido.
- column (optional) - nombre de la columna para mapear el identificador. El resto de propiedades también está disponible.

13) IGNORE NOT FOUND
Especifica cómo las FKs que referencian a filas no encontradas son manejadas en las relaciones many-to-one.

String title 
Thumbnail thumbnail

static mapping = { thumbnail ignoreNotFound: true }

Por defecto el valor es false, es decir si no encuentra la fila Hibernate lanzará una excepción "org.hibernate.ObjectNotFoundException". Si lo tienes a true, aunque no lo encuentre, lo ignorará. Esto viene bien cuando tienes BBDD corruptas que le van a faltar datos.

14) INDEX COLUMN
Customiza el índice de una colección de tipo Lista o un Mapa.

static hasMany = [matrix: Integer]

static mapping = { matrix indexColumn: [name: "the_matrix", type: Integer] }

Esto se define con el nombre de la asociación seguido de los siguientes parámetros:
- name - nombre de columna como un String
- type (optional) - tipo Hibernate
- sqlType (optional) - tipo SQL
- enumType (optional) - tipo de enumerado para las propiedades Enum. (ordinal o string)
- index (optional) - nombre del índice
- unique (optional) - si es único
- length (optional) - longitud de la columna
- precision (optional) - nº de posiciones de la parte entera de la columna
- scale (optional) - nº de decimales de la columna

15) INSERTABLE / UPDATEABLE
Determina si una propiedad de la BBDD está configurada como insertable/updateable cuando una instancia es persistida.

String title

static belongsTo = [author: Author]

static mapping = { 
              author insertable: false 
              author updateable: false 
}

Se define con el nombre del atributo seguido de insertable/updateable: boolean. Por defecto están a true.

16) JOIN TABLE
Customiza el tipo de join table que se usa para las relaciones unidireccionales de tipo one-to-many, many-to-many y tipos de colección primitivos.

static hasMany = [projects: Project]

static mapping = { 
projects joinTable: [name: 'EMP_PROJ', column: 'PROJECT_ID', key: 'EMPLOYEE_ID'] 
}

Se define con el nombre de la asociación seguido de joinTable y de los siguientes parámetros:
- name - nombre de table
- key (optional) - clave foránea
- column (optional) - columna inversa

17) LAZY
Configura si se usa proxies y carga de datos lazy para las relaciones one-to-one y many-to-one.

static belongsTo = [author: Author]

static mapping = { author lazy: false }

Por defecto, en GORM las asociaciones single-ended son lazy: true es decir cuando se carga una instancia de un dominio, la asociación de ese dominio no es cargada hasta que se accede a ella.
Hibernate crea un proxy dinámico para subclasificar la clase de dominio y sus métodos y propiedades.

18) ORDER
Customizar el orden por defecto de los resultado de las queries.

static mapping = {
        order "desc"
    }

19) SORT
Customizar el atributo de la clase dominio para ordenar los resultados de las queries.

static mapping = {
        sort "releaseDate"
    }

20) TABLE
Customizar el nombre de la BBDD asociada de la clase de dominio.

class Book {
    static mapping = {
        table "book_catalog"
    }
}

También se le puede especificar el schema y el catálogo definiéndolo así,

static mapping = {
    table name: "book_catalog", schema: "dbo", catalog: "CRM"
}

21) TYPE
Para configurar el tipo de Hibernate para una propiedad particular.

String title

static mapping = { title type: "text" }

Esta propiedad viene bien para definir tipos CLOB o TEXT dependiendo del dialecto de la BBDD.

22) VERSION
Se usa para deshabilitar el bloqueo optimista o cambiar la columna que mapea la versión.

static mapping = {
        version false
    }

static mapping = {
        version 'revision_number'
    }

Entendiendo el Plugin Resources

noreply@blogger.com (EduSanz) — Wed, 26 Sep 2012 15:10:00 +0000

Este plugin representa una nueva forma de declarar tus recursos estáticos (css, js e img) mediante módulos y lincarlos a tus GSP por medio de tags específicas.
Primero, instala el plugin resources. Si tienes instalado Grails 2 ya viene por defecto instalado. Otros plugins muy interesantes para optimizar el rendimiento de tu aplicación serían: zipped-resources, cached-resources, lesscss-resources, gsp-resources, yui-minify-resources, handlebars-resources y page-resources.
Empezaremos declarando los módulos en el fichero "AppResources.groovy" que está en el directorio conf

modules = {
 common {
  resource url:"css/main.css"
  resource url:"js/jquery.js"
 }
}

Aquí le estamos diciendo que declare un módulo llamado "common" con dos recursos: main.css y jquery.js en donde por defecto los css los pondrá en el head y el js al final de la GSP (“defer”) que le definamos. Si queremos que los js los ponga en el head de la GSP, le añadiremos a la linea del resource disposition:"head"
Ahora necesitas meterlo dentro de una GSP. Para hacer esto, necesitas las tags propias del Plugin. Antes de nada, definamos el layout Sitemesh de nuestra aplicación.

<html>
    <head>
        
        
    </head>
    <body>
        
            
        
        
    </body>
</html>

El primer r:layoutResources servirá para lincar todos los css, js, iconos, etc que tengas en tu <head> y el segundo para renderizar algún resource “defer”, que normalmente es sólo código JavaScript.

Para utilizar un módulo de recursos en una GSP:

<html>
    <head>
        
        
    </head>
    <body>
    …
    </body>
</html>

A veces tienes que controlar el orden de tus recursos ya que dependen de otros para cargarse bien. La regla general de este plugin es que se empiecen a cargar los recursos en orden de definición (es decir de arriba a abajo). También se puede hacer de otra manera, con "dependsOn". Por ejemplo,

modules = {
    customize{
        dependsOn "common"
        resource url:'css/customize.css'
    }
}

Con esto le estamos diciendo que antes de cargar el módulo customize, debe estar cargado el módulo common.
Otra de las tags que pueden ser útiles es la r:script. Esta tag se utiliza para introducir algo de código JS en la GSP.

<html>
    <head>
        
        
        window.alert('Boo!')
    </head>
    <body>
    …
    </body>
</html>

Este alert que hemos definido se cargará con disposition "defer", es decir se cargará cuando se haya cargado toda la página, aunque esté definido en el head.
Si quisiéramos forzar a que este trozo de JS se cargara en el head le tendríamos que modificar la tag con,

<r:script disposition="head" >

Otro tipo de recurso que se puede utilizar en este plugin son las imágenes. Se puede hacer de dos formas: llamándole desde la GSP,

<r:img uri="images/logo.png"/>

o creando un módulo desde AppResources,

modules = {
    images {
        resource url:'images/logo.png',
            attrs:[width:400, height:180, alt:'ACME Corp.'],
            disposition: 'image'
    }
}

Chain = encadenar

noreply@blogger.com (EduSanz) — Mon, 24 Sep 2012 10:46:00 +0000

Las acciones pueden ser encadenadas. El encadenamiento permite guardar el model de una acción a otra. Por ejemplo llamamos a sucesivas acciones en este código:

class ExampleChainController {

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

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

def third() { [three: 3]) } 
}

Al final de la tercera accion tu model sería,

[one: 1, two: 2, three: 3]

El modelo puede ser accedido en el siguiente controller al chain usando el mapa chainModel. Esta propiedad dinámica existe sólo en acciones siguientes a la llamada de algún método chain.

class ChainController {

def nextInChain() { 
def model = chainModel.myModel
 … 
} 
}

Como en el método redirect, puedes pasar también parámetros a un método chain:

chain(action: "action1", model: [one: 1], params: [myparam: "param1"])

Peticiones asíncronas

noreply@blogger.com (EduSanz) — Mon, 24 Sep 2012 10:36:00 +0000

Grails soporta el procesamiento de peticiones asícronas como característica de la especificación de Servlet 3.0. Para activar la característica necesitas añadir la siguiente líena de código en tu BuildConfig.groovy:

grails.servlet.version = "3.0"

Con esto te aseguras de que tienes la caracterísitica activada en tiempo de compilación.
NOTA: Con el Servlet 3.0 activado, podrás solamente hacer deploy en contenedores que lo soporten como Tomcat 7, etc.
- Renderizar asíncronamente
Puedes renderizar contenido (templates, binary data, etc) de una forma asíncrona por medio de una llamada al método startAsync que devuelve una instancia del AsyncContext de Servlet 3.0. Una vez que tienes una referencia al AsyncContext, puedes usar el método render:

def index() {
    def ctx = startAsync()
    ctx.start {
        new Book(title:"The Stand").save()
        render template:"books", model:[books:Book.list()]
        ctx.complete()
    }
}

Deberías llamar al método complete() para terminar la conexión.

- Reanudar una petición asíncrona
Para reanudar el procesamiento de una petición asíncrona (por ejemplo para delegar a una vista renderizada), se usa el método dispatch de la clase AsyncContext:

def index() {
    def ctx = startAsync()
    ctx.start {
        // do working
        …
        // render view
        ctx.dispatch()
    }
}

Interceptores en controladores

noreply@blogger.com (EduSanz) — Fri, 21 Sep 2012 15:41:00 +0000

A menudo es útil para interceptar procesamientos de cualquier petición, sesión o estado de aplicación. Esto puedes lograrlo con la acción de los interceptores. Actualmente hay dos tipos de interceptores: before and after.

NOTA: Si tu interceptor se aplica a más de un controlador, deberías definir mejor un Filtro. Los filtros pueden aplicarse a múltiples controladores o a URIs sin la necesidad de cambiar la lógica de cada controlador.

- Before Interception
Intercepta procesamientos antes de que la acción se ejecute. Si devuelve false, la acción interceptada no será ejecutada. El interceptor podrá ser definido en todas las acciones de un controlador como lo siguiente:

def beforeInterceptor = {
    println "Tracing action ${actionUri}"
}

El código es declarado en el cuerpo del controlador. Será ejecutado antes que todas las acciones y no interferirá en el procesamiento. Un caso común es una simple autenticación:

def beforeInterceptor = [action: this.&auth, except: 'login']

// defined with private scope, so it's not considered an action 
private auth() { 
if (!session.user) { redirect(action: 'login') return false } }
def login() { // display login page }

El código define un método llamado auth. Un método privado es usado para no exponerlo como acción fuera de todo. El beforeInterceptor define un interceptor que es usado para todas las acciones excepto en la acción login y que ejecuta el método auth. El método auth se referencia usando la sintaxis de puntero de un método Groovy.
Dentro del método detecta si hay un usuario en sesión, si no es así redirige a la acción de login y devuelve un false, causando que la acción interceptada no sea procesada.

- After Interception
Usa la propiedad afterInterceptor para definir un interceptor que es ejecutado después de una acción:

def afterInterceptor = { model ->
    println "Tracing action ${actionUri}"
}

El afterInterceptor toma el resultado del model como argumento y por lo tanto puede manipular el modelo o la respuesta.
Un afterInterceptor puede también modificar el objeto ModelAndView de Spring MVC antes de renderizarlo. E este caso, sería:

def afterInterceptor = { model, modelAndView ->
    println "Current view is ${modelAndView.viewName}"
    if (model.someVar) modelAndView.viewName = "/mycontroller/someotherview"
    println "View is now ${modelAndView.viewName}"
}

Esto permite que la vista sea cambiada basándose en el modelo devuelto por la actual acción. Anotar que el modelAndView puede ser null si la acción que ha sido interceptada llama a un redirect o un render.

Ámbito en los controladores

noreply@blogger.com (EduSanz) — Fri, 21 Sep 2012 15:08:00 +0000

Al igual que los servicios, nosotros podemos fijar el scope también en los controladores. Por defecto, una instancia del controlador es creada por cada petición. De hecho, todos los controladores por defecto son de ámbito "prototype", es thread-safe que quiere decir que cada petición ocurre en su propio thread.

Puedes cambiar este comportamiento de los controladores sustituyendo por uno de los ámbitos soportados:
- prototype (default): un nuevo controlador será creado por cada petición (recomendado para acciones como propiedades de closure)
- session: un controlador es creado por cada ámbito de sesión
- singleton: solamente una instancia del controlador existe (recomendado para acciones como los métodos)

Para activar uno de los ámbitos, se añade una propiedad estática llamada scope en tu controlador con uno de los ámbitos válidos, cmo por ejemplo,

static scope = "singleton"

Puedes definir la estrategia por defecto en el fichero Config.groovy con la clave grails.controllers.defaultScope, por ejemplo:

grails.controllers.defaultScope = "singleton"

NOTA: Usar los ámbitos en los controladores sabiamente. Por instancia, no recomendamos tener ninguna propiedad en un controlador singleton-scoped ya que serán compartidos por todas las peticiones. Poniendo el ámbito por defecto que no sea prototype también puede dar lugar a comportamientos inesperados si tienes controladores suministrados por plugins instalados ya que se esperan que el ámbito sea prototype.

¿Por qué métodos en lugar de closures?

noreply@blogger.com (EduSanz) — Fri, 21 Sep 2012 14:47:00 +0000

En versiones anteriores de Grails, las acciones en los controladores eran implementadas con closures. Esto en Grails 2 todavía está soportado, pero la opción preferida es usar métodos.

Elegir métodos en vez de closures tiene algunas ventajas:
- Memoria eficiente
- Permite uso de de controladores en singleton scope
- Puedes sobrescribir acciones de subclases y llamar al método de la superclase con super.actionName()
- Los métodos pueden ser interceptados con mecanismos estandar de proxying, algo que es complicado de hacer con closures ya que tienen campos

Si prefieres la sintaxis con closures o tienes un controlador antiguo creado en una versión anterior de Grails y quieres las ventajas de usar métodos, puedes poner en el BuildConfig.groovy la siguiente linea,

grails.compile.artefacts.closures.convert=true

y en tiempo de compilación las transformaciones AST convertirán tus closures en métodos en el bytecode generado.

NOTA: Si un controlador extiende de otra clase que no está definida dentro del directorio app/controllers/, lo métodos heredados de esa clase no serán conertidos en acciones. Si la intención es exponer esos métodos heredados como acciones de un controlador, los métodos pueden ser sobreescritos en la subclase y el método de la subclase puede invocar al método en la super clase.

Command objects

noreply@blogger.com (EduSanz) — Thu, 30 Aug 2012 12:16:00 +0000

Los controladores de Grails y las clases dentro de src/groovy soportan el concepto de los command objects. Un command object es similar a un bean. También se le puede definir validación.
- Declarando command objects

import grails.validation.Validateable

class SampleController {
  ...
}
@Validateable
class LoginCommand {
    String username
    String password

static constraints = { username(blank: false, minSize: 6) password(blank: false, minSize: 6) } 
}

* Como se muestra en el ejemplo, la clase del command object está marcada por la anotación Validateable, donde con esto podrás definir constraints del mismo modo que en las clases de dominio. Otra forma de hacer un command object validable es definirlo sin la anotación y meter una la siguiente línea en tu Config.groovy

grails.validateable.classes = [com.example.LoginCommand]

- Uso del command object
Para usar los command objects en las acciones de los controladores que se quieran utilizar, se le pasará como parámetro dicho command object.

class LoginController {

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

// work with the command object data } }

Antes de que la acción del controlador se ejecute, Grails creará automáticamente una instancia del command object y rellenará sus propiedades con los parámetros de la petición. Si el command object está marcado con @Validateable, entonces se validará con sus contraints.
- Inyección de dependencias dentro de los command objects

@Validateable
class LoginCommand {

def loginService

String username String password

static constraints = { username validator: { val, obj -> obj.loginService.canLogin(obj.username, obj.password) } } }

* Para quien le interese, también se puede crear command objects dentro de servicios. Aquí os dejo el enlace donde lo explican http://jts-blog.com/?p=252

Diferencia entre get / read / load

noreply@blogger.com (EduSanz) — Thu, 09 Aug 2012 12:24:00 +0000

A todos se les pasa el ID como identificador.
- El método get carga el objeto de base de datos.
- El método read carga el objeto en modo lectura. En este caso Hibernate no hará dirty checking y el objeto no será persistido.
- El método load carga un proxy para una instancia. Esto no incurre el acceso a base de datos.

Herencia en GORM

noreply@blogger.com (EduSanz) — Thu, 09 Aug 2012 12:17:00 +0000

GORM soporta la herencia tanto de clases abstractas como de entidades persistentes.

class Content {
 String author
}

class BlogEntry extends Content {
 URL url
}

A nivel de base de datos, Grails por defecto usa la estrategia de mapeo "table-per-hierarchy" con una columna discriminandora llamada "class", así que la clase padre Content y su hijo/s (BlogEntry, etc) compartirán la misma tabla.

La estrategia de mapeo "table-per-hierarchy" tiene un punto débil que es que no puede tener propiedades non-nullable. Una solución podría ser cambiar la estrategia y ponerla a "table-per-subclass".

class Payment {
Integer amount
static mapping = [ tablePerHierarchy : false ]
}
class CreditCardPayment extends Payment {
String cardNumber
}

Sin embargo, el excesivo uso de la herencia y de la estrategia "table-per-subclass" puede penalizar en el rendimiento por el uso de outer join queries. El consejo es usar la herencia pero no abusar de ella sobre todo si es muy profunda.

Data binding en los argumentos de la acción

noreply@blogger.com (EduSanz) — Wed, 08 Aug 2012 12:07:00 +0000

En Grails 2 una de las caraterísticas era el databinding en los argumentos de la acción de un Controlador.

def save (float width, float height) {
...
}

Pero ahora podemos cambiar el nombre de los argumentos para poder utilizarlos en la acción con la anotación @RequestParameter de Spring 3 (ej. para conectar con una API externa).

def save (@RequestParameter('w') float width,  @RequestParameter('h') float height){
...
}

* Ahora el campo width se inicializá con params.w y height con params.h

Entendiendo ignoreNotFound

noreply@blogger.com (EduSanz) — Wed, 08 Aug 2012 11:56:00 +0000

Sirve para subsanar el error de una referencia perdida de una FK (foreign key borrada) en una base de datos en una relación many-to-one.
Cuando los datos en una base de datos están corruptos y una FK no existe, Hibernate nos dará un mensaje de "No row with the given identifier exists".
Una forma de solucionarlo es poner ignoreNotFound a true para que Hibernate trate la columna perdida como una asociación nula.

*Hay que tener cuidado porque cuando hagamos el save() nos puede dar una excepción por "Missing reference".

Nuevo método params.date()

noreply@blogger.com (EduSanz) — Wed, 08 Aug 2012 11:31:00 +0000

Hay un nuevo método en Grails 2 para resolver el problema de parsear fechas cuando vienen en el params.

def date = params.date('myDate')
ó
def date = params.date('myDate','dd/MM/yyyy')