1. 注解使用
mybatis-plus提供了 ·@TableName·, @TableId, @TableField, @TableLogic 四种注解，其含义分别为：
@TableName
@TableName("SPF_Require_Vehicle") 用于声明当前class所对应数据库中的表，如果class的名字和表的名字完全相同，则不需要添加该注解，如果不一样，则需要用该注解进行声明。
@TableId
@TableId(value = "SPF_UID", type = IdType.AUTO) 用于声明主键， value指定数据库中主键的名称，type为主键的生成类型，支持 Assign（雪花算法，java字段需要是Long）、Auto（数据库字段需要声明为auto_increment）， uuid
@TableField
@TableField("SPF_Name") 用于声明当前字段对应的表中的字段
@TableLogic
@TableLogic(value = "0", delval = "1") 用于软删除，value是默认值，delval表示软删除后的值。
@TableName("SPF_Require_Vehicle")
@Data
public class Employee {
/**
* 指定主键名称为SPF_uid, 类型为自增，即数据库的字段必须是auto_increment
*/
@TableId(value = "SPF_UID", type = IdType.AUTO)
private Long id;
/**
* 指定数据库中对应的字段是 Part_PartSap
*/
@TableField("Part_PartSap")
private String partSap;
@TableField("Part_PlateSap")
private String plateSap;
@TableField("SPF_Name")
private String name;
/**
* 逻辑删除
*/
@TableLogic(value = "0", delval = "1")
@TableField("IsActvie")
private Boolean active;
}@EnumValue
代码简洁性考虑：许多时候需要用到Enum，例如0表示男1表示女、0表示关闭1表示打开，and so on
- 在数据库表中增加字段gender： 0表示男，1表示女
- 定义枚举类， @EnumValue注解表示该字段是向数据库中插入的值，@JsonValue表示读取的时候对外展示的值
@Getter
public enum SexEnum {
SEX_MALE(0, "男"),
SEX_FEMALE(1, "女");
/**
* 表示当前字段是执行insert时向数据库中插入的字段
*/
@EnumValue
private int sexVal;
/**
* 表示从数据库读取的时候对外显示的值
*/
@JsonValue
private String sexName;
SexEnum(int sexVal, String sexName) {
this.sexVal = sexVal;
this.sexName = sexName;
}
/**
* 配合 @JsonValue使用
* @return 返回展示的值
*/
@Override
public String toString() {
return this.sexName;
}
}3. 使用处
插入的值为枚举注释的值
读取的是 @JsonValue注释的值
2. IService使用
2.1 批量插入
boolean saveBatch(Collection<T> entityList, int batchSize);
@Test
public void baseBatchInsertTest() {
List<Employee> list = new ArrayList<>();
for (int i = 20; i < 30; i++) {
Employee employee = new Employee();
employee.setName("zhagnsan" + i);
employee.setPartSap("123425-" + i);
employee.setPlateSap("312342-" + i);
list.add(employee);
}
// 批量插入，service提供了两个函数，可以带第二个参数，也可以不带，不带的情况下默认是1000
// 批量插入实际也是一条一条的插入，不同的是底层启动了同一个session，插入完成后关闭，不需要每次都开启关闭
this.service.saveBatch(list, 10);
}2.2 批量插入修改
如果主键Id已经在表中存在则修改，如果不存在则插入一条新数据
// 第二个参数选填，默认是1000
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);
@Test
public void testBatchInsertOrUpdate() {
List<Employee> list = new ArrayList<>();
Employee e1 = new Employee();
// 1L已经存在，会指定update
e1.setId(1L);
// 只添加了一个字段，也就是只修改一个字段
e1.setName("车轱辘");
Employee e2 = new Employee();
// id在表中不存在，则新增
e2.setId(50L);
e2.setName("车顶");
e2.setPartSap("123142314-00");
e2.setPlateSap("423414-09");
list.add(e1);
list.add(e2);
this.service.saveOrUpdateBatch(list,2);
}2.2 单个插入修改
// 如果id存在则修改，否则插入
boolean saveOrUpdate(T entity);
2.3 单个删除
default boolean removeById(Serializable id)
default boolean removeById(T entity)
@Test
public void testRemoveSingle01() {
/**
* id如果存在则删除，返回ture，否则返回false
*/
boolean b = this.service.removeById(9);
System.out.println("b:" + b);
}
/*
* 有的时候，前端传过来的是一个类，此时可以直接调用该函数删除
*/
@Test
public void testRemoveSignle02() {
Employee employee = new Employee();
employee.setId(8L);
this.service.removeById(employee);
}2.4 有条件删除
实际中很多情况并不是根据Id进行删除而是根据实际需要进行删除， service也提供了该功能
removeByMap
default boolean removeByMap(Map<String, Object> columnMap)
/*
* 下面代码执行的语句如下
* UPDATE SPF_Require_Vehicle SET IsActvie=1 WHERE Part_PlateSap = ? AND Part_PartSap = ? AND IsActvie=0
*/
@Test
public void testRemoveByMap() {
Map<String, Object> map = new HashMap<>();
map.put("Part_PartSap", "123425-0");
map.put("Part_PlateSap", "312342-0");
this.service.removeByMap(map);
}remove（可根据条件批量删除）
也可以根据wrapper进行删除，删除的时候使用的是QueryWrapper， Wrapper的用法有很多种，此处只展示in的用法，其他用法下文进行介绍
default boolean remove(Wrapper<T> queryWrapper)
@Test
public void testRemove03() {
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
List<Long> list = new ArrayList<>();
list.add(2L);
list.add(3L);
list.add(4L);
wrapper.in(list != null && !list.isEmpty(), "SPF_UID", list);
/**
* UPDATE SPF_Require_Vehicle SET IsActvie=1 WHERE IsActvie=0 AND (SPF_UID IN (?,?,?))
*/
this.service.remove(wrapper);
}2.5 批量删除
根据主键批量删除
removeByIds
default boolean removeByIds(Collection<?> list)
@Test
public void testRemoveByIds() {
List<Long> list = new ArrayList<>();
list.add(2L);
list.add(3L);
list.add(5L);
/**
* 根据Ids批量删除
* UPDATE SPF_Require_Vehicle SET IsActvie=1 WHERE SPF_UID IN ( ? , ? , ? ) AND IsActvie=0
*/
this.service.removeByIds(list);
}removeBatchByIds
采用jdbc批量删除，底层使用for循环逐个删除，这点是和上面函数的区别
default boolean removeBatchByIds(Collection<?> list, int batchSize)
@Test
public void testremoveBatchByIds() {
List<Long> list = new ArrayList<>();
list.add(2L);
list.add(3L);
list.add(5L);
/**
* UPDATE SPF_Require_Vehicle SET IsActvie=1 WHERE SPF_UID=? AND IsActvie=0
*/
this.service.removeBatchByIds(list, list.size());
}2.6 单个修改：根据Id修改
default boolean updateById(T entity)
@Test
public void testupdateById() {
Employee employee = new Employee();
employee.setId(8L);
employee.setName("doris");
/**
* UPDATE SPF_Require_Vehicle SET SPF_Name=? WHERE SPF_UID=? AND IsActvie=0
*/
this.service.updateById(employee);
}2.7 有条件修改：根据wrapper修改
default boolean update(Wrapper<T> updateWrapper)
@Test
public void testupdate() {
Integer minId = 9;
Integer maxId = 14;
String name = "doris";
String nName = "wangshun";
LambdaUpdateWrapper<Employee> wrapper = new LambdaUpdateWrapper<>();
wrapper.gt(minId != null, Employee::getId, minId)
.lt(maxId != null, Employee::getId, maxId)
.or()
.like(name != null && !name.isEmpty(), Employee::getName, name);
wrapper.set(nName != null && !nName.isEmpty(), Employee::getName, nName);
/**
* UPDATE SPF_Require_Vehicle SET SPF_Name=? WHERE IsActvie=0 AND (SPF_UID > ? AND SPF_UID < ? OR SPF_Name LIKE ?)
*/
this.service.update(wrapper);
}2.8 批量修改：根据Id修改
这个方法很使用，实际工作中，都是根据前端传过来的结构体进行修改
boolean updateBatchById(Collection<T> entityList, int batchSize)
@Test
public void testupdateBatchById() {
List<Employee> list = new ArrayList<>();
Employee e1 = new Employee();
e1.setId(1L);
e1.setName("wangwu");
Employee e2 = new Employee();
e2.setId(2L);
e2.setName("wangbaochuan");
list.add(e1);
list.add(e2);
/**
* UPDATE SPF_Require_Vehicle SET SPF_Name=? WHERE SPF_UID=? AND IsActvie=0
*/
this.service.updateBatchById(list, list.size());
}2.9 单个查询
根据Id单个查询
getById
@Test
public void testgetById() {
/**
* SELECT SPF_UID AS id,Part_PartSap AS partSap,Part_PlateSap AS plateSap,SPF_Name AS name,IsActvie AS active FROM SPF_Require_Vehicle WHERE SPF_UID=? AND IsActvie=0
*/
Employee byId = this.service.getById(1);
System.out.println(byId);
}getOne
// 根据条件查找时：如果有多个则会抛出异常
default T getOne(Wrapper<T> queryWrapper)
@Test
public void testgetOne() {
LambdaQueryWrapper<Employee> wrapper = new LambdaQueryWrapper<>();
String plateSap = "312342-6";
wrapper.eq(plateSap != null && !plateSap.isEmpty(), Employee::getPlateSap, plateSap);
/**
* SELECT SPF_UID AS id,Part_PartSap AS partSap,Part_PlateSap AS plateSap,SPF_Name AS name,IsActvie AS active
* FROM SPF_Require_Vehicle WHERE IsActvie=0 AND (Part_PlateSap = ?)
*/
Employee one = this.service.getOne(wrapper);
System.out.println(one);
}
2.10 批量查询
listByIds
@Test
public void testlistByIds() {
List<Long> list = new ArrayList<>();
list.add(1L);
list.add(2L);
list.add(3L);
List<Employee> employees = this.service.listByIds(list);
/**
* SELECT SPF_UID AS id,Part_PartSap AS partSap,Part_PlateSap AS plateSap,SPF_Name AS name,IsActvie AS active FROM SPF_Require_Vehicle WHERE SPF_UID IN ( ? , ? , ? ) AND IsActvie=0
*/
employees.forEach(System.out::println);
}list
@Test
public void testList() {
List<Employee> list = this.service.list();
/**
* SELECT SPF_UID AS id,Part_PartSap AS partSap,Part_PlateSap AS plateSap,SPF_Name AS name,IsActvie AS active
* FROM SPF_Require_Vehicle WHERE IsActvie=0
*/
list.forEach(System.out::println);
}2.11 有条件批量查询
listByMap
default List<T> listByMap(Map<String, Object> columnMap)
@Test
public void testlistByMap() {
Map<String, Object> map = new HashMap<>();
map.put("SPF_Name", "wangshun");
map.put("Part_PlateSap", "312342-20");
/**
* SELECT SPF_UID AS id,Part_PartSap AS partSap,Part_PlateSap AS plateSap,SPF_Name AS name,IsActvie AS active
* FROM SPF_Require_Vehicle WHERE Part_PlateSap = ? AND SPF_Name = ? AND IsActvie=0
*/
List<Employee> employees = this.service.listByMap(map);
employees.forEach(System.out::println);
}list
default List<T> list(Wrapper<T> queryWrapper)
@Test
public void testList() {
LambdaQueryWrapper<Employee> wrapper = new LambdaQueryWrapper<>();
wrapper.like(Employee::getName, "wangshun");
List<Employee> list = this.service.list(wrapper);
/**
* SELECT SPF_UID AS id,Part_PartSap AS partSap,Part_PlateSap AS plateSap,SPF_Name AS name,IsActvie AS active
* FROM SPF_Require_Vehicle WHERE IsActvie=0 AND (SPF_Name LIKE ?)
*/
list.forEach(System.out::println);
}2.12 查询指定列
getmap
// 如果查询出过个，则只取第一个
Map<String, Object> getMap(Wrapper<T> queryWrapper);
@Test
public void testSelectMap() {
String name = "wangshun";
LambdaQueryWrapper<Employee> wrapper = new LambdaQueryWrapper<>();
wrapper.like(!name.isEmpty(), Employee::getName, name);
/**
* 只查询这两列，如果同时查询出多行，则只取第一行
* SELECT Part_PlateSap AS plateSap,Part_PartSap AS partSap FROM SPF_Require_Vehicle WHERE IsActvie=0 AND (SPF_Name LIKE ?)
*/
wrapper.select(Employee::getPlateSap, Employee::getPartSap);
Map<String, Object> map = this.service.getMap(wrapper);
System.out.println(map);
}listMap
可查询多行
@Test
public void testlistMaps() {
LambdaQueryWrapper<Employee> wrapper = new LambdaQueryWrapper<>();
wrapper.like(Employee::getName, "wangshun");
/**
* 只显示这三列
*/
wrapper.select(Employee::getPartSap, Employee::getPlateSap, Employee::getName);
List<Map<String, Object>> maps = this.service.listMaps(wrapper);
for (Map<String, Object> map : maps) {
System.out.println(map);
}
}
default List<Map<String, Object>> listMaps() 如果不见条件则查询所有的行
2.13 个数查询
// 查询表中国有效的总行数 default long count()
// 根据条件查询行数 default long count(Wrapper<T> queryWrapper)
2.14 分页查询
分页查询需要首先注册mybatis-plus的拦截器，配置如下
@Configuration
public class MpConfig {
@Bean
public MybatisPlusInterceptor getIntercepter() {
MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
return mybatisPlusInterceptor;
}
}@Test
public void testPage01() {
Page<Employee> page = new Page<>(2, 4);
LambdaQueryWrapper<Employee> wrapper = new LambdaQueryWrapper<>();
wrapper.like(Employee::getName, "wangshun");
this.service.page(page, wrapper);
System.out.println(page);
// 查询到的内容
System.out.println("records: " + page.getRecords());
// 总页数
System.out.println("pages: " + page.getPages());
// 当前页数
System.out.println("current: " + page.getCurrent());
// 总条目数
System.out.println("total: " + page.getTotal());
}2.15 SQL分页查询
许多时候需要手写语句实现分页查询，例如同时从多张表中查询数据，这个时候需要自己写条件。
01. 在 application.yml中指定mybatis-plus的相关配置，尤其要指定xml的路径，默认在mapper下，本人仍习惯指明位置
mybatis-plus:
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
# 指定mapper.xml所在的位置
mapper-locations: classpath:/mapper/*.xml02. 在Mapper中增加声明
/**
* 手写语句实现分页查询
* @param page 拦截器使用，当前sql中不需要
* @param employee 查询对象
* @return 查询结果
*/
Page<Employee> getEmployeeInfoByPage(@Param("page") Page<Employee> page, @Param("employee") Employee employee);03. 添加Mapper对应的xml文件并增加对应的函数
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ssm01.mapper.EmployeeMapper">
<resultMap id="baseResultMap" type="com.ssm01.pojo.Employee">
<result column="SPF_UID" property="id"/>
<result column="Part_PartSap" property="partSap"/>
<result column="Part_PlateSap" property="plateSap"/>
<result column="SPF_Name" property="name"/>
</resultMap>
<select id="getEmployeeInfoByPage" resultMap="baseResultMap">
select * from SPF_Require_Vehicle where SPF_Name = #{employee.name} and IsActvie = 0
</select>
</mapper>04. 在自己的service中增加相应的方法，调用mapper中的函数
