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.

The most common integration way is to let Spring manage class dependencies of an application. When a class "A" references a class "B" and calls B's method, we say that A depends on B. In examples of previous chapters, we create this dependency by instantiating B class in A class as follows:

public class ProfileViewController extends SelectorComposer<Component>{

	AuthenticationService authService = new AuthenticationServiceChapter8Impl();
	...
}

• ProfileViewController depends AuthenticationService.

Spring can help us manage these dependencies without instantiating dependent classes manually. In this chapter, we won't create new example applications but will make previous examples integrate with Spring.

Configuration

Maven

In order to integrate ZK application with Spring, we must add dependencies for Spring. The cglib is an optional dependency and 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 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

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 Manually

When using @WireVariable out of a composer (or a ViewModel), ZK will not wire Spring beans for you automatically. If you need to get Spring bean, you can wire them manually. The example below is to wire a Spring bean in a page initiator:

@VariableResolver(DelegatingVariableResolver.class)
public class AuthenticationInit implements Initiator {

	@WireVariable
	AuthenticationService authService;
	
	public void doInit(Page page, Map<String, Object> args) throws Exception {
		//wire service manually by calling Selectors API
		Selectors.wireVariables(page, this, Selectors.newVariableResolvers(getClass(), null));
		
		UserCredential cre = authService.getUserCredential();
		if(cre==null || cre.isAnonymous()){
			Executions.sendRedirect("/chapter8/login.zul");
			return;
		}
	}
}

• Line 9: After applying @VariableResolver and @WireVariable, use Selectors to wire Spring beans manually.