SpringDataJPA 查询封装

最新推荐文章于 2024-08-13 11:07:45 发布

wang954066877

最新推荐文章于 2024-08-13 11:07:45 发布

阅读量1.3k

点赞数 1

文章标签： jpa

本文链接：https://blog.csdn.net/stupid_qb/article/details/79911164

版权

Git 地址：https://github.com/344399160/JPAManager

用过JPA查询应该都知道，实现下面接口去做查询是很痛苦的，简单的业务逻辑却要写几十行的代码，因此开始查阅各种资料，最终看了一位博主的文章后开始在他的基础上继续完善

@Override  
ublic Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) {

封装过程是参照Hibernate QBC查询做的，会QBC的同学就会这个的使用方法了，以下是一些例子，还有很多方法可以自己体验一下，如果不是做关联查询目前的功能可以涵盖大部分操作了

@Autowired  
private UserRepository userRepository;  
  
@Test  
public void getTObjectJson() {  
    Criteria<User> criteria = new Criteria<>();  
    criteria.add(Restrictions.eq("name", "test")); //等于 name = ‘test’  
    criteria.add(Restrictions.like("name", "test", Criterion.MatchMode.ANYWHERE)); //等于 name like %test%  
    criteria.add(Restrictions.between("age", 1 , 20));  //age between(1, 20)  
    criteria.add(Restrictions.isNotEmpty("name")); // ISNOTEMPTY(name)  
    List<String> list = new ArrayList();  
    list.add("Alice");  
    list.add("Mick");  
    criteria.add(Restrictions.in("name", list));  // name in ('Alice','Mick')  
  
    criteria.add(Restrictions.eq(Projections.Length("name"), 5));  // length(name) = 5  
    criteria.add(Restrictions.gt(Projections.Max("name"), 5));  // max(name) = 5  
    criteria.add(Restrictions.or(Restrictions.eq("name", "tt"),Restrictions.eq("name", "qq"))); //(name = 'tt' or name = 'qq')  
    List<User> userList = userRepository.findAll(criteria);  
}

以下是封装代码，当时项目急用所以封装的挺粗糙的，谈不上代码美观高效。望勿怪，但是还蛮好用的，一年多了一直在用，如果有好的建议也希望能提出来，不过该封装有个问题，就是不能实现多表联查，这个挺头疼的。

 
 import java.util.ArrayList;  
import java.util.List;  
  
import javax.persistence.criteria.CriteriaBuilder;  
import javax.persistence.criteria.CriteriaQuery;  
import javax.persistence.criteria.Predicate;  
import javax.persistence.criteria.Root;  
  
import org.apache.commons.lang.StringUtils;  
import org.springframework.data.jpa.domain.Specification;  
/**  
 * 定义一个查询条件容器  
 *  
 * @param <T>  
 */    
public class Criteria<T> implements Specification<T>{  
    //查询条件容器  
    private List<Criterion> criterions = new ArrayList<Criterion>();    
    //倒序查询条件  
    private String orderByDESC;  
    //升序查询条件  
    private String orderByASC;  
    //group查询条件  
    private String groupBy;  
        
    public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query,    
            CriteriaBuilder builder) {    
        if(!StringUtils.isEmpty(orderByASC))  
            query.orderBy(builder.desc(root.get(getOrderByASC())));  
        if(!StringUtils.isEmpty(orderByDESC))  
            query.orderBy(builder.desc(root.get(getOrderByDESC())));  
        if(!StringUtils.isEmpty(groupBy))  
            query.groupBy(root.get(getGroupBy()));  
        if (!criterions.isEmpty()) {    
            List<Predicate> predicates = new ArrayList<Predicate>();    
            for(Criterion c : criterions){    
                predicates.add(c.toPredicate(root, query,builder));    
            }  
            // 将所有条件用 and 联合起来    
            if (predicates.size() > 0) {    
                return builder.and(predicates.toArray(new Predicate[predicates.size()]));    
            }    
        }    
        return builder.conjunction();    
    }    
    /**  
     * 增加简单条件表达式  
     * @Methods Name add  
     *  
     */    
    public void add(Criterion criterion){    
        if(criterion!=null){    
            criterions.add(criterion);    
        }    
    }    
      
    public void orderByDESC(String col){  
        setOrderByDESC(col);  
    }  
      
    public void orderByASC(String col){  
        setOrderByASC(col);  
    }  
      
    public void groupBy(String col){  
        setGroupBy(col);  
    }  
      
      
    public String getOrderByDESC() {  
        return orderByDESC;  
    }  
    private void setOrderByDESC(String orderByDESC) {  
        this.orderByDESC = orderByDESC;  
    }  
    public String getOrderByASC() {  
        return orderByASC;  
    }  
    private void setOrderByASC(String orderByASC) {  
        this.orderByASC = orderByASC;  
    }  
    public String getGroupBy() {  
        return groupBy;  
    }  
    private void setGroupBy(String groupBy) {  
        this.groupBy = groupBy;  
    }  
 

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
/**
* 条件接口
* 用户提供条件表达式接口
*/
public interface Criterion {
public enum Operator {
EQ, NE, LIKE, GT, LT, GTE, LTE, AND, OR, BETWEEN, ISNULL, ISNOTNULL, ISEMPTY, ISNOTEMPTY
}
public enum MatchMode {
START, END, ANYWHERE
}
public enum Projection {
MAX, MIN, AVG, LENGTH, SUM, COUNT
}
public Predicate toPredicate(Root<?> root, CriteriaQuery<?> query,
CriteriaBuilder builder);
}

 
 import java.util.ArrayList;  
import java.util.List;  
  
import javax.persistence.criteria.CriteriaBuilder;  
import javax.persistence.criteria.CriteriaQuery;  
import javax.persistence.criteria.Expression;  
import javax.persistence.criteria.Predicate;  
import javax.persistence.criteria.Root;  
  
import org.springframework.util.StringUtils;  
  
/**  
 * 逻辑条件表达式 用于复杂条件时使用，如但属性多对应值的OR查询等  
 *  
 */    
public class LogicalExpression implements Criterion {  
    private Criterion[] criterion;  // 逻辑表达式中包含的表达式    
    private Operator operator;      //计算符  
    private String col;  
    private Object exp1;  
    private Object exp2;  
        
    public LogicalExpression(Criterion[] criterions, Operator operator) {    
        this.criterion = criterions;    
        this.operator = operator;    
    }    
      
    //between用构造方法  
    public LogicalExpression(String col, Object exp1, Object exp2, Operator operator){  
        this.col = col;  
        this.exp1 = exp1;  
        this.exp2 = exp2;  
        this.operator = operator;  
        this.criterion = null;  
    }  
      
    public Predicate toPredicate(Root<?> root, CriteriaQuery<?> query,    
            CriteriaBuilder builder) {    
        List<Predicate> predicates = new ArrayList<Predicate>();    