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
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.
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.
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.
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.
Select the One-to-One radio option to specify one customer per customerid.
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.
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.
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.
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.
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.
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(
);
}
Save the Contact class. Now, we have the object representation
for CONTACT persistence data. Next, we will annotate the Contact
object.
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.
Click the Browse button for Java Class and select the
com.bea.beans.Contact object to be mapped.
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.
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.
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.
Click Finish.
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.
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: