under the hood: using spring in grails

© 2010 SpringSource, A division of VMware. All rights reserved

CONFIDENTIALCONFIDENTIAL

Under the Hood: Using Spring in Grails

Burt Beckwith

SpringSource

2CONFIDENTIAL 2CONFIDENTIAL

Who Am I

Java developer for over 13 years

Background in Spring, Hibernate, Spring Security

Grails developer for 5 years

SpringSource employee on the Grails team

Created or reworked over 40 Grails plugins

http://burtbeckwith.com/blog/

https://twitter.com/#!/burtbeckwith

http://burtbeckwith.com/blog/

https://twitter.com/#!/burtbeckwith


Spring Overview

Main functions of Spring

• Bean container: ApplicationContext and BeanFactory

• Dependency Injection (DI) and Inversion of Control (IoC)

• Proxies

• Transactions

• Security

• Caching

• Event publishing and listening

• Exception conversion


Grails Services


Grails Services

What is a Grails Service?


Grails Services


•Groovy class in grailsapp/services


Grails Services



•Great place for business logic


Grails Services




•A Spring bean, by default singleton scope


Grails Services





•Automatically transactional unless configured otherwise


Grails Services





•Automatically transactional unless configured otherwise

•Proxied, sometimes multiple times


Manually Wiring


Grails Services

package test;

import other.LoggingService;import auth.User;

public class UserManager {

private LoggingService loggingService;

public void setLoggingService(LoggingService service) { loggingService = service; }

public User createUser(String username) { User user = new User(); user.setUsername(username); user.save(); loggingService.logMessage( "Created user with username " + username); return user; }}

src/java/test/UserManager.java


Grails Services

import test.UserManager

beans = { userService(UserManager) { loggingService = ref('loggingService') }}

grails-app/conf/spring/resources.groovy


Grails Services


beans = { userService(UserManager) { bean -> bean.autowire = 'byName' }}



How to Make it Transactional?


Grails Services

import org.codehaus.groovy.grails.orm.support.GroovyAwareNamedTransactionAttributeSourceimport org.springframework.transaction.interceptor.TransactionProxyFactoryBean


beans = {

userService(TransactionProxyFactoryBean) { bean -> bean.lazyInit = true

target = { innerBean -> innerBean.lazyInit = true innerBean.autowire = 'byName' innerBean.beanClass = UserManager }

proxyTargetClass = true

def props = ['*': 'PROPAGATION_REQUIRED'] as Properties TransactionAttributeSource = new GroovyAwareNamedTransactionAttributeSource(transactionalAttributes: props)

transactionManager = ref('transactionManager') }}



or


Grails Services

package test;

import org.springframework.transaction.annotation.Transactional;import other.LoggingService;import auth.User;

@Transactionalpublic class UserManager {

private LoggingService loggingService;

public void setLoggingService(LoggingService service) { loggingService = service; }

public User createUser(String username) { ... }}



Grails Services


beans = {

userService(UserManager) { bean -> bean.lazyInit = true bean.autowire = 'byName' }}



How to be sure it's Transactional?


Grails Services

package test;

import org.springframework.transaction.TransactionStatus;import org.springframework.transaction.annotation.Transactional;import org.springframework.transaction.interceptor.TransactionAspectSupport;import org.springframework.transaction.support.TransactionSynchronizationManager;

...

public User createUser(String username) {

if (TransactionSynchronizationManager.isSynchronizationActive()) { TransactionStatus status = TransactionAspectSupport.currentTransactionStatus(); System.out.println("TX is active; isRollbackOnly: " + status.isRollbackOnly()); } else { System.out.println("Uh-oh, TX not active"); }

... }}



Grails Services

package test

import auth.User

class UserService {

def loggingService

User createUser(String username) { def user = new User(username: username) user.save() loggingService.logMessage( "Created user with username $username") user }}

grails-app/services/test/UserService.groovy


Transaction Helper Methods


Utility Methods

import o.s.t.interceptor.TransactionAspectSupportimport o.s.t.support.TransactionSynchronizationManager

for (sc in grailsApplication.serviceClasses) { def metaClass = sc.clazz.metaClass

…}


Utility Methods

// returns TransactionStatusmetaClass.getCurrentTransactionStatus = { >

if (!delegate.isTransactionActive()) {return null

}TransactionAspectSupport.currentTransactionStatus()

}


Utility Methods

