使用JPA Metamodel的标准查询

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:

@Entity
@Table(name = "students")
public class Student {
    
    @Id
    @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 EclipseLink, OpenJPA, 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:

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-jpamodelgen</artifactId>
    <version>6.1.7.Final</version>
</dependency>

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")
@StaticMetamodel(Student.class)
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);
criteriaQuery.select(root).where(cb.equal(root.get(Student_.gradYear), 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

REST

Security