3. Create and Manage Entities

Time to complete this step: 30 minutes

Modify and manage existing OR Mappings and test with EJBQL

The JPA ORM Generation wizard allows modification of existing OR mappings and the creation of new entity associations.

Create a new One-to-One Association between CUSTOMER and CUSTOMERID

1. Workshop also supports the creation of new entity associations in case your database lacks foreign key definitions (such as for performance reasons). It can create Simple Associations (one to one, one to many, many to one) between two tables and Many to Many Associations through an intermediate table.
2. Right-click in the DbXplorer > Generate JPA Mapping. Select workshop-jpa-tutorial as JPA web application and click Ok. Select all the Database tables except CONTACT and click Next. Click the Create New Association option and specify the properties of the new association.

   

3. We want to define a Simple one-to-one association between CUSTOMER and CUSTOMERID tables. In Create New Association dialog, select the CUSTOMER and CUSTOMERID tables as shown below and click Next.

   

4. Select the CUSTOMERID column for the CUSTOMER table and the CUSTOMERID column for the CUSTOMERID table to specify join columns between tables and click Next.

   

5. Select the One-to-One radio option to specify one customer per customerid.

   

6. Click Finish. Since the new associations (shown in yellow) are not observed in the database schema, they will be annotated programmatically in the respective entity beans.

   
   

7. Click Finish in the JPA ORM Generation dialog.

Review generated classes with annotations

Review the following annotations in the class Customer and CustomerId.

• One-to-One Properties - A one-to-one property designates a relationship in which an entity A references a single entity B, and no other A's can reference the same B. This is a one-to-one relation between A and B.
• The following shows the one-to-one mapping association between Customer and CustomerId in the Customer class.

@OneToOne(fetch=FetchType.EAGER) @JoinColumn(name="CUSTOMERID", referencedColumnName="CUSTOMERID", nullable=false, insertable=false, updatable=false) public Customerid getCustomeridBean() { return this.customeridBean; } public void setCustomeridBean(Customerid customeridBean) { this.customeridBean = customeridBean; }

• The following shows the one-to-one mapping association between CustomerId and Customer in the CustomerId class.

@OneToOne(mappedBy="customeridBean", fetch=FetchType.EAGER) public Customer getCustomer() { return this.customer; } public void setCustomer(Customer customer) { this.customer = customer; }

• Note : The annotation attributes for one-to-one mapping are similar to one-to-many and many-to-one annotation attributes as explained before in step 2: Review Generated Classes with Annotations.

Add annotations to an existing Java class

In this step, you will create a Java class Contact and use Workshop to annotate existing Java classes (POJOs) to make them into JPA entity beans. This way, we will follow the Top-Down development scenario.

1. Under the package com.bea.beans, create a Java class Contact which implements the java.io.Serializable interface. Select Constructors from superclass to add a no argument constructor.

   

2. Add the following set of private variables of type String to the Contact class. Note: we are defining properties that map to columns in the CONTACT database table.

   private String contactId; private String address; private String city; private String phone;

3. Add getter and setter methods for each property.
4. Override the equals( ) and hashCode( ) methods as we are going to use Contact instances in Set.

   public boolean equals(Object other) {   if ( (this == other ) ) return true;   if ( !(other instanceof Contact) ) return false;   Contact castOther = (Contact) other;   if( this.getContactId( ).equals(castOther.getContactId( )) ) {     return true;   } else {     return false;   } } public int hashCode() {    return this.getContactId( ).hashCode( ); }

5. Save the Contact class. Now, we have the object representation for CONTACT persistence data. Next, we will annotate the Contact object.
6. In the AppXplorer view, right click on the project workshop-jpa-tutorial. Choose New > Other. Expand Java Persistence API(JPA) and select Annotate Java Class, then click Next.

   

7. Click the Browse button for Java Class and select the com.bea.beans.Contact object to be mapped.

   

8. In the Entity Access dropdown list, if you choose property, Workshop Studio will annotate your class's accessors; if you choose field, it will annotate your class's fields. Choose property and click Next.

   

9. In the Class Mapping Properties dialog, browse and select the CONTACT table as the mapping database table and select the Java property contactId as the primary key property. Click Next.

   

10. Under Bean Properties Mapping, verify or edit mappings between database columns and fields of the Java class Contact that are being annotated. Note that you can click the Edit button to display the Basic Property Tag dialog for editing a selected property mapping. At present we do not need to change any mapping information.
    
    

11. Click Finish.
12. Open the annotated class Contact to add a bi-directional many-to-one mapping association with Customer.
    • Import the following javax.persistence classes for adding a new many-to-one column join.

      import javax.persistence.JoinColumn; import javax.persistence.ManyToOne;

    • Add a property customer of type Customer.

      private Customer customer;

    • Add the following annotation to the Contact entity for adding a many-to-one association with Customer. The @JoinColumn annotation defines the attributes Column Name which is the name of the column to which the property is bound and the Referenced column which is the name of the primary key column being joined to.

      @ManyToOne() @JoinColumn(name="CUSTOMERID", referencedColumnName="CUSTOMERID") public Customer getCustomer() { return this.customer; } public void setCustomer(Customer customer) { this.customer = customer; }

    • Save the class Contact.
    
    Note : For the above many-to-one customer property in the Contact entity there should be a one-to-many contact property in the Customer entity.

• Open class Customer.
• Add a property contacts of type java.util.Set

  private java.util.Set<Contact> contacts;

• Add the following annotation to the Customer entity for adding a one-to-many association with Contact. The @OnetoMany annotation defines the attribute MappedBy which is the name of the many-to-one field in the Contact entity that maps this bidirectional relation.

  @OneToMany(mappedBy="customer") public java.util.Set<Contact> getContacts() { return this.contacts; } public void setContacts(java.util.Set<Contact> contacts) { this.contacts = contacts; }

• Save the class Customer.

Run EJBQL to ensure that the new mappings are correct and function properly at runtime

In this step we have created a new association between Customer and CustomerId Entities using the JPA ORM Mapping tool. Also we have annotated an existing Java class Contact to make it into a JPA entity bean. Use the EJBQL editor to test the runtime behaviors.

• Test the bi-directional one-to-one mapping between Customer and CustomerId. Execute the following query in the EJBQL Editor.

• Test the bi-directional one-to-one mapping between CustomerId and Customer. Execute the following query in the EJBQL Editor.

• Test bi-directional many-to-one mapping betweenContact and Customer. Execute the following query in the EJBQL Editor.

Click one of the following arrows to navigate through the tutorial: