Introduction to the

Spring Framework
By Mumbai Academics

Advantages of Spring Framework Architecture

There are many advantages of Spring Framework. They are as
follows:
Lightweight: Spring framework is lightweight because of its
POJO implementation. The Spring Framework doesn't force the
programmer to inherit any class or implement any interface.
That is why it is said non-invasive, Enable you to write powerful,
scalable applications using POJOs.
Easy to develop JavaEE application: The Dependency
Injection feature of Spring Framework and it support to various
frameworks makes the easy development of JavaEE
application.
Easy to test: The Dependency Injection makes easier to test
the application. The EJB or Struts application require server to
run the application but Spring framework doesn't require server.

Loose Coupling: The Spring applications are loosely

coupled because of dependency injection and handles
injecting dependent components without a component
knowing where they came from (IoC).
Powerful abstraction: It provides powerful abstraction to
JavaEE specifications such as JMS, JDBC, JPA and JTA.
Declarative support: It provides declarative support for
caching, validation, transactions and formatting.
Portable :can use server-side in web/ejb app, client-side in
swing app, business logic is completely portable.
Cross-cutting behavior : Resource Management is crosscutting concern, easy to copy-and-paste everywhere.

Configuration information: Spring provides one consistent

way of configuring everything, separate configuration from
application logic, varying configuration.
Lifecycle : Responsible for managing all your application
components, particularly those in the middle tier container
sees components through well-defined lifecycle: init(),
destroy()

Spring

A popular and stable Java application framework for

enterprise development

Ubiquitous for Java development

Well established in enterprise Java apps
Time tested and proven reliable

A primary purpose is to reduce dependencies and

even introduce negative dependencies
Different from almost every other framework out
there
Part of the reason it has been adopted so quickly
Spring code base is proven to be well structured
(possibly the best)
139 packages
No dependency cycles

Spring

A lightweight framework that addresses each tier in a Web

application.

Presentation layer An MVC framework that is most similar to Struts

but is more powerful and easy to use.
Business layer Lightweight IoC container and AOP support
(including built in aspects)
Persistence layer DAO template support for popular ORMs and
JDBC

Simplifies persistence frameworks and JDBC

Complimentary: Not a replacement for a persistence framework

Helps organize your middle tier and handle typical J2EE

plumbing problems.
Solutions to typical coding busywork
JDBC ,LDAP,Web Services
Reduces code and speeds up development
Current Version is 3.0

Spring (continued)

Do I have to use all components of Spring?

Spring is a non-invasive and portable framework that
allows you to introduce as much or as little as you want
to your application.
Promotes decoupling and reusability
POJO Based
Allows developers to focus more on reused business
logic and less on plumbing problems.
Reduces or alleviates code littering, ad hoc singletons,
factories, service locators and multiple configuration
files.
Removes common code issues like leaking
connections and more.
Built in aspects such as transaction management
Most business objects in Spring apps do not depend on
the Spring framework.

Why Did I choose Spring?

Introduced to Spring by way of Hibernate

Spring is an open source layered Java/J2EE application
framework
The Spring Framework is licensed under the terms of the
Apache License
Originally wanted Spring to provide a way to simplify DAO
objects and provide declarative transaction support to our
non-EJB applications.
Needed a solution to loosely couple business logic in a
POJO fashion.
Wanted to build portable applications that provided clearer
separation of presentation, business, and persistence logic.
Easily integrated with our existing frameworks
Great documentation and community support

Spring Mission Statement

J2EE should be easier to use

