Realdolmen Education

Details

Spring 4

This course is currently not scheduled on the open calendar, but can be organized on request.

Request Course

Duration

3 day(s)

Audience

Developers and architects who want to learn about the Spring framework.

Prerequisites

Participants should have a good understanding of Java programming. Knowledge of design patterns and JavaEE principles in a plus but is not required.

Objectives

This course will teach you about the Spring framework, updated to it's latest 4.0 release. The course will focus only on the most typical Spring features that all Spring programmers need to know about.

Methods

Classroom training with hands-on exercises.

Description

The Spring framework is a powerful yet lightweight application platform for developing enterprise Java applications. It provides a flexible alternative to the Java EE platform to solve typical enterprise problems. Spring achieves this by focusing on good Object Oriented design principles such as designing to interfaces, working with the POJO model and testability.

The core technologies used in Spring are based on a strong IoC engine, that offers dependency injection and a managed lifecycle. Another fundamental part of Spring is its Aspect Oriented Programming engine that allows separation of crosscutting concerns, so that applications are easier to maintain.

On top of these core principles, integration is provided with other frameworks, such as JPA, JDBC, JEE, etc?. Spring streamlines interaction with these technologies, by eliminating as much boilerplate as possible and providing a non-intrusive programming model.

Spring 4.0 now enhances the framework by focusing on modern technoloigies such as Java 8, JEE 7 and adding support for new technologies.

RealDolmen Education now provides the opportunity for developers, architects and designers to learn about Spring so that they can leverage it to facilitate their daily tasks. The course is oriented to the practical use of Spring, but also provides the necessary in-depth information to efficiently work with the framework. This is accomplished by instructor-led hands-on exercises in combination with quality course material.

This course also includes the superb technlogies Spring Boot and Spring Data to simplify development even further. Consult the table of contents for more detailed description of the course.

Contents

  • Introduction
    • Agenda
    • What is Spring?
    • History of Spring
    • Exciting new features in Spring 4
    • Spring strategies
    • The power of POJOs
    • Dependency injection
    • Wiring
    • Seeing it work
    • Applying aspects
    • Templating
    • Spring containers
    • Bean lifecycle
    • Spring framework modules
    • Spring portfolio
    • What's new in Spring 4?
    • Exercises
  • Wiring Beans
    • Wiring beans
    • Spring configuration options
    • Automatically wiring beans
    • Component scanning
    • Autowiring with annotations
    • Wiring beans with Java
    • Wiring with XML
    • Importing and mixing configurations
    • Exercises
    • Environments and profiles
    • Conditional beans
    • Addressing ambiguity in autowiring
    • Scoping beans
    • Runtime value injection
    • Wiring with Spring Expression Language
  • Aspect Orientation
    • Cross-cutting concerns
    • Aspect Oriented Programming
    • AOP terminology
    • Advices
    • Join points
    • Pointcuts
    • Aspects
    • Introduction
    • Weaving
    • AOP frameworks
    • Spring AOP
    • AOP proxies
    • Configuring aspects using annotations
    • Dependencies
    • Enabling AOP
    • Pointcut designators
    • Execution
    • Within, this and target
    • Args
    • Annotations
    • Bean
    • Aspect beans
    • Before advice
    • After advice
    • After advice capturing
    • Around advice
    • JoinPoint reflection
    • Named pointcuts
    • Argument capturing
    • Introductions
    • XML configuration
    • Exercises
  • Spring Persistence
    • Persistence overview
    • Repositories
    • DataAccessException
    • Template classes
    • DataSource
    • DriverManagerDataSource
    • Pooled DataSource
    • JNDI DataSource
    • Embedded DataSource
    • Using profiles
  • Spring JDBC
    • JDBC pros and cons
    • Dependencies
    • JDBC boilerplate code
    • JdbcTemplate
    • Configuring JdbcTemplate
    • Eliminating boilerplate code
    • RowMappers
    • JdbcTemplate API
    • Named parameters
    • Exercises
  • Spring JPA
    • JPA pros and cons
    • Spring ORM
    • Dependencies
    • POJO repositories
    • EntityManagerFactory
    • Spring based persistence configuration
    • JPA based persistence configuration
    • Transaction manager
    • JPA repositories
    • Exercises
  • Spring Data
    • Spring Data
    • Defining query methods
    • Declaring custom queries
    • Mixing in custom functionality
    • Exercises
  • Transaction Support
    • Understanding transactions
    • Transaction support
    • Spring framework transaction strategy
    • Choosing a platform
    • Defining transaction managers
    • Declarative transaction management
    • Using @Transactional
    • @Transactional settings
    • @Transactional properties
    • Transaction propagation
    • Transaction isolation
    • Programmatic transaction management
    • Exercises
  • Spring Web MVC
    • Spring Web MVC
    • Getting started with Spring Web MVC
    • Configuring the DispatcherServlet
    • A tale of two application contexts?
    • Configuring Spring Web MVC
    • Configuring the backend application context
    • Writing a simple controller
    • Creating the view
    • Testing the controller
    • Defining class-level request handling
    • Passing model data to the view
    • Accepting request input
    • Validating forms
    • Rendering web views
    • Creating JSP views
    • Resolving JSTL views
    • Binding forms to the model
    • Spring's general tag library
    • Working with Thymeleaf
    • Defining Thymeleaf templates
    • Form binding with Thymeleaf
    • Exercises
  • Spring Test
    • Test-driven development with Spring
    • Configuring the ApplicationContext
    • Inheriting context configuration
    • ApplicationContext caching
    • Injecting dependencies in tests
    • Using transaction management in tests
    • Testing with ORM frameworks
    • Testing web applications
    • Testing request- and session-scoped beans
    • Testing Spring MVC projects
    • Testing form submission
    • Testing exception handlers
    • Spring-provided mock objects and other utilities
    • Exercises
  • Spring Boot
    • What is Spring Boot?
    • Rationale
    • Main components
    • Starter dependencies
    • Autoconfiguration
    • Command-line interface
    • Actuator
    • Building a web application
    • Project setup
    • Controllers
    • Domain classes
    • Views
    • Static resources
    • Persistence
    • Application configuration
    • Running the application
    • Groovy and Spring Boot CLI
    • Installing the CLI
    • Groovy domain classes
    • Autoimporting
    • Grabbing
    • Groovy controllers
    • Groovy views and static resources
    • Groovy persistence
    • Running from the CLI
    • Enabling the Actuator
    • Actuator endpoints
    • Exercises
  • References
    • References