Spring l.jpg
This presentation is the property of its rightful owner.
Sponsored Links
1 / 54

Spring PowerPoint PPT Presentation


  • 190 Views
  • Uploaded on
  • Presentation posted in: General

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.

Download Presentation

Spring

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


Spring l.jpg

Spring


Slide2 l.jpg

  • 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 l.jpg

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 overview4 l.jpg

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

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 spring6 l.jpg

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

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 benefits8 l.jpg

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

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 framework10 l.jpg

Spring Framework


Spring framework11 l.jpg

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 framework12 l.jpg

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 framework13 l.jpg

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 framework14 l.jpg

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 framework15 l.jpg

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 framework16 l.jpg

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.


Slide17 l.jpg

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

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

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

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

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

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

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


Autowiring properties l.jpg

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”


Web initialization l.jpg

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


Applicationcontext example l.jpg

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

Spring AOP


Aop fundamentals l.jpg

AOP Fundamentals

  • Aspect-oriented programming (AOP) provides for simplified application of cross-cutting concerns

    • Transaction management

    • Security

    • Logging

    • Auditing

    • Locking


Transactions l.jpg

Transactions


Aop transactions l.jpg

AOP Transactions

  • Spring provides AOP support for declarative transactions

  • Delegates to a PlatformTransactionManager instance

    • DataSourceTransactionManager

    • HibernateTransactionManager

    • JdoTransactionManager

    • JtaTransactionManager


Transaction configuration l.jpg

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

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

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

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

Data Access


Data access36 l.jpg

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

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 support38 l.jpg

DAO Support

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean" lazy-init="default" autowire="default" dependency-check="default">

<property name="jndiName">

<value>com.bt.bbv.r1oss</value>

</property>

</bean>

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate" lazy-init="default" autowire="default" dependency-check="default">

<property name="dataSource">

<ref bean="dataSource" />

</property>

</bean>

</beans>


Hibernate dao example l.jpg

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

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 d41 l.jpg

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

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

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

Web Framework


Dispatcherservlet l.jpg

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

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

Dispatcher Servlet Configuration

  • MultipartResolver

    • Handling of file upload

  • LocaleResolver

    • Default uses HTTP accept header, cookie, or session


Controllers l.jpg

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

Controller Implementations

  • CommandControllers bind parameters to data objects

  • AbstractCommandController

  • AbstractFormController

  • SimpleFormController

  • WizardFormController


Integration with struts l.jpg

Integration with Struts

  • <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn"><set-propertyproperty="contextConfigLocation" value="/WEB-INF/spring/core/spring-advice.xml,/WEB-INF/spring/core/spring-dao.xml,/WEB-INF/spring/core/spring-email.xml,/WEB-INF/spring/core/spring-services.xml,/WEB-INF/spring/core/spring-tasks.xml,/WEB-INF/spring/core/spring-webservices.xml" />

  • </plug-in>


Integration with struts51 l.jpg

Integration with Struts

  • <bean id="CispWebService" class="com.bt.bbv.core.util.webservices.WebServiceProxyFactoryBean">

  • </property>- <property name="servicePrefix">

  •   <value>CISP</value>  

  • </property> <property name="wsdlDocumentUrl"> 

  • <value>classpath:com/btexact/cisp/api/CispApiEJB.wsdl</value>

  • </property>- <property name="serviceInterface"> <value>com.bt.bbv.core.service.cisp.webservice.CispApiEJBPort</value>

  • <property name="serviceName"><value>CispApiEJB</value>

  • </property> <property name="portName">  <value>CispApiEJBPort</value>

  • </property> <property name="portInterface"><value>com.btexact.cisp.api.CispApiEJBPort</value></property>

  • </bean>


Integration with ldap l.jpg

Integration with LDAP

  • <public class TraditionalPersonDaoImpl implements PersonDao {

  • public List getAllPersonNames() {

  • Hashtable env = new Hashtable();

  • env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");

  • env.put(Context.PROVIDER_URL, "ldap://localhost:389/dc=example,dc=com");

  • DirContext ctx = new InitialDirContext(env);

    • }

    • catch (NamingException e) {

  • throw new RuntimeException(e);

  • }


Integration with ejb l.jpg

Integration with EJB

<bean id="myComponent“ class="org.springframework.ejb.access.LocalStatelessSessionProxyFactoryBean">

  • <property name="jndiName" value="ejb/myBean"/> <property name="businessInterface" value="com.mycom.MyComponent"/> </bean>


References l.jpg

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


  • Login