mybatisplus快速入门-个人理解版

mybatisplus快速入门

1.快速入门
- 1.1准备开发环境-idea2019.2.1版
- - 第一步：新建工程
  - 第二步：导入依赖
- 1.2创建数据库和表
- - 创建库表
  - 添加数据
- 1.3编写代码进行测试
- - 第一步：配置application.yml
  - 第二步：添加实体类
  - 第三步：添加mapper
  - 第四步：在test类下写测试类
2.Mapper CRUD 接口
- 2.1插入insert
- 2.2删除delete
- - 通过id删除记录
  - 通过id批量删除记录
  - 通过map条件删除记录
- 2.3修改update
- 2.4查询select
- 2.5自动填充-代码级别
- - 第一步：修改数据库
  - 第二步：给实体类的字段属性增加注释
  - 第三步：编写处理器来处理注释
  - 第四步：测试插入和修改
3.Service CRUD 接口
- 3.1创建Service接口和实现
- 3.2测试查询记录数
- 3.3测试批量插入
4.条件构造器和常用接口
- 4.1Wrapper
- 4.2QueryWrapper
- - 组装查询条件
  - 组装排序条件
  - 组装删除条件
  - 条件的优先级
  - 组装select子句
  - 实现子查询
- 4.3UpdateWrapper
- 4.4condition
5.插件
- 5.1分页插件
- - 第一步：添加配置类
  - 第二步：去测试类测试

在这里插入图片描述

可点击MyBatis-Plus官方文档进行MyBatis-Plus的深入理解

1.快速入门

1.1准备开发环境-idea2019.2.1版

特地说一下版本是因为博主版本较低，很多东西需要更改，但是会将最终更改好的pom文件都放上来，如果用的时候出错了，可以去找找自己对应的版本，不要找太高的

第一步：新建工程

在这里插入图片描述

第二步：导入依赖

pom.xml文件跟下面代码一样即可，可以复制粘贴

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.svt</groupId>
    <artifactId>mybatisplus01</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mybatisplus01</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.1</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- 时间格式化需要-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>4.6.17</version>
        </dependency>


    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

1.2创建数据库和表

创建库表

CREATE DATABASE `mp_study` /*!40100 DEFAULT CHARACTER SET utf8mb4 */;
use `mp_study`;
CREATE TABLE `user` (
`id` bigint(20) NOT NULL COMMENT '主键ID',
`name` varchar(30) DEFAULT NULL COMMENT '姓名',
`age` int(11) DEFAULT NULL COMMENT '年龄',
`email` varchar(50) DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

添加数据

INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, 'test1@baomidou.com'),
(2, 'Jack', 20, 'test2@baomidou.com'),
(3, 'Tom', 28, 'test3@baomidou.com'),
(4, 'Sandy', 21, 'test4@baomidou.com'),
(5, 'Billie', 24, 'test5@baomidou.com');

1.3编写代码进行测试

结构图
在这里插入图片描述

第一步：配置application.yml

在resources文件夹下，初始是application.properties文件，重命名为.yml文件，在里面配置
注意这里写自己的数据库名字，以及用户名和密码，配置日志能看到sql语句的执行日志，还是蛮有必要的

# DataSource Config
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mp_study?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
    username: root
    password: 1234

# 配置日志
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  mapper-locations:

第二步：添加实体类

这里讲一个@Data注解，是lombok注解注在类上可以省略get、set、toString方法

@Data//lombok注解
public class User {

    //@TableId(type = IdType.AUTO)
    private Long id;//bigint
    private String name;
    private Integer age;
    private String email;

第三步：添加mapper

这里我写了UserDao类，去继承一个BaseMapper集合，是一个模板方法，在里面有很多简单的mapper模板，BaseMapper是MyBatis-Plus提供的模板mapper，其中包含了基本的CRUD方法，泛型为操作的实体类型

IDEA在 userMapper 处报错，因为找不到注入的对象，因为类是动态创建的，但是程序可以正确的执行。为了避免报错，可以在mapper接口上添加 @Repository 注解

@Mapper
@Repository
public interface UserDao extends BaseMapper<User> {
}

第四步：在test类下写测试类

sql和方法都是MyBatis-Plus一手包揽

@SpringBootTest
class Mybatisplus01ApplicationTests {
    @Autowired
    private UserDao userDao;

