Curso Java EE - Develop Database Applications with JPA - Pue

Definir términos de lenguaje y programación de Java Persistence API, y del uso de las anotaciones OrderBy y OrderColumn para orden y clasificación.
Practicar operaciones de optimización de rendimiento y manejo de CRUD mediante el uso de herramientas como JPA dentro de las plataformas Java SE y EE.
Validar datos, transacciones y bloqueo, así como enumeraciones y colecciones persistentes a través del Bean Validation.
Implementar el uso de propiedades de relación para definir asociaciones unidireccionales y bidireccionales uno a uno y de varios a uno o de uno a varios, incluso de muchos a muchos.
Describir la relación entre una entidad y un administrador de entidad, y entre un contexto de persistencia y una unidad de persistencia.
Describir el ciclo de vida de la entidad y el uso de las operaciones del administrador para realizar operaciones CRUD y de cascada: persistir, buscar, fusionar, y eliminar.

Curso Java EE - Develop Database Applications with JPA

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
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
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
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
WORKING WITH THE ENTITY MANAGER
- Describing the relationship between an entity and an entity manager, and between a persistence context and a persistence unit
- 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
PERSISTING ENUMS AND COLLECTIONS
- Persisting entities that contain enums
- Persisting entities that contain collections
- Persisting entities that contain Maps
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
- Performing bulk updates and deletes
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
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
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
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
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
- Using cache optimizations with JPA and EclipseLink