本博客中的内容是作者是企业中开发时实际用到的功能，感兴趣的读者可以将代码整合到自己的项目中，然后结合自己身业务进行调整。
表示关系运算的常量public interface Logic {
String and = "AND";
String or = "OR";
}
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Between {
/**
* 逻辑
*
* @return
*/
String logic() default Logic.and;
String min() default "";
String max() default "";
}
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface EQ {
/**
* 逻辑
*
* @return
*/
String logic() default Logic.and;
String value() default "";
}
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface IN {
/**
* 逻辑
*
* @return
*/
String logic() default Logic.and;
String value() default "";
}
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Like {
/**
* 逻辑
*
* @return
*/
String logic() default "AND";
String value() default "";
}
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface NE {
/**
* 逻辑
*
* @return
*/
String logic() default Logic.and;
String value() default "";
}
public class SQLUtil {
public static String getTableName(Class clazz) {
String className = clazz.getSimpleName();
String tableName = StringUtil.hump2underscore(className);
return tableName;
}
public static String getTableColumns(Class clazz) {
Field[] fields = clazz.getDeclaredFields();
List fieldNames = new ArrayList();
for (Field field : fields) {
String fieldName = field.getName();
if (fieldName.equals("serialVersionUID")) {
continue;
}
String columnName = StringUtil.hump2underscore(fieldName);
fieldNames.add(columnName);
}
String columns = String.join(",", fieldNames);
return columns;
}
public static void main(String[] args) {
System.out.println(StringUtil.hump2underscore("Project"));
System.out.println(StringUtil.hump2underscore("SaleGrade"));
final String tableName = getTableName(Project.class);
System.out.println(tableName);
final String tableColumns = getTableColumns(Project.class);
System.out.println(tableColumns);
}
}
public class MyBatisUtil {
/**
* 获取Mapper接口对应的实体类的字节码
*
* @param context
* @return
*/
private static Class getEntityClass(ProviderContext context) {
//获取Mapper接口名
final Class mapperType = context.getMapperType();
//获取带参数化类型的通用Mapper
final ParameterizedType parameterizedType = (ParameterizedType) (mapperType.getGenericInterfaces()[0]);
//获取通用mapper的第二个泛型参数的字节码
final Class clazz = (Class) parameterizedType.getActualTypeArguments()[1];
return clazz;
}
/**
* 获取表名
*
* @param context
* @return
*/
public static String getTableName(ProviderContext context) {
final Class clazz = getEntityClass(context);
//获取表名
final String tableName = SQLUtil.getTableName(clazz);
return "tb_" + tableName;
}
/**
* 获取表字段列表
*
* @param context
* @return
*/
public static String getTableColumns(ProviderContext context) {
final Class clazz = getEntityClass(context);
//获取字段列表
final String tableColumns = SQLUtil.getTableColumns(clazz);
return tableColumns;
}
}
/**
* @param 主键类型类名
* @param 实体类类名
* @author hc
*
* 通用Mapper
*/
public interface BaseMapper {
/**
* 根据ID进行查找
*
* @param id
* @return
*/
@SelectProvider(type = BaseMapperProvider.class, method = "selectById")
E selectById(K id);
/**
* 根据条件进行查询
*
* @param baseQuery
* @return
*/
@SelectProvider(type = BaseMapperProvider.class, method = "selectByCondition")
List selectByCondition(BaseQuery baseQuery);
/**
* 插入数据
*
* @param e
* @return
*/
@InsertProvider(type = BaseMapperProvider.class, method = "insert")
@Options(useGeneratedKeys = true, keyProperty = "id", keyColumn = "id")
//@Options和@SelectKey都能够实现功能：返回新增记录的自增长主键id字段值
//@SelectKey(statement = "select last_insert_id()",keyProperty = "id",before = false,resultType = Long.class)
int insert(E e);
/**
* 选择性插入数据
*
* @param e
* @return
*/
@InsertProvider(type = BaseMapperProvider.class, method = "insertSelective")
@Options(useGeneratedKeys = true, keyProperty = "id", keyColumn = "id")
int insertSelective(E e);
/**
* 批量插入数据
*
* @param list
* @return
*/
@InsertProvider(type = BaseMapperProvider.class, method = "batchInsert")
@Options(useGeneratedKeys = true, keyProperty = "id", keyColumn = "id")
int batchInsert(@Param("list") List list);
/**
* 根据ID更新数据
*
* @param e
* @return
*/
@UpdateProvider(type = BaseMapperProvider.class, method = "update")
int update(E e);
/**
* 选择性更新数据
*
* @param e
* @return
*/
@UpdateProvider(type = BaseMapperProvider.class, method = "updateSelective")
int updateSelective(E e);
/**
* 批量更新数据
*
* @param list
* @return
*/
@UpdateProvider(type = BaseMapperProvider.class, method = "batchUpdate")
int batchUpdate(List list);
/**
* 选择性地批量更新数据
*
* @param list
* @return
*/
@UpdateProvider(type = BaseMapperProvider.class, method = "batchUpdateSelective")
int batchUpdateSelective(List list);
/**
* 插入或更新数据
*
* @param e
* @return
*/
@InsertProvider(type = BaseMapperProvider.class, method = "insertOrUpdate")
int insertOrUpdate(E e);
/**
* 选择性插入或更新数据
*
* @param e
* @return
*/
@InsertProvider(type = BaseMapperProvider.class, method = "insertOrUpdateSelective")
int insertOrUpdateSelective(E e);
/**
* 修改指定ID的记录的状态
* 删除数据为逻辑删除：修改其状态state值为0
*
* @param id
* @param state
* @return
*/
@UpdateProvider(type = BaseMapperProvider.class, method = "updateStateById")
int updateStateById(@Param("id") K id, @Param("state") Integer state);
/**
* 批量修改指定数据的状态
*
* @param idList
* @param state
* @return
*/
@UpdateProvider(type = BaseMapperProvider.class, method = "batchUpdateStateById")
int batchUpdateStateById(@Param("idList") List idList, @Param("state") Integer state);
/**
* 根据ID删除：真正的物理删除
*
* @param id
* @return
*/
@DeleteProvider(type = BaseMapperProvider.class, method = "deleteById")
int deleteById(@Param("id") K id);
}
package com.hc.common.mybatisplus;
import com.hc.common.mybatisplus.anno.Between;
import com.hc.common.mybatisplus.anno.EQ;
import com.hc.common.mybatisplus.anno.IN;
import com.hc.common.mybatisplus.anno.Like;
import com.hc.common.mybatisplus.anno.NE;
import com.hc.common.mybatisplus.util.MyBatisUtil;
import com.hc.common.utils.StringUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.builder.annotation.ProviderContext;
import org.apache.ibatis.jdbc.SQL;
import java.io.Serializable;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.util.List;
/**
* @author hc
* 用来生成Mapper的具体实现
*/
@Slf4j
public class BaseMapperProvider {
private String basePackage = "com.hc.zhaopin";
/**
* 根据ID查找
*
* SELECT 字段列表
* FROM tb_project
* WHERE id = #{id}
*
* @param context
* @return
*/
public String selectById(ProviderContext context) {
//表名
final String tableName = MyBatisUtil.getTableName(context);
//列名
final String tableColumns = MyBatisUtil.getTableColumns(context);
String cols = "";
for (String field : tableColumns.split(",")) {
cols += field+" as "+ StringUtil.underline2hump(field)+", ";
}
cols = cols.substring(0,cols.length()-2);
final String sql = "SELECT " + cols + " FROM " + tableName + " WHERE id = #{id}";
return sql;
}
/**
* 根据条件进行查找
*
*SELECT 字段列表 FROM tb_project
*
*
* and name=#{name}
*
*
* and intro like #{intro}
*
*
* and resume_id in
*
* #{item}
*
*
*
*
* ORDER BY ${sorts}
*
*
* @param context
* @return
*/
public String selectByCondition(ProviderContext context) {
//表名
final String tableName = MyBatisUtil.getTableName(context);
//列名
final String tableColumns = MyBatisUtil.getTableColumns(context);
String cols = "";
for (String field : tableColumns.split(",")) {
cols += field+" as "+ StringUtil.underline2hump(field)+", ";
}
cols = cols.substring(0,cols.length()-2);
String sql = "";
sql += "SELECT " + cols + " FROM " + tableName + " ";
sql += "";
//获取实体类的名称
final String entityName = StringUtil.underline2hump(tableName.substring(3));
Class clazz = null;
try {
//利用反射获取Query类的字节码
clazz = Class.forName(basePackage + ".domain.query." + StringUtil.first2Upper(entityName) + "Query");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//获取Query类中都有哪些属性
final Field[] declaredFields = clazz.getDeclaredFields();
for (Field field : declaredFields) {
//获取Query类属性上的注解
final Annotation[] annotations = field.getAnnotations();
for (Annotation annotation : annotations) {
//获取Query类属性上的注解类型的字节码
final Class annotationType = annotation.annotationType();
//获取Query类属性的名称
final String fieldName = field.getName();
//获取Query类对应的表字段名
final String columnName = StringUtil.hump2underscore(fieldName);
if (Between.class == annotationType) {
Between between = (Between) annotation;
sql += "";
sql += between.logic() + " " + columnName + " BETWEEN '" + between.min() + "' AND '" + between.max() + "' ";
sql += "";
} else if (EQ.class == annotationType) {
EQ eq = (EQ) annotation;
sql += "";
sql += eq.logic() + " " + columnName + " = #{" + fieldName + "} ";
sql += "";
} else if (IN.class == annotationType) {
IN in = (IN) annotation;
sql += "0'>";
sql += in.logic() + " " + columnName + " IN ";
sql += " ";
sql += "#{item} ";
sql += " ";
sql += "";
} else if (Like.class == annotationType) {
Like like = (Like) annotation;
sql += "";
sql += like.logic() + " " + columnName + " LIKE CONCAT(CONCAT('%', #{" + fieldName + ",jdbcType=VARCHAR}), '%') ";
sql += "";
} else if (NE.class == annotationType) {
NE ne = (NE) annotation;
sql += "";
sql += ne.logic() + " " + columnName + " != #{" + fieldName + "} ";
sql += "";
}
}
}
sql += " ";
sql += " ";
sql += "ORDER BY ${sorts} ";
sql += "";
sql += "";
//System.out.println(sql);
return sql;
}
/**
* 插入数据
*
* insert into tb_project (`name`, url, intro )
* values
* (#{name}, #{url}, #{intro}})
*
* @param context
* @return
*/
public String insert(ProviderContext context) {
//表名
final String tableName = MyBatisUtil.getTableName(context);
//列名
final String tableColumns = MyBatisUtil.getTableColumns(context);
//存放字段列表
String columnStr = " (";
//存放和字段列表相对应的值的列表
String valueStr = " VALUES (";
//获取到数据库表中所有的字段
final String[] columns = tableColumns.split(",");
for (String column : columns) {
//插入数据时不考虑自动增长的主键id
if (!column.equals("id")) {
columnStr += column + ", ";
//将表字段转换成实体类属性
column = StringUtil.underline2hump(column);
valueStr += "#{" + column + "}, ";
}
}
//去除最后的逗号
columnStr = columnStr.substring(0, columnStr.length() - 2) + " )";
valueStr = valueStr.substring(0, valueStr.length() - 2) + " )";
String sql = "INSERT INTO " + tableName + columnStr + valueStr;
//System.out.println(sql);
return sql;
}
/**
* 修改数据
*
* update tb_project
* set `name` = #{name},url = #{url},intro = #{intro}
* where id = #{id}
*
* @param context
* @return
*/
public String update(ProviderContext context) {
//表名
final String tableName = MyBatisUtil.getTableName(context);
//列名
final String tableColumns = MyBatisUtil.getTableColumns(context);
//set子名
String kv = " SET ";
//where子句
String where = " WHERE id = ";
final String[] columns = tableColumns.split(",");
for (String column : columns) {
if (!column.equals("id")) {
//字段
String field = StringUtil.underline2hump(column);
kv += column + "= #{" + field + "}, ";
} else {
where += "#{" + column + "}";
}
}
//去除后面的逗号
kv = kv.substring(0, kv.length() - 2);
String sql = "UPDATE " + tableName + kv + where;
//System.out.println(sql);
return sql;
}
/**
* 选择性插入数据
*
*INSERT INTO tb_project
*
*
* `name`,
*
*
* url,
*
*
* intro,
*
*
*
*
* #{name,jdbcType=VARCHAR},
*
*
* #{url,jdbcType=VARCHAR},
*
*
* #{intro,jdbcType=LONGVARCHAR},
*
*
* @param context
* @return
*/
public String insertSelective(ProviderContext context) {
//表名
final String tableName = MyBatisUtil.getTableName(context);
//表字段，各字段之间以,分隔
final String tableColumns = MyBatisUtil.getTableColumns(context);
String sql = "";
sql += "INSERT INTO " + tableName + " ";
//字段列表
sql += "";
final String[] columns1 = tableColumns.split(",");
for (String column : columns1) {
String field = StringUtil.underline2hump(column);
sql += "";
sql += column + ",";
sql += "";
}
sql += "";
//值列表
sql += "";
final String[] columns = tableColumns.split(",");
for (String column : columns) {
String field = StringUtil.underline2hump(column);
sql += "";
sql += "#{" + field + "},";
sql += "";
}
sql += "";
sql += "";
//System.out.println(sql);
return sql;
}
/**
* 批量插入数据
*
* INSERT INTO tb_project (`name`, url, intro)
* VALUES
*
* (#{item.name,jdbcType=VARCHAR}, #{item.url,jdbcType=VARCHAR}, #{item.intro,jdbcType=LONGVARCHAR} )
*
*
* @param context
* @return
*/
public String batchInsert(ProviderContext context) {
//表名
final String tableName = MyBatisUtil.getTableName(context);
//表字段，各字段之间以,分隔
final String tableColumns = MyBatisUtil.getTableColumns(context);
String sql = "";
sql += "INSERT INTO " + tableName + "(" + tableColumns + ") VALUES ";
sql += "(";
final String[] columns = tableColumns.split(",");
for (String column : columns) {
final String field = StringUtil.underline2hump(column);
sql += "#{item." + field + "}, ";
}
sql = sql.substring(0, sql.length() - 2);
sql += ")";
sql += "";
// System.out.println(sql);
return sql;
}
/**
* 添加数据或更新数据
*
*
* update tb_city
* set `name`=#{name},
* priority=#{priority},
* province_id=#{provinceId}
* where id = #{id}
*
*
* insert into tb_city (`name`, priority, province_id)
* values (#{name}, #{priority}, #{provinceId)
*
*
*
* @param context
* @return
*/
public String insertOrUpdate(ProviderContext context) {
//表名
final String tableName = MyBatisUtil.getTableName(context);
//表字段，各字段之间以,分隔
final String tableColumns = MyBatisUtil.getTableColumns(context);
String sql = "";
sql += " ";
//更新数据
sql += " ";
sql += "UPDATE " + tableName + " SET ";
final String[] columns = tableColumns.split(",");
for (String column : columns) {
if (!"id".equals(column)) {
final String field = StringUtil.underline2hump(column);
sql += column + " = #{" + field + "}, ";
}
}
sql = sql.substring(0, sql.length() - 2) + " where id = #{id} ";
sql += "";
//添加数据
sql += "";
String columnStr = " (";
String valueStr = " VALUES (";
for (String column : columns) {
if (!"id".equals(column)) {
columnStr += column + ", ";
column = StringUtil.underline2hump(column);
valueStr += "#{" + column + "}, ";
}
}
columnStr = columnStr.substring(0, columnStr.length() - 2) + " )";
valueStr = valueStr.substring(0, valueStr.length() - 2) + " )";
sql += "INSERT INTO " + tableName + columnStr + valueStr;
sql += "";
sql += "";
sql += "";
//System.out.println(sql);
return sql;
}
/**
* 根据id修改状态
*
* update tb_project
* set `state` = #{state}
* where id = #{id}
*
* @param context
* @return
*/
public String updateStateById(ProviderContext context) {
//表名
final String tableName = MyBatisUtil.getTableName(context);
final SQL sql = new SQL()
.UPDATE(tableName)
.SET("state=#{state}")
.WHERE("id=#{id}");
return sql.toString();
}
/**
* 批量根据id修改状态
*
* update tb_project
* set `state` = #{state}
* where id in (1,2,3,4)
*
* @param context
* @param idList
* @param state
* @return
*/
public String batchUpdateStateById(ProviderContext context, List idList, Integer state) {
//表名
final String tableName = MyBatisUtil.getTableName(context);
String sql = "update " + tableName + " set state=" + state + " where id in (";
for (K id : idList) {
sql += id + ", ";
}
//去除语句后面的逗号
sql = sql.substring(0, sql.length() - 2) + ")";
return sql;
}
/**
* 选择性添加数据或更新数据
*
*
* UPDATE tb_project
*
* name = #{name},
* url = #{url},
* intro = #{intro},
*
* where id = #{id}
*
*
* INSERT INTO tb_project
*
* id,
* name,
* url,
* intro,
*
* VALUES
*
* #{id},
* #{name},
* #{url},
* #{intro},
*
*
*
*
* @param context
* @return
*/
public String insertOrUpdateSelective(ProviderContext context) {
//表名
final String tableName = MyBatisUtil.getTableName(context);
//表字段，各字段之间以,分隔
final String tableColumns = MyBatisUtil.getTableColumns(context);
String sql = "";
sql += " ";
//更新数据
sql += " ";
sql += "UPDATE " + tableName + " ";
sql += "";
final String[] columns = tableColumns.split(",");
for (String column : columns) {
if (!"id".equals(column)) {
final String field = StringUtil.underline2hump(column);
sql += "";
sql += column + " = #{" + field + "}, ";
sql += "";
}
}
sql += " ";
sql += " where id = #{id} ";
sql += "";
//添加数据
sql += "";
sql += "INSERT INTO " + tableName + " ";
sql += " ";
for (String column : columns) {
sql += " ";
sql += column + ",";
sql += " ";
}
sql += " ";
sql += "VALUES ";
sql += " ";
for (String column : columns) {
sql += " ";
sql += "#{" + StringUtil.underline2hump(column) + "},";
sql += " ";
}
sql += "";
sql += "";
sql += "";
sql += "";
System.out.println(sql);
return sql;
}
/**
* 选择性更新
*
* UPDATE tb_project
*
* name = #{name},
* url = #{url},
* intro = #{intro},
* duty = #{duty},
*
* where id = #{id}
*
* @param context
* @return
*/
public String updateSelective(ProviderContext context) {
//表名
final String tableName = MyBatisUtil.getTableName(context);
//表字段，各字段之间以,分隔
final String tableColumns = MyBatisUtil.getTableColumns(context);
String sql = "";
sql += "UPDATE " + tableName + " ";
sql += "";
final String[] columns = tableColumns.split(",");
for (String column : columns) {
if (!"id".equals(column)) {
final String field = StringUtil.underline2hump(column);
sql += "";
sql += column + " = #{" + field + "}, ";
sql += "";
}
}
sql += " ";
sql += " where id = #{id} ";
sql += "";
//System.out.println(sql);
return sql;
}
/**
* 批量更新
*
*UPDATE tb_project
*
*
* when id = #{item.id} then #{item.name}
*
*
* when id = #{item.id} then #{item.url}
*
*
* when id = #{item.id} then #{item.intro}
*
*
* when id = #{item.id} then #{item.duty}
*
*
* WHERE id IN
*
* #{item.id}
*
*
* @param context
* @return
*/
public String batchUpdate(ProviderContext context) {
//表名
final String tableName = MyBatisUtil.getTableName(context);
//表字段，各字段之间以,分隔
final String tableColumns = MyBatisUtil.getTableColumns(context);
String sql = "";
sql += "UPDATE " + tableName + " ";
sql += " ";
final String[] columns = tableColumns.split(",");
for (String column : columns) {
if (!"id".equals(column)) {
sql += " ";
sql += " ";
sql += "when id = #{item.id} then #{item." + StringUtil.underline2hump(column) + "} ";
sql += " ";
sql += " ";
}
}
sql += " ";
sql += "WHERE id IN ";
sql += " ";
sql += "#{item.id} ";
sql += " ";
sql += "";
System.out.println(sql);
return sql;
}
/**
* 选择性地批量更新
*
*update tb_province
*
*
*
*
* when id = #{item.id,jdbcType=BIGINT} then #{item.name,jdbcType=VARCHAR}
*
*
*
*
*
*
* when id = #{item.id,jdbcType=BIGINT} then #{item.area,jdbcType=VARCHAR}
*
*
*
*
*
*
* when id = #{item.id,jdbcType=BIGINT} then #{item.priority,jdbcType=INTEGER}
*
*
*
*
*
*
* when id = #{item.id,jdbcType=BIGINT} then #{item.state,jdbcType=TINYINT}
*
*
*
*
* where id in
*
* #{item.id,jdbcType=BIGINT}
*
* @param context
* @return
*/
public String batchUpdateSelective(ProviderContext context) {
//表名
final String tableName = MyBatisUtil.getTableName(context);
//表字段，各字段之间以,分隔
final String tableColumns = MyBatisUtil.getTableColumns(context);
String sql = "";
sql += "UPDATE " + tableName + " ";
sql += " ";
final String[] columns = tableColumns.split(",");
for (String column : columns) {
if (!"id".equals(column)) {
sql += " ";
sql += " ";
sql += "";
sql += "when id = #{item.id} then #{item." + StringUtil.underline2hump(column) + "} ";
sql += "";
sql += " ";
sql += " ";
}
}
sql += " ";
sql += "WHERE id IN ";
sql += " ";
sql += "#{item.id} ";
sql += " ";
sql += "";
System.out.println(sql);
return sql;
}
/**
* 根据ID删除，物理删除
*
* SELECT 字段列表 FROM tb_project
* WHERE id = #{id}
*
* @param context
* @return
*/
public String deleteById(ProviderContext context) {
//表名
final String tableName = MyBatisUtil.getTableName(context);
String sql = " DELETE FROM " + tableName + " WHERE id = #{id}";
return sql;
}
}
@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class User {
/**
* 编号
*/
private Long id;
/**
* 姓名
*/
private String name;
/**
* 头像
*/
private String avatar;
/**
* 昵称
*/
private String nickname;
/**
* 账户
*/
private String account;
/**
* 密码
*/
private String password;
/**
* 性别 1男 2女 3未知
*/
private Integer gender;
/**
* 生日
*/
private LocalDateTime birth;
/**
* 电话
*/
private String tel;
/**
* 邮件
*/
private String email;
/**
* QQ
*/
private String qq;
/**
* 微信
*/
private String wechat;
/**
* 个人主页
*/
private String homePage;
/**
* 户籍编号
*/
private Long huJiId;
/**
* 户籍地址
*/
private String huJiAddr;
/**
* 居住地编号
*/
private Long juZhuId;
/**
* 居住地地址
*/
private String juZhuAddr;
/**
* 显示优先级
*/
private Integer priority;
/**
* 状态 1正常 2功能受限 3删除
*/
private Integer state;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新时间
*/
private LocalDateTime updateTime;
}
@Mapper
public interface UserMapper extends BaseMapper {
}
@SpringBootTest
public class UserMapperTest {
@Resource
private UserMapper userMapper;
@Test
void selectById() {
final User user = userMapper.selectById(5L);
System.out.println(user);
}
@Test
void selectByCondition1() {
final List userList = userMapper.selectByCondition(UserQuery.builder()
.name("as")
.build());
userList.forEach(System.out::println);
}
@Test
void selectByCondition2() {
final List userList = userMapper.selectByCondition(UserQuery.builder()
.state(2)
.build());
userList.forEach(System.out::println);
}
@Test
void selectByCondition3() {
final List userList = userMapper.selectByCondition(UserQuery.builder()
.state(2)
.sorts(Map.of("id", "desc", "name", "asc", "birth", "desc"))
.build());
userList.forEach(System.out::println);
}
@Test
void insert() {
User user = User.builder()
.name("haha")
.account("xixi")
.build();
userMapper.insert(user);
System.out.println(user);
}
@Test
void insertSelective() {
User user = User.builder()
.name("haha")
.account("xixi")
.createTime(LocalDateTime.now())
.build();
userMapper.insertSelective(user);
System.out.println(user);
}
@Test
void batchInsert() {
List list = new ArrayList();
list.add(User.builder().name("aa").build());
list.add(User.builder().name("bb").build());
list.add(User.builder().name("cc").build());
userMapper.batchInsert(list);
System.out.println(list);
}
@Test
void update() {
final int res = userMapper.update(User.builder()
.id(62L)
.name("abc")
.account("cba")
.build());
System.out.println(res);
}
@Test
void updateSelective() {
final int res = userMapper.updateSelective(User.builder()
.id(62L)
.name("abc")
.qq("2341312")
.account("cba")
.build());
System.out.println(res);
}
@Test
void batchUpdate() {
List list = new ArrayList();
list.add(User.builder().id(22L).name("aa").build());
list.add(User.builder().id(23L).name("bb").build());
list.add(User.builder().id(58L).name("cc").build());
userMapper.batchUpdate(list);
System.out.println(list);
}
@Test
void batchUpdateSelective() {
List list = new ArrayList();
list.add(User.builder().id(22L).name("111").build());
list.add(User.builder().id(23L).name("222").birth(LocalDateTime.now()).qq("2134124").build());
list.add(User.builder().id(58L).name("333").createTime(LocalDateTime.now()).build());
userMapper.batchUpdateSelective(list);
System.out.println(list);
}
@Test
void insertOrUpdate1() {
final int res = userMapper.insertOrUpdate(User.builder()
.id(62L)
.name("abc")
.qq("2341312")
.account("cba")
.build());
System.out.println(res);
}
@Test
void insertOrUpdate2() {
final int res = userMapper.insertOrUpdate(User.builder()
.name("abc")
.qq("2341312")
.account("cba")
.build());
System.out.println(res);
}
@Test
void insertOrUpdateSelective1() {
final int res = userMapper.insertOrUpdateSelective(User.builder()
.name("abc")
.qq("2341312")
.account("cba")
.build());
System.out.println(res);
}
@Test
void insertOrUpdateSelective2() {
final int res = userMapper.insertOrUpdateSelective(User.builder()
.id(62L)
.name("abc")
.qq("2341312")
.account("cba")
.birth(LocalDateTime.now())
.build());
System.out.println(res);
}
@Test
void updateStateById() {
userMapper.updateStateById(1L, GlobalConst.state_enable);
}
@Test
void batchUpdateStateById() {
List idList = ListUtil.add(4L, 5L, 6L, 7L);
userMapper.batchUpdateStateById(idList, GlobalConst.state_disable);
}
@Test
void deleteById() {
final int res = userMapper.deleteById(21L);
System.out.println(res);
}
}
