spring l.
Skip this Video
Loading SlideShow in 5 Seconds..
Spring PowerPoint Presentation
Download Presentation

Loading in 2 Seconds...

play fullscreen
1 / 57

Spring - PowerPoint PPT Presentation

  • Uploaded on

Spring. Paul Jensen Principal, 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.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Spring' - andrew

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

Paul Jensen

Principal, Object Computing Inc.

spring overview
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
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 spring4
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 dependency injection
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
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
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
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 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>



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

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

bean creation
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 creation12
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
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
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
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
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
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 Initialization
  • Web applications may use ContextLoaderListener to initialize Spring




<param-value>/WEB-INF/daoContext.xml /WEB-INF/applicationContext.xml






Automatically done by Spring DispatcherServlet

specialized beans
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
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
ApplicationContext Example

<bean id="propertyConfigurer"


<property name="location"><value>database.properties</value></property>


<bean id="dataSource"


<property name="driverClassName">



<property name="url">




aop fundamentals
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 fundamentals25
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 aop26
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
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
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 d29
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
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.


// change return value, stop transaction, unlock,etc.



spring advice31
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 advice32
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
Injecting Advice

<bean id=“meetingTarget" class=“ex.DefaultMeeting“


<property name=“topic">Spring</property>


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



<bean id="debugInterceptor"



injecting advice cont d
Injecting Advice (cont'd)

<bean id=“meeting"


<property name="proxyInterfaces">



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

<property name="interceptorNames">







All methods

using CGLib

if none defined

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
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
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
AOP Transactions
  • Spring provides AOP support for declarative transactions
  • Delegates to a PlatformTransactionManager instance
    • DataSourceTransactionManager
    • HibernateTransactionManager
    • JdoTransactionManager
    • JtaTransactionManager
transaction configuration
Transaction Configuration

<bean id="sessionFactory"


<property name="dataSource"><ref bean="dataSource"/></property>

<property name="mappingResources">






<bean id="transactionManager”


<property name="sessionFactory">

<ref bean="sessionFactory"/>



declarative transactions
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
Injecting Transaction Support

Declarative transaction support for single bean

<bean id=“reservationService"


<property name="transactionManager">

<ref bean="transactionManager"/>


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

<property name="transactionAttributes">


<prop key=“reserveRoom*">PROPAGATION_REQUIRED</prop>

<prop key="*">PROPAGATION_REQUIRED,readOnly</prop>




transaction autoproxy
Transaction Autoproxy

<bean id="autoproxy"



<bean id="transactionAdvisor"


autowire="constructor" >


<bean id="transactionInterceptor"




<bean id="transactionAttributeSource"




<bean id="attributes"



Generic autoproxy


Invokes interceptor

based on attributes

Applies transaction

using transactionManager

Caches metadata

from classes

data access45
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
Hibernate DAO Example

public class ReservationDaoImpl extends HibernateDaoSupport

implements ReservationDao {

public Reservation getReservation (Long orderId) {

return (Reservation)getHibernateTemplate().load(Reservation .class,



public void saveReservation (Reservation r) {



public void remove(Reservation Reservation) {



hibernate dao cont d
Hibernate DAO (cont’d)

public Reservation[] findReservations(Room room) {

List list = getHibernateTemplate().find(

"from Reservation reservation “ +

“ where reservation.resource =? “ +

“ order by reservation.start",


return (Reservation[]) list.toArray(new Reservation[list.size()]);

hibernate dao cont d48
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
Hibernate Example

<bean id="sessionFactory" class="org.springframework.orm.hibernate.LocalSessionFactoryBean">

<property name="dataSource"><ref bean="dataSource"/></property>

<property name="mappingResources">







<property name="hibernateProperties">


<prop key="hibernate.dialect">${hibernate.dialect}</prop>

<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}


<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>




<bean id=“reservationDao"


<property name="sessionFactory"><ref bean="sessionFactory"/>



jdbc support
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
  • 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
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
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
Controller Implementations
  • CommandControllers bind parameters to data objects
  • AbstractCommandController
  • AbstractFormController
  • SimpleFormController
  • WizardFormController
  • 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