Composite Primary Keys in JPA

Azure Container Apps is a fully managed serverless container service that enables you to build and deploy modern, cloud-native Java applications and microservices at scale. It offers a simplified developer experience while providing the flexibility and portability of containers.

Of course, Azure Container Apps has really solid support for our ecosystem, from a number of build options, managed Java components, native metrics, dynamic logger, and quite a bit more.

To learn more about Java features on Azure Container Apps, visit the documentation page.

You can also ask questions and leave feedback on the Azure Container Apps GitHub page.

Of course, Azure Container Apps has really solid support for our ecosystem, from a number of build options, managed Java components, native metrics, dynamic logger, and quite a bit more.

To learn more about Java features on Azure Container Apps, you can get started over on the documentation page.

And, you can also ask questions and leave feedback on the Azure Container Apps GitHub page.

Modern software architecture is often broken. Slow delivery leads to missed opportunities, innovation is stalled due to architectural complexities, and engineering resources are exceedingly expensive.

Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.

With Orkes Conductor managed through Orkes Cloud, developers can focus on building mission critical applications without worrying about infrastructure maintenance to meet goals and, simply put, taking new products live faster and reducing total cost of ownership.

Try a 14-Day Free Trial of Orkes Conductor today.

Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.

Try a 14-Day Free Trial of Orkes Conductor today.

End-to-end testing is a very useful method to make sure that your application works as intended. This highlights issues in the overall functionality of the software, that the unit and integration test stages may miss.

Playwright is an easy-to-use, but powerful tool that automates end-to-end testing, and supports all modern browsers and platforms.

When coupled with LambdaTest (an AI-powered cloud-based test execution platform) it can be further scaled to run the Playwright scripts in parallel across 3000+ browser and device combinations:

>> Automated End-to-End Testing With Playwright

1. Introduction

In this tutorial, we’ll learn about Composite Primary Keys and the corresponding annotations in JPA.

Spring JPA @Embedded and @EmbeddedId

Learn how to use the @EmbeddeId and @Embeddable annotations to represent composite keys in JPA entities.

When Does JPA Set the Primary Key

Learn about the different strategies JPA uses to generate the primary key for an entity and at which moment each strategy sets the key value during persistence.

Returning an Auto-Generated Id with JPA

In this tutorial, we'll discuss how we can handle auto-generated ids with JPA.

2. Composite Primary Keys

A composite primary key, also called a composite key, is a combination of two or more columns to form a primary key for a table.

In JPA, we have two options to define the composite keys: the @IdClass and @EmbeddedId annotations.

In order to define the composite primary keys, we should follow some rules:

The composite primary key class must be public.
It must have a no-arg constructor.
It must define the equals() and hashCode() methods.
It must be Serializable.

3. The IdClass Annotation

Let’s say we have a table called Account and it has two columns, accountNumber and accountType, that form the composite key. Now we have to map it in JPA.

As per the JPA specification, let’s create an AccountId class with these primary key fields:

public class AccountId implements Serializable {
    private String accountNumber;

    private String accountType;

    // default constructor

    public AccountId(String accountNumber, String accountType) {
        this.accountNumber = accountNumber;
        this.accountType = accountType;
    }

    // equals() and hashCode()
}

Next let’s associate the AccountId class with the entity Account.

In order to do that, we need to annotate the entity with the @IdClass annotation. We must also declare the fields from the AccountId class in the entity Account and annotate them with @Id:

@Entity
@IdClass(AccountId.class)
public class Account {
    @Id
    private String accountNumber;

    @Id
    private String accountType;

    // other fields, getters and setters
}

4. The EmbeddedId Annotation

@EmbeddedId is an alternative to the @IdClass annotation.

Let’s consider another example where we have to persist some information of a Book, with title and language as the primary key fields.

In this case, the primary key class, BookId, must be annotated with @Embeddable:

@Embeddable
public class BookId implements Serializable {
    private String title;
    private String language;

    // default constructor

    public BookId(String title, String language) {
        this.title = title;
        this.language = language;
    }

    // getters, equals() and hashCode() methods
}

Then we need to embed this class in the Book entity using @EmbeddedId:

@Entity
public class Book {
    @EmbeddedId
    private BookId bookId;

    // constructors, other fields, getters and setters
}

5. @IdClass vs @EmbeddedId

As we can see, the difference on the surface between these two is that with @IdClass we had to specify the columns twice, once in AccountId and again in Account; however, with @EmbeddedId we didn’t.

There are some other trade offs though.

For example, these different structures affect the JPQL queries that we write.

With @IdClass, the query is a bit simpler:

SELECT account.accountNumber FROM Account account

With @EmbeddedId, we have to do one extra traversal:

SELECT book.bookId.title FROM Book book

Also, @IdClass can be quite useful in places where we are using a composite key class that we can’t modify.

If we’re going to access parts of the composite key individually, we can make use of @IdClass, but in places where we frequently use the complete identifier as an object, @EmbeddedId is preferred.

6. Count Query With Composite Primary Key

We can use JPQL and CriteriaQuery to count the entity using embedded ID as the primary key.

6.1. Using JPQL

We can write a JPQL query to perform a count on an entity and execute it using the entity manager. getSingleResult() method returns the count for the book entity:

long countBookByEmbeddedIdUsingJPQL() {
    String jpql = "SELECT count(b) FROM Book b";
    Query query = em.createQuery(jpql);
    return (long) query.getSingleResult();
}

We can verify the result with a unit test:

@Test
public void givenBookWithEmbeddedId_whenCountCalled_thenReturnsCount() {
    IntStream.rangeClosed(1, 10)
      .forEach(i -> {
          BookId bookId = new BookId("Book" + i, "English");
          Book book = new Book(bookId);
          book.setDescription("Novel and Historical Fiction" + i);
          persist(book);
      });
    assertEquals(10, countBookByEmbeddedIdUsingJPQL());
    assertEquals(10, countBookByEmbeddedIdUsingCriteriaQuery());
}

6.2. Using CriteriaQuery

We can use CriteriaQuery to count the entity using the embedded ID. First, we build the root query and then use getSingleResult() to return the count for the root query:

long countBookByEmbeddedIdUsingCriteriaQuery() {
    CriteriaBuilder criteriaBuilder = em.getCriteriaBuilder();
    CriteriaQuery<Long> criteriaQuery = criteriaBuilder.createQuery(Long.class);
    Root<Book> root = criteriaQuery.from(Book.class);
    criteriaQuery.select(criteriaBuilder.count(root));

    return em.createQuery(criteriaQuery).getSingleResult();
}

We can verify the result with a unit test:

@Test
public void givenBookWithEmbeddedId_whenCountCalled_thenReturnsCount() {
    IntStream.rangeClosed(1, 10)
      .forEach(i -> {
          BookId bookId = new BookId("Book" + i, "English");
          Book book = new Book(bookId);
          book.setDescription("Novel and Historical Fiction" + i);
          persist(book);
      });
    assertEquals(10, countBookByEmbeddedIdUsingJPQL());
    assertEquals(10, countBookByEmbeddedIdUsingCriteriaQuery());
}

7. Conclusion

In this brief article, we explored composite primary keys in JPA.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.

Of course, Azure Container Apps has really solid support for our ecosystem, from a number of build options, managed Java components, native metrics, dynamic logger, and quite a bit more.

To learn more about Java features on Azure Container Apps, visit the documentation page.

You can also ask questions and leave feedback on the Azure Container Apps GitHub page.

Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.

Try a 14-Day Free Trial of Orkes Conductor today.

Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.

Try a 14-Day Free Trial of Orkes Conductor today.