Just like in any OOP (Object-Oriented Programming) language, entity inheritance is suitable for varying behavior rather than reusing data structures, for which we could composition. The Domain Model compromising both data (e.g. persisted entities) and behavior (business logic), we can still make use of inheritance for implementing a behavioral software design pattern.
In this article, I’m going to demonstrate how to use JPA inheritance as a means to implement the Strategy design pattern.
Domain Model
Considering we have a notification system that needs to send both email and SMS to customers, we can model the notification relationships as follows:
Both the SmsNotification and EmailNotification inherit the base class Notification properties. However, if we use a RDBMS (relational database system), there is no standard way of implementing table inheritance, so we need to emulate this relationship. Usually, there are only two choices:
or we can use separate tables for the base class and subclass entities in which case the subclass table Primary Key is also a Foreign Key to the base class Primary Key.
For this example, we are going to use the JOINED table approach which has the following database entity relationship diagram:
Bridging the gap
With JPA and Hibernate, mapping the OOP and the RDBMS models is straightforward.
The Notification base class is mapped as follows:
@Entity
@Table(name = "notification")
@Inheritance(
strategy = InheritanceType.JOINED
)
public class Notification {
@Id
@GeneratedValue
private Long id;
@Column(name = "first_name")
private String firstName;
@Column(name = "last_name")
private String lastName;
@Temporal( TemporalType.TIMESTAMP )
@CreationTimestamp
@Column(name = "created_on")
private Date createdOn;
//Getters and setters omitted for brevity
}
The SmsNotification and EmailNotification mappings looks like this:
@Entity
@Table(name = "sms_notification")
public class SmsNotification
extends Notification {
@Column(
name = "phone_number",
nullable = false
)
private String phoneNumber;
//Getters and setters omitted for brevity
}
@Entity
@Table(name = "email_notification")
public class EmailNotification
extends Notification {
@Column(
name = "email_address",
nullable = false
)
private String emailAddress;
//Getters and setters omitted for brevity
}
Business logic
So far, we only mapped the relationship between the OOP and the RDBMS data structures, but we haven’t covered the actual business logic which is required to send these notifications to our users.
For this purpose, we have the following NotificationSender Service components:
The NotificationSender has two methods:
appliesTo gives the entity that’s supported by this NotificationSender
send encapsulates the actual sending logic
The EmailNotificationSender is implemented as follows:
@Component
public class EmailNotificationSender
implements NotificationSender<EmailNotification> {
protected final Logger LOGGER = LoggerFactory.getLogger(
getClass()
);
@Override
public Class<EmailNotification> appliesTo() {
return EmailNotification.class;
}
@Override
public void send(EmailNotification notification) {
LOGGER.info(
"Send Email to {} {} via address: {}",
notification.getFirstName(),
notification.getLastName(),
notification.getEmailAddress()
);
}
}
Of course, the actual sending logic was stripped away, but this is sufficient to understand how the Strategy pattern works.
However, the user does not have to interact with the NotificationSender directly. They only want to send a campaign, and the system should figure out the subscriber channels each client has opted for.
Therefore, we can use the Facade Pattern to expose a very simple API:
The NotificationSenderImpl is where all the magic happens:
There are several things to note in this implementation:
We make use of Spring List auto-wiring feature which I explained in my very first blog post. This way, we can inject any NotificationSender the user has configured in our system, therefore decoupling the NotificationService from the actual NotificationSender implementations our system us currently supporting.
The init method builds the notificationSenderMap which takes a Notification class type as the Map key and the associated NotificationSender as the Map value.
The sendCampaign method fetches a List of Notification entities from the DAO layer and pushes them to their associated NotificationSender instances.
Because JPA offers polymorphic queries, the findAll DAO method can be implemented as follows:
Writing JPA Criteria API queries is not very easy. The Codota IDE plugin can guide you on how to write such queries, therefore increasing your productivity.
For more details about how you can use Codota to speed up the process of writing Criteria API queries, check out this article.
The system does not have to know which are the actual Notification implementation each client has chosen. The polymorphic query is figured out at runtime by JPA and Hibernate.
Testing time
If we created the following Notification entities in our system:
notificationService.sendCampaign(
"Black Friday",
"High-Performance Java Persistence is 40% OFF"
);
Hibernate executes the following SQL query:
SELECT
n.id AS id1_1_,
n.created_on AS created_2_1_,
n.first_name AS first_na3_1_,
n.last_name AS last_nam4_1_,
n1_.email_address AS email_ad1_0_,
n2_.phone_number AS phone_nu1_2_,
CASE WHEN n1_.id IS NOT NULL THEN 1
WHEN n2_.id IS NOT NULL THEN 2
WHEN n.id IS NOT NULL THEN 0
END AS clazz_
FROM
notification n
LEFT OUTER JOIN
email_notification n1_ ON n.id = n1_.id
LEFT OUTER JOIN
sms_notification n2_ ON n.id = n2_.id
And the following output is logged:
EmailNotificationSender - Send Email to Vlad Mihalcea via address: vlad@acme.com
SmsNotificationSender - Send SMS to Vlad Mihalcea via phone number: 012-345-67890
Cool, right?
If you enjoyed this article, I bet you are going to love my Book and Video Courses as well.
Conclusion
Entity Inheritance is a very useful technique, but only when you use it along with a behavioral software design pattern, such as Strategy or Visitor pattern.
If you only need to propagate certain properties from a base class to all subclasses, you don’t need JPA entity inheritance. All you need is the @MappedSuperclass annotation, but that’s not entity inheritance since the object hierarchy is only visible in the OOP domain, not in the relationship model.
Only if you need to build the entity query dynamically, then you should use Criteria API. Otherwise, you could use JPQL or native SQL, which is much more readable.
Thank you for your post,
Could you please tell me which software that all images in this post are drawn from? I really like its visualization.
Thank you very much
Based on my book, High-Performance Java Persistence, this workshop teaches you various data access performance optimizations from JDBC, to JPA, Hibernate and jOOQ for the major rational database systems (e.g. Oracle, SQL Server, MySQL and PostgreSQL).
The SQL Master Class for Java Developers training is aimed to level up your SQL skills with techniques such as Window Functions, recursive queries, Pivoting, JSON processing, and many other database querying features supported by Oracle, SQL Server, MySQL, or PostgreSQL.
Hi Vlad, If I need to retrieve notifications by email address using JPA, do I need to create a criteria query?
Assuming JPA repository
Only if you need to build the entity query dynamically, then you should use Criteria API. Otherwise, you could use JPQL or native SQL, which is much more readable.
Vlad, I have a doubt…
if I use the annotation:
@Inheritance(
strategy = InheritanceType.JOINED
)
Is possible to get data from only the parent database table, disconsidering childrens tables? like:
JPA: createQuery(“from Notification”, Notification.class).getResultList();
SQL: “select * from notification”;
Thank you for your great post!!
Try with the @Polymorphism(EXPLICIT) annotation on the base class.
Thank you for your post,
Could you please tell me which software that all images in this post are drawn from? I really like its visualization.
Thank you very much
The class diagrams are exported from IntelliJ IDEA. The table diagrams from MySQL Browser. The other diagrams are done using yED.
Thanks you very much.
You’re welcome. If you liked my articles, you are going to love my High-Performance Java Persistence book as well.