CSC 8520 Spring 2010. Paula MatuszekSlides based in part on and -part2.ppt CS 8520: Artificial.
Spring PPT
-
Upload
mumbai-academics -
Category
Documents
-
view
83 -
download
0
description
Transcript of Spring PPT
![Page 1: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/1.jpg)
Introduction to the Spring Framework
By Mumbai Academics
![Page 2: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/2.jpg)
Advantages of Spring Framework ArchitectureThere are many advantages of Spring Framework. They are as
follows: Lightweight: Spring framework is lightweight because of its
POJO implementation. The Spring Framework doesn't force the programmer to inherit any class or implement any interface. That is why it is said non-invasive, Enable you to write powerful, scalable applications using POJOs.
Easy to develop JavaEE application: The Dependency Injection feature of Spring Framework and it support to various frameworks makes the easy development of JavaEE application.
Easy to test: The Dependency Injection makes easier to test the application. The EJB or Struts application require server to run the application but Spring framework doesn't require server.
![Page 3: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/3.jpg)
Loose Coupling: The Spring applications are loosely coupled because of dependency injection and handles injecting dependent components without a component knowing where they came from (IoC).
Powerful abstraction: It provides powerful abstraction to JavaEE specifications such as JMS, JDBC, JPA and JTA.
Declarative support: It provides declarative support for caching, validation, transactions and formatting.
Portable :can use server-side in web/ejb app, client-side in swing app, business logic is completely portable.
Cross-cutting behavior : Resource Management is cross-cutting concern, easy to copy-and-paste everywhere.
![Page 4: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/4.jpg)
Configuration information: Spring provides one consistent way of configuring everything, separate configuration from application logic, varying configuration.
Lifecycle : Responsible for managing all your application components, particularly those in the middle tier container sees components through well-defined lifecycle: init(), destroy()
![Page 5: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/5.jpg)
Spring A popular and stable Java application framework for
enterprise development Ubiquitous for Java development Well established in enterprise Java apps Time tested and proven reliable
A primary purpose is to reduce dependencies and even introduce negative dependencies Different from almost every other
framework out there Part of the reason it has been adopted so quickly Spring code base is proven to be well structured
(possibly the best) 139 packages No dependency cycles
![Page 6: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/6.jpg)
Spring A lightweight framework that addresses each tier in a Web
application. Presentation layer – An MVC framework that is most similar to
Struts but is more powerful and easy to use. Business layer – Lightweight IoC container and AOP support
(including built in aspects) Persistence layer – DAO template support for popular ORMs and
JDBC Simplifies persistence frameworks and JDBC Complimentary: Not a replacement for a persistence framework
Helps organize your middle tier and handle typical J2EE plumbing problems.
Solutions to typical coding busywork JDBC ,LDAP,Web Services
Reduces code and speeds up development Current Version is 3.0
![Page 7: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/7.jpg)
Spring (continued) Do I have to use all components of Spring? Spring is a non-invasive and portable framework that
allows you to introduce as much or as little as you want to your application.
Promotes decoupling and reusability POJO Based Allows developers to focus more on reused business
logic and less on plumbing problems. Reduces or alleviates code littering, ad hoc
singletons, factories, service locators and multiple configuration files.
Removes common code issues like leaking connections and more.
Built in aspects such as transaction management Most business objects in Spring apps do not depend
on the Spring framework.
![Page 8: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/8.jpg)
Why Did I choose Spring? Introduced to Spring by way of Hibernate Spring is an open source layered Java/J2EE application
framework The Spring Framework is licensed under the terms of the
Apache License Originally wanted Spring to provide a way to simplify DAO
objects and provide declarative transaction support to our non-EJB applications.
Needed a solution to loosely couple business logic in a POJO fashion.
Wanted to build portable applications that provided clearer separation of presentation, business, and persistence logic.
Easily integrated with our existing frameworks Great documentation and community support
![Page 9: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/9.jpg)
Spring Mission Statement J2EE should be easier to use It's 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 framework shouldn't
force you to catch exceptions you're unlikely to be able to recover from.
Testability is essential, and a framework such as Spring should help make your code easier to test
Spring should be a pleasure to use Your application code should not depend on Spring APIs Spring should not compete with good existing solutions, but should
foster integration. (For example, JDO and Hibernate are great O/R mapping solutions. Don't need to develop another one).
![Page 10: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/10.jpg)
Simplify your code with Spring Enables you to stop polluting code No more custom singleton objects
Beans are defined in a centralized configuration file No more custom factory object to build and/or locate other
objects DAO simplification
Consistent CRUD Data access templates No more copy-paste try/catch/finally blocks No more passing Connection objects between methods No more leaked connections
POJO Based Refactoring experience with Spring Caution Spring is addictive!
![Page 11: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/11.jpg)
Modules of the Spring FrameworkThe Spring Framework can be considered as a collection of frameworks-in-the-framework:
Core - Inversion of Control (IoC) and Dependency Injection. AOP :- These modules support aspect oriented programming
implementation where you can use Advices, Pointcuts etc. to decouple the code.
DAO - Data Access Object support, transaction management, JDBC-abstraction
ORM - Object Relational Mapping data access, integration layers for JPA, JDO, Hibernate, and iBatis
MVC - Model-View-Controller implementation for web-applications
Context-This module supports internationalization (I18N), EJB,Remote Access, Authentication and Authorization, Remote Management like RMI,HTTP Invoker,Hessain, Messaging Framework, Web Services, Email, Testing, …
![Page 12: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/12.jpg)
Modules of the Spring Framework Expression Language:- It is an extension to the EL
defined in JSP. It provides support to setting and getting property values, method invocation, accessing collections and indexers, named variables, logical and arithmetic operators, retrieval of objects by name etc.
![Page 13: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/13.jpg)
Overview of the Spring Framework
Very loosely coupled, components widely reusable and separately packaged.
![Page 14: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/14.jpg)
Spring Details Spring allows to decouple software layers by injecting a
component’s dependencies at runtime rather than having them declared at compile time via importing and instantiating classes.
Spring provides integration for J2EE services such as EJB, JDBC, JNDI, JMS, JTA. It also integrates several popular ORM toolkits such as Hibernate and JDO and assorted other services as well.
One of the highly touted features is declarative transactions, which allows the developer to write transaction-unaware code and configure transactions in Spring config files.
![Page 15: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/15.jpg)
Spring Details Spring is built on the principle of unchecked exception
handling. This also reduces code dependencies between layers. Spring provides a granular exception hierarchy for data access operations and maps JDBC, EJB, and ORM exceptions to Spring exceptions so that applications can get better information about the error condition.
With highly decoupled software layers and programming to interfaces, each layer is easier to test. Mock objects is a testing pattern that is very useful in this regard.
![Page 16: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/16.jpg)
Spring Solutions
• Solutions address major J2EE problem areas:• Web application development (MVC)• Enterprise Java Beans (EJB, JNDI)• Database access (JDBC, iBatis, ORM)• Transaction management (JTA, Hibernate, JDBC)• Remote access (Web Services, RMI)
• Each solution builds on the core architecture• Solutions foster integration, they do not re-invent
the wheel
![Page 17: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/17.jpg)
How to Start Using Spring
create the class create the xml file to provide the values create the test class Load the spring jar files Run the test class
![Page 18: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/18.jpg)
Create Java class
![Page 19: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/19.jpg)
Create the xml file
![Page 20: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/20.jpg)
Create the test class
![Page 21: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/21.jpg)
Load the jar files required for spring framework
There are mainly three jar files required to run this application.
org.springframework.core-3.0.1.RELEASE-A com.springsource.org.apache.commons.logging-1.1.1 org.springframework.beans-3.0.1.RELEASE-A
![Page 22: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/22.jpg)
What are Lightweight Frameworks?
• Non-intrusive• No container requirements• Simplify application development
• Remove re-occurring pattern code• Productivity friendly• Unit test friendly
• Very pluggable• Usually open source• Examples:
• Spring, Pico, Hivemind• Hibernate, IBatis, Castor• WebWork• Quartz• Sitemesh
![Page 23: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/23.jpg)
Spring IoC + AOP IoC container
Setter based and constructor based dependency injection Portable across application servers Promotes good use of OO practices such as programming
to interfaces. Beans managed by an IoC container are reusable and
decoupled from business logic AOP
Spring uses Dynamic AOP Proxy objects to provide cross-cutting services
Reusable components Aopalliance support today Integrates with the IoC container AspectJ support in Spring 1.1
![Page 24: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/24.jpg)
Spring IoC
![Page 25: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/25.jpg)
Inversion of Control Dependency injection
Beans define their dependencies through constructor arguments or properties
The container provides the injection at runtime Decouples object creators and locators from application logic Easy to maintain and reuse Testing is easier Useful for separating dao and business layer Useful for separating controllers and business layer The code is more extensible, easier to read, and
modules/layers can easily be replaced
![Page 26: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/26.jpg)
Non-IoC / Dependency Injection
![Page 27: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/27.jpg)
Non-IoC Service Objectpublic class OrderServiceImpl implements
IOrderService {public Order saveOrder(Order order) throws
OrderException{try{ // 1. Create a Session/Connection object// 2. Start a transaction// 3. Lookup and invoke one of the methods in a
// DAO and pass the Session/Connection object.// 4. Commit transaction}catch(Exception e){// handle e, rollback transaction, //cleanup, // throw e}finally{//Release resources and handle more exceptions}
}
![Page 28: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/28.jpg)
IoC / Dependency Injection
![Page 29: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/29.jpg)
IoC Service Objectpublic class OrderSpringService implements IOrderService {
IOrderDAO orderDAO;public Order saveOrder(Order order) throws OrderException{// perform some business logic…return orderDAO.saveNewOrder(order);
}
public void setOrderDAO(IOrderDAO orderDAO) {this.orderDAO = orderDAO;
}
Program to interfaces for your bean dependencies!
![Page 30: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/30.jpg)
Spring Bean Definition Typical java bean with a unique id In spring there are basically two types
Singleton One instance of the bean created and
referenced each time it is requestedPrototype (non-singleton)
New bean created each time Same as new ClassName()
Beans are normally created by Spring as late as possible
![Page 31: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/31.jpg)
Spring Bean Definition The bean class is the actual implementation of the
bean being described by the BeanFactory. Bean examples – DAO, DataSource, Transaction
Manager, Persistence Managers, Service objects, etc Spring config contains implementation classes while
your code should program to interfaces. Bean behaviors include:
Singleton or prototype Autowiring Initialization and destruction methods
init-method destroy-method
Beans can be configured to have property values set. Can read simple values, collections, maps, references to
other beans, etc.
![Page 32: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/32.jpg)
What is a bean definition? Defines a bean for Spring to manage
Key attributes class (required): fully qualified java class name id: the unique identifier for this bean configuration: (singleton, init-method, etc.) constructor-arg: arguments to pass to the constructor at
creation time property: arguments to pass to the bean setters at
creation time Collaborators: other beans needed in this bean (a.k.a
dependencies), specified in property or constructor-arg
Typically defined in an XML file
![Page 33: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/33.jpg)
Simple Spring Bean Example <bean id=“orderBean” class=“example.OrderBean”
init-method=“init”><property
name=“minimumAmountToProcess”>10</property><property name=“orderDAO”> <ref bean=“orderDAOBean”/></property>
</bean>
public class OrderBean implements IOrderBean{…public void
setMinimumAmountToProcess(double d){this. minimumAmountToProcess = d;
}public void setOrderDAO(IOrderDAO odao){
this.orderDAO = odao;}
}
![Page 34: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/34.jpg)
Spring BeanFactory BeanFactory is core to the Spring framework
Lightweight container that loads bean definitions and manages your beans.
Configured declaratively using an XML file, or files, that determine how beans can be referenced and wired together.
Knows how to serve and manage a singleton or prototype defined bean
Responsible for lifecycle methods. Injects dependencies into defined beans when served
Avoids the use of singletons and factories Spring uses a BeanFactory to create, manage and
locate “beans” which are basically instances of a class Typical usage is an XML bean factory which allows
configuration via XML files
![Page 35: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/35.jpg)
Spring ApplicationContext A Spring ApplicationContext allows you to get access
to the objects that are configured in a BeanFactory in a framework manner.
ApplicationContext extends BeanFactory Adds services such as international messaging capabilities. Add the ability to load file resources in a generic fashion.
Several ways to configure a context: XMLWebApplicationContext – Configuration for a web
application. ClassPathXMLApplicationContext – standalone XML
application context FileSystemXmlApplicationContext
Allows you to avoid writing Service Locators
![Page 36: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/36.jpg)
Configuring an XMLWebApplicationContext<context-param>
<param-name>contextConfigLocation</param-name> <param-value>
/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener> <listener-class> org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
![Page 37: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/37.jpg)
Configuring an XMLWebApplicationContext<context-param>
<param-name>contextConfigLocation</param-name> <param-value>
/WEB-INF/applicationContext.xml</param-value>
</context-param><servlet>
<servlet-name>context</servlet-name> <servlet-class> org.springframework.web.context.ContextLoaderServlet</servlet-class> <load-on-startup>1</load-on-startup>
</servlet>
![Page 38: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/38.jpg)
Spring AOP
![Page 39: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/39.jpg)
Spring AOP Framework that builds on the aopalliance interfaces. Aspects are coded with pure Java code. You do not need
to learn pointcut query languages that are available in other AOP implementations.
Separates the core business code from the aspects we wrap around it: security, transaction management, monitering,logging…
Spring aspects can be configured using its own IoC container. Objects obtained from the IoC container can be transparently
advised based on configuration Spring AOP has built in aspects such as providing
transaction management, performance monitoring and more for your beans
Spring AOP is not as robust as some other implementations such as AspectJ. However, it does support common aspect uses to solve common
problems in enterprise applications
![Page 40: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/40.jpg)
Spring AOP Attempts to separate concerns, increase
modularity, and decrease redundancy Separation of Concerns (SoC)
Break up features to minimize overlap
Don’t Repeat Yourself (DRY) Minimize code duplication
Cross-Cutting Concerns Program aspects that affect many others (e.g. logging)
AspectJ is the top AOP package
![Page 41: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/41.jpg)
Spring AOP Supports the following advices:
method before method after returning throws advice around advice (uses AOPAlliance MethodInterceptor directly)
Spring allows you to chain together interceptors and advice with precedence.
Aspects are weaved together at runtime. AspectJ uses compile time weaving.
Spring AOP also includes advisors that contain advice and pointcut filtering.
ProxyFactoryBean – sources AOP proxies from a Spring BeanFactory
IoC + AOP is a great combination that is non-invasive Through AOP, we add transversal functionalities to
objects (ie not directly related to the code it contains)
![Page 42: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/42.jpg)
2. Spring principles: AOP
Without AOP
With AOP
![Page 43: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/43.jpg)
2. Spring principles: AOP
Useful for automatic handling of transaction with Hibernate
Useful for Acegi (automatic credentials checking before executing some methods)
Code smaller, easier to read (not polluted by transversal aspects not directly relevant)
![Page 44: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/44.jpg)
Spring Database Components
![Page 45: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/45.jpg)
Consistent Abstract Classes for DAO Support Extend your DAO classes with the proper xxxDAOSupport class
that matches your persistence mechanism. JdbcDaoSupport
Super class for JDBC data access objects. Requires a DataSource to be set, providing a JdbcTemplate based
on it to subclasses. HibernateDaoSupport
Super class for Hibernate data access objects. Requires a SessionFactory to be set, providing a
HibernateTemplate based on it to subclasses. JdoDaoSupport
Super class for JDO data access objects. Requires a PersistenceManagerFactory to be set, providing a
JdoTemplate based on it to subclasses. SqlMapDaoSupport
Supper class for iBATIS SqlMap data access object. Requires a DataSource to be set, providing a SqlMapTemplate
![Page 46: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/46.jpg)
Spring DAO Templates Built in code templates that support JDBC, Hibernate,
JDO, and iBatis SQL Maps Simplifies data access coding by reducing redundant
code and helps avoid common errors. Alleviates opening and closing connections in your
DAO code. No more ThreadLocal or passing Connection/Session
objects. Transaction management is handled by a wired bean You are dropped into the template with the resources
you need for data access – Session, PreparedStatement, etc.
Code only needs to be implemented in callback methods. doInXXX(Object)
Optional separate JDBC framework
![Page 47: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/47.jpg)
Ex: Code without a template
public class OrderHibernateDAO implements IOrderDAO {public Order saveOrder(Order order) throws
OrderException{Session s = null;Transaction tx = null;try{
s = ... // get a new Session objecttx = s.beginTransaction();s.save(order);tx.commit();
} catch (HibernateException he){// log, rollback, and convert to OrderException
} catch (SQLException sqle){// log, rollback, and convert to OrderException
} finally {s.close(); // needs a try/catch block
}return order;
}
![Page 48: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/48.jpg)
Ex: Spring DAO Template Examplepublic class OrderHibernateDAO extends HibernateDaoSupport
implements IOrderDAO {...public Order saveOrder(final Order order) {
return (Order) getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session)throws HibernateException, SQLException {
session.save(order);return order;
}});
}...}
![Page 49: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/49.jpg)
Consistent Exception Handling Spring has it’s own exception handling hierarchy for DAO logic.
No more copy and pasting redundant exception logic!
Exceptions from JDBC, or a supported ORM, are wrapped up into an appropriate, and consistent, DataAccessException and thrown.
This allows you to decouple exceptions in your business logic.
These exceptions are treated as unchecked exceptions that you can handle in your business tier if needed. No need to try/catch in your DAO.
Define your own exception translation by subclassing classes such as SQLErrorCodeSQLExceptionTranslator
![Page 50: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/50.jpg)
Spring and Testing Easier test driven development (TDD) Integration testing
Can use a standalone Spring configuration with mock objects for testing.
Consider XMLApplicationContext or FileSystemApplicationContext.
Unit testingAllows you to test outside the container
without using the Spring container. Easy to test POJOs
![Page 51: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/51.jpg)
Spring MVC Framework
![Page 52: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/52.jpg)
MVC Framework Clear separation of roles: controller, validator, form object,
Dispatch servlet, View resolver, … Extensible and adaptable Several views of a result (pdf, excel, html, …) Can be wired (possible to use transparently the IoC pattern). Spring Annotation Based Controllers Spring 2.5 introduced support for annotation based MVC
controllers. @RequestMapping, @RequestParam, @ModelAttribute are some of the annotations provided for this implementation.
![Page 53: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/53.jpg)
Can be used with other frameworks: JSF, Struts, Tapestry, Webwork
Completely transparent: no need to change anything in what is done by these other frameworks
![Page 54: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/54.jpg)
Benefits of the Spring Web MVC Framework
The Spring Web MVC Framework is a robust, flexible, and well-designed framework for rapidly developing web applications using the MVC design pattern.The benefits achieved from using this Spring module are similar to those you get from the rest of the Spring Framework
Easier testing—This is a common theme you will find across all the Spring classes.The fact that most of Spring’s classes are designed as JavaBeans enables you to inject test data using the setter methods of these classes. Spring also provides mock classes to simulate Java HTTP objects (HttpServletRequest, for example), which makes unit testing of the web layer much simpler.
![Page 55: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/55.jpg)
Benefits of the Spring Web MVC Framework
Bind directly to business objects—Spring MVC does not require your business (model) classes to extend any special classes; this enables you to reuse your business
objects by binding them directly to the HTML forms fields. In fact, your controller classes are the only ones that are required to extend Spring classes (or implement a Spring controller interface).
Clear separation of roles—Spring MVC nicely separates the roles played by the various components that make up this web framework. For example, when we dis-cuss concepts such as controllers, command objects, and validators, you will begin to see how each component plays a distinct role.
![Page 56: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/56.jpg)
Benefits of the Spring Web MVC Framework
Simple but powerful tag library—Spring's tag library is small, straightforward, but powerful. For example. Spring uses the JSP expression language (EL) for arguments
to the <spring :bind> tag.Web Flow—This module is a subproject and is not bundled
with the Spring core distribution. It is built on top of Spring MVC and adds the capability to easily write wizard like web applications that span across several HTTP requests (an online shopping cart, for example).
![Page 57: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/57.jpg)
Benefits of the Spring Web MVC Framework
View technologies and web frameworks—Although we are using JSP as our view technology. Spring supports odier view technologies as well, such as Apache Velocity and FreeMarker.This is a powerful concept because switching from JSP to Velocity is a matter of configura-tion. Furthermore, Spring provides integration support for Apache Struts.
■ Lighter-weight environment—As I mentioned in die previous chapter. Spring enables you to build enterprise-ready applications using FOJOs; the environmentsetup can be simpler and less expensive because you could develop and deploy your application using a lighter-weight servlet container.
![Page 58: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/58.jpg)
Features of Spring Web MVCSpring's web module provides a wealth of unique web support features, including: Clear separation of roles - controller, validator, command object, form object, model object, DispatcherServlet, handler mapping, view resolver, etc. Each role can be fulfilled by a specialized object. Powerful and straightforward configuration of both framework and application classes as JavaBeans, including easy referencing across contexts, such as from web controllers to business objects and validators. Adaptability, non-intrusiveness. Use whatever controller subclass you need (plain, command, form, wizard, multi-action, or a custom one) for a given scenario instead of deriving from a single controller for everything. Reusable business code - no need for duplication. You can use existing business objects as command or form objects instead of mirroring them in order to extend a particular framework base class.
![Page 59: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/59.jpg)
Features of Spring Web MVC
Customizable locale and theme resolution, support for JSPs with or without Spring tag library, support for JSTL, support for Velocity without the need for extra bridges, etc. A simple yet powerful JSP tag library known as the Spring tag library that provides support for features such as data binding and themes. The custom tags allow for maximum flexibility in terms of markup code. For information on the tag library descriptor. A JSP form tag library, introduced in Spring 2.0, that makes writing forms in JSP pages much easier. For information on the tag library descriptor. Beans whose lifecycle is scoped to the current HTTP request or HTTP Session. This is not a specific feature of Spring MVC itself, but rather of the WebApplicationContext container(s) that Spring MVC uses. These bean scopes are described in detail in the section entitled.
![Page 60: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/60.jpg)
Features of Spring Web MVC
Customizable binding and validation - type mismatches as application-level validation errors that keep the offending value, localized date and number binding, etc instead of String-only form objects with manual parsing and conversion to business objects. Customizable handler mapping and view resolution - handler mapping and view resolution strategies range from simple URL-based configuration, to sophisticated, purpose-built resolution strategies. This is more flexible than some web MVC frameworks which mandate a particular technique. Flexible model transfer - model transfer via a name/value Map supports easy integration with any view technology.
![Page 61: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/61.jpg)
4. A full MVC Framework
![Page 62: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/62.jpg)
Working Of MVC FrameworkThe Spring web MVC framework provides model-view-controller architecture and ready components that can be used to develop flexible and loosely coupled web applications. The MVC pattern results in separating the different aspects of the application (input logic, business logic, and UI logic), while providing a loose coupling between these elements.
The Model encapsulates the application data and in general they will consist of POJO.
The View is responsible for rendering the model data and in general it generates HTML output that the client's browser can interpret.
The Controller is responsible for processing user requests and building appropriate model and passes it to the view for rendering.
![Page 63: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/63.jpg)
The DispatcherServletThe Spring Web model-view-controller (MVC) framework is designed around a DispatcherServlet that handles all the HTTP requests and responses. The request processing workflow of the Spring Web MVC DispatcherServlet is illustrated in the following diagram:
![Page 64: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/64.jpg)
Following is the sequence of events corresponding to an incoming HTTP request to DispatcherServlet:
After receiving an HTTP request, DispatcherServlet consults the HandlerMapping to call the appropriate Controller.
The Controller takes the request and calls the appropriate service methods based on used GET or POST method. The service method will set model data based on defined business logic and returns view name to the DispatcherServlet.
The DispatcherServlet will take help from ViewResolver to pickup the defined view for the request.
Once view is finalized, The DispatcherServlet passes the model data to the view which is finally rendered on the browser.
All the above mentioned components ie. HandlerMapping, Controller and ViewResolver are parts ofWebApplicationContext which is an extension of the plain ApplicationContext with some extra features necessary for web
applications.
![Page 65: Spring PPT](https://reader034.fdocuments.in/reader034/viewer/2022042702/55cf9979550346d0339d93df/html5/thumbnails/65.jpg)
Even More Spring Components JavaMail helpers Many ORM tools are supported: Hibernate, JDO, Apache OJB, iBATIS Templates using IoC to reduce the amount of code in the DAO objects Scheduling support via Quartz Convenience implementation classes for
Remoting support – JAXRPC, RMI, Hessian, and Burlap EJB support for easier access. Acegi Security System for Spring
http://acegisecurity.sourceforge.net/ Very good framework!
Eclipse Plugin – Spring IDE for Eclipse Coming soon
JMS implementation classes JMX support