1z0898 Java EE 6 Java Persistence API Developer Certified Expert Exam Free Practice Test — 30 Questions

Question 1

A developer is implementing a Java EE 6 application using the Java Persistence API. They have an entity `ProductCatalog` with a bidirectional `@OneToMany` relationship to a `Category` entity. The `Category` entity has a `@ManyToOne` relationship back to `ProductCatalog`. The `ProductCatalog` entity\'s `categories` collection is mapped with `FetchType.LAZY` by default. During testing, it\'s observed that accessing `productCatalog.getCategories()` after the `EntityManager` has been closed results in a `LazyInitializationException`. Which modification to the `ProductCatalog` entity\'s mapping would most effectively prevent this exception by ensuring the `categories` collection is loaded within the persistence context?

Accepted Answer

Change the `@OneToMany` annotation on the `categories` field in `ProductCatalog` to `fetch = FetchType.EAGER`.

Question 2

Consider a `CustomerOrder` entity with a `@OneToMany(mappedBy=\"order\", cascade=CascadeType.ALL, orphanRemoval=true)` relationship to an `OrderItem` entity. The `OrderItem` entity has a `@ManyToOne` relationship to `CustomerOrder` with the field named `order`. If a developer wishes to remove a specific `OrderItem` instance from the `CustomerOrder`\'s managed collection and ensure its deletion from the database while maintaining bidirectional consistency, what critical step must be performed in addition to removing the `OrderItem` from the `CustomerOrder`\'s collection?

Accepted Answer

Explicitly set the `order` field of the `OrderItem` instance to `null`.

Question 3

A stateless session bean, `OrderProcessorBean`, is designed to process customer orders. This bean interacts with `Product` and `Order` entity beans. The `placeOrder` method within `OrderProcessorBean` is annotated with `@TransactionAttribute(TransactionAttributeType.REQUIRED)`. Inside this method, it retrieves a `Product` entity, creates a new `Order` entity, associates the `Order` with the `Product`, and then attempts to persist both the `Product` and the `Order` using the `EntityManager`. If, during the persistence of the `Order` entity, an `OptimisticLockException` is encountered due to concurrent modification of the underlying data, what is the most likely outcome for the transaction managed by the EJB container?

Accepted Answer

The EJB container will automatically roll back the entire transaction, and neither the `Product` nor the `Order` entity changes will be committed.

Question 4

Consider a scenario where an `Employee` entity has a non-nullable `@ManyToOne` relationship to a `Department` entity, with the foreign key `department_id` in the `Employee` table. The `Department` entity, in turn, has a bidirectional `@OneToMany` relationship to `Employee` entities, configured with `cascade = CascadeType.ALL` and `orphanRemoval = true`. If an `Employee` object is removed from the `employees` collection of a `Department` instance, and then the `Department` instance is persisted, what is the most accurate outcome regarding the `Employee` entity in the database?

Accepted Answer

The `Employee` entity is deleted from the database, and the `department_id` column in the `Employee` table is correctly handled as part of the deletion process.

Question 5

Consider a Java EE 6 application using the Java Persistence API (JPA) where an `EntityManager` instance is used to manage the lifecycle of `ProjectUpdate` entities. During a long-running transaction, an external, unmanaged process modifies records in the `ProjectUpdate` table directly in the database, which are also present in the `EntityManager`\'s first-level cache. Upon attempting to commit the transaction, the application encounters an error indicating that the data is no longer consistent. What is the most appropriate course of action to recover from this state and ensure data integrity for subsequent operations?

Accepted Answer

Discard the current `EntityManager` and obtain a new instance to re-execute the operation.

Question 6

Consider a Java EE 6 application utilizing the Java Persistence API. A `Product` entity, identified by a primary key `123`, was previously retrieved and then detached from its `EntityManager`. Subsequently, the application attempts to remove this detached `Product` entity by passing it to the `EntityManager.remove()` method. Which of the following actions must occur before the `remove()` operation can be successfully executed on the detached entity to ensure its deletion from the database upon transaction commit?

Accepted Answer

The detached entity must be reattached to the `EntityManager` using the `merge()` operation.

Question 7

