Chapter 9: Spring Integration

Overview

Spring Framework is a popular application development framework for enterprise Java. One key element is its infrastructural support: a light-weighted IoC (Inversion of Control) container that manages POJOs as Spring beans and their dependency relationship.

In this chapter, we won't create new example applications but will make previous examples integrated with Spring.

How to Integrate Spring Framework

The most common integration way is to let Spring manage an application's dependencies.

Configuration

Maven

In order to integrate Spring, we must add dependencies for Spring. The cglib is an optional dependency. We add it because our application uses scoped-proxy that requires it.

Extracted from pom.xml

	<properties>
		<zk.version>6.5.1</zk.version>
		<maven.build.timestamp.format>yyyy-MM-dd</maven.build.timestamp.format>
		<packname>-${project.version}-FL-${maven.build.timestamp}</packname>
		<spring.version>3.1.2.RELEASE</spring.version>
	</properties>
...
		<!-- Spring 3 dependencies -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>cglib</groupId>
			<artifactId>cglib</artifactId>
			<version>2.2.2</version>
		</dependency>

Deployment Descriptor

The deployment descriptor (web.xml) also needs two more listeners.

Extracted from web.xml

<?xml version="1.0" encoding="UTF-8"?>

<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> 

	<description><![CDATA[ZK Tutorial]]></description>
	<display-name>ZK Tutorial</display-name>

	<!-- ZK configuration-->
	...
	
	<!-- Spring configuration -->
	<!-- Initialize spring context -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	<!-- Enable webapp Scopes-->
	 <listener>
    	<listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
	</listener>
	
	<welcome-file-list>
		<welcome-file>index.zul</welcome-file>
	</welcome-file-list>
</web-app>

• Line 16: The ContextLoaderListener reads Spring configuration, and default location is WEB-INF/applicationContext.xml.
• Line 20: Use RequestContextListener to support web-scoped beans (request, session, global session).

Create Spring configuration file with default name (applicationContext.xml). We enable Spring's classpath scanning to detect and register those class with annotation as beans automatically.

WEB-INF/applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="
        http://www.springframework.org/schema/beans     
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 
 	<context:component-scan base-package="org.zkoss.tutorial" />
 
</beans>

• Line 10: This configuration enables scanning classpath. Spring will automatically detect those classes with Spring bean annotations and register them in bean definitions. For base-package, you should specify a common parent package or a comma-separated list that includes all candidate classes.

Register Spring Beans

Starting from 2.0, Spring provides an option to detect beans by scanning the classpath. Developers can use annotation (e.g. @Component) to register bean definitions in Spring container and this removes the use of XML. We can use @Component which is a generic stereotype annotation or those specialized stereotype annotation: @Controller, @Service, or @Repository for presentation, service, persistence layer, respectively. These annotations work equally for registering beans but using specialized annotation makes your classes suited for processing by tools.

When you register a bean, its bean scope is "singleton" by default if you don't specify. Our service class is stateless so that it is suitable to be a singleton-scoped bean. For those beans used in composers, you should use scoped-proxy to ensure every time you get the latest bean .

@Service("authService")
@Scope(value="singleton",proxyMode=ScopedProxyMode.TARGET_CLASS)
public class AuthenticationServiceImpl implements AuthenticationService,Serializable{
...
}

• Line 1: You could specify bean's name in @Service or its bean is derived from class name with first character in lower case (e.g. authenticationServiceImpl in this case).
• Line 2: If you want to specify a bean's scope, use @Scope..

Wire Spring Beans

After registering beans for service classes, we can "wire" them in our controllers with ZK's variable resolver. To wire a Spring bean in a composer, we need to apply a DelegatingVariableResolver. Then, we can apply annotation @WireVariable on a variable which we want to wire a Spring bean with. ZK will then wire the corresponding Spring bean with the variable whose name is same as the bean's name. Alternatively, you can specify the bean's name with @WireVariable("beanName").

You might think why don't we just register our controllers(or ViewModels) as Spring beans, so that we can use Spring's @Autowire. We don't recommend to do so. The main reason is that none of Spring bean's scope matches ZK's composer's life cycle, for detail please refer to Developer's Reference.

Wire beans in a ViewModel

@VariableResolver(DelegatingVariableResolver.class)
public class ProfileViewModel implements Serializable{
	private static final long serialVersionUID = 1L;

	//wire services
	@WireVariable
	AuthenticationService authService;
	@WireVariable
	UserInfoService userInfoService;
	...
}

• Line 6: Wire a Spring bean whose bean name is authService.

Wire beans in a composer

@VariableResolver(DelegatingVariableResolver.class)
public class SidebarChapter4Controller extends SelectorComposer<Component>{

	private static final long serialVersionUID = 1L;
	
	//wire components
	@Wire
	Grid fnList;
	
	//wire service
	@WireVariable("sidebarPageConfigPagebase")
	SidebarPageConfig pageConfig;

	...
}

• Line 11: Specify bean's name sidebarPageConfigPagebase