Spring Overview

Santosh Kothapalli
 Spring Origin
 Created by Rod Johnson

Based on “Expert one-on-one J2EE Design
and Development”

Currently on version 3.0.x
 Spring Mission
 J2EE should be easier to use
 It is 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 platform shouldn't force you
to catch exceptions you're unlikely to be able to recover from.
 Testability is essential, and a platform such as Spring should help make
your code easier to test
 Why Use Spring?
 Wiring of components (Dependency Injection)

Promotes/simplifies decoupling, design to
interfaces, TDD
 Declarative programming without J2EE
 Easily configured aspects, esp. transaction support
 Simplify use of popular technologies
 Abstractions insulate application from specifics,
eliminate redundant code, and handle common
error conditions

Underlying technology specifics still accessible
(closures)
 Spring Features
 The most complete lightweight container, providing centralized,
automated configuration and wiring of your application objects. The
container is non-invasive, capable of assembling a complex system from a
set of loosely-coupled components (POJOs) in a consistent and
transparent fashion. The container brings agility and leverage, and
improves application testability and scalability by allowing software
components to be first developed and tested in isolation, then scaled up for
deployment in any environment (J2SE or J2EE).

 A common abstraction layer for transaction management, allowing for

pluggable transaction managers, and making it easy to demarcate
transactions without dealing with low-level issues. Generic strategies for
JTA and a single JDBC DataSource are included. In contrast to plain JTA
or EJB CMT, Spring's transaction support is not tied to J2EE environments.

 A JDBC abstraction layer that offers a meaningful exception hierarchy

(no more pulling vendor codes out of SQLException), simplifies error
handling, and greatly reduces the amount of code you'll need to write.
You'll never need to write another finally block to use JDBC again. The
JDBC-oriented exceptions comply to Spring's generic DAO exception
 Spring Features
 Integration with Toplink, Hibernate, JDO, and iBATIS SQL Maps: in
terms of resource holders, DAO implementation support, and transaction
strategies. First-class Hibernate support with lots of IoC convenience
features, addressing many typical Hibernate integration issues. All of these
comply to Spring's generic transaction and DAO exception hierarchies.

 AOP functionality, fully integrated into Spring configuration

management. You can AOP-enable any object managed by Spring,
adding aspects such as declarative transaction management. With Spring,
you can have declarative transaction management without EJB... even
without JTA, if you're using a single database in Tomcat or another web
container without JTA support.

 A flexible MVC web application framework, built on core Spring

functionality. This framework is highly configurable via strategy interfaces,
and accommodates multiple view technologies like JSP, Velocity, Tiles,
iText, and POI. Note that a Spring middle tier can easily be combined with
a web tier based on any other web MVC framework, like Struts, WebWork,
or Tapestry.
 Benefits of Spring over other
frameworks
 Spring provides a very clean division between controllers, JavaBean
models, and views

 Spring has layered architecture. Use what you need and leave you don't
need now.

 Spring has a well defined interface to business layer

 Spring Enables POJO Programming. There is no behind the scene magic

here. POJO programming enables continuous integration and testability.

 Dependency Injection and Inversion of Control Simplifies JDBC

 Open source and no vendor lock-in.

Spring Framework
Spring Application
 Spring Dependency Injection
 Inversion of Control (IoC)
 “Hollywood Principle”

Don't call me, I'll call you
 “Container” resolves (injects) dependencies of components by setting
implementation object (push)
 As opposed to component instantiating or Service Locator pattern where
component locates implementation (pull)
 Martin Fowler calls Dependency Injection
 Dependency Injection Variants
 Variations on dependency injection

Interface based (Avalon)

Constructor-based (PicoContainer, Spring)

Setter-based (Spring)
 BeanFactory provides configuration framework to initialize and “wire”