// void, throws NoTransactionExceptionmetaClass.setRollbackOnly = { >

TransactionAspectSupport.currentTransactionStatus() .setRollbackOnly()}


Utility Methods

// returns booleanmetaClass.isRollbackOnly = { >

if (!delegate.isTransactionActive()) {return false

}delegate.getCurrentTransactionStatus().isRollbackOnly()

}


Utility Methods

// returns booleanmetaClass.isTransactionActive = { >

TransactionSynchronizationManager .isSynchronizationActive()}


Dependency Injection


Inversion of Control and Dependency Injection

def userService


Inversion of Control and Dependency Injection

def userService

private Object userService

void setUserService(Object userService) { this.userService = userService}

Object getUserService() { return userService}


Complex dependency configuration using Spring

SpEL


Complex dependency configuration using Spring SpEL

beans = { bar(Bar)

foo(Foo) { name = '#{bar.name}' }}


Complex dependency configuration using Spring SpEL

beans = { bar(Bar)

foo(Foo) { name = '#{bar.resourceName()}' }}


Manually injecting dependencies at runtime


Manually injecting dependencies at runtime

import org.springframework.beans.factory.config.AutowireCapableBeanFactory

...

def grailsApplication

...

def instance = new XXX(...)

def ctx = grailsApplication.mainContextctx.beanFactory.autowireBeanProperties( instance, AutowireCapableBeanFactory.AUTOWIRE_BY_NAME, false)


Bean Scopes


Bean Scopes

By default Spring beans are singletons


Bean Scopes

Other scopes

• prototype

• session

• request


Bean Scopes

You can even create your own custom scope:

• implement

org.springframework.beans.factory.config.Scope

• register: ctx.beanFactory.registerScope

'myScope', new MyScope()


Bean lifecycles and interfaces



Set the initMethod and/or the destroyMethod names

when registering beans

import com.mycompany.myapp.LdapAuthenticationManager

...

authenticationManager(LdapAuthenticationManager) { bean > serverUrl = '...' password = '...' bean.initMethod = 'init' bean.destroyMethod = 'destroy'}



Implement the

org.springframework.beans.factory.InitializingBean

interface and its afterPropertiesSet method and/or the

org.springframework.beans.factory.DisposableBean

interface and its destroy method



package com.mycompany.myapp

import org.springframework.beans.factory.DisposableBeanimport org.springframework.beans.factory.InitializingBean

