JAVA自定义查询策略

此文章为个人笔记，考虑之后工作用到，博客方便于查找，
如果可以给他人提供参考价值，那再好不过

1.定义查询接口参数

package com.qy.code.generator.query;

import java.util.ArrayList;
import java.util.List;

import com.qy.code.generator.constant.OperatorConstants;
import com.qy.code.generator.utils.CodeArrayUtils;

/**
 * 描述：查询类
 * @author 七脉
 */
public class Query {
    /**
     * 当前页码
     */
    private Integer pageNum;

    /**
     * 每页条数
     */
    private Integer pageSize;

    /**
     * 查询包含并且 查询条件
     */
    private List<Condition> andList;

    /**
     * 查询包含或查询条件
     */
    private List<Condition> orList;

    /**
     * 查询包含分组查询条件
     */
    private List<String> groupKeys;

    /**
     * 查询包含排序条件项
     */
    private List<OrderBy> sorts;

    /**
     * and条件结合 and(a=1 and b=2 or c=1)
     */
    private List<MultiCondition> andMultiConditionList;

    /**
     * or条件结合 or(a=1 and b=2 or c=1)
     */
    private List<MultiCondition> orMultiConditionList;

    /**
     * map集合里的and和or两个key值，用于区分( a=1 ..or或and.. c=1)
     */
    public static final String AND_CONDITIONS_KEY = "ands";
    public static final String OR_CONDITIONS_KEY = "ors";

    private String[] selectColumns;

    private String table;

    private List<Join> joinList;

    /**
     * 查询列  （表连接查询时，必填）
     * @param columns
     * @return
     */
    public Query select(String... selectColumns) {
        if(null!=selectColumns && selectColumns.length>0) {
            this.selectColumns = selectColumns;
        }
        return this;
    }

    /**
     * 查询表 （表连接查询时，必填）
     * @param columns
     * @return
     */
    public Query from(String table) {
        this.table = table;
        return this;
    }

    /**
     * 查询列
     * @param columns
     * @return
     */
    public Query join(Join join) {
        if(null==joinList) {
            this.joinList = new ArrayList<>();
        }
        if(null!=join) {
            this.joinList.add(join);
        }
        return this;
    }

    /**
     * 私有化构造器
     */
    public Query() {
    }

    /**
     * 描述：静态构建对象方便方法连续调用
     * @author 七脉
     * @return
     */
    public static Query create(){
        return new Query();
    }

    /**
     * 等于操作
     * @param value
     * @return
     */
    public Query eq(String key, Object value){
        return and(key, OperatorConstants.TYPE_EQ, value);
    }

    /**
     * 不等于操作
     * @param value
     * @return
     */
    public Query neq(String key, Object value){
        return and(key, OperatorConstants.TYPE_NEQ, value);
    }

    /**
     * 大于操作
     * @param value
     * @return
     */
    public Query gt(String key, Object value){
        return and(key, OperatorConstants.TYPE_GT, value);
    }

    /**
     * 大于等于操作
     * @param value
     * @return
     */
    public Query ge(String key, Object value){
        return and(key, OperatorConstants.TYPE_GE, value);
    }

    /**
     * 小于操作
     * @param value
     * @return
     */
    public Query lt(String key, Object value){
        return and(key, OperatorConstants.TYPE_LT, value);
    }

    /**
     * 小于等于操作
     * @param value
     * @return
     */
    public Query le(String key, Object value){
        return and(key, OperatorConstants.TYPE_LE, value);
    }

    /**
     * 模糊查询操作
     * @param value
     * @return
     */
    public Query like(String key, Object value){
        return and(key, OperatorConstants.TYPE_LIKE, value);
    }

    /**
     * 左侧模糊查询操作
     * @param value
     * @return
     */
    public Query leftlike(String key, Object value){
        return and(key, OperatorConstants.TYPE_LLIKE, value);
    }

    /**
     * 右侧模糊查询操作
     * @param value
     * @return
     */
    public Query rightlike(String key, Object value){
        return and(key, OperatorConstants.TYPE_RLIKE, value);
    }

    /**
     * in()包含操作（之所以不用list，首先list反射去class泛型名字很慢,其次数组比集合要快）
     * @param array 数组
     * @return
     */
    public Query in(String key, Object[] array){
        if(null==array || array.length==0){
            return this;
        }
        return and(key, OperatorConstants.TYPE_IN,array);
    }

    /**
     * not in()不包含操作
     * @param array 数组
     * @return
     */
    public Query notIn(String key, Object[] array) {
        if(null==array || array.length==0){
            return this;
        }
        return and(key, OperatorConstants.TYPE_NOT_IN,array);
    }

