JAVA EE PROGRAMMING WITH SPRING 3 USING ECLIPSE AND WEBSPHERE – GTWSP6

Course Description

This course shows how to use the popular Spring framework with some of the most recent Java EE technologies on the WebSphere platform. Rather than using technologies like Servlets, JSP, and Hibernate, this course highlights how more recent technologies can make Java EE application programming easier while also relying on standard technologies to ease deployment to various platforms. This course can provide an introduction to the various technologies in addition to Spring so that students can immediately be effective developers.

OBJECTIVES
Upon completion of this course, you should be able to:

  • Understand the need for the Spring framework
  • Program JSF web applications
  • Integrate Spring with JSF
  • Utilize JSF events, navigation, and validation
  • Use Java Persistence API (JPA) to manage persistence of Java data
  • Query persistent data with JPA QL
  • Manage relationships between data with JPA
  • Integrate Spring with the JPA ORM framework
  • Use Spring in web service applications
  • Utilize Spring JMS
TOPICS
  • Introduction to JSF
  • JSF components
  • JSF Navigation
  • JSF Validation
  • Using JSF with Spring
  • Introduction to JPA
  • JPA data queries
  • JPA entity relationships
  • JPA and Database Support in Spring
  • Spring Web Services
  • Spring JMS

^^

Duration

5 days

^^

Target Audience

Software designers, developers and programmers.

^^

Course Prerequisites

To succeed fully in this course, students should be able to Program Java applications. The following course meets this requirement:

GTJ01 – Introduction to Java Using Eclipse

^^

Suggested Follow on Courses

There are a number of options of suitable follow-on courses, depending on your business needs. Please contact us for further details.

^^

Course Content

CHAPTER 1. INTRODUCTION TO THE SPRING FRAMEWORK

What is the Spring Framework?

Spring Characteristics

Spring Modules

Why Spring?

Problems with EJB

Spring Philosophies

Alternatives to Spring

Simple Example

What is Inversion of Control?

IoC Example

CHAPTER 2. SPRING 3 DEVELOPMENT TOOLS

SpringSource Tool Suite

Developing Spring 3 Applications With RAD

Sequence of Installation for Spring/RAD/WebSphere

Alternatives to RAD for Spring/WebSphere Development

Creating a Spring Project

Tools for Spring Beans Configuration Files

Spring Configuration Validation

Spring Web Flow Definition Tools

Maven Overview

Managing Spring JARs with Maven

Adding Maven Dependencies

CHAPTER 3. DEFINING AND USING SPRING BEANS

Spring “Beans”

Spring Containers

Instantiating the Spring Container

Retrieving Spring Beans

Configuring Spring Beans

<bean> Element

Naming Beans

Setting Bean Properties

Using the Spring XML ‘p’ Schema

Creating Beans with a Constructor

Resolving Constructor Ambiguity

Setting Properties vs. Invoking Constructors

Bean Scope

Effect of Bean Scope on Instances

CHAPTER 4. ADVANCED SPRING BEAN CONFIGURATION

Defining Beans with Annotations

Component Stereotype Annotations

Spring Component Annotations

Bean Scope with Annotations

Configuring Classpath Scanning for Spring Beans

Choosing Which Annotations to Use

Overriding Annotation Configuration with XML

Externalizing Bean Configuration

PropertyPlaceholderConfigurer

PropertyOverrideConfigurer

Inheriting Bean Configuration

Lazy Initialization

Declaring Beans from Static Fields

Declaring Beans from Object Properties

CHAPTER 5. SPRING DEPENDENCY INJECTION

Dependency Injection

Benefits of Dependency Injection

Specifying Bean References

Constructor Injection

Constructor vs. Setter Injection

Injecting Multivalued Properties

Other Multivalued Types

Specifying the Data Type of Collections

Defining Collections Using Utility Factory Beans

Defining a Reusable Properties From an External File

Bean Scope Effect on Dependency Injection

Autowiring With XML

Autowiring Example

Errors in Autowiring

Excluding a Bean from Autowiring

Autowiring Multivalued Properties

Mixing Explicit and Autowiring

CHAPTER 6. SPRING DEPENDENCY INJECTION WITH ANNOTATIONS

Dependency Injection Annotations

@Autowired and @Inject

Locations for @Autowired and @Inject

Autowiring Multivalued Properties

Autowiring by Bean Name with @Resource

Injecting Named Collections Defined in XML with @Resource

Checking Required Dependencies

Enforcing Required Properties with XML Autowiring