class LdapAuthenticationManager implements InitializingBean, DisposableBean {

...

void afterPropertiesSet() { // initialization work }

void destroy() { // shutdown work }}


Bean PostProcessors


Bean PostProcessors

o.s.b.factory.config.BeanPostProcessor

• Object postProcessBeforeInitialization(Object bean,

String beanName)

• Object postProcessAfterInitialization(Object bean,

String beanName)


Bean PostProcessors

o.s.b.factory.config.BeanFactoryPostProcessor

• void postProcessBeanFactory(ConfigurableListableBeanFactory

beanFactory)


Bean PostProcessors

o.s.b.factory.support.BeanDefinitionRegistryPostProcessor

• extends BeanFactoryPostProcessor

• void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry

registry)


Cloud Support Plugin (cloudfoundry, heroku)

dataSourceBean.driverClassName = updatedValues.driverClassName

dataSourceBean.url = updatedValues.url + suffix

dataSourceBean.username = updatedValues.userName

dataSourceBean.password = updatedValues.password


Alternate approach to BeanDefinition modification

def doWithSpring = {

def mybeanDef = delegate.getBeanDefinition('mybean')

mybeanDef.beanClass = NewClass

mybeanDef.propertyValues.add("order", application.config.plugin?.rendering?.order ?: 42)}

● Use loadAfter = ['plugin1', 'plugin2'] to

ensure the bean is loaded

● Only valid in a plugin, not the app's resources.groovy


Bean Aliases


Aliases

As of Grails 2.1 aliases work fully

• You can create aliases pre2.1 but only if defined in the same

resources.groovy or plugin (doWithSpring)

beans = { springConfig.addAlias 'alias', 'realBean'}


Aliases

The cache plugin registers the alias cacheOperationSource for

the bean registered as

org.springframework.cache.annotation.AnnotationCacheOperationSource#0

Can use to have multiple implementations of a bean and choose

one via configuration at startup, e.g. perenvironment or some

other rule


Aliases

import grails.util.Environment

beans = {

String realBeanName

switch (Environment.current) {

case Environment.TEST: realBeanName = 'testCardProcessingService'; break

case Environment.PRODUCTION: realBeanName = 'productionCardProcessingService'; break

default: // Environment.DEVELOPMENT, custom envs realBeanName = 'mockCardProcessingService'; break }

springConfig.addAlias 'cardProcessingService', realBeanName}


Internationalization



Firstclass support in Grails via .properties files in grailsapp/i18n

All generated controllers, GSPs, and layouts are fully

internationalized with no hardcoded strings

Domain class validation errors are internationalized the same way

Enabled under the hood by the messageSource bean

(org.springframework.context.MessageSource)



Use the <g:message> tag in GSPs, message method in

controllers

Or use dependency injection like with any Spring bean

• def messageSource


Spring MVC Controllers


Spring MVC

New in Grails 1.2

Annotate src/java or src/groovy classes with @Controller

Add all packages to the grails.spring.bean.packages list in

Config.groovy

• e.g.grails.spring.bean.packages = ['gr8conf.testapp.foo']


Spring MVC

Annotate methods with

@o.s.w.bind.annotation.RequestMapping

@RequestMapping("/mvc/hello.dispatch")public ModelMap handleRequest() { return new ModelMap() .addAttribute("text", "some text") .addAttribute("cost", 42) .addAttribute("config", grailsApplication.getConfig().flatten()));}


Spring MVC

class UrlMappings {

static mappings = { …

"/mvc/hello"(uri:"/mvc/hello.dispatch")

"/mvc/other"(uri:"/mvc/other.dispatch") }}

@RequestMapping URI value must end in .dispatch

Add entries in UrlMappings to create more natural URLs


Spring MVC

Use @Autowired for dependency injection (on fields in Groovy

classes, on setters or constructors in Java)

private GrailsApplication grailsApplication;

@Autowiredpublic void setGrailsApplication(GrailsApplication app) { grailsApplication = app;}


Hibernate Integration



org.springframework.orm.hibernate3.

LocalSessionFactoryBean factory bean configures

org.hibernate.SessionFactory instances




HibernateTransactionManager implements

org.springframework.transaction.

PlatformTransactionManager to abstract away the details of

transaction management


Threadlocal holders

Cumbersome to explicitly open a Hibernate Session or start a

transaction and have to pass one or more related objects from

method to method


Threadlocal holders

Spring uses ThreadLocal scope since web requests are handled

per-thread


Threadlocal holders

See org.springframework.transaction.support.

TransactionSynchronizationManager and


SessionFactoryUtils helper classes


Threadlocal holders

Further helped by

org.codehaus.groovy.grails.orm.hibernate.support.

GrailsOpenSessionInViewInterceptor


Threadlocal holders

Opens a Hibernate Session at the start of all controller requests

and registers it in thread-local scope

For the duration of the request, there is always an active session

After the request it flushes and closes the Session


Threadlocal holders

Hibernate implementation of GORM uses a


HibernateTemplate under the hood to execute most queries


Threadlocal holders

HibernateTemplate uses SessionFactoryUtils.getSession() to

find or create a Session


Threadlocal holders

Plugins that enable asynchronous processing (Quartz, Gpars,

Executor) all implement patterns similar to OpenSessionInView


Other Cool Stuff


Other Cool Stuff

Standard and Custom Events

Resources

Data Binding and Validation

Marshalling XML using O/X Mappers

JMS (see Grails jms and ActiveMQ plugins)

EJBs

http://grails.org/plugin/jms

http://grails.org/plugin/activemq


Other Cool Stuff

Remoting (see the Grails remoting plugin)

• Remote Method Invocation (RMI)

• Hessian (Caucho's lightweight binary HTTPbased protocol)

• Burlap (another protocol from Caucho which uses XML)

• Spring's HTTP invoker

JMX (see the Grails jmx plugin)

Email (see the Grails mail plugin)

http://grails.org/plugin/remoting

http://grails.org/plugin/jmx

http://grails.org/plugin/mail


Other Cool Stuff

Other persistence support

• HibernateTemplate

• JdbcTemplate

• Other database support

• JDO

• JPA

• iBATIS (2.x) SQL Maps


Want More Information?


Thank You

under the hood: using spring in grails

Sports

groovyclassingrailsapp services greatplaceforbusinesslogic aspringbean

public void setloggingservice

java package test

groovy import test

import auth

created user

string username

import org