The Spring framework is an application framework that provides a lightweight container that supports the creation of simple-to-complex components in a non-invasive fashion. Spring's flexibility and transparency is congruent and supportive of incremental development and testing. The framework's structure supports the layering of functionality such as persistence, transactions, view-oriented frameworks, and enterprise systems and capabilities. Spring makes JEE development easier. Spring simplifies common tasks and encourages good design based on programming to interfaces. Spring makes your application easier to configure and reduces the need for many JEE design patterns. Spring puts the OO design back into your JEE application. This Spring course will take an in-depth tour of the basic Spring framework, initially examining concepts such as Inversion of Control and Dependency Injection, and then working with the container and basic components. The improved Spring 3.0 configuration management options centered on the Spring Expression Language (SPEL) is covered. The course then moves into the areas of persistence and transactions, looking at various options including both JDBC and Hibernate. You will then look at options for handling the view portion of MVC web architecture.

In this course, you will learn:

• The issues associated with complex frameworks such as JEE and how Spring addresses those issues
• To understand the relationships between Spring and JEE, AOP, IOC, JDBC, Hibernate, JSF, Struts, JMS, and EJBs
• The challenges to adopting Spring
• To write applications that take advantage of the Spring container
• What the Spring Expression Language brings to the table
• About Spring's support for transactions
• To understand and work with various options for integrating view-oriented frameworks for web applications into Spring
• About what the SpringSource Tool Suite (STS) provides in supporting advanced Spring development
• How to optionally work with the STS and SpringSource’s tc Server

• Benefits of Spring
• Goals of the Spring Framework
• The Nature of POJOs
• Key Features of Spring
• Dependency Injection

Spring Configuration

• Spring Jars
• Configuring Objects (XML Style) Spring
• XML Schema and DTD
• Typical Bean Creation
• Spring 3 Annotations

Configuration Advanced Features

• Overview of Factory Beans
• Bean Definition Re-use
• Using Property Files from XML Config Files
• Bean Post-Processors

Spring Aspect Oriented Programming (AOP)

• What is Aspect Oriented Programming?
• Cross Cutting Concerns
• What is an "Aspect"?
• The Three Technologies of "Weaving"
• The Generated Proxy Object Structure
• Four Kinds of "Advice"

Method Interceptor

• Method Interceptor
• ExampleInterceptor

JoinPoints and Pointcuts

• JoinPoint
• Pointcuts
• The Advisor
• Proxy Configuration

Spring IOC and Annotation Based AOP

• Review of Java Annotations
• Using Annotations
• Using Annotations to Create Aspects
• ProceedingJoinPoint - Used by Aspects
• Spring Pointcut Pattern Expressions

Persistence in Spring

• DAO Implementations
• Transaction Support
• Isolation Level Concepts
• Three Approaches to Transaction Management

Using Spring JDBC

• Obtaining a DataSource
• JdbcDaoSupport - JDBC DAO Implementation
• Operation Classes

Spring Views

• Overview of Spring MVC
• The WebApplicationContext
• Workflow of Request Handling
• Mapping URLs to Controllers

Using Spring MVC

• ModelAndView and View
• ViewResolvers
• Controllers
• Handling Form Requests
• Spring MVC Annotations

Advanced Spring MVC

• The Spring3 MVC Namespace
• Annotation Controller Mapping
• Spring MVC 3 Handler Methods Parameters
• The Form
• Using a PropertyEditor
• Additional Functionality