Java Training : Introduction to Spring 5 and JPA2

Introduction to Spring 5 and JPA2

Java Training Overview

This course includes coverage of all the core Spring 5 and JPA 2 capabilities, as well as the integration capabilities provided by Spring. It provides extensive coverage of using Spring and JPA together, as well as using Spring Boot for dependency management and creating JPA-based repositories using Spring Data. All capabilities are practiced via an extensive set of hands-on labs.

Spring 5 provides an evolutionary advance of Spring's powerful capabilities. The course introduces these capabilities, as well as providing guidelines on when and how to use them. It includes coverage of the three main configuration styles: Java-based (@Configuration), annotation-based (@Component), and the traditional XML-based configuration that may still play an important role in existing and new projects. It uses Spring Boot capabilities for dependency management in many of the labs.

The JPA material covers all basic JPA concepts, including mapping persistent classes, and using EntityManager and EntityManagerFactory to access and manipulate persistent entities. Querying with the Java Persistence Query Language (JPQL) is covered in depth, from basic queries to more advanced queries like eager queries using left joins. It also includes coverage of advanced concepts such as collections of value objects, relationships, and inheritance and polymorphic queries.

This course is hands on with labs to reinforce all the important concepts. It will enable you to build working Spring/JPA applications and give you an understanding of the important concepts and technology in a very short time.

The standard platform does all labs with the Eclipse IDE, and the lab instructions include detailed directions for setting up and using it. The course can be made available for all major development environments, including IBM RAD and IntelliJ.

Java Training Skills Gained

Understand the core principles of Spring, and of Dependency Injection (DI) / Inversion of Control
Use the Spring Core module and DI to configure and wire application objects (beans) together
Know the different types of metadata (XML, annotations/@Component, and Java Configuration/@Configuration), and how and when to use them
Understand and use the complete capabilities of the Core module, such as lifecycle events, bean scopes, and the Spring API
Use Spring Boot to simplify dependency management and configuration
Understand the benefits of JPA and the JPA Architecture
Create JPA based applications
Work with the ORM (Object-Relational Mapping) module to integrate Spring with JPA.
Understand and use Spring's transaction support, including the easy-to-use Java annotation support, as well as the tx/aop XML configuration elements
Understand and use JPA mapping to map persistent objects to the database
Work with JPA queries and JPQL
Understand and work with collections and associations (Value and entity types, unidirectional, bidirectional, 1-1, 1-N, N-N
Use JPA's versioning support
Map inheritance hierarchies using JPA
Integrate Spring/JPA with Java EE Web applications
Use Spring Data to automatically generate JPA-based repositories with auto-generated queries

Hands-On

Minimum 50% hands-on labs

Supported Platforms

Spring 5, Eclipse, and Tomcat. Can be supported on IBM RAD/WAS, and IntelliJ with advance notice and possible extra charge.

Java Training Course Duration

5 Days

Java Training Course outline

Session 1: Introduction to Spring

Overview of Spring Technology

Motivation for Spring, Spring Architecture
The Spring Framework

Spring Introduction

Declaring and Managing Beans
ApplicationContexts - The Spring Container
XML and @Component/@Named Config

Dependencies and Dependency Injection (DI)

Examining Dependencies
Dependency Inversion / Dependency Injection (DI)
DI in Spring - XML and @Autowired

Session 2: Configuration in Depth

Java Based Configuration (@Configuration)

Overview, @Configuration, @Bean
Dependency Injection
Resolving Dependencies

Integrating Configuration Types

XML and @Component Pros/Cons
@Configuration Pros/Cons
Choosing a Configuration Style
Integrating with @Import and <import>

Bean Scope and Lifecycle

Singleton, Prototype, and Other Scopes
Configuring Scope
Bean Lifecycle / Callbacks

Externalizing Properties

Properties Files
@PropertySource, property-placeholder
Using @Value
SpEL

Profiles

Overview and Configuration
Activating Profiles

Session 3: Spring Boot Overview

maven and Spring
Spring Boot Structure
Spring POMs with Boot Parents
Spring Boot Starters
Other Capabilities

Session 4: Spring Testing

Testing and JUnit Overview

Writing Tests - Test Classes, asserts, Naming Conventions
Running Tests - IDE, maven, ...
Test Fixtures - setup and teardown

Spring TestContext Framework

Overview
Configuration
Running Tests

Session 5: Introduction to Java Persistence API (JPA2)

Overview
- Persistence Layers, Object-Relational Mapping (ORM), JDBC
- JPA Overview
Mapping with JPA
- Entities and @Entity, ids and @Id,
- Generated Id Values
- Basic Mapping Types
Persistence Unit and EntityManager
- Persisting to the DB, the EntityManager API
- Persistence Units, Config, Persistence Context
- Retrieving Persistent Entities with find()
More About Mappings
- Default Mappings, @Basic, @Column
- Field vs. Property Access
- Temporal (Date/Time) Mappings
- Java 8 Data/Time Mapping
equals() and hashCode()
Logging Options (Provider based)

Session 6: Spring/JPA Integration

Spring's DataSource Support
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 7: JPA Updates and Queries

Inserting Updating, and Deleting Entities
Querying and JPQL
- Entity Based Queries, SELECT ,WHERE
- Query Interface, Executing Queries, Generic Queries (JPA 2)
- JPQL Operators, Expressions, and Parameters
- Named Queries
Additional Query Capabilities - Projection and Aggregate Query, Embedded Objects

Session 8 Transactions

TX Overview and JPA Transactions
Spring's Declarative TX Management (REQUIRED, etc.)
@Transactional
TX Scope and Propagation
Pointcut-based Configuration of Transactions

Session 9: The JPA Persistence Lifecycle

The Persistence Lifecycle
- JPA Entity States (New, Managed, Detached, Removed), and Entity State Diagram
- Persistence Context - Lifespan, Propagation
- Synchronization to the DB
Versioning and Optimistic Locking
- Overview, Detached Instances
- Versioning, @Version, Optimistic Locking
Lifecycle Callbacks
- @PrePersist, @PostPersist, etc.
- Entity Listeners, @EntityListeners

Session 10: Relationships

Relationships Overview: Object Relationships, Participants, Roles, Directionality, Cardinality
Relationship Mapping
- Mapping Overview (1-1, 1-N, N-1, N-N)
- Unidirectional and Bidirectional
- @ManyToOne, @OneToMany, @ManyToMany, @OneToOne with Table Structures
- Relationship Inverse - Owning Side
- Collection Types (List, Set, etc)
- Cascading, Lazy and Eager Loading
- Queries Across Relationships (Inner Joins, Outer Joins, Fetch Joins)
Entity Inheritance Mapping
- Overview
- Single Table, Joined (Table per Subclass), Table per Concrete Class Mappings
- Pros and Cons of Mapping Strategies

Session 11: Spring Web Integration

Integrating Spring with Java EE Web Apps
- ContextLoaderListener
- WebApplicationContext
- Using Spring beans in Wep app controller logic
Open EntityManager in View
- Lazy Loading Issue in Web Apps
- Open EntityManager in View Pattern
- Using Spring's OpenEntityManagerInViewFilter/Interceptor

Session 12: Spring Data Introduction

Spring Data Overview

Overview and Architecture
Configuring Spring Data
Repositories and JPA Repositories
Using CrudRepository

Using Spring Data

Naming Conventions for Querying
Creating more Complex Queries
Query Configuration

Session 13: Additional Topics

Spring 5: Core Updates
JPA: Embedded Objects
JPA: Compound Primary Keys
JPA: Element Collections