    /**
     * 判空操作
     * @return
     */
    public Query isNull(String key){
        return and(key, OperatorConstants.TYPE_IS_NULL, null);
    }

    /**
     * 判非空操作
     * @return
     */
    public Query isNotNull(String key){
        return and(key, OperatorConstants.TYPE_IS_NOT_NULL, null);
    }

    /**
     * 判空字符串操作
     * @return
     */
    public Query isBlank(String key){
        return and(key, OperatorConstants.TYPE_EQ, "");
    }

    /**
     * 判非空字符串操作
     * @return
     */
    public Query isNotBlank(String key){
        return and(key, OperatorConstants.TYPE_NEQ, "");
    }

    /**
     * 描述：增加与条件
     * @author 七脉
     * @param key
     * @param operator
     * @param value
     * @return
     */
    public Query and(String key, String operator, Object value){
        Condition condition = Condition.create(key, operator, value,true);
        return and(condition);
    }

    /**
     * 等于操作
     * @param value
     * @return
     */
    public Query orEq(String key, Object value){
        return or(key, OperatorConstants.TYPE_EQ, value);
    }

    /**
     * 不等于操作
     * @param value
     * @return
     */
    public Query orNeq(String key, Object value){
        return or(key, OperatorConstants.TYPE_NEQ, value);
    }

    /**
     * 大于操作
     * @param value
     * @return
     */
    public Query orGt(String key, Object value){
        return or(key, OperatorConstants.TYPE_GT, value);
    }

    /**
     * 大于等于操作
     * @param value
     * @return
     */
    public Query orGe(String key, Object value){
        return or(key, OperatorConstants.TYPE_GE, value);
    }

    /**
     * 小于操作
     * @param value
     * @return
     */
    public Query orLt(String key, Object value){
        return or(key, OperatorConstants.TYPE_LT, value);
    }

    /**
     * 小于等于操作
     * @param value
     * @return
     */
    public Query orLe(String key, Object value){
        return or(key, OperatorConstants.TYPE_LE, value);
    }

    /**
     * 模糊查询操作
     * @param value
     * @return
     */
    public Query orLike(String key, Object value){
        return or(key, OperatorConstants.TYPE_LIKE, value);
    }

    /**
     * 左侧模糊查询操作
     * @param value
     * @return
     */
    public Query orLeftlike(String key, Object value){
        return or(key, OperatorConstants.TYPE_LLIKE, value);
    }

    /**
     * 右侧模糊查询操作
     * @param value
     * @return
     */
    public Query orRightlike(String key, Object value){
        return or(key, OperatorConstants.TYPE_RLIKE, value);
    }

    /**
     * in()包含操作（之所以不用list，首先list反射去class泛型名字很慢,其次数组比集合要快）
     * @param array 数组
     * @return
     */
    public Query orIn(String key, Object[] array){
        if(null==array || array.length==0){
            return this;
        }
        return or(key, OperatorConstants.TYPE_IN,array);
    }

    /**
     * not in()不包含操作
     * @param array 数组
     * @return
     */
    public Query orNotIn(String key, Object[] array) {
        if(null==array || array.length==0){
            return this;
        }
        return or(key, OperatorConstants.TYPE_NOT_IN,array);
    }

    /**
     * 判空操作
     * @return
     */
    public Query orIsNull(String key){
        return or(key, OperatorConstants.TYPE_IS_NULL, null);
    }

    /**
     * 判非空操作
     * @return
     */
    public Query orIsNotNull(String key){
        return or(key, OperatorConstants.TYPE_IS_NOT_NULL, null);
    }

    /**
     * 判空字符串操作
     * @return
     */
    public Query orIsBlank(String key){
        return or(key, OperatorConstants.TYPE_EQ, "");
    }

    /**
     * 判非空字符串操作
     * @return
     */
    public Query orIsNotBlank(String key){
        return or(key, OperatorConstants.TYPE_NEQ, "");
    }

    /**
     * and(a=1 and b=2 or c=1)形式查询
     * @param condition
     * @return
     */
    public Query and(MultiCondition multiCondition) {
        if(null!=multiCondition) {
            if(null == this.andMultiConditionList) {
                this.andMultiConditionList = new ArrayList<>();
            }
            this.andMultiConditionList.add(multiCondition);
        }
        return this;
    }

