Retired - Red Hat Certified Specialist in Persistence exam


Exam description

Note: This exam and credential are no longer available.

The Red Hat Certified Specialist in Persistence exam tests whether candidates are ready for the real-world responsibilities of creating and maintaining Java™ applications that use the Java Persistence API (JPA) with JBoss® Hibernate®.

The Red Hat Certified Specialist in Persistence exam credential demonstrates an individual's readiness for the real-world tasks associated with using the Java™ Persistence API (JPA) with JBoss Hibernate. The JPA is a Java programming language framework for managing relational data, and Hibernate is a high-performance object-relational persistence and query service that implements the JPA.

Familiarize yourself with the tools, environment, and requirements of a Red Hat JBoss Certified Developer exam.

Audience for this exam

The Red Hat Certified Specialist in Persistence is designed for:

  • Experienced Java application developers and architects.
  • Business component and database developers.

Prerequisites for this exam

  • Have familiarity working in a Red Hat Enterprise Linux environment
  • Review the Red Hat Certified Specialist in Persistence exam (EX297) objectives

Red Hat recommends that candidates for this exam earn Red Hat Certified JBoss Developer (RHCJD) before attempting this exam, but it is not required.


Study points for the exam

To help you prepare, the exam objectives highlight the task areas you can expect to see covered in the exam. Red Hat reserves the right to add, modify, and remove exam objectives. Such changes will be made public in advance.

Exam tasks

Red Hat Certified Specialist in Persistence Exam candidates should be able to perform the following tasks using JPA with Hibernate. To aid your study, we've also included a list of recommended reference sources for these activities.

