+1 (778) 681-0711

Java EE 6: Develop Database Applications with JPA

Duration : 4 Days (32 Hours)

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

The Java EE 6: Develop Database Applications with JPA course guides developers in utilizing the Java Persistence API (JPA) to create and manage database applications. Participants learn JPA fundamentals, including entity beans and ORM, and delve into advanced topics like caching, concurrency, and transactions. Through hands-on exercises, they gain practical experience in creating and deploying JPA-based database applications in Java EE 6. The course also explores JPA internals and tools like EclipseLink for building enterprise applications, emphasizing coding best practices, debugging, and testing. By course completion, participants acquire the essential knowledge and practical skills for proficiently developing database applications with JPA.

Intended Audience:

  • Mid-level and experienced software developers seeking to expand their knowledge of Java EE 6 and develop database applications using Java Persistence API (JPA)
  • Developers interested in enhancing their skills in working with databases, enterprise Java frameworks, and tools, as well as developing Java Enterprise Edition applications
  • Those who want to learn how to create and manage entity classes, execute queries, manage transactions, and establish entity relationships using JPA
  • Developers looking to improve their troubleshooting and optimization skills for Java EE applications that utilize JPA technologies

Learning Objectives of Java EE 6: Develop Database Applications with JPA:

1. Understand the JPA Architecture and know how to utilize it in a Java EE application.
2. Learn the basics of the JPA Entity Model and how to define the relationships and constraints between different entities.
3. Implement JPA Entities and use the various methods of EntityManager interface for CRUD operations.
4. Build dynamic queries for the Entities and optimize them for better performance.
5. Work with Embeddable Types, transactions and Entity Listeners.
6. Use the various techniques for mapping the Entities.
7. Create application that is robust, secure and portable across various Java EE application servers.
8. Utilize the Optimistic locking and Advanced Cascading techniques for Object to Relational mapping.
9. Create dynamic Web pages using JSF, JDBC and JPA.
10. Utilize the best practices while working with the Java EE 6.

 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
  • 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
  • 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
  • Describing the auction application
  • Defining the domain objects of the auction application
  • Describing the implementation model for the auction system
  • 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
  • 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
  • Persisting entities that contain enums
  • Persisting entities that contain collections
  • Persisting entities that contain Maps
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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

Java EE 6: Develop Database Applications with JPA Course Prerequisites:

• Knowledge of basic programming principles
• Basic understanding of object-oriented programming concepts
• Familiarity with basic data structures and algorithms
• Understanding of development process paradigms, such as agile and waterfall
• Experienced in coding languages such as Java, C++, and Python
• Experienced in development and deployment tools such as Eclipse, Git, Maven, and Jenkins.

Discover the perfect fit for your learning journey

Choose Learning Modality

Live Online

  • Convenience
  • Cost-effective
  • Self-paced learning
  • Scalability

Classroom

  • Interaction and collaboration
  • Networking opportunities
  • Real-time feedback
  • Personal attention

Onsite

  • Familiar environment
  • Confidentiality
  • Team building
  • Immediate application

Training Exclusives

This course comes with following benefits:

  • Practice Labs.
  • Get Trained by Certified Trainers.
  • Access to the recordings of your class sessions for 90 days.
  • Digital courseware
  • Experience 24*7 learner support.

Got more questions? We’re all ears and ready to assist!

Request More Details

Please enable JavaScript in your browser to complete this form.

Subscribe to our Newsletter

Please enable JavaScript in your browser to complete this form.
×