    /**
     * 查询
     */
    @Test
    void testGetAll() {
        List<User> userList = userDao.selectList(null);
        //System.out.println(userList);
        for (User user : userList) {
            System.out.println(user);
        }
        //userList.forEach(user->System.out.println(user));
    }
}

在这里插入图片描述

2.Mapper CRUD 接口

以下测试类都写在test文件夹下的Mybatisplus01ApplicationTests内

2.1插入insert

/**
     * 插入
     * id设置为null，却插入了1744724495252283394
     * 这是因为MyBatis-Plus在实现插入数据时，会默认基于雪花算法的策略生成id
     */
    @Test
    void insert(){
        User user = new User();
        user.setName("wonwoo");
        user.setAge(21);
        user.setEmail("wonwoo@baomidou.com");
        int i=userDao.insert(user);
        System.out.println("受影响行数"+i);
        System.out.println(user);
    }

2.2删除delete

通过id删除记录

	/**
     * 通过id删除记录
     */
    @Test
    void testDeleteById(){
        //DELETE FROM user WHERE id=?
        int result = userDao.deleteById(1);
        System.out.println("受影响行数："+result);
    }

通过id批量删除记录

    /**
     * 通过id批量删除记录
     */
    @Test
    void testDeleteBatchIds(){
        //DELETE FROM user WHERE id IN ( ? , ? , ? )
        List<Long> ids = Arrays.asList(1L, 2L, 3L);
        int result = userDao.deleteBatchIds(ids);
        System.out.println("受影响行数："+result);
    }

通过map条件删除记录

    /**
     * 通过map条件删除记录
     */
	@Test
    void testDeleteByMap(){
        //DELETE FROM user WHERE name = ? AND age = ?
        Map<String,Object> map=new HashMap<>();
        map.put("age",21);
        map.put("name","damin");
        int result = userDao.deleteByMap(map);
        System.out.println("受影响行数："+result);
    }

2.3修改update

这里是指定id修改内容

    /**
     * 修改
     */
    @Test
    void testUpdateById(){
        //SELECT id,name,age,email FROM user WHERE id=?
        User user = new User();
        user.setId(1744651407332372481L);
        user.setName("aa");
        user.setAge(22);
        user.setEmail("test22@baomidou.com");
        int result = userDao.updateById(user);
        //注意：updateById参数是一个对象
        System.out.println("受影响行数："+result);
    }

2.4查询select

与删除语法类似，可以仿照写

2.5自动填充-代码级别

讲代码级别的，另一个级别不是动态更新，想了解的自己去搜数据库级别

第一步：修改数据库

添加两个字段create_time,update_time，类型设置为timestamp
将前面数据库级别中的默认设置为null或者不写，根据当前时间更新这个框不勾选
在这里插入图片描述

第二步：给实体类的字段属性增加注释

package com.svt.domain;

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.AllArgsConstructor;
import lombok.Data;
import org.apache.ibatis.annotations.Update;

import java.sql.Date;
import java.sql.Timestamp;
import java.time.LocalDateTime;

@Data//lombok注解 注在类上可以省略get、set、toString方法
public class User {

    //@TableId(type = IdType.AUTO)
    //上面这个注释掉了，如果使用这个注释就要去数据库里将表的主键设置为自增
    private Long id;//bigint
    private String name;
    private Integer age;
    private String email;

    /**
     * 字段添加填充内容
     */

    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createTime;

    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime updateTime;


    public User(Long id, String name, Integer age, String email, LocalDateTime createTime, LocalDateTime updateTime) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.email = email;
        this.createTime = createTime;
        this.updateTime = updateTime;
    }

    public User(){}
}

第三步：编写处理器来处理注释

一定要加上@Slf4j和@Component，前一个开启log4j日志功能，后面为了将我们的处理器加到IOC容器中

package com.svt.handler;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.Date;

@Slf4j
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    //插入时的填充策略
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("start insert fill.....");
        this.strictInsertFill(metaObject, "createTime", LocalDateTime.class, LocalDateTime.now());
        this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());

    }

    //更新时的填充策略
    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("start update fill.....");
        this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());
    }
}

第四步：测试插入和修改

和前面插入insert和修改update的代码一致，直接执行就能看到数据库内有时间信息

3.Service CRUD 接口

说明:
通用 Service CRUD 封装IService (opens new window)接口，进一步封装 CRUD
采用 get 查询单行 remove 删除 list 查询集合 page 分页前缀命名方式区分 Mapper 层避免混淆，
泛型 T 为任意实体对象
建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类
对象 Wrapper 为条件构造器

