Email Us   Phone : 503-259-0312   
  Home    |    Instructor-led Training    |    Self-Paced Learning    |    Online Training     


Contact Us   -   Why Choose Wintrac   -   Clients    

Courses
ADA
Adobe
Agile
AJAX
Android
Apache
AutoCAD
Big Data
Business Analysis
Business Intelligence
Business Objects
Business Skills
C++ programming
Cisco
Citrix
Cloud Computing
COBOL
Cognos
ColdFusion
COM/COM+
CompTIA
CORBA
CRM
Crystal Reports
Datawarehousing
DB2
Desktop Application Software
DNS
Embedded Systems
Google Web Toolkit (GWT)
IPhone
ITIL
Java
JBoss
LDAP
Leadership Development
Lotus
Machine learning/AI
Macintosh
Mainframe programming
Microsoft technologies
Mobile
MultiMedia and design
.NET
NetApp
Networking
New Manager Development
Object oriented analysis and design
OpenVMS
Oracle
Oracle VM
Perl
PHP
PowerBuilder
Professional Soft Skills Workshops
Project Management
Rational
Ruby
Sales Performance
SAP
SAS
Security
SharePoint
SOA
Software quality and tools
SQL Server
Sybase
Symantec
Telecommunications
Teradata
Tivoli
Tomcat
Unix/Linux/Solaris/AIX/
HP-UX
Visual Basic
Visual Foxpro
VMware
Web Development
WebLogic
WebSphere
Websphere MQ (MQSeries)
Windows programming
XML
XML Web Services
Other
Fast Track to the Java Persistence API Version 2 (JPA 2)
Java Training Overview

As part of the complete overhaul of the Enterprise JavaBeans (EJB) specification, database persistence was broken out into a completely separate specification, the Java Persistence API (JPA). JPA replaces entity beans with powerful new Object-Relational Mapping (ORM) capabilities based on proven technologies such as Toplink and Hibernate. This course includes all important features from JPA 2, and is also suitable for users of the 1.0 release.

JPA supports a POJO (Plain Old Java Object) based model using annotations which lets you develop persistent classes following common Java idioms. It supports entity relationships, inheritance, polymorphism, composition, and much more. The Java Persistence Query Language (JPQL), which is based on SQL but operates on the object model, provides a powerful bridge between the object and relational worlds. JPA also allows you to express queries using native SQL, including the capability to map the SQL query results to persistent entities

This course covers everything you need to know to begin working with the Java Persistence API in a very short time. It covers all the important concepts necessary to access and update data stored in relational databases. It includes an extensive series of labs to exercise all major capabilities.

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 is available for all major development environments, including IBM RAD and IntelliJ.


Java Training Skills Gained
  • Understand the JPA architecture
  • Create JPA based applications
  • Understand and use JPA to map persistent objects to the database
  • Create JPA persistence units, and understand JPA persistence contexts and the Entity Lifecycle
  • Use the JPA EntityManager
  • Work with queries and JPQL (Java Persistence Query Language), as well as the Criteria API (JPA 2)
  • Understand and work with collections & associations
    • Value and Entity Types
    • Bidrectional and unidirectional
    • 1-1, 1-N, N-N
  • Use versioning support for optimistic locking
  • Map inheritance hierarchies using JPA
  • Performance tune your JPA applications
  • Understand JPA transaction support
  • Understand the relationship between JPA / EJB3
  • Use JPA entities from session beans (Optional)
  • Be familiar with Spring support for JPA (Optional)
Hands-On

50% hands-on, 50% lecture

Supported Platforms

Persistence Providers: Hibernate, EclipseLink

Java Training Course Duration

3 Days

Java Training Course outline

Session 1: Introduction to Java Persistence API (JPA)

  • 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
  • Logging Options (Provider based)

Session 2:  Updates and Queries

  • Inserting and Updating - Persisting new Entities, Updating an Instance, Removing an Instance
  • 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 query, Ordering, Aggregate Query, Build Update and Delete
  • Embedded Objects
    • @Embeddable, @Embedded
    • Defining and using Embedded Objects
  • Compound Primary Keys - @EmbeddedID, @IDClass, Defining Compound Keys

Session 3:  The Persistence Lifecycle

  • Transaction Overview and Transactions in JPA
    • Transaction Overview
    • EntityTransaction API (including JTA and resource-local EntityManager)
  • 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 4:  Entity 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, Table Structures
    • Relationship Inverse - Owning Side
    • Collection Types (List, Set, etc)
    • Cascading Over Relationships (including orphanRemoval - JPA 2)
    • @ManyToMany, @OneToOne
    • Lazy and Eager Loading
    • Queries Across Relationships (Inner Joins, Outer Joins, Fetch Joins)
  • Entity Inheritance Mapping
    • Overview
    • Single Table Mapping
    • Joined (Table per Subclass) Mapping
    • Table per Concrete Class Mapping
    • Pros and Cons
  • Element Collections (JPA 2)
    • Overview, Collections of Value Objects, @ElementCollection, @CollectionTable
    • Using Element Collections
    • Collections of Embeddables

Session 5:  The Crietria API (JPA 2)

  • Overview of the Criteria API
  • Path Expressions, Building Queries (CriteriaBuilder, CriteriaQuery, Subquery, Predicate, Expression, Order, Selection, Join)
  • Executing Queries and Accessing Results

Session 6:  Additional JPA Capabilities

  • XML Mapping Files
  • Bean Validation (JPA 2)
  • Best Practices
    • Primary Keys, Named Queries, Lazy/Eager Loading, Transactional Semantics, Encapsulation, Report Queries

Session 7:  Integration

  • Data Access Objects (DAO) and Java SE Integration (Optional)
    • DAO Overview
    • JpaUtil Class for EntityManager management in Java SE
    • Lifecycle Considerations
  • Integration with EJB (Optional)
    • Using JPA with Session Beans
    • Container Managed (Injected) Entity Manger
    • JTA Transactions and Lifecycle Considerations
    • Extended Persistence Contexts
  • Using JPA with Java Web Apps
    • Using EntityManager in Web apps - request scoping
    • Lazy Loading - Open EntityManager in View Pattern
  • Integration with Spring (Optional)
    • Injection of EntityManger, EntityManagerFactory
    • LocalEntityManagerFactoryBean
    • JPA/Spring Based DAO

 
About us
Contact us
Careers at Wintrac
Our Clients
Why Wintrac


Register for a free training CD-ROM drawing
Refer a client or instructor and earn $$$


Wintrac Inc.
16523 SW McGwire Ct.
Beaverton OR 97007
 
Wintrac, Inc. All rights reserved.                                                                               Site Map   |   Terms of Use   |   Privacy Policy