    /**
     * and a=1 和 and(a=1 and b=2 or c=1)形式查询
     * @param condition
     * @return
     */
    public Query and(Condition... condition) {
        if(CodeArrayUtils.isNotEmpty(condition)) {
            if(condition.length>1){
                if(null == this.andMultiConditionList) {
                    this.andMultiConditionList = new ArrayList<>();
                }
                MultiCondition multiCondition = MultiCondition.create().add(condition);
                this.andMultiConditionList.add(multiCondition);
            }else{
                if(this.andList == null){
                    this.andList = new ArrayList<Condition>();
                }
                this.andList.add(condition[0]);
                return this;
            }
        }
        return this;
    }
    /**
     * or(a=1 and b=2 or c=1)形式查询
     * @param condition
     * @return
     */
    public Query or(MultiCondition multiCondition) {
        if(null!=multiCondition) {
            if(null == this.orMultiConditionList) {
                this.orMultiConditionList = new ArrayList<>();
            }
            this.orMultiConditionList.add(multiCondition);
        }
        return this;
    }

    /**
     * 增加或条件 or a=1 和 or(a=1 and b=2 or c=1)形式查询
     * @param conditions
     * @return
     */
    public Query or(Condition... condition) {
        if(CodeArrayUtils.isNotEmpty(condition)) {
            if(condition.length>1){
                if(null == this.orMultiConditionList) {
                    this.orMultiConditionList = new ArrayList<>();
                }
                MultiCondition multiCondition = MultiCondition.create().add(condition);
                this.orMultiConditionList.add(multiCondition);
            }else{
                if(this.orList == null){
                    this.orList = new ArrayList<Condition>();
                }
                this.orList.add(condition[0]);
                return this;
            }
        }
        return this;
    }

    /**
     * 描述：where条件，支持连续调用
     * @author 七脉
     * @param condition
     * @return
     */
    public Query where(Condition condition){
        if(null != condition){
            if(condition.isAnd()){
                if(this.andList == null){
                    this.andList = new ArrayList<Condition>();
                }
                this.andList.add(condition);
            }else{
                if(this.orList == null){
                    this.orList = new ArrayList<Condition>();
                }
                this.orList.add(condition);
            }
        }
        return this;
    }

    /**
     * 描述：增加或条件
     * @author 七脉
     * @param key
     * @param operator
     * @param value
     * @return
     */
    public Query or(String key, String operator, Object value){
        Condition condition = Condition.create(key, operator, value, false);
        return or(condition);
    }

    /**
     * 描述：升序排序
     * @param key 字段名称
     * @return
     */
    public Query asc(String key){
        key = getColumn(key);
        if(null != key){
            if(this.sorts == null){
                this.sorts = new ArrayList<OrderBy>();
            }
            this.sorts.add(OrderBy.asc(key));
        }
        return this;
    }

    /**
     * 描述：降序排序
     * @param key 字段名称
     * @return
     */
    public Query desc(String key){
        key = getColumn(key);
        if(null != key){
            if(this.sorts == null){
                this.sorts = new ArrayList<OrderBy>();
            }
            this.sorts.add(OrderBy.asc(key));
        }
        return this;
    }

    /**
     * 增加分组条件
     * @param groups
     * @return
     */
    public Query group(String... groupKeys){
        if(null != groupKeys){
            for(String key : groupKeys){
                key = getColumn(key);
                if(this.groupKeys == null){
                    this.groupKeys = new ArrayList<>();
                }
                this.groupKeys.add(key);
            }
        }
        return this;
    }

    public Query limit(Integer pageNum, Integer pageSize) {
        if(null==pageNum || 0==pageNum) {
            this.pageNum = 1;
        }else {
            this.pageNum = pageNum;
        }
        if(null==pageSize || 0==pageSize) {
            this.pageSize = 1;
        }else {
            this.pageSize = pageNum;
        }
        return this;
    }

    private String getColumn(String key) {
        if(!key.contains("_")){
            String newKey = "";
            for(int i=0; i<key.length(); i++){
                char ch = key.charAt(i);
                if(Character.isUpperCase(ch)){
                    newKey += "_"+ch;
                }else{
                    newKey += ch;
                }
            }
            key = newKey;
        }
        return key;
    }

    public List<Condition> getAndList() {
        return andList;
    }

    public List<Condition> getOrList() {
        return orList;
    }

    public List<String> getGroupKeys() {
        return groupKeys;
    }

    public List<OrderBy> getSorts() {
        return sorts;
    }

    public List<MultiCondition> getAndMultiConditionList() {
        return andMultiConditionList;
    }

    public List<MultiCondition> getOrMultiConditionList() {
        return orMultiConditionList;
    }

    public static String getAndConditionsKey() {
        return AND_CONDITIONS_KEY;
    }

    public static String getOrConditionsKey() {
        return OR_CONDITIONS_KEY;
    }

    public String[] getSelectColumns() {
        return selectColumns;
    }

    public String getTable() {
        return table;
    }

    public List<Join> getJoinList() {
        return joinList;
    }

    public Integer getPageNum() {
        return pageNum;
    }

    public Integer getPageSize() {
        return pageSize;
    }

}

2.查询条件

package com.qy.code.generator.query;

