The Spring Framework
Paul Bakker

Goals
An introduction
Not pointing a winner

Outline
• History and overview
• Dependency Injection
• AOP
• Module deep dive
• Testing

History
Founded by Rod Johnson
First introduced in his book
“J2EE Design &
Development”

Modules

Why Dependency Injection?
public double calculateTotalPrice() {
ProductService productService = new ProductService();
List products = productService.getProducts();
//iterate products and sum prices
return total;
}
How would you test this method?

productService.getProducts()
Database

Throws
public void testCalculateTotalPrice() {
Calculator calc = new Calculator();
Exception...
assertEquals(150, calc.calculateTotalPrice());
}
public double calculateTotalPrice() {
ProductService productService = new ProductService();
List products = productService.getProducts();
//iterate products and sum prices
return total;
}

public Calculator(ProductService productService) {
this.productService = productService;
}
public double calculateTotalPrice() {
List products = productService.getProducts();
//iterate products and sum prices
return total;
}

public void testCalculateTotalPrice() {
Calculator calc =
new Calculator(new ProductServiceMock());
assertEquals(150, calc.calculateTotalPrice());
}

Program to interfaces
not to
implementations

Inversion of Control
A container manages dependencies
IoC Container
ProductService Calculator

Configuring a container
ProductService pService = new ProductServiceImpl();
Calculater calc = new Calculator(pService);
//init other instances
This will be a lot of work however...

Configuration using
XML
<bean id=\"productService\"
class=\"services.ProductServiceImpl\"/>
<bean id=\"calculator\" class=\"calc.Calculator\">
<constructor‐arg index=\"0\" ref=\"productService\"/>
</bean>
Spring version 1 way