Multiple @Autowired Constructors

Multiple Autowiring Matches

Qualifiers with Annotation-based Autowiring

Adding a Qualifier Value to a Bean Definition

Qualification of Multivalued Properties

Defining Custom @Qualifier Annotations

Complex Custom @Qualifier Annotations

Associating Custom Bean Qualifiers with XML

Processing Injection Annotations

Overriding Annotation Injection

CHAPTER 7. TESTING SPRING APPLICATIONS

Spring Unit Testing

Configuring Test Projects

Spring TestContext Framework

Implementing Test Classes

Loading Spring Configuration with Test Classes

Accessing Spring Components Within Test Classes

Defining Tests to Execute

Isolating Tests Which Modify the Spring Environment

Transactional Testing Support

Transactional Test Base Classes

Avoiding False Positives with ORM Testing

Other Transaction Annotations

Other Spring Annotations for JUnit

Unit Testing Support Classes

Mock Objects

CHAPTER 8. INTRODUCTION TO JAVASERVER FACES

What is JavaServer Faces (JSF)?

Why Use JSF?

Nature of a JSF Application

The Sun Reference Implementation (RI)

JSF and MVC

Faces Servlet

Managed Bean

The View

A Simple JSF Application

The Input Form: form.jsp

The Result: thanks.jsp

The Controller: AddressBean

Page Flow or Navigation Rule

How Does the Application Work?

Under the Covers: The Rendered Form HTML

Under the Covers: The Layout Tree

CHAPTER 9. MANAGED BEAN

What is a Managed Bean?

Why Do You Need Managed Beans?

Managed Bean As a Controller

Registering a Managed Bean

Lifecycle of a Managed Bean

Initializing a Managed Bean

What Scope to Use?

Value Binding

Property Data Conversion

Advanced Property Types

Component Binding

Other Binding Types

Basic Input Processing

Advanced Input Processing

JSF Expression Language

Language Basics

Use of Expression in JSF

Basic Expression

Property Access Expression

Map Access Expression

Complex Access Expression

Predefined Objects

Operators

CHAPTER 10. USING JSF WITH SPRING

JSF Integration Options

DelegatingVariableResolver

SpringBeanVariableResolver

SpringBeanFacesELResolver

Spring Bean Scopes

FacesContextUtils

JSF with Spring Web Flow

CHAPTER 11. USER INTERFACE COMPONENTS

JSF UI Components

JSF Component Tag Libraries

Using the Tag Libraries

HTML Tag Library

Identifying Components

Component Identifier

Client Identifier

Form Input Field Names

Define a Form

Labels and Images

Buttons

Links

Adding Parameters to Links

Text Input

Simple Check Box

Check Box Group

Check Box Group Example

Radio Button

List Boxes

Dynamic List Box

Example

Another Example

JSF Core Library

JSF Core Library – Components

JSF Component Model

Base Class Hierarchy

Useful Base Classes

Useful HTML Classes

CHAPTER 12. JSF EVENT HANDLING

Request Processing Phases

Action Request Processing Phases

JSF Event & Listener Model…

JSF Event Classes

Event Classes

Event Classes: Hierarchy

Action Event Handling

Action Event: Example

Action Listener

Value Change Event

Value Change Event Handler

Listener Classes

Listener Interfaces

Listener Classes: Hierarchy

Action Listener Class

Value Change Listener Class

Phase Event Listener

Request Processing Lifecycle

Phase Identifiers

CHAPTER 13. JSF NAVIGATION

JSF Navigation

Example Action Listener

faces-config.xml File

JSF Navigation

Choosing Between Redirect & Direct Rendering

Navigation Rules: Example

Navigation: Scenarios

CHAPTER 14. ADVANCED GUI COMPONENTS

HTML Panel

Applying Styles

Grouping Components

Data Table

Using a Data Table

Data Table Model

Using a Data Table

Displaying a Header and Footer Row

Applying Styles

Adding Links to a Row

Using Component Binding

Handling Action

Using the Data Table Model

Handling Action

CHAPTER 15. ENTITIES AND JAVA PERSISTENCE API

Data Persistence

Java Persistence API

Entities

Session Beans Vs Entities

Entities

Persisting and Retrieving Data

Accessing Entities

EntityManager & Persistence Unit

Persistence Context

Entities – Example

persistence.xml – Hibernate Provider

persistence.xml – Open JPA Provider

persistence.xml – Toplink

Entity Instance Lifecycle

Creating EntityManager in Session EJB

Creating EntityManager in a Plain Java Class

