MyBatis-Plus整合SpringBoot2

MyBatis-Plus整合SpringBoot

• MyBatis-Plus(简称MP)是一个MyBatis的增强工具，在MyBatis的基础上只做增强不做改变，为简化开发，提高效率而生。
• MyBatis-Plus整合SpringBoot
  • 创建SpringBoot工程，添加依赖

<?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.5.1</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.amberli</groupId>
    <artifactId>mybatis-plus-springboot001</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mybatis-plus-springboot001</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.13</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.projectreactor</groupId>
            <artifactId>reactor-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

• 创建数据库和数据表

CREATE DATABASE mybatisplus;

CREATE TABLE tbl_employee(
 id INT(11) PRIMARY KEY AUTO_INCREMENT,
 last_name VARCHAR(255),
 email VARCHAR(255),
 gender CHAR(1),
 age INT(11)
);

INSERT INTO tbl_employee(last_name,email,gender,age) VALUES('tom','tom@qq.com',1,20);
INSERT INTO tbl_employee(last_name,email,gender,age) VALUES('jack','jack@qq.com',1,21);
INSERT INTO tbl_employee(last_name,email,gender,age) VALUES('jerry','jerry@qq.com',0,22);
INSERT INTO tbl_employee(last_name,email,gender,age) VALUES('smith','smith@qq.com',0,23);

• 配置数据源

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/mybatisplus?serverTimezone=Asia/Shanghai&useSSL=false
    username: root
    password: 123456
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

• 创建数据表对应的Bean类

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tbl_employee")
public class Employee {
    @TableId(type = IdType.AUTO)
    private Integer id;
    private String lastName;
    private String email;
    private Integer gender;
    private Integer age;

    @TableField(exist = false)
    private Integer salary;
}

• 在启动类上添加Mapper接口扫描注解

@SpringBootApplication
@MapperScan("com.amberli.boot.mapper")  //Mapper接口扫描注解
public class MybatisPlusSpringboot001Application {

    public static void main(String[] args) {
        SpringApplication.run(MybatisPlusSpringboot001Application.class, args);
    }

}

• 创建Mapper接口并继承BaseMapper获取通用CRUD方法

package com.amberli.boot.mapper;

import com.amberli.boot.bean.Employee;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface EmployeeMapper extends BaseMapper<Employee> {
}

• 接口EmployeeMapper继承BaseMapper接口，BaseMapper源码中定义了非常多的方法

public interface BaseMapper<T> extends Mapper<T> {
    int insert(T entity);

    int deleteById(Serializable id);

    int deleteByMap(@Param("cm") Map<String, Object> columnMap);

    int delete(@Param("ew") Wrapper<T> queryWrapper);

    int deleteBatchIds(@Param("coll") Collection<? extends Serializable> idList);

    int updateById(@Param("et") T entity);

    int update(@Param("et") T entity, @Param("ew") Wrapper<T> updateWrapper);

    T selectById(Serializable id);

    List<T> selectBatchIds(@Param("coll") Collection<? extends Serializable> idList);

    List<T> selectByMap(@Param("cm") Map<String, Object> columnMap);

    T selectOne(@Param("ew") Wrapper<T> queryWrapper);

    Integer selectCount(@Param("ew") Wrapper<T> queryWrapper);

    List<T> selectList(@Param("ew") Wrapper<T> queryWrapper);

    List<Map<String, Object>> selectMaps(@Param("ew") Wrapper<T> queryWrapper);

    List<Object> selectObjs(@Param("ew") Wrapper<T> queryWrapper);

    <E extends IPage<T>> E selectPage(E page, @Param("ew") Wrapper<T> queryWrapper);

    <E extends IPage<Map<String, Object>>> E selectMapsPage(E page, @Param("ew") Wrapper<T> queryWrapper);
}

• 测试代码，新增

    @Autowired
    private EmployeeMapper employeeMapper;

    // 新增
    @Test
    void contextLoads() {
        Employee employee = new Employee(null, "aaa","aaa@qq.com",1,30,null);
        employeeMapper.insert(employee);
    }

• 更新

    //更新
    @Test
    void update_contextLoads(){
        Employee employee = new Employee(5, "bbb", "bbb@qq.com", 1, 30, 3000);
        employeeMapper.updateById(employee);
    }

