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 <list> and <set> 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 ITC 01/08