• Dependency Injection: Objects and other resources are assigned by the Spring framework instead of being created at their point of usage within the target object.
• Aspect Orientated Programming (AOP): Cross-cutting concerns, like transaction management or tracing, are externalized into specialized modules.
• Templates provide convenient, unified, API abstractions over the underlying frameworks, manage resources, and translate exceptions into a unified hierachy of runtime exceptions.
• Spring Model-View-Controller (MVC) is a framework for web applications, separating concerns, accordingly.

• Apache Tomcat 6.0
• Mortbay Jetty 6.1
• Springsource tc Server 6.0

• HSQLDB 1.8
• MySQL 5.0
• Oracle Express 10g
• PostgreSQL 8.3

Running the Sample Application

User Roles and Use Cases

User Roles

Use Cases

All Users

Administrators

Customers

Vendors

The Spring Container

BeanFactory and ApplicationContext

Container Instantiation

Manual Instantiation

ApplicationContext context = new ClassPathXmlApplicationContext(
        new String[] {"services.xml", "daos.xml"});
MyBean myBean = (MyBean) context.getBean("myBean");

Implicit Instantiation within the Spring TestContext Framework

@ContextConfiguration(locations = {
        "classpath:applicationContext-remoting.xml",
        "classpath:applicationContext-web.xml"})
public abstract class AbstractTests extends AbstractJUnit4SpringContextTests {}

Implicit Instantiation within a Web Application

ContextLoaderListener

<listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
                classpath:applicationContext-middleTier.xml
                classpath:applicationContext-dataAccess.xml
        </param-value>
</context-param>

DispatcherServlet

<servlet>
        <servlet-name>springDispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <init-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>
                        classpath:applicationContext-client-frontend.xml
                </param-value>
        </init-param>

        <load-on-startup>2</load-on-startup>
</servlet>

<servlet-mapping>
        <servlet-name>springDispatcher</servlet-name>
        <url-pattern>/app/*</url-pattern>
</servlet-mapping>

WebApplicationContext

Dependency Injection

class Car {
        Tire[] tires = new Tire[4];

        Car() {
                tires[0] = new SnowTire();
                tires[1] = new SnowTire();
                tires[2] = new SnowTire();
                tires[3] = new SnowTire();
        }
}

Injection Types

Constructor Arguments Injection

class Car {
        Tire[] tires;
        CigaretteLighter lighter;

        Car(Tire[] tires, CigaretteLighter lighter) {
                this.tires = tires;
                this.lighter = lighter;
        }
}

<bean id="tire" class="example.SnowTire" />

<util:set id="tires">
        <idref local="tire" />
        <idref local="tire" />
        <idref local="tire" />
        <idref local="tire" />
</util:set>

<bean id="lighter" class="example.CigaretteLighter" />

<bean id="car" class="example.Car">
        <constructor-arg ref="tires" />
        <constructor-arg ref="lighter" />
</bean>

<constructor-arg type="int" value="42" />
<constructor-arg type="java.lang.String" value="777" />

<constructor-arg index="0" value="42" />
<constructor-arg index="1" value="777" />

Instance Field Injection

Setter Injection

public class Car {
        CigaretteLighter lighter;

        public void setCigaretteLighter(CigaretteLighter lighter) {
                this.lighter = lighter;
        }
}

<bean class="example.Car">
        <property name="cigaretteLighter">
                <bean class="example.CigaretteLighter" />
        </property>
</bean>

Method Arguments Injection

Autowiring

<bean class="example.Car" autowire="byType" />

Bean Scopes

Bean Configuration

XML Schema-Based Configuration

The beans Schema

<?xml version="1.0" encoding="UTF-8"?>
<beans 
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:p="http://www.springframework.org/schema/p"
        xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">

        <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping"
                p:order="0" 
                p:interceptors-ref="localeChangeInterceptor">

                <property name="mappings">
                        <value>
                                /adminAddCustomer.htm=adminAddCustomerController
                        </value>
                </property>
        </bean>

        <bean id="localeChangeInterceptor" class="..." ... />
</beans>

Bean Properties

<bean id="supportedLocales" class="java.util.HashMap">
        <constructor-arg>
                <map>
                        <entry key="en" value="general.languages.english" />
                        <entry key="de" value="general.languages.german" />
        </constructor-arg>
</bean>

bean Attributes

The aop Schema

<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="
                http://www.springframework.org/schema/aop 
                http://www.springframework.org/schema/aop/spring-aop.xsd
                http://www.springframework.org/schema/beans 
                http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

The context Schema

<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="
                http://www.springframework.org/schema/beans 
                http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/context 
                http://www.springframework.org/schema/context/spring-context.xsd">
</beans>

The util Schema

<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:util="http://www.springframework.org/schema/util"
        xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/util 
        http://www.springframework.org/schema/util/spring-util.xsd">
</beans>

<bean id="supportedLocales" class="java.util.HashMap">
        <constructor-arg>
                <map>
                        <entry key="en" value="general.languages.english"></entry>
                        <entry key="de" value="general.languages.german"></entry>
                </map>
        </constructor-arg>
</bean>

<util:map id="supportedLocales">
        <entry key="en" value="general.languages.english"></entry>
        <entry key="de" value="general.languages.german"></entry>
</util:map>

The tx Schema

<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="http://www.springframework.org/schema/beans 
                http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/tx 
                http://www.springframework.org/schema/tx/spring-tx.xsd">
</beans>

<tx:advice id="readOnlyTransactionsAdvice"
        transaction-manager="transactionManager">
        <tx:attributes>
                <tx:method name="get*" read-only="true" />
                <tx:method name="*" />
        </tx:attributes>
</tx:advice>

<aop:config>
        <aop:pointcut id="serviceLayerGettersPointcut"
                expression="execution(* com.acme.sample.businessfacade.impl.*.*(..))" />
        <aop:advisor id="readOnlyTransactionsInServiceLayerAdvisor"
                advice-ref="readOnlyTransactionsAdvice" pointcut-ref="serviceLayerGettersPointcut" />
</aop:config>

Annotation-based Configuration

Configuration Related to Dependency Injection

@Autowired
public void prepareForRide(Saddle saddle, @Qualifier("rainJacket") Jacket jacket) { 
        ... 
}

<bean class="example.jackets.RainJacket">
        <qualifier value="rainJacket">
</bean>

Configuration Related to Lifecycle Events

Configuration Related to Bean Management

Configuration Related to Spring AOP

Configuration Related to Transactional Behavior

Configuration Related to the Spring TestContext Framework

Spring Security

Authentication (and Some Bits of Authorization)

<authentication-provider>
        <user-service>
                <user 
                        name="admin1" 
                        password="l33nuxRules"
                        authorities="ROLE_ADMINISTRATOR" />
                <user 
                        name="vendor1" 
                        password="l33nuxRules"
                        authorities="ROLE_VENDOR" />
        </user-service>
</authentication-provider>

<authentication-provider>
        <jdbc-user-service 
                data-source-ref="dataSource"
                authorities-by-username-query="SELECT username,authority 
                        FROM authorities WHERE username = ?"
                users-by-username-query="SELECT username,password,enabled 
                        FROM users WHERE username = ?" />
        </authentication-provider>

<http auto-config="true">
        <intercept-url 
                pattern="/**"
                access="ROLE_CUSTOMER,ROLE_VENDOR,ROLE_ADMINISTRATOR" />
        <intercept-url 
                pattern="/admin/**"
                access="ROLE_ADMINISTRATOR" />
        </http>

<c:if test="${not empty param.login_error}">
        <c:out value="${SPRING_SECURITY_LAST_EXCEPTION.message}" />
        <br />
</c:if>

<form action="j_spring_security_check">
        User name: <input type='text' name='j_username'
        value='<c:if test="${not empty param.login_error}"><c:out value="${SPRING_SECURITY_LAST_USERNAME}"/></c:if>' />
        <br />
        
        Password: <input type='password' name='j_password' />
        
        <%-- 
                <br />
                "Remember me" is optional
                <input type="checkbox" name="_spring_security_remember_me" />
                Remember password
        --%>
        
        <input value="Login" type="submit">
</form>

Authorization

<%@ taglib prefix="sec" uri="http://www.springframework.org/security/tags" %>

<sec:authorize ifAllGranted="ROLE_ADMINISTRATOR">
        <a href="<c:url value='/app/adminListProducts.htm'/>">Products</a>
</sec:authorize>

<global-method-security jsr250-annotations="enabled"
        secured-annotations="enabled" />

Spring AOP

AOP Terminology

Advices

Declaring or Implementing an Advice

Declaring an Advice in XML configuration

<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:aop="http://www.springframework.org/schema/aop" 
        xsi:schemaLocation="
                http://www.springframework.org/schema/aop
                http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
        ...
        <aop:config>
                <aop:aspect ref="someBean">
                        <aop:around method="doProfiling" pointcut="execution(* *(..))" />
                </aop:aspect>
        </aop:config>
        ...
</beans>

Declaring an Advice Using AspectJ Annotations

@Aspect
public class ProfilingAdvice {

        @Around("execution(* *(..))")
        public void doProfiling() {
                ...
        }
}

<aop:aspectj-autoproxy />

Implementing an Advice by Implementing a Specific Interface

public class ProfilingAdvice implements MethodInterceptor {
 
        public Object invoke(MethodInvocation method) throws Throwable {
                ...
        }
}

Types of Advices

Before Advice

public interface MethodBeforeAdvice extends BeforeAdvice {
        void before(Method method, Object[] args, Object target) throws Throwable;
}

After Returning Advice

public interface AfterReturningAdvice extends AfterAdvice {
        void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable;
}

After Throwing Advice

public interface ThrowsAdvice extends AfterAdvice {
}

void afterThrowing([Method, args, target], ThrowableSubclass);

After Advice

public interface AfterAdvice extends Advice {
}

Around Advice

public interface org.aopalliance.intercept.MethodInterceptor extends org.aopalliance.intercept.Interceptor {
        Object invoke(org.aopalliance.intercept.MethodInvocation arg0) throws Throwable;
}

@Aspect
public class I18nAdvice {
        ...

        @Around("execution(org.springframework.web.servlet.ModelAndView *.*(..))")
        public ModelAndView addSupportedLocales(ProceedingJoinPoint joinPoint)
                        throws Throwable {
                ModelAndView mav = (ModelAndView) joinPoint.proceed();

                mav.addObject("supportedLocales", supportedLocales);

                return mav;
        }
}

Pointcuts

Pointcut Expressions

execution(
        modifiers-pattern? 
        ret-type-pattern 
        declaring-type-pattern? 
        name-pattern(param-pattern)
        throws-pattern?
)

execution(* *(..))

execution(org.springframework.web.servlet.ModelAndView *.*(..))

Declaring or Implementing a Pointcut

Declaring a Pointcut in XML Configuration

<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:aop="http://www.springframework.org/schema/aop" 
        xsi:schemaLocation="
                http://www.springframework.org/schema/aop
                http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
        ...
        <aop:config>
                <aop:aspect ref="someBean">
                        <aop:around method="doProfiling" pointcut="execution(* *(..))" />
                </aop:aspect>
        </aop:config>
        ...
</beans>

<aop:config>
        <aop:aspect ref="someBean">
                <aop:pointcut expression="execution(* *(..))" id="myPointcut"/>
                <aop:around method="doProfiling" pointcut-ref="myPointcut" />
        </aop:aspect>
</aop:config>

Declaring a Pointcut Using AspectJ Annotations

@Pointcut("execution(* *(..))")
public void foo() {}

@Before("foo()")
public void bar() {
        ...
}

Pointcut Implementations

boolean matches(Method method, Class targetClass, Object[] args);

Advisors

<!--
        Add read-only transactions to all get* methods in the service layer.
—>
<tx:advice id="readOnlyTransactionsAdvice"
        transaction-manager="transactionManager">
        <tx:attributes>
                <tx:method name="get*" read-only="true" />
                <tx:method name="*" />
        </tx:attributes>
</tx:advice>

<aop:config>
        <aop:pointcut id="serviceLayerGettersPointcut"
                expression="execution(* com.acme.sample.businessfacade.impl.*.*(..))" />
        <aop:advisor id="readOnlyTransactionsInServiceLayerAdvisor"
                advice-ref="readOnlyTransactionsAdvice" pointcut-ref="serviceLayerGettersPointcut" />
</aop:config>

AOP and Dependency Injection

@Aspect
public class I18nAdvice {
        ...

        @Around("execution(org.springframework.web.servlet.ModelAndView *.*(..))")
        public ModelAndView addSupportedLocales(ProceedingJoinPoint joinPoint)
                        throws Throwable {
                ...
        }
}

public class AdminAddCustomerControllerTests extends AbstractTests {
        @Autowired
        @Resource(name="adminAddCustomerController")
        private AdminAddCustomer controller;
...

AOP Use Cases in the Sample Application

Add Transactional Behavior to Certain Methods

Add a List of Available Languages To Each MVC View

@Aspect
public class I18nAdvice {
        private Map<String, String> supportedLocales;

        @Resource(name="supportedLocales")
        public void setSupportedLocales(Map<String, String> locales) {
                this.supportedLocales = locales;
        }

        @Around("execution(org.springframework.web.servlet.ModelAndView *.*(..))")
        public ModelAndView addSupportedLocales(ProceedingJoinPoint joinPoint)
                        throws Throwable {
                ModelAndView mav = (ModelAndView) joinPoint.proceed();

                mav.addObject("supportedLocales", supportedLocales);

                return mav;
        }
}

Notify Vendor on Order Placement

<util:list id="vendorsToNotifyList">
        <value>vendor1</value>
        <value>John Doe</value>
        <value>Big Bill Broonzey</value>
</util:list>

<bean id="vendorNotifierPointcut"
        class="com.acme.sample.businessfacade.aop.VendorNotifierPointcutImpl"
        p:vendorsToNotifyNames-ref="vendorsToNotifyList"></bean>

public boolean matches(Method method, Class targetClass, Object[] args) {
        boolean matches = matches(method, targetClass);
        
        if (matches) {
                matches = false;
                
                Order order = (Order) args[0];
                String vendorName = order.getVendor().getName();
                
                for (String vendorToNotifyName : vendorsToNotifyNames) {
                        if (vendorName.equals(vendorToNotifyName)) {
                                matches = true;
                                break;
                        }
                }
        }
        
        return matches;
}

@Override
public void afterReturning(Object returnValue, Method method,
                Object[] args, Object target) throws Throwable {
        Order order = (Order) args[0];
        vendorRmiConnector.notifyAboutNewOrder(order);
}

Data Persistence

DataSource Setup

<?xml version="1.0" encoding="UTF-8"?>
<beans 
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
         xmlns:p="http://www.springframework.org/schema/p"
        xsi:schemaLocation="
                        http://www.springframework.org/schema/beans 
                        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
                        http://www.springframework.org/schema/context 
                        http://www.springframework.org/schema/context/spring-context-2.5.xsd">
        <context:property-placeholder location="classpath:jdbc.properties" />

        <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
                destroy-method="close"
                p:driverClassName="${jdbc.driverClassName}"
                p:url="${jdbc.url}" p:username="${jdbc.username}" p:password="${jdbc.password}" />
</beans>

jdbc.driverClassName=org.hsqldb.jdbcDriver
jdbc.url=jdbc:hsqldb:file:testdb
jdbc.username=sa
jdbc.password=

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
        <property name="jndiName" value="java:comp/env/jdbc/DefaultDS"/>
</bean>

The Sample Application's Data Access Layer

Domain Model

Data Access Layer

public interface GenericDAO<T extends AbstractIdentifyable> {
        T get(int id);

        List<T> get(String filterCriteria);

        List get(String query, Object[] params);

        List<T> get();

        void insert(T object);

        void update(T object);

        void remove(T object);
}

public interface OrderDAO extends GenericDAO<Order> {
        /**
         * Return a list of orders for the given customer.
         */
        List<Order> get(Customer customer);

        /**
         * Return a list of orders for the given vendor.
         */
        List<Order> get(Vendor vendor);
}