Map a single table or object
  • Understand the behavior of the id generators, including how and when the value is generated
  • Understand how to map a primary key, including:
    • Using generated keys
    • Mapping simple business keys
    • Mapping compound keys
  • Understand object identity and business equivalence
  • Configure database-specific information, such as table name, column name, column width, and
    column attributes (nullable, unique, type, and so on)
  • Convert an existing Java object into a persistent object using JPA/Hibernate
  • Map basic JPA data types to corresponding database types
  • Given an existing database table, create a new persistent Java object to map that table
  • Understand how and when to use lazy versus eager loading
  • Understand and use optimal mapping strategies for collections and value types
  • Handle Java/object model-specific properties and behaviors in a persistent object. This includes:
    • Serialization
    • Transient properties
    • Generated and calculated properties
    • Immutable properties
    • Value types
    • Co-dependent properties (i.e. where a property's valid values depend on the value of another
Map object relationships with JPA/Hibernate
  • Understand how to map relationships, including but not limited to:
    • Value relationships (for example, has-a details object)
    • Parent/child relationships
    • One-to-one relationships (both unidirectional and bidirectional)
    • Many-to-one and one-to-many relationships (both unidirectional and bidirectional)
    • Many-to-many relationships (both unidirectional and bidirectional)
  • Understand default mapping behaviors, including but not limited to:
    • Foreign key names
    • Association table names
  • Understand the use of foreign keys and join tables when creating relationships
  • Understand how to map a compound primary key based on the relationship
  • Understand JPA/Hibernate collections (sets, maps lists, and bags) and how they map to object and
    table relationships
  • Understand the performance impacts of the different collections
  • Understand how and when to use lazy versus eager loading, including the performance and code
    impacts of both
  • Given a set of existing tables and relationships, create a persistent Java object graph matching
    the database
  • Map an existing object model, including various associations, to a persistence store
  • Determine optimal loading strategies for a given business process
Map hierarchical object relationships with JPA/Hibernate
  • Understand how to represent different object hierarchies using JPA/Hibernate
  • Convert an existing Java object hierarchy to persistent objects using JPA/Hibernate
  • Represent an existing set of table relationships as an object hierarchy (for example, savings
    account, credit card, and loan account)
  • Understand polymorphic queries and associations
  • Understand the benefits and limitations of the different inheritance strategies
  • Analyze and determine optimal database representations for different object hierarchies
Understand transactional behavior (ACID)
  • Acquire and use a transaction context under:
    • Java EE/CMT
    • Java EE/BMT
    • Java SE using JPA APIs
  • Understand how the persistence context is bound to the transaction in Java EE
  • Understand transactional context propagation with EJB3
  • Understand the consequences of a transaction rollback at the persistence context level
  • Understand transactional concurrency risks
  • Evaluate data loss/corruption versus performance trade-offs
Retrieve persistent objects
  • Understand JPA/Hiibernate loading strategies:
    • Lazy loading
    • Subselect loading
    • Batch loading
  • Understand and use advanced query options:
    • HQL/JPA QL
    • Criteria APIs
    • Native queries (SQL)
  • Use the runtime eager fetching feature
  • Use named parameters
  • Anticipate and avoid LazyInitializationException
  • Analyze and improve JPA/Hibernate performance
  • Understand and use JPA optimistic locking and Hibernate pessimistic locking extended features
Manipulating persistent objects
  • Understand entity states, such as:
    • transient
    • persistent
    • attached
    • detached
    • removed
  • Understand how to change the state of an entity/entity graph using JPA APIs
  • Understand the lifecycle of the persistence context and its impact on the entities being managed
  • Apply JPA/Hibernate batching features:
    • API usage patterns
    • DML queries
  • Determine and apply optimal implementation and cascade settings to manipulate an object graph
  • Evaluate when to use batching

What you need to know

Documentation and training

Access to documentation during the exam will be limited to the official JBoss Enterprise Application Platform documentation for the version being tested plus any sample files or additional documentation included with the product. We will not strip anything out that is normally included.

Please note that you will not have access to the jboss.org or hibernate.org wikis. While these wikis are useful resources and include content that may be relevant to the exam, the wiki format makes it inappropriate for access during an exam. We want to test you, not the people reading and updating the wiki.

You will not be permitted to bring any hard-copy or electronic documentation into the exam. This prohibition includes notes, books, or any other materials. Internet access will be strictly controlled. Keep these restrictions in mind as you study.


You will be working on a Red Hat® Enterprise Linux® 5.4 system during the exam, so prior experience using Linux or UNIX will be helpful. Extensive Linux experience is, however, not required, as the purpose of this exam is to test your JPA with Hibernate skills, not your operating system-specific skills. You will have a full desktop environment in which to work, and we will provide a list of basic commands for your reference in addition to the man pages and other documentation that come with Red Hat Enterprise Linux.

Fedora provides a freely available alternative for you to practice your Linux skills. A Live CD version is available, which allows you to work on Fedora without needing to install it on your computer. While it's not an exact match for the environment in Red Hat Enterprise Linux, it's close enough for the level of familiarity required.

Exam format

The Red Hat Certified Specialist in Persistence exam is 100% performance-based—candidates demonstrate their knowledge and skills by doing tasks rather than regurgitating facts. Most IT certification exams ask a series of questions for which you will choose A, B, C, or D, or the ever-unpopular Choose all that apply. You won't see questions like that on the Red Hat Certified Specialist in Persistence exam. In fact, you won't see any questions at all. Instead, you're given a real environment in which you'll perform a list of real-world tasks. For example, we might ask you to create and maintain a persistent association rather than asking a series of questions about the JPA mapping annotations. Consequently, candidates are advised to view any online brain dumps and the like with skepticism. The single best source of information about what's in this exam is this document.

The Red Hat Certified Specialist in Persistence exam is 4 timed hours. Some time is required in advance of the start time to check identification and gather information.

Exam environment

Development tools

In addition to the desktop environment, we will provide an installed and configured copy of JBoss Developer Studio 3 (JBDS). The exam is not a JBDS exam and you are not expected to know or use JBDS to complete the exam tasks. However, JBDS is an excellent tool for developing and maintaining JPA/Hibernate applications, and some JBDS experience and skills will certainly be helpful in the exam. If you do not have access to a supported copy of JBDS, you can download a free version. If you are not already registered with Red Hat, you will need to create a free Red Hat account. If you do not want to sign up with Red Hat for the free download, a standard Eclipse distribution with the JBoss Tools 4 plug-in will be adequate for practicing for the exam.

The projects in the exam have been created with Maven. If you do not want to use JBDS, you can use a standard text editor (such as gedit or vi), the command line, and Maven. Note that the exam is a closed environment and that Maven is running in offline mode. You cannot use any Maven repositories or plug-ins that have not already been imported into the local environment.

Working directory

When you start the exam, the default JBDS workspace will contain 1 or more project directories which must be used for the exam. You do not have to use JBDS for your development, but you must use the default workspace directory and the provided project directories for all tasks. We repeat: All code and resources must be developed in, and consistent with, the structure of the provided directories.

Coding standards

This is a practical, hands-on exam, and you must write code in order to complete the tasks. Different companies have different coding standards and, like any real-world environment, you will be expected to follow the local coding standards. Listed below is some information on the exam coding standards that may help you in your preparations. This information is also provided during the exam. For the purposes of the exam, it will be easiest if you imagine that you are a newly hired JPA/Hibernate developer who has been called in to complete a project. Unfortunately, the original developer has had to drop the project part of the way through and is no longer available. You need to pick up where the prior developer left the code and complete as much of it as you can in the time available.

The code is reasonably well documented and there are many TODOs throughout the code to give you an indication of what needs to be done. Please note, however, that the Javadoc and TODOs are not sufficient; you need to read the task descriptions and understand what is required before acting on a TODO. If you feel that there is a conflict between the task text, the UML/PDM diagrams, and the Javadoc/TODO, always do what the task description says.

The following are some key points to keep in mind when you are working:

  • Code format is not important. Whether you use tabs or spaces and how you place your curly brackets will not impact how your work is evaluated.
  • You may map your classes using XML files, field annotations, or property annotations; it does not matter which you use. The existing code uses a small number of field-level annotations, but you can easily change to your preferred style of mapping.
  • Many of the classes are unusually organized; fields and related methods are grouped together. This is very unusual and is not a recommended practice. It is done to make it easier for you to work on a single item without having to search back and forth through the code for the fields and related methods. Feel free to sort the class members if you would rather use a more normal code structure. Hint: In JBDS, the blue TODO marker blobs on the right of the editor window and the property list in the Outline view are both helpful for quickly navigating these classes.
  • Unlike the real world, comments and exception messages are not important. The exam is machine-marked so comments and messages are completely ignored.
  • Code quality and best practices are important. You should use best practices at all times and assume that poor or inefficient practices will be marked down. For example, it is considered a Java best practice never to expose publicly field members and, therefore, you should always use standard JavaBeans getters and setters for your object properties.
  • The project in the exam scenario has been designed together with other applications in other departments. Unless explicitly instructed by a task description or a TODO in the code, you must not change the signature of any existing method. The only exception to this rule is that you can, and should, make the signature more specific (that is, use a subclass and/or specific generic) if that is appropriate. For example, you should replace Collection{cke_protected}{C}%3C!%2D%2D%3F%2D%2D%3E with List where that makes sense.
  • You may add fields, properties, and methods as required.
  • Since the project is focused on the persistent entities and you have no input into the controller/service layer, you are expected to code the persistent entities defensively. That is, your entity methods should try to prevent the business logic from destroying object consistency. For example, a setter for a not nullable property should throw a NullPointerException if passed a null value.
  • Unless otherwise stated, all entities must use database primary keys that are automatically generated by the persistence engine.
  • If a method needs to throw an exception because of some internal problem, always use a RuntimeException; do not create a business-specific exception. For example, you could use IllegalArgumentException if the problem is an invalid argument to a method. You could use IllegalStateException if the problem is an inconsistency in the state of the object model or persistence store. And, of course, you can always use NullPointerException when that is appropriate. Unless explicitly told to do so, do not use the JPA transitive persistence features to propagate changes automatically to associated entities in an object graph. Our experience shows that many business-level developers get confused by this feature and it can cause severe performance and reliability issues when used inappropriately. A final warning: We cannot evaluate your work if it does not compile or fails to run properly. In particular, a broken persistent association can cause all persistence actions to fail. It is better to comment out a difficult association than to risk it interfering with other, working associations. The test projects include a good selection of JUnit tests and we recommend that you run the whole suite of tests after completing a task. Please note, however, that the included JUnit tests are not the exam and having your code pass the tests does not necessarily mean that your work will earn full marks.

Scores and reporting

Official scores for exams come exclusively from Red Hat Certification Central. Red Hat does not authorize examiners or training partners to report results to candidates directly. Scores on the exam are usually reported within 3 U.S. business days.

Exam results are reported as section scores. Red Hat does not report performance on individual items, nor will it provide additional information upon request.