import com.qy.code.generator.constant.OperatorConstants;

/**
 * 描述：查询条件
 * @author 七脉
 */
public class Condition {

    /**
     * 查询键（数据库表字段名称）
     */
    private String key;

    /**
     * 操作符
     */
    private String operator;

    /**
     * 查询条件值
     */
    private Object value;

    /**
     * 非 and 即 or
     */
    private boolean isAnd;

    /**
     * 构造器私有，使用方法创建
     */
    private Condition(){}

    /**
     * 创建查询条件
     * @param key 查询键
      * @param operator 查询条件值
     * @param value 查询值
     */
    private Condition(String key, String operator, Object value, boolean isAnd) {
        this.key = key;
        this.operator = operator;
        this.value = value;
        this.isAnd = isAnd;
    }

    /**
     * 供query类使用
     * @param key
     * @param operator
     * @param value
     * @return
     */
    public static Condition create(String key, String operator, Object value, boolean isAnd) {
        return operate(key, operator, value, isAnd);
    }

    /**
     * 等于操作
     * @param value
     * @return
     */
    public static Condition eq(String key, Object value){
        return and(key, OperatorConstants.TYPE_EQ, value);
    }

    /**
     * 不等于操作
     * @param value
     * @return
     */
    public static Condition neq(String key, Object value){
        return and(key, OperatorConstants.TYPE_NEQ, value);
    }

    /**
     * 大于操作
     * @param value
     * @return
     */
    public static Condition gt(String key, Object value){
        return and(key, OperatorConstants.TYPE_GT, value);
    }

    /**
     * 大于等于操作
     * @param value
     * @return
     */
    public static Condition ge(String key, Object value){
        return and(key, OperatorConstants.TYPE_GE, value);
    }

    /**
     * 小于操作
     * @param value
     * @return
     */
    public static Condition lt(String key, Object value){
        return and(key, OperatorConstants.TYPE_LT, value);
    }

    /**
     * 小于等于操作
     * @param value
     * @return
     */
    public static Condition le(String key, Object value){
        return and(key, OperatorConstants.TYPE_LE, value);
    }

    /**
     * 模糊查询操作
     * @param value
     * @return
     */
    public static Condition like(String key, Object value){
        return and(key, OperatorConstants.TYPE_LIKE, value);
    }

    /**
     * 左侧模糊查询操作
     * @param value
     * @return
     */
    public static Condition leftlike(String key, Object value){
        return and(key, OperatorConstants.TYPE_LLIKE, value);
    }

    /**
     * 右侧模糊查询操作
     * @param value
     * @return
     */
    public static Condition rightlike(String key, Object value){
        return and(key, OperatorConstants.TYPE_RLIKE, value);
    }

    /**
     * in()包含操作（之所以不用list，首先list反射去class泛型名字很慢,其次数组比集合要快）
     * @param array 数组
     * @return
     */
    public static Condition in(String key, Object[] array){
        if(null==array || array.length==0){
            return null;
        }
        return and(key, OperatorConstants.TYPE_IN,array);
    }

    /**
     * not in()不包含操作
     * @param array 数组
     * @return
     */
    public static Condition notIn(String key, Object[] array) {
        if(null==array || array.length==0){
            return null;
        }
        return and(key, OperatorConstants.TYPE_NOT_IN,array);
    }

    /**
     * 判空操作
     * @return
     */
    public static Condition isNull(String key){
        return and(key, OperatorConstants.TYPE_IS_NULL, null);
    }

    /**
     * 判非空操作
     * @return
     */
    public static Condition isNotNull(String key){
        return and(key, OperatorConstants.TYPE_IS_NOT_NULL, null);
    }

    /**
     * 判空字符串操作
     * @return
     */
    public static Condition isBlank(String key){
        return and(key, OperatorConstants.TYPE_EQ, "");
    }

    /**
     * 判非空字符串操作
     * @return
     */
    public static Condition isNotBlank(String key){
        return and(key, OperatorConstants.TYPE_NEQ, "");
    }

    /**
     * 等于操作
     * @param value
     * @return
     */
    public static Condition orEq(String key, Object value){
        return or(key, OperatorConstants.TYPE_EQ, value);
    }

    /**
     * 不等于操作
     * @param value
     * @return
     */
    public static Condition orNeq(String key, Object value){
        return or(key, OperatorConstants.TYPE_NEQ, value);
    }

    /**
     * 大于操作
     * @param value
     * @return
     */
    public static Condition orGt(String key, Object value){
        return or(key, OperatorConstants.TYPE_GT, value);
    }

    /**
     * 大于等于操作
     * @param value
     * @return
     */
    public static Condition orGe(String key, Object value){
        return or(key, OperatorConstants.TYPE_GE, value);
    }

