MyBatis-Plus 封装（值为空字段不拼接到sql语句中）
封装背景
- 使用过MyBatis-Plus 的想必都经历过在使用查询语句时，有时候我们前端传递过来的参数是null或者空字符串或者是空白字符串等问题，而我们就需要使用去对每个查询条件进行判空处理，不为空在给QueryWrapper进行sql的凭借，如果在mybatis中可以直接写if条件判断，但在MyBatis-Plus要写在java 逻辑代码处理中，就会显得代码臃肿，不美观，会产生大量的条件判断。故进行封装，将需要的条件传递进去就行。
QueryWrapper封装代码如下：
继承原生的MyBatis-Plus的QueryWrapper类进行实现
import com.baomidou.mybatisplus.core.toolkit.ArrayUtils;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
/**
* 拓展 MyBatis Plus QueryWrapper 类，主要增加如下功能：
* <p />
* 拼接条件的方法，增加 xxxIfPresent 方法，用于判断值不存在的时候,不要拼接到条件中
* @author gremlin
* @param <T> 数据类型
*/
public class QueryWrapper<T> extends com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<T> {
/**
* 等于条件判断 单条件
* @param column 数据库表字段
* @param val 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> eqIfPresent(String column, Object val) {
if (val != null) {
// 如果是String 判断是否为空字符串或者有空白
if (val instanceof String){
if (StringUtils.hasText(val.toString())){
return (QueryWrapper<T>) super.eq(column, val);
} else {
return this;
}
} else {
return (QueryWrapper<T>) super.eq(column, val);
}
}
return this;
}
/**
* 等于条件判断 两个条件
* @param column1 数据库表字段1
* @param column2 数据库表字段2
* @param val1 条件值1
* @param val2 条件值2
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> eqIfPresent(String column1, Object val1,String column2, Object val2) {
if (val1 != null || val2 != null){
if (val1 != null) {
// 如果是String 判断是否为空字符串或者有空白
if (val1 instanceof String){
if (StringUtils.hasText(val1.toString())){
super.eq(column1, val1);
}
} else {
super.eq(column1, val1);
}
}
if (val2 != null) {
// 如果是String 判断是否为空字符串或者有空白
if (val2 instanceof String){
if (StringUtils.hasText(val2.toString())){
super.eq(column2, val2);
}
} else {
super.eq(column2, val2);
}
}
}
return this;
}
/**
* 多参数等于条件判断 不同原mybatis plus 中的是当map中的value值为空时不拼接该字段eq语句
* @param params 数据库表字段map
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> allEqIfPresent(Map<String,Object> params) {
if (!ObjectUtils.isEmpty(params)){
Iterator<Map.Entry<String, Object>> iterator = params.entrySet().stream().iterator();
while(iterator.hasNext()) {
Map.Entry<String, Object> entry = iterator.next();
if (StringUtils.hasText(entry.getKey())){
if (entry.getValue() != null && entry.getValue() instanceof String){
if (StringUtils.hasText(entry.getValue().toString())){
super.eq(entry.getKey(),entry.getValue());
}
} else {
super.eq(entry.getKey(),entry.getValue());
}
}
}
}
return this;
}
/**
* 全模糊条件判断 LIKE '%值%'
* @param column 数据库表字段
* @param val 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> likeIfPresent(String column, String val) {
if (StringUtils.hasText(val)) {
return (QueryWrapper<T>) super.like(column, val);
}
return this;
}
/**
* 左模糊条件判断 LIKE '%值'
* @param column 数据库表字段
* @param val 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> likeLeftIfPresent(String column, String val) {
if (StringUtils.hasText(val)) {
return (QueryWrapper<T>) super.likeLeft(column, val);
}
return this;
}
/**
* 右模糊条件判断 LIKE '值%'
* @param column 数据库表字段
* @param val 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> likeRightIfPresent(String column, String val) {
if (StringUtils.hasText(val)) {
return (QueryWrapper<T>) super.likeRight(column, val);
}
return this;
}
/**
* 全模糊不匹配条件判断 NOT LIKE '%值%'
* @param column 数据库表字段
* @param val 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> notLikeIfPresent(String column, String val) {
if (StringUtils.hasText(val)) {
return (QueryWrapper<T>) super.notLike(column, val);
}
return this;
}
/**
* 左模糊不匹配条件判断 NOT LIKE LEFT '%值'
* @param column 数据库表字段
* @param val 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> notLikeLeftIfPresent(String column, String val) {
if (StringUtils.hasText(val)) {
return (QueryWrapper<T>) super.notLikeLeft(column, val);
}
return this;
}
/**
* 右模糊不匹配条件判断 NOT LIKE RIGHT '值%'
* @param column 数据库表字段
* @param val 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> notLikeRightIfPresent(String column, String val) {
if (StringUtils.hasText(val)) {
return (QueryWrapper<T>) super.notLikeRight(column, val);
}
return this;
}
/**
* in 条件判断
* 字段 in (value.get(0), value.get(1), ...)
* <p>例: in("id", Arrays.asList(1, 2, 3, 4, 5))</p>
* <li> 如果集合为 empty 则不会进行 sql 拼接 </li>
* @param column 数据库表字段
* @param values 条件值 集合（set,list）
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> inIfPresent(String column, Collection<?> values) {
if (CollectionUtils.isNotEmpty(values)) {
return (QueryWrapper<T>) super.in(column, values);
}
return this;
}
/**
* notIn 条件判断
* 字段 notIn (value.get(0), value.get(1), ...)
* <p>例: notIn("id", Arrays.asList(1, 2, 3, 4, 5))</p>
* <li> 如果集合为 empty 则不会进行 sql 拼接 </li>
* @param column 数据库表字段
* @param values 条件值 集合（set,list）
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> notInIfPresent(String column, Collection<?> values) {
if (CollectionUtils.isNotEmpty(values)) {
return (QueryWrapper<T>) super.notIn(column, values);
}
return this;
}
/**
* 字段 in (v0, v1, ...)
* <p>例: in("id", 1, 2, 3, 4, 5)</p>
* <p>例: in("id", Arrays.asList(1, 2, 3, 4, 5))</p>
* <li> 如果集合为 empty 则不会进行 sql 拼接 </li>
* @param column 数据库表字段
* @param values 条件值 数组
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> inIfPresent(String column, Object ... values) {
if (ArrayUtils.isNotEmpty(values)) {
return (QueryWrapper<T>) super.in(column, values);
}
return this;
}
/**
* 字段 notIn (v0, v1, ...)
* <p>例: notIn("id", 1, 2, 3, 4, 5)</p>
* <p>例: notIn("id", Arrays.asList(1, 2, 3, 4, 5))</p>
* <li> 如果集合为 empty 则不会进行 sql 拼接 </li>
* @param column 数据库表字段
* @param values 条件值 数组
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> notInIfPresent(String column, Object ... values) {
if (ArrayUtils.isNotEmpty(values)) {
return (QueryWrapper<T>) super.notIn(column, values);
}
return this;
}
/**
* 不等于 < > 条件判断
* @param column 数据库表字段
* @param val 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> neIfPresent(String column, Object val) {
if (val != null) {
return (QueryWrapper<T>) super.ne(column, val);
}
return this;
}
/**
* 大于 > 条件判断
* @param column 数据库表字段
* @param val 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> gtIfPresent(String column, Object val) {
if (val != null) {
return (QueryWrapper<T>) super.gt(column, val);
}
return this;
}
/**
* 大于等于 >= 条件判断
* @param column 数据库表字段
* @param val 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> geIfPresent(String column, Object val) {
if (val != null) {
return (QueryWrapper<T>) super.ge(column, val);
}
return this;
}
/**
* 小于 < 条件判断
* @param column 数据库表字段
* @param val 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> ltIfPresent(String column, Object val) {
if (val != null) {
return (QueryWrapper<T>) super.lt(column, val);
}
return this;
}
/**
* 小于等于 <= 条件判断
* @param column 数据库表字段
* @param val 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> leIfPresent(String column, Object val) {
if (val != null) {
return (QueryWrapper<T>) super.le(column, val);
}
return this;
}
/**
* 值1与值2之间 包含值1和值2
* @param column 数据库表字段
* @param val1 条件值
* @param val2 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> betweenIfPresent(String column, Object val1, Object val2) {
if (val1 != null && val2 != null) {
return (QueryWrapper<T>) super.between(column, val1, val2);
}
if (val1 != null) {
return (QueryWrapper<T>) ge(column, val1);
}
if (val2 != null) {
return (QueryWrapper<T>) le(column, val2);
}
return this;
}
/**
* 值1与值2之间 包含值1和值2,有效值个数2个
* @param column 数据库表字段
* @param values 数组
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> betweenIfPresent(String column, Object ... values) {
if (ArrayUtils.isNotEmpty(values)){
if (values[0] != null && values[1] != null) {
return (QueryWrapper<T>) super.between(column, values[0], values[1]);
}
if (values[0] != null) {
return (QueryWrapper<T>) ge(column, values[0]);
}
if (values[1] != null) {
return (QueryWrapper<T>) le(column, values[1]);
}
}
return this;
}
/**
* 值1与值2之间 结果包含值1和值2,有效值个数2个
* @param column 数据库表字段
* @param valueCollect 数组
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> betweenIfPresent(String column, Collection<?> valueCollect) {
if (CollectionUtils.isNotEmpty(valueCollect)) {
Object[] values = valueCollect.toArray();
if (Objects.nonNull(values[0]) && Objects.nonNull(values[1])) {
return (QueryWrapper<T>) super.between(column, values[0], values[1]);
}
if (Objects.nonNull(values[0])) {
return (QueryWrapper<T>) ge(column, values[0]);
}
if (Objects.nonNull(values[1])) {
return (QueryWrapper<T>) le(column, values[1]);
}
}
return this;
}
/**
* 不在值1与值2之间 结果不包含值1和值2
* @param column 数据库表字段
* @param val1 条件值
* @param val2 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public QueryWrapper<T> notBetweenIfPresent(String column, Object val1, Object val2) {
if (val1 != null && val2 != null) {
return (QueryWrapper<T>) super.notBetween(column, val1, val2);
}
if (val1 != null) {
return (QueryWrapper<T>) gt(column, val1);
}
if (val2 != null) {
return (QueryWrapper<T>) lt(column, val2);
}
return this;
}
/**
* 查询字段为空不添加到查询语句中
* @param columns 要查询的数据库表字段数组
* @return 查询构造器 QueryWrapper
*/
public QueryWrapper<T> selectIfPresent(String... columns) {
if (ArrayUtils.isNotEmpty(columns)) {
return selectIfPresent(Arrays.asList(columns));
}
return this;
}
/**
* 查询字段为空不添加到查询语句中
* @param columns 要查询的数据库表字段 集合
* @return 查询构造器 QueryWrapper
*/
public QueryWrapper<T> selectIfPresent(Collection<String> columns) {
if (CollectionUtils.isNotEmpty(columns)) {
columns.stream().forEach(column -> {
if (StringUtils.hasText(column)){
super.select(column);
}
});
}
return this;
}
//TODO ========== 重写父类方法，方便链式调用 可根据需要进行重写 ==========
@Override
public QueryWrapper<T> eq(boolean condition, String column, Object val) {
super.eq(condition, column, val);
return this;
}
@Override
public QueryWrapper<T> eq(String column, Object val) {
super.eq(column, val);
return this;
}
@Override
public QueryWrapper<T> orderByDesc(String column) {
super.orderByDesc(column);
return this;
}
@Override
public QueryWrapper<T> last(String lastSql) {
super.last(lastSql);
return this;
}
@Override
public QueryWrapper<T> in(String column, Collection<?> coll) {
super.in(column, coll);
return this;
}
@Override
public QueryWrapper<T> in(String column, Object... values) {
super.in(column, values);
return this;
}
@Override
public QueryWrapper<T> select(List<String> columns) {
super.select(columns);
return this;
}
}
LambdaQueryWrapper 封装代码如下：
继承原生的MyBatis-Plus的LambdaQueryWrapper类进行实现
import com.baomidou.mybatisplus.core.toolkit.ArrayUtils;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import org.springframework.util.StringUtils;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
/**
* 拓展 MyBatis Plus LambdaQueryWrapper 类,主要增加如下功能
* <p>
* 拼接条件的方法，增加 xxxIfPresent 方法，用于判断值不存在的时候，不要拼接到条件中。
* <li> SFunction<T, ?>是一个泛型函数式接口，其中T表示实体类类型，?表示字段数据类型 </li>
* <li> 例如：SFunction<User, String> user -> user.getName() </li>
* <li> 表示User对象的getName()方法返回一个String类型的值 </li>
* @author gremlin
* @param <T> 数据类型
*/
public class LambdaQueryWrapper<T> extends com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<T> {
/**
* 等于条件判断 单条件
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param val 条件值
* @return 查询构造器 LambdaQueryWrapper<T>
*/
public LambdaQueryWrapper<T> eqIfPresent(SFunction<T, ?> column, Object val) {
if (val != null) {
// 如果是String 判断是否为空字符串或者有空白
if (val instanceof String){
if (StringUtils.hasText(val.toString())){
return (LambdaQueryWrapper<T>) super.eq(column, val);
} else {
return this;
}
} else {
return (LambdaQueryWrapper<T>) super.eq(column, val);
}
}
return this;
}
/**
* 等于条件判断 两个条件
* @param column1 SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段1
* @param column2 SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段2
* @param val1 条件值1
* @param val2 条件值2
* @return 查询构造器 LambdaQueryWrapper<T>
*/
public LambdaQueryWrapper<T> eqIfPresent(SFunction<T, ?> column1, Object val1,SFunction<T, ?> column2, Object val2) {
if (val1 != null || val2 != null){
if (val1 != null) {
// 如果是String 判断是否为空字符串或者有空白
if (val1 instanceof String){
if (StringUtils.hasText(val1.toString())){
super.eq(column1, val1);
}
} else {
super.eq(column1, val1);
}
}
if (val2 != null) {
// 如果是String 判断是否为空字符串或者有空白
if (val2 instanceof String){
if (StringUtils.hasText(val2.toString())){
super.eq(column2, val2);
}
} else {
super.eq(column2, val2);
}
}
}
return this;
}
/**
* 全模糊条件判断 LIKE '%值%'
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param val 条件值
* @return 查询构造器 LambdaQueryWrapper<T>
*/
public LambdaQueryWrapper<T> likeIfPresent(SFunction<T, ?> column, String val) {
if (StringUtils.hasText(val)) {
return (LambdaQueryWrapper<T>) super.like(column, val);
}
return this;
}
/**
* 左模糊条件判断 LIKE '%值'
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param val 条件值
* @return 查询构造器 LambdaQueryWrapper<T>
*/
public LambdaQueryWrapper<T> likeLeftIfPresent(SFunction<T, ?> column, String val) {
if (StringUtils.hasText(val)) {
return (LambdaQueryWrapper<T>) super.likeLeft(column, val);
}
return this;
}
/**
* 右模糊条件判断 LIKE '值%'
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param val 条件值
* @return 查询构造器 LambdaQueryWrapper<T>
*/
public LambdaQueryWrapper<T> likeRightIfPresent(SFunction<T, ?> column, String val) {
if (StringUtils.hasText(val)) {
return (LambdaQueryWrapper<T>) super.likeRight(column, val);
}
return this;
}
/**
* 全模糊不匹配条件判断 NOT LIKE '%值%'
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param val 条件值
* @return 查询构造器 LambdaQueryWrapper<T>
*/
public LambdaQueryWrapper<T> notLikeIfPresent(SFunction<T, ?> column, String val) {
if (StringUtils.hasText(val)) {
return (LambdaQueryWrapper<T>) super.notLike(column, val);
}
return this;
}
/**
* 左模糊不匹配条件判断 NOT LIKE '%值'
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param val 条件值
* @return 查询构造器 LambdaQueryWrapper<T>
*/
public LambdaQueryWrapper<T> notLikeLeftIfPresent(SFunction<T, ?> column, String val) {
if (StringUtils.hasText(val)) {
return (LambdaQueryWrapper<T>) super.notLikeLeft(column, val);
}
return this;
}
/**
* 右模糊不匹配条件判断 NOT LIKE '%值'
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param val 条件值
* @return 查询构造器 LambdaQueryWrapper<T>
*/
public LambdaQueryWrapper<T> notLikeRightIfPresent(SFunction<T, ?> column, String val) {
if (StringUtils.hasText(val)) {
return (LambdaQueryWrapper<T>) super.notLikeRight(column, val);
}
return this;
}
/**
* in 条件判断
* 字段 in (value.get(0), value.get(1), ...)
* <p>例: in("id", Arrays.asList(1, 2, 3, 4, 5))</p>
* <li> 如果集合为 empty 则不会进行 sql 拼接 </li>
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param values 条件值 集合（set,list）
* @return 查询构造器 LambdaQueryWrapper<T>
*/
public LambdaQueryWrapper<T> inIfPresent(SFunction<T, ?> column, Collection<?> values) {
if (CollectionUtils.isNotEmpty(values)) {
return (LambdaQueryWrapper<T>) super.in(column, values);
}
return this;
}
/**
* notIn 条件判断
* 字段 notIn (value.get(0), value.get(1), ...)
* <p>例: notIn("id", Arrays.asList(1, 2, 3, 4, 5))</p>
* <li> 如果集合为 empty 则不会进行 sql 拼接 </li>
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param values 条件值 集合（set,list）
* @return 查询构造器 LambdaQueryWrapper<T>
*/
public LambdaQueryWrapper<T> notInIfPresent(SFunction<T, ?> column, Collection<?> values) {
if (CollectionUtils.isNotEmpty(values)) {
return (LambdaQueryWrapper<T>) super.notIn(column, values);
}
return this;
}
/**
* 字段 in (v0, v1, ...)
* <p>例: in("id", 1, 2, 3, 4, 5)</p>
* <p>例: in("id", Arrays.asList(1, 2, 3, 4, 5))</p>
* <li> 如果集合为 empty 则不会进行 sql 拼接 </li>
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param values 条件值 数组
* @return 查询构造器 LambdaQueryWrapper<T>
*/
public LambdaQueryWrapper<T> inIfPresent(SFunction<T, ?> column, Object... values) {
if (ArrayUtils.isNotEmpty(values)) {
return (LambdaQueryWrapper<T>) super.in(column, values);
}
return this;
}
/**
* 字段 in (v0, v1, ...)
* <p>例: in("id", 1, 2, 3, 4, 5)</p>
* <p>例: in("id", Arrays.asList(1, 2, 3, 4, 5))</p>
* <li> 如果集合为 empty 则不会进行 sql 拼接 </li>
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param values 条件值 数组
* @return 查询构造器 LambdaQueryWrapper<T>
*/
public LambdaQueryWrapper<T> notInIfPresent(SFunction<T, ?> column, Object... values) {
if (ArrayUtils.isNotEmpty(values)) {
return (LambdaQueryWrapper<T>) super.notIn(column, values);
}
return this;
}
/**
* 不等于 < > 条件判断
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param val 条件值
* @return 查询构造器 LambdaQueryWrapper<T>
*/
public LambdaQueryWrapper<T> neIfPresent(SFunction<T, ?> column, Object val) {
if (val != null) {
return (LambdaQueryWrapper<T>) super.ne(column, val);
}
return this;
}
/**
* 大于 > 条件判断
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param val 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public LambdaQueryWrapper<T> gtIfPresent(SFunction<T, ?> column, Object val) {
if (val != null) {
return (LambdaQueryWrapper<T>) super.gt(column, val);
}
return this;
}
/**
* 大于等于 >= 条件判断
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param val 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public LambdaQueryWrapper<T> geIfPresent(SFunction<T, ?> column, Object val) {
if (val != null) {
return (LambdaQueryWrapper<T>) super.ge(column, val);
}
return this;
}
/**
* 小于 < 条件判断
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param val 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public LambdaQueryWrapper<T> ltIfPresent(SFunction<T, ?> column, Object val) {
if (val != null) {
return (LambdaQueryWrapper<T>) super.lt(column, val);
}
return this;
}
/**
* 小于等于 <= 条件判断
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param val 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public LambdaQueryWrapper<T> leIfPresent(SFunction<T, ?> column, Object val) {
if (val != null) {
return (LambdaQueryWrapper<T>) super.le(column, val);
}
return this;
}
/**
* 值1与值2之间 包含值1和值2
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param val1 条件值
* @param val2 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public LambdaQueryWrapper<T> betweenIfPresent(SFunction<T, ?> column, Object val1, Object val2) {
if (val1 != null && val2 != null) {
return (LambdaQueryWrapper<T>) super.between(column, val1, val2);
}
if (val1 != null) {
return (LambdaQueryWrapper<T>) ge(column, val1);
}
if (val2 != null) {
return (LambdaQueryWrapper<T>) le(column, val2);
}
return this;
}
/**
* 值1与值2之间 包含值1和值2,有效值个数2个
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param values 数组
* @return 查询构造器 QueryWrapper<T>
*/
public LambdaQueryWrapper<T> betweenIfPresent(SFunction<T, ?> column, Object ... values) {
if (com.baomidou.mybatisplus.core.toolkit.ArrayUtils.isNotEmpty(values)){
if (values[0] != null && values[1] != null) {
return (LambdaQueryWrapper<T>) super.between(column, values[0], values[1]);
}
if (values[0] != null) {
return (LambdaQueryWrapper<T>) ge(column, values[0]);
}
if (values[1] != null) {
return (LambdaQueryWrapper<T>) le(column, values[1]);
}
}
return this;
}
/**
* 值1与值2之间 结果包含值1和值2,有效值个数2个
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param valueCollect 数组
* @return 查询构造器 QueryWrapper<T>
*/
public LambdaQueryWrapper<T> betweenIfPresent(SFunction<T, ?> column, Collection<?> valueCollect) {
if (CollectionUtils.isNotEmpty(valueCollect)) {
Object[] values = valueCollect.toArray();
if (Objects.nonNull(values[0]) && Objects.nonNull(values[1])) {
return (LambdaQueryWrapper<T>) super.between(column, values[0], values[1]);
}
if (Objects.nonNull(values[0])) {
return (LambdaQueryWrapper<T>) ge(column, values[0]);
}
if (Objects.nonNull(values[1])) {
return (LambdaQueryWrapper<T>) le(column, values[1]);
}
}
return this;
}
/**
* 不在值1与值2之间 结果不包含值1和值2
* @param column SFunction<T, ?>类型的函数式接口,用于指定查询条件的字段
* @param val1 条件值
* @param val2 条件值
* @return 查询构造器 QueryWrapper<T>
*/
public LambdaQueryWrapper<T> notBetweenIfPresent(SFunction<T, ?> column, Object val1, Object val2) {
if (val1 != null && val2 != null) {
return (LambdaQueryWrapper<T>) super.notBetween(column, val1, val2);
}
if (val1 != null) {
return (LambdaQueryWrapper<T>) gt(column, val1);
}
if (val2 != null) {
return (LambdaQueryWrapper<T>) lt(column, val2);
}
return this;
}
/**
* 查询字段为空不添加到查询语句中
* @param columns 要查询的实体类字段数组
* @return 查询构造器 QueryWrapper
*/
@SafeVarargs
public final LambdaQueryWrapper<T> selectIfPresent(SFunction<T, ?>... columns) {
if (ArrayUtils.isNotEmpty(columns)) {
return selectIfPresent(Arrays.asList(columns));
}
return this;
}
/**
* 查询字段为空不添加到查询语句中
* @param columns 要查询的实体类字段 集合
* @return 查询构造器 QueryWrapper
*/
public LambdaQueryWrapper<T> selectIfPresent(Collection<SFunction<T, ?>> columns) {
if (CollectionUtils.isNotEmpty(columns)) {
columns.stream().forEach(column -> {
if (StringUtils.hasText((CharSequence) column)){
super.select(column);
}
});
}
return this;
}
// TODO ========== 重写父类方法，方便链式调用 可根据需要进行重写 ==========
@Override
public LambdaQueryWrapper<T> eq(boolean condition, SFunction<T, ?> column, Object val) {
super.eq(condition, column, val);
return this;
}
@Override
public LambdaQueryWrapper<T> eq(SFunction<T, ?> column, Object val) {
super.eq(column, val);
return this;
}
@Override
public LambdaQueryWrapper<T> orderByDesc(SFunction<T, ?> column) {
super.orderByDesc(column);
return this;
}
@Override
public LambdaQueryWrapper<T> last(String lastSql) {
super.last(lastSql);
return this;
}
@Override
public LambdaQueryWrapper<T> in(SFunction<T, ?> column, Collection<?> coll) {
super.in(column, coll);
return this;
}
@Override
public LambdaQueryWrapper<T> in(SFunction<T, ?> column, Object ... values) {
super.in(column, values);
return this;
}
@Override
public LambdaQueryWrapper<T> select(List<SFunction<T, ?>> columns) {
super.select(columns);
return this;
}
}
892
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
