This document provides an overview of the Spring framework, including: - A brief history of Spring's development from 2002 to present. - An overview of Spring's key features like lightweight containers, declarative transactions, and dependency injection. - An explanation of Spring's layered architecture including presentation, service, and persistence layers. - A discussion of why Spring was created to simplify enterprise application development and reduce complexity. - An outline of Spring's various modules that can be selectively used in applications.

1. Presented By
Suman Behara
Java Developer

2. Agenda Overview:
• What is Spring ?
• History of Spring
• Features of Spring
• Why Spring ?
• What does Spring offer?
• Goal of Spring
• Modules of Spring
• Types of layers
• Application Layering
• Where to use Spring ?
• Conclusion

3. What is Spring:
What is Spring:
• Spring is an open source framework created to address the
complexity of enterprise application development
• One of the chief advantages of the Spring framework is its
layered architecture, which allows you to be selective about
which of its components you use while also providing a
cohesive framework for J2EE application development.
• It makes the application easy to configure and reduces the
need for many J2EE design patterns. Spring can be used to
configure declarative transaction management

4. History of Spring :
• The first version of Spring Framework was developed by
Rod Johnson. It's first version was released with the
publication of the book Expert One-on-One J2EE
Design and Development in the October 2002.
• Year 2002, Rod Johnson release it's first version
• March 2004, first version release under Apache 2.0
license
• In Year 2004 and 2005 further milestone release was
make available to the developers
• Year 2006 Spring 1.2.6 released
• In December 2009, version 3.0 GA was released
• June 15, 2010, Spring 3.0.3 released
• Dec 12th,2011, Spring 3.1.0 GA was released
• Sep 10th,2012, Spring 3.2 M2 released

5. Features of Spring :
• Spring is Lightweight container
• No App Server Dependent – like EJB JNDI Calls
• Objects are created Lazily , Singleton - configuration
• Components can added Declaratively
• Initialization of properties is easy – no need to read from properties
file
• Declarative transaction, security and logging service – AOP
• application code is much easier to unit test
• With a Dependency Injection approach, dependencies are explicit,
and evident in constructor or JavaBeans properties
• Spring's configuration management services can be used in any
architectural layer, in whatever runtime environment.
• Spring can effectively organize your middle tier objects
• Not required special deployment steps

6. Why Spring :
• The Spring Framework was developed to ease the development of
Enterprise Java applications
• Reducing the writing code while development application.
• Easy to integrate with any existing framework
• 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.
• Simplify use of popular technologies
handle common error conditions
• Well designed
▫ Easy to extend
▫ Many reusable classes

7. 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!

8. What does Spring offer?
• Dependency Injection
▫ Also known as IoC (Inversion of Control)
• Aspect Oriented Programming
▫ Runtime injection-based
• Portable Service Abstractions
▫ The rest of spring
 ORM, DAO, Web MVC, Web, etc.
 Allows access to these without knowing how they
actually work
• Spring Security

9. Modules of Spring :

10. Spring is Non-Invasive :
• What does that mean ?
You are not forced to import or extend any spring APIs
Anti-Patterns
• EJB force you to use JNDI
• Struts force you to extend Action, ActionSupport
• Invasive frameworks are inheritently difficult to
test(especially unit test)
• You to stub the runtime that is supplied by the
application server.

11. Layer’s are 4 types:
1.Presentation or UI (User Interface) Layer
(Struts/Jsps/JSF/Velocity etc.)
2.Bussiness or Service Layer
(Servlets/EJB/Spring)
3. Data Access Layer or Persistence layer (ORM’s or JDBC)
(Hibernate/JPA/Ibaties/Toplink etc.)
4. Data Layer (Database)
(MySql/Oracle/IBM DB2/Postgress/Ingress/
SQL Server etc.)

12. Application Layering :
• A clear separation of application component responsibility.
▫ Presentation layer
 Concentrates on request/response actions
 Handles UI rendering from a model.
 Contains formatting logic and non-business related validation logic.
 Handles exceptions thrown from other layers
▫ Persistence layer
 Used to communicate with a persistence store such as a relational database.
 Provides a query language
 Possible O/R mapping capabilities
 JDBC, Hibernate, iBATIS, JDO, Entity Beans, etc.
▫ Domain layer
 Contains business objects that are used across above layers.
 Contain complex relationships between other domain objects
 May be rich in business logic
 May have ORM mappings
 Domain objects should only have dependencies on other domain objects

13. What about a Service Layer?
•Where do we position loosely-coupled business logic?
• What is service logic?
• How should container level services be implemented?
• How do we support transactions in a POJO based application?
• How do we communicate from our presentation layer to our persistence layer?
• How do we get to services that contain business logic?
• How should our business objects communicate with our persistence layer?
• How do we get objects retrieved from our persistence layer to our UI layer?

14. Application Layering (cont):
▫ Service layer
 Gateway to expose business logic to the
outside world
 Manages ‘container level services’ such as
transactions, security, data access logic, and
manipulates domain objects
 Not well defined in many applications today
or tightly coupled in an inappropriate layer.

15. Layered Architecture :

16. Such a combination allows the development of you web applications
with maximal of flexibility and minimal effort

17. More Application Layering Combinations :
Presentation/Business/Persistence
• Struts+Spring+Hibernate
• Struts +Spring + EJB
• JSF+ Spring + JPA/ iBATIS
• Spring + Spring + JDO
• Flex + Spring + Hibernate
• Struts + Spring + JDBC
• You decide…

18. Conclusion :
• Layered architecture application development is Long
life with strong flexibility.
• Migrating from an any framework is very easy in future.
• Technology independent application development is
providing loose coupling and portability, that supports
spring.

19. Resources :
• http://www.springsource.org/
• http://www.interface21.com/
• Reference Manual of Spring
• http://static.springsource.org/spring/docs/3.0.x
/spring-framework-reference/html/

20. Spring Books :
• Spring in Action –by Craig walls and Ryan Bredenbach
• Pro Spring-by Rob Harrop and Jan Machacek
• J2EE Without EJB-by Rod Johnson and Juergen Holler
• Expert One-on-One J2EE Design and Development- by Rod
Johnson
• Spring Developers Notebook- by Bruce tate and justin Gehtland
• Spring Live- by matt Raible
• Professional Java development With the Spring Framework –Rod &
others

21. Thank U….!