Spring Overview

Umesh Adhikari
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 hierarchy.
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>
<value>myAdvisor</value> Advisors applied in order
<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"
class="org...DefaultAdvisorAutoProxyCreator">
</bean>
Generic autoproxy
<bean id="transactionAdvisor"
support
class="org...TransactionAttributeSourceAdvisor"
autowire="constructor" >
</bean>
Invokes interceptor
<bean id="transactionInterceptor" based on attributes
class="org...TransactionInterceptor"
autowire="byType">
</bean> Applies transaction
using transactionManager
<bean id="transactionAttributeSource"
class="org...AttributesTransactionAttributeSource"
autowire="constructor"> Caches metadata
</bean> from classes
<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