Spring
Spring Overview
Spring Container Concepts
Spring and AOP
Spring and Data Access
Managing Transactions and Resources
Remoting and Accessing Enterprise Services
Spring Web Framework
Integrating with Struts
DAO and LDAP support
Spring Overview
Spring is a Lightweight Application Framework
Spring Promotes loose coupling through Inversion
of Control (IoC)
Spring comes with rich support for
Aspect-Oriented Programming.
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
Declarative programming without J2EE
Easily configured aspects, esp. transaction
support
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
Architectural benefits
Spring can effectively organize your middle tier objects, whether
or not you choose to use EJB.
Spring's configuration management services can be used in any
architectural layer, in whatever runtime environment.
Spring can use AOP to deliver declarative transaction
management without using an EJB container.
Architectural benefits
Spring provides a consistent framework for data access,
whether using JDBC or an O/R mapping product such as
TopLink, Hibernate
Spring provides a consistent, simple programming model in
many areas JDBC, JMS, JavaMail, JNDI and many other
important API’s.
Spring Framework
The Spring framework is a layered architecture
consisting of seven well-defined modules. The
Spring modules are built on top of the core
container, which defines how beans are created,
configured and managed.
Spring Framework
Spring Framework
Core container
Provides the essential functionality of the Spring
framework.
Primary component of the core container is the
BeanFactory, an implementation of the Factory
pattern.
BeanFactory applies the Inversion of Control (IOC)
pattern to separate an application's configuration and
dependency specification from the actual application code.
Spring Framework
Spring context
Spring context is a configuration file that provides context
information to the Spring framework. The Spring context
includes enterprise services such as JNDI, EJB, e-mail,
validation, and scheduling functionality.
Spring Framework
Spring AOP
The Spring AOP integrates aspect-oriented
functionality directly into the Spring framework.
Provides transaction management services for objects
in any Spring-based application.
Incorporates declarative transaction management
capabilities into applications without relying on EJB
components.
Spring Framework
Spring DAO
Spring JDBC DAO abstraction layer offers exception hierarchy
for managing the exception handling and error messages
thrown by different database vendors.
The exception hierarchy simplifies error handling and greatly
reduces the amount of exception code you need to write, such
as opening and closing connections.
Spring DAO's JDBC-oriented exceptions comply to its generic
DAO exception hierarchy.
Spring Framework
Spring ORM
The Spring framework plugs into several ORM
frameworks to provide its Object Relational tool,
including JDO and Hibernate.
All of these comply to Spring's generic transaction
and DAO exception hierarchies.
Spring Framework
Spring Web module
The Web context module builds on top of the application context
module, providing contexts for Web-based applications.
The Web module also eases the tasks of handling multi-part
requests and binding request parameters to domain objects.
Spring MVC framework
The Model-View-Controller (MVC) framework
featured MVC implementation for building Web
applications.
The MVC framework is highly configurable via
strategy interfaces and accommodates numerous
view technologies including JSP, Velocity, Tiles
and iText.
Aspect Oriented Programming
Aspect-oriented programming, or AOP, is a
programming technique that allows programmers to
modularize crosscutting concerns, or behavior that
cuts across the typical divisions of responsibility,
such as logging and transaction management.
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”);
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 (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.
XmlBeanFactory Example
Property and constructor based IoC
1
1
Bean Creation
Direct instantiation
BeanFactory instantiation
Same syntax but class is subclass of BeanFactory
getObject() called to obtain Bean
Static Factory
Instance Factory Method
Autowiring Properties
Beans may be auto-wired (rather than using
)
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”
Web Initialization
Web applications may use
ContextLoaderListener to initialize Spring
web.xml
contextConfigLocation
/WEB-INF/daoContext.xml /WEB-INF/applicationContext.xml
org.springframework.web.context.ContextLoaderListener
Automatically done by Spring DispatcherServlet
ApplicationContext Example
database.properties
${database.connection.driver_class}
${database.connection.url}
Spring AOP
AOP Fundamentals
Aspect-oriented programming (AOP) provides
for simplified application of cross-cutting
concerns
Transaction management
Security
Logging
Auditing
Locking
Transactions
AOP Transactions
Spring provides AOP support for
declarative transactions
Delegates to a
PlatformTransactionManager instance
DataSourceTransactionManager
HibernateTransactionManager
JdoTransactionManager
JtaTransactionManager
Transaction Configuration
com/../model/*.hbm.xml
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
Injecting Transaction Support
Declarative transaction support for single bean
PROPAGATION_REQUIRED
PROPAGATION_REQUIRED,readOnly
Transaction Autoproxy
support
based on attributes
Caches metadata
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
DAO Support
The Data Access Object (DAO) support
in Spring is primarily aimed at making it
easy to work with data access
technologies like JDBC, Hibernate or
JDO in a standardized way.
DAO Support
com.bt.bbv.r1oss
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
com/jensenp/Reservation/Room.hbm.xml
com/jensenp/Reservation/Reservation.hbm.xml
com/jensenp/Reservation/Resource.hbm.xml
${hibernate.dialect}
${hibernate.hbm2ddl.auto}
${hibernate.show_sql}
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
Integration with Struts
Integration with Struts
-
CISP
classpath:com/btexact/cisp/api/CispApiEJB.wsdl
-
com.bt.bbv.core.service.cisp.webservice.CispApiEJBPort
CispApiEJB
CispApiEJBPort
com.btexact.cisp.api.CispApiEJBPort
Integration with LDAP
References
Spring’s homepage: http://www.springframework.org
“Introducing the Spring Framework” by Rod Johnson:
http://theserverside.com/news/thread.jsp?thread_id=2
1893
“Inversion of control containers and dependency
injection” by Martin Fowler:
http://www.martinfowler.com/articles/injection.html
AOP Alliance: http://aopalliance.sourceforge.net