Consider a scenario where a detached `Product` entity, which has a bidirectional `@OneToMany` relationship with `Order` entities (with `mappedBy` on the `Product` side), is merged back into the persistence context. Following the merge, an `Order` instance is removed from the `Product`\'s collection of orders. If the intention is for this removal to also delete the corresponding `Order` record from the database, what essential JPA annotation attribute must be configured on the `@OneToMany` mapping within the `Product` entity?

Accepted Answer

`orphanRemoval=true`

Question 8

A seasoned developer is building a financial reporting module for a Java EE 6 application utilizing the Java Persistence API. During testing, it\'s observed that after a record representing a client\'s account balance is successfully updated via a managed `EntityManager`, subsequent retrievals of the same account balance within the same transaction sometimes yield an older, stale value. This behavior is particularly noticeable when external processes (outside the current transaction\'s scope) might also be updating the same account balance, although the application\'s own update logic appears sound. The developer needs a strategy to guarantee that when an entity is accessed, it reflects the most current state available in the database, without necessarily invalidating the entire persistence context or introducing complex locking mechanisms if not strictly required for preventing concurrent writes. Which of the following JPA operations would best address this specific requirement of ensuring data freshness for a particular entity instance?

Accepted Answer

Invoking `EntityManager.refresh(accountEntity)` on the specific account entity instance.

Question 9

A Java EE 6 application utilizing the Java Persistence API is encountering severe performance degradation and occasional `OutOfMemoryError` exceptions when executing a query that is expected to return millions of `Order` records. The current implementation fetches all matching `Order` entities into a `List` at once. The business requirement is to process each `Order` record, update its status, and persist the changes. Which JPA 2.0 strategy would most effectively address the memory consumption issue while fulfilling the processing requirement?

Accepted Answer

Utilize `Query.getScrollableResult()` to retrieve results as a `ScrollableResults` object and iterate through it, processing a subset of records at a time before committing transactions.

Question 10

An enterprise application utilizes JPA 2.0 for managing business entities. A core entity, `Order`, has a bidirectional `@ManyToOne` relationship with a `Customer` entity, and a `@OneToMany` relationship with a collection of `OrderItem` entities, with `Order` being the owning side of the `OrderItem` association. When retrieving a specific `Order` by its primary key using `entityManager.find(Order.class, orderId)`, the application observes a performance bottleneck due to repeated database calls when accessing the associated `Customer` information. Which of the following strategies most effectively resolves this performance issue by ensuring the `Order` and its associated `Customer` are retrieved in a single database round trip?

Accepted Answer

Apply the `@Fetch(FetchMode.JOIN)` annotation to the `@ManyToOne` association mapping between `Order` and `Customer`.

Question 11

Consider a scenario where an `Order` entity is managed by two concurrent transactions, Transaction Alpha and Transaction Beta. Both transactions fetch the same `Order` entity, which initially has a version number of 3, managed by the `@Version` annotation. Transaction Beta successfully updates the `Order` and commits, incrementing the version number to 4. Subsequently, Transaction Alpha attempts to commit its changes to the same `Order` entity. What is the most appropriate outcome and subsequent action for Transaction Alpha in this situation according to JPA best practices for optimistic concurrency control?

Accepted Answer

Transaction Alpha throws an `OptimisticLockException`, requiring the application to refresh the entity from the database and potentially re-apply its changes.

Question 12

Consider an `Order` entity that has a one-to-many relationship with an `OrderItem` entity. The relationship is defined with `FetchType.LAZY` for the `OrderItem` collection within the `Order` entity, and no explicit `CascadeType` is specified in the `@OneToMany` annotation for this collection. An `Order` entity, previously detached from the persistence context, has a new `OrderItem` instance added to its collection of `OrderItem`s. Subsequently, this detached `Order` is passed to the `EntityManager`\'s `merge()` method. What is the most accurate outcome regarding the persistence of the newly added `OrderItem`?

Accepted Answer

The new `OrderItem` will remain detached and unpersisted, as the `merge` operation on the `Order` does not cascade to new, unassociated entities without an explicit cascade setting.

Question 13

