Framework ITRONIX CERTIFIED

Spring Framework Industrial Training

 

Overview

  1. Java EE: The Good, The Bad, and the Ugly
  2. Enter the Framework
  3. Spring Modules
  4. Controlling Object Creation
  5. Web Applications
  6. Persistence Support
  7. Aspect-Oriented Programming
  8. Integrating Other Frameworks

Core Techniques

  1. Component-Based Software
  2. JavaBeans, Reconsidered
  3. The Factory Pattern
  4. Inversion of Control
  5. XML View: Declaring Beans
  6. Java View: Using Beans
  7. Singletons and Prototypes
  8. Initializing Bean State

Dependency Injection

  1. Complex Systems
  2. Assembling Object Graphs
  3. Dependency Injection
  4. Single and Multiple Relationships
  5. The Utility Schema
  6. Autowiring
  7. Bean Aliases
  8. Order of Instantiation

Validation

  1. Validators
  2. The Errors Object
  3. ValidationUtils
  4. Error Messages and Localization
  5. Nested Property Paths

The Web Module

  1. Servlets and JSPs: What’s Missing
  2. The MVC Pattern
  3. The Front Controller Pattern
  4. DispatcherServlet
  5. A Request/Response Cycle
  6. The Strategy Pattern
  7. JavaBeans as Web Components
  8. Web Application Contexts
  9. Handler Mappings
  10. “Creating” a Model
  11. View Resolvers

Controllers and Commands

  1. Working with Forms
  2. Command Objects
  3. The Template Method Pattern
  4. Command Controllers
  5. Data Binding
  6. MultiActionController
  7. Scope and Granularity of Command Objects

Customizing Spring MVC

  1. HandlerMapping Options
  2. ViewResolver Options
  3. Chaining View Resolvers
  4. Triggering Redirects

Web Binding and Validation

  1. Property Editors
  2. Custom Property Editors
  3. Registrars
  4. Validating Form Input

Testing a Spring-Based Application

  1. Annotations for integration testing with Spring (using JUnit)
  2. Advanced concepts: application context caching and the @DirtiesContext annotation

Aspect-Oriented Programming

  1. What problems does AOP solve?
  2. Differences between Spring AOP and AspectJ
  3. Defining pointcut expressions
  4. How to use the types of advice: around, before, after

Simplifying Application Configuration

  1. Bean definition inheritance
  2. Inner beans
  3. p and util namespaces
  4. Dependency injection of collections
  5. Spring Expression Language (SpEL)

Annotation-Based Dependency Injection

  1. Autowiring and component scanning
  2. Stereotype annotations
  3. Java-based configuration
  4. Mixing configuration styles
  5. When to use XML, annotations, and Java configuration

Form Controllers

  1. Form Controllers
  2. AbstractFormController
  3. SimpleFormController
  4. Spring Custom Tags
  5. <form:form> and Friends
  6. <form:errors>
  7. Reporting Errors

Refining the Handling Cycle

  1. The Intercepting Filter Pattern
  2. Exception Handling
  3. Interceptors
  4. The Decorator Pattern
  5. Context and Lifecycle
  6. Awareness Interfaces
  7. Support and Utility Classes
  8. “Death By XML”

The Persistence Tier

  1. The DAO Pattern
  2. The DaoSupport Hierarchy
  3. The DataAccessException Hierarchy
  4. JDBC DAOs
  5. JdbcTemplate and RowMapper
  6. Object/Relational Mapping
  7. Hibernate® DAOs
  8. Transaction Control
  9. AOP vs. Annotations

Integration with Hibernte

  1. Integration of Hibernate
  2. Hibernate® HibernateDaoSupport
  3. Hibernate® HibernateTemplate
  4. Understanding of Integration with Spring
  5. Best Practices of Spring with Hibernate
  6. Best Practices of Spring
  7. Conclusion Questions and Answer Session