Como esta é uma pergunta muito comum, escrevi este artigo , no qual esta resposta se baseia.
Vamos supor que o nosso aplicativo usa o seguinte Post, PostComment, PostDetails, e Tagentidades, que formam um um-para-muitos, um-para-um, e muitos-para-muitos relações de tabela :
Como gerar o Metamodelo de Critérios JPA
A hibernate-jpamodelgenferramenta fornecida pelo Hibernate ORM pode ser usada para escanear as entidades do projeto e gerar o Metamodelo de Critérios JPA. Tudo que você precisa fazer é adicionar o seguinte annotationProcessorPathao arquivo de configuração maven-compiler-plugindo Maven pom.xml:
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>${maven-compiler-plugin.version}</version>
<configuration>
<annotationProcessorPaths>
<annotationProcessorPath>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-jpamodelgen</artifactId>
<version>${hibernate.version}</version>
</annotationProcessorPath>
</annotationProcessorPaths>
</configuration>
</plugin>
Agora, quando o projeto é compilado, você pode ver que na targetpasta, as seguintes classes Java são geradas:
> tree target/generated-sources/
target/generated-sources/
└── annotations
└── com
└── vladmihalcea
└── book
└── hpjp
└── hibernate
├── forum
│ ├── PostComment_.java
│ ├── PostDetails_.java
│ ├── Post_.java
│ └── Tag_.java
Metamodelo de entidade de tag
Se a Tagentidade for mapeada da seguinte maneira:
@Entity
@Table(name = "tag")
public class Tag {
@Id
private Long id;
private String name;
//Getters and setters omitted for brevity
}
A Tag_classe Metamodel é gerada assim:
@Generated(value = "org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor")
@StaticMetamodel(Tag.class)
public abstract class Tag_ {
public static volatile SingularAttribute<Tag, String> name;
public static volatile SingularAttribute<Tag, Long> id;
public static final String NAME = "name";
public static final String ID = "id";
}
O SingularAttributeé usado para os atributos básicos ide de name Tagentidade JPA.
Metamodelo de entidade post
A Postentidade é mapeada assim:
@Entity
@Table(name = "post")
public class Post {
@Id
private Long id;
private String title;
@OneToMany(
mappedBy = "post",
cascade = CascadeType.ALL,
orphanRemoval = true
)
private List<PostComment> comments = new ArrayList<>();
@OneToOne(
mappedBy = "post",
cascade = CascadeType.ALL,
fetch = FetchType.LAZY
)
@LazyToOne(LazyToOneOption.NO_PROXY)
private PostDetails details;
@ManyToMany
@JoinTable(
name = "post_tag",
joinColumns = @JoinColumn(name = "post_id"),
inverseJoinColumns = @JoinColumn(name = "tag_id")
)
private List<Tag> tags = new ArrayList<>();
//Getters and setters omitted for brevity
}
A Postentidade tem dois atributos básicos ide title, uma commentscoleção de um para muitos , uma detailsassociação de um para um e uma tagscoleção de muitos para muitos .
A Post_classe Metamodel é gerada da seguinte maneira:
@Generated(value = "org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor")
@StaticMetamodel(Post.class)
public abstract class Post_ {
public static volatile ListAttribute<Post, PostComment> comments;
public static volatile SingularAttribute<Post, PostDetails> details;
public static volatile SingularAttribute<Post, Long> id;
public static volatile SingularAttribute<Post, String> title;
public static volatile ListAttribute<Post, Tag> tags;
public static final String COMMENTS = "comments";
public static final String DETAILS = "details";
public static final String ID = "id";
public static final String TITLE = "title";
public static final String TAGS = "tags";
}
Os atributos básicos ide title, bem como a detailsassociação um para um , são representados por um SingularAttributeenquanto as coleções commentse tagssão representadas pelo JPA ListAttribute.
Metamodelo de entidade PostDetails
A PostDetailsentidade é mapeada assim:
@Entity
@Table(name = "post_details")
public class PostDetails {
@Id
@GeneratedValue
private Long id;
@Column(name = "created_on")
private Date createdOn;
@Column(name = "created_by")
private String createdBy;
@OneToOne(fetch = FetchType.LAZY)
@MapsId
@JoinColumn(name = "id")
private Post post;
//Getters and setters omitted for brevity
}
Todos os atributos da entidade serão representados pelo JPA SingularAttributena PostDetails_classe Metamodelo associada :
@Generated(value = "org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor")
@StaticMetamodel(PostDetails.class)
public abstract class PostDetails_ {
public static volatile SingularAttribute<PostDetails, Post> post;
public static volatile SingularAttribute<PostDetails, String> createdBy;
public static volatile SingularAttribute<PostDetails, Long> id;
public static volatile SingularAttribute<PostDetails, Date> createdOn;
public static final String POST = "post";
public static final String CREATED_BY = "createdBy";
public static final String ID = "id";
public static final String CREATED_ON = "createdOn";
}
Metamodelo de entidade PostComment
O PostCommenté mapeado da seguinte forma:
@Entity
@Table(name = "post_comment")
public class PostComment {
@Id
private Long id;
@ManyToOne(fetch = FetchType.LAZY)
private Post post;
private String review;
//Getters and setters omitted for brevity
}
E todos os atributos de entidade são representados pelo JPA SingularAttributena PostComments_classe Metamodelo associada :
@Generated(value = "org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor")
@StaticMetamodel(PostComment.class)
public abstract class PostComment_ {
public static volatile SingularAttribute<PostComment, Post> post;
public static volatile SingularAttribute<PostComment, String> review;
public static volatile SingularAttribute<PostComment, Long> id;
public static final String POST = "post";
public static final String REVIEW = "review";
public static final String ID = "id";
}
Usando o Metamodelo de Critérios JPA
Sem o Metamodelo JPA, uma consulta de Criteria API que precisa buscar as PostCommententidades filtradas por seus Posttítulos associados ficaria assim:
CriteriaBuilder builder = entityManager.getCriteriaBuilder();
CriteriaQuery<PostComment> query = builder.createQuery(PostComment.class);
Root<PostComment> postComment = query.from(PostComment.class);
Join<PostComment, Post> post = postComment.join("post");
query.where(
builder.equal(
post.get("title"),
"High-Performance Java Persistence"
)
);
List<PostComment> comments = entityManager
.createQuery(query)
.getResultList();
Observe que usamos o postliteral String ao criar a Joininstância e o titleliteral String ao fazer referência ao Post title.
O Metamodelo JPA nos permite evitar atributos de entidade de codificação permanente, conforme ilustrado pelo seguinte exemplo:
CriteriaBuilder builder = entityManager.getCriteriaBuilder();
CriteriaQuery<PostComment> query = builder.createQuery(PostComment.class);
Root<PostComment> postComment = query.from(PostComment.class);
Join<PostComment, Post> post = postComment.join(PostComment_.post);
query.where(
builder.equal(
post.get(Post_.title),
"High-Performance Java Persistence"
)
);
List<PostComment> comments = entityManager
.createQuery(query)
.getResultList();
Escrever consultas de API de critérios JPA é muito mais fácil se você estiver usando uma ferramenta de auto-completar de código como Codota. Confira este artigo para obter mais detalhes sobre o plugin Codota IDE.
Ou digamos que queremos buscar uma projeção DTO enquanto filtramos Post titleos PostDetails createdOnatributos e.
Podemos usar o Metamodelo ao criar os atributos de junção, bem como ao construir os aliases da coluna de projeção DTO ou ao fazer referência aos atributos de entidade que precisamos filtrar:
CriteriaBuilder builder = entityManager.getCriteriaBuilder();
CriteriaQuery<Object[]> query = builder.createQuery(Object[].class);
Root<PostComment> postComment = query.from(PostComment.class);
Join<PostComment, Post> post = postComment.join(PostComment_.post);
query.multiselect(
postComment.get(PostComment_.id).alias(PostComment_.ID),
postComment.get(PostComment_.review).alias(PostComment_.REVIEW),
post.get(Post_.title).alias(Post_.TITLE)
);
query.where(
builder.and(
builder.like(
post.get(Post_.title),
"%Java Persistence%"
),
builder.equal(
post.get(Post_.details).get(PostDetails_.CREATED_BY),
"Vlad Mihalcea"
)
)
);
List<PostCommentSummary> comments = entityManager
.createQuery(query)
.unwrap(Query.class)
.setResultTransformer(Transformers.aliasToBean(PostCommentSummary.class))
.getResultList();
Legal certo?
