JPA Buddy
announcement - icon

JPA is huge! It covers nearly every aspect of communication between relational databases and the Java application and is deeply integrated into all major frameworks.

If you're using IntelliJ, JPA Buddy is super helpful. The plugin gently guides you through the subtleties of the most popular JPA implementations, visually reminds you of JPA features, generates code that follows best practices, and integrates intelligent inspections to improve your existing persistence code.

More concretely, it provides powerful tooling to generate Spring Data JPA repositories and methods, Flyway Versioned Migrations, Liquibase Differential Changelogs, DDL and SQL statements, DTO objects, and MapStruct interfaces.

Oh, and it actually generates JPA entities from an existing database and gradually update the data model as the database evolves! Yeah.

>> Become a lot more productive with JPA Buddy

Persistence top

Get started with Spring Data JPA through the reference Learn Spring Data JPA course:


1. Overview

In this tutorial, we'll discuss how to use the JPA static metamodel classes while writing criteria queries in Hibernate.

We'll need a basic understanding of criteria query APIs in Hibernate, so please check out our tutorial on Criteria Queries for more information on this topic, if needed.

2. Why the JPA Metamodel?

Often, when we write a criteria query, we need to reference entity classes and their attributes.

Now, one of the ways of doing this is to provide the attributes' names as strings. But, this has several downsides.

For one, we have to look up the names of entity attributes. And, in case a column name is changed later in the project lifecycle, we have to refactor each query where the name is being used.

The JPA Metamodel was introduced by the community to avoid these drawbacks and provide static access to the metadata of the managed entity classes.

3. Entity Class

Let's consider a scenario where we are building a Student Portal Management system for one of our clients, and a requirement comes up to provide search functionality on Students based on their graduation year.

First, let's look at our Student class:

@Table(name = "students")
public class Student {
    @GeneratedValue(strategy = GenerationType.AUTO)
    private int id;

    @Column(name = "first_name")
    private String firstName;

    @Column(name = "last_name")
    private String lastName;

    @Column(name = "grad_year")
    private int gradYear;

    // standard getters and setters

4. Generating JPA Metamodel Classes

Next, we need to generate the metamodel classes, and for this purpose, we'll use the metamodel generator tool provided by JBoss. JBoss is just one of the many tools available to generate the metamodel. Other suitable tools include EclipseLinkOpenJPA, and DataNucleus.

To use the JBoss tool, we need to add the latest dependency in our pom.xml file, and the tool will generate the metamodel classes once we trigger the maven build command:


Note, we need to add the target/generated-classes folder to the classpath of our IDE, as by default, the classes will be generated in this folder only.

5. Static JPA Metamodel Classes

Based on the JPA specification, a generated class will reside in the same package as the corresponding entity class and will have the same name with an added “_” (underscore) at the end. So, the metamodel class generated for the Student class will be Student_ and will look something like:

@Generated(value = "org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor")
public abstract class Student_ {

    public static volatile SingularAttribute<Student, String> firstName;
    public static volatile SingularAttribute<Student, String> lastName;
    public static volatile SingularAttribute<Student, Integer> id;
    public static volatile SingularAttribute<Student, Integer> gradYear;

    public static final String FIRST_NAME = "firstName";
    public static final String LAST_NAME = "lastName";
    public static final String ID = "id";
    public static final String GRAD_YEAR = "gradYear";

6. Using JPA Metamodel Classes

We can use the static metamodel classes in the same way we would use the String references to attributes. The criteria query API provides overloaded methods that accept String references as well as Attribute interface implementations.

Let's look at the criteria query that will fetch all Students who graduated in 2015:

//session set-up code
CriteriaBuilder cb = session.getCriteriaBuilder();
CriteriaQuery<Student> criteriaQuery = cb.createQuery(Student.class);

Root<Student> root = criteriaQuery.from(Student.class);, 2015));

Query<Student> query = session.createQuery(criteriaQuery);
List<Student> results = query.getResultList();

Notice how we've used the Student_.gradYear reference instead of using the conventional grad_year column name.

7. Conclusion

In this quick article, we learned how to use static metamodel classes and why they may be preferred over the traditional way of using String references as described earlier.

The source code of this tutorial can be found over on Github.

Persistence bottom
Get started with Spring Data JPA through the reference Learn Spring Data JPA course: >> CHECK OUT THE COURSE
Persistence footer banner
Comments are closed on this article!