All entity beans must have a primary key to ensure that they can be persisted to the database. An entity is a lightweight persistence capable domain object, and the primary key is the reference to locating the row in the database table of the underlying database.

JPA is not designed for entities that do not have any representation of a primary key. For such functional requirements then, you probably have to think about a specific document database solution outside of the Java EE 7 standard.

The first way maps a POJO with a separate class that contains a set of primitive fields, and the getter and setter methods. The annotation @javax.persistence.IdClass specifies a composite primary key class on the target entity.

A class designated as a separate identity composite key must follow these rules:

The consumer rewritten to support a composite primary key class is as follows:

@Entity
@IdClass(Contact2PK.class)
public class ContactConsumer2 implements Serializable {
  @Id
  private long contactId;
  
  @Id
  @Column(name = "FIRST_NAME", nullable = false)
  private String firstname;
  
  @Id
  @Column(name = "LAST_NAME", nullable = false)
  private String lastname;
  
  // Constructors omitted
  
  public long getContactId() {return contactId;}
  public void setContactId(long contactId) {
    this.contactId = contactId;
    }
  
  public String getFirstname() {return firstname;}
  public void setFirstname(String firstname) {
    this.firstname = firstname;
    }
  
  public String getLastname() {return lastname;}
  public void setLastname(String lastname) {
    this.lastname = lastname;
    }
  
  // toString() method omitted
  }

In the class ContactConsumer1, there are three fields that constitute the composite primary key: contactId, firstname, and lastname. Entity uses the field annotations with @Id. The class is annotated @IdClass, which takes the single argument, the reference to the composite key class.

The composite key classContact2PK is as follows:

package je7hb.basic2.jpa;
import java.io.Serializable;

public class Contact2PK implements Serializable {
  private long contactId;
  private String firstname;
  private String lastname;
  
  public long getContactId() {return contactId;}
  public void setContactId(long contactId) {
    this.contactId = contactId;
    }
  
  public String getFirstname() {return firstname;}
  public void setFirstname(String firstname) {
    this.firstname = firstname;
    }
  
  public String getLastname() {return lastname;}
  public void setLastname(String lastname) {
    this.lastname = lastname;
    }
  
  // hashCode(), equals() method omitted
  // toString() method omitted
  }

Notice how, in the composite key class, the names and types of the fields as well as the property accessor match the same in the entity bean.

The hashCode() and equals() methods are omitted in the example, but they can be generated by any of the popular IDEs.

How are composite primary key classes used? The answer is that we can use the EntityManager.find() method, which takes two arguments: the class of the entity that will be returned, and an instance of the composite key class.

An extract of a unit test method that illustrates the use case is as follows:

@PersistenctContext EntityManager em;

public void shouldRetrieveByCompositeKey() {
  ContactConsumer2 consumer = new ContactConsumer2(100, "Annabel", "Smith")
  em.persist(consumer)
  
  ContactConsumer2 consumerCopy = em.find(ContactConsumer2.class, new Contact2PK(consumer.getContactId(), consumer.getFirstname(), consumer.getLastname()));
  assertEquals(consumer, consumerCopy)
  }

We create an entity bean, then we save it to the database using the entity manager. We search for the entity using a composite primary key instance. Finally, we check if the two entities are the same.

This second way of creating the composite primary keys relies on the embedded object instances into the entity bean. In this way, the fields and properties are delegated to the separate primary key object class. In order to delegate the primary key to a delegate class instance, use the annotation @javax.persistence.Embeddable.

A class that is designated as embeddable must follow these rules:

The contact primary key record is transformed into an embeddable entity as follows:

@Embeddable
public class Contact3PK implements Serializable {
  private long contactId;
  @Column(name = "FIRSTNAME")
  private String firstname;
  @Column(name = "LASTNAME")
  private String lastname;
  
  public long getContactId() {return contactId;}
  public void setContactId(long contactId) {
    this.contactId = contactId;
    }
  
  public String getFirstname() {return firstname;}
  public void setFirstname(String firstname) {
    this.firstname = firstname;
    }
  
  public String getLastname() {return lastname;}
  public void setLastname(String lastname) {
    this.lastname = lastname;
    }
  
  public Contact3PK() {
    this(0,null,null);
    }
  
  public Contact3PK(long contactId, String firstname, String lastname) {
    this.contactId = contactId;
    this.firstname = firstname;
    this.lastname = lastname;
    }
  
  // A copy constructor
  public Contact3PK(Contact3PK ref) {
    this.contactId = ref.contactId;
    this.firstname = ref.firstname;
    this.lastname = ref.lastname;
    }
  
  // equals() and hashCode() methods omitted
  // toString() method omitted
  }

We first annotate the Contact3PK class with @Embeddable, which denotes to the JPA provider that this class is embeddable, a composite primary key instance.

It has exactly the same primary key columns as fields: contactId, firstname, and lastname. We have also placed the @Column metadata into the class now. We do not have to place the @Id annotations on this type, because we made the class embeddable, and therefore this information is now implied.

Finally, embeddable must have correct and valid hashCode() and equals() methods in order for persistence to function successfully.

To conclude, we added a copy constructor to this composite key class, to make it easier for other developers to create copies of this entity in a test and production development work.

In order to make use of the embeddable class in an entity, the enclosing entity simply declares a reference field or the accessor property of the embeddable class, and annotates it with @javax.persistence.EmbeddedId.

The contact consumer class is refactored to make use of the embeddable entity instance as follows:

packageje7hb.basic2.jpa;
import javax.persistence.*;
import java.io.Serializable;

@Entity
public class ContactConsumer3 implements Serializable {
  @EmbeddedId
  private Contact3PK contact;
  private String location;
  
  public ContactConsumer3() {
    this( new Contact3PK(), null);
    }
  
  public ContactConsumer3(Contact3PK contact, String location) {
    this.contact = contact;
    this.location = location;
    }
  
  public Contact3PK getContact() {return contact;}
  public void setContact(Contact3PK contact) {
    this.contact = contact;
    }
  
  public String getLocation() {return location;}
  public void setLocation(String location) {
    this.location = location;
    }
  
  // equals() and hashCode() methods omitted
  // toString() method omitted
  }

The entity bean, ContactConsumer3, no longer defines separate primary key metadata. Instead, it delegates to Contact3PK, the embeddable entity with the annotation @EmbeddedId. Every annotation of @EmbeddedId must reference a class that is marked up with @Embeddable (or the corresponding ORM XML syntax).

We also threw in the additional field location to demonstrate that the entity bean can also still define additional columns of its own.

An extract of a unit test to demonstrate the principle of the embeddable entity objects is as follows:

@PersistenctContext EntityManager em;

public void shouldRetrieveByEmbeddableKey() {
  ContactConsumer consumer = new ContactConsumer3(new Contact3PK(200, "Benjamin", "Ferguson"), "Glasgow"));
  em.persist(consumer)
  
  ContactConsumer3 consumerCopy = em.find(ContactConsumer3.class, new Contact3PK(consumer.getContact()));
  assertEquals(consumer, consumerCopy)
  }

We construct the embeddable Contact3PK entity bean before we construct the entity bean ContactConsumer3. We save it to the database using the entity manager. Next, we retrieve the same entity that was just saved with a new copy of the composite key object. This is exactly where a copy constructor is useful.