Fast Track to Spring 2.0

AUDIENCE: Java developers who need to work with Spring based applications
PREREQUISITES: A good working knowledge of basic Java, JDBC, and Servlets/JSP is required.
DURATION: 3 days. Hands on.
OBJECTIVES: This course is a completely new course based on the new Spring 2.0 release. It starts with the basics of Spring and in-depth coverage on using the powerful capabilities of the Core module to reduce coupling, increase flexibility, and ease the maintenance and testing of your applications. It goes on to cover all the important capabilities of Spring 2.0, including using Spring to simplify the creation of a persistence layer with JDBC and/or persistence frameworks like Hibernate, and using Spring''s Aspect Oriented Programming (AOP) to program cross-cutting concerns such as transactions and security. The course also includes a solid introduction to Spring''s Web MVC - a Web framework based on the powerful Model-View-Controller pattern. This module covers the basics of Spring MVC, and how it supports organizing your Web applications in a highly structured, loosely coupled manner.
COURSE CONTENT:
Introduction to Spring
The Challenge of Enterprise Applications
Shortcomings of Java/Java EE
What is Spring?
The Spring Components
The Spring Distribution
Spring Introduction
Managing Beans
A Basic Spring Application
Some Bean Classes
Configuration Metadata
Declaring Beans
The Spring Container
Working with Spring
Why Bother?
Some Important BeanFactory Methods
Dependencies and Dependency Injection
Dependencies Between Objects
Dependency Inversion Principal
Dependency Injection (DI) in Spring
Dependency Injection Configuration
Advantages of Dependency Injection
Dependency Injection Reduces Coupling

More about Bean Properties
Working with Properties
Configuring Value Based Properties
Using Value Based Properties
Property Conversions
Constructor Injections
Constructor Argument Resolution
Setter Injection vs. Constructor Injection
Collection Valued Properties
Working with Collections
Configuring and Properties
Configuring Collections of Bean References
Map Valued Properties
java.util.Properties Valued Properties
Additional Capabilities
Factory Methods
Instance Factory Methods
Bean Aliases
Bean Definition Inheritance
Autowiring
Autowiring byType
Pros and Cons of Autowiring
To Autowire or Not to Autowire

The Spring Container and API
ApplicationContext
ApplicationContext Interface
ApplicationContext Implementations
Constructors
Using an ApplicationContext
Spring Resource Access
Built-in Resource Implementations
Bean Scope and Lifecycle
Bean Scope
Specifying Bean Scope
Inner Beans
Compound Names
Depends On
Bean Creation Lifecycle
Bean Creation Lifecycle Details
Using the Lifecycle Interfaces for Beans
Bean Destruction Lifecycle
BeanPostProcessor
Event Handling
MessageSources
Issues with Messages
Resource Bundles
Defining Resource Bundles
Using Resource Bundles and MessageSource
Localization/Internationalizatin
Paramaterizing Messages


Database Access with Spring
Issues with JDBC
Problems Using JDBC Directly
Let''s Review Some Simple JDBC Usage
Simple Query on the Database
Problems with the Previous Approach
Spring Support for the DAO Pattern
Spring DAO Support
The Spring Database API
The JdbcTemplate Class
The JdbcDaoSupport Class
DataSources
Spring Jdbc Exception Hierarchy
DAO Based on Spring Classes
Configuring a DataSource
Looking up a DataSource in JNDI
Building a DAO Without the Support Class
Queries and Updates
Querying with JdbcTemplate
Mapping Result Rows to Objects
Defining a RowMapper Class
Inserting/Updating
SimpleJdbcTemplate
The SimpleJdbcTemplate Class
The SimpleJdbcDaoSupport Class
Querying with SimpleJdbcTemplate
Defining a ParameterizedRowMapper
Inserting/Updating
Hibernate Overview
Typical Hibernate Configuration File
Using Hibernate Directly
Spring Support for Hibernate
HibernateTemplate
LocalSessionFactoryBean
HibernateDaoSupport
Configuring a Hibernate DAO
Querying with HibernateTemplate
UsingHibernateCallback
Contextual Sessions
Spring Free DAO
What Approach to Use
Support for Java Persistence API (JPA)


Aspect Oriented Programming (AOP)
AOP Overview
The Issue with Crosscutting Concerns
Crosscutting Illustrated
Aspect Oriented Programming (AOP) Defined
Spring AOP Introduction
Spring AOP with AspectJ Annotations
Defining an Aspect with AspectJ
Defining a Pointcut
Defining Advice
Configuring Spring
A Program that Triggers Advice
More on How Spring AOP Works
Pointcut Expressions and Advice
Pointcut Expressions
Sample Execution Designator Patterns
Other Designators Available in Spring AOP
Combining Pointcut Expressions
Kinds of Advice
A Brief Note on Annotations
Annotation Definition
Using Annotations
XML Based AOP Support
Defining Aspects Using XML
Specifying Advice with XML
Other Considerations
Spring Proxies and Direct Invocation
More on Spring Proxies
Issues with AOP
Is AOP Worth It
Other AOP Capabilities and Functionality

Transactions
Transaction Managers
Configuring Transaction Managers
JTA Transaction Manager
Spring Declarative Transaction Management
Transactional Scope
Transaction Attributes for Propagation
MANDATORY
NESTED
NEVER
NOT_SUPPORTED
REQUIRED
REQUIRES_NEW
SUPPORTS
Transaction Attributes - Some Choices
Specifying Transaction Attributes
Additional Transactional Attributes
Rolling Back and Exceptions
XML Configuration
Linking Advice with Pointcuts
Attributes

Spring and the Web
Integration with Java EE
Spring and Java EE
Java EE Web Applications
Web Application Structure
Web Application Components
ApplicationContext and Web Apps
Configuring ContextLoaderListener
Using the Application Context
Spring MVC Basics
What is Spring MVC?
MVC Architecture
MVC Pattern Flow
Spring MVC Architecture
Simple Search App Model - Servlets/JSP
Simple Search App Model - Spring MVC
DispatcherServlet
DispatcherServlet Initialization
Command Controllers
Very Simple Command Controller
Configuring the Command Controller
Forms and View Resolvers
View Resolvers
A JavaBean Command Class
Working with Forms
Defining a FormController
Configuring a FormController
The Response View
HandlerMappings

ITC 01/08