A financial services application built with Java EE 6 and JPA is experiencing significant latency when displaying a list of active client accounts. Each `ClientAccount` entity has a collection of `Transaction` entities representing the account\'s history. The current implementation retrieves all active accounts and, for each account, lazily loads its associated transactions only when the transaction details are explicitly requested. However, when a report is generated that requires displaying the total number of transactions for each active account, the application triggers an excessive number of individual `SELECT` statements for transactions, leading to a severe performance bottleneck. Which JPA approach would most effectively resolve this issue by optimizing the retrieval of `ClientAccount` entities along with their associated `Transaction` entities for the reporting requirement?

Accepted Answer

Utilize a JPQL query with a `JOIN FETCH` clause to retrieve `ClientAccount` entities and their associated `Transaction` entities in a single database operation.

Question 14

A Java EE 6 application developer is tasked with optimizing a feature that retrieves a list of `Project` entities, each associated with multiple `Task` entities. Analysis of the application\'s performance reveals a recurring N+1 select problem when accessing the `tasks` collection for each `Project`. The developer needs to implement a solution that minimizes database round trips for fetching these related `Task` entities without altering the default fetch type of the `tasks` collection from lazy to eager, and without modifying every JPQL query to explicitly use `JOIN FETCH`. Which JPA annotation, when applied to the `tasks` collection within the `Project` entity, would most effectively mitigate this performance bottleneck by fetching related entities in optimized batches?

Accepted Answer

@BatchSize

Question 15

Consider a Java EE 6 application utilizing the Java Persistence API. A `Project` entity is defined with a `LAZY` fetch type for its collection of associated `Task` entities. An `EntityManager` is used to persist a new `Project` instance. Subsequently, the `EntityManager` is explicitly closed. If the application then attempts to access the size of the `tasks` collection on the persisted `Project` instance, what is the most likely outcome?

Accepted Answer

A `LazyInitializationException` will be thrown.

Question 16

An enterprise application utilizes Java Persistence API (JPA) 2.0 for data management. A `CustomerOrder` entity has a collection of associated `OrderItem` entities, representing individual items within an order. The business requirement dictates that when a `CustomerOrder` is irrevocably deleted from the system, all its corresponding `OrderItem` records must also be automatically removed to maintain data integrity and prevent orphaned records. Considering the lifecycle management of these related entities within the JPA persistence context, which specific JPA cascade type, when applied to the `@OneToMany` relationship mapping from `CustomerOrder` to `OrderItem`, would ensure this automatic deletion of associated `OrderItem` entities upon the removal of the `CustomerOrder`?

Accepted Answer

CascadeType.REMOVE

Question 17

A Java EE 6 application utilizes JPA for data persistence. A developer is working with an entity `Project` that has a `@ElementCollection` of `String` values representing associated tags. The `Project` entity is retrieved, then detached from the `EntityManager`. Subsequently, the developer modifies the collection of tags by adding a new tag while the `Project` entity is detached. The modified `Project` entity is then passed to a service method that reattaches it to the `EntityManager` using `em.merge(detachedProject)`. Despite this, the newly added tag is not reflected in the database after the transaction commits. Which of the following JPA operations, when applied correctly in the described scenario, would most reliably ensure that changes to the detached entity\'s element collection are persisted?

Accepted Answer

Invoking `em.merge(detachedProject)` correctly synchronizes the state of the owning entity, including its element collections, with the persistence context, causing the addition of the new tag to be persisted.

Question 18

Consider a scenario where a `CustomerOrder` entity, mapped with a `@OneToMany` relationship to `OrderItem` entities, has `orphanRemoval=true` configured. If the `CustomerOrder` entity is detached from the `EntityManager`\'s persistence context, and subsequently an `OrderItem` is removed from the `CustomerOrder`\'s collection of order items, what action is necessary to ensure that the removed `OrderItem` is also deleted from the database?

Accepted Answer

Re-attach the detached `CustomerOrder` entity to an `EntityManager` and then call the `merge()` operation on the `EntityManager` with the modified `CustomerOrder` entity.

Question 19

A financial services application uses Java EE 6 with the Java Persistence API (JPA) to manage account transactions. A requirement dictates that immediately after a new transaction record is persisted to the database and its auto-generated unique transaction identifier (primary key) is assigned, a validation check must be performed to ensure the identifier adheres to a specific format pattern before any other database operations related to this transaction are finalized. Which JPA lifecycle callback method, when annotated appropriately, would be the most suitable to implement this validation logic, ensuring it executes after the primary key generation but before the transaction is fully committed and other dependent operations might implicitly occur?

