Question

早上好，我正在尝试使用Hibernate Criteria创建一个从MySQL数据库返回多个游戏的方法。该方法接收一个Product对象，该对象可以有多个null参数。我现在正在使用Hibernate 5.2。

我的产品类是：

@Entity
@Table(name = "Producto", catalog = "gzone")
public class Producto {

private Long idProducto = null;
private String nombre = null;
private Double precio = null;
private Integer anio = null;
private String requisitos = null;
private Oferta oferta = null;

private Set<Producto_Idioma> producto_idioma = new HashSet<Producto_Idioma>(0);

private List<Categoria> categorias = null;
private List<NJugadores> njugadores = null;
private List<Idioma> idioma = null;

public Producto () {
    categorias = new ArrayList<Categoria>();
    idioma = new ArrayList<Idioma>();
    njugadores = new ArrayList<NJugadores>();
}

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "id_producto", unique = true, nullable = false)
public Long getIdProducto() {
    return idProducto;
}

public void setIdProducto(Long idProducto) {
    this.idProducto = idProducto;
}

@Column(name = "nombre", unique = false, nullable = false)
public String getNombre() {
    return nombre;
}

public void setNombre(String nombre) {
    this.nombre = nombre;
}

@Column(name = "precio", unique = false, nullable = false)
public Double getPrecio() {
    return precio;
}

public void setPrecio(Double precio) {
    this.precio = precio;
}

@Column(name = "anio", unique = false, nullable = false)
public Integer getAnio() {
    return anio;
}

public void setAnio(Integer i) {
    this.anio = i;
}

@Column(name = "requisitos", unique = false, nullable = true)
public String getRequisitos() {
    return requisitos;
}

public void setRequisitos(String requisitos) {
    this.requisitos = requisitos;
}

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "id_oferta", nullable = false)
public Oferta getOferta() {
    return oferta;
}

public void setOferta(Oferta oferta) {
    this.oferta = oferta;
}

@ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
@JoinTable(name = "Producto_Categoria", catalog = "gzone", joinColumns = {
@JoinColumn(name = "id_producto", nullable = false, updatable = false) },
        inverseJoinColumns = { @JoinColumn(name = "id_categoria",
                nullable = false, updatable = false) })
public List<Categoria> getCategorias() {
    return categorias;
}

public void setCategorias(List<Categoria> categorias) {
    this.categorias = categorias;
}

@ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
@JoinTable(name = "Producto_NJugadores", catalog = "gzone", joinColumns = {
@JoinColumn(name = "id_producto", nullable = false, updatable = false) },
        inverseJoinColumns = { @JoinColumn(name = "id_njugador",
                nullable = false, updatable = false) })
public List<NJugadores> getNjugadores() {
    return njugadores;
}

public void setNjugadores(List<NJugadores> njugadores) {
    this.njugadores = njugadores;
}

@ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
@JoinTable(name = "Producto_Idioma_Disponible", catalog = "gzone", joinColumns = {
@JoinColumn(name = "id_producto", nullable = false, updatable = false) },
        inverseJoinColumns = { @JoinColumn(name = "id_idioma",
                nullable = false, updatable = false) })
public List<Idioma> getIdioma() {
    return idioma;
}

public void setIdioma(List<Idioma> idioma) {
    this.idioma = idioma;
}

@OneToMany(fetch = FetchType.LAZY, mappedBy = "pk.producto")
public Set<Producto_Idioma> getProducto_Idioma() {
    return this.producto_idioma;
}

public void setProducto_Idioma(Set<Producto_Idioma> producto_idioma) {
    this.producto_idioma = producto_idioma;
}

}

这是Hibernate Criteria代码：