ORM with Hibernate

SessionFactory Setup

<?xml version="1.0" encoding="UTF-8"?>
<beans 
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
         xmlns:p="http://www.springframework.org/schema/p"
        xsi:schemaLocation="
                http://www.springframework.org/schema/beans 
                http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
                http://www.springframework.org/schema/context 
                http://www.springframework.org/schema/context/spring-context-2.5.xsd">
        
        <context:property-placeholder location="classpath:jdbc.properties" />

        <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
                destroy-method="close" 
                p:driverClassName="${jdbc.driverClassName}"
                p:url="${jdbc.url}" 
                p:username="${jdbc.username}"
                p:password="${jdbc.password}" />

        <bean id="sessionFactory"
                class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"
                p:dataSource-ref="dataSource" 
                p:mappingResources="article.hbm.xml">
                <property name="hibernateProperties">
                        <props>
                                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
                                <prop key="hibernate.generate_statistics">${hibernate.generate_statistics}
                                </prop>
                                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}
                                </prop>
                        </props>
                </property>
                <property name="eventListeners">
                        <map>
                                <entry key="merge">
                                        <bean
                class="org.springframework.orm.hibernate3.support.IdTransferringMergeEventListener" />
                                </entry>
                        </map>
                </property>
        </bean>
</beans>

Hibernate Mappings

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"
                "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
        <class name="com.acme.sample.domain.LineItem" table="line_items" />
        <class name="com.acme.sample.domain.Order" table="orders" />
        ...
</hibernate-mapping>

id Element

<hibernate-mapping>
        <class name="com.acme.sample.domain.LineItem" table="line_items">
                <id name="id" column="id">
                        <generator class="native" />
                </id>
                ...
        </class>
        ...
</hibernate-mapping>

property Element

<hibernate-mapping> 
        <class name="com.acme.sample.domain.User" table="users">
                ...
                <property name="name" column="user_name" length="50"
                        not-null="true" unique="true" />
        </class>
        ...
</hibernate-mapping>

Relations

One-to-one Relation

class Person {
        Address address;

        Address getAddress { return address; }
        setAddress(Address address) { this.address = address; }
}

<class name="com.acme.sample.domain.Address">
        <id name="id">
                <generator class="native" />
        </id>
        <property name="street" />
        <property name="city" />
</class>

<class name="com.acme.sample.domain.Person">
        <id name="id">
                <generator class="foreign">
                        <param name="property">address</param>
                </generator>
        </id>
        <property name="name" />
        <one-to-one name="address" constrained="true" />
</class>

<class name="com.acme.sample.domain.Person">
        <id name="id">
                <generator class="native" />
        </id>
        <property name="name" />
        <many-to-one name="address" column="person_id" unique="true" />
</class>

Optional, Bidirectional, One-to-one Relation

Collection Mappings

One-to-many Relations

class User {
        private Set<Authority> authorities;

        public Set<Authority> getAuthorities() { return authorities }
        public void setAuthorities(Set<Authority> authorities {
                this.authorities = authorities;
        }
}

<class name="com.acme.sample.domain.User" table="users">
        ...
        <set name="authorities" table="authorities">
                <key column="user_id" />
                <one-to-many class="com.acme.sample.domain.Authority" />
        </set>
        ...
</class>

Many-to-one Relations

<class name="com.acme.sample.domain.LineItem" table="line_items">
        ...
        <many-to-one name="product" column="product_id"
                class="com.acme.sample.domain.Product" />
        ...
</class>

Many-to-many Relations

<class name="com.acme.sample.domain.Product" table="products">
        ...
        <set name="vendors" table="vendors_products">
                <key column="product_id" />
                <many-to-many class="com.acme.sample.domain.Vendor"
                        column="vendor_id" />
        </set>
        ...
</class>

Cascading Operations

Hibernate: update orders set customer_id=null where customer_id=?

Hibernate: update line_items set order_id=null where order_id=?
Hibernate: delete from line_items where id=?
Hibernate: delete from orders where id=?
Hibernate: delete from business_users where id=?

Additional DDL Commands

<hibernate-mapping>
        ...

        <database-object>
                <create>
                        ALTER TABLE products
                        ADD CONSTRAINT products_check_price_gt_0 
                        CHECK (price > 0::double precision);
                </create>
                <drop>
                        ALTER TABLE products 
                        DROP CONSTRAINT products_check_price_gt_0;
                </drop>
                <dialect-scope name="org.hibernate.dialect.PostgreSQLDialect" />
        </database-object>
</hibernate-mapping>

Hibernate ORM and Inheritance Mapping

<class name="com.acme.sample.domain.BusinessUser" table="BusinessUsers">
        <id name="id">
                <generator class="native" />
        </id>

        <property name="name" column="name" 
                length="255" not-null="true"
                index="businessUserName" />
        <property name="springSecurityUserID" 
                column="springSecurityUserID" not-null="true" 
                index="businessUserSpringSecurityUserID" />
        
        <discriminator column="userType" type="string" length="10" />
        
        <subclass name="com.acme.sample.domain.Vendor"
                discriminator-value="VENDOR">
                <set name="orders" table="Orders">
                        <key column="vendorID" />
                        <one-to-many class="com.acme.sample.domain.Order" />
                </set>
                <set name="products" table="VendorsProducts">
                        <key column="vendorID" />
                        <many-to-many class="com.acme.sample.domain.Product"
                                column="productID" />
                </set>
        </subclass>
        <subclass name="com.acme.sample.domain.Customer"
                discriminator-value="CUSTOMER">
                <set name="orders" table="Orders">
                        <key column="customerID" />
                        <one-to-many class="com.acme.sample.domain.Order" />
                </set>
        </subclass>
</class>

Hibernate DAO Implementations

private HibernateTemplate hibernateTemplate;

@Autowired
public void setSessionFactory(SessionFactory sessionFactory) {
        this.hibernateTemplate = new HibernateTemplate(sessionFactory);
}

@Override
public List get(String query, Object[] params) {
        return this.hibernateTemplate.find(query, params);
}

@Override
public T get(int id) {
        return (T) this.hibernateTemplate.get(this.tClass, id);
}

@Override
public List<T> get(String filterCriteria) {
        String queryString = "from " + this.getEntityName()
                        + " where name like ?" + orderBy;

        return (List<T>) this.hibernateTemplate.find(queryString,
                        filterCriteria);
}

@Override
public List<T> get() {
        String queryString = "from " + this.getEntityName() + orderBy;

        return (List<T>) this.hibernateTemplate.find(queryString);
}

@Override
public void insert(T T) {
        this.hibernateTemplate.persist(T);
}

@Override
public void remove(T T) {
        this.hibernateTemplate.delete(T);
}

@Override
public void update(T T) {
        this.hibernateTemplate.merge(T);
}

Generic Data Access Objects

public abstract class GenericDaoImpl
        <T extends AbstractIdentifyable>
        implements GenericDAO<T> {
        // implementation code ...
}

public class CustomerDaoImpl 
        extends GenericDaoImpl<Customer> 
        implements CustomerDAO {
        // inherited methods, which don't need to be overridden ...
}

this.tClass = (Class<T>) ((ParameterizedType) getClass()
        .getGenericSuperclass()).getActualTypeArguments()[0];

JDBC

Spring Data Access Exception Hierarchy

Central JDBC Worker Classes

<bean id="businessUserDAO" class="com.acme.sample.dao.impl.jdbc.JdbcTemplateBusinessUserDaoImpl" />

<bean id="businessUserDAO" class="com.acme.sample.dao.impl.jdbc.StoredProcedureBusinessUserDaoImpl" />

JdbcTemplate

public class JdbcTemplateBusinessUserDaoImpl implements BusinessUserDAO {
        private JdbcTemplate jdbcTemplate;