JavaBeans
 org.springframework.beans and org.springframework.context

 Typically use the XmlBeanFactory, employing XML configuration files

 Dependency Injection (cont'd)
 BeanFactory configured components need have no Spring
dependencies

Simple JavaBeans
 Beans are singletons by default
 Properties may be simple values or references to other beans
 Built-in support for defining Lists, Maps, Sets, and Properties collection
types.
 Custom PropertyEditors may be defined to convert string values to

other, arbitrary types.

 XmlBeanFactory Example
 Property and constructor based IoC
<bean id="exampleBean" class="examples.ExampleBean">
<property name="beanOne"><ref bean="anotherExampleBean"/></property>
<property name="beanTwo"><ref bean="yetAnotherBean"/></property>
<property name="integerProperty">1</property>
</bean>

<bean id="anotherExampleBean" class="examples.AnotherBean"/>

<bean id="yetAnotherBean" class="examples.YetAnotherBean"/>

<bean id="exampleBean" class="examples.ExampleBean">

<constructor-arg><ref bean="anotherExampleBean"/></constructor-arg>
<constructor-arg><ref bean="yetAnotherBean"/></constructor-arg>
<constructor-arg><value>1</value></constructor-arg>
</bean>

<bean id="anotherExampleBean" class="examples.AnotherBean"/>

<bean id="yetAnotherBean" class="examples.YetAnotherBean"/>
 Bean Creation
 Direct instantiation
 <bean id=“beanId” class=“className”>
 BeanFactory instantiation
 Same syntax but class is subclass of BeanFactory
 getObject() called to obtain Bean
 Static Factory
 <bean id=“beanId” class=“className" factory-method="
staticCreationMethod“>
 Instance Factory Method
 <bean id=“beanId” factory-bean=“existingBeanId" factory-
method=“nonStaticCreationMethod">
 Bean Creation
 Beans may be singletons or “prototypes”

Attribute singleton=“false” causes instantiation with each getBean()
lookup

Singleton is default
 XmlBeanFactory pre-instantiates singletons

May be overridden on per-instance basis by lazy-init=“true”
 Beans may also be marked abstract, allowing reuse of attribute values
through inheritance
 Autowiring Properties
 Beans may be auto-wired (rather than using <ref>)

Per-bean attribute autowire

Explicit settings override
 autowire=“name”
 Bean identifier matches property name

 autowire=“type”
 Type matches other defined bean

 autowire=”constructor”

Match constructor argument types
 autowire=”autodetect”

Attempt by constructor, otherwise “type”
 Dependency Checking
 Ensures properties are defined

Per-bean attribute dependency-check

None required by default

Verifies autowiring succeeded
 “simple”
 all but collaborators

 “object”
 collaborators only

 “all”

Collaborators, primitive types, and collections
 Lifecycle Customization
 Can define init method called after properties set

init-method=”<method-name>”
 Can define destroy method as shutdown hook

destroy-method=”<method-name>”
 May alternatively implement InitializingBean and/or DisposableBean

At cost of Spring dependency
 BeanFactory Miscellany
 BeanFactoryAware interface provides BeanFactory for bean

setBeanFactory(BeanFactory)
 BeanNameAware interface provides bean name

setBeanName(String)
 FactoryBean for beans which are themselves factories

Object getObject()

Boolean isSingleton()

Class getObjectType()
 BeanFactory Usage
InputStream is = new FileInputStream("beans.xml");
XmlBeanFactory factory = new XmlBeanFactory(is);
MyBeanClass bean = (MyBeanClass)factory.getBean(“myBean”);

OR

ApplicationContext ctx = new

ClassPathXmlApplicationContext("beans.xml");
MyBeanClass bean = (MyBeanClass)ctx.getBean(“myBean”);
 ApplicationContext
 Extends functionality of BeanFactory
 Pre-instantiates singleton beans
 Detects and registers BeanPostProcessors and
BeanFactoryPostProcessors
 Supports nesting of contexts
 ApplicationListener and ApplicationEvents
 Initialized and closed predefined

 Custom may be created

 MessageSource provides i18n messaging


<bean id=”messageSource”
class=”...ResourceBundleMessageSource”/>

Contains list of bundle base names
 Web Initialization
 Web applications may use ContextLoaderListener to initialize Spring

web.xml
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/daoContext.xml /WEB-INF/applicationContext.xml
</param-value>
</context-param>

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

Automatically done by Spring DispatcherServlet

 Specialized Beans
 MethodInvokingFactoryBean

Invokes method on registered beans or any static methods

Stores return value
 SingletonBeanFactoryLocator and ContextSingletonBeanFactoryLocator

Useful for sharing BeanFactories

Eliminate duplication of beans in multiple similar factories or contexts
 ApplicationContext
customization
 Defined beans inheriting from BeanFactoryPostProcessor are detected and
invoked
 CustomEditorConfigurer
 Registers custom PropertyEditors for converting configuration string

values to specific types

 AutoProxyCreators
 Wrap beans in proxies based on various criteria (name, metadata, etc)

 PropertyResourceConfigurer
• Sets from property file and/or system properties
 ApplicationContext Example
<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location"><value>database.properties</value></property>
</bean>

<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>${database.connection.driver_class}</value>
</property>
<property name="url">
<value>${database.connection.url}</value>
</property>
</bean>
Spring AOP
 AOP Fundamentals
 Aspect-oriented programming (AOP) provides for simplified application
of cross-cutting concerns

Transaction management

Security

Logging

Auditing

Locking
 AOP sometimes (partially) achieved via Decorators or Proxies

CORBA Portable Interceptors

Servlet Filters
 AOP Fundamentals
 Aspect - Implementation of a cross-cutting concern.
 Spring Advisors or Interceptors

 Joinpoint - Execution point to target


Typically, methods
 Advice - Action taken at a particular joinpoint.
 Pointcut - A set of joinpoints specifying where advice should be applied
(e.g. Regular expression)
 Introduction/Mixin - Adding methods or fields to an advised class.
 Weaving - Assembling aspects into advised objects.
 Spring AOP
 Generally, applies aspects to beans using BeanFactory

Uses Dynamic Proxies if interface available otherwise CGLIB

CGLIB creates derived class which proxies requests
• Bean class may not be final
 Less capable than AspectJ

does not have field interception
 only runtime weaving solution is available

Closer integration with AspectJ anticipated
 Spring Pointcuts
 Pointcut applicability to a class may be evaluated statically or
dynamically
 Spring only creates proxies where necessary

public interface Pointcut {

ClassFilter getClassFilter();
MethodMatcher getMethodMatcher();
}
public interface ClassFilter {
boolean matches(Class clazz);
}
 Pointcuts (cont'd)
 Pointcut may be statically or dynamically evaluated based on isRuntime()
 Abstract class StaticMethodMatcherPointcut requires override of 1st method
only
public interface MethodMatcher {
boolean matches(Method m, Class targetClass);
boolean isRuntime();
boolean matches(Method m, Class targetClass, Object[] args);
}

Only called if isRuntime() == true

 Pointcuts (cont'd)
 Spring predefined pointcuts

In org.springframework.aop.support package
 RegexpMethodPointcut

Union of multiple regular expressions

Uses Jakarta ORO package
 ControlFlowPointcut
 Similar to AspectJ cflow

 Applied if call stack includes specific class and, optionally, method

 UnionPointcut

Merges pointcuts
 Spring Advice
 Can have per-class or per-instance Advice
 Spring provides several Advice types
 Around Advice
• AOP Alliance compliant
• Must call invocation.proceed() to call target

public class MyAdvice implements AroundAdvice {

Object invoke(MethodInvocation invocation) {
// change arguments, start transaction, lock, etc.
invocation.proceed();
// change return value, stop transaction, unlock,etc.
}
}
 Spring Advice
 MethodBeforeAdvice

void before(Method m, Object[] args, Object target)

Cannot alter return type
 ThrowsAdvice

Marker interface

Implementors define methods of form:
• afterThrowing([Method], [args], [target], subclassOfThrowable)
 AfterReturningAdvice

void afterReturning(Object returnValue, Method, m, Object[] args,
Object target)

Cannot modify return value
 Spring Advice
 IntroductionInterceptor provides ability to define mixins

public class RollbackAdvice extends DelegatingIntroductionInterceptor

implements RollbackSupport {
Map map = new HashMap();

void rollback(Date date) {

// rollback to state at given time
}

public Object invoke(MethodInvocation invocation) {

// record change and time of change
}
}
 Injecting Advice
<bean id=“meetingTarget" class=“ex.DefaultMeeting“
singleton=“false”>
<property name=“topic">Spring</property>
</bean>

<bean id="myAdvisor" class=“ex.RollbackAdvice"

singleton=”false”>
</bean>

<bean id="debugInterceptor"
class="org.springframework.aop.interceptor.DebugInterceptor">
</bean>
 Injecting Advice (cont'd)
<bean id=“meeting"
class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces"> All methods
<value>ex.Meeting</value> using CGLib
</property> if none defined
<property name="target"><ref local=“meetingTarget"/></property>

<property name="interceptorNames">
<list> Advisors applied in order
<value>myAdvisor</value>
<value>debugInterceptor</value>
</list>
</property>
</bean>
 Autoproxying
 Autoproxy bean definitions automatically proxy selected beans.
 BeanNameAutoProxyCreator

Adds listed advisors/interceptors to beans with names matching regular
expression
 DefaultAdvisorAutoProxyCreator

Generic autoproxy infrastructure support
 Applies all advisors defined in the context to all beans, proxying

appropriately
 Metadata support
 Spring supports obtaining meta data Object attributes at class, method,
and field level

Not yet argument level (as JSR-175)
 Currently supports Jakarta Commons Attributes
 Support for JSR-175 in work
 Metadata support provided via Attributes interface

Amenable to mocking unlike JDK reflection and Commons static
methods
 Metadata autoproxying
 Configuration of autoproxying based on metadata attributes simplifies
configuration

Define custom attribute class

Define Advisor with pointcut based on custom attribute

Add Advisor in ApplicationContext with autoproxy
 Examples

Transaction Attributes

Security Attributes

Pooling

Mapping of controllers to URLs
Transactions
 AOP Transactions
 Spring provides AOP support for declarative transactions
 Delegates to a PlatformTransactionManager instance

DataSourceTransactionManager

HibernateTransactionManager

JdoTransactionManager

JtaTransactionManager
Transaction Configuration
<bean id="sessionFactory"
class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
<property name="dataSource"><ref bean="dataSource"/></property>
<property name="mappingResources">
<list>
<value>com/../model/*.hbm.xml</value>
</list>
</property>
</bean>

<bean id="transactionManager”
class="org.springframework.orm.hibernate.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>
 Declarative Transactions
 Declarative transactional support can be added to any bean by using
TransactionProxyFactoryBean
 Similar to EJB, transaction attributes may be defined on a per-method basis
 Also allows definition of pre- and post- interceptors (e.g. for security)
Injecting Transaction Support

Declarative transaction support for single bean

<bean id=“reservationService"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager">
<ref bean="transactionManager"/>
</property>
<property name="target"><ref local=“reservationServiceTarget"/></property>
<property name="transactionAttributes">
<props>
<prop key=“reserveRoom*">PROPAGATION_REQUIRED</prop>
<prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>
 Transaction Autoproxy
<bean id="autoproxy" Generic autoproxy
class="org...DefaultAdvisorAutoProxyCreator">
</bean>
support

<bean id="transactionAdvisor"
class="org...TransactionAttributeSourceAdvisor"
Invokes interceptor
autowire="constructor" > based on attributes
</bean>

<bean id="transactionInterceptor" Applies transaction

class="org...TransactionInterceptor" using transactionManager
autowire="byType">
</bean>
Caches metadata
<bean id="transactionAttributeSource" from classes
class="org...AttributesTransactionAttributeSource"
autowire="constructor">
</bean>

<bean id="attributes"
class="org...CommonsAttributes"
/>
Data Access
 Data Access
 DAO support provides pluggable framework for persistence
 Currently supports JDBC, Hibernate, JDO, and iBatis
 Defines consistent exception hierarchy (based on RuntimeException)
 Provides abstract “Support” classes for each technology

Template methods define specific queries
 Hibernate DAO Example
public class ReservationDaoImpl extends HibernateDaoSupport
implements ReservationDao {
public Reservation getReservation (Long orderId) {
return (Reservation)getHibernateTemplate().load(Reservation .class,
orderId);
}

public void saveReservation (Reservation r) {

getHibernateTemplate().saveOrUpdate(r);
}

public void remove(Reservation Reservation) {

getHibernateTemplate().delete(r);
}
 Hibernate DAO (cont’d)

public Reservation[] findReservations(Room room) {

List list = getHibernateTemplate().find(
"from Reservation reservation “ +
“ where reservation.resource =? “ +
“ order by reservation.start",
instrument);
return (Reservation[]) list.toArray(new Reservation[list.size()]);
 Hibernate DAO (cont’d)
public Reservation[] findReservations(final DateRange range) {
final HibernateTemplate template = getHibernateTemplate();
List list = (List) template.execute(new HibernateCallback() {
public Object doInHibernate(Session session) {
Query query = session.createQuery(
"from Reservation r “ +
“ where r.start > :rangeStart and r.start < :rangeEnd “);
query.setDate("rangeStart", range.getStartDate()
query.setDate("rangeEnd", range.getEndDate())
return query.list();
}
});
return (Reservation[]) list.toArray(new Reservation[list.size()]);
}
}
 Hibernate Example
<bean id="sessionFactory"
class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
<property name="dataSource"><ref bean="dataSource"/></property>
<property name="mappingResources">
<list>
<value>com/jensenp/Reservation/Room.hbm.xml</value>
<value>com/jensenp/Reservation/Reservation.hbm.xml</value>
<value>com/jensenp/Reservation/Resource.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">${hibernate.dialect}</prop>
<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}
</prop>
<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
</props>
</property>
</bean>

<bean id=“reservationDao"
class="com.jensenp.Reservation.ReservationDaoImpl">
<property name="sessionFactory"><ref bean="sessionFactory"/>
</property>
</bean>
 JDBC Support
 JDBCTemplate provides
 Translation of SQLExceptions to more meaningful Spring Runtime

exceptions
 Integrates thread-specific transactions

 MappingSQLQuery simplifies mapping of ResultSets to Java objects

Web Framework
 DispatcherServlet
 The DispatcherServlet is the Spring Front Controller
 Initializes WebApplicationContext
 Uses /WEB-INF/[servlet-name]-servlet.xml by default
 WebApplicationContext is bound into ServletContext
DispatcherServlet Configuration
 HandlerMapping

Routing of requests to handlers
 HandlerAdapter

Adapts to handler interface. Default utilizes Controllers
 HandlerExceptionResolver

Maps exceptions to error pages

Similar to standard Servlet, but more flexible
 ViewResolver

Maps symbolic name to view
Dispatcher Servlet Configuration
 MultipartResolver

Handling of file upload
 LocaleResolver

Default uses HTTP accept header, cookie, or session
 Controllers
 Controller interface defines one method

ModelAndView handleRequest(HttpServletRequest req,
HttpServletResponse resp) throws Exception
 ModelAndView consists of a view identifier and a Map of model data
 Controller Implementations
 CommandControllers bind parameters to data objects
 AbstractCommandController
 AbstractFormController
 SimpleFormController
 WizardFormController
Creating Spring IOC
Application
 Hello World Application using Eclipse
 Create new Java Project , File->New->Java
Project
 Contd.
 Give project name as HelloWorld and click Finish
 Contd.
 Right Click on the Project and Add Spring Capabilities, which add all the
resources required for executing the spring application
 Contd.

 Click Next
 Contd.

 This adds the spring configuration file to the HelloWorld Project, Click
Finish
 Contd.

 On Successful creation of spring project you see applicationContext.xml

added to the HelloWorld project , similar to below screen shot in the
package explorer of Eclipse IDE
 Contd.
Create a java class called HelloWorld , by right clicking on the src directory of
the project
New -> Class
 Contd

 Give the package and class name and click Finish

 Contd.

 HelloWorld.java
 Contd.
 applicationContext.xml
 Running the Application

 Right click on the HelloWorld.java and Run As , Java Application

 Output

 Successful execution will display the value that is set as value in

applicationContext.xml
 References

 Spring’s homepage: http://www.springframework.org

 “Introducing the Spring Framework” by Rod Johnson:
http://theserverside.com/news/thread.jsp?thread_id=21893
 “Inversion of control containers and dependency injection” by Martin Fowler:
http://www.martinfowler.com/articles/injection.html
 AOP Alliance: http://aopalliance.sourceforge.net
Thank You