Java 使用参数从JPQL查询中选择全部

我在平面数据上有选择参数，只是不知道如何完全省略一个参数，或者使它成为一个完整的通配符。搜索可能使用一个或所有参数。这是怎么做到的？使用

ANY

或

ALL

？或者，还有别的办法吗

我想对所有参数使用一个通用查询，并为这些参数中的一些参数传递“all”或“any”

现行守则：

package legacy.database;

import java.sql.Timestamp;
import java.util.List;
import java.util.logging.Logger;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

public class MyQueries {

    private static final Logger log = Logger.getLogger(MyQueries.class.getName());
    private final EntityManagerFactory emf = Persistence.createEntityManagerFactory("LegacyDatabasePU");
    private final EntityManager em = emf.createEntityManager();

    public MyQueries() {
    }

    public List<Clients> findAll() {
        Query q = em.createQuery("select c from Clients c");
       List<Clients> clients = q.getResultList();
        return clients;
    }

    public List<Clients> selectWithParameters(Criteria c) {
        log.info(c.toString());
        String opener = c.getOpener();
        String closer1 = c.getCloser1();
        String status = c.getStatus();
        Query q = em.createQuery(
                "SELECT c FROM Clients c "
                + "WHERE c.status like :status "
                + "and c.closer1 like :closer1 "
                + "and c.opener like :opener");
        q.setParameter("opener", opener);
        q.setParameter("closer1", closer1);
        q.setParameter("status", status);
        log.info(q.toString());
        List<Clients> clients = q.getResultList();
        log.fine(clients.toString());
        return clients;
    }

    public Clients findById(int id) {
        Clients client = em.find(Clients.class, id);
        return client;
    }

    public void send(int id) {
        Clients c = em.find(Clients.class, id);
        java.util.Date date = new java.util.Date();
        Timestamp t = new Timestamp(date.getTime());
        em.getTransaction().begin();
        c.setDateUpdated(t.toString());
        em.getTransaction().commit();
    }
}