        @Autowired
        public void setDataSource(DataSource dataSource) {
                this.jdbcTemplate = new JdbcTemplate(dataSource);
        }
        
        ...
}

@Override
@SuppressWarnings("unchecked")
public List<BusinessUserWrapper> getCandidatesForLogin(int loginID) {
        String query = "select id, name, security_user_id"
                        + " from business_users where security_user_id <> ?"
                        + " or security_user_id is null";

        return (List<BusinessUserWrapper>) this.jdbcTemplate.query(
                        query,
                        new Object[] { loginID }, 
                        new RowMapper() {

                                @Override
                                public BusinessUserWrapper mapRow(ResultSet rs, int rowNum)
                                                throws SQLException {
                                        BusinessUserWrapper user = new BusinessUserWrapper();
                                        user.setId(rs.getInt("id"));
                                        user.setName(rs.getString("name"));
                                        user.setSpringSecurityID(rs.getInt("security_user_id"));

                                        return user;
                                }
                        });
}

SimpleJdbcTemplate

public class SimpleJdbcTemplateBusinessUserDaoImpl implements BusinessUserDAO {
        private SimpleJdbcTemplate simpleJdbcTemplate;

        @Autowired
        public void setDataSource(DataSource dataSource) {
                this.simpleJdbcTemplate = new SimpleJdbcTemplate(dataSource);
        }

