Skip Navigation Links

Course Length:
3 Days
Course Description:
This course introduces the Spring Framework, the leading full-stack framework for Java EE applications. Topics covered include the Spring container, dependency injection, data validation, aspect-oriented programming, the JDBC Template, and the Hibernate Template. A Web application is also presented to illustrate the use of the Spring Web MVC design pattern.
Who Should Attend:
This course is for Java developers and architects who wish to explore a popular, open-source alternative to traditional Java EE programming.
Benefits of Attendance:
Upon completion of this course, students will be able to:
  • Describe the seven component modules of the Spring Framework.
  • Understand the basic philosophies of Spring.
  • Explain the purpose and benefits of dependency injection.
  • Configure beans in a Spring configuration file.
  • Use setter and constructor injection with Spring beans.
  • Create property files for error messages and to support internationalization.
  • Write validators and property editors for user-defined data .
  • Understand basic concepts of aspect-oriented programming.
  • Use the JDBC template to simplify database access.
  • Use the Hibernate template to integrate Hibernate and Spring.
  • Create Web applications using the Model-View-Controller architecture.
  • Write forms and controllers for Spring Web applications.
Prerequisites:
Students must have strong Java programming skills and exposure to Java EE technology.
Course Outline:
  • Chapter 1: Introduction to Spring
    1. What is Spring?
    2. Overview of the Spring Framework
    3. Spring Philosophies
    4. Spring Documentation
    5. Java 5 Language Features
  • Chapter 2: A First Look at Spring
    1. A Simple Example
    2. Wiring Beans
    3. Configuring a Properties File
    4. Schema-Based Configuration
  • Chapter 3: Beans and Containers
    1. Spring Containers
    2. Spring Configuration File
    3. Spring Beans
    4. Using the Container
    5. The BeanFactory Interface
    6. Singleton vs. Prototype
    7. Bean Naming
    8. Dependency Injection
    9. Setter Injection
    10. Constructor Injection
  • Chapter 4: The Application Context
    1. The ApplicationContext Interface
    2. Accessing Application Components
    3. Accessing Resources
    4. Internationalization with MessageSource
    5. Application Events
  • Chapter 5: Data Validation and Conversion
    1. The Validator Interface
    2. The Errors Interface
    3. The ValidationUtils Class
    4. Validator Example
    5. Testing the Validator
    6. Property Editors
    7. Custom Property Editors
  • Chapter 6: Aspect-Oriented Programming
    1. Aspect-Oriented Programming
    2. AOP Concepts
    3. AOP Proxies
    4. The AOP Alliance
    5. Types of Advice
    6. AOP Example
    7. Introductions
  • Chapter 7: Using JDBC with Spring
    1. A Simpler Approach
    2. Working with the HSQLDB Database
    3. The JdbcTemplate Class
    4. Exception Translation
    5. Updating with the JdbcTemplate
    6. Queries using the JdbcTemplate
    7. Mapping Results to Java Objects
  • Chapter 8: Using Hibernate with Spring
    1. What is Hibernate?
    2. Hibernate Sessions
    3. The HibernateTemplate
    4. Sample Class and Mapping File
    5. Creating and Saving a New Entity
    6. Locating an Existing Entity
    7. Updating an Existing Entity
    8. Hibernate Query Language
    9. Executing Queries
  • Chapter 9: Spring Web MVC - Part 1
    1. Spring Web MVC
    2. The DispatcherServlet
    3. Writing a Controller
    4. A Simple View Page
    5. Configuring the Controller
    6. Adding a View Resolver
    7. Adding a Message Bundle
    8. Adding Business Classes
    9. Adding Test Data
    10. Accessing a Database
    11. Adding a Form
    12. Updating the Database
    13. Integrating Hibernate
  • Chapter 10: Spring Web MVC - Part 2
    1. Handler Mappings
    2. View Resolution
    3. Chaining View Resolvers
    4. Controllers
    5. AbstractWizardFormController
  • Appendix A: Resources
    1. Resources
  • Appendix B: Spring IDE
    1. Spring IDE
    2. Adding the Spring Project Nature
    3. Managing Spring Configuration Files
    4. Visualizing a Configuration File
  • Appendix C: Creating a Spring Project in Eclipse
    1. Introduction
    2. Creating a Spring Project
    3. Configuring the Build Path
  • Appendix D: Running the Examples in Eclipse
    1. Running the Standalone Applications
    2. Starting the Server
    3. Starting the Server
    4. Running the Web Application
    5. Modifying the Web Application
    6. Stopping the Server