Spring J2EE Framework

Ram A. Rao
May 15th 05

Last Update: 5/15/06

Agenda Spring Framework

1.

Introduction to Spring Framework, Dependency

2.

Injection/Inversion of Control and AOP

3.

Spring usage scenarios and initializing. Spring in J2EE applications

4.

Spring in Web tier. Spring with Struts.

5.

Spring with EJBs and declarative transactions

6.

Using Spring for persistence

7.

Using Spring AOP interceptors

8.

Using other Spring supported functions (JNDI, Mail, JMS,

WebServices)

9.

Testing using Spring

LastUpdate:5/

Spring

A lightweight non-intrusive framework which addresses

various tiers in a J2EE application.

Presentation layer: Integrates with Struts to initialize action

classes
Business layer: Lightweight IoC container with support for
AOP-driven interceptors and transaction.
Persistence layer DAO template support for Hibernate,
SQLMaps and JDBC
Factory implementation to abstract and integrate various
other facets of enterprise applications like E-mails, JMS,
WebServices, etc.

Helps integrates tiers together using XML configuration

instead of hard-coding.
Substantially reduces code, speeds up development,
facilitates easy testing and improves code quality.

LastUpdate:5/

Spring Stack

LastUpdate:5/

Source: Spring Docs

Spring Benefits

Not a J2EE container. Doesnt compete with J2EE app

servers. Simply provides alternatives.
POJO-based, non-invasive framework which allows a
la carte usage of its components.
Promotes decoupling and reusability
Reduces coding effort and enforces design discipline
by providing out-of-box implicit pattern
implementations such as singleton, factory, service
locator etc.
Removes common code issues like leaking
connections and more
Support for declarative transaction management
Easy integration with third party tools and
technologies.

LastUpdate:5/

Fundamentals Concepts
Spring largely built around

Inversion of Control (IoC) or Dependency

Management

Aspect Oriented Programming (AOP)

LastUpdate:5/

Inversion of Control

Instead of objects invoking other objects, the

dependant objects are added through an external
entity/container.
Also known as the Hollywood principle dont call
me I will call you
Dependency injection
Dependencies are injected by container during
runtime.
Beans define their dependencies through
constructor arguments or properties
Prevents hard-coded object creation and
object/service lookup.
Loose coupling
Helps write effective unit tests.

LastUpdate:5/

Non-IoC / Dependency Injection

Source: Spring Documentation

LastUpdate:5/

Non-IoC Service Object

