Oracle/Java EE 6: Develop Database Applications with JPA/1Z0-898

Java EE 6: Develop Database Applications with JPA Certification Training Course Overview

The Java EE 6: Develop Database Applications with JPA training and certification course will give you a detailed overview on using the Java Persistence API in a web-based Java Enterprise Edition application, as well as within a stand-alone Java Standard Edition application. During the training, you will also learn the Java Persistence API with the Enterprise JavaBeans technology.

Who should do Java EE 6: Develop Database Applications with JPA training?

  • Database Designers
  • J2EE Developer
  • Java Developer
  • Java EE Developer
     
This course prepares you for Exam 1Z0-898.

Java EE 6: Develop Database Applications with JPA (32 Hours) Download Course Contents

Live Virtual Classroom Fee On Request
Group Training Date On Request
1-on-1 Training (GTR)
4 Hours
8 Hours
Week Days
Weekend

Start Time : At any time

12 AM
12 PM

GTR=Guaranteed to Run
Classroom Training (Available: London, Dubai, India, Sydney, Vancouver)
Duration : On Request
Fee : On Request
On Request
Special Solutions for Corporate Clients! Click here
Hire Our Trainers! Click here

Course Modules

Module 1: Course Introduction
  • Describing the target audience for this course
  • Explaining the course itinerary
  • Describing the format that the class will use
  • Introducing the course environment
  • Describing the need for Object-Relational Mapping
Module 2: Introduction to Java Persistence API
  • Describing the Java Persistence API
  • Creating entity classes
  • Using persistent field and properties
  • Using a generated primary key (table, sequence and identity)
  • Obtaining an Entity Manager
  • Creating a Persistence Unit
  • Using an entity manager to create, find, update, and delete entities
  • Creating typed queries in JPA
Module 3: Working with JPA in a Java Enterprise Environment
  • Evaluating the role of the container with JPA
  • Accessing JPA entities from a servlet
  • Evaluating the application of JSF as a user interface framework
  • Accessing JPA entities from Enterprise JavaBeans
  • Determining the impact of using stateless, stateful, and singleton session beans on entities
  • Configuring a persistence context in an EE context
Module 4: Introduction to the Auction Application Case Sudy
  • Describing the auction application
  • Defining the domain objects of the auction application
  • Describing the implementation model for the auction system
Module 5: Modeling Relational Databases with JPA Entities
  • Examining relationships in the data and object models
  • Using relationship properties to define associations
  • Implementing one-to-one unidirectional and bidirectional associations
  • Implementing many-to-one/one-to-many bidirectional associations
  • Implmenting many-to-many unidirectional and bidirectional associations
  • Using OrderBy and OrderColumn annotations to define sort order
  • Applying the OrphanRemoval annotation to prevent orphaned entities
Module 6: Working with the Entity Manager
  • Describing the relationship between an entity and an entity manager, and between a persistence context and a persistence
  • Differentiating between transaction-scoped and extended entity managers
  • Describing the entity life cycle
  • Using entity manager operations to perform CRUD operations: persist, find, merge, remove
  • Examining the role of the entity manager with detached entities
  • Defining and use cascading operations
Module 7: Persisting Enums and Collections
  • Persisting entities that contain enums
  • Persisting entities that contain collections
  • Persisting entities that contain Maps
Module 8: Creating Queries with the Java Persistence Query Language (JPQL)
  • Describing the Java Persistence Query Language (JPQL)
  • Contrasting JPQL with native queries
  • Using conditionals to filter results
  • Refining queries to return only needed data
  • Performing joins between entities
  • Creating dynamic queries with parameters
  • Using named queries
  • Performing bulk updates and deletes
Module 9: Using the Critieria API
  • Contrasting the Critiera API with JPQL
  • Using the Critieria API structure and core interfaces
  • Creating SELECT, FROM, and WHERE clauses
  • Creating paths and expressions
  • Using ORDER BY, GROUP BY, and HAVING clauses
  • Using the canonical metamodel
Module 10: Implementing Bean Validation with JPA
  • Describing the JPA lifecycle phases where validation takes place
  • Creating an entity listener class
  • Utilizing validation groups
  • Using built-in validation constraint annotations provided by Bean Validation
  • Creating a custom Bean Validation constraint
Module 11: Applying Locking and Transactions
  • Describing transaction semantics
  • Comparing programmatic and declarative transaction scoping
  • Using JTA to scope transactions programmatically
  • Implementing a container-managed transaction policy
  • Supporting optimistic locking with the versioning of entity components
  • Supporting pessimistic locking by using EntityManager APIs
  • Describing the effect of exceptions on transaction state
Module 12: Advanced Modeling: Entity Inheritance Relationships
  • 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
  • Overriding mappings with the @AttributeOverride and @AssociationOverride annotations
  • Specifying composite primary keys
Module 13: Optimizing JPA Performance
  • Using lazy fetching to prevent the loading of entities that are not being used
  • Using pagination to control the amount data that is needed at any one time
  • Modifying queries to prevent the N + 1 problem
  • Creating read-only queries
  • Describing performance issues associated with IDENTITY ID generation
  • Creating and using stored procedures with JPA and EclipseLink
  • Creating and using stored procedures with JPA and EclipseLink
Download Course Contents

Request More Information

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

On completion of this course, you will know:

  • Update multiple database tables based on relationships
  • Perform CRUD operations with JPA in Java SE and EE environments
  • Perform data validation using Bean Validation
  • Optimize JPA for performance
  • Apply transactions and locking
  • Map relational database tables to Java using ORM techniques and JPA
  • Understand key concepts found in the Java Persistence API
  • Create robust entity models
  • Create static and dynamic queries using Java Persistence API Query Language
  • Create type-safe queries with the Java Persistence API Criteria API