• 查询

    //查询
    @Test   // selectById 根据id查询
    void selectById_contextLoads(){
        Employee employee = employeeMapper.selectById(1);
        System.out.println(employee);
    }

    @Test   //selectBatchIds 批量查询
    void selectBatchIds_contextLoads(){
        List<Employee> employees = employeeMapper.selectBatchIds(Arrays.asList(1, 2, 3));
        for (Employee emp: employees
             ) {
            System.out.println(emp);
        }
    }

    @Test   // selectByMap 批量查询 根据Map封装条件, Map中的键为数据库表中的字段名二非实体类中的属性名
    void selectByMap_contextLoads(){
        HashMap<String, Object> map = new HashMap<>();
        map.put("last_name","tom");
        map.put("id",1);
        map.put("gender",1);

//        map.put("id","2");

        List<Employee> employees = employeeMapper.selectByMap(map);
        for (Employee emp: employees
             ) {
            System.out.println(emp);
        }

    }

• 删除

    @Test   //deleteById 根据id删除
    void deleteById_contextLoads(){
        employeeMapper.deleteById(10);
    }

    @Test
    void deleteByMap_contextLoads(){
        HashMap<String, Object> map = new HashMap<>();
        map.put("last_name", "aaa");
        employeeMapper.deleteByMap(map);
    }

    @Test
    void deleteBatchIds_contextLoads(){
        employeeMapper.deleteBatchIds(Arrays.asList(1,2,3));
    }

• 条件构造器
  • MyBatisPlus提供了一个条件构造器，QueryWrapper，能够自由构建查询条件，大大提升开发效率

 @Test   // 按每页两行数据进行分页，显示第一页
    void queryWrapper_contextLoads(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.between("age",10,30);   //查询年龄在10~30岁之间的员工信息
        IPage<Employee> page = employeeMapper.selectPage(new Page<>(1, 2), wrapper);    //分页显示，当前页，每页显示2个
        List<Employee> emps = page.getRecords();
        for (Employee emp: emps
             ) {
            System.out.println(emp);
        }
    }

• 首先构造QueryWrapper对象，通过between拼接sql,注意其中的参数必须是表字段名，然后通过selectPage方法进行分页查询 分页规则，new Page<>(1,2),即:按每页两行数据进行分页，显示第1页，记得需要注册分页拦截器

@Configuration
//@MapperScan("com.baomidou.service.*.mapper*")
public class MyBatisConfig {

    // 新版  注册分页拦截器
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

• QueryWrapper对象的链式调用

@Test
    void selectPage_contextLoads(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<Employee>()
                .between("age",10,30)   // 查询年龄10~30岁
                .eq("gender",1);    // 且性别为男
        Page<Employee> page = employeeMapper.selectPage(new Page<>(1,2),wrapper);
        List<Employee> emps = page.getRecords();
        for (Employee emp:emps
             ) {
            System.out.println(emp);
        }
    }

    @Test   // 查询性别为男，名字带有字母j或者邮箱中带有字母a员工信息
    void selectList_contextLoads(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<Employee>()
                .eq("gender",1)
                .like("last_name","j")
                .or()
                .like("email","a");
        List<Employee> employees = employeeMapper.selectList(wrapper);
        for (Employee emp:employees
             ) {
            System.out.println(emp);
        }
    }

    @Test   //updateWrapper更新，修改名字中字母j并且年龄为21岁的员工信息，将其年龄修改为30岁
    void updateWrapper_contextLoads(){
        Employee employee = new Employee();
        employee.setAge(30);
        UpdateWrapper<Employee> wrapper = new UpdateWrapper<Employee>()
                .like("last_name","j")
                .eq("age",21);
        employeeMapper.update(employee, wrapper);
    }

    @Test   // QueryWrapper来限定条件，删除名字中带字母b且年龄为30岁的男性员工信息
    void delete_contenxtLoads(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<Employee>()
                .like("last_name","b")
                .eq("age",30)
                .eq("gender",1);
        employeeMapper.delete(wrapper);
    }

    @Test
    void remove_contextLoads(){
        Employee employee = new Employee();
        employee.setLastName("xiaoa");
        employee.setAge(25);
        UpdateWrapper<Employee> wrapper = new UpdateWrapper<Employee>()
                .like("last_name", "aa")
                .eq("gender",1)
                .eq("age",30);
        employeeMapper.update(employee,wrapper);

    }
}