This document provides an overview of the Spring framework. Key points include: - Spring is a lightweight container that promotes loose coupling and separation of concerns through dependency injection. - It simplifies programming without J2EE by providing declarative transaction management and abstraction from underlying technologies. - Spring uses dependency injection and inversion of control to configure and wire together components. It supports setter, constructor, and autowiring of dependencies. - The Spring container manages the lifecycle of beans through initialization and destruction callbacks.

1. Spring
Paul Jensen
Principal, Object Computing Inc.

2. Spring Overview
 “Lightweight Container”
 Very loosely coupled
 Components widely reusable and separately
packaged
 Created by Rod Johnson
 Based on “Expert one-on-one J2EE Design and
Development”
 Currently on version 1.1.1

3. 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)

4. Why Use Spring?
 Conversion of checked exceptions to
unchecked
 (Or is this a reason not to use it?)
 Not an all-or-nothing solution
 Extremely modular and flexible
 Well designed
 Easy to extend
 Many reusable classes

5. Spring Framework

6. Spring Application

7. 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

8. 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

9. 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.

10. 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"/>

11. 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">

12. 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

13. 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”

14. 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

15. 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

16. 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()

17. 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”);

18. 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

19. 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

20. 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

21. 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

22. 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>

23. Spring AOP

24. 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

25. 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.

26. 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

27. 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);
}

28. 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

29. 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

30. 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.
}
}

31. 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

32. 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
}
}

33. 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>

34. 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>

35. 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

36. 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

37. 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

38. Transactions

39. AOP Transactions
 Spring provides AOP support for declarative
transactions
 Delegates to a PlatformTransactionManager
instance
 DataSourceTransactionManager
 HibernateTransactionManager
 JdoTransactionManager
 JtaTransactionManager

40. 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>

41. 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)

42. 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>

43. 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"
autowire="byType"> using transactionManager
</bean>
<bean id="transactionAttributeSource" Caches metadata
class="org...AttributesTransactionAttributeSource" from classes
autowire="constructor">
</bean>
<bean id="attributes"
class="org...CommonsAttributes"
/>

44. Data Access

45. 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

46. 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);
}

47. 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()]);

48. 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()]);
}
}

49. 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>

50. 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

51. Web Framework

52. DispatcherServlet
 The DispatcherServlet is the Spring Front
Controller
 Initializes WebApplicationContext
 Uses /WEB-INF/[servlet-name]-servlet.xml by
default
 WebApplicationContext is bound into
ServletContext

53. 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

54. Dispatcher Servlet Configuration
 MultipartResolver
 Handling of file upload
 LocaleResolver
 Default uses HTTP accept header, cookie, or
session

55. 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

56. Controller Implementations
 CommandControllers bind parameters to data
objects
 AbstractCommandController
 AbstractFormController
 SimpleFormController
 WizardFormController

57. 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