    /**
     * 小于操作
     * @param value
     * @return
     */
    public static Condition orLt(String key, Object value){
        return or(key, OperatorConstants.TYPE_LT, value);
    }

    /**
     * 小于等于操作
     * @param value
     * @return
     */
    public static Condition orLe(String key, Object value){
        return or(key, OperatorConstants.TYPE_LE, value);
    }

    /**
     * 模糊查询操作
     * @param value
     * @return
     */
    public static Condition orLike(String key, Object value){
        return or(key, OperatorConstants.TYPE_LIKE, value);
    }

    /**
     * 左侧模糊查询操作
     * @param value
     * @return
     */
    public static Condition orLeftlike(String key, Object value){
        return or(key, OperatorConstants.TYPE_LLIKE, value);
    }

    /**
     * 右侧模糊查询操作
     * @param value
     * @return
     */
    public static Condition orRightlike(String key, Object value){
        return or(key, OperatorConstants.TYPE_RLIKE, value);
    }

    /**
     * in()包含操作（之所以不用list，首先list反射去class泛型名字很慢,其次数组比集合要快）
     * @param array 数组
     * @return
     */
    public static Condition orIn(String key, Object[] array){
        if(null==array || array.length==0){
            return null;
        }
        return or(key, OperatorConstants.TYPE_IN,array);
    }

    /**
     * not in()不包含操作
     * @param array 数组
     * @return
     */
    public static Condition orNotIn(String key, Object[] array) {
        if(null==array || array.length==0){
            return null;
        }
        return or(key, OperatorConstants.TYPE_NOT_IN,array);
    }

    /**
     * 判空操作
     * @return
     */
    public static Condition orIsNull(String key){
        return or(key, OperatorConstants.TYPE_IS_NULL, null);
    }

    /**
     * 判非空操作
     * @return
     */
    public static Condition orIsNotNull(String key){
        return or(key, OperatorConstants.TYPE_IS_NOT_NULL, null);
    }

    /**
     * 判空字符串操作
     * @return
     */
    public static Condition orIsBlank(String key){
        return or(key, OperatorConstants.TYPE_EQ, "");
    }

    /**
     * 判不为空字符串操作
     * @return
     */
    public static Condition orIsNotBlank(String key){
        return or(key, OperatorConstants.TYPE_EQ, "");
    }

    /**
     * 描述：and条件
     * @author 七脉
     * @param key
     * @param operator
     * @param value
     * @return
     */
    public static Condition and(String key, String operator, Object value){
        return operate(key, operator, value, true);
    }

    /**
     * 描述：or条件
     * @author 七脉
     * @param key
     * @param operator
     * @param value
     * @return
     */
    public static Condition or(String key, String operator, Object value){
        return operate(key, operator, value, false);
    }

    /**
     * 创建连接及查询 条件值
     * @param operate 连接符
     * @param value 查询条件值
     * @return
     */
    private static Condition operate(String key, String operator, Object value, boolean isAnd){
        if(null==key || null==operator || null==value || ""==key || ""==operator || ""==value){
            return null;
        }
        if(!key.contains("_")){
            String newKey = "";
            for(int i=0; i<key.length(); i++){
                char ch = key.charAt(i);
                if(Character.isUpperCase(ch)){
                    newKey += "_"+ch;
                }else{
                    newKey += ch;
                }
            }
            key = newKey;
        }
        Condition condition = new Condition(key, operator, value, isAnd);
        return condition;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getOperator() {
        return operator;
    }

    public void setOperator(String operator) {
        this.operator = operator;
    }

    public Object getValue() {
        return value;
    }

    public void setValue(Object value) {
        this.value = value;
    }

    public boolean isAnd() {
        return isAnd;
    }

    public void setAnd(boolean isAnd) {
        this.isAnd = isAnd;
    }

}

3.多条件查询

package com.qy.code.generator.query;

import java.util.ArrayList;
import java.util.List;

import com.qy.code.generator.constant.OperatorConstants;

/**
 * 描述：查询条件
 * @author 七脉
 */
public class MultiCondition {

    /**
     * and条件集合
     */
    private List<Condition> andList;

    /**
     * and条件集合
     */
    private List<Condition> orList;

    /**
     * 构造器私有，使用方法创建
     */
    private MultiCondition(){}

    /**
     * 实例化对象
     * @return
     */
    public static MultiCondition create(){
        return new MultiCondition();
    }

    /**
     * 等于操作
     * @param value
     * @return
     */
    public MultiCondition eq(String key, Object value){
        return and(key, OperatorConstants.TYPE_EQ, value);
    }

    /**
     * 不等于操作
     * @param value
     * @return
     */
    public MultiCondition neq(String key, Object value){
        return and(key, OperatorConstants.TYPE_NEQ, value);
    }

