Spring Framework 2.x

Public Training Price: $1950 per student
Private Training Price: $7215 for up to 3 students*
*Additional students subject to a nominal fee
Share
Request Class
Print this outline

 

 

 

Spring Framework 2.x Training Class Summary

Spring is a lightweight Java framework for building enterprise applications. Its Core module allows you to manage the lifecycle of your objects, and the dependencies between them, via configuration metadata (usually XML) and Dependency Injection / Inversion of Control. Its advanced capabilities provide support for JDBC and persistence frameworks like Hibernate (DAO and ORM modules), Aspect-Oriented Programming (AOP module), integration with Java Web technologies (MVC module), security, transactions, and more.

This course is a completely new course based on the Spring 2.0 and 2.5 releases. 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. The course goes on to cover all the important capabilities of Spring 2.0 / 2.5, 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 includes a brief 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. The course also includes a brief introduction to Spring Security which was integrated into the Spring project when Spring 2.5 was released. This module includes an overview of the Spring Security architecture, and how to use it to secure both Web application requests and bean invocations

Audience: Java developers who need to work with Spring based applications.

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

Class Length: 3 days

Spring Framework 2.x Training Class Objectives
  • Understand the core principles of Spring, and of Dependency Injection (DI)/Inversion of Control.
  • Use the Spring Core module and DI to configure and wire application objects (beans) together.
  • Understand and use the complete capabilities of the Core module, such as lifecycle events, bean scopes, and the Spring API.
  • Work with the DAO and/or ORM modules to create a well structured persistence layer with JDBC or Hibernate.
  • Understand and use Spring 2.0's powerful new AOP capabilities for programming cross-cutting concerns across multiple points in an application.
  • Understand and use Spring's transaction support, including Spring 2.0's easy to use tx/aop XML configuration elements, and Java 5 annotations.
  • Understand how Spring MVC works, and how to build well-structured Web applications with it.
  • Understand the basics of Spring Security, and how to secure Web apps and Spring managed beans with it.
Spring Framework 2.x Training Class Detailed Outline
  1. 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
  2. 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
  3. 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/Internationalization
    • Paramaterizing Messages
    • Annotation Driven Configuration
    • Annotations in Spring
    • Enabling Spring Annotations
    • DI Using @Resource
    • @Resource – Additional Uses
    • @Component and Auto-Detecting Beans
    • Complete Declarations Using Annotations
    • Other Stereotype Annotations
    • Lifecycle Annotations
    • XML Config – Annotations and Scanning
    • Annotation Configuration – Pro/Con
    • A Note on the XML Configuration
    • A Brief Note on Annotations
  4. 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
    • Using Spring with Hibernate
    • 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)
  5. 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
  6. 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
  7. 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
    • Spring MVC Form Tags
    • Rendering the Form via Spring MVC
    • Flow for Rendering Form
    • Initializing the Form
    • Form Initialized and Rendered
    • Annotation-Based Configuration
    • Controller and Request Annotation
    • Annotations and Forms
    • Annotations and Form Initialization
  8. Spring Security Overview
    • 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

.