Springboot整合mybatis-Plus(注解版)

环境：

开发工具：idea
Java version: 1.8.0

新建工程：

新建一个maven工程

新建maven工程

先看看我的工程结构吧，列出了几个用到的类和配置文件

工程结构

我们需要导入什么包呢？看看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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.myspringboot</groupId>
  <artifactId>collection</artifactId>
  <version>1.0-SNAPSHOT</version>
  <name>collection</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <mybatis-plus.version>3.1.1</mybatis-plus.version>
  </properties>
  
  <!-- spring-boot -->
  <parent>
     <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.6.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>

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

    <!-- springboot开发工具 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-devtools</artifactId>
    </dependency>

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

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

    <!-- mybatisPlus插件 -->
    <dependency>
      <groupId>com.baomidou</groupId>
      <artifactId>mybatis-plus-boot-starter</artifactId>
      <version>${mybatis-plus.version}</version>
    </dependency>

    <!--阿里 Druid Spring Boot Starter依赖-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid-spring-boot-starter</artifactId>
      <version>1.1.18</version>
    </dependency>

    <!-- 分页 -->
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>5.1.6</version>
    </dependency>
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper-spring-boot-starter</artifactId>
      <version>1.2.13</version>
    </dependency>

    <!-- 实体类 -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.8</version>
      <scope>provided</scope>
    </dependency>

    <!-- mysql数据库驱动 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.16</version>
      <scope>runtime</scope>
    </dependency>

    <!--阿里 FastJson依赖-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.58</version>
    </dependency>

    <dependency>
      <groupId>com.fasterxml.jackson.datatype</groupId>
      <artifactId>jackson-datatype-jsr310</artifactId>
    </dependency>

    <!-- 打印 -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>

  </dependencies>

  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.7.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-project-info-reports-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>

</project>

log4j.properties的配置:

# Global logging configuration, 建议开发环境中要用DEBUG,生产环境设置成info或error
log4j.rootLogger=DEBUG, stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n

log4j.logger.Java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

application.yml的配置：

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatisPlus?characterEncoding=utf-8
    username: root
    password: 930614

# Mybatis配置
mybatis-plus:
  # 如果是放在src/main/java目录下 classpath:/com/yourpackage/*/mapper/*Mapper.xml
  # 如果是放在resource目录 classpath:/mapper/*Mapper.xml
  # 我们这里使用注解的方式：这句话可以注释掉：
  # mapper-locations: classpath:/mapper/**/*Mapper.xml

  #实体扫描，多个package用逗号或者分号分隔
  type-aliases-package: com.myspringboot.model
  #枚举扫描，多个package用逗号或者分号分隔
  type-enums-package: com.myspringboot.enums
  
  global-config:  #全局配置mybatis
    db-config:
      #主键类型  0:"数据库ID自增", 1:"用户输入ID",2:"全局唯一ID (数字类型唯一ID)", 3:"全局唯一ID UUID";
      id-type: id_worker
      #字段策略 0:"忽略判断",1:"非 NULL 判断"),2:"非空判断"
      field-strategy: not_empty
      #逻辑删除配置（下面3个配置）
      #逻辑删除全局值
      logic-delete-value: 1
      #逻辑未删除全局值
      logic-not-delete-value: 0
      # sql-injector: com.baomidou.mybatisplus.extension.injector.LogicSqlInjector
      #自定义填充策略接口实现
      #meta-object-handler: com.baomidou.springboot.MyMetaObjectHandler
  configuration:
    #配置返回数据库(column下划线命名&&返回java实体是驼峰命名)，自动匹配无需as（没开启这个，SQL需要写as： select user_id as userId）
    map-underscore-to-camel-case: true
    cache-enabled: false
    #当查询数据为空时字段返回为null，不加这个查询数据为空时，字段将被隐藏
    call-setters-on-nulls: true

#pagehelper
pagehelper:
  helperDialect: mysql
  reasonable: true
  supportMethodsArguments: true
  params: count=countSql
  returnPageInfo: check

关于mybatis的一些插件配置，还有扫描mapper接口实体我们放在一个MybatisPlusConfig配置类里做，并且将其加入到spring容器中，更方便维护。
MybatisPlusConfig配置类内容

package com.myspringboot.config;

import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.myspringboot.commos.interceptor.MyInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@MapperScan("com.myspringboot.dao") // 设置mapper接口的扫描包，会自动生成实例
public class MybatisPlusConfig {
    /**
     * 配置mybatis拦截器(插件)
     */
    @Bean
    public MyInterceptor myInterceptor() {
        return new MyInterceptor();
    }

    /**
     * 配置乐观锁：当更新一条记录时，希望这条记录没有被别人更新
     *  实现方式： 1.取出记录时，获取当前的version 2.更新时，带上这个version 3.执行更新时，set version = newVersion where version = oldVersion
     *           4.若version不对，就更新失败
     *  仅支持：updateById()、update(entity wrapper)  注意这个wrapper不能复用！
     */
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }


    // 分页插件(我们这里使用了pagehelper插件，所以没用mybatis自带插件)
//    @Bean
//    public PaginationInterceptor paginationInterceptor(){
//        return new PaginationInterceptor();
//    }
}

提及了一个MyInterceptor拦截器

MyInterceptor

我这里做简单的注释使用吧，不是今天的主菜。

package com.myspringboot.commos.interceptor;

