Instructor-led training

Introduction to Spring 4, Spring MVC, and Spring REST Training in Roanoke, Virginia

Request a Training Proposal View Course Outline

What you'll learn

The course starts with in-depth coverage on using the powerful capabilities of Spring's Core module to reduce coupling and increase the flexibility, ease of maintenance, and testing of your applications. It goes on to cover many of the most important capabilities of Spring, including integrating persistence layers (e.g. Hibernate/JPA) with Spring, using Spring's powerful Aspect Oriented Programming (AOP) to program cross-cutting concerns in a safe and maintainable way, and using Spring's declarative transaction capabilities. The course includes integration of Spring with Java EE Web applications, and an introduction to Spring MVC. Spring MVC utilizes a Model-View-Controller pattern for building Web applications, and the introduction covers the basics of Spring MVC, and how it supports organizing your Web applications in a highly structured, loosely coupled manner. This includes an introduction to REST (Representational state transfer), and how to use Spring MVC to build RESTful resources and invoke them from Ajax-based front ends.

Prerequisites

Programmers with experience in working with Java and Object - Oriented (OO) programming.

Course Outline

Session 1:

Introduction to Spring

Overview of Spring Technology

Challenges for Modern Applications

Motivation for Spring, Spring Architecture

The Spring Framework

Spring Introduction

Managing Beans

Inversion of Control / IoC, Dependency Injection / DI

Configuration Metadata Overview, Configuring Beans (XML)

The Spring Container

Overview of the Spring Container

A Simple Spring Example

ApplicationContext Overview

ClassPathXmlApplicationContext, FileSystemXmlApplicationContext, AnnotationConfigApplicationContext

API and Usage

Dependencies and Dependency Injection (DI)

Examining Dependencies

Dependency Inversion

Dependency Injection (DI) in Spring - Basic Configuration and Usage

Session 2:

Configuration in Depth

Annotation Driven Configuration

JSR 330 (@Named) and Spring (@Component) annotation styles

@Named/@Component, @Inject/@Autowired, @Repository, @Service

Configuring Beans and Autowiring with Annotations

Enabling Annotations - context:component-scan

Pros and Cons

Java Based Configuration (@Configuration)

Overview - code-centric Configuration

@Configuration and @Bean

Dependency Injection

Resolving Dependencies on Other Beans, Injecting Configuration Classes

Pros and Cons

Integrating Configuration Types

Choosing a Configuration Style

Integrating Configuration Styles

Importing: @Import and

Scanning with @Configuration style

Bean Scope and Lifecycle

Bean Scope Defined - singleton, prototype, and Other Scopes

Configuring Scope

Bean Creation Lifecycle, Lifecycle Callbacks

BeanPostProcessor, Event Handling

Session 3:

Wiring in Depth

Value Injection

Configuring Value Properties, Property Conversions

Externalizing Values in Properties Files

Constructor Injection

Constructor Injection Overview

Configuration - @Configuration and XML

p: and c: namespaces for XML configuration

Qualifiers / Domain Specific Language (DSL)

Limitations of Autowiring

Qualifiers and DSL

Creating and Using an Annotation-Based DSL for Bean Configuration

Benefits of Qualifiers for Bean Configuration

Profiles

Profiles Overview

Configuring Profiles (XML and @Configuration)

Activating Profiles

Overview of SpEL

Session 4:

Database Access with Spring

Overview of Spring database support

Configuring a DataSource

Using Spring with Hibernate

High Level Hibernate Overview

SessionFactory configuration, LocalSessionFactoryBean

Contextual Sessions and Spring Integration

Using Spring with JPA

Managing the EntityManager (EM)

LocalContainerEntityManagerFactoryBean and Container-managed EMs

JEE and JNDI Lookup of the EM

Configuration and Vendor Adaptors

Creating a JPA Repository/DAO Bean - @PersistenceUnit, @PersistenceContext

Session 5:

Aspect Oriented Programming (AOP)

Overview of AOP

Crosscutting Concerns

AOP Basics, Aspect, Joinpoint, Advice, Pointcut

Spring AOP Introduction

Configuration - XML and @AspectJ

Defining an Aspect, Pointcut, and Advice

How Advice is Triggered

Pointcut Expressions and Advice

Pointcut Expression Overview

The execution() Designator

Other Designators (within, target, args, @target, ...)

Kinds of Advice - before, after, around, after-returning, after-throwing

Marker Annotations (Rubber Stamp AOP)

Issue with AOP Configuration

Defining an AOP Marker / Rubber Stamp

Configuring AOP Using a Marker

Advantages of Marker Annotations

@AspectJ Based AOP Support

@AspectJ Annotations Overview

Defining an Aspect, Pointcut, and Advice

Other Considerations

Spring AOP Proxies and Self-Invocation Issues

Load-Time Weaving

Caveats of AOP

Session 6:

Spring Transaction (TX) Management

Intro to Spring Transaction Management

Spring Transaction Managers

Spring Declarative TX Management

Spring TX Scope and Propagation

Spring TX Attributes (REQUIRED, SUPPORTS, etc)

XML Configuration of Transactions

Specifying Advice, TX Attributes, and Methods

Linking Advice with Pointcuts

Benefits of XML Configuration of TX Behavior

Session 7:

Spring Web Integration and Intro to Spring MVC

Integrating Spring with Java EE Web Apps - ContextLoaderListener and WebApplicationContext

Spring Web MVC Overview, Capabilities, Architecture (Front Controller, MVC Pattern)

Spring MVC Basics

DispatcherServlet, Configuration (@EnableWebMvc, Servlet 3 initialization), mvc Namespace

Controllers, @Controller, @RequestMapping (Handler Methods)

@RequestParam and Parameter Binding

View Resolvers

Controller Details, @RequestMapping, @RequestParam, @PathVariable

Model Data, @ModelAttribute, Model/ModelAndView Classes

Session 8:

Additional Spring MVC Capabilities

Reference Data with @ModelAttribute

Forms and Binding, Spring Form Tags

Session Attributes, @SessionAttributes

Validation / JSR-303

Session 9:

RESTful Services with Spring

REST Overview (Characteristics/Capabilities, URI Templates, REST vs SOAP

REST and Spring MVC

Spring support for REST

@RequestMapping/@PathVariable, @RequestBody, @ResponseBody, HTTP Method conversion

Writing RESTful Controllers

Returning XML and JSON data

Client-side Access to RESTful Services

Ajax access (Browser/JavaScript/jQuery)

Using Spring's RestTemplate

Programming Common REST Patterns

GET: Read

POST: Create

PUT: Update

DELETE: Delete

Session 10:

XML Specific Configuration

Collection Valued Properties - Configuring and using lists, sets, etc.

Additional Capabilities

Factory Classes and Factory Methods

Definition Inheritance (Parent Beans)

AutoWiring with XML

Inner Beans, Compound Names

Appendix: Maven and Spring

Training locations

Introduction to Spring 4, Spring MVC, and Spring REST training across the U.S. and beyond.

We provide Introduction to Spring 4, Spring MVC, and Spring REST training onsite and live online for organizations throughout the United States and internationally.

View all Introduction to Spring 4, Spring MVC, and Spring REST training locations

Ready to train your team?

Let's customize this training for your organization.

Tell us about your employees, your goals, and your preferred schedule. We'll prepare a training proposal covering scope, delivery format, and pricing.

Request a Training Proposal

or call 303.377.6176