    /**
     * 大于操作
     * @param value
     * @return
     */
    public MultiCondition gt(String key, Object value){
        return and(key, OperatorConstants.TYPE_GT, value);
    }

    /**
     * 大于等于操作
     * @param value
     * @return
     */
    public MultiCondition ge(String key, Object value){
        return and(key, OperatorConstants.TYPE_GE, value);
    }

    /**
     * 小于操作
     * @param value
     * @return
     */
    public MultiCondition lt(String key, Object value){
        return and(key, OperatorConstants.TYPE_LT, value);
    }

    /**
     * 小于等于操作
     * @param value
     * @return
     */
    public MultiCondition le(String key, Object value){
        return and(key, OperatorConstants.TYPE_LE, value);
    }

    /**
     * 模糊查询操作
     * @param value
     * @return
     */
    public MultiCondition like(String key, Object value){
        return and(key, OperatorConstants.TYPE_LIKE, value);
    }

    /**
     * 左侧模糊查询操作
     * @param value
     * @return
     */
    public MultiCondition leftlike(String key, Object value){
        return and(key, OperatorConstants.TYPE_LLIKE, value);
    }

    /**
     * 右侧模糊查询操作
     * @param value
     * @return
     */
    public MultiCondition rightlike(String key, Object value){
        return and(key, OperatorConstants.TYPE_RLIKE, value);
    }

    /**
     * in()包含操作（之所以不用list，首先list反射去class泛型名字很慢,其次数组比集合要快）
     * @param array 数组
     * @return
     */
    public MultiCondition in(String key, Object[] array){
        if(null==array || array.length==0){
            return this;
        }
        return and(key, OperatorConstants.TYPE_IN,array);
    }

    /**
     * not in()不包含操作
     * @param array 数组
     * @return
     */
    public MultiCondition notIn(String key, Object[] array) {
        if(null==array || array.length==0){
            return this;
        }
        return and(key, OperatorConstants.TYPE_NOT_IN,array);
    }

    /**
     * 判空操作
     * @return
     */
    public MultiCondition isNull(String key){
        return and(key, OperatorConstants.TYPE_IS_NULL, null);
    }

    /**
     * 判非空操作
     * @return
     */
    public MultiCondition isNotNull(String key){
        return and(key, OperatorConstants.TYPE_IS_NOT_NULL, null);
    }

    /**
     * 判空字符串操作
     * @return
     */
    public MultiCondition isBlank(String key){
        return and(key, OperatorConstants.TYPE_EQ, "");
    }

    /**
     * 判非空字符串操作
     * @return
     */
    public MultiCondition isNotBlank(String key){
        return and(key, OperatorConstants.TYPE_NEQ, "");
    }

    /**
     * 等于操作
     * @param value
     * @return
     */
    public MultiCondition orEq(String key, Object value){
        return or(key, OperatorConstants.TYPE_EQ, value);
    }

    /**
     * 不等于操作
     * @param value
     * @return
     */
    public MultiCondition orNeq(String key, Object value){
        return or(key, OperatorConstants.TYPE_NEQ, value);
    }

    /**
     * 大于操作
     * @param value
     * @return
     */
    public MultiCondition orGt(String key, Object value){
        return or(key, OperatorConstants.TYPE_GT, value);
    }

    /**
     * 大于等于操作
     * @param value
     * @return
     */
    public MultiCondition orGe(String key, Object value){
        return or(key, OperatorConstants.TYPE_GE, value);
    }

    /**
     * 小于操作
     * @param value
     * @return
     */
    public MultiCondition orLt(String key, Object value){
        return or(key, OperatorConstants.TYPE_LT, value);
    }

    /**
     * 小于等于操作
     * @param value
     * @return
     */
    public MultiCondition orLe(String key, Object value){
        return or(key, OperatorConstants.TYPE_LE, value);
    }

    /**
     * 模糊查询操作
     * @param value
     * @return
     */
    public MultiCondition orLike(String key, Object value){
        return or(key, OperatorConstants.TYPE_LIKE, value);
    }

    /**
     * 左侧模糊查询操作
     * @param value
     * @return
     */
    public MultiCondition orLeftlike(String key, Object value){
        return or(key, OperatorConstants.TYPE_LLIKE, value);
    }

    /**
     * 右侧模糊查询操作
     * @param value
     * @return
     */
    public MultiCondition orRightlike(String key, Object value){
        return or(key, OperatorConstants.TYPE_RLIKE, value);
    }

    /**
     * in()包含操作（之所以不用list，首先list反射去class泛型名字很慢,其次数组比集合要快）
     * @param array 数组
     * @return
     */
    public MultiCondition orIn(String key, Object[] array){
        if(null==array || array.length==0){
            return this;
        }
        return or(key, OperatorConstants.TYPE_IN,array);
    }