public class CampaignServiceImpl implements
CampaignService {
public Campaign updateCampaign(Campaign campaign)
throws CampaignException{
try{
CampaignDAO campaign = new CampaignDAOImpl();
..
OpportunityDAO oppDAO = new OpportunityDAOImpl();
// Alternatively, initialize thru factory
// OpportunityDAO oppDAO = OppFactory.getOpp();
oppDAO.save(campaign);
..

}catch(Exception e){
}
}
Code is tightly coupled or interspersed with Factory
code!

LastUpdate:5/

IoC / Dependency Injection

Source: Spring Documentation

LastUpdate:5/

10

IoC Service Object

public class CampaignServiceImpl implements
CampaignService {
public Campaign updateCampaign(Campaign campaign)
throws CampaignException{
try{
oppDAO.save(campaign);
}catch(Exception e){
}
}
// Spring sets the value thru runtime injection!
private setOpportunityDAO(OpportunityDAO oppDao){
this.oppDAO = oppDao;
}

LastUpdate:5/

11

Spring Usage Scenarios

Following are the typical usage scenarios for Spring

Presentation layer

Business layer

Integrates with EJBs

Provides integration with components using IoC.
Transaction (declarative and programmatic)

Persistence layer

Integrates with Struts to initialize action classes and its

dependencies.
Facilitates presentation-tier testing

DAO pattern implementation

Template support for Hibernate, iBatis DataMapper and JDBC
Transaction management, Exception translation, connection
management.

General

Email, JNDI, WebServices

LastUpdate:5/

12

Spring Bean Definition

The bean class is the actual implementation of the bean

being described by the BeanFactory.
Bean examples DAO, DataSource, Transaction Manager,
Persistence Managers, Service objects, etc
Spring config contains implementation classes while your
code should program to interfaces.
Bean behaviors include:
Singleton or prototype
Autowiring
Initialization and destruction methods

init-method
destroy-method

Beans can be configured to have property values set.

Can read simple values, collections, maps, references to other

beans, etc.

LastUpdate:5/

13

Simple Spring Bean Example

<bean id=CampaignServiceTarget"
class="com.corp.CampaignServiceImpl">
<property name=promotionService">
<ref bean=promotionService" />
</property>
<property name=count">2</property>
</bean>
public class CampaignServiceImpl implements CampaignService{

public void setCount(int c){

this.count = c;
}
public void setPromotionService(PromotionService pServ){
this.promotionService = pServ;
}
}

LastUpdate:5/

14

Spring BeanFactory

BeanFactory is core to the Spring framework

Lightweight container that loads bean definitions

and manages your beans.

Configured declaratively using an XML file, or files,

that determine how beans can be referenced and
wired together.

Knows how to serve and manage a singleton or

prototype defined bean

Responsible for lifecycle methods.

Injects dependencies into defined beans when

served

Removes the need for ad-hoc singletons and factories

LastUpdate:5/

15

Spring ApplicationContext

A Spring ApplicationContext allows you to get access

to the objects that are configured in a BeanFactory in
a framework manner.
ApplicationContext extends BeanFactory

Several ways to configure a context:

Adds services such as international messaging

capabilities.
Add the ability to load file resources in a generic fashion.
XMLWebApplicationContext Configuration for a web
application.
ClassPathXMLApplicationContext standalone XML
application context
FileSystemXmlApplicationContext

Allows you to avoid writing Service Locators

LastUpdate:5/

16

Struts Support

ContextLoaderPlugin

Loads a Spring application context for the Struts

ActionServlet.
Struts Actions are managed as Spring beans.

ActionSupport and DispatchActionSupport

Pre-built convenience classes to provide access to the

context.
Provides methods in superclass for easy context lookup.

LastUpdate:5/

17

Configuring Context Option 1

<plug-in
className="org.springframework.web.struts.Conte
xtLoaderPlugIn">
<set-property property="contextConfigLocation"
value="/WEB-INF/applicationContext.xml"/>
</plug-in>

LastUpdate:5/

18

Configuring Context Option 2

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
/WEB-INF/applicationContext.xml
</param-value>
</context-param>
<!-- listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener -->
<servlet>
<servlet-name>context</servlet-name>
<servlet-class>
org.springframework.web.context.ContextLoaderServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>

LastUpdate:5/

19

Locating a Bean with Struts

public abstract class BaseAction extends
ActionSupport {
protected CampaignService getCampaignService() {
return (CampaignService)
getWebApplicationContext()
.getBean(campaignService");
}
}
<bean id=campaignService"
class=com.corp.CampaignServiceImpl">

LastUpdate:5/

20

Spring with EJB

Implements service locator and code-less business

delegate.
Configurable EJB lookup for remote and local EJBs
Supports POJO business tier with EJB faade
Easier EJB development with helper classes
Supports SLSBs and MDBs
Implement Business Interface pattern

EJB classes and POJO implementation extend a common

interface
Common interface defines all methods

LastUpdate:5/

21

Spring and EJB

Spring promoted as an alternative to the relatively

complex EJBs
Provides few comparable features, if not all
EJBs are a must for

Distributed transactions
Cluster-safe remoting of services
Container managed component security
High availability services

Using Spring with EJBs moves implementation to a

POJO model
Positions applications to a easier transition into the new
EJB 3.0 spec.

LastUpdate:5/

22

Spring with EJB

LastUpdate:5/

23

Spring EJB Declaration ejb-jar.xml

<session id=CampaignService">

<ejb-name>CampaignService</ejb-name>
<local-home>com.corp.ejb.CampaignServiceLocalHome</local-home>
<local>com.corp.ejb.CampaignServiceLocal</local>
<ejb-class>com.corp.ejb.CampaignServiceBean</ejb-class>
<session-type>Stateless</session-type>
<transaction-type>Bean</transaction-type>
<env-entry>
<env-entry-name>ejb/BeanFactoryPath</env-entry-name>
<env-entry-type>java.lang.String</env-entry-type>
<env-entry-value>ejbContext.xml</env-entry-value>
</env-entry>
<ejb-local-ref id="EJBLocalRef_1136316508000">
<ejb-ref-name>ejb/CampaignService</ejb-ref-name>
<ejb-ref-type>Session</ejb-ref-type>
<local-home>com.corp.ejb.services.CampaignServiceLocalHome</local-home>
<local>com.corp.ejb.services.CampaignServiceLocal</local>
<ejb-link>CampaignService</ejb-link>
</ejb-local-ref>
</session>

LastUpdate:5/

24

Spring EJB Declaration

<bean id="accountService"
class=LocalStatelessSessionProxyFactoryBean">
<property name="jndiName">
<value>ejb/CampaignServiceHome</value>
</property>
<property name="businessInterface">
<value>com.corp.services.CampaignService</value>
</property>
</bean>

LastUpdate:5/

25

EJB Client with Spring Helper

EJB Local:
/**
* Local interface for Enterprise Bean: CampaignService.
*/
public interface CampaignServiceLocal extends
javax.ejb.EJBLocalObject, CampaignService {
}

LastUpdate:5/

26

EJB class with Spring Helper

/**
* Bean implementation class for Enterprise Bean:
CampaignService
*/
public class CampaignServiceBean extends
AbstractStatelessSessionBean
implements CampaignService {
private static final String BEAN_NAME=
campaignService";
private Campaign service;
protected void onEjbCreate() throws CreateException {
service = (CampaignService)
getBeanFactory().getBean(BEAN_NAME);
}
}
LastUpdate:5/

27

Delegated POJO Service Implementation

/**
* POJO implementation class for Enterprise Bean:
CampaignServiceBean
*/
public class CampaignServiceImpl implements CampaignService {
public Long createCampaign(String c) throws AppException {
..
}
}
applicationContext.xml
<bean id=campaignServiceTarget"
class="com.corp.services.CampaignServiceImpl">
<property name=promoDAO">
<ref bean=promoDAO" />
</property>
</bean>

LastUpdate:5/

28

Transaction Management With Spring

Choice of two transaction managers

DataSourceTransactionManager for Local
Transactions
JtaTransactionManager for using container
transactions manager

Choice of two transaction

Declarative (preferred); Declarations are in Spring
context.
Programmatic; only for scenarios when declarative
doesnt work. Custom Spring API

LastUpdate:5/

29

Transaction Management With Spring

Local Transactions:

<bean id=localTransactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactio
nManager">
<property name="dataSource">
<ref local="springContainerDataSource" />
</property>
</bean>
JTA Transactions (Using Websphere):

<bean id="wsJtaTm"
class="org.springframework.transaction.jta.WebSphereTransaction
ManagerFactoryBean"/>
<bean id=distTransactionManager"
class="org.springframework.transaction.jta.JtaTransactionManage
r">
<property name="transactionManager" ref="wsJtaTm" />
<property name="userTransactionName"><null /></property>
</bean>

LastUpdate:5/

30

Enabling Transactions on Services

Transactions are typically enabled at the business tier level

and not in the DAO
Spring transactions are an alternative to EJB transactions;
for both declarative and programmatic
Have to be enabled after disabling EJB CMT. No point in
having both

LastUpdate:5/

31

Enabling Declarative Transactions on

Services
id=campaignServiceTxn"

<bean
class="org.springframework.transaction.interceptor.TransactionP
roxyFactoryBean">
<property name="transactionManager">
<ref bean="distTransactionManager" />
</property>
<property name="target">
<ref bean=campaignServiceTarget" />
</property>
<property name="transactionAttributes">
<props>
<prop key="update*">
PROPAGATION_REQUIRED, -com.corp.common.exception.NWException
</prop>
<prop key="*">
PROPAGATION_REQUIRED,readOnly,-com.corp.common.exception.NWException
</prop>
</props>

</property>
</bean>

LastUpdate:5/

32

Dependency Injection

LastUpdate:5/

33

Persistence With Spring

Provides DAO implementation

Data access templates/helper classes.
Exception handling and translation. try/catch/finally
blocks are not required anymore.
Connection management and implicit passing of
datasource to DAO
Traditional problem of connection leaking etc. no
more a concern

LastUpdate:5/

34

Defining Datasource
<bean id="springContainerDataSource"
class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName">
<value>jdbc/CustomerDB</value>
</property>
</bean>

LastUpdate:5/

35

Defining Persistence and wiring

Datasource
<bean id=hibernateSessionFactory" class=
org.springframework.orm.hibernate.LocalSessionFactoryBean>
<property name="dataSource">
<ref local="springContainerDataSource />
</property>
<property name="mappingResources">
<list>
<value>com/corp/orm/Customer.hbm.xml</value>
<value>com/corp/orm/Account.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">
net.sf.hibernate.dialect.DB2Dialect
</prop>
<prop key="hibernate.show_sql">false</prop>
<prop key="hibernate.autocommit">false</prop>
<prop key="cache.provider_class">
org.hibernate.cache.OSCacheProvider
</prop>
</props>
</property>
</bean>

LastUpdate:5/

36

Defining Persistence Beans

<bean id=promoDao"
class="com.corp.dao.HibernatePromotionDao">
<property name="sessionFactory">
<ref local="hibernateSessionFactory" />
</property>

</bean>

LastUpdate:5/

37

DAO Support classes

Support for

JdbcDaoSupport

HibernateDaoSupport

Provides callback methods for row iteration

Initializes Hibernate session factory
Provides templates to invoke Hibernate API or the
session

SqlMapDaoSupport

Provides template for iBatis SQLMaps

Support similar to Hibernate template

LastUpdate:5/

38

JDBC Code without a template

public class JDBCPromotionDAO implements PromotionDAO {
public Order savePromotion(Promotion promo) throws
PromoException{
Transaction tx = null;
try{
s = ... // get a new datasourceobject
tx = s.beginTransaction();
s.save(promo);
tx.commit();
} catch (SQLException sqle){
// log, rollback, and convert to OrderException
} finally {
s.close(); // needs a try/catch block
}
return promo;
}

LastUpdate:5/

39

Spring JDBC DAO Template

public class JDBCPromotionDAO implements
PromotionDAO extends JDBCDaoSupport{
public Order savePromotion(Promotion promo) throws
DataAccessException{
Transaction tx = null;
// get a new datasourceobject
templ = new JdbcTemplate(this.appDataSource);
templ.update(promo);
return promo;
}
public void setAppDataSource (DataSource ds) {
this.appDataSource = ds;
}

LastUpdate:5/

40

Hibernate Code without a template

public class HibernatePromotionDAO implements PromotionDAO {
public Order savePromotion(Promotion promo) throws PromoException{
Session s = null;
Transaction tx = null;
try{
s = ... // get a new Hibernate Session object
tx = s.beginTransaction();
s.save(promo);
tx.commit();
} catch (HibernateException he){
// log, rollback, and convert to DomainException
} catch (SQLException sqle){
// log, rollback, and convert to DomainException
} finally {
s.close(); // needs a try/catch block
}
return promo;
}

LastUpdate:5/

41

Spring Hibernate DAO Template Example

public class PromotionHibernateDAO extends HibernateDaoSupport

implements PromotionDAO {
...
public Order savePromotion(final Promotion promo) {
return (Order) getHibernateTemplate().execute(new
HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
session.save(promo);
return promo;
}
});
}
...
}

LastUpdate:5/

42

Spring Hibernate DAO Template Example

public class PromotionHibernateDAO extends
HibernateDaoSupport
implements PromotionDAO {
...
public List findOrdersByCustomerId(int id) {
return getHibernateTemplate()
.findByNamedQuery(OrdersByCustomerID,
new Integer(id));
}

public Order findOrderById(int orderId ) {

return (Order) getHibernateTemplate().load(
Order. class,
new Integer(orderId));
}
...
}

LastUpdate:5/

43

Consistent Exception Handling

Exception logic is managed by Spring using its own

exception hierarchy.

Exceptions from JDBC, Hibernate, SQLMaps, are wrapped

up into an appropriate, and consistent,
DataAccessException and thrown.

Cleaner separation of tiers.

These exceptions are treated as unchecked exceptions that

can be handled in business tier.

Own exception translation can be defined by sub-classing

classes such as SQLErrorCodeSQLExceptionTranslator

LastUpdate:5/

44

Spring AOP

Provides a non-intrusive solution to common OO

limitation for easily implementing cross cutting
concerns.
Used effectively for functions such as declarative
transaction management, declarative security,
profiling, logging, etc.
Supports AOPAlliance out-of-box. Supports AspectJ
for added features and compile time weaving.
Supports standard advices

method before
method after returning
throws advice
around advice

LastUpdate:5/

45

Spring AOP Runtime Weaving

LastUpdate:5/

46

Spring AOP Advice for Component

Authorization
<!-- Advisor pointcut definition for before advice -->
<bean id="methodAuthzAdvisor
class="org.springframework.aop.support.RegexpMethodPointcu
tAdvisor">
<property name="advice">
<ref local="methodAuthzAdvice"/>
</property>
<property name="pattern">
<value>.*</value>
</property>
</bean>
<!-- Advice classes -->
<bean id="methodAuthzAdvice"
class="com.corp.marketlink.aspects.AuthorizationAdvice"/>

LastUpdate:5/

47

Spring AOP Before Advice Example

public class AuthorizationAdvice implements
MethodBeforeAdvice {
..
public void before(Method method, Object[] args, Object
target) throws Throwable {
//Implement user authorization
CtxAwareReqData reqData = (CtxAwareReqData) args[0];
List allowedRoles = getAllowedRoles(reqData);
boolean isValidAccess = checkAccess(reqData,
allowedRoles);
if (!isValidAccess) {
//Unauthorized user access, do not process any
further.
throw new Exception();
}
}

..
LastUpdate:5/
}

48

Spring Interceptor Injection

LastUpdate:5/

49

Incorporating Advice in Service

<bean id=promotionService"
class="org.springframework.aop.framework.ProxyFactor
yBean">
<property name="proxyInterfaces">
<value>com.corp.CampaignService</value>
</property>
<property name="target">
<ref local=CampaignServiceTxn"/>
</property>
<property name="interceptorNames">
<list>
<value>methodAuthzAdvisor</value>
</list>
</property>
</bean>

LastUpdate:5/

50

Spring and Testing

Easier test driven development

Integration testing
Can use a standalone Spring configuration with
mock objects for testing.
XMLApplicationContext or
FileSystemApplicationContext to initialize Spring
Unit testing
Dependency injection setter makes its very easy
to perform unit tests.
Allows tests outside the container without using
the Spring container.
Provides mock objects for Struts and DB tests

LastUpdate:5/

51

Other Spring Components

JavaMail helpers
JMS implementation
JNDI lookup
Integration with iText for PDF generation
Helper classes for Http Invocation and WebServices
.. and a whole lot of other abstractions

LastUpdate:5/

52

Resources/References

Spring www.springframework.org
Inversion of Control http://www.martinfowler.com/articles/injection.html
Java Development With Spring Framework
Johnson, Hoeller et al.
Spring in Action Walls, Breidenbach

LastUpdate:5/

53