Read more
2Month/20 Hours Price:125,000
120,000
Java EE 6: Develop Database Applications with JPA
This Java EE 6: Develop Database Applications with JPA NEW training explores using the Java Persistence API within the context of a web-based Java Enterprise Edition application, as well as within a stand-alone Java Standard Edition application. This includes using Java Persistence API with the
Enterprise JavaBeans technology.
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.
Learn To:
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.
Course Objectives
Map relational database tables to Java using ORM techniques and JPAPerform 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 Content:
Introduction
Describing the need for Object-Relational MappingExplaining 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 classesDescribing 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 JavaBeansEvaluating 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 applicationDescribing 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 associationsExamining 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, removeDescribing 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 enumsPersisting entities that contain Maps
Persisting entities that contain collections
Creating Queries with the Java Persistence Query Language (JPQL)
Using named queriesContrasting 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 metamodelUsing 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 groupsCreating 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 policyDescribing 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 annotationsSpecifying 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 EclipseLinkCreating 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
Suggested Prerequisite
Experience with Java EE 6 platform recommendedExperience 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 12cJava SE 7 Programming
Audience
J2EE DeveloperJava EE Developers
Database Designers
Java Developers
0 Reviews