package legacy.database；
导入java.sql.Timestamp；
导入java.util.List；
导入java.util.logging.Logger；
导入javax.persistence.EntityManager；
导入javax.persistence.EntityManagerFactory；
导入javax.persistence.persistence；
导入javax.persistence.Query；
公共类MyQueries{
私有静态最终记录器log=Logger.getLogger（myquerys.class.getName（））；
私有最终EntityManagerFactory emf=Persistence.createEntityManagerFactory（“LegacyDatabasePU”）；
私有最终EntityManager em=emf.createEntityManager（）；
公共查询（）{
}
公共列表findAll（）{
Query q=em.createQuery（“从客户机c中选择c”）；
List clients=q.getResultList（）；
返回客户；
}
公共列表选择参数（标准c）{
log.info（c.toString（））；
String opener=c.getOpener（）；
字符串closer1=c.getCloser1（）；
字符串状态=c.getStatus（）；
Query q=em.createQuery(
“从客户端c中选择c”
+“其中c.状态，如：状态”
+“和c.closer1类似：closer1”
+“和c.opener类似：opener”）；
q、 设置参数（“开启器”，开启器）；
q、 设置参数（“closer1”，closer1）；
q、 设置参数（“状态”，状态）；
log.info（q.toString（））；
List clients=q.getResultList（）；
log.fine（clients.toString（））；
返回客户；
}
公共客户端findById（int-id）{
Clients client=em.find（Clients.class，id）；
返回客户；
}
公共无效发送（int id）{
Clients c=em.find（Clients.class，id）；
java.util.Date Date=新建java.util.Date（）；
Timestamp t=新的时间戳（date.getTime（））；
em.getTransaction（）.begin（）；
c、 setDateUpdated（t.toString（））；
em.getTransaction（）.commit（）；
}
}

如果参数是可选的，则criteria API提供了更大的灵活性。 如果调用StUSETUE参数经常调用，则考虑使用参数，因为DB可以缓存参数化查询。 选择带有可选参数的WithParameters如下所示：

public List<Clients> selectWithParameters(Criteria criteria) {
    log.info(criteria.toString());
    String opener = criteria.getOpener();
    String closer1 = criteria.getCloser1();
    String status = criteria.getStatus();

    CriteriaBuilder criteriaBuilder = em.getCriteriaBuilder();
    CriteriaQuery<Clients> query = criteriaBuilder.createQuery(Clients.class);
    Root<Clients> c = query.from(Clients.class);
    List<Predicate> wherePredicates = new LinkedList<Predicate>();
    if (null != status) {
        wherePredicates.add(criteriaBuilder.like(c.get("status"), status));
    }
    if (null != closer1) {
        wherePredicates.add(criteriaBuilder.like(c.get("closer1"), closer1));
    }
    if (null != opener) {
        wherePredicates.add(criteriaBuilder.like(c.get("opener"), opener));
    }
    query.where(wherePredicates.toArray(new Predicate[0]));

    List<Clients> clients = em.createQuery(query).getResultList();
    log.fine(clients.toString());
    return clients;
}

public List selectWithParameters（标准）{
log.info（criteria.toString（））；
String opener=criteria.getOpener（）；
字符串closer1=criteria.getCloser1（）；
字符串状态=criteria.getStatus（）；
CriteriaBuilder CriteriaBuilder=em.getCriteriaBuilder（）；
CriteriaQuery=criteriaBuilder.createQuery（Clients.class）；
Root c=query.from（Clients.class）；
List wherePredicates=newlinkedlist（）；
如果（空！=状态）{
add（criteriaBuilder.like（c.get（“status”），status））；
}
如果（空！=closer1）{
add（criteriaBuilder.like（c.get（“closer1”），closer1））；
}
如果（空！=开启器）{
add（criteriaBuilder.like（c.get（“opener”），opener））；
}
query.where（wherePredicates.toArray（新谓词[0]）；
List clients=em.createQuery（query.getResultList（）；
log.fine（clients.toString（））；
返回客户；
}
谢谢你，海纳。这是可行的，我不知道为什么我在使用Heiner的代码时会遇到问题，但他的示例为我指明了正确的方向：

public List<Clients> selectByCriteria(Criteria criteria) {
    CriteriaBuilder criteriaBuilder = em.getCriteriaBuilder();
    CriteriaQuery<Clients> clientCriteriaQuery = criteriaBuilder.createQuery(Clients.class);
    Root<Clients> clientRoot = clientCriteriaQuery.from(Clients.class);
    clientCriteriaQuery.select(clientRoot);
    List<Predicate> predicates = new ArrayList<>();
    predicates.add(criteriaBuilder.like(clientRoot.get(Clients_.phone1), "%" + criteria.getPhone1() + "%"));
    if (!criteria.getOpener().equalsIgnoreCase("all")) {
        predicates.add(criteriaBuilder.like(clientRoot.get(Clients_.opener), "%" + criteria.getOpener() + "%"));
    }
    if (!criteria.getCloser1().equalsIgnoreCase("all")) {
        predicates.add(criteriaBuilder.like(clientRoot.get(Clients_.closer1), "%" + criteria.getCloser1() + "%"));
    }
    if (!criteria.getStatus().equalsIgnoreCase("all")) {
        predicates.add(criteriaBuilder.like(clientRoot.get(Clients_.status), "%" + criteria.getStatus() + "%"));
    }
    clientCriteriaQuery.where(predicates.toArray(new Predicate[0]));
    List<Clients> clients = em.createQuery(clientCriteriaQuery).getResultList();
    return clients;
}

公共列表selectByCriteria（标准）{
CriteriaBuilder CriteriaBuilder=em.getCriteriaBuilder（）；
CriteriaQuery clientCriteriaQuery=criteriaBuilder.createQuery（Clients.class）；
Root clientRoot=clientCriteriaQuery.from（Clients.class）；
clientCriteriaQuery.select（clientRoot）；
列表谓词=新的ArrayList（）；
add（criteriaBuilder.like（clientRoot.get（Clients.phone1），“%”+criteria.getPhone1（）+“%”）；
如果（！criteria.getOpener（）.equalsIgnoreCase（“全部”））{
add（criteriaBuilder.like（clientRoot.get（Clients.opener），“%”+criteria.getOpener（）+“%”）；
}
如果（！criteria.getCloser1（）.equalsIgnoreCase（“全部”））{
add（criteriaBuilder.like（clientRoot.get（Clients.closer1），“%”+criteria.getCloser1（）+“%”）；
}
如果（！criteria.getStatus（）.equalsIgnoreCase（“全部”））{
add（criteriaBuilder.like（clientRoot.get（Clients.status），“%”+criteria.getStatus（）+“%”）；
}
clientCriteriaQuery.where（谓词.toArray（新谓词[0]）；
List clients=em.createQuery（clientCriteriaQuery）.getResultList（）；
返回客户；
}

与海纳的回答可能没有实质性的区别。JPA和JPQL有点模糊。我不敢相信，但我几乎更喜欢SQL！我得调整一下