Working With the EntityManager Interface

Transaction Basics

CHAPTER 16. USING SPRING WITH JPA OR HIBERNATE

Spring ORM

Benefits of Using Spring with ORM

Spring @Repository

Using JPA with Spring

Configure Spring JPA EntityManagerFactory

Using JNDI to Lookup JPA EntityManagerFactory

LocalContainerEntityManagerFactoryBean

LocalEntityManagerFactoryBean

Application JPA Code

Hibernate

Hibernate Session Factory

Spring LocalSessionFactoryBean

Application Hibernate Code

“Classic” Spring ORM Usage

Spring JpaTemplate

Spring JpaCallback

JpaTemplate Convenience Features

Spring HibernateTemplate

Spring HibernateCallback

HibernateTemplate Convenience Methods

CHAPTER 17. JPA ENTITY LIFECYCLE

Entity Lifecycle

When is an Entity Managed or Detached?

Implementing the CRUD Pattern

Accessing Entities Using Stateless Session Beans

Inserting Data

Retrieving Data

Updating Data

Deleting Data

Merging Entities

Merging Entities (example)

Life-Cycle Callbacks

Example: Internal callback

External Callback Class

Listener Class – Example

Synchronizing with Databases

Entity Lookup

JPAQL (JPA Query Language)

CHAPTER 18. JAVA PERSISTENCE QUERY LANGUAGE (JPA QL)

JPA Query Language

Basic JPAQL Syntax

Simple SELECT Examples

Example of Using JPAQL

The SELECT clause

Reading Data from Code

The WHERE Clause

Example Using JPAQL from Session EJB

Named Query

Multiple Named Queries

Bulk Updates

Bulk Delete

Running Native SQL Query

Native SELECT Query

Native SQL Delete and Insert

Named Native Query

CHAPTER 19. BASIC ENTITY RELATIONSHIPS

Relationship Between Entities

Anatomy of a Relationship

Foreign Key

Example Schema

One-to-One Unidirectional

Creating Entity Instances

Traversing the Relationship

The Cascade Behavior

One-to-One Bidirectional

Maintaining Bidirectional Links

Simplifying Bidirectional Links

Traversing the Relationship

CHAPTER 20. COMPLEX ENTITY RELATIONSHIPS

One-To-Many and Many-To-One

Many-to-One Unidirectional

Creating Entity Instances

Traversing the Relationship

Modeling One-to-Many

Maintaining Bidirectional Links

Creating Entity Instances

Traversing the Relationship

Many-to-Many

Modeling Many-to-Many

Maintaining Bidirectional Links

Creating Entity Instances

Traversing Relationship

Unidirectional One-to-Many

Modeling Unidirectional One-to-Many

Creating Entity Instances

Traversing the Relationship

Relationship in JPA QL

Fetching Optimizations

Lazy vs. Eager Initialization

Lazy Initialization

Various Problems with Lazy Initialization

Fetch Join Query

CHAPTER 21. SPRING, JSF AND JPA INTEGRATION

Integrating JSF

JPA

Spring

Putting It All Together

Simple Application

Code the JPA Entity

The Managed Bean

Entity as Managed Bean

Entity as a Field of the Managed Bean

Accessing the Entity Manager

EntityManager in JSF Managed Bean

Separate Spring Component Works with EntityManager

Entity As DTO

Managed Bean Scope

CHAPTER 22. IMPLEMENTING WEB SERVICES WITH SPRING

Web Services in Spring Applications

Spring Web Service Options

Injecting Spring Components Into Web Service Classes

Using Spring with JAX-WS Web Services

Extending the SpringBeanAutowiringSupport Class

Using a @PostConstruct Initialization Method

Combining @PostConstruct and @Autowired

Comparing Third Party Frameworks with Spring-WS

CHAPTER 23. SPRING JMS

Spring JMS

JmsTemplate

Connection and Destination

JmsTemplate Configuration

Transaction Management

Example Transaction Configuration

Producer Example

Consumer Example

Converting Messages

Message Listener Containers

Message-Driven POJO’s Async Receiver Example

Message-Driven POJO’s Async Receiver Configuration

CHAPTER 24. REVIEW OF NEW FEATURES IN SPRING 3.0

Requirements and Supported Environments

Using Spring with Servers

Packaging

Spring Expression Language

Java-based Configuration

Annotation-based Configuration

Spring MVC Changes

New Spring MVC Configuration

Spring MVC Annotation Example

Validation

^^

See more WebSphere courses