Dauer: 5 Tage

Inhalt:

• Überblick Spring Framework
• Bean Wiring
• Aspekt Orientierte Programmierung mit Spring 
• Spring Datenbank Zugriff
  
• Spring Transaktionen
• Spring MVC Web Programmierung (Web Views, Web Flow)

Notwendiges Vorwissen:

• Kenntnisse und Programmiererfahrung in der Programmiersprache Java.
• Programmierung von Servlets und Java Server Pages

Empfohlene Schulungen im Vorfeld:

• Java Programming Language
• Web Component development with Servlet and JSP Technologies

Detailierter Inhalt:

Introducing Spring
What Is Spring?
Beyond Dependency Injection
Aspect-Oriented Programming with Spring
Accessing Data in Spring
Simplifying and Integrating with Java EE
Job Scheduling Support
Mail Support
Dynamic Languages
Remoting Support
Managing Transactions
The Spring MVC Framework
Spring Web Flow
AJAX
Internationalization
Simplified Exception Handling
The Spring Project
Origins of Spring
The Spring Community
Spring for Microsoft .NET
The Spring IDE
The Spring Security (Formerly Acegi)
Alternatives to Spring

Introducing Inversion of Control
IoC and DI
Types of IoC
Contextualized Dependency Lookup
Constructor DI
Setter DI
Injection vs. Lookup
Setter Injection vs. Constructor Injection
IoC in Spring
DI with Spring
Beans and BeanFactories
BeanFactory Implementations
XML Bean Definition
Using Constructor Injection
Injection Parameters
Understanding Bean Naming
Bean Instantiation Modes
Resolving Dependencies
Automatically Wiring Your Beans
Checking Dependencies
Bean Inheritance

Introducing Spring AOP
AOP Concepts
Types of AOP
Static AOP
Dynamic AOP
Choosing an AOP Type
AOP in Spring
The AOP Alliance
“Hello,World” in AOP
Spring AOP Architecture
The ProxyFactory Class
Creating Advice in Spring
Advisors and Pointcuts in Spring
The Pointcut Interface
Using ComposablePointcut
Pointcutting Summary
All About Proxies
Understanding Proxies
Using JDK Dynamic Proxies
Using CGLIB Proxies
Comparing Proxy Performance
Which Proxy to Use?

Advanced AOP
@AspectJ
@AspectJ Aspects in Detail
Pointcuts
Pointcut Expressions
Exploring the Pointcut Expressions
Using the @Pointcuts in XML
Types of Advice
Argument Binding
Introductions
The Aspect Life Cycle
Framework Services for AOP
Creating Our First Aspect Using the aop Namespace
Pointcuts in the aop Namespace
Creating Advice Using the aop Namespace
Introductions in the aop Namespace
Which Style Should You Use?
Working with Spring AOP Proxies
Impact of Proxies
AspectJ Integration
Creating Your First AspectJ Aspect
Compiling the Sample Application
AspectJ’s Aspect Scope
Load-Time Weaving
Your First Load-Time Weaving Example
LoadTimeWeaver Lookup Strategies
Practical Uses of AOP
Performance and Health Monitoring

JDBC Support
Key JDBC Concepts
Using the DriverManager and Connections
Using PreparedStatements
Using CallableStatements
Other JDBC Concepts
Concepts in Spring Data Access Support
JDBC Data Access Support
Using the JdbcTemplate
JdbcTemplate.execute
JdbcTemplate.query and Friends
JdbcTemplate.update
JdbcTemplate.batchUpdate
RdbmsOperation Subclasses
SqlUpdate
BatchSqlUpdate
SqlCall and StoredProcedure
SqlQuery and Its Subclasses
JdbcTemplate or RdbmsOperation?
Large Binary Objects
JdbcDaoSupport
Simple Spring JDBC
SimpleJdbcTemplate
SimpleJdbcCall
SimpleJdbcInsert
SimpleJdbcDaoSupport

Hibernate Support
Hibernate Primer
Packaging
Introduction to Hibernate Support
Using Hibernate Sessions
Using HibernateDaoSupport
Deciding Between HibernateTemplate and Session
Using Hibernate in Enterprise Applications
Preventing Stale Data Updates
Object Equality
Transactional Behavior
Lazy Loading
Dealing with Large Data Sets
Handling Large Objects
Combining Hibernate with Other DAO Code

Transaction Management
Exploring the Spring Transaction Abstraction Layer
Analyzing Transaction Properties
Exploring the TransactionDefinition Interface
Using the TransactionStatus Interface
Implementations of the PlatformTransactionManager
Exploring a Transaction Management Sample
Nontransactional Code
Programmatic Transaction Management
Using the TransactionTemplate Class
Programmatic Transaction Management Summary
Declarative Transaction Management
Using the TransactionProxyFactoryBean
Implications of Using Proxies in Transaction Management
AOP Transaction Management
Using Annotation-Based AOP Transaction Management
Using XML AOP Transaction Management
Working with Transactions Over Multiple Transactional Resources
Implementing Your Own Transaction Synchronization

Web Applications with Spring MVC
MVC Architecture
Spring MVC
MVC Implementation
Using Handler Mappings
Spring Controllers
AbstractController
ParameterizableViewController
MultiActionController
Interceptors
Views, Locales, and Themes
Using Views Programmatically
Using View Resolvers
Using Localized Messages
Using Locales
Using Themes
Command Controllers
Using Form Controllers
Exploring the AbstractWizardFormController
File Upload
Handling Exceptions
Spring and Other Web Technologies
Spring Conventions Over Configuration
Controller Conventions
MultiActionController Conventions
Model Conventions
View Conventions
Using Annotations for Controller Configuration
@Controller
@RequestMapping
@RequestParam
@ModelAttribute
Using Annotations with the Command Controller

Spring Web Flow
Introducing Spring Web Flow
Core Concepts
Obtaining Spring Web Flow
Spring Web Flow Dependencies
Hello,Web Flow!
Exploring States
View State
Decision State
End State
Working with Transitions
Advanced Concepts
Expression Languages and Scopes
Implementing Actions
Model Data Binding
Partial Rendering of Views
Mapping Flow Input and Output Parameters
Using Subflows
Spring Web Flow Behind the Scenes
Flow Execution Architecture
Flow Executor
Flow Definition Registry
Flow Execution Repository
Integration with Spring MVC
Flow Handling
View Resolving
Securing Flows with Spring Security
Step 1: Adding the SecurityFlowExecutionListener
Step 2: Basic Authentication and Authorization Handling
Step 3: Defining Security Rules in Flow Definitions
Problem Solver
Stateful Navigational Control
Browser Navigation Bar Support and Double Submit
Testing Flow Definitions