FastTrack to Spring 2.0 Course

- this course is no longer scheduled to run. Please refer to schedule for current course titles.

This course is for Java developers who need to work with Spring based applications. It 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.

Delegates should have a good working knowledge of basic Java, JDBC, and Servlets/JSP.

Topics covered on the 3 day FastTrack to Spring 2.0 course

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
• <tx:method> 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