One of the latest features in JPA 2.1 is the ability to specify fetch plans using Entity Graphs. This is useful since it allows you to customise the data that is retrieved with a query or find operation. When working with mid to large size applications is common to display data from the same entity in different and many ways. In other cases, you just want to select a smallest set of information to optimize the performance of your application.
You don’t have many mechanisms to control what is loaded or not in a JPA Entity. You could use EAGER / LAZY fetching, but these definitions are pretty much static. You were unable to change their behaviour when retrieving data, meaning that you were stuck with what was defined in the entity. Changing these in mid development is a nightmare, since it can cause queries to behave unexpectedly. Another way to control loading is to write specific JPQL queries. You usually end up with very similar queries and the following methods: findEntityWithX, findEntityWithY, findEntityWithXandY, and so on.
Before JPA 2.1, the implementations already supported a non standard way to load data similar to Entity Graphs. You have Hibernate Fetch Profiles, OpenJPA Fetch Groups and EclipseLink Fetch Groups. It was logical to have this kind of behaviour in the specification. It allows you a much finer and detail control on what you need to load using a standard API.
Example
Consider the following Entity Graph:
(Probably the relationships should be N to N, but lets keep it simple).
And the Movie Entity has the following definition:
Movie.java
@Entity
@Table(name = "MOVIE_ENTITY_GRAPH")
@NamedQueries({
@NamedQuery(name = "Movie.findAll", query = "SELECT m FROM Movie m")
})
@NamedEntityGraphs({
@NamedEntityGraph(
name = "movieWithActors",
attributeNodes = {
@NamedAttributeNode("movieActors")
}
),
@NamedEntityGraph(
name = "movieWithActorsAndAwards",
attributeNodes = {
@NamedAttributeNode(value = "movieActors", subgraph = "movieActorsGraph")
},
subgraphs = {
@NamedSubgraph(
name = "movieActorsGraph",
attributeNodes = {
@NamedAttributeNode("movieActorAwards")
}
)
}
)
})
public class Movie implements Serializable {
@Id
private Integer id;
@NotNull
@Size(max = 50)
private String name;
@OneToMany
@JoinColumn(name = "ID")
private Set<MovieActor> movieActors;
@OneToMany(fetch = FetchType.EAGER)
@JoinColumn(name = "ID")
private Set<MovieDirector> movieDirectors;
@OneToMany
@JoinColumn(name = "ID")
private Set<MovieAward> movieAwards;
}Looking closer to the entity, we can see that we have three 1 to N relationships and movieDirectors is set to be Eagerly loaded. The other relationships are set to the default Lazy loading strategy. If we want to change this behaviour, we can define different loading models by using the annotation @NamedEntityGraph. Just set a name to identify it and then use the @NamedAttributeNode to specify which attributes of the root entity that you want to load. For relationships you need to set a name to the subgraph and then use @NamedSubgraph. In detail:
Annotations
Entity Graph movieWithActors
@NamedEntityGraph(
name = "movieWithActors",
attributeNodes = {
@NamedAttributeNode("movieActors")
}
) )This defines an Entity Graph with name movieWithActors and specifies that the relationship movieActors should be loaded.
Entity Graph movieWithActorsAndAwards
@NamedEntityGraph(
name = "movieWithActorsAndAwards",
attributeNodes = {
@NamedAttributeNode(value = "movieActors", subgraph = "movieActorsGraph")
},
subgraphs = {
@NamedSubgraph(
name = "movieActorsGraph",
attributeNodes = {
@NamedAttributeNode("movieActorAwards")
}
)
}
)This defines an Entity Graph with name movieWithActorsAndAwards and specifies that the relationship movieActors should be loaded. Additionally, it also specifies that the relationship movieActors should load the movieActorAwards.
Note that we don’t specify the id attribute in the Entity Graph. This is because primary keys are always fetched regardless of what’s being specified. This is also true for version attributes.
Hints
To use the Entity Graphs defined in a query, you need to set them as an hint. You can use two hint properties and these also influences the way the data is loaded.
You can use javax.persistence.fetchgraph and this hint will treat all the specified attributes in the Entity Graph as FetchType.EAGER. Attributes that are not specified are treated as FetchType.LAZY.
The other property hint is javax.persistence.loadgraph. This will treat all the specified attributes in the Entity Graph as FetchType.EAGER. Attributes that are not specified are treated to their specified or default FetchType.
To simplify, and based on our example when applying the Entity Graph movieWithActors:
| Default / Specified | javax.persistence.fetchgraph | javax.persistence.loadgraph | |
|---|---|---|---|
| movieActors | LAZY | EAGER | EAGER |
| movieDirectors | EAGER | LAZY | EAGER |
| movieAwards | LAZY | LAZY | LAZY |
In theory, this should be how the different relationships are fetched. In practice, it may not work this way, because the JPA 2.1 specification also states that the JPA provider can always fetch extra state beyond the one specified in the Entity Graph. This is because the provider can optimize which data to fetch and end up loading much more stuff. You need to check your provider behaviour. For instance Hibernate always fetch everything that is specified as EAGER even when using the javax.persistence.fetchgraph hint. Check the issue here.
Query
Performing the query is easy. You do it as you would normally do, but just call setHint on the Query object:
Hint Entity Graph
@PersistenceContext
private EntityManager entityManager;
public List<Movie> listMovies(String hint, String graphName) {
return entityManager.createNamedQuery("Movie.findAll")
.setHint(hint, entityManager.getEntityGraph(graphName))
.getResultList();
}To get the Entity Graph you want to use on your query, you need to call the getEntityGraph method on the EntityManager and pass the name. Then use the reference in the hint. Hint must be either javax.persistence.fetchgraph or javax.persistence.loadgraph.
Programmatic
Annotations may become verbose, especially if you have big graphs or many Entity Graphs. Instead of using annotations, you can programmatically define Entity Graphs. Let’s see how:
Start by adding a static meta model Entity Class:
Movie_.java
@StaticMetamodel(Movie.class)
public abstract class Movie_ {
public static volatile SingularAttribute<Movie, Integer> id;
public static volatile SetAttribute<Movie, MovieAward> movieAwards;
public static volatile SingularAttribute<Movie, String> name;
public static volatile SetAttribute<Movie, MovieActor> movieActors;
public static volatile SetAttribute<Movie, MovieDirector> movieDirectors;
}This is not really needed, you can reference the attributes by their string names, but this will give you type safety.
Programmatic Entity Graph
EntityGraph<Movie> fetchAll = entityManager.createEntityGraph(Movie.class);
fetchAll.addSubgraph(Movie_.movieActors);
fetchAll.addSubgraph(Movie_.movieDirectors);
fetchAll.addSubgraph(Movie_.movieAwards);This Entity Graph specifies that all relationships of the Entity must be loaded. You can now adjust to your own use cases.
Resources
You can find this sample code in the Java EE samples at Github. Check it here.
Extra Note: currently there is a bug in EclipseLink / Glassfish that prevents javax.persistence.loadgraph hint from working properly. Check the issue here.
Conclusion
Entity Graphs filled a gap missing in the JPA specification. They are an extra mechanism that helps you to query for what you really need. They also help you to improve the performance of your application. But be smart when using them. There might be a better way.
| Reference: | JPA Entity Graphs from our JCG partner Roberto Cortez at the Roberto Cortez Java Blog blog. |