Accepted Answer

A method annotated with `@PostPersist`

Question 20

A Java EE 6 application uses JPA to manage `Customer` entities. A `Customer` object, initially retrieved and managed by an `EntityManager` instance `em1`, is subsequently passed to a remote service. This remote service modifies the `Customer` object\'s address but does not have an active persistence context. Later, in a different transaction managed by a *new* `EntityManager` instance `em2`, the application attempts to persist these modifications. Which operation on `em2` will correctly associate the modified `Customer` object with the new persistence context and ensure its updated state is persisted?

Accepted Answer

`em2.merge(detachedCustomer)`

Question 21

A Java EE 6 application using JPA to manage customer orders is exhibiting significant performance issues. During a single transaction processing multiple orders with a \'PROCESSING\' status, the application frequently executes numerous individual `SELECT` statements to retrieve the `OrderItem` collection for each `Order` entity. This behavior occurs even when the `OrderItem` collection is annotated with `@OneToMany(fetch = FetchType.LAZY)`. The application\'s performance monitoring indicates that this pattern is a primary contributor to transaction latency. What is the most effective strategy to optimize data retrieval and reduce the number of database queries in this scenario?

Accepted Answer

Modify the `@OneToMany` annotation on the `OrderItem` collection to `FetchType.EAGER` to ensure all order items are loaded with each order.

Question 22

Consider a scenario where two independent transactions, initiated by distinct client requests, attempt to modify the same `Product` entity in a database managed by a Java EE 6 application utilizing the Java Persistence API. Both transactions initially fetch the `Product` entity, which has a `@Version` annotation on its `version` field, with an initial value of 1. Transaction Alpha successfully updates and commits its changes, causing the `version` field in the database to be incremented to 2. Immediately following Alpha\'s commit, Transaction Beta attempts to merge its modified `Product` entity, which still carries the original version value of 1. What specific exception will the JPA persistence provider most likely throw upon Beta\'s merge operation, and why?

Accepted Answer

`OptimisticLockException` because the version number in the database (2) does not match the version number of the entity being merged (1).

Question 23

Consider a scenario in a Java EE 6 application where a `Customer` entity, which has a lazily loaded collection of `Order` entities (`@OneToMany(fetch = FetchType.LAZY)`), is retrieved within a transaction. Subsequently, this `Customer` entity is passed to a service method operating outside the original transaction\'s scope. During the execution of this second service method, an attempt to access the `customer.getOrders()` collection results in a `LazyInitializationException`. What is the most appropriate and robust strategy to prevent this exception while preserving the lazy loading behavior for other use cases?

Accepted Answer

Within the initial transaction, explicitly initialize the `customer.getOrders()` collection before the `Customer` entity is detached from the persistence context.

Question 24

Consider a scenario where a Java EE 6 application, leveraging the Java Persistence API, retrieves a `Project` entity that has an `@OneToMany` relationship to a collection of `Task` entities. The `Project` entity\'s `tasks` field is declared as `private List tasks;`. Upon retrieving a `Project` instance via a `TypedQuery` and subsequently calling `project.getTasks().isEmpty()`, a `NullPointerException` is thrown. The `Project` entity itself was successfully retrieved from the database, and the `project` variable is not null. Which of the following is the most probable underlying cause for this `NullPointerException` in the context of JPA entity lifecycle and relationship management?

Accepted Answer

The `tasks` collection field within the `Project` entity was not initialized by the persistence provider, leading to a null reference when accessed.

Question 25

Consider a scenario where a Java Persistence API (JPA) entity, `ProductInventory`, is configured with optimistic locking using a version field. Two concurrent transactions, initiated by distinct application threads, attempt to update the same `ProductInventory` record. Transaction Alpha reads the `ProductInventory` record, which has a current version number of 1. Before Transaction Alpha can commit, Transaction Beta reads the same record, updates its quantity, increments the version number to 2, and successfully commits. Subsequently, Transaction Alpha attempts to commit its changes, which also involve updating the quantity. What is the most likely outcome for Transaction Alpha upon attempting its commit?

