Java EE 6: Develop Database Applications with JPA

This Java EE 6 training takes you through the process of developing Java applications that leverage object/relational mapping with the Java Persistence API. Learn to use the new features and enhancements of JPA 2.0.

Suggested Prerequisite

• Experience with Java EE 6 platform recommended
• Experience with Relational Databases recommended
• Experience with Java programming
• Oracle WebLogic Server 12c Basic Administration Tasks OBEs
• Experience with NetBeans recommended
• Experience building and deploying EE applications

Required Prerequisite

• Developing Applications with Java EE 6 on WebLogic Server 12c
• Java SE 7 Programming

Audience

• J2EE Developer
• Java EE Developers
• Database Designers
• Java Developers

Course Objectives

• Map relational database tables to Java using ORM techniques and JPA
• Perform CRUD operations with JPA in Java SE and EE environments
• Update multiple database tables based on relationships
• Perform data validation using Bean Validation
• Apply transactions and locking
• Optimize JPA for performance

Course Introduction

• Describing the need for Object-Relational Mapping
• Explaining the course itinerary
• Describing the target audience for this course
• Describing the format that the class will use
• Introducing the course environment

Introduction to Java Persistence API

• Creating entity classes
• Describing the Java Persistence API
• Creating typed queries in JPA
• Obtaining an Entity Manager
• Using an entity manager to create, find, update, and delete entities
• Creating a Persistence Unit
• Using persistent field and properties
• Using a generated primary key (table, sequence and identity)

Working with JPA in a Java Enterprise Environment

• Accessing JPA entities from Enterprise JavaBeans
• Evaluating the application of JSF as a user interface framework
• Determining the impact of using stateless, stateful, and singleton session beans on entities
• Accessing JPA entities from a servlet
• Evaluating the role of the container with JPA
• Configuring a persistence context in an EE context

Introduction to the Auction Application Case Sudy

• Defining the domain objects of the auction application
• Describing the implementation model for the auction system
• Describing the auction application

Modeling Relational Databases with JPA Entities

• Implementing many-to-one/one-to-many bidirectional associations
• Examining relationships in the data and object models
• Using relationship properties to define associations
• Implementing one-to-one unidirectional and bidirectional associations
• Applying the OrphanRemoval annotation to prevent orphaned entities
• Using OrderBy and OrderColumn annotations to define sort order
• Implmenting many-to-many unidirectional and bidirectional associations

Working with the Entity Manager

• Using entity manager operations to perform CRUD operations: persist, find, merge, remove
• Describing the entity life cycle
• Defining and use cascading operations
• Differentiating between transaction-scoped and extended entity managers
• Examining the role of the entity manager with detached entities
• Describing the relationship between an entity and an entity manager, and between a persistence context and a persistence unit

Persisting Enums and Collections

• Persisting entities that contain enums
• Persisting entities that contain Maps
• Persisting entities that contain collections

Creating Queries with the Java Persistence Query Language (JPQL)

• Using named queries
• Contrasting JPQL with native queries
• Refining queries to return only needed data
• Performing joins between entities
• Creating dynamic queries with parameters
• Using conditionals to filter results
• Describing the Java Persistence Query Language (JPQL)
• Performing bulk updates and deletes

Using the Critieria API

• Using the canonical metamodel
• Using ORDER BY, GROUP BY, and HAVING clauses
• Creating paths and expressions
• Contrasting the Critiera API with JPQL
• Using the Critieria API structure and core interfaces
• Creating SELECT, FROM, and WHERE clauses

Implementing Bean Validation with JPA

• Utilizing validation groups
• Creating a custom Bean Validation constraint
• Using built-in validation constraint annotations provided by Bean Validation
• Describing the JPA lifecycle phases where validation takes place
• Creating an entity listener class

Applying Locking and Transactions

• Implementing a container-managed transaction policy
• Describing transaction semantics
• Supporting pessimistic locking by using EntityManager APIs
• Supporting optimistic locking with the versioning of entity components
• Using JTA to scope transactions programmatically
• Comparing programmatic and declarative transaction scoping
• Describing the effect of exceptions on transaction state

Advanced Modeling: Entity Inheritance Relationships

• Overriding mappings with the @AttributeOverride and @AssociationOverride annotations
• Specifying composite primary keys
• Evaluating object-relational mapping strategies for entity inheritance
• Applying single-table-per-class, joined-subclass, and table-per-class inheritance mapping strategies
• Using embeddable classes

Optimizing JPA Performance

• Using cache optimizations with JPA and EclipseLink
• Creating and using stored procedures with JPA and EclipseLink
• Modifying queries to prevent the N + 1 problem
• Using lazy fetching to prevent the loading of entities that are not being used
• Describing performance issues associated with IDENTITY ID generation
• Creating read-only queries
• Using pagination to control the amount data that is needed at any one time]