Srping Data Jpa条件查询封装
2014-09-08 16:49
411 查看
Java代码
/**
* 定义一个查询条件容器
* @author lee
*
* @param <T>
*/
public class Criteria<T> implements Specification<T>{
private List<Criterion> criterions = new ArrayList<Criterion>();
public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query,
CriteriaBuilder builder) {
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
* @Create In 2012-2-8 By lee
* @param expression0 void
*/
public void add(Criterion criterion){
if(criterion!=null){
criterions.add(criterion);
}
}
}
然后是各种条件组装类,我首先做了一个接口来包装各种条件
Java代码
/**
* 条件接口
* 用户提供条件表达式接口
* @Class Name Criterion
* @Author lee
* @Create In 2012-2-8
*/
public interface Criterion {
public enum Operator {
EQ, NE, LIKE, GT, LT, GTE, LTE, AND, OR
}
public Predicate toPredicate(Root<?> root, CriteriaQuery<?> query,
CriteriaBuilder builder);
}
然后是针对不同类型条件处理的实现
一个是简单比较类型的处理
Java代码
/**
* 简单条件表达式
* @author lee
*
*/
public class SimpleExpression implements Criterion{
private String fieldName; //属性名
private Object value; //对应值
private Operator operator; //计算符
protected SimpleExpression(String fieldName, Object value, Operator operator) {
this.fieldName = fieldName;
this.value = value;
this.operator = operator;
}
public String getFieldName() {
return fieldName;
}
public Object getValue() {
return value;
}
public Operator getOperator() {
return operator;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
public Predicate toPredicate(Root<?> root, CriteriaQuery<?> query,
CriteriaBuilder builder) {
Path expression = null;
if(fieldName.contains(".")){
String[] names = StringUtils.split(fieldName, ".");
expression = root.get(names[0]);
for (int i = 1; i < names.length; i++) {
expression = expression.get(names[i]);
}
}else{
expression = root.get(fieldName);
}
switch (operator) {
case EQ:
return builder.equal(expression, value);
case NE:
return builder.notEqual(expression, value);
case LIKE:
return builder.like((Expression<String>) expression, "%" + value + "%");
case LT:
return builder.lessThan(expression, (Comparable) value);
case GT:
return builder.greaterThan(expression, (Comparable) value);
case LTE:
return builder.lessThanOrEqualTo(expression, (Comparable) value);
case GTE:
return builder.greaterThanOrEqualTo(expression, (Comparable) value);
default:
return null;
}
}
}
一个逻辑条件计算实现
Java代码
/**
* 逻辑条件表达式 用于复杂条件时使用,如但属性多对应值的OR查询等
* @author lee
*
*/
public class LogicalExpression implements Criterion {
private Criterion[] criterion; // 逻辑表达式中包含的表达式
private Operator operator; //计算符
public LogicalExpression(Criterion[] criterions, Operator operator) {
this.criterion = criterions;
this.operator = operator;
}
public Predicate toPredicate(Root<?> root, CriteriaQuery<?> query,
CriteriaBuilder builder) {
List<Predicate> predicates = new ArrayList<Predicate>();
for(int i=0;i<this.criterion.length;i++){
predicates.add(this.criterion[i].toPredicate(root, query, builder));
}
switch (operator) {
case OR:
return builder.or(predicates.toArray(new Predicate[predicates.size()]));
default:
return null;
}
}
}
添加一个组装工厂类
Java代码
/**
* 条件构造器
* 用于创建条件表达式
* @Class Name Restrictions
* @Author lee
*/
public class Restrictions {
/**
* 等于
* @param fieldName
* @param value
* @param ignoreNull
* @return
*/
public static SimpleExpression eq(String fieldName, Object value, boolean ignoreNull) {
if(StringUtils.isEmpty(value))return null;
return new SimpleExpression (fieldName, value, Operator.EQ);
}
/**
* 不等于
* @param fieldName
* @param value
* @param ignoreNull
* @return
*/
public static SimpleExpression ne(String fieldName, Object value, boolean ignoreNull) {
if(StringUtils.isEmpty(value))return null;
return new SimpleExpression (fieldName, value, Operator.NE);
}
/**
* 模糊匹配
* @param fieldName
* @param value
* @param ignoreNull
* @return
*/
public static SimpleExpression like(String fieldName, String value, boolean ignoreNull) {
if(StringUtils.isEmpty(value))return null;
return new SimpleExpression (fieldName, value, Operator.LIKE);
}
/**
*
* @param fieldName
* @param value
* @param matchMode
* @param ignoreNull
* @return
*/
public static SimpleExpression like(String fieldName, String value,
MatchMode matchMode, boolean ignoreNull) {
if(StringUtils.isEmpty(value))return null;
return null;
}
/**
* 大于
* @param fieldName
* @param value
* @param ignoreNull
* @return
*/
public static SimpleExpression gt(String fieldName, Object value, boolean ignoreNull) {
if(StringUtils.isEmpty(value))return null;
return new SimpleExpression (fieldName, value, Operator.GT);
}
/**
* 小于
* @param fieldName
* @param value
* @param ignoreNull
* @return
*/
public static SimpleExpression lt(String fieldName, Object value, boolean ignoreNull) {
if(StringUtils.isEmpty(value))return null;
return new SimpleExpression (fieldName, value, Operator.LT);
}
/**
* 大于等于
* @param fieldName
* @param value
* @param ignoreNull
* @return
*/
public static SimpleExpression lte(String fieldName, Object value, boolean ignoreNull) {
if(StringUtils.isEmpty(value))return null;
return new SimpleExpression (fieldName, value, Operator.GTE);
}
/**
* 小于等于
* @param fieldName
* @param value
* @param ignoreNull
* @return
*/
public static SimpleExpression gte(String fieldName, Object value, boolean ignoreNull) {
if(StringUtils.isEmpty(value))return null;
return new SimpleExpression (fieldName, value, Operator.LTE);
}
/**
* 并且
* @param criterions
* @return
*/
public static LogicalExpression and(Criterion... criterions){
return new LogicalExpression(criterions, Operator.AND);
}
/**
* 或者
* @param criterions
* @return
*/
public static LogicalExpression or(Criterion... criterions){
return new LogicalExpression(criterions, Operator.OR);
}
/**
* 包含于
* @param fieldName
* @param value
* @return
*/
@SuppressWarnings("rawtypes")
public static LogicalExpression in(String fieldName, Collection value, boolean ignoreNull) {
if(ignoreNull&&(value==null||value.isEmpty())){
return null;
}
SimpleExpression[] ses = new SimpleExpression[value.size()];
int i=0;
for(Object obj : value){
ses[i]=new SimpleExpression(fieldName,obj,Operator.EQ);
i++;
}
return new LogicalExpression(ses,Operator.OR);
}
}
使用方法如下
Java代码
Criteria<Event> c = new Criteria<Event>();
c.add(Restrictions.like("code", searchParam.getCode(), true));
c.add(Restrictions.eq("level", searchParam.getLevel(), false));
c.add(Restrictions.eq("mainStatus", searchParam.getMainStatus(), true));
c.add(Restrictions.eq("flowStatus", searchParam.getFlowStatus(), true));
c.add(Restrictions.eq("createUser.userName", searchParam.getCreateUser(), true));
c.add(Restrictions.lte("submitTime", searchParam.getStartSubmitTime(), true));
c.add(Restrictions.gte("submitTime", searchParam.getEndSubmitTime(), true));
c.add(Restrictions.eq("needFollow", searchParam.getIsfollow(), true));
c.add(Restrictions.ne("flowStatus", CaseConstants.CASE_STATUS_DRAFT, true));
c.add(Restrictions.in("solveTeam.code",teamCodes, true));
eventDao.findAll(c);
/**
* 定义一个查询条件容器
* @author lee
*
* @param <T>
*/
public class Criteria<T> implements Specification<T>{
private List<Criterion> criterions = new ArrayList<Criterion>();
public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query,
CriteriaBuilder builder) {
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
* @Create In 2012-2-8 By lee
* @param expression0 void
*/
public void add(Criterion criterion){
if(criterion!=null){
criterions.add(criterion);
}
}
}
然后是各种条件组装类,我首先做了一个接口来包装各种条件
Java代码
/**
* 条件接口
* 用户提供条件表达式接口
* @Class Name Criterion
* @Author lee
* @Create In 2012-2-8
*/
public interface Criterion {
public enum Operator {
EQ, NE, LIKE, GT, LT, GTE, LTE, AND, OR
}
public Predicate toPredicate(Root<?> root, CriteriaQuery<?> query,
CriteriaBuilder builder);
}
然后是针对不同类型条件处理的实现
一个是简单比较类型的处理
Java代码
/**
* 简单条件表达式
* @author lee
*
*/
public class SimpleExpression implements Criterion{
private String fieldName; //属性名
private Object value; //对应值
private Operator operator; //计算符
protected SimpleExpression(String fieldName, Object value, Operator operator) {
this.fieldName = fieldName;
this.value = value;
this.operator = operator;
}
public String getFieldName() {
return fieldName;
}
public Object getValue() {
return value;
}
public Operator getOperator() {
return operator;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
public Predicate toPredicate(Root<?> root, CriteriaQuery<?> query,
CriteriaBuilder builder) {
Path expression = null;
if(fieldName.contains(".")){
String[] names = StringUtils.split(fieldName, ".");
expression = root.get(names[0]);
for (int i = 1; i < names.length; i++) {
expression = expression.get(names[i]);
}
}else{
expression = root.get(fieldName);
}
switch (operator) {
case EQ:
return builder.equal(expression, value);
case NE:
return builder.notEqual(expression, value);
case LIKE:
return builder.like((Expression<String>) expression, "%" + value + "%");
case LT:
return builder.lessThan(expression, (Comparable) value);
case GT:
return builder.greaterThan(expression, (Comparable) value);
case LTE:
return builder.lessThanOrEqualTo(expression, (Comparable) value);
case GTE:
return builder.greaterThanOrEqualTo(expression, (Comparable) value);
default:
return null;
}
}
}
一个逻辑条件计算实现
Java代码
/**
* 逻辑条件表达式 用于复杂条件时使用,如但属性多对应值的OR查询等
* @author lee
*
*/
public class LogicalExpression implements Criterion {
private Criterion[] criterion; // 逻辑表达式中包含的表达式
private Operator operator; //计算符
public LogicalExpression(Criterion[] criterions, Operator operator) {
this.criterion = criterions;
this.operator = operator;
}
public Predicate toPredicate(Root<?> root, CriteriaQuery<?> query,
CriteriaBuilder builder) {
List<Predicate> predicates = new ArrayList<Predicate>();
for(int i=0;i<this.criterion.length;i++){
predicates.add(this.criterion[i].toPredicate(root, query, builder));
}
switch (operator) {
case OR:
return builder.or(predicates.toArray(new Predicate[predicates.size()]));
default:
return null;
}
}
}
添加一个组装工厂类
Java代码
/**
* 条件构造器
* 用于创建条件表达式
* @Class Name Restrictions
* @Author lee
*/
public class Restrictions {
/**
* 等于
* @param fieldName
* @param value
* @param ignoreNull
* @return
*/
public static SimpleExpression eq(String fieldName, Object value, boolean ignoreNull) {
if(StringUtils.isEmpty(value))return null;
return new SimpleExpression (fieldName, value, Operator.EQ);
}
/**
* 不等于
* @param fieldName
* @param value
* @param ignoreNull
* @return
*/
public static SimpleExpression ne(String fieldName, Object value, boolean ignoreNull) {
if(StringUtils.isEmpty(value))return null;
return new SimpleExpression (fieldName, value, Operator.NE);
}
/**
* 模糊匹配
* @param fieldName
* @param value
* @param ignoreNull
* @return
*/
public static SimpleExpression like(String fieldName, String value, boolean ignoreNull) {
if(StringUtils.isEmpty(value))return null;
return new SimpleExpression (fieldName, value, Operator.LIKE);
}
/**
*
* @param fieldName
* @param value
* @param matchMode
* @param ignoreNull
* @return
*/
public static SimpleExpression like(String fieldName, String value,
MatchMode matchMode, boolean ignoreNull) {
if(StringUtils.isEmpty(value))return null;
return null;
}
/**
* 大于
* @param fieldName
* @param value
* @param ignoreNull
* @return
*/
public static SimpleExpression gt(String fieldName, Object value, boolean ignoreNull) {
if(StringUtils.isEmpty(value))return null;
return new SimpleExpression (fieldName, value, Operator.GT);
}
/**
* 小于
* @param fieldName
* @param value
* @param ignoreNull
* @return
*/
public static SimpleExpression lt(String fieldName, Object value, boolean ignoreNull) {
if(StringUtils.isEmpty(value))return null;
return new SimpleExpression (fieldName, value, Operator.LT);
}
/**
* 大于等于
* @param fieldName
* @param value
* @param ignoreNull
* @return
*/
public static SimpleExpression lte(String fieldName, Object value, boolean ignoreNull) {
if(StringUtils.isEmpty(value))return null;
return new SimpleExpression (fieldName, value, Operator.GTE);
}
/**
* 小于等于
* @param fieldName
* @param value
* @param ignoreNull
* @return
*/
public static SimpleExpression gte(String fieldName, Object value, boolean ignoreNull) {
if(StringUtils.isEmpty(value))return null;
return new SimpleExpression (fieldName, value, Operator.LTE);
}
/**
* 并且
* @param criterions
* @return
*/
public static LogicalExpression and(Criterion... criterions){
return new LogicalExpression(criterions, Operator.AND);
}
/**
* 或者
* @param criterions
* @return
*/
public static LogicalExpression or(Criterion... criterions){
return new LogicalExpression(criterions, Operator.OR);
}
/**
* 包含于
* @param fieldName
* @param value
* @return
*/
@SuppressWarnings("rawtypes")
public static LogicalExpression in(String fieldName, Collection value, boolean ignoreNull) {
if(ignoreNull&&(value==null||value.isEmpty())){
return null;
}
SimpleExpression[] ses = new SimpleExpression[value.size()];
int i=0;
for(Object obj : value){
ses[i]=new SimpleExpression(fieldName,obj,Operator.EQ);
i++;
}
return new LogicalExpression(ses,Operator.OR);
}
}
使用方法如下
Java代码
Criteria<Event> c = new Criteria<Event>();
c.add(Restrictions.like("code", searchParam.getCode(), true));
c.add(Restrictions.eq("level", searchParam.getLevel(), false));
c.add(Restrictions.eq("mainStatus", searchParam.getMainStatus(), true));
c.add(Restrictions.eq("flowStatus", searchParam.getFlowStatus(), true));
c.add(Restrictions.eq("createUser.userName", searchParam.getCreateUser(), true));
c.add(Restrictions.lte("submitTime", searchParam.getStartSubmitTime(), true));
c.add(Restrictions.gte("submitTime", searchParam.getEndSubmitTime(), true));
c.add(Restrictions.eq("needFollow", searchParam.getIsfollow(), true));
c.add(Restrictions.ne("flowStatus", CaseConstants.CASE_STATUS_DRAFT, true));
c.add(Restrictions.in("solveTeam.code",teamCodes, true));
eventDao.findAll(c);
相关文章推荐
- 【spring data jpa】带有条件的查询后分页和不带条件查询后分页实现
- 【spring data jpa】带有条件的查询后分页和不带条件查询后分页实现
- Spring Data JPA实现动态条件与范围查询实例代码
- SpringDataJPA学习记录(三)--复杂查询的封装
- spring data jpa的多条件查询
- SpringDataJPA学习记录(三)--复杂查询的封装
- spring-data-jpa 多条件查询 学习记录
- 【spring data jpa】带有条件的查询后分页和不带条件查询后分页实现
- spring data jpa 多表多条件查询
- 关于Spring data JPA 如何使用条件查询。
- 【java】spring-data-jpa 集成hibernate实现多条件分页查询
- spring data jpa 条件分页查询
- Spring data jpa 多表查询(一:单表动态条件查询)
- spring data jpa的动态查询封装(转)
- Spring data jpa 多表查询(二:多表动态条件查询)
- Spring Data JPA 复杂/多条件组合查询
- spring-data-jpa动态条件查询
- Spring Data JPA 复杂/多条件组合分页查询
- Spring MVC结合Spring Data JPA实现按条件查询和分页
- Spring MVC和Spring Data JPA之按条件查询和分页(kkpaper分页组件)