    /**
     * not in()不包含操作
     * @param array 数组
     * @return
     */
    public MultiCondition orNotIn(String key, Object[] array) {
        if(null==array || array.length==0){
            return this;
        }
        return or(key, OperatorConstants.TYPE_NOT_IN,array);
    }

    /**
     * 判空操作
     * @return
     */
    public MultiCondition orIsNull(String key){
        return or(key, OperatorConstants.TYPE_IS_NULL, null);
    }

    /**
     * 判非空操作
     * @return
     */
    public MultiCondition orIsNotNull(String key){
        return or(key, OperatorConstants.TYPE_IS_NOT_NULL, null);
    }

    /**
     * 判空字符串操作
     * @return
     */
    public MultiCondition orIsBlank(String key){
        return or(key, OperatorConstants.TYPE_EQ, "");
    }

    /**
     * 判非空字符串操作
     * @return
     */
    public MultiCondition orIsNotBlank(String key){
        return or(key, OperatorConstants.TYPE_NEQ, "");
    }

    /**
     * 描述：增加与条件
     * @author 七脉
     * @param key
     * @param operator
     * @param value
     * @return
     */
    private MultiCondition and(String key, String operator, Object value){
        Condition condition = Condition.create(key, operator, value,true);
        return and(condition);
    }

    /**
     * 描述：增加或条件
     * @author 七脉
     * @param key
     * @param operator
     * @param value
     * @return
     */
    private MultiCondition or(String key, String operator, Object value){
        Condition condition = Condition.create(key, operator, value,false);
        return or(condition);
    }

    /**
     * 描述：增加与条件
     * @author 七脉
     * @param key
     * @param operator
     * @param value
     * @return
     */
    public MultiCondition and(Condition condition){
        return add(condition);
    }

    /**
     * 描述：增加或条件
     * @author 七脉
     * @param key
     * @param operator
     * @param value
     * @return
     */
    public MultiCondition or(Condition condition){
        return add(condition);
    }

    /**
     * 描述：增加与条件
     * @author 七脉
     * @param condition
     * @return
     */
    public MultiCondition add(Condition... condition){
        for(Condition cdt : condition){
            if(null==condition){
                continue;
            }
            if(cdt.isAnd()){
                if(this.andList == null){
                    this.andList = new ArrayList<Condition>();
                }
                this.andList.add(cdt);
            }else{
                if(this.orList == null){
                    this.orList = new ArrayList<Condition>();
                }
                this.orList.add(cdt);
            }
        }
        return this;
    }

    public List<Condition> getAndList() {
        return andList;
    }

    public void setAndList(List<Condition> andList) {
        this.andList = andList;
    }

    public List<Condition> getOrList() {
        return orList;
    }

    public void setOrList(List<Condition> orList) {
        this.orList = orList;
    }

}

4.连接表

package com.qy.code.generator.query;

import java.util.ArrayList;
import java.util.List;

import com.qy.code.generator.enums.JoinType;
import com.qy.code.generator.utils.CodeArrayUtils;

/**
 * 连接类型 父类（不可定义为接口，因为重写方法都一样）
 * @author 七脉
 */
public class Join {
    /**
     * 左连接表 查询列
     */
    private String[] selectColumns;

    /**
     * 左连接表
     */
    private String table;

    /**
     * on条件 主表列
     */
    private String onMasterColumn;

    /**
     * on条件 左连接表列
     */
    private String onJoinColumn;

    /**
     * where过滤掉件 and a = 1
     */
    List<Condition> whereAndConditionList;

    /**
     * where过滤掉件 or a = 1
     */
    List<Condition> whereOrConditionList;

    /**
     * where过滤掉件 and(a = 1 and b=2 or c=1)
     */
    List<MultiCondition> whereAndMultiConditionList;

    /**
     * where过滤掉件 or(a = 1 and b=2 or c=1)
     */
    List<MultiCondition> whereOrMultiConditionList;

    /**
     * 连接类型
     */
    private JoinType joinType;

    /**
     * 私有化构造器
     */
    private Join() {
    }

    /**
     * 描述：静态构建对象实例
     * @author 七脉
     * @return
     */
    public static Join createInnerJoin(String table){
        Join join = new Join();
        join.table = table;
        join.joinType = JoinType.INNER_JOIN;
        return join;
    }

    /**
     * 描述：静态构建对象实例
     * @author 七脉
     * @return
     */
    public static Join createLiftJoin(String table){
        Join join = new Join();
        join.table = table;
        join.joinType = JoinType.LEFT_JOIN;
        return join;
    }

    /**
     * 连接表的查询列
     * @param joinColumns
     * @return
     */
    public Join select(String... selectColumns) {
        this.selectColumns = selectColumns;
        return this;
    }

