Jpa @Embedded and @Embeddable

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Regression testing is an important step in the release process, to ensure that new code doesn't break the existing functionality. As the codebase evolves, we want to run these tests frequently to help catch any issues early on.

The best way to ensure these tests run frequently on an automated basis is, of course, to include them in the CI/CD pipeline. This way, the regression tests will execute automatically whenever we commit code to the repository.

In this tutorial, we'll see how to create regression tests using Selenium, and then include them in our pipeline using GitHub Actions:, to be run on the LambdaTest cloud grid:

>> How to Run Selenium Regression Tests With GitHub Actions

1. Overview

In this tutorial, we’ll see how we can map one entity that contains embedded properties to a single database table.

For this purpose, we’ll use the @Embeddable and @Embedded annotations provided by the Java Persistence API (JPA).

2. Data Model Context

First, let’s define a table called company.

The company table will store basic information such as company name, address and phone as well as the information of a contact person:

public class Company {

    private Integer id;

    private String name;

    private String address;

    private String phone;

    private String contactFirstName;

    private String contactLastName;

    private String contactPhone;

    // standard getters, setters
}

However, it seems like the contact person should be abstracted out to a separate class.

The problem is that we don’t want to create a separate table for those details.

So, let’s see what we can do.

3. @Embeddable

JPA provides the @Embeddable annotation to declare that a class will be embedded by other entities.

Let’s define a class to abstract out the contact person details:

@Embeddable
public class ContactPerson {

    private String firstName;

    private String lastName;

    private String phone;

    // standard getters, setters
}

4. @Embedded

The JPA annotation @Embedded is used to embed a type into another entity.

Let’s next modify our Company class.

We’ll add the JPA annotations, and we’ll also change to use ContactPerson instead of separate fields:

@Entity
public class Company {

    @Id
    @GeneratedValue
    private Integer id;

    private String name;

    private String address;

    private String phone;

    @Embedded
    private ContactPerson contactPerson;

    // standard getters, setters
}

As a result, we have our entity Company, embedding contact person details and mapping to a single database table.

We still have one more problem, though, and that is how JPA will map these fields to database columns.

5. @EmbeddedColumnNaming

We can use the @EmbeddedColumnNaming annotation to customize how Hibernate prefixes embedded attribute columns when mapping to the database.

By default, Hibernate prefixes the embedded columns with the name of the embedded field. For example, for the embedded field contactPerson, columns would be named like contactPerson_firstName, contactPerson_lastName, etc.

If we want to customize or remove this prefix, we can use @EmbeddedColumnNaming with prefix:

@Entity
public class Company {
    // existing attributes

    @Embedded
    @EmbeddedColumnNaming("contact_")
    private ContactPerson contactPerson;

    // standard getters, setters
}

In this example, instead of columns being named like contactPerson_firstName, Hibernate names the columns contact_firstName, contact_lastName, and contact_phone, following the prefix we specified.

If we want to completely remove the prefix (so column names are just firstName), we can set prefix = “”:

@Embedded
@EmbeddedColumnNaming("")
private ContactPerson contactPerson;

6. Attributes Override

Our fields were called things like contactFirstName in our original Company class and now firstName in our ContactPerson class. So, JPA will want to map these to contact_first_name and first_name, respectively.

Aside from being less than ideal, it will actually break us with our now-duplicated phone column.

So, we can use @AttributeOverrides and @AttributeOverride to override the column properties of our embedded type.

Let’s add this to the ContactPerson field in our Company entity:

@Embedded
@AttributeOverrides({
  @AttributeOverride( name = "firstName", column = @Column(name = "contact_first_name")),
  @AttributeOverride( name = "lastName", column = @Column(name = "contact_last_name")),
  @AttributeOverride( name = "phone", column = @Column(name = "contact_phone"))
})
private ContactPerson contactPerson;

Note that since these the annotations go on the field, we can have different overrides for each enclosing entity.

7. Conclusion

In this article, we configured an entity with some embedded attributes and mapped them to the same database table as the enclosing entity.

To do this, we used the @Embedded, @Embeddable, @AttributeOverrides, @EmbeddedColumnNaming @AttributeOverride annotations provided by the Java Persistence API.

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.