Configuration using
annotations
@Stateless(name = \"ProductEJB\")
public class ProductBean {
public ProductBean() {
}
}
@EJB ShoppingBasketBean shoppingBasket;
JEE 5 way

Spring annotations
• Spring can now be configured using
annotations
• Use annotations for component
declarations
• Use XML for container wide configuration

Annotation example
@Service
public class SimpleMovieLister {
private MovieFinder movieFinder;
@Autowired
public SimpleMovieLister(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}
}

AutoWiring
• Don’t explicitly wire dependencies
• Just declare beans

Autowiring qualifiers
<bean class=\"example.SimpleMovieCatalog\">
<qualifier value=\"main\"/>
</bean>
<bean class=\"example.SimpleMovieCatalog\">
<qualifier value=\"action\"/>
</bean>
@Autowired
@Qualifier(\"main\")
private MovieCatalog movieCatalog;

Aspect Oriented
Programming
• Used internally by Spring;
• e.g. Transaction Management
• AspectJ integration for easy AOP on your
Spring beans

2 minute AOP intro
Class A
public void trace(..) {
//log something
Before }
public void myMethod(..) {
//do something
}

Module deep dive

JdbcTemplate
int countOfActorsNamedJoe = this.jdbcTemplate.queryForInt(
\"select count(0) from t_actors where first_name = ?\",
new Object[]{\"Joe\"});

JdbcTemplate
this.jdbcTemplate.update(
\"delete from actor where id = ?\",
new Object[] {new Long.valueOf(actorId)});

SimpleJdbcTemplate
String sql = \"select id, first_name, last_name from T_ACTOR where id = ?\";
ParameterizedRowMapper<Actor> mapper = new ParameterizedRowMapper<Actor>()
{
public Actor mapRow(ResultSet rs, int rowNum) throws SQLException {
Actor actor = new Actor();
actor.setId(rs.getLong(\"id\"));
actor.setFirstName(rs.getString(\"first_name\"));
actor.setLastName(rs.getString(\"last_name\"));
return actor;
}
};
return this.simpleJdbcTemplate.queryForObject(sql, mapper, id);

Exceptions
• Spring wraps every jdbc exception
• Same structure for ORM exceptions
• Handle specific database exceptions in a
uniform way
• Translate checked exception to unchecked
exceptions

Module deep dive

ORM Integration
• Hibernate
• iBATIS
• JDO
• TopLink
• JPA

Session Factory
Configuration
<bean id=\"mySessionFactory\"
class=\"org.springframework.orm.hibernate3.LocalSessionFactoryBean\">
<property name=\"dataSource\" ref=\"myDataSource\"/>
<property name=\"mappingResources\">
<list>
<value>product.hbm.xml</value>
</list>
</property>
<property name=\"hibernateProperties\">
<value>
hibernate.dialect=org.hibernate.dialect.HSQLDialect
</value>
</property>
</bean>

Hibernate Template
Configuration
<bean id=\"myProductDao\" class=\"product.ProductDaoImpl\">
<property name=\"sessionFactory\" ref=\"mySessionFactory\"/>
</bean>

Hibernate Template
public class HibernateProductDao extends HibernateDaoSupport {
public Collection loadProductsByCategory(String category) throws
DataAccessException, MyException {
return this.hibernateTemplate.find(
\"from test.Product product where product.category=?\", category);
}
}

Transactions
It’s just more configuration

<bean id=\"myTxManager\"
class=\"org.springframework.orm.hibernate3.HibernateTransactionManager\">
<property name=\"sessionFactory\" ref=\"mySessionFactory\"/>
</bean>
<aop:config>
<aop:pointcut id=\"productServiceMethods\" expression=\"execution(*
product.ProductService.*(..))\"/>
<aop:advisor advice‐ref=\"txAdvice\" pointcut‐
ref=\"productServiceMethods\"/>
</aop:config>
<tx:advice id=\"txAdvice\" transaction‐manager=\"myTxManager\">
<tx:attributes>
<tx:method name=\"increasePrice*\" propagation=\"REQUIRED\"/>
<tx:method name=\"someOtherBusinessMethod\"
propagation=\"REQUIRES_NEW\"/>
<tx:method name=\"*\" propagation=\"SUPPORTS\" read‐only=\"true\"/>
</tx:attributes>
</tx:advice>

<bean id=\"myTxManager\"
class=\"org.springframework.orm.hibernate3.HibernateTransactionManager\">
<property name=\"sessionFactory\" ref=\"mySessionFactory\"/>
</bean>
<aop:config>
<aop:pointcut id=\"productServiceMethods\" expression=\"execution(*
product.ProductService.*(..))\"/>
<aop:advisor advice‐ref=\"txAdvice\" pointcut‐
ref=\"productServiceMethods\"/>
</aop:config>
<tx:advice id=\"txAdvice\" transaction‐manager=\"myTxManager\">
<tx:attributes>
<tx:method name=\"increasePrice*\" propagation=\"REQUIRED\"/>
<tx:method name=\"someOtherBusinessMethod\"
propagation=\"REQUIRES_NEW\"/>
<tx:method name=\"*\" propagation=\"SUPPORTS\" read‐only=\"true\"/>
</tx:attributes>
</tx:advice>
Transaction manager

<bean id=\"myTxManager\"
class=\"org.springframework.orm.hibernate3.HibernateTransactionManager\">
<property name=\"sessionFactory\" ref=\"mySessionFactory\"/>
</bean>
<aop:config>
<aop:pointcut id=\"productServiceMethods\" expression=\"execution(*
product.ProductService.*(..))\"/>
<aop:advisor advice‐ref=\"txAdvice\" pointcut‐
ref=\"productServiceMethods\"/>
</aop:config>
<tx:advice id=\"txAdvice\" transaction‐manager=\"myTxManager\">
<tx:attributes>
<tx:method name=\"increasePrice*\" propagation=\"REQUIRED\"/>
<tx:method name=\"someOtherBusinessMethod\"
propagation=\"REQUIRES_NEW\"/>
<tx:method name=\"*\" propagation=\"SUPPORTS\" read‐only=\"true\"/>
</tx:attributes>
</tx:advice>
Pointcut and Advisor

<bean id=\"myTxManager\"
class=\"org.springframework.orm.hibernate3.HibernateTransactionManager\">
<property name=\"sessionFactory\" ref=\"mySessionFactory\"/>
</bean>
<aop:config>
<aop:pointcut id=\"productServiceMethods\" expression=\"execution(*
product.ProductService.*(..))\"/>
<aop:advisor advice‐ref=\"txAdvice\" pointcut‐
ref=\"productServiceMethods\"/>
</aop:config>
<tx:advice id=\"txAdvice\" transaction‐manager=\"myTxManager\">
<tx:attributes>
<tx:method name=\"increasePrice*\" propagation=\"REQUIRED\"/>
<tx:method name=\"someOtherBusinessMethod\"
propagation=\"REQUIRES_NEW\"/>
<tx:method name=\"*\" propagation=\"SUPPORTS\" read‐only=\"true\"/>
</tx:attributes>
</tx:advice>
Advice - Propagation properties

Module deep dive

Web MVC
Components
• Controllers
• View Handlers
• Validation

Controller Hierarchy
AbstractController MultiactionController
CommandController
FormController
WizzardController

Compared to other
web frameworks
• Web MVC is very simple
• It’s ‘action’ based
• Close to the request/response model
• It doesn’t have conversational state

Spring Portlets
• Web MVC for JSR-168
• Exactly the same programming model for
Portlets and Servlets
• Doesn’t hide the Portlet specific flow

Testing
• Spring Mock
• Integration Testing

Spring Mocks
• Mock often used objects
• Request, Response, Session, JNDI etc.

Spring integration
testing
• Test Wiring
• Test DAOs

Test DAOs
• Wire beans
• Manage transactions
• Rollback transaction after each test
• Mix Hibernate and plain JDBC in one
transaction

DAO test example
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={\"daos.xml\"})
public final class HibernateTitleDaoTests {
@Autowired
private HibernateTitleDao titleDao;
public void testLoadTitle() throws Exception {
Title title = this.titleDao.loadTitle(new Long(10));
assertNotNull(title);
}
}

Closed source Spring?

The verdict
• Spring is very complete
• It’s “environment friendly”
• It helps loose coupling
• It’s much better than J2EE

Do we still need it?
• JEE 5 has a similar programming model
• Seam is a much better web framework

Where to start
• http://springframework.org
• Reference documentation
• Spring Pet store

Spring related
• Spring Webflow
• Spring security (acegi)
• Spring webservices
• Spring integration

Enjoy your evening