3.1创建Service接口和实现

package com.svt.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.svt.domain.User;

/**
 *  UserService继承IService模板提供的基础功能
 */
public interface UserService extends IService<User> {
}

package com.svt.service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.svt.dao.UserDao;
import com.svt.domain.User;
import org.springframework.stereotype.Service;

/**
 * ServiceImpl实现了IService，提供了IService中基础功能的实现
 * 若ServiceImpl无法满足业务需求，则可以使用自定的UserService定义方法，并在实现类中实现
 */
@Service
public class UserServiceImpl extends ServiceImpl<UserDao, User> implements UserService {
}

3.2测试查询记录数

    @Autowired
    private UserService userService;

    /**
     * 测试查询记录数
     */
    @Test
    void testGetCount(){
        long count = userService.count();
        System.out.println("总记录数：" + count);
    }

3.3测试批量插入

    /**
     * 测试批量插入
     * 先把user对象存到list（存在内存中），然后直接save集合list中的所有user
     */
    @Test
    void testSaveBatch(){
        // SQL长度有限制，海量数据插入单条SQL无法实行，
        // 因此MP将批量插入放在了通用Service中实现，而不是通用Mapper
        ArrayList<User> users = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            User user = new User();
            user.setName("lyl"+i);
            user.setAge(20+i);
            user.setEmail("test"+i+"@baomidou.com");
            users.add(user);
        }
        //SQL:INSERT INTO t_user ( username, age ) VALUES ( ?, ? )
        userService.saveBatch(users);
    }

4.条件构造器和常用接口

4.1Wrapper

Wrapper：条件构造器抽象类，最顶端父类
- AbstractWrapper ：用于查询条件封装，生成 sql 的 where 条件
  - QueryWrapper ：查询条件封装
  - UpdateWrapper ： Update 条件封装
  - AbstractLambdaWrapper ：使用Lambda 语法
    - LambdaQueryWrapper ：用于Lambda语法使用的查询Wrapper
    - LambdaUpdateWrapper ： Lambda 更新封装Wrapper

按照层级划分

4.2QueryWrapper