    /**
     * 左连接 on 条件字段
     * @param onMasterColumn
     * @param onJoinColumn
     * @return
     */
    public Join on(String onMasterColumn, String onJoinColumn) {
        this.onMasterColumn = onMasterColumn;
        this.onJoinColumn = onJoinColumn;
        return this;
    }

    /**
     * where 后的 and条件
     * @param condition
     * @return
     */
    public Join and(Condition... conditions) {
        if(CodeArrayUtils.isNotEmpty(conditions)) {
            if(this.whereAndConditionList == null) {
                this.whereAndConditionList = new ArrayList<>();
            }
            for(Condition cdt : conditions) {
                this.whereAndConditionList.add(cdt);
            }
        }
        return this;
    }

    /**
     * where 后的 or条件
     * @param condition
     * @return
     */
    public Join or(Condition... conditions) {
        if(CodeArrayUtils.isNotEmpty(conditions)) {
            if(this.whereOrConditionList == null) {
                this.whereOrConditionList = new ArrayList<>();
            }
            for(Condition cdt : conditions) {
                this.whereOrConditionList.add(cdt);
            }
        }
        return this;
    }

    /**
     * where过滤掉件 and(a = 1 and b=2 or c=1)
     * @param conditions
     * @return
     */
    public Join and(MultiCondition... conditions) {
        if(CodeArrayUtils.isNotEmpty(conditions)) {
            if(this.whereAndMultiConditionList == null) {
                this.whereAndMultiConditionList = new ArrayList<>();
            }
            for(MultiCondition condition : conditions) {
                this.whereAndMultiConditionList.add(condition);
            }
        }
        return this;
    }

    /**
     * where过滤掉件 or(a = 1 and b=2 or c=1)
     * @param conditions
     * @return
     */
    public Join or(MultiCondition... conditions) {
        if(CodeArrayUtils.isNotEmpty(conditions)) {
            if(this.whereOrMultiConditionList == null) {
                this.whereOrMultiConditionList = new ArrayList<>();
            }
            for(MultiCondition condition : conditions) {
                this.whereOrMultiConditionList.add(condition);
            }
        }
        return this;
    }

    public String[] getSelectColumns() {
        return selectColumns;
    }

    public void setSelectColumns(String[] selectColumns) {
        this.selectColumns = selectColumns;
    }

    public String getTable() {
        return table;
    }

    public void setTable(String table) {
        this.table = table;
    }

    public String getOnMasterColumn() {
        return onMasterColumn;
    }

    public void setOnMasterColumn(String onMasterColumn) {
        this.onMasterColumn = onMasterColumn;
    }

    public String getOnJoinColumn() {
        return onJoinColumn;
    }

    public void setOnJoinColumn(String onJoinColumn) {
        this.onJoinColumn = onJoinColumn;
    }

    public List<Condition> getWhereAndConditionList() {
        return whereAndConditionList;
    }

    public List<Condition> getWhereOrConditionList() {
        return whereOrConditionList;
    }

    public List<MultiCondition> getWhereAndMultiConditionList() {
        return whereAndMultiConditionList;
    }

    public List<MultiCondition> getWhereOrMultiConditionList() {
        return whereOrMultiConditionList;
    }

    public JoinType getJoinType() {
        return joinType;
    }
}

4.排序类

package com.qy.code.generator.query;

/**
 * 描述：查询排序条件
 * @author 七脉
 */
public class OrderBy {

    /** 顺序排序 */
    public final static String ASC = "asc";

    /** 逆序排序 */
    public final static String DESC = "desc";

    /**
     * 排序字段名称
     */
    private String key;

    /**
     * 排序方式
     * {@link #ASC}
     * {@link #DESC}
     */
    private String asc;

    private OrderBy() {
    }

    /**
     * 创建顺序排序条件项
     * @param name
     * @return
     */
    public static OrderBy asc(String key){
        OrderBy sort = new OrderBy();
        sort.setKey(key);
        sort.setAsc(ASC);
        return sort;
    }

    /**
     * 创建逆序排序条件项
     * @param name
     * @return
     */
    public static OrderBy desc(String key){
        OrderBy sort = new OrderBy();
        sort.setKey(key);
        sort.setAsc(DESC);
        return sort;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getAsc() {
        return asc;
    }

    public void setAsc(String asc) {
        this.asc = asc;
    }

    @Override
    public String toString() {
        return getKey() + " " + getAsc();
    }
}

使用场景：通过Query类定义查询条件，根据最终的Query条件，完成查询需求。
如：使用query生成JdbcTemplate所需SQL

　　或Mybatis Mapper定义好SQL模板，Query直接作为Mapper接口参数。