import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.plugin.*;

import java.util.Properties;

/**
 * 配置mybatis拦截器，可以拦截mybatis的API，下面举例update
 * Mybatis允许使用插件拦截得方法调用包括：
 *  1.执行器的方法       Executor(update, query, flushStatements, commit, rollback, getTransaction)
 *  2.参数的处理        ParameterHandler(getParameterObject, setParameters)
 *  3.结果集的处理      ResultSetHandler(handleResultSets, handleOutputParameters)
 *  4.sql语法构建的处理 StatementHandler(prepare, parameterize, batch, update, query)
 */
@Intercepts({
        @Signature(type = Executor.class, // 拦截执行器
                   method = "update", // 执行器中的update方法
                   args = {MappedStatement.class, Object.class})
})
public class MyInterceptor implements Interceptor {

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 拦截方法，具体业务编写的位置 - 这只有update操作才会拦截，因为上面注解已经限制了
        System.out.println("111111");
        return invocation.proceed();
    }

    @Override
    public Object plugin(Object target) {
        // 创建target对象的代理对象，目的是将当前拦截器加入到该对象中
        return Plugin.wrap(target, this); // 意思对target对象进行包装
    }

    @Override
    public void setProperties(Properties properties) {
        // 设置属性
    }
}

看看我们数据库的表结构

表结构

随意插入了几条数据吧：

表数据

接下来就是我们的MVC层的内容了：
实体类User

package com.myspringboot.model;


import com.baomidou.mybatisplus.annotation.*;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_user") // mybatis-plus 映射表名 默认是类名小写user，可以配置前缀
public class User extends Model<User> { //ActiveRecord功能： extends Model<User>
    // 指定生成ID类型枚举类, 若在springboot配置文件上添加了全局主键生成策略，则不需要在这里写了
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    private String userName;

    // 不想在查询的时候被查询出来时设置这个select
    // fill是在插入或更新或者两者都支持填充的时候，自动插入值，默认default就是不处理。ps：需要自定义MyMetaObjectHandler实现接口
    @TableField(select = false, fill = FieldFill.INSERT) // 这里指定在插入时，自动填充
    private String password;

    private String name;

    private Integer age;

    // 解决对象中的属性名和字段名不一致（非驼峰）
    @TableField(value = "email")
    private String mail;

    // 解决对象中的属性在表中不存在的问题
    @TableField(exist = false)
    private String address;

    // 乐观锁的版本字段（需要在MybatisPlusConfig配置乐观锁拦截器）
    // 当更新一条记录时，希望这条记录没有被别人更新
    @Version
    private Integer version;

    // 标记逻辑删除字段 0-正常 1-删除
    // 逻辑删除需要在application.yml中做配置
    // 实际上删除的数据是不会从物理上删除，只是做一个标记，等查询的时候不被查询出来
    @TableLogic
    private Integer deleted;
}

UserService接口：

package com.myspringboot.service;

import com.github.pagehelper.PageInfo;
import com.myspringboot.model.User;

import java.util.Map;

public interface UserService {

    User findById(long id);

    PageInfo<Map<String, Object>> allUsers(Integer pageSize, Integer pageNum);
}

UserServiceImpl实现类

package com.myspringboot.service.impl;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.myspringboot.dao.UserMapper;
import com.myspringboot.model.User;
import com.myspringboot.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;

@Service
public class UserServiceImpl implements UserService {
    // 这个实体类生成是在MybatisPlusConfig配置类里扫描了mapper
    @Autowired
    private UserMapper userMapper; 

    @Override
    public User findById(long id) {
        return this.userMapper.findById(id);
    }

    @Override
    public PageInfo<Map<String, Object>> allUsers(Integer pageNum,Integer pageSize) {
        PageHelper.startPage(pageNum, pageSize);
        List<User> list = userMapper.selectList(null);
        PageInfo pageInfo =  new PageInfo(list);
        int pages = pageInfo.getPages(); // 注意如果pageNum > pages 产生的数值还是最大页码值
        System.out.println(pages);
        return pageInfo;
    }
}

UserController:

package com.myspringboot.controller;

import com.alibaba.fastjson.JSONObject;
import com.myspringboot.commos.exception.ResultGenerator;
import com.myspringboot.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping(value = "/user")
public class UserController {

    @Autowired
    private UserService userService;

    @PostMapping("/findAllUser")
    @ResponseBody
    Object findAllUser(@RequestBody JSONObject json) {
        Integer pageNum = json.getInteger("pageNum");
        Integer pageSize = json.getInteger("pageSize");
        return this.userService.allUsers(pageNum, pageSize);
    }

    @PostMapping("/findUserById")
    Object findUserById(@RequestParam("id") Integer id) {
        System.out.println(id);
        return this.userService.findById(id);
    }

    @GetMapping("/findById/{id}") // 支持RESTful规范
    Object findById(@PathVariable("id") Integer id) {
        System.out.println(id);
        return ResultGenerator.getSuccessResult(this.userService.findById(id));
    }
}

最后是我们的启动类App

package com.myspringboot;

import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@SpringBootApplication(exclude = DruidDataSourceAutoConfigure.class)
@EnableTransactionManagement
@EnableCaching
public class App
{
    public static void main( String[] args )
    {
        SpringApplication.run(App.class, args);
    }
}

验证时刻：
启动我们的App