Spring

Paul JensenPrincipal, Object Computing Inc.

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

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)

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

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

ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml"); MyBeanClass bean = (MyBeanClass)ctx.getBean(“myBean”);

OR

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

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

web.xml

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)

public interface MethodMatcher { boolean matches(Method m, Class targetClass); boolean isRuntime(); boolean matches(Method m, Class targetClass, Object[] args);}

Pointcut may be statically or dynamically evaluated based on isRuntime()

Abstract class StaticMethodMatcherPointcut requires override of 1st method only

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

mixinspublic 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"> <value>ex.Meeting</value> </property>

<property name="target"><ref local=“meetingTarget"/></property>

<property name="interceptorNames"> <list> <value>myAdvisor</value> <value>debugInterceptor</value> </list> </property></bean>

Advisors applied in order

All methodsusing CGLib if none defined

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

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

Declarative transaction support for single bean

Transaction Autoproxy<bean id="autoproxy" class="org...DefaultAdvisorAutoProxyCreator"></bean>

<bean id="transactionAdvisor" class="org...TransactionAttributeSourceAdvisor" autowire="constructor" ></bean>

<bean id="transactionInterceptor" class="org...TransactionInterceptor" autowire="byType"> </bean>

<bean id="transactionAttributeSource" class="org...AttributesTransactionAttributeSource" autowire="constructor"></bean>

<bean id="attributes" class="org...CommonsAttributes"/>

Caches metadatafrom classes

Generic autoproxysupport

Applies transactionusing transactionManager

Invokes interceptorbased on attributes

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

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