Java EE 6: Develop Database Applications with JPA




    4 Day(s) Course


    Official Courseware


    Exam Voucher


    Certified Trainer


    1:1 Training Available on Demand


    Customize Your Batch



    This Java EE 6: Develop Database Applications with JPA training will expose participants to the utility of Java Persistence API in managing relational databases in applications deploying the Java Platform, Java Enterprise Edition application, as well as a Java Standard Edition. The course will teach participants to apply the Enterprise JavaBeans technology while using Java Persistence API.

    Completion of this training course will enable candidates in:

    • Updating multiple database tables based on relationships.
    • Performing CRUD operations with JPA in Java SE and EE environments.
    • Performing data validation using Bean Validation.
    • Optimizing JPA for performance.
    • Applying transactions and locking.
    • Mapping relational database tables to Java using ORM techniques and JPA.
    • Understanding key concepts found in the Java Persistence API.
    • Creating robust entity models.
    • Creating static and dynamic queries using Java Persistence API Query Language.
    • Creating type-safe queries with the Java Persistence API Criteria API.

    Course Benefits:

    Attaining certification of this course helps individuals in the development of applications that use relational databases using Java Persistence API. Participants will also explore how JPA solves issues with traditional relational database applications, including SQL injection.

    JPA Enhancements

    JPA has been enhanced and simplified in Java EE 6. The Java Persistence API (JPA) version 2.0 specification facilitates more effective and reliable (that is, more strongly typed) methodology for building object-centric criteria-based dynamic database queries.

    1. Course Introduction

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

    2. Introduction to Java Persistence API

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

    3. Working with JPA in a Java Enterprise Environment

    • Evaluate the role of the container with JPA
    • Access JPA entities from a servlet
    • Evaluate the application of JSF as a user interface framework
    • Access JPA entities from Enterprise JavaBeans
    • Determine the impact of Deploying stateless, stateful, and singleton session beans on entities
    • Configure a persistence context in an EE context

    4. Introduction to the Auction Application Case Study

    • Describe the auction application
    • Define the domain objects of the auction application
    • Describe the implementation model for the auction system

    5. Modeling Relational Databases with JPA Entities

    • Examine relationships in the data and object models
    • Use relationship properties to define associations
    • Implement one-to-one unidirectional and bidirectional associations
    • Implement many-to-one/one-to-many bidirectional associations
    • Implement many-to-many unidirectional and bidirectional associations
    • Use OrderBy and OrderColumn annotations to define sort order
    • Apply the OrphanRemoval annotation to prevent orphaned entities

    6. Working with the Entity Manager

    • Describe the relationship between an entity and an entity manager, and between a persistence context and a persistence unit
    • Differentiate between transaction-scoped and extended entity managers
    • Describe the entity life cycle
    • Use entity manager operations to perform CRUD operations: persist, find, merge, remove
    • Examine the role of the entity manager with detached entities
    • Define and use cascading operations

    7. Persist Enums and Collections

    • Persist entities that contain enums
    • Persist entities that contain collections
    • Persist entities that contain Maps

    8. Create Queries with the Java Persistence Query Language (JPQL)

    • Describe the Java Persistence Query Language (JPQL)
    • Contrast JPQL with native queries
    • Use conditionals to filter results
    • Refine queries to return only needed data
    • Perform joins between entities
    • Create dynamic queries with parameters
    • Use named queries
    • Perform bulk updates and deletes

    9. Using the Criteria API

    • Contrasting the Criteria API with JPQL
    • Use the Criteria API structure and core interfaces
    • Create SELECT, FROM, and WHERE clauses
    • Create paths and expressions
    • Use ORDER BY, GROUP BY, and HAVING clauses
    • Use the canonical metamodel

    10. Implement Bean Validation with JPA

    • Describe the JPA lifecycle phases where validation takes place
    • Create an entity listener class
    • Utilizing validation groups
    • Create a custom Bean Validation constraint

    11. Apply Locking and Transactions

    • Describe transaction semantics
    • Describe the effect of exceptions on transaction state
    • Use JTA to scope transactions programmatically
    • Support pessimistic locking by using EntityManager APIs
    • Support optimistic locking with the versioning of entity components
    • Implement a container-managed transaction policy

    12. Advanced Modeling: Entity Inheritance Relationships

    • Evaluate object-relational mapping strategies for entity inheritance
    • Apply single-table-per-class, joined-subclass, and table-per-class inheritance mapping strategies
    • Use embeddable classes
    • Override mappings with the @AttributeOverride and @AssociationOverride annotations
    • Specify composite primary keys

    13. Optimizing JPA Performance

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

    This course is ideal for those working with the profiles of:

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


    • Experience with Java programming, Java EE 6 platform, and Relational Databases recommended
    • Developing Applications with Java EE 6 on WebLogic Server 12c Training
    • Java SE 7 Programming Training

    Suggested Prerequisites:

    • Experience with NetBeans recommended
    • Experience building and deploying EE applications
    • Oracle WebLogic Server 12c Basic Administration Tasks OBEs

    Name Code Fee



    What Our Trainees Say

    Mercury Solutions Ltd. is rated 4.6 stars by based on 18 reviews.