What is the @Embeddable annotation used for in JPA?

Table of Contents

Introduction

The @Embeddable annotation in Java Persistence API (JPA) is used to mark a class whose instances can be embedded within another entity. This means that the class is not an independent entity but is rather part of a larger entity as a group of fields. An embeddable class can be used for complex types or composite primary keys that are shared across multiple entities.

The @Embeddable annotation is typically used alongside the @Embedded annotation on the parent entity to include the embedded class as a field.

1. Purpose of @Embeddable Annotation

The @Embeddable annotation allows you to define classes that are meant to be embedded into other entities. These embedded classes are not persistent by themselves but contribute to the overall state of the parent entity.

  • It is used when you want to group multiple related fields together and encapsulate them in a separate class.
  • It helps in reducing redundancy when the same fields need to be embedded in multiple entities.

Example Use Cases:

  • Address as part of a Customer entity: You can create an Address class with fields like street, city, and zipCode, and embed it in the Customer entity.
  • Composite primary keys: You can use @Embeddable to define a composite primary key, where multiple fields together make up the primary key of an entity.

2. Using @Embeddable with @Embedded

To use the @Embeddable annotation, you define a class with multiple attributes that you want to embed in an entity. The class is marked as @Embeddable, and it can then be embedded in another entity using the @Embedded annotation.

2.1 Example: Embedding an Address in a Customer Entity

Code Example:

In this example:

  • The Address class is marked with @Embeddable, indicating it can be embedded within another entity.
  • The Customer entity has an @Embedded field, address, which will include the fields of the Address class as part of the Customer entity.

The Address fields (street, city, zipCode) will be stored in the same table as the Customer entity, with the column names being derived from the names of the attributes in the Address class.

3. Composite Primary Keys Using @Embeddable

The @Embeddable annotation is also commonly used for defining composite primary keys. When an entity's primary key is made up of multiple columns, you can define a separate class for the primary key fields, annotate it with @Embeddable, and then use @EmbeddedId in the parent entity.

Code Example: Composite Primary Key

In this example:

  • OrderId is marked as @Embeddable to indicate that it can be embedded into the Order entity as a composite primary key.
  • The @EmbeddedId annotation is used in the Order entity to indicate that the composite key is embedded in the orderId field.

4. Benefits of Using @Embeddable

  • Reuse: You can reuse the embedded class in multiple entities, reducing redundancy and improving maintainability.
  • Clean Design: It allows for better organization and encapsulation of related fields, especially when dealing with complex data structures like addresses or coordinates.
  • Composite Keys: It provides a clean way to represent composite keys, which consist of multiple fields in the database.

5. Key Differences: @Embeddable vs. @Entity

While both @Embeddable and @Entity are used to define classes that can be persisted in the database, there are key differences:

  • @Embeddable classes do not have their own identity or table in the database. They are always part of another entity.
  • @Entity classes are independent and have their own table in the database.

Conclusion

The @Embeddable annotation in JPA is an essential feature for embedding complex objects or composite keys within other entities. By grouping related fields into a single embeddable class, you can reduce redundancy, improve organization, and create a cleaner, more maintainable entity model. Whether you're embedding an address or defining a composite primary key, the @Embeddable annotation plays a crucial role in JPA entity mapping

Share
Similar Questions