修改查询和删除

src/main/java/cn/flowbb/framework/mybatis/core/mapper/BaseMapperX.java

@@ -4,15 +4,12 @@ import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-
 import org.apache.ibatis.annotations.Param;
 import org.apache.ibatis.logging.Log;
 import org.apache.ibatis.logging.LogFactory;
-
 import com.baomidou.mybatisplus.core.conditions.Wrapper;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.core.enums.SqlMethod;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
@@ -27,14 +24,12 @@ import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
 import com.github.yulichang.base.MPJBaseMapper;
 import com.github.yulichang.interfaces.MPJBaseJoin;
 import com.github.yulichang.wrapper.MPJLambdaWrapper;
-
 import cn.flowbb.framework.mybatis.common.pojo.PageParam;
 import cn.flowbb.framework.mybatis.common.pojo.PageResult;
 import cn.flowbb.framework.mybatis.common.pojo.SortablePageParam;
 import cn.flowbb.framework.mybatis.common.pojo.SortingField;
 import cn.flowbb.framework.mybatis.core.util.DbX;
 import cn.flowbb.framework.mybatis.core.util.MyBatisUtils;
-import cn.hutool.core.collection.CollUtil;
 
 /**
  * 在 MyBatis Plus 的 BaseMapper 的基础上拓展，提供更多的能力
@@ -89,52 +84,61 @@ public interface BaseMapperX<T> extends MPJBaseMapper<T> {
 		return new PageResult<>(mpPage.getRecords(), mpPage.getTotal());
 	}
 
-	// ------selectOne查询从一个条件到三个条件---start--------------------------------------------
+	// -按照字段查询-----这是eq得查询
 	default T selectOne(String field, Object value) {
 		return selectOne(new QueryWrapper<T>().eq(field, value));
 	}
 
-	default T selectOne(SFunction<T, ?> field, Object value) {
-		return selectOne(new LambdaQueryWrapper<T>().eq(field, value));
+	default T selectOne(String field, Collection<?> value) {
+		return selectOne(new QueryWrapper<T>().in(field, value));
 	}
 
 	default T selectOne(String field1, Object value1, String field2, Object value2) {
 		return selectOne(new QueryWrapper<T>().eq(field1, value1).eq(field2, value2));
 	}
 
-	default T selectOne(SFunction<T, ?> field1, Object value1, SFunction<T, ?> field2, Object value2) {
-		return selectOne(new LambdaQueryWrapper<T>().eq(field1, value1).eq(field2, value2));
+	default T selectOne(String field1, Collection<?> value1, String field2, Collection<?> value2) {
+		return selectOne(new QueryWrapper<T>().in(field1, value1).in(field2, value2));
+	}
+
+	default T selectOne(String field1, Object value1, String field2, Collection<?> value2) {
+		return selectOne(new QueryWrapper<T>().eq(field1, value1).in(field2, value2));
+	}
+
+	default T selectOne(String field1, Collection<?> value1, String field2, Object value2) {
+		return selectOne(new QueryWrapper<T>().in(field1, value1).eq(field2, value2));
 	}
 
 	default T selectOne(String field1, Object value1, String field2, Object value2, String field3, Object value3) {
 		return selectOne(new QueryWrapper<T>().eq(field1, value1).eq(field2, value2).eq(field3, value3));
 	}
 
-	default T selectOne(SFunction<T, ?> field1, Object value1, SFunction<T, ?> field2, Object value2,
-			SFunction<T, ?> field3, Object value3) {
-		return selectOne(new LambdaQueryWrapper<T>().eq(field1, value1).eq(field2, value2).eq(field3, value3));
+	default T selectOne(String field1, Object value1, String field2, Object value2, String field3,
+			Collection<?> value3) {
+		return selectOne(new QueryWrapper<T>().eq(field1, value1).eq(field2, value2).in(field3, value3));
 	}
-	// ------selectOne查询从一个条件到三个条件---end--------------------------------------------
 
-	// 查询in得集合----------------start---------------------------------------
-	default List<T> selectIn(String field, Collection<?> value) {
-		return selectList(new QueryWrapper<T>().in(field, value));
+	default T selectOne(String field1, Object value1, String field2, Collection<?> value2, String field3,
+			Collection<?> value3) {
+		return selectOne(new QueryWrapper<T>().eq(field1, value1).in(field2, value2).in(field3, value3));
 	}
 
-	default List<T> selectIn(SFunction<T, ?> field, Collection<?> value) {
-		return selectList(new LambdaQueryWrapper<T>().in(field, value));
+	default T selectOne(String field1, Collection<?> value1, String field2, Collection<?> value2, String field3,
+			Collection<?> value3) {
+		return selectOne(new QueryWrapper<T>().in(field1, value1).in(field2, value2).in(field3, value3));
 	}
 
-	default List<T> selectIn(String field1, Collection<?> value1, String field2, Collection<?> value2) {
-		return selectList(new QueryWrapper<T>().in(field1, value1).in(field2, value2));
+	default T selectOne(String field1, Collection<?> value1, String field2, Collection<?> value2, String field3,
+			Object value3) {
+		return selectOne(new QueryWrapper<T>().in(field1, value1).in(field2, value2).eq(field3, value3));
 	}
 
-	default List<T> selectIn(SFunction<T, ?> field1, Collection<?> value1, SFunction<T, ?> field2,
-			Collection<?> value2) {
-		return selectList(new LambdaQueryWrapper<T>().in(field1, value1).in(field2, value2));
+	default T selectOne(String field1, Collection<?> value1, String field2, Object value2, String field3,
+			Object value3) {
+		return selectOne(new QueryWrapper<T>().in(field1, value1).eq(field2, value2).eq(field3, value3));
 	}
 
-	// 查询in得集合----------------end---------------------------------------
+	// ------selectOne查询从一个条件到三个条件---end--------------------------------------------
 
 	// 查询selectCount----------------start----------------------
 	default Long selectCount() {
@@ -145,17 +149,55 @@ public interface BaseMapperX<T> extends MPJBaseMapper<T> {
 		return selectCount(new QueryWrapper<T>().eq(field, value));
 	}
 
-	default Long selectCount(SFunction<T, ?> field, Object value) {
-		return selectCount(new LambdaQueryWrapper<T>().eq(field, value));
+	default Long selectCount(String field, Collection<?> value) {
+		return selectCount(new QueryWrapper<T>().in(field, value));
 	}
 
 	default Long selectCount(String field1, Object value1, String field2, Object value2) {
-		return selectCount(new QueryWrapper<T>().eq(field2, value2));
+		return selectCount(new QueryWrapper<T>().eq(field1, value1).eq(field2, value2));
+	}
+
+	default Long selectCount(String field1, Collection<?> value1, String field2, Collection<?> value2) {
+		return selectCount(new QueryWrapper<T>().in(field1, value1).in(field2, value2));
 	}
 
-	default Long selectCount(SFunction<T, ?> field1, Object value1, SFunction<T, ?> field2, Object value2) {
-		return selectCount(new LambdaQueryWrapper<T>().eq(field1, value1).eq(field2, value2));
+	default Long selectCount(String field1, Object value1, String field2, Collection<?> value2) {
+		return selectCount(new QueryWrapper<T>().eq(field1, value1).in(field2, value2));
 	}
+
+	default Long selectCount(String field1, Collection<?> value1, String field2, Object value2) {
+		return selectCount(new QueryWrapper<T>().in(field1, value1).eq(field2, value2));
+	}
+
+	default Long selectCount(String field1, Object value1, String field2, Object value2, String field3, Object value3) {
+		return selectCount(new QueryWrapper<T>().eq(field1, value1).eq(field2, value2).eq(field3, value3));
+	}
+
+	default Long selectCount(String field1, Object value1, String field2, Object value2, String field3,
+			Collection<?> value3) {
+		return selectCount(new QueryWrapper<T>().eq(field1, value1).eq(field2, value2).in(field3, value3));
+	}
+
+	default Long selectCount(String field1, Object value1, String field2, Collection<?> value2, String field3,
+			Collection<?> value3) {
+		return selectCount(new QueryWrapper<T>().eq(field1, value1).in(field2, value2).in(field3, value3));
+	}
+
+	default Long selectCount(String field1, Collection<?> value1, String field2, Collection<?> value2, String field3,
+			Collection<?> value3) {
+		return selectCount(new QueryWrapper<T>().in(field1, value1).in(field2, value2).in(field3, value3));
+	}
+
+	default Long selectCount(String field1, Collection<?> value1, String field2, Collection<?> value2, String field3,
+			Object value3) {
+		return selectCount(new QueryWrapper<T>().in(field1, value1).in(field2, value2).eq(field3, value3));
+	}
+
+	default Long selectCount(String field1, Collection<?> value1, String field2, Object value2, String field3,
+			Object value3) {
+		return selectCount(new QueryWrapper<T>().in(field1, value1).eq(field2, value2).eq(field3, value3));
+	}
+
 	// 查询selectCount----------------end----------------------
 
 	// 查询selectList----------------start----------------------
@@ -163,79 +205,134 @@ public interface BaseMapperX<T> extends MPJBaseMapper<T> {
 		return selectList(new QueryWrapper<>());
 	}
 
-	// 这里是equal操作查询
 
 	default List<T> selectList(String field, Object value) {
 		return selectList(new QueryWrapper<T>().eq(field, value));
 	}
 
-	default List<T> selectList(SFunction<T, ?> field, Object value) {
-		return selectList(new LambdaQueryWrapper<T>().eq(field, value));
+	default List<T> selectList(String field, Collection<?> value) {
+		return selectList(new QueryWrapper<T>().in(field, value));
 	}
 
 	default List<T> selectList(String field1, Object value1, String field2, Object value2) {
 		return selectList(new QueryWrapper<T>().eq(field1, value1).eq(field2, value2));
 	}
 
-	default List<T> selectList(SFunction<T, ?> field1, Object value1, SFunction<T, ?> field2, Object values) {
-		return selectList(new LambdaQueryWrapper<T>().in(field1, value1).eq(field2, values));
+	default List<T> selectList(String field1, Collection<?> value1, String field2, Collection<?> value2) {
+		return selectList(new QueryWrapper<T>().in(field1, value1).in(field2, value2));
 	}
 
-	// 这个是list in 查询
-	default List<T> selectList(String field, Collection<?> value) {
-		return selectList(new QueryWrapper<T>().in(field, value));
+	default List<T> selectList(String field1, Object value1, String field2, Collection<?> value2) {
+		return selectList(new QueryWrapper<T>().eq(field1, value1).in(field2, value2));
 	}
 
-	default List<T> selectList(SFunction<T, ?> field, Collection<?> value) {
-		return selectList(new LambdaQueryWrapper<T>().in(field, value));
+	default List<T> selectList(String field1, Collection<?> value1, String field2, Object value2) {
+		return selectList(new QueryWrapper<T>().in(field1, value1).eq(field2, value2));
 	}
 
-	default List<T> selectList(String field1, Collection<?> value1, String field2, Collection<?> value2) {
-		return selectList(new QueryWrapper<T>().in(field1, value1).in(field2, value2));
+	default List<T> selectList(String field1, Object value1, String field2, Object value2, String field3, Object value3) {
+		return selectList(new QueryWrapper<T>().eq(field1, value1).eq(field2, value2).eq(field3, value3));
 	}
 
-	default List<T> selectList(SFunction<T, ?> field1, Collection<?> value1, SFunction<T, ?> field2,
-			Collection<?> values) {
-		return selectList(new LambdaQueryWrapper<T>().in(field1, value1).in(field2, values));
+	default List<T> selectList(String field1, Object value1, String field2, Object value2, String field3,
+			Collection<?> value3) {
+		return selectList(new QueryWrapper<T>().eq(field1, value1).eq(field2, value2).in(field3, value3));
 	}
 
-	// 这里是equal和in操作查询
-
-	default List<T> selectList(SFunction<T, ?> field1, Collection<?> value1, SFunction<T, ?> field2, Object values) {
-		return selectList(new LambdaQueryWrapper<T>().in(field1, value1).eq(field2, values));
+	default List<T> selectList(String field1, Object value1, String field2, Collection<?> value2, String field3,
+			Collection<?> value3) {
+		return selectList(new QueryWrapper<T>().eq(field1, value1).in(field2, value2).in(field3, value3));
 	}
 
-	default List<T> selectList(SFunction<T, ?> field1, Object value1, SFunction<T, ?> field2, Collection<?> value2) {
-		return selectList(new LambdaQueryWrapper<T>().eq(field1, value1).in(field2, value2));
+	default List<T> selectList(String field1, Collection<?> value1, String field2, Collection<?> value2, String field3,
+			Collection<?> value3) {
+		return selectList(new QueryWrapper<T>().in(field1, value1).in(field2, value2).in(field3, value3));
 	}
 
-	default List<T> selectList(String field1, Collection<?> value1, String field2, Object values2) {
-		return selectList(new QueryWrapper<T>().in(field1, value1).eq(field2, values2));
+	default List<T> selectList(String field1, Collection<?> value1, String field2, Collection<?> value2, String field3,
+			Object value3) {
+		return selectList(new QueryWrapper<T>().in(field1, value1).in(field2, value2).eq(field3, value3));
 	}
 
-	default List<T> selectList(String field1, Object value1, String field2, Collection<?> value2) {
-		return selectList(new QueryWrapper<T>().eq(field1, value1).in(field2, value2));
+	default List<T> selectList(String field1, Collection<?> value1, String field2, Object value2, String field3,
+			Object value3) {
+		return selectList(new QueryWrapper<T>().in(field1, value1).eq(field2, value2).eq(field3, value3));
 	}
 
 	// 查询selectList----------------end----------------------
 
-	// 删除条件-----------------------start--------------------------------
+	// 删除条件---equal--------------------start--------------------------------
 	default int delete(String field, Object value) {
 		return delete(new QueryWrapper<T>().eq(field, value));
 	}
 
-	default int delete(SFunction<T, ?> field, Object value) {
-		return delete(new LambdaQueryWrapper<T>().eq(field, value));
+	 
+	default int delete(String field, Collection<?> value) {
+		return delete(new QueryWrapper<T>().in(field, value));
+	}
+
+	default int delete(String field1, Object value1, String field2, Object value2) {
+		return delete(new QueryWrapper<T>().eq(field1, value1).eq(field2, value2));
+	}
+
+	default int delete(String field1, Collection<?> value1, String field2, Collection<?> value2) {
+		return delete(new QueryWrapper<T>().in(field1, value1).in(field2, value2));
+	}
+
+	default int delete(String field1, Object value1, String field2, Collection<?> value2) {
+		return delete(new QueryWrapper<T>().eq(field1, value1).in(field2, value2));
+	}
+
+	default int delete(String field1, Collection<?> value1, String field2, Object value2) {
+		return delete(new QueryWrapper<T>().in(field1, value1).eq(field2, value2));
+	}
+
+	default int delete(String field1, Object value1, String field2, Object value2, String field3, Object value3) {
+		return delete(new QueryWrapper<T>().eq(field1, value1).eq(field2, value2).eq(field3, value3));
+	}
+
+	default int delete(String field1, Object value1, String field2, Object value2, String field3,
+			Collection<?> value3) {
+		return delete(new QueryWrapper<T>().eq(field1, value1).eq(field2, value2).in(field3, value3));
 	}
 
-	default int delete(String field, Collection<?> values) {
-		return delete(new QueryWrapper<T>().in(field, values));
+	default int delete(String field1, Object value1, String field2, Collection<?> value2, String field3,
+			Collection<?> value3) {
+		return delete(new QueryWrapper<T>().eq(field1, value1).in(field2, value2).in(field3, value3));
 	}
 
-	default int delete(SFunction<T, ?> field, Collection<?> values) {
-		return delete(new LambdaQueryWrapper<T>().in(field, values));
+	default int delete(String field1, Collection<?> value1, String field2, Collection<?> value2, String field3,
+			Collection<?> value3) {
+		return delete(new QueryWrapper<T>().in(field1, value1).in(field2, value2).in(field3, value3));
 	}
 
+	default int delete(String field1, Collection<?> value1, String field2, Collection<?> value2, String field3,
+			Object value3) {
+		return delete(new QueryWrapper<T>().in(field1, value1).in(field2, value2).eq(field3, value3));
+	}
+
+	default int delete(String field1, Collection<?> value1, String field2, Object value2, String field3,
+			Object value3) {
+		return delete(new QueryWrapper<T>().in(field1, value1).eq(field2, value2).eq(field3, value3));
+	}
+
+	// -------按照-----Lambda表达式查询----------------------------------------------------------------
+	default T selectOne(SFunction<T, ?> field, Object value) {
+		return selectOne(new LambdaQueryWrapper<T>().eq(field, value));
+
+	}
+
+	default T selectOne(SFunction<T, ?> field1, Object value1, SFunction<T, ?> field2, Object value2) {
+		return selectOne(new LambdaQueryWrapper<T>().eq(field1, value1).eq(field2, value2));
+	}
+
+	default T selectOne(SFunction<T, ?> field1, Object value1, SFunction<T, ?> field2, Object value2,
+			SFunction<T, ?> field3, Object value3) {
+		return selectOne(new LambdaQueryWrapper<T>().eq(field1, value1).eq(field2, value2).eq(field3, value3));
+	}
+
+	// -----------------------------------------------------------------------
+
 	// 删除条件-----------------------end--------------------------------
 	/**
 	 * 批量插入，适合大量数据插入

src/main/java/cn/flowbb/framework/mybatis/core/service/AbstractService.java

@@ -224,29 +224,14 @@ public interface AbstractService<T> extends MPJBaseService<T> {
 		return getBaseMapper().selectList(field, value);
 	}
 
-	default List<T> selectList(SFunction<T, ?> field, Collection<?> value) {
-		return getBaseMapper().selectList(field, value);
-	}
-
+ 
 	default List<T> selectList(String field1, Collection<?> value1, String field2, Collection<?> value2) {
 		return getBaseMapper().selectList(field1, value1, field2, value2);
 	}
 
-	default List<T> selectList(SFunction<T, ?> field1, Collection<?> value1, SFunction<T, ?> field2,
-			Collection<?> values) {
-		return getBaseMapper().selectList(field1, value1, field2, values);
-	}
-
+	 
 	// 这里是equal和in操作查询
-
-	default List<T> selectList(SFunction<T, ?> field1, Collection<?> value1, SFunction<T, ?> field2, Object values) {
-		return getBaseMapper().selectList(field1, value1, field2, values);
-	}
-
-	default List<T> selectList(SFunction<T, ?> field1, Object value1, SFunction<T, ?> field2, Collection<?> value2) {
-		return getBaseMapper().selectList(field1, value1, field2, value2);
-	}
-
+  
 	default List<T> selectList(String field1, Collection<?> value1, String field2, Object values2) {
 		return getBaseMapper().selectList(field1, value1, field2, values2);
 	}
@@ -254,46 +239,20 @@ public interface AbstractService<T> extends MPJBaseService<T> {
 	default List<T> selectList(String field1, Object value1, String field2, Collection<?> value2) {
 		return getBaseMapper().selectList(field1, value1, field2, value2);
 	}
-
 	// 查询selectList----------------end----------------------
-
 	// 查询selectList----------------end----------------------
 
-	// 查询in得集合----------------start---------------------------------------
-	default List<T> in(String field, Collection<?> value) {
-		return getBaseMapper().selectIn(field, value);
-	}
-
-	default List<T> in(SFunction<T, ?> field, Collection<?> value) {
-		return getBaseMapper().selectIn(field, value);
-	}
-
-	default List<T> in(String field1, Collection<?> value1, String field2, Collection<?> value2) {
-		return getBaseMapper().selectIn(field1, value1, field2, value2);
-	}
-
-	default List<T> in(SFunction<T, ?> field1, Collection<?> value1, SFunction<T, ?> field2, Collection<?> value2) {
-		return getBaseMapper().selectIn(field1, value1, field2, value2);
-	}
-
-	// 查询in得集合----------------end---------------------------------------
-
 	// 查询remove----------------start----------------------
 	default int remove(String field, Object value) {
 		return getBaseMapper().delete(field, value);
 	}
-
-	default int remove(SFunction<T, ?> field, Object value) {
-		return getBaseMapper().delete(field, value);
-	}
+ 
 
 	default int remove(String field, Collection<?> values) {
 		return getBaseMapper().delete(field, values);
 	}
 
-	default int remove(SFunction<T, ?> field, Collection<?> values) {
-		return getBaseMapper().delete(field, values);
-	}
+	 
 
 	// 查询remove----------------end----------------------