Accepted Answer

An `OptimisticLockException` is thrown, preventing Transaction Alpha from committing its changes until the version mismatch is resolved.

Question 26

A financial reporting application built on Java EE 6 utilizes JPA to manage `Account` entities, where each `Account` can have multiple `Transaction` entities associated with it via a `@OneToMany` relationship. During peak usage, the application retrieves lists of 500 `Account` records and displays summary transaction data for each. Performance monitoring reveals a significant number of individual SQL `SELECT` statements being executed, one for the initial account retrieval and then one for each account\'s transactions, leading to database contention. Which of the following JPA 2.0 (Java EE 6) strategies would most effectively address this \"N+1 select\" problem without introducing substantial architectural changes?

Accepted Answer

Modify the `@OneToMany` relationship in the `Account` entity to use `FetchType.JOIN` or apply `@BatchSize` to the collection.

Question 27

Consider an application using Java EE 6 and JPA, where the `Product` entity has a `@OneToMany(mappedBy = \"product\", cascade = CascadeType.PERSIST, orphanRemoval = true)` relationship to `Category`, and a `@ManyToMany(cascade = CascadeType.ALL, orphanRemoval = true)` relationship to `Tag`. If a `Product` is persisted with new `Category` and `Tag` instances, and then a `Tag` is removed from the `Product`\'s collection of `Tag`s, what will be the net effect on the database entities?

Accepted Answer

The Product and Category are persisted, and the Tag is deleted.

Question 28

Consider a Java EE 6 application utilizing the Java Persistence API. A `ProjectResource` entity, identified by `resourceId = 123`, is initially retrieved in a transaction, resulting in a detached entity. The `EntityManager` from the initial transaction is then closed. Subsequently, in a new transaction, the application obtains a new `EntityManager`. The detached `projectResource` entity has its `allocatedHours` property updated from 25 to 50. This modified detached entity is then passed to `entityManager.merge(projectResource)`. Following this, `entityManager.flush()` is called. Immediately after the flush, `entityManager.remove(projectResource)` is invoked. Upon transaction commit, what is the most accurate outcome regarding the `ProjectResource` record with `resourceId = 123` in the database?

Accepted Answer

The `ProjectResource` record with `resourceId = 123` will be deleted from the database.

Question 29

An enterprise Java application utilizes JPA for data persistence. The `ProjectAssignment` entity has a `@ManyToOne` relationship with the `Employee` entity, where multiple `ProjectAssignment` records can be linked to a single `Employee`. The `Employee` entity, in turn, is intended to have a collection of associated `ProjectAssignment` records, represented by a `@OneToMany` relationship. During the development of the `Employee` entity, the `@OneToMany` annotation was applied to the `projectAssignments` collection, but the `mappedBy` attribute was omitted. The `ProjectAssignment` entity correctly specifies the owning side of the relationship by having the `@ManyToOne` annotation on its `employee` field. Considering the JPA specification for bidirectional relationships and the potential consequences of an unmanaged inverse side, what is the most robust approach to rectify this mapping to ensure correct synchronization and prevent potential data integrity issues?

Accepted Answer

Add `mappedBy="employee"` to the `@OneToMany` annotation in the `Employee` entity.

Question 30

Consider an enterprise application utilizing Java EE 6 and the Java Persistence API (JPA). A `CustomerOrder` entity has a bidirectional `@OneToMany` relationship with an `OrderItem` entity, where `OrderItem` has a `@ManyToOne` back-reference. The `@OneToMany` mapping on `CustomerOrder` is defined with `cascade = CascadeType.PERSIST` and `orphanRemoval = true`. If a developer removes an `OrderItem` instance from the `CustomerOrder`\'s associated collection and then flushes the `EntityManager`, what is the most likely outcome when attempting to retrieve that specific `OrderItem` instance from the database using a subsequent query?

Accepted Answer

A `NoResultException` will be thrown because the `OrderItem` has been automatically deleted from the database due to the `orphanRemoval` setting.

1z0898 Java EE 6 Java Persistence API Developer Certified Expert Exam Free Practice Test — 30 Questions

A lot more is already mapped out

About the 1z0898 Java EE 6 Java Persistence API Developer Certified Expert Exam Certification