使用组合主键的桥接表的Java Criteria API查询

Question

与以下SQL等效的Java条件api查询是什么？ 我对此并不陌生，尝试过一些方法，但没有任何效果。

SELECT p.* FROM Product p
RIGHT JOIN store_has_product shp ON  p.id_product=shp.id_product
WHERE shp.id_store=1;

TableA：存储

桥接表：store_has_product（该表具有id_store，id_product作为复合pk）

表B：产品

实体（无构造函数，getter / setter）

    @Entity
@Table(name = "product")
@XmlRootElement
@NamedQueries({
    @NamedQuery(name = "Product.findAll", query = "SELECT p FROM Product p"),
    @NamedQuery(name = "Product.findByIdProduct", query = "SELECT p FROM Product p WHERE p.idProduct = :idProduct"),
    @NamedQuery(name = "Product.findByName", query = "SELECT p FROM Product p WHERE p.name = :name"),
    @NamedQuery(name = "Product.findByCost", query = "SELECT p FROM Product p WHERE p.cost = :cost")})
public class Product implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Basic(optional = false)
    @Column(name = "idProduct")
    private Integer idProduct;
    @Size(max = 45)
    @Column(name = "name")
    private String name;
    // @Max(value=?)  @Min(value=?)//if you know range of your decimal fields consider using these annotations to enforce field validation
    @Column(name = "cost")
    private Double cost;
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "product")
    private Collection<StoreHasProduct> storeHasProductCollection;

@Entity
@Table(name = "store")
@XmlRootElement
@NamedQueries({
    @NamedQuery(name = "Store.findAll", query = "SELECT s FROM Store s"),
    @NamedQuery(name = "Store.findByIdStore", query = "SELECT s FROM Store s WHERE s.idStore = :idStore"),
    @NamedQuery(name = "Store.findByName", query = "SELECT s FROM Store s WHERE s.name = :name")})
public class Store implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Basic(optional = false)
    @Column(name = "idStore")
    private Integer idStore;
    @Size(max = 45)
    @Column(name = "name")
    private String name;
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "store")
    private Collection<StoreHasProduct> storeHasProductCollection;

@Entity
@Table(name = "store_has_product")
@XmlRootElement
@NamedQueries({
    @NamedQuery(name = "StoreHasProduct.findAll", query = "SELECT s FROM StoreHasProduct s"),
    @NamedQuery(name = "StoreHasProduct.findByStoreidStore", query = "SELECT s FROM StoreHasProduct s WHERE s.storeHasProductPK.storeidStore = :storeidStore"),
    @NamedQuery(name = "StoreHasProduct.findByProductidProduct", query = "SELECT s FROM StoreHasProduct s WHERE s.storeHasProductPK.productidProduct = :productidProduct"),
    @NamedQuery(name = "StoreHasProduct.findByActive", query = "SELECT s FROM StoreHasProduct s WHERE s.active = :active")})
public class StoreHasProduct implements Serializable {
    private static final long serialVersionUID = 1L;
    @EmbeddedId
    protected StoreHasProductPK storeHasProductPK;
    @Column(name = "active")
    private Short active;
    @JoinColumn(name = "Product_idProduct", referencedColumnName = "idProduct", insertable = false, updatable = false)
    @ManyToOne(optional = false)
    private Product product;
    @JoinColumn(name = "Store_idStore", referencedColumnName = "idStore", insertable = false, updatable = false)
    @ManyToOne(optional = false)
    private Store store;

@Embeddable
public class StoreHasProductPK implements Serializable {
    @Basic(optional = false)
    @NotNull
    @Column(name = "Store_idStore")
    private int storeidStore;
    @Basic(optional = false)
    @NotNull
    @Column(name = "Product_idProduct")
    private int productidProduct;

元模型

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

    public static volatile SingularAttribute<Product, Double> cost;
    public static volatile SingularAttribute<Product, String> name;
    public static volatile SingularAttribute<Product, Integer> idProduct;
    public static volatile CollectionAttribute<Product, StoreHasProduct> storeHasProductCollection;

}

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

    public static volatile SingularAttribute<Store, String> name;
    public static volatile SingularAttribute<Store, Integer> idStore;
    public static volatile CollectionAttribute<Store, StoreHasProduct> storeHasProductCollection;

}

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

    public static volatile SingularAttribute<StoreHasProduct, Product> product;
    public static volatile SingularAttribute<StoreHasProduct, Short> active;
    public static volatile SingularAttribute<StoreHasProduct, Store> store;
    public static volatile SingularAttribute<StoreHasProduct, StoreHasProductPK> storeHasProductPK;

}

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

    public static volatile SingularAttribute<StoreHasProductPK, Integer> productidProduct;
    public static volatile SingularAttribute<StoreHasProductPK, Integer> storeidStore;

}

编辑*问题：是否可以将其用作规范？ 我什至不知道我是否对谓词做正确的事情，但这是我正在尝试的事情：

Integer resultsPerPage = 20;
    Sort.Direction sortOrder = Sort.Direction.DESC;
    String sortBy = "name";
    PageRequest request
            = new PageRequest(1 - 1, resultsPerPage, sortOrder, sortBy);
    Page<Product> prods = productRepository.findAll(where(productBelongsToStore("Tesco")), request);

    for (Product prod : prods.getContent()) {
        System.out.println(""+ prod.getName());
    }

规格：

public static Specification<Product> productBelongsToStore(final String searchTerm) {
    return new Specification<Product>() {
        @Override
        public Predicate toPredicate(Root<Product> root, CriteriaQuery<?> cq, CriteriaBuilder cb) {
            String likePattern = SpecificationUtilityMethods.getLikePattern(searchTerm);
            Root<Product> product = cq.from(Product.class);
            Join<Product, StoreHasProduct> storeHasProduct = product.join(Product_.storeHasProductCollection);
            Path<Store> storeName = storeHasProduct.get(StoreHasProduct_.store);
            return cb.like(cb.lower(storeName.<String>get(Store_.name)), likePattern);

        }
    };
}

输出：牛奶牛奶汁果汁谷物谷物黄油面包面包

哪有错

*对于尝试相同操作的任何人，我都通过删除“ Root product = cq.from（Product.class）;”来解决此问题。 并仅使用root参数。

Answer 1

请尝试以下操作：

CriteriaBuilder cb = entityManager.getCriteriaBuilder();
CriteriaQuery<Product> query = cb.createQuery(Product.class);

// "FROM Product p"
Root<Product> product = query.from(Product.class);
// "RIGHT JOIN store_has_product shp", "ON p.id_product=shp.id_product" is handled inside Product.class
Join<Product,StoreHasProduct> storeHasProduct = product.join(Product_.storeHasProductCollection);
// Create an alias to the shp.id_store column to use in the where condition
Path<Integer> id = storeHasProduct.get(StoreHasProduct_.storeHasProductPK).get(StoreHasProductPK_.storeidStore);
// "WHERE shp.id_store = 1"
query.where(cb.equal(id, 1));
// "SELECT p.*"
query.select(product);

TypedQuery<Product> tq = entityManager.createQuery(query);
for (Product p : tq.getResultList()) {
    // do stuff
}

这是从我的脑海中冒出来的，并且代码未经测试，所以我希望我没有犯任何重大错误。

也可以不使用元模型类来解决此问题，但是在将列名作为字符串输入时，您可能会犯错。 编译器无法捕获的内容。 使用元模型，编译器可以捕获更多否则可能会遗漏的错误。