@Override
    public List<Producto> findByCriteria(Session session, ProductoCriteria productoCriteria, int startIndex, int count, String idioma)
            throws DataException {

        try {

             CriteriaBuilder builder = session.getCriteriaBuilder();

             Join<Producto, Oferta> ofertaJoin = null;
             Join<Producto, Categoria> categoriaJoin = null;
             Join<Producto, Idioma> idiomaJoin = null;
             Join<Producto, NJugadores> jugadoresJoin = null;

             CriteriaQuery<Producto> criteria = builder.createQuery( Producto.class );
             // Seleccionamos la tabla orgien (En este caso producto)
             Root<Producto> producto = criteria.from( Producto.class );

             //Seleccionamos la tabla producto
             criteria.select(producto);

             // Hacemos un JOIN de la tabla oferta que es una @ManyToOne
             if (productoCriteria.getOferta()!=null) 
                 ofertaJoin = producto.join(ParameterNamesCriteria.OFERTA);

             // Hacemos un JOIN de la tabla oferta que es una @ManyToMany
             if (!productoCriteria.getCategorias().isEmpty()) 
                 categoriaJoin = producto.join(ParameterNamesCriteria.CATEGORIA);         

             // Hacemos un JOIN de la tabla idioma que es una @ManyToMany
             if (!productoCriteria.getIdioma().isEmpty()) 
                 idiomaJoin = producto.join(ParameterNamesCriteria.IDIOMA);          

             // Hacemos un JOIN de la tabla idioma que es una @ManyToMany
             if (!productoCriteria.getNjugadores().isEmpty()) 
                 jugadoresJoin = producto.join(ParameterNamesCriteria.NJUGADODRES);


             /*
             *   Inserciones de las clausulas where        
             */  

             //Hacemos un where para buscar por id de producto
             if (productoCriteria.getIdProducto()!=null)
                 criteria.where(builder.equal(producto.get(ParameterNamesCriteria.PID), productoCriteria.getIdProducto()));

             //Hacemos un where para buscar por nombre
             if (productoCriteria.getNombre()!=null)  
                 builder.equal(producto.get(ParameterNamesCriteria.PNOMBRE), "%"+productoCriteria.getNombre()+"%");

             //Hacemos un where para buscar por año
             if (productoCriteria.getAnio()!=null) 
                 builder.equal(producto.get(ParameterNamesCriteria.PANIO), productoCriteria.getAnio());

             //Hacemos un where para buscar por precio
             if (productoCriteria.getPrecio()!=null)
                 criteria.where(builder.equal(producto.get(ParameterNamesCriteria.PPRECIO), productoCriteria.getPrecio()));

//           //Hacemos un where para buscar por oferta
//           if (productoCriteria.getOferta()!=null) 
//               criteria.select(producto).where(builder.equal(ofertaJoin.get(ParameterNamesCriteria.OID), productoCriteria.getOferta()));
//           
//           //Hacemos un where para buscar por categoria
//           if (!productoCriteria.getCategorias().isEmpty())            
//               criteria.select(producto).where(builder.equal(categoriaJoin.get(ParameterNamesCriteria.CID), productoCriteria.getCategorias()));

//           //Hacemos un where para buscar por njugadores
//           if (!productoCriteria.getNjugadores().isEmpty()) 
//               criteria.select(producto).where(builder.equal(jugadoresJoin.get(ParameterNamesCriteria.INJ), productoCriteria.getNjugadores()));
//           
//           //Hacemos un where para buscar por idioma
//           if (!productoCriteria.getIdioma().isEmpty()) 
//               criteria.select(producto).where(builder.equal(idiomaJoin.get(ParameterNamesCriteria.IID), idioma));


//           //Hacemos un where para internazionalizar la búsqueda
//           if (idioma!=null) 
//               criteria.select(producto).where(builder.equal(idiomaJoin.get(ParameterNamesCriteria.IID), idioma));
//           
             TypedQuery<Producto> mostrar = session.createQuery(criteria);


             List<Producto> productos=mostrar.getResultList();

//          if (idioma!=null) {
//              addClause(queryString, first, " pi.id_idioma LIKE ? ");
//              first = false;
//          }

            return productos;

            } finally {
                session.close();
        }
    }

当我尝试使用2个或更多＆＃34;限制时出现我的问题＆＃34;做一个特定的搜索。在这种情况下，如果我向产品引入2个或更多值（例如，idProducto和anio（游戏的发行年）），我的标准不会附加这两个限制，仅使用我使用的最后一个执行sql查询，在这种情况下，＆＃34; anio＆＃34;。

所以我问我怎么能同时检查我收到的参数是否为null，在第二种情况下，将criteria.select(producto).where(builder.equal..附加到我的sql查询中。

非常感谢你的时间。

Answer 1

尝试创建谓词并将其添加到条件中：谓词条件= builder.equal（...）; criteria.add（条件）; - Fran Montero 23小时前

Hibernate Criteria多个在哪里

1 个答案: