MybatisPlus - 技术栈

[1 引入MP依赖代替Mybatis依赖](#1 引入MP依赖代替Mybatis依赖)

[2 配置yaml](#2 配置yaml)

[3 继承BaseMapper](#3 继承BaseMapper)

[3.1 默认约定](#3.1 默认约定)

[3.2 自定义约定](#3.2 自定义约定)

[3.3 继承BaseMapper的常用方法](#3.3 继承BaseMapper的常用方法)

[3.3.1 增](#3.3.1 增)

[3.3.2 删](#3.3.2 删)

[3.3.3 改](#3.3.3 改)

[3.3.4 查](#3.3.4 查)

[4 条件构造器](#4 条件构造器)

[4.1 QueryWrapper](#4.1 QueryWrapper)

[4.2 UpdateWrapper](#4.2 UpdateWrapper)

[4.3 AbstractLambdaWrapper(推荐)](#4.3 AbstractLambdaWrapper(推荐))

[4.4 自定义sql方法](#4.4 自定义sql方法)

[4.4.1 dao接口+xml](#4.4.1 dao接口+xml)

[4.4.2 用法示例](#4.4.2 用法示例)

[5 IService接口](#5 IService接口)

[5.1 Iservice常用方法](#5.1 Iservice常用方法)

[5.2 使用流程](#5.2 使用流程)

[5.3 用法示例](#5.3 用法示例)

[5.4 lambdaQuery()方法、lambdaUpdate()方法](#5.4 lambdaQuery()方法、lambdaUpdate()方法)

[5.5 批量操作](#5.5 批量操作)

[5.5.1 批量操作对比](#5.5.1 批量操作对比)

[5.5.2 代码示例](#5.5.2 代码示例)

[6 多表查询](#6 多表查询)

1 引入MP依赖代替Mybatis依赖

XML 复制代码

<!--MybatisPlus(包含了mybatis的starter)-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.4</version>
</dependency>

2 配置yaml

(见之前文章SpringBoot (2) yaml,整合项目)

3 继承BaseMapper

BaseMapper泛型为所要操作的pojo类,MP依据此泛型通过反射得到类的字节码文件,然后通过字节码信息反推出数据库中的表信息,反推要遵循约定

java 复制代码

public interface TeacherDao extends BaseMapper<Teacher> {
}

3.1 默认约定

(1) 类名的驼峰转下划线作为表名: 类名HighSchool反推出的表名就是high_school

(2) 名为id的成员变量作为主键字段

(3) 类成员变量的驼峰转下划线作为字段名

3.2 自定义约定

@TableName用在pojo类上,指定表名

@TableId(value="id", type=IdType.AUTO)用在pojo类成员变量上,指定表主键字段

IdType.AUTO表示自增Id,数据库自动生成

IdType.INPUT表示set方法设置,用户自己填写

IdType.ASSING_ID(默认)表示MP会自动利用雪花算法生成long类型的整数,长度20位

@TableField用在pojo类成员变量上,指定普通字段

(1) 对于is开头并且是boolean类型的pojo成员变量,在通过反射机制会将is去掉,那么就起不到驼峰转下划线的效果,因此is开头的boolean类型的成员变量必须用@TableField注解

(2) 对于关键字的pojo成员变量,必须用@TableField注解,并且要将关键字写在反引号``中

(3) pojo成员变量不是数据库字段,必须用@TableField(exist=false)注解

java 复制代码

@TableName("aboluo_person")
public class Person {
    @TableId
    private Long id;
    @TableField("user_name")
    private String name;
    @TableField("is_man")
    private Boolean isMan;
    @TableField("`select`")
    private Integer select;
    @TableField(exist = false)
    private String other;
}

3.3 继承BaseMapper的常用方法

3.3.1 增

teacherDao.insert(T); //这里的"泛型类"就是BaseMapper的泛型

3.3.2 删

teacherDao.deleteById(5)

teacherDao.delete(Wrapper)

teacherDao.deleteBatchIds(Collection<?>)

3.3.3 改

teacherDao.updateById(T) //非空字段才更新(可以在yaml中设置)

teacherDao.update(Wrapper<T>)

teacherDao.update(T,Wrapper<T>)

3.3.4 查

单查询:

teacherDao.selectOne(Wrapper<T>);

teacherDao.selectById(6);

多查询:

teacherDao.selectList(Wrapper<T>); //参数为null表示(无条件)查询所有

teacherDao.selectBatchIds(List.of(1,3,9)); //根据id的List集合查询

4 条件构造器

条件构造器Wrapper支持各种复杂的where条件

4.1 QueryWrapper

|---------------|------------------ | 函数名 | .eq | 等于= | .ne | 不等于<> | .gt | 大于> | .ge | 大于等于>= | .lt | 小于< | .le | 小于等于<= | .between | BETWEEN值1 | .notBetween | NOT BETWEEN值1 AND 值2 | .like | LIKE'%值%' | .likeLeft | LIKE'%值' | .likeRight | LIKE'值%' | .notLike | NOT LIKE'%值%' | .notLikeLeft | NOT LIKE'%值' | .notLikeRight | NOT LIKE'值%' | .isNull | 字段IS NULL | .isNotNull | 字段IS NOT NULL | .in | 字段IN(v1,v2...) | .notIn | 字段NOT IN(v1,v2...) | .inSql | 字段IN(sql语句) | .notInSql | 字段NOT IN(sql语句) | .groupBy | 分组GROUP | .orderByAsc | 排序ORDER | .orderByDesc | 排序ORDER | .having | 分组后筛选 | .or | 或OR | .apply | 拼接sql | .last | 在最后面拼接sql | .exists | 与EXISTS(子查询 | .notExist | 与NOT EXISTS(子 ---------|---------------------------------------------------------------------------------------------------------|
| 说明 | 示例 |
| .eq("name","张三") |
| |
| .gt("age",18) |
| |
| |
| |
AND 值2 #包含值1和值2 | .between("age",18,30) |
| |
| .like("name","陈") |
| |
| |
| |
| |
| |
| .isNull("name") |
| |
| .in("age",{1,2,3}) |
| .notIn("age",1,2,3) |
| .inSql("id","select id from table where id<3")**==>**id IN (select id from table where id<3) |
| |
BY 字段1,字段2... | .groupBy("id","name") |
BY 字段1,字段2...ASC | .orderByAsc("id","name") |
BY 字段1,字段2...DESC | |
| .having("CHAR_LENGTH(name)>{0} and age>{1}", 2, 18) |
| 不调用or,则默认使用and eq("naem","张三").or().eq("naem","李四") |
| 方式一:(有sql注入问题) .apply("sql1"+变量1+"sql2"+常量+"sql3") 方式二:(不会有sql注入问题) .apply("sql1+{0}+sql2+{1}",变量1,变量2) |
| |
)作用相同 | |
查询)作用相同 | |

示例1:查询position中带"语文",年龄age大于18的"position,name,age"字段

java 复制代码

/*SELECT position, name, age 
FROM teacher 
WHERE
	position LIKE '%语文%' 
	AND age > 18;*/
QueryWrapper<Teacher> wrapper = new QueryWrapper<Teacher>()
		.select("position", "name", "age")
		.like("position", "语文")
		.gt("age", 18);
List<Teacher> teachers = teacherDao.selectList(wrapper);

示例2:把name为"张三"的Teacher的age修改为33

java 复制代码

/*UPDATE teacher 
SET age = 45 
WHERE
	NAME = '张三';*/
Teacher teacher = new Teacher();
teacher.setAge(33);
QueryWrapper<Teacher> wrapper = new QueryWrapper<Teacher>()
		.eq("name", "张三");
teacherDao.update(teacher, wrapper);
return Result.success();

4.2 UpdateWrapper

UpdateWrapper提供了2种修改记录的方式:

(1) 将修改内容放在pojo类中,UpdateWrapper只做where筛选(用法同QueryWrapper)

(2) 直接UpdateWrapper对象.setSql(sql),替代sql中的set

示例3:将所有语文老师的年龄增加1岁

java 复制代码

/*UPDATE teacher 
SET age = age + 1 
WHERE
	position = '语文老师';*/
UpdateWrapper<Teacher> wrapper = new UpdateWrapper<Teacher>()
		.setSql("age=age+1")
		.eq("position", "语文老师");
teacherDao.update(wrapper);

4.3 AbstractLambdaWrapper(推荐)

QueryWrapper和UpdateWrapper在写字段时存在硬编码问题,而LambdaQueryWrapper和LambdaUpdateWrapper就可以解决这个问题

LambdaQueryWrapper替换QueryWrapper:查询position中带"语文",年龄age大于18的"position,name,age"字段

java 复制代码

/*SELECT position, name, age 
FROM teacher 
WHERE
	position LIKE '%语文%' 
	AND age > 18;*/
LambdaQueryWrapper<Teacher> wrapper = new LambdaQueryWrapper<Teacher>()
		.select(Teacher::getPosition, Teacher::getName, Teacher::getAge)
		.like(Teacher::getPosition, "语文")
		.gt(Teacher::getAge, 18);
List<Teacher> teachers = teacherDao.selectList(wrapper);

LambdaUpdateWrapper替换UpdateWrapper:将所有语文老师的年龄增加1岁

java 复制代码

/*UPDATE teacher 
SET age = age + 1 
WHERE
	position = '语文老师';*/
LambdaUpdateWrapper<Teacher> wrapper = new LambdaUpdateWrapper<Teacher>()
		.setSql("age=age+1")
		.eq(Teacher::getPosition, "语文老师");
teacherDao.update(wrapper);

4.4 自定义sql方法

✖问题1:Mybatis只有Dao接口,通过xml映射在SpringIOC中生成Dao实例,因此Wrapper只能写在Service层,导致sql语句无法被其它Service复用

✖问题2:条件构造器善于处理where后面的sql,但不善于处理where前的sql(例如:聚合查询,查询字段起别名...),所以只能将sql写在业务层中(如"示例3"),但实际开发中并不建议在业务层写sql

✔解决:用"where前交给xml文件处理,where后交给MP条件构造器处理"方式解决

4.4.1 dao接口+xml

同mybatis一样,在dao接口中自定义sql方法(此方法与xml文件能映射),方法参数是@Param("ew ")Wrapper和自定义参数

xml文件中用#{自定义参数},${ew.customerSqlSegment}引用

4.4.2 用法示例

示例1:查询position中带"语文",年龄age大于18的"position,name,age"字段

java 复制代码

//dao接口
public interface TeacherDao extends BaseMapper<Teacher> {
    List<Teacher> customSQL1(@Param("ew") LambdaQueryWrapper wrapper);
}

//xml文件
<mapper namespace="xyz.aboluo.mybatisPlus.dao.TeacherDao">
    <resultMap id="teacherMap" type="teacher">
        <result column="position" property="position"/>
        <result column="name" property="name"/>
        <result column="age" property="age"/>
    </resultMap>

    <select id="customSQL1" resultMap="teacherMap">
        select * from teacher ${ew.customSqlSegment}
    </select>
</mapper>

//使用"自定义sql"
@RequestMapping("/customSQL1.do")
public Result customSQL1() {
	LambdaQueryWrapper<Teacher> wrapper = new LambdaQueryWrapper<Teacher>()
			.like(Teacher::getPosition, "英语")
			.gt(Teacher::getAge, 18);
	List<Teacher> teachers = teacherDao.customSQL1(wrapper);
	return Result.success(teachers);
}

示例2:把name为"张三"的Teacher的age修改为33

java 复制代码

//dao接口
public interface TeacherDao extends BaseMapper<Teacher> {
    Integer customSQL2(@Param("ew") LambdaQueryWrapper wrapper,  @Param("teacher") Teacher teacher);
}

//xml文件
<mapper namespace="xyz.aboluo.mybatisPlus.dao.TeacherDao">
    <resultMap id="teacherMap" type="teacher">
        <result column="position" property="position"/>
        <result column="name" property="name"/>
        <result column="age" property="age"/>
    </resultMap>

    <update id="customSQL2" parameterType="teacher">
        update teacher set age=#{teacher.age} ${ew.customSqlSegment}
    </update>
</mapper>

//使用"自定义sql"
@RequestMapping("/customSQL2.do")
public Result customSQL2() {
	Teacher teacher = new Teacher();
	teacher.setAge(33);
	LambdaQueryWrapper<Teacher> wrapper = new LambdaQueryWrapper<Teacher>()
			.eq(Teacher::getName, "张三");
	teacherDao.customSQL2(wrapper, teacher);
	return Result.success();
}

//使用BaseMapper方法
@RequestMapping("/customSQL3.do")
public Result customSQL3() {
	LambdaUpdateWrapper<Teacher> wrapper = new LambdaUpdateWrapper<Teacher>()
			.set(Teacher::getAge,33)
			.eq(Teacher::getName, "张三");
	teacherDao.update(wrapper);
	return Result.success();
}

5 IService接口

BaseMapper接口是增强Dao接口的,dao接口直接继承BaseMap"增删改查"等方法

IService接口是增强Service接口的,Service接口直接继承IService"增删改查"等方法

5.1 Iservice常用方法

|--------|------------------------------------------------------------------------|-------------------|
| 类型 | 方法 | 说明 |
| 增 | save(T) | |
| 增 | saveBatch(Collection<T>) | |
| 增 | saveOrUpdate(T) | |
| 增 | saveOrUpdate(T,Wrapper<T>) | |
| 增 | saveOrUpdateBatch(Collection<T>) | |
| 删 | remove(Wrapper<T>) | |
| 删 | removeById(T) | |
| 删 | removeBatchByIds(Collection<?>) | |
| 改 | update(Wrapper<T>) | |
| 改 | update(T,Wrapper<T>) | |
| 改 | updateById(T) | |
| 改 | updateBatchById(Collectiion<T>) | |
| 查 | getById(Serializable) //参数是泛型T,并且T继承Serializable,并且用@TableId标记出那个字段是ID | 查询一个用get开头 |
| 查 | getOne(Wrapper<T>) | |
| 查 | listByIds(Collection<? extends Serializable>) | 查询多个用list开头 |
| 查 | list(Wrapper<T>) | 参数null,表示查所有 |
| 查 | lambdaQuery(T) | 参数null,表示查所有 |
| 查 | lambdaUpdate() | |
| 其它 | count(Wrapper<T>) | 统计(参数null,表示统计所有) |
| 其它 | page(E) | 分页查询 |
| 其它 | page(E,Wrapper<T>) | |

5.2 使用流程

因为dao接口是通过xml文件在SpringIOC中反射生成实现类,dao接口直接继承BaseMapper就可以用了,因此不需要写实现类

继承Iservice接口的xxxService接口有xxxServiceImpl实现类,并且实现类需要重写xxxService接口方法和Iservice接口方法,但在实际开发中我们只想重写自定义的xxxService接口,不想重写Iservice接口方法,xxxServiceImpl可以继承MP提供的ServiceImpl方法

5.3 用法示例

(1) xxxService继承IService接口要写pojo泛型

(2) xxxServiceImpl继承ServiceImpl要写dao泛型和pojo泛型

java 复制代码

//xxxService
public interface TeacherService extends IService<Teacher> {
}

//xxxServiceImpl
@Service
public class TeacherServiceImpl extends ServiceImpl<TeacherDao, Teacher> implements TeacherService {
}

//查询position中带"语文",年龄大于18的"position,name,age"字段
@RequestMapping("/service3.do")
public Result service3() {
    LambdaQueryWrapper<Teacher> wrapper = new LambdaQueryWrapper<Teacher>()
            .select(Teacher::getPosition, Teacher::getName, Teacher::getAge)
            .like(Teacher::getPosition, "语文")
            .gt(Teacher::getAge, 18);
    return Result.success(teacherService.list(wrapper));
}

//把name为"张三"的Teacher的age修改为33(方式一)
@RequestMapping("/service4.do")
public Result service4() {
    Teacher teacher = new Teacher();
    teacher.setAge(33);
    LambdaQueryWrapper<Teacher> wrapper = new LambdaQueryWrapper<Teacher>()
            .eq(Teacher::getName, "张三");
    teacherService.update(teacher, wrapper);
    return Result.success();
}

//把name为"张三"的Teacher的age修改为33(方式二)
@RequestMapping("/service5.do")
public Result service5() {
    LambdaUpdateWrapper<Teacher> wrapper = new LambdaUpdateWrapper<Teacher>()
            .set(Teacher::getAge, 33)
            .eq(Teacher::getName, "张三");
    teacherService.update(wrapper);
    return Result.success();
}

5.4 lambdaQuery()方法、lambdaUpdate()方法

这2个方法通常用于复杂条件的查询

lambdaQuery().one表示查一条记录**.list查多条记录.page** 分页查询**.count**统计

lambdaUpdate().set 表示设置字段值**.update**表示执行lambdaUpdate更新

lambdaQuery()示例:根据"position模糊"查询,"name精确"查询,"大于age"查询,并且position,name,age3个字段允许为null,当为null时对此字段不做筛选

java 复制代码

//xxxService
public interface TeacherService extends IService<Teacher> {
    Result lambdaQuery1(Teacher teacher);
}

//xxxServiceImpl
@Service
public class TeacherServiceImpl extends ServiceImpl<TeacherDao, Teacher> implements TeacherService {
    @Override
    public Result lambdaQuery1(Teacher teacher) {
        List<Teacher> teachers = lambdaQuery()
                //第一个参数condition表示判断,如果为true则执行这一步筛选
                .like(teacher.getPosition() != null, Teacher::getPosition, teacher.getPosition())
                .eq(teacher.getName() != null, Teacher::getName, teacher.getName())
                .gt(teacher.getAge() != null, Teacher::getAge, teacher.getAge())
                .list();
        return Result.success(teachers);
    }
}

//使用
@RequestMapping("/lambdaQuery1.do")
public Result lambdaQuery1(@RequestBody Teacher teacher) {
    return Result.success(teacherService.lambdaQuery1(teacher));
}

lambdaUpdate()示例:将name为"张三"的用户年龄-200岁,如果年龄不足则操作失败

java 复制代码

//xxxDao
public interface TeacherService extends IService<Teacher> {
    Result lambdaQuery2();
}

//xxxDaoImpl
@Service
public class TeacherServiceImpl extends ServiceImpl<TeacherDao, Teacher> implements TeacherService {
    @Override
    public Result lambdaQuery2() {
        //去数据库查询name为"张三"的Teacher
        LambdaQueryWrapper<Teacher> wrapper = new LambdaQueryWrapper<Teacher>()
                .eq(Teacher::getName, "张三");
        Teacher teacher = getOne(wrapper);
        Integer restMoney = teacher.getAge() - 200;
        //修改余额
        lambdaUpdate()
                .set(restMoney >= 0, Teacher::getAge, restMoney)
                .set(restMoney < 0, Teacher::getAge, teacher.getAge())//总有一条生效,防止都不生效导致sql错误
                .eq(Teacher::getName, "张三")
                .eq(Teacher::getAge, teacher.getAge())//此处是为了防止并发冲突(之前查到的age要和现在set操作时的age相同)
                .update();
        return Result.success();
    }
}

//使用
@RequestMapping("/lambdaQuery2.do")
public Result lambdaQuery2() {
    teacherService.lambdaQuery2();
    return Result.success();
}

5.5 批量操作

5.5.1 批量操作对比

(1) 使用for循环逐条将sql交给mysql处理(性能极低,每执行一条sql,后台就与mysql通讯一次)

(2) MP基于预编译批量处理(例如xxxDao.saveBatch(list)),将多条sql统一交给(也不能一次给太多,对内存压力大)mysql处理(性能一般,虽然将多条sql统一交给mysql,但mysql依旧是一条条执行)

(3) 将多条sql写作一条sql 例如:多条INSERT INTO table(xx,xx,xx) VALUE (yy,yy,yy) ==> 一条INSERT INTO table(xx,xx,xx) VALUES (yy,yy,yy),(yy,yy,yy)

方式一: 使用手写拼接(不推荐)

方式二: 配置mysql的jdbc驱动(开启rewriteBatchedStatements=true),开启mysql将多条sql整合成一条sql执行

5.5.2 代码示例

例:新增10000条数据,使用"逐条新增"的方式 //耗时28817ms

java 复制代码

@RequestMapping("/batch1.do")
public void batch1() {
    //向数据库逐条插入10000条数据
    for (int i = 0; i < 10000; i++) {
        Teacher teacher = createTeacher(i);
        teacherService.save(teacher);
    }
}

public Teacher createTeacher(Integer positionNo) {
    Teacher teacher = new Teacher();
    teacher.setPosition("" + positionNo);
    return teacher;
}

例:新增10000条数据,使用"预编译"的方式 //耗时3020ms

java 复制代码

@RequestMapping("/batch2.do")
public void batch2() {
    long time1 = System.currentTimeMillis();
    //每次向数据库插入1000条(一次插入过多对内存要求压力大),插入10次
    for (int i = 1; i <= 10000; i++) {
        teachers.add(createTeacher(i));
        if (i % 1000 == 0) {
            teacherService.saveBatch(teachers);
            teachers.clear();
        }
    }
}

public Teacher createTeacher(Integer positionNo) {
    Teacher teacher = new Teacher();
    teacher.setPosition("" + positionNo);
    return teacher;
}

例:新增10000条数据,使用"预编译"+"sql整合"的方式 //耗时1284ms

java 复制代码

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/sunner?rewriteBatchedStatements=true

6 多表查询

(使用.xml文件)