Working with Java Persistence API (JPA) Mappings

With BEA Workshop Studio ORM Workbench you can create a persistence layer that uses the Enterprise JavaBeans (EJB) 3.0 standard Java Persistence API (JPA). The ORM Workbench includes tools to generate entities, while Workshop Studio includes two provider implementations of persistence tools: BEA Kodo (JPA) and an implementation that is part of the open source Hibernate project. You can use either of these or supply your own provider.

This documentation describes how to use the ORM Workbench to generate and edit JPA persistence entities.

Using JPA in Workshop Studio

In EJB version 3.0, the role of entity beans is played by JPA persistence entities. These persistence entities differ quite a bit from previous entity beans in ways designed to simplify the programming model, and the ORM Workbench toolset in Workshop Studio is designed to help you make the most of these changes. Key features of the JPA specification include:

• Support for a Plain Old Java Object (POJO) programming model. For example, it's no longer necessary for entities to implement component and home EJB interfaces.
• Use of Java annotations for metadata, including information on how the entity should be mapped to the data source.
• Beans do not require an EJB container.
• Use of a persistence.xml file as a deployment descriptor. This file includes information for connecting to the persistence data source, setting persistence provider-specific properties, listing the entity beans to use, and so on.
• An updated EJB Query Language (EJBQL).

Support for JPA Tasks

The Workshop Studio ORM Workbench includes tools that greatly ease the tasks associated with creating a persistence layer using EJB 3.0. These tasks include:

• Examining and updating the data source that the persistence layer will use.

  You can view and change the source for persisted data — such as a relational database — using tools such as the DbXplorer and DbXaminer. For more information, see Exploring Databases with the DbXplorer.

• Annotating Java entity sources with Java 5 annotations that describe how the entities and their properties map to the data source schema.

  You can generate new entity sources or annotate existing classes. See Generating JPA Mappings for more information.

• Editing entity mappings for fine tuning.

  With entities in your project, you can edit their relationships using the Entities Editor. See Managing EJB3 Entities with the Entities Editor for more information.

• Creating and editing a persistence.xml file that lists information about the entity beans, the data source for persisted data, and the JPA provider.

  Workshop Studio provides an editing interface for the persistence.xml file. See Configuring JPA Properties for more information.

• Writing query expressions to retrieve and update entity data. You can use either SQL or EJBQL.

  You can use the DbXaminer to create and edit query expressions, ensuring that they achieve results you want before using them in code. For more information, see Viewing Database Diagrams and Running Queries.

High-Level Steps to Creating a JPA Persistence Layer

Starting out with a web application project, you can create a persistence layer with Workshop Studio using the following high-level steps:

1. Create a web application project that support JPA, or add persistence support to an existing web application project.
2. Add a connection to the database that the persistence layer will be using.
3. Developing entities and mapping relationships depending on what you're starting out with:
   • If you're starting with a database and no entity source code:

     Generate entity source code from the database schema.

   • If you're starting with a database and non-entity Java sources:

     Annotate your Java source files so that they are mapped to the database.

   • If you're starting with a database and existing entity source code:

     Add your existing entity source code to the project, add a connection to the database, then use the Entities Editor to map entities to the database schema.

4. Edit mappings as needed using the Entities Editor.
5. Develop queries as needed using the DbXplorer.
6. Use the resulting entities in application logic.

Adding JPA Support

Generating JPA Mappings

Managing EJB3 Entity Relationships