It's best to program to interfaces, rather than classes. Spring reduces
the complexity cost of using interfaces to zero.
JavaBeans offer a great way of configuring applications
OO design is more important than any implementation technology, such
as J2EE
Checked exceptions are overused in Java. A framework shouldn't force
you to catch exceptions you're unlikely to be able to recover from.
Testability is essential, and a framework such as Spring should help
make your code easier to test
Spring should be a pleasure to use
Your application code should not depend on Spring APIs
Spring should not compete with good existing solutions, but should
foster integration. (For example, JDO and Hibernate are great O/R
mapping solutions. Don't need to develop another one).

Simplify your code with Spring

Enables you to stop polluting code

No more custom singleton objects

Beans are defined in a centralized configuration file

No more custom factory object to build and/or locate other

objects
DAO simplification
Consistent CRUD
Data access templates
No more copy-paste try/catch/finally blocks
No more passing Connection objects between methods
No more leaked connections
POJO Based
Refactoring experience with Spring
Caution Spring is addictive!

Modules of the Spring Framework

The Spring Framework can be considered as a collection of

frameworks-in-the-framework:
Core - Inversion of Control (IoC) and Dependency Injection.
AOP :- These modules support aspect oriented programming
implementation where you can use Advices, Pointcuts etc. to
decouple the code.
DAO - Data Access Object support, transaction management,
JDBC-abstraction
ORM - Object Relational Mapping data access, integration
layers for JPA, JDO, Hibernate, and iBatis
MVC - Model-View-Controller implementation for webapplications
Context-This module supports internationalization (I18N),
EJB,Remote Access, Authentication and Authorization,
Remote Management like RMI,HTTP Invoker,Hessain,
Messaging Framework, Web Services, Email, Testing,

Modules of the Spring Framework

Expression Language:- It is an extension to the EL

defined in JSP. It provides support to setting and getting
property values, method invocation, accessing collections
and indexers, named variables, logical and arithmetic
operators, retrieval of objects by name etc.

Overview of the Spring Framework

Very loosely coupled, components widely reusable and

separately packaged.

Spring Details

Spring allows to decouple software layers by injecting a

components dependencies at runtime rather than having
them declared at compile time via importing and
instantiating classes.
Spring provides integration for J2EE services such as EJB,
JDBC, JNDI, JMS, JTA. It also integrates several popular
ORM toolkits such as Hibernate and JDO and assorted
other services as well.
One of the highly touted features is declarative transactions,
which allows the developer to write transaction-unaware
code and configure transactions in Spring config files.

Spring Details

Spring is built on the principle of unchecked exception

handling. This also reduces code dependencies between
layers. Spring provides a granular exception hierarchy for
data access operations and maps JDBC, EJB, and ORM
exceptions to Spring exceptions so that applications can get
better information about the error condition.
With highly decoupled software layers and programming to
interfaces, each layer is easier to test. Mock objects is a
testing pattern that is very useful in this regard.

Spring Solutions

Solutions address major J2EE problem areas:

Web application development (MVC)

Enterprise Java Beans (EJB, JNDI)
Database access (JDBC, iBatis, ORM)
Transaction management (JTA, Hibernate, JDBC)
Remote access (Web Services, RMI)

Each solution builds on the core architecture

Solutions foster integration, they do not re-invent
the wheel

How to Start Using Spring

create the class

create the xml file to provide the values
create the test class
Load the spring jar files
Run the test class

Create Java class

Create the xml file

Create the test class

Load the jar files required for

spring framework
There are mainly three jar files required to run this
application.
org.springframework.core-3.0.1.RELEASE-A
com.springsource.org.apache.commons.logging-1.1.1
org.springframework.beans-3.0.1.RELEASE-A

What are Lightweight Frameworks?

Non-intrusive
No container requirements
Simplify application development
Remove re-occurring pattern code
Productivity friendly
Unit test friendly

Very pluggable
Usually open source
Examples:

Spring, Pico, Hivemind

Hibernate, IBatis, Castor
WebWork
Quartz
Sitemesh

Spring IoC + AOP

IoC container

Setter based and constructor based dependency injection

Portable across application servers
Promotes good use of OO practices such as programming
to interfaces.
Beans managed by an IoC container are reusable and
decoupled from business logic

AOP

Spring uses Dynamic AOP Proxy objects to provide crosscutting services

Reusable components
Aopalliance support today
Integrates with the IoC container
AspectJ support in Spring 1.1

Spring IoC

Inversion of Control

Dependency injection
Beans define their dependencies through constructor
arguments or properties
The container provides the injection at runtime
Decouples object creators and locators from application logic
Easy to maintain and reuse
Testing is easier
Useful for separating dao and business layer
Useful for separating controllers and business layer
The code is more extensible, easier to read, and
modules/layers can easily be replaced

Non-IoC / Dependency Injection

Non-IoC Service Object

public class OrderServiceImpl implements IOrderService
{
public Order saveOrder(Order order) throws
OrderException{
try{
// 1. Create a Session/Connection object
// 2. Start a transaction
// 3. Lookup and invoke one of the methods in a
// DAO and pass the Session/Connection object.
// 4. Commit transaction
}catch(Exception e){
// handle e, rollback transaction, //cleanup, //
throw e
}finally{
//Release resources and handle more exceptions
}

IoC / Dependency Injection

IoC Service Object

public class OrderSpringService
implements IOrderService {
IOrderDAO orderDAO;
public Order saveOrder(Order order)
throws OrderException{
// perform some business logic
return orderDAO.saveNewOrder(order);
}
public void setOrderDAO(IOrderDAO
orderDAO) {
this.orderDAO = orderDAO;
}

Program to interfaces for your bean dependencies!

Spring Bean Definition

Typical java bean with a unique id
In spring there are basically two types

Singleton

One instance of the bean created and

referenced each time it is requested

Prototype

(non-singleton)

New bean created each time

Same as new ClassName()

Beans are normally created by Spring

as late as possible

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.

What is a bean definition?

Defines a bean for Spring to manage

Key

attributes

class (required): fully qualified java class name

id: the unique identifier for this bean
configuration: (singleton, init-method, etc.)
constructor-arg: arguments to pass to the constructor at
creation time
property: arguments to pass to the bean setters at
creation time
Collaborators: other beans needed in this bean (a.k.a
dependencies), specified in property or constructor-arg

Typically defined in an XML file

Simple Spring Bean Example

<bean id=orderBean class=example.OrderBean

init-method=init>
<property
name=minimumAmountToProcess>10</property>
<property name=orderDAO>
<ref bean=orderDAOBean/>
</property>
</bean>

public class OrderBean implements IOrderBean{

public void
setMinimumAmountToProcess(double d){
this. minimumAmountToProcess = d;
}
public void setOrderDAO(IOrderDAO odao){
this.orderDAO = odao;
}
}

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

Avoids the use of singletons and factories

Spring uses a BeanFactory to create, manage and
locate beans which are basically instances of a
class
Typical

usage is an XML bean factory which allows

configuration via XML files

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

Configuring an XMLWebApplicationContext
<context-param>
<param-name>contextConfigLocation</paramname>
<param-value>
/WEB-INF/applicationContext.xml
</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoader
Listener
</listener-class>
</listener>

Configuring an XMLWebApplicationContext
<context-param>
<param-name>contextConfigLocation</paramname>
<param-value>
/WEB-INF/applicationContext.xml
</param-value>
</context-param>
<servlet>
<servlet-name>context</servlet-name>
<servlet-class>
org.springframework.web.context.ContextLoader
Servlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>

Spring AOP

Spring
AOP
Framework
that builds on the aopalliance interfaces.

Aspects are coded with pure Java code. You do not need
to learn pointcut query languages that are available in other
AOP implementations.
Separates the core business code from the aspects we
wrap around it: security, transaction management,
monitering,logging
Spring aspects can be configured using its own IoC
container.

Objects obtained from the IoC container can be transparently

advised based on configuration

Spring AOP has built in aspects such as providing

transaction management, performance monitoring and
more for your beans
Spring AOP is not as robust as some other implementations
such as AspectJ.

However, it does support common aspect uses to solve common

problems in enterprise applications

Spring
AOP to separate concerns, increase
Attempts
modularity, and decrease redundancy
Separation

Break up features to minimize overlap

Dont

of Concerns (SoC)

Repeat Yourself (DRY)

Minimize code duplication

Cross-Cutting

Concerns

Program aspects that affect many others (e.g. logging)

AspectJ is the top AOP package

 Supports
Spring
AOPthe following advices:

method before
method after returning
throws advice
around advice (uses AOPAlliance MethodInterceptor directly)

Spring allows you to chain together interceptors and

advice with precedence.
Aspects are weaved together at runtime. AspectJ uses
compile time weaving.
Spring AOP also includes advisors that contain advice
and pointcut filtering.
ProxyFactoryBean sources AOP proxies from a Spring
BeanFactory
IoC + AOP is a great combination that is non-invasive
Through AOP, we add transversal functionalities to
objects (ie not directly related to the code it contains)

2. Spring principles: AOP

Without AOP

With AOP

2. Spring principles: AOP

Useful for automatic handling of transaction
with Hibernate
Useful for Acegi (automatic credentials
checking before executing some methods)
Code smaller, easier to read (not polluted
by transversal aspects not directly relevant)

Spring Database Components

Consistent Abstract Classes for DAO Support

Extend your DAO classes with the proper xxxDAOSupport class

that matches your persistence mechanism.
JdbcDaoSupport
Super class for JDBC data access objects.
Requires a DataSource to be set, providing a JdbcTemplate based
on it to subclasses.

HibernateDaoSupport
Super class for Hibernate data access objects.
Requires a SessionFactory to be set, providing a
HibernateTemplate based on it to subclasses.

JdoDaoSupport
Super class for JDO data access objects.
Requires a PersistenceManagerFactory to be set, providing a
JdoTemplate based on it to subclasses.

SqlMapDaoSupport
Supper class for iBATIS SqlMap data access object.
Requires a DataSource to be set, providing a SqlMapTemplate

Spring DAO Templates

Built in code templates that support JDBC, Hibernate,

JDO, and iBatis SQL Maps
Simplifies data access coding by reducing redundant
code and helps avoid common errors.
Alleviates opening and closing connections in your
DAO code.
No more ThreadLocal or passing Connection/Session
objects.
Transaction management is handled by a wired bean
You are dropped into the template with the resources
you need for data access Session,
PreparedStatement, etc.
Code only needs to be implemented in callback
methods.

doInXXX(Object)

Optional separate JDBC framework

Ex: Code without a template

public class OrderHibernateDAO implements IOrderDAO {
public Order saveOrder(Order order) throws
OrderException{
Session s = null;
Transaction tx = null;
try{
s = ... // get a new Session object
tx = s.beginTransaction();
s.save(order);
tx.commit();
} catch (HibernateException he){
// log, rollback, and convert to OrderException
} catch (SQLException sqle){
// log, rollback, and convert to OrderException
} finally {
s.close(); // needs a try/catch block
}
return order;
}

Ex: Spring DAO Template Example

public class OrderHibernateDAO extends HibernateDaoSupport
implements IOrderDAO {
...
public Order saveOrder(final Order order) {
return (Order) getHibernateTemplate().execute(new
HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
session.save(order);
return order;
}
});
}
...
}

Consistent Exception Handling

Spring has its own exception handling hierarchy for DAO logic.

No more copy and pasting redundant exception logic!

Exceptions from JDBC, or a supported ORM, are wrapped up

into an appropriate, and consistent, DataAccessException and
thrown.

This allows you to decouple exceptions in your business logic.

These exceptions are treated as unchecked exceptions that you

can handle in your business tier if needed. No need to try/catch
in your DAO.

Define your own exception translation by subclassing classes

such as SQLErrorCodeSQLExceptionTranslator

Spring and Testing

Easier test driven development (TDD)
Integration testing

Can

use a standalone Spring configuration

with mock objects for testing.
Consider XMLApplicationContext or
FileSystemApplicationContext.

Unit testing
Allows

you to test outside the container

without using the Spring container.

Easy to test POJOs

Spring MVC Framework

MVC Framework

Clear separation of roles: controller, validator, form object,

Dispatch servlet, View resolver,
Extensible and adaptable
Several views of a result (pdf, excel, html, )
Can be wired (possible to use transparently the IoC pattern).
Spring Annotation Based Controllers
Spring 2.5 introduced support for annotation based MVC
controllers. @RequestMapping, @RequestParam,
@ModelAttribute are some of the annotations provided for this
implementation.

Can be used with other frameworks: JSF, Struts,

Tapestry, Webwork
Completely transparent: no need to change anything in
what is done by these other frameworks

Benefits of the Spring Web MVC

Framework
The Spring Web MVC Framework is a robust, flexible, and
well-designed framework for rapidly developing web
applications using the MVC design pattern.The benefits
achieved from using this Spring module are similar to
those you get from the rest of the Spring Framework
Easier testingThis is a common theme you will find
across all the Spring classes.The fact that most of Springs
classes are designed as JavaBeans enables you to inject
test data using the setter methods of these classes. Spring
also provides mock classes to simulate Java HTTP objects
(HttpServletRequest, for example), which makes unit
testing of the web layer much simpler.

Benefits of the Spring Web MVC

Framework
Bind directly to business objectsSpring MVC does not
require your business (model) classes to extend any special
classes; this enables you to reuse your business
objects by binding them directly to the HTML forms fields. In
fact, your controller classes are the only ones that are
required to extend Spring classes (or implement a Spring
controller interface).
Clear separation of rolesSpring MVC nicely separates the
roles played by the various components that make up this
web framework. For example, when we dis-cuss concepts
such as controllers, command objects, and validators, you
will begin to see how each component plays a distinct role.

Benefits of the Spring Web MVC

Framework
Simple but powerful tag librarySpring's tag library is
small, straightforward, but powerful. For example. Spring
uses the JSP expression language (EL) for arguments
to the <spring :bind> tag.
Web FlowThis module is a subproject and is not bundled
with the Spring core distribution. It is built on top of Spring
MVC and adds the capability to easily write wizard like
web applications that span across several HTTP requests
(an online shopping cart, for example).

Benefits of the Spring Web MVC

Framework
View technologies and web frameworksAlthough we are
using JSP as our view technology. Spring supports odier
view technologies as well, such as Apache Velocity and
FreeMarker.This is a powerful concept because switching
from JSP to Velocity is a matter of configura-tion.
Furthermore, Spring provides integration support for Apache
Struts.
Lighter-weight environmentAs I mentioned in die
previous chapter. Spring enables you to build enterpriseready applications using FOJOs; the environment
setup can be simpler and less expensive because you could
develop and deploy your application using a lighter-weight
servlet container.

Features of Spring Web MVC

Spring's web module provides a wealth of unique web support
features, including:
Clear separation of roles - controller, validator, command
object, form object, model object, DispatcherServlet, handler
mapping, view resolver, etc. Each role can be fulfilled by a
specialized object.
Powerful and straightforward configuration of both framework
and application classes as JavaBeans, including easy
referencing across contexts, such as from web controllers to
business objects and validators.
Adaptability, non-intrusiveness. Use whatever controller
subclass you need (plain, command, form, wizard, multi-action,
or a custom one) for a given scenario instead of deriving from a
single controller for everything.
Reusable business code - no need for duplication. You can use
existing business objects as command or form objects instead of
mirroring them in order to extend a particular framework base

Features of Spring Web MVC

Customizable

locale and theme resolution, support for JSPs

with or without Spring tag library, support for JSTL, support for
Velocity without the need for extra bridges, etc.
A simple yet powerful JSP tag library known as the Spring tag
library that provides support for features such as data binding
and themes. The custom tags allow for maximum flexibility in
terms of markup code. For information on the tag library
descriptor.
A JSP form tag library, introduced in Spring 2.0, that makes
writing forms in JSP pages much easier. For information on the
tag library descriptor.
Beans whose lifecycle is scoped to the current HTTP request
or HTTP Session. This is not a specific feature of Spring MVC
itself, but rather of the WebApplicationContext container(s) that
Spring MVC uses. These bean scopes are described in detail in
the section entitled.

Features of Spring Web MVC

Customizable binding and validation - type mismatches as

application-level validation errors that keep the offending value,
localized date and number binding, etc instead of String-only
form objects with manual parsing and conversion to business
objects.
Customizable handler mapping and view resolution - handler
mapping and view resolution strategies range from simple URLbased configuration, to sophisticated, purpose-built resolution
strategies. This is more flexible than some web MVC
frameworks which mandate a particular technique.
Flexible model transfer - model transfer via a name/value Map
supports easy integration with any view technology.

4. A full MVC Framework

Working Of MVC Framework

The Spring web MVC framework provides model-view-controller architecture

and ready components that can be used to develop flexible and loosely
coupled web applications. The MVC pattern results in separating the
different aspects of the application (input logic, business logic, and UI logic),
while providing a loose coupling between these elements.
The Model encapsulates the application data and in general they will consist
of POJO.
The View is responsible for rendering the model data and in general it
generates HTML output that the client's browser can interpret.
The Controller is responsible for processing user requests and building
appropriate model and passes it to the view for rendering.

The DispatcherServlet
The Spring Web model-view-controller (MVC) framework is
designed around a DispatcherServlet that handles all the
HTTP requests and responses. The request processing
workflow of the Spring Web MVC DispatcherServlet is
illustrated in the following diagram:

Following is the sequence of events corresponding to an incoming HTTP request

to DispatcherServlet:
After receiving an HTTP request, DispatcherServlet consults
the HandlerMapping to call the appropriate Controller.
The Controller takes the request and calls the appropriate service methods based
on used GET or POST method. The service method will set model data based on
defined business logic and returns view name to the DispatcherServlet.
The DispatcherServlet will take help from ViewResolver to pickup the defined
view for the request.
Once view is finalized, The DispatcherServlet passes the model data to the view
which is finally rendered on the browser.

All the above mentioned components ie. HandlerMapping, Controller and ViewResolver are parts
ofWebApplicationContext which is an extension of the plain ApplicationContext with some extra features necessary for web
applications.

Even More Spring Components

JavaMail helpers
Many ORM tools are supported: Hibernate, JDO, Apache OJB, iBATIS
Templates using IoC to reduce the amount of code in the DAO objects
Scheduling support via Quartz
Convenience implementation classes for

Remoting support JAXRPC, RMI, Hessian, and Burlap

EJB support for easier access.

Acegi Security System for Spring

http://acegisecurity.sourceforge.net/
Very good framework!

Eclipse Plugin Spring IDE for Eclipse

Coming soon

JMS implementation classes

JMX support