        @Override
        public List<BusinessUserWrapper> getCandidatesForLogin(int loginID) {
                String query = "select id, name, security_user_id"
                                + " from business_users" + " where security_user_id <> ?"
                                + " or security_user_id is null";

                return this.simpleJdbcTemplate.query(
                        query,
                        new BusinessUserRowMapper(), 
                        loginID);
        }
}

public class BusinessUserRowMapper implements
                ParameterizedRowMapper<BusinessUserWrapper> {

        @Override
        public BusinessUserWrapper mapRow(ResultSet rs, int rowNum)
                        throws SQLException {
                ...

NamedParameterJdbcTemplate

      public List<BusinessUserWrapper> getCandidatesForLogin(int loginID) {
                String query = "select id, name, security_user_id"
                                + " from business_users" + " where security_user_id <> :id"
                                + " or security_user_id is null";
                
                Map<String, Object> params = new HashMap<String, Object>();
                params.put("id", loginID);

                return (List<BusinessUserWrapper>) this.jdbcTemplate.query(query,
                                params, new BusinessUserRowMapper());
        }

StoredProcedure

<database-object>
        <create>CREATE TYPE business_user_wrapper as (
        id integer, name character varying(255), security_user_id integer)</create>
        <drop>DROP TYPE business_user_wrapper</drop>
        <dialect-scope name="org.hibernate.dialect.PostgreSQLDialect" />
</database-object>
<database-object>
        <create>CREATE FUNCTION get_candidates_for_login(login_id integer) 
                RETURNS SETOF business_user_wrapper 
                AS
                        'select id, name, security_user_id 
                        from business_users 
                        where security_user_id &lt;&gt; $1 
                        or security_user_id is null'
                LANGUAGE 'sql' VOLATILE;</create>
        <drop>DROP FUNCTION get_candidates_for_login(integer)</drop>
        <dialect-scope name="org.hibernate.dialect.PostgreSQLDialect" />
</database-object>

public class StoredProcedureBusinessUserDaoImpl extends StoredProcedure
                implements BusinessUserDAO {
        private static final String STORED_PROCEDURE_NAME = "get_candidates_for_login";

        private static final String STORED_PROCEDURE_PARAM1 = "login_id";

        private static final String RESULT_SET_NAME = "businessUsers";

        @Autowired
        public void setDataSource(DataSource dataSource) {
                super.setDataSource(dataSource);
        }

        public StoredProcedureBusinessUserDaoImpl() {
                this.setSql(STORED_PROCEDURE_NAME);
                // input parameter
                this.declareParameter(new SqlParameter(STORED_PROCEDURE_PARAM1,
                                Types.INTEGER));
                // output (parameter)
                this.declareParameter(new SqlReturnResultSet(RESULT_SET_NAME,
                                new BusinessUserRowMapper()));
                // this call does have a return value
                this.setFunction(true);
        }

        @SuppressWarnings("unchecked")
        @Override
        public List<BusinessUserWrapper> getCandidatesForLogin(int loginID) {
                Map<String, Object> params = new HashMap<String, Object>();
                params.put(STORED_PROCEDURE_PARAM1, loginID);

                Map result = this.execute(params);

                return (List<BusinessUserWrapper>) result.get(RESULT_SET_NAME);
        }
}

Transaction Management

Transaction Definitions

Propagation

Isolation

Other Transaction Settings

Transaction Managers

Setting Up a Transaction Manager

<bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager"
        p:sessionFactory-ref="sessionFactory" />

<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

        <tx:jta-transaction-manager />
        ...

Declarative Transaction Management

tx:advice XML Configuration

<tx:advice id="readOnlyTransactionsAdvice"
        transaction-manager="transactionManager">
        <tx:attributes>
                <tx:method name="get*" read-only="true" />
                <tx:method name="*" />
        </tx:attributes>
</tx:advice>

<aop:config>
        <aop:pointcut id="serviceLayerGettersPointcut"
                expression="execution(* com.acme.sample.businessfacade.impl.*.*(..))" />
        <aop:advisor id="readOnlyTransactionsInServiceLayerAdvisor" advice-ref="readOnlyTransactionsAdvice"
                pointcut-ref="serviceLayerGettersPointcut" />
</aop:config>

@Test
public void testReadOnlyGetMethods() {
        assertTrue("AdminFacade is not proxied by AOP.", 
                AopUtils.isAopProxy(adminFacade));
        assertTrue("AdminFacade is not a JDK Dynamic Proxy.", 
                AopUtils.isJdkDynamicProxy(adminFacade));

        Pointcut pointcut = (Pointcut) applicationContext
                .getBean("serviceLayerGettersPointcut");
        assertTrue(
                "Pointcut serviceLayerGettersPointcut cannot be applied to AdminFacade.",
                AopUtils.canApply(pointcut, AopUtils.getTargetClass(adminFacade)));

        Advisor advisor = (Advisor) applicationContext
                .getBean("readOnlyTransactionsInServiceLayerAdvisor");
        assertTrue(
                "Advisor readOnlyTransactionsInServiceLayerAdvisor cannot be applied to AdminFacade.",
                AopUtils.canApply(advisor, AopUtils.getTargetClass(adminFacade)));
}

@Transactional Annotation

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {
        Propagation propagation() default Propagation.REQUIRED;
        Isolation isolation() default Isolation.DEFAULT;
        int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
        boolean readOnly() default false;
        Class<? extends Throwable>[] rollbackFor() default {};
        String[] rollbackForClassName() default {};
        Class<? extends Throwable>[] noRollbackFor() default {};
        String[] noRollbackForClassName() default {};
}

Spring MVC

Controllers

AbstractController

public class CustomerListOrdersController extends AbstractController {
        // ...

        @Override
        protected ModelAndView handleRequestInternal(HttpServletRequest request,
                        HttpServletResponse response) throws Exception {
                Map<String, Object> model = new HashMap<String, Object>();
                model.put("orders", 
                                facade.getCustomer(
                                request.getUserPrincipal().getName()
                                ).getOrders());

                return new ModelAndView("customerListOrders", model);
        }
}

SimpleFormController

public class AdminAddVendorController extends SimpleFormController {
        // ...

        public AdminAddVendorController() {
                // views can then access the "form backing object" 
                // by the EL variable $vendor
                setCommandName("vendor");
                
                // location of the form view to display
                setFormView("adminAddVendor");
                
                // what to display after the form data
                // has been saved
                setSuccessView("redirect:adminListVendors.htm");
        }

        // the model, accessible  
        // by the variable $vendor (in this case)
        @Override
        protected Object formBackingObject(HttpServletRequest request)
                        throws Exception {
                return new Vendor(); // a simple entity bean
        }

        // called after a form submit
        @Override
        protected void onBindAndValidate(HttpServletRequest request,
                        Object command, BindException errors) throws Exception {
                // this form has only one editable field,
                // so validation is simple
                ValidationUtils.rejectIfEmpty(errors, "name", "validation.general.nameMustNotBeEmpty",
                                "Name must not be empty.");
        }

        // called after a form submit,
        // if no BindExceptions were raised 
        @Override
        protected void doSubmitAction(Object command) throws Exception {
                // the command object
                // (or form backing object)
                // that the user has edited.
                Vendor vendor = (Vendor) command;
                
                // do some business action
                facade.addVendor(vendor);
                
                // the underlying SimpleFormController instance
                // will now forward to our defined successView
        }
}

AbstractWizardFormController

public class CustomerAddOrderController extends AbstractWizardFormController {
        @Autowired
        private CustomerFacade facade;

        public CustomerAddOrderController() {
                setCommandName("orderForm");

                // specify a number of pages
                setPages(new String[] { "customerAddOrderSelectVendor",
                                "customerAddOrderSelectProducts" });
        }

        @Override
        protected int getTargetPage(HttpServletRequest request, Object command,
                        Errors errors, int currentPage) {
                AddOrderForm form = (AddOrderForm) command;
                if (currentPage == 0 && form.getVendor().getId() > 0) {
                        // a vendor has been selected;
                        // proceed with the "vendor's products" page
                        return 1;
                }
                else if (currentPage == 1) {
                        return 1;
                }

                return 0;
        }

        @Override
        protected void onBindAndValidate(HttpServletRequest request,
                        Object command, BindException errors, int page) throws Exception {
                // synchronize form properties
                AddOrderForm form = (AddOrderForm) command;

                switch (page) {
                case 0: // "select vendor" page
                        // retrieve the vendor that has been selected in form 0
                        Vendor vendor = facade.getVendor(
                                form.getVendor().getId());
                        form.setVendor(vendor);

                        // provide the form with this vendor's products
                        form.setVendorProducts(
                                vendor.getProductsAsList());
                        break;
                case 1: // "select products" page
                        // apply the customer's product selection
                        // ... (edit the form backing bean)
                }
        }

        @Override
        protected Object formBackingObject(HttpServletRequest request)
                        throws Exception {
                AddOrderForm form = new AddOrderForm();
                form.setVendors(facade.getVendors());

                return form;
        }

        @Override
        protected ModelAndView processFinish(HttpServletRequest request,
                        HttpServletResponse response, Object command, BindException errors)
                        throws Exception {

                AddOrderForm form = (AddOrderForm) command;
                form.setCustomer(getCurrentCustomer(request));
                facade.addOrder(form);

                return new ModelAndView("customerAddOrderFinish");
        }
}

Other Controllers

Mapping Controllers to URLs

<bean name="/index.htm" class="com.acme.sample.web.controllers.MainController" />

@RequestMapping("/index.htm")
public class MainController extends AbstractController { ...

      <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping" p:order="0">
                <property name="mappings">
                        <value>
                                /adminAddCustomer.htm=adminAddCustomerController
                        </value>
                </property>
        </bean>

      <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping"
                p:order="0">
                ...
        </bean>

        <!--
                The following two handler mappings only need to be explicitly declared
                when a non-default handler mapping (like SimpleUrlHandlerMapping
                above) is declared.
        —>
        <bean
                class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"
                p:order="1" />
        <bean
                class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"
                p:order="2" />

Views

Passing Model Data to Views

Map model = new HashMap();
model.put("key1", "hello world");

MyHelloWorld myHelloWorld = new MyHelloWorld();
myHelloWorld.setMessage("hello world");
model.put("key2", "hello back");

$key1
$key2.message

public class OrderExcelView extends AbstractExcelView {

        @Override
        protected void buildExcelDocument(Map model, HSSFWorkbook workbook,
                        HttpServletRequest request, HttpServletResponse response)
                        throws Exception {
                Order order = (Order) model.get("order");
                // ...

View Technologies

JSP and JSTL Views; Spring's Form Tag Library

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>

<form:form commandName="product">
        Name:
        <form:input path="name" />
        <form:errors path="name" cssClass="errors" />
        <br />

        Price:
        <form:input path="price" />
        <form:errors path="price" cssClass="errors" />

        &nbsp;
        <input type="submit" value="Save" />
        <br />
</form:form>

<form:checkboxes items="${products.allProducts}" path="vendorProductIDs"
        itemLabel="name" itemValue="id"
        element="div" />

Excel Views

protected void buildExcelDocument(Map model, HSSFWorkbook workbook,
                HttpServletRequest request, HttpServletResponse response)
                throws Exception {
        Order order = (Order) model.get("order");

        HSSFSheet sheet = workbook.createSheet("Order");
        
        int row = 0;
        for (LineItem item : order.getLineItems()) {
                HSSFCell cell = getCell(sheet, row, 0);
                setText(cell, String.valueOf(item.getCount()));
                
                cell = getCell(sheet, row, 1);
                setText(cell, String.valueOf(item.getProduct().getName()));
                
                cell = getCell(sheet, row, 2);
                setText(cell, String.valueOf(item.getProduct().getPrice()));
                
                row++;
        }
}

Resolving Views

<bean p:order="1"
        class="org.springframework.web.servlet.view.InternalResourceViewResolver"
        p:viewClass="org.springframework.web.servlet.view.JstlView" 
        p:prefix="/WEB-INF/views/"
        p:suffix=".jsp" />

<bean p:order="0" 
        class="org.springframework.web.servlet.view.ResourceBundleViewResolver"
        p:basename="views" />

index.class=org.springframework.web.servlet.view.JstlView
index.url=/WEB-INF/jsp/index.jsp

Internationalization

MessageSource Implementation

validation.general.nameMustNotBeEmpty='Name' must not be empty.
views.includes.navi.youAreLoggedInAs=You are logged in as

<entries>
        <entry key="validation.general.nameMustNotBeEmpty">'Name' must not be empty.</entry>
        <entry key="views.includes.navi.youAreLoggedInAs">You are logged in as</entry>
</entries>

Retrieving Messages

<bean id="messageSource" 
        p:cacheSeconds="3" p:defaultEncoding="UTF-8"
        p:basenames="/WEB-INF/classes/messages"
        class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
</bean>

<%@ taglib uri="http://www.springframework.org/tags" prefix="spring"%>
<div><spring:message code="views.includes.navi.youAreLoggedInAs" /></div> ...

ValidationUtils.rejectIfEmpty(errors, "name",
        "validation.general.nameMustNotBeEmpty");

Resolving and Changing Locales

<bean id="localeResolver"
        class="org.springframework.web.servlet.i18n.CookieLocaleResolver" />

<bean id="localeChangeInterceptor"
        class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor" />

<bean
        class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"
        p:interceptors-ref="localeChangeInterceptor" />

Providing a List of Selectable Locales

@Aspect
public class I18nAdvice {
        private Map<String, String> supportedLocales;

        /**
         * Specify which locales are supported by the application.
         * @param locales Key: Locale code (i.e., "en", or "en_US").<br>
         * Value: Message code for the display language (i.e., "languages.english",
         * or "languages.german").
         */
        @Required
        public void setSupportedLocales(Map<String, String> locales) {
                this.supportedLocales = locales;
        }

        /**
         * Add a Map of supported locales to each ModelAndView.
         */
        @Around("execution(org.springframework.web.servlet.ModelAndView *.*(..))")
        public ModelAndView addSupportedLocales(ProceedingJoinPoint joinPoint)
                        throws Throwable {
                ModelAndView mav = (ModelAndView) joinPoint.proceed();

                mav.addObject("supportedLocales", supportedLocales);

                return mav;
        }
}

<bean id="i18nAdvice" class="com.acme.sample.web.controllers.advices.I18nAdvice">
        <property name="supportedLocales">
                <map>
                        <entry key="en" value="general.languages.english"></entry>
                        <entry key="de" value="general.languages.german"></entry>
                </map>
        </property>
</bean>

<%@ taglib prefix='c' uri='http://java.sun.com/jstl/core_rt'%>
<%@ taglib uri="http://www.springframework.org/tags" prefix="spring"%>
...
<c:forEach
        items="${supportedLocales}" 
        var="locale">
        <a href="?locale=${locale.key}">
                <spring:message code="${locale.value}" />
        </a>&nbsp;
</c:forEach>

Request Character Encoding

<filter>
        <filter-name>encoding-filter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
                <param-name>encoding</param-name>
                <param-value>UTF-8</param-value>
        </init-param>
</filter>
<filter-mapping>
        <filter-name>encoding-filter</filter-name>
        <url-pattern>/*</url-pattern>
</filter-mapping>

Integration

Remoting

Remote Method Invocation (RMI)

Server-side Configuration

public interface RmiConnector {
        /**
         * Notify the vendor that the given order had been placed in the shop application.
         * @throws RemoteException
         */
        void notifyAboutNewOrder(Order order);
        
        /**
         * Acknowledge that the order with the given ID has been received.
         */
        boolean isOrderNotificationReceived(long orderID);
}

<bean class="org.springframework.remoting.rmi.RmiServiceExporter"
        p:serviceName="VendorRmiConnector" 
        p:serviceInterface="com.vendor1.erp1.RmiConnector"
        p:registryPort="1199">
        <property name="service">
                <bean class="com.vendor1.erp.rmi.RmiConnectorImpl"></bean>
        </property>
</bean>

Client-side Configuration

<bean id="vendorRmiConnector" 
        class="org.springframework.remoting.rmi.RmiProxyFactoryBean"
        p:serviceUrl="rmi://localhost:1199/VendorRmiConnector"
        p:serviceInterface="com.vendor1.erp.rmi.RmiConnector" />

Standalone JAX-WS Web Service

Server-side Configuration

@WebService(serviceName = "VendorJaxWsService")
@SOAPBinding(parameterStyle = ParameterStyle.BARE)
public interface JaxWsConnector {
        @WebMethod
        void notifyAboutNewOrder(Order order);

        @WebMethod
        boolean isOrderNotificationReceived(long orderID);
}

<bean id="jaxWsServiceExporter"
        class="org.springframework.remoting.jaxws.SimpleJaxWsServiceExporter"
        p:baseAddress="http://localhost:9999/" />

Client-side Configuration

<bean id="vendorJaxWsConnector" 
        class="org.springframework.remoting.jaxws.JaxWsPortProxyFactoryBean"
        depends-on="jaxWsServiceExporter"
        p:serviceInterface="com.vendor1.erp.jaxws.JaxWsConnector"
        p:wsdlDocumentUrl="http://localhost:9999/VendorJaxWsService?WSDL"
        p:namespaceUri="http://jaxws.erp.vendor1.com/"
        p:serviceName="VendorJaxWsService" 
        p:portName="JaxWebServiceEndpointPort" />

JAX-WS Web Service via Apache CXF

Server-side Configuration

<servlet>
        <servlet-name>jaxws</servlet-name>
        <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
        <servlet-name>jaxws</servlet-name>
        <url-pattern>/jaxws/*</url-pattern>
</servlet-mapping>

<web-app>
        <context-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>
                        classpath:applicationContexts/vendor/appContext-remotingServicesHTTP.xml
                        ...
                </param-value>
        </context-param>
        ...

        <listener>
                <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
        </listener>
        ...
</web-app>

<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:p="http://www.springframework.org/schema/p" 
        xmlns:jaxws="http://cxf.apache.org/jaxws"
        xsi:schemaLocation="
                http://www.springframework.org/schema/beans 
                http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/context 
                http://www.springframework.org/schema/context/spring-context-2.5.xsd
                http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">

        <bean id="vendorJaxWsService" class="com.vendor1.erp.remoting.jaxws.JaxWsServiceImpl" />
        <jaxws:endpoint implementor="#vendorJaxWsService" address="/VendorService" />
</beans>

Client-side Configuration

<jaxws:client id="vendorJaxWsConnector"
        serviceClass="com.vendor1.erp.remoting.jaxws.JaxWsService" 
        address="http://localhost:${ports.http}/springarticle/jaxws/VendorService" />

@Resource(name = "vendorJaxWsConnector")
JaxWsService jaxWsConnector;

Hessian

Server-side configuration

public interface HessianConnector {
        void notifyAboutNewOrder(long orderID);
        boolean isOrderNotificationReceived(long orderID);
}

<bean id="hessianConnectorImpl" class="com.vendor1.erp.hessian.HessianConnectorImpl"></bean>

<bean name="hessianExporter"
        class="org.springframework.remoting.caucho.HessianServiceExporter"
        p:service-ref="hessianConnectorImpl" p:serviceInterface="com.vendor1.erp.hessian.HessianConnector" />

<servlet>
        <servlet-name>hessianExporter</servlet-name>
        <servlet-class>org.springframework.web.context.support.HttpRequestHandlerServlet</servlet-class>
</servlet>

<servlet-mapping>
        <servlet-name>hessianExporter</servlet-name>
        <url-pattern>/hessianExporter/HessianConnector</url-pattern>
</servlet-mapping>

Client-side configuration

<bean id="vendorHessianConnector"
        class="org.springframework.remoting.caucho.HessianProxyFactoryBean"
        p:serviceUrl="http://localhost:8080/springarticle/hessianExporter/HessianConnector"
        p:serviceInterface="com.vendor1.erp.hessian.HessianConnector" />

Spring HTTP Invokers

Server-side configuration

public interface HttpInvokerService  {
        void notifyAboutNewOrder(Order order);
        boolean isOrderNotificationReceived(long orderID);
}

Client-side configuration

Java Message Service (JMS)

Consuming Messages

<amq:broker useJmx="false" persistent="false">
        <amq:transportConnectors>
                <amq:transportConnector uri="tcp://localhost:0" />
        </amq:transportConnectors>
</amq:broker>

<amq:connectionFactory id="jmsFactory" brokerURL="vm://localhost" />

<amq:queue id="destinationQueue" physicalName="com.vendor1.erp.jms.Queue1" />

<bean id="connectionFactory"
        class="org.springframework.jms.connection.SingleConnectionFactory"
        p:targetConnectionFactory-ref="jmsFactory" />

<bean id="vendor1JmsConsumer" class="com.vendor1.erp.jms.JmsConsumer" />

<bean id="jmsListenerContainer"
        class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="destination" ref="destinationQueue" />
        <property name="messageListener" ref="vendor1JmsConsumer" />
</bean>

public class JmsConsumer implements SessionAwareMessageListener {

        @Override
        public void onMessage(Message message, Session session) throws JMSException {
                Order order = (Order) ((ObjectMessage) message).getObject();

                if (message.getJMSReplyTo() != null) {
                        TextMessage replyToMessage = new ActiveMQTextMessage();
                        replyToMessage.setJMSCorrelationID(message.getJMSCorrelationID());
                        replyToMessage.setText("there needs to be some text");
                        
                        session.createProducer(message.getJMSReplyTo())
                                        .send(replyToMessage);
                }
        }
}

Producing Messages

<import resource="../vendor/appContext-jms.xml"/>

<bean id="producerJmsTemplate" class="org.springframework.jms.core.JmsTemplate"
        p:connectionFactory-ref="connectionFactory" />

<bean id="vendorJmsProducer"
        class="com.acme.sample.businessfacade.interceptors.orderinserted.JmsVendorNotifier"
        p:destinationName="com.vendor1.erp.jms.Queue1" p:jmsTemplate-ref="producerJmsTemplate" />

Connection replyToConnection = jmsTemplate.getConnectionFactory().createConnection();
replyToConnection.start();
Session replyToSession = replyToConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
final Destination replyToDestination = replyToSession.createTemporaryQueue();
MessageConsumer replyToConsumer = replyToSession.createConsumer(replyToDestination);
replyToConsumer.setMessageListener(this);

jmsTemplate.send(destinationName, new MessageCreator() {

        @Override
        public Message createMessage(Session session)
                        throws JMSException {
                ObjectMessage message = session.createObjectMessage(order);

                // prepare reply-to
                message.setJMSReplyTo(replyToDestination);
                message.setJMSCorrelationID("ID:" + String.valueOf(order.getId()));

                return message;
        }
});

jmsTemplate.convertAndSend(order);

Exposing and Accessing EJBs

Exposing EJBs

@Interceptors(SpringBeanAutowiringInterceptor.class)

<bean class="org.springframework.context.support.ClassPathXmlApplicationContext" />

public class MySpringBeanAutowiringInterceptor extends
                SpringBeanAutowiringInterceptor {

        @Override
        protected BeanFactoryLocator getBeanFactoryLocator(Object target) {
                return ContextSingletonBeanFactoryLocator
                                .getInstance("classpath:some/xmlConfigFile.xml");
        }
}

Accessing EJBs

<jee:remote-slsb id="vendorEjb3SlsbConnector"
        cache-home="false" jndi-name="Ejb3StatelessBeanServiceRemote"
        business-interface="com.vendor1.erp.ejb3.Ejb3StatelessBeanServiceRemote">
        <jee:environment>
                java.naming.factory.initial=org.apache.openejb.client.LocalInitialContextFactory
        </jee:environment>
</jee:remote-slsb>

Automated Testing

The JUnit Testing Framework

@RunWith(Suite.class)
@SuiteClasses( { /* DAO tests: */BusinessUserDaoTest.class,
                CustomerDaoTest.class, OrderDaoTest.class, ProductDaoTest.class,
                UserDaoTest.class, VendorDaoTest.class, /* MVC tests: */
                AdminAddCustomerControllerTest.class, /* Transactions tests: */
                TransactionsTest.class, /* Integration tests: */InsertOrderTest.class,
                HttpLoginTest.class,
                /* Remoting tests (Non-HTTP) */RmiTest.class, Ejb3RemoteSlsbTest.class,
                /* JMS */
                JmsTest.class })
public class AllTestsSuite extends AbstractTests {
}

@Test
public void testGetCandidatesForLoginInt() {
        List<BusinessUserWrapper> loginCandidates = businessUserDAO
                        .getCandidatesForLogin(user.getId());

        assertEquals(0, loginCandidates.get(loginCandidates.size() - 1)
                        .getSpringSecurityID());
        assertNotNull(loginCandidates.get(0).getName());
        assertTrue(loginCandidates.get(0).getId() > 0);
}

public class AbstractWebServerTests extends AbstractTests {
        ...

        @Before
        public void startWebServer() {
                ...
                webappRunner.start();
                ...
        }

        @After
        public void stopWebServer() {
                ...
                webappRunner.stop();
                ...
        }
}

Spring Testing Support

Spring TestContext Framework

@ContextConfiguration(locations = {
        "classpath:applicationContexts/backend/appContext-dataSource.xml",
        "classpath:applicationContexts/backend/appContext-dataAccessObjects.xml"})
public abstract class AbstractDaoTests extends AbstractTransactionalJUnit4SpringContextTests { ...

AbstractTransactionalxxxSpringContextTests

int[] rowCounts = new int[7];

String[] tableNames = { "authorities", "business_users", "line_items",
                "orders", "products", "users", "vendors_products" };

@BeforeTransaction
public void countTableRowsBeforeTransaction() {
        for (int i = 0; i < rowCounts.length; i++) {
                rowCounts[i] = countRowsInTable(tableNames[i]);
        }
}

@AfterTransaction
public void countTableRowsAfterTransaction() {
        for (int i = 0; i < rowCounts.length; i++) {
                assertEquals("Transaction didn't rollback with table "
                                + tableNames[i], rowCounts[i],
                                countRowsInTable(tableNames[i]));
        }
}

Common Annotations

Tests in the Sample Application

Excursus: Embedding the Jetty HTTP Server

public class JettyUtils {
        public static Server startServer(Properties serverProps) throws Exception {
                Server server = new Server(Integer.parseInt((String) serverProps
                                .get("port")));
                WebAppContext context = new WebAppContext((String) serverProps
                                .get("webappContextPath"), (String) serverProps
                                .get("webappPartialURL"));
                context.setClassLoader(ClassLoader.getSystemClassLoader());
                server.addHandler(context);
                server.start();

                return server;
        }

        public static void stopServer(Server server) throws Exception {
                if (server != null && !server.isFailed() && !server.isStopped()
                                && !server.isStopping()) {
                        server.stop();
                }
                else {
                        throw new IllegalStateException();
                }
        }
}

Running the Tests

mvn package -Dmaven.test.skip=true

mvn test

mvn test -Dtest=com.acme.sample.test.remoting.http.JaxWsTest

DAO Tests

Remoting Tests

AOP Tests

Integrational Tests

Testing HTML Forms

WebConversation conversation = new WebConversation();
WebRequest request = new GetMethodWebRequest(
                "http://localhost:" + serverProps.getProperty("port")
                                + "/springarticle");

WebResponse response = conversation.getResponse(request);
WebForm loginForm = response.getForms()[0];
request = loginForm.getRequest();

request.setParameter("j_username", userName);
request.setParameter("j_password", password);

response = conversation.getResponse(request);

assertTrue("Login for " + userName + "/" + password
                + " not successful.", response.getText().indexOf(
                "Main Page") > -1);

Testing a MVC Controller

@Before
public void setUp() {
        this.controller = (AdminAddCustomer) applicationContext
        .getBean("adminAddCustomerController");
}

@Test
public void testFormBackingObjectHttpServletRequest() {
        MockHttpServletRequest request = new MockHttpServletRequest();
        try {
                assertEquals(new Customer(), controller.formBackingObject(request));
        }
        catch (Exception e) {
                fail(e.toString());
        }
}

@Test
public void testOnBindAndValidateHttpServletRequestObjectBindException() {
        MockHttpServletRequest request = new MockHttpServletRequest();
        Object command = new Customer();
        BindException errors = new BindException(command, "customer");

        // validate a Customer with an empty name
        try {
                controller.onBindAndValidate(request, command, errors);
        }
        catch (Exception e) {
                fail(e.toString());
        }

        assertEquals(1, errors.getAllErrors().size());

        // validate a valid Customer
        errors = new BindException(command, "customer");
        ((Customer) command).setName(StringUtils.getRandomString());
        try {
                controller.onBindAndValidate(request, command, errors);
        }
        catch (Exception e) {
                fail(e.toString());
        }

        assertEquals(0, errors.getAllErrors().size());
}

@Test
public void testDoSubmitActionObject() {
        Customer customer = new Customer();
        customer.setName(StringUtils.getRandomString());

        try {
                controller.doSubmitAction(customer);
                        
                Customer savedCustomer = customerDAO.get(customer.getId());
                assertEquals(customer, savedCustomer);
        }
        catch (Exception e) {
                fail(e.toString());
        }
}

@RolesAllowed( { "ROLE_ADMINISTRATOR" })
public interface AdminFacade {
        ...

<global-method-security jsr250-annotations="enabled"
        secured-annotations="enabled" />

ModelAndView mav = controller.handleRequest(request, response);

ModelAndViewAssert.assertAndReturnModelAttributeOfType(mav,
                "customer", Customer.class);
ModelAndViewAssert.assertAndReturnModelAttributeOfType(mav,
                "supportedLocales", Map.class);

ModelAndViewAssert.assertModelAttributeAvailable(mav, "customer");

ModelAndViewAssert.assertModelAttributeValue(mav, "customer",
                new Customer());

ModelAndViewAssert.assertViewName(mav, "adminAddCustomer");

Testing the "Insert Order" Use Case

Patterns in Spring

Architectural Patterns

Dependency Injection Pattern

Problem

Solution

Model-View-Controller (MVC) Pattern

Problem

Solution

Design Patterns

Creational Design Patterns

Factory Pattern

Problem

Solution

Singleton Pattern

Problem

Solution

public class UserSettings {
        private static UserSettings userSettings;

        private UserSettings() {}

        public static UserSettings getInstance() {
                if (userSettings == null) {
                        userSettings = new UserSettings();
                }
                return userSettings;
        }

        public Locale getLocale() {
                ...
        }
}

Structural Design Patterns

Exporter Pattern

Problem

Solution

<bean id="rmiServiceExporter" class="org.springframework.remoting.rmi.RmiServiceExporter"
        p:serviceName="VendorRmiConnector" p:serviceInterface="com.vendor1.erp.remoting.rmi.RmiService"
        p:registryPort="1199">
        <property name="service">
                <bean class="com.vendor1.erp.remoting.rmi.RmiServiceImpl"></bean>
        </property>
</bean>

Proxy Pattern

Problem

Solution

<bean id="vendorRmiConnector" class="org.springframework.remoting.rmi.RmiProxyFactoryBean"
        p:serviceUrl="rmi://localhost:1199/VendorRmiConnector"
        p:serviceInterface="com.vendor1.erp.remoting.rmi.RmiService" />

Data Access Object (DAO) Pattern

Problem

Solution

Decorator Pattern

Problem

Solution

public GZIPOutputStream(OutputStream out) .. { ...

Exception Translator Pattern

Problem

Solution

Behavioral Design Patterns

Listener Pattern

Problem

Solution

Strategy Pattern

Problem

Solution

Template Pattern

Problem

Solution

return (List<BusinessUserWrapper>) this.jdbcTemplate.query(query, new Object[] { loginID }, 
        
        new RowMapper() {

                @Override
                public BusinessUserWrapper mapRow(ResultSet rs, int rowNum)
                        throws SQLException {
                        BusinessUserWrapper user = new BusinessUserWrapper();
                        user.setId(rs.getInt("id"));
                        user.setName(rs.getString("name"));
                        user.setSpringSecurityID(rs.getInt("user_id"));

                        return user;
                }
        }
);

Resources

Spring Framework (Core)

• Johnson, Rod: Introduction to the Spring Framework 2.5, theserverside.com, 2007
• Johnson, Rod, et al.: Spring Framework - Reference Documentation, springframework.org, 2008
• Lorimer, R. J.: Spring: A Quick Journey Through Spring AOP, javalobby.org, 2005
• Wolff, Eberhard: Spring 2 - Framework für die Java-Entwicklung, dpunkt.verlag, 2007

Spring Integration (Remoting, etc.)

• A. J.: BigInteger and hessian. Using custom hessian Serializers with Spring, ayax79.wordpress.com, 2009
• Anonymous: hessian binary web service protocol, Caucho Technology, Inc., 2008
• Anonymous: OpenEJB EJB3 Examples, openejb.apache.org
• Anonymous: Spring EJB and JPA, openejb.apache.org
• Burke, Bill & Monson-Haefel, Richard: Enterprise JavaBeans 3.0, O'Reilly Media, Inc., 2006
• Gredler, Daniel: Java Remoting: Protocol Benchmarks, daniel.gredler.net, 2008
• Jendrock, Eric, et al.: The Java EE 5 Tutorial, java.sun.com, 2008
• Shannon, Bill: JavaTM Platform, Enterprise Edition (Java EE) Specification, v5, Sun Microsystems, Inc., 2006
• Sierra, Kathy & Bates, Bert: Head First Servlets and JSP, O'Reilly Media, Inc., 2008
• Winterfeldt, David: Embedded Spring Web Services, springbyexample.org, 2009

Spring Framework (Other)

• De Smet, Geoffrey & De Bruyker, Peter: Spring RichClient Reference Guide, spring-rich-c.sourceforge.net, 2008
• Johnson, Rod: Open Source, Open Strategy: The SpringSource Manifesto, blog.springsource.com, 2008
• Johnson, Rod, et al.: Spring Security - Reference Documentation, springframework.org, 2007
• Poutsma, Aren, et al.: Spring Web Services - Reference Documentation, springframework.org
• Winterfeldt, David: Spring by Example, springbyexample.org, 2009

Hibernate ORM

• Anonymous: Hibernate Annotations Reference Guide, (JBoss, 3.4.0.GA)
• Anonymous: How inheritance works in Hibernate, simsonlive.wordpress.com, 2008
• Anonymous: Generic Data Access Objects, Red Hat, Inc., 2009
• Bauer, Christian & King, Gavin: Java Persistence with Hibernate, Manning Publications Co., 2007
• Iltchenko, Andrei: Hibernate doesn't support optional one-to-one associations, Atlassian JIRA, 2006
• King, Gavin, et al.: Hibernate Reference Documentation, Red Hat, Inc., 2009

Testing

• Anonymous: JUnit Testing Framework, junit.sourceforge.com, 2009
• Anonymous: HttpUnit Testing Framework, httpunit.sourceforge.net, 2008
• Anonymous: Inclusions and Exclusions of Tests (Maven), maven.apache.org, 2008
• Anonymous: JWebUnit Testing Framework, jwebunit.sourceforge.com, 2009
• Anonymous: Spring Support For Testing, De Luca Consulting, 2008
• Aston, Philip & Fitzgerald, Calum: The Grinder Testing Framework, grinder.sourceforge.net, 2009
• Beust, Cedric: TestNG Testing Framework, testng.org, 2009
• Johnson, Rod: System Integration Testing Using Spring, InfoQ, 2007
• Penchikala, Kavitha & Penchikala, Srinki: Software Testing With Spring Framework, InfoQ, 2007

Design Patterns

• Anonymous: Design Patterns, sourcemaking.com
• Fowler, Martin: Inversion of Control Containers and the Dependency Injection pattern, martinfowler.com, 2004

Other Resources

• Anonymous: Apache Maven Project, The Apache Software Foundation, 2009
• Gredler, Daniel: Embedding Jetty 6 in Spring, daniel.gredler.net, 2007
• Horn, Thorsten: Technische Kurzdokumentationen, torsten-horn.de, 2009