组装查询条件

    /**
     * 组装查询条件
     */
    @Test
    void test1(){
        //查询用户名包含l，年龄在20到30之间，并且邮箱不为null的用户信息
        //SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE
        // is_deleted=0 AND (username LIKE ? AND age BETWEEN ? AND ? AND email IS NOT NULL)
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
        queryWrapper.like("name","l")
                .between("age",20,30)
                .isNotNull("email");
        List<User> userList = userDao.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

组装排序条件

    /**
     * 组装排序条件
     */
    @Test
    void test2(){
        //按年龄降序查询用户，如果年龄相同则按id升序排列
        // SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE
        // is_deleted=0 ORDER BY age DESC,id ASC
        QueryWrapper<User>queryWrapper=new QueryWrapper<>();
        queryWrapper.orderByDesc("age")//降序
                .orderByAsc("id");//升序
        List<User> userList = userDao.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

组装删除条件

    /**
     * 组装删除条件
     */
    @Test
    void test3(){
        //删除age为空的用户
        //DELETE FROM t_user WHERE (age IS NULL)
        QueryWrapper<User>queryWrapper=new QueryWrapper<>();
        queryWrapper.isNull("age");
        int result = userDao.delete(queryWrapper);
        System.out.println("受影响的行数：" + result);
    }

条件的优先级

    /**
     * 条件的优先级
     */
    @Test
    void test4(){
        //将（年龄大于25并且用户名中包含有a）或邮箱为null的用户信息修改 年龄18，邮箱aaa@a.com
        //UPDATE t_user SET age=?, email=? WHERE (username LIKE ? AND age > ?
        // OR email IS NULL)
        QueryWrapper<User>queryWrapper=new QueryWrapper<>();
        queryWrapper.gt("age",25)
                .like("name","a")
                .or()
                .isNull("email");
        User user = new User();
        user.setAge(18);
        user.setEmail("aaa@a.com");
        int result = userDao.update(user, queryWrapper);
        System.out.println("受影响的行数：" + result);
    }

组装select子句

    /**
     * 组装select子句
     */
    @Test
    void test5(){
        //查询用户信息的username和age字段
        //SELECT username,age FROM t_user
        QueryWrapper<User>queryWrapper=new QueryWrapper<>();
        queryWrapper.select("name","age");
        List<User> userList = userDao.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

实现子查询

    /**
     * 实现子查询
     */
    @Test
    void test6(){
        //查询id小于等于3的用户信息
        //SELECT id,username AS name,age,email,is_deleted FROM t_user
        // WHERE (id IN (select id from t_user where id <= 3))
        QueryWrapper<User>queryWrapper=new QueryWrapper<>();
        queryWrapper.inSql("id", "select id from user where id <= 3");
        List<User> userList = userDao.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

4.3UpdateWrapper

    /**
     * UpdateWrapper
     */
    @Test
    void test7(){
        //将（年龄大于20或邮箱为null）并且用户名中包含有l的用户信息修改
        //组装set子句以及修改条件
        UpdateWrapper<User> updateWrapper=new UpdateWrapper<>();
        //lambda表达式内的逻辑优先运算
        updateWrapper.set("age",16)
                .set("name","wonwoo")
                .like("name","l")
                .and(i->i.gt("age",20).or().isNull("email"));
        //这里必须要创建User对象，否则无法应用自动填充。如果没有自动填充，可以设置为null
        //UPDATE t_user SET username=?, age=?,email=? WHERE (username LIKE ? AND (age > ? OR email IS NULL))
//        User user = new User();
        //user.setName("张三");
        int result = userDao.update(null, updateWrapper);
        System.out.println(result);
    }

4.4condition

在真正开发的过程中，组装条件是常见的功能，而这些条件数据来源于用户输入，是可选的
因此我们在组装这些条件时，必须先判断用户是否选择了这些条件，若选择则需要组装该条件
若没有选择则一定不能组装，以免影响SQL执行的结果

    /**
     * condition
     * 在真正开发的过程中，组装条件是常见的功能，而这些条件数据来源于用户输入，是可选的
     * 因此我们在组装这些条件时，必须先判断用户是否选择了这些条件，若选择则需要组装该条件
     * 若 没有选择则一定不能组装，以免影响SQL执行的结果
     */
    @Test
    void test8(){
        //定义查询条件，有可能为null（用户未输入或未选择）
        String name=null;
        Integer ageBegin=10;
        Integer ageEnd=24;
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
        //StringUtils.isNotBlank()判断某字符串是否不为空且长度不为0且不由空白符(whitespace)构成
        if(StringUtils.isNotBlank(name)){
            queryWrapper.like("name","a");
        }
        if(ageBegin!=null){
            queryWrapper.ge("age",ageBegin);//大于等于
        }
        if (ageEnd!=null){
            queryWrapper.le("age",ageEnd);//小于等于
        }
        //SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE (age >= ? AND age <= ?)
        List<User> userList = userDao.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

    /**
     * 上面的实现方案没有问题，但是代码比较复杂，我们可以使用带condition参数的重载方法构建查 询条件，简化代码的编写
     */
    @Test
    void test08UseCondition(){
        //定义查询条件，有可能为null（用户未输入或未选择）
        String name=null;
        Integer ageBegin=10;
        Integer ageEnd=20;
        QueryWrapper<User>queryWrapper=new QueryWrapper<>();
        //StringUtils.isNotBlank()判断某字符串是否不为空且长度不为0且不由空白符(whitespace)构成
        queryWrapper.like(StringUtils.isNotBlank(name),"name","a")
                .ge(ageBegin!=null,"age",ageBegin)
                .le(ageEnd!=null,"age",ageEnd);
        //SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE (age >= ? AND age <= ?)
        List<User> userList = userDao.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

5.插件

5.1分页插件

MyBatis Plus自带分页插件，只要简单的配置即可实现分页功能

第一步：添加配置类

package com.svt.config;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@MapperScan("com.svt.dao")//可将主类中的注解移到这里
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new
                PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

第二步：去测试类测试

    /**
     * 分页参数
     */
    @Test
    void testPage(){
        //设置分页参数
        Page<User> page=new Page<>();
        userDao.selectPage(page,null);
        //获取分页数据
        List<User> list = page.getRecords();
        list.forEach(System.out::println);
        System.out.println("当前页："+page.getCurrent());
        System.out.println("每页显示的条数："+page.getSize());
        System.out.println("总记录数："+page.getTotal());
        System.out.println("总页数："+page.getPages());
        System.out.println("是否有上一页："+page.hasPrevious());
        System.out.println("是否有下一页："+page.hasNext());
    }