You are on page 1of 74

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 noninvasive, capable of assembling a complex system from a set of looselycoupled 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”> Same syntax but class is subclass of BeanFactory getObject() called to obtain Bean <bean id=“beanId” class=“className" factory-method=" staticCreationMethod“> <bean id=“beanId” factory-bean=“existingBeanId" factorymethod=“nonStaticCreationMethod">

BeanFactory instantiation
 

Static Factory

Instance Factory Method

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

    

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>

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></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 Typically, methods

Joinpoint - Execution point to target

 

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 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> <value>debugInterceptor</value> </list> </property> </bean>

Advisors applied in order

 

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


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

Generic autoproxy support Invokes interceptor based on attributes Applies transaction using transactionManager Caches metadata from classes

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="">${} </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

   

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


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


Give project name as HelloWorld and click Finish


Right Click on the Project and Add Spring Capabilities, which add all the resources required for executing the spring application


Click Next


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


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


Create a java class called HelloWorld , by right clicking on the src directory of the project New -> Class


Give the package and class name and click Finish




Running the Application

Right click on the and Run As , Java Application


Successful execution will display the value that is set as value in applicationContext.xml


 

Spring’s homepage: “Introducing the Spring Framework” by Rod Johnson: “Inversion of control containers and dependency injection” by Martin Fowler: AOP Alliance:

Thank You