Fast Track to Spring 3

This course is a new course based on the Spring® 3 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

A good working knowledge of basic Java, JDBC, and Servlets/JSP

The Challenge of Enterprise Applications
Shortcomings of Java/Java EE
What is Spring?
The Spring Modules
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 BeanFactory Methods
Dependencies and Dependency Injection
Fast Track to Spring® 3
Dependencies Between Objects
Dependency Inversion Principal
Dependency Injection (DI) in Spring
Dependency Injection Configuration
Advantages of Dependency Injection
Dependency Injection Reduces Coupling

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

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
Using the Lifecycle Interfaces for Beans
Bean Creation Lifecycle Details
Bean Destruction Lifecycle
BeanPostProcessor
@PostConstruct and @PreDestroy
Event Handling
MessageSources
Issues with Messages
Resource Bundles
Defining Resource Bundles
Using Resource Bundles and MessageSource
Localization/Internationalization
Paramaterizing Messages
Annotation Driven Configuration
Annotations in Spring
Enabling Spring Annotations
@Component and Auto-Detecting Beans
DI Using @Resource
Complete Declarations Using Annotations
@Resource – Additional Uses
@AutoWired
Qualifiers
Lifecycle Annotations
XML Config – Annotations and Scanning
Annotation Configuration – Pro/Con
A Note on the XML Configuration
A Brief Note on Annotations
Java-Based Configuratio
Java Configuration Overview
Using Java-Based Configuration
Dependency Injection
More on How it Works
Dependencies Between Configuration Classes
Other Usage Scenarios
Classpath Scanning
Other @Bean Capabilities
Java-Based Configuration – Pro / Con
Other Capabilities
SpEL – Spring Expression Language
Other SpEL Capabilities
Validation
Using Validation
Configuring Validation
Validation Constraints
Additional Capabilities

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
Using Spring with Hibernate
Hibernate Overview
Typical Hibernate Configuration File
Using Hibernate Directly
Spring Support for Hibernate
Template Support for Hibernate
LocalSessionFactoryBean
Configuring a Hibernate Session Factory
Contextual Sessions
Spring-Free DAO
What Approach to Use
Using Spring with JPA
Template Support for JPA
Support for Managing EntityManager
LocalEntityManagerFactoryBean
Obtaining an EntityManager from JNDI
LocalContrainerEntityManagerFactory Bean
Container-Managed EntityManager
Additional Spring Configuration
JPA Data Access Object
Extended Persistence Context

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

Transaction Lifecycle
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
Specifying Transactions Using XML
Linking Advice with Pointcuts
Attributes

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 Security
Spring Web Security – web.xml
Spring Web Security – Spring Configuration
More Capabilities
Other Authentication Providers
Method Security
Method Security – Annotations
Method Security – Pointcut Expressions
Method Security – XML Configuration