[Java知识库]Mybatis-plus快速上手

MyBatis-Plus

什么是mybatis-plus：

MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

官网：https://mp.baomidou.com/guide/page.html

1、基本的curd操作

Spring Boot整合MyBatis-Plus，简单的配置，即可快速进行单表的curd操作

1. 引入依赖

   	<!--引入mybatis-plus的依赖-->
           <dependency>
               <groupId>com.baomidou</groupId>
               <artifactId>mybatis-plus-boot-starter</artifactId>
               <version>3.4.2</version>
           </dependency>
   

   需要xml

   附：yml中配置MyBatis-Plus日志和数据源

   #配置MyBatis-Plus日志、xmlw
   mybatis-plus:
     configuration:
       log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
     mapper-locations: classpath*:/com/tianyi/springbootshiro/mapper/xml/*Mapper.xml
   #数据源配置
   spring:
     datasource:
       driver-class-name: com.mysql.cj.jdbc.Driver
       url: jdbc:mysql://localhost:3306/smbms?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
       username: root
       password: root
   

   要么在resources下创建包来存放*Mapper.xml，要么配置pom.xml，让程序编译java目录下的xml文件

   <!--其他内容省略-->
   <build>
       <resources>
         <!--编译src/main/java目录下的xml文件-->
         <resource>
           <directory>src/main/java</directory>
           <includes>
             <include>**/*.xml</include>
           </includes>
           <filtering>true</filtering>
         </resource>
       </resources>
   </build>
   

2. 创建实体类（User）

3. 编写mapper包和实体类对应的mapper接口，同时继承BaseMapper父接口

   //对哪个实体类进行操作，BaseMapper中的泛型就填写哪个类
   public interface UserMapper extends BaseMapper<User> {
   
   }
   

4. 应用程序入口类添加@MapperScan注解
   精确到mapper层

   @MapperScan("com.tianyi.mapper")
   

5. 就可以写测试类，测试在springboot的测试类中功能了……

   @Autowired
       private UserMapper userMapper;
   
       /**
        * 查询所有的列表
        */
       @Test
       void selectList() {
           List<User> users = userMapper.selectList(null);
           users.forEach(user -> System.out.println(user));
       }
   
       /**
        * 增加
        */
       @Test
       void insert(){
           User user=new User(null,"李伟伟",18,"liweiweiniubi@qq.com");
           int i = userMapper.insert(user);
           System.out.println(i);
       }
   
       /**
        * 通过id删除
        */
       @Test
       void deleteById(){
           int i = userMapper.deleteById(1l);
           System.out.println(i);
       }
   
       /**
        * 根据map条件删除数据，也就是根据map中的多个键值对条件来进行删除
        */
       @Test
       void deleteByMap(){
           Map map=new HashMap();
           map.put("name","Billie");
           map.put("age",24);
           int i = userMapper.deleteByMap(map);
           System.out.println(1);
       }
   
       /**
        * 批量删除
        */
       @Test
       void deleteBatchIds(){
           int i = userMapper.deleteBatchIds(Arrays.asList(1,2,3));
           System.out.println(i);
       }
   

   注意：
   如果实体类字段，是sql中的关键字，查询的时候就会报错，这时候给实体类字段添加@TableField注解

   @TableField("`explain`")
   private String explain;
   

2、主键增长策略

• 新增的时候如果没有给实体类赋值id属性，并且数据库没有id自增，mybatis-plus会自动给我们生成一个id

• 自3.3.0开始,默认使用雪花算法+UUID(不含中划线)

• //UUID的产生例子
  @Test
  void testUUID(){
      UUID uuid=UUID.randomUUID();
      System.out.println(uuid);
  }
  //结果
  //20bec9fb-7310-4ebb-b084-954cf0e417e5
  

• 导致数据库设置了自增也无法按之前一样，id++地自增

• //清除表数据，并重置id
  truncate table user
  

• 设置主键生成策略：

  public class User {
      //在需要自增的列上增加这个注解，并设置type的值
      @TableId(type= IdType.AUTO)
      private Long id;
      private String name;
      private Integer age;
      private String email;
  }
  

3、分页插件

不用导入依赖，mybatis-plus内置有

配置分页插件：在config包（专门写配置类的包）下编写MybatisPlusConfig类

//Spring boot方式
@Configuration
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        //分页插件
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.H2));
        return interceptor;
    }
}

测试：

@Test
    void selectPageVo(){
        //简单的分页，只适用单表的查询
        IPage<User> page=new Page<>(1,2);
        //两个参数，第二个为查询条件，属于高级查询内容
        IPage<User> userIPage = userMapper.selectPage(page, null);
        List<User> userList = userIPage.getRecords();
        userList.forEach(user -> System.out.println(user));
        //userService.page(page);
    }

注意：编写配置类

4、逻辑删除

例子：订单删除，并不是真的删除，而是创建一个标识字段，查询的时候根据这个表示字段过滤掉“删除”了的数据，这个订单只是用户看不到了，后台还需要这个订单信息，例如要做年度销售额报告。

注意：

• 只对自动注入的sql起效

• 插入：不作限制

• 查找：追加where条件过滤掉已删除的数据，且使用 wrapper.entity 生成的where条件会忽略该字段
  例如：

  select id,name,deleted from user where deleted=0
  

• 更新：追加where条件防止更新到已经删除的数据，且使用 wrapper.entity 生成的where条件会忽略该字段

• 删除：转变为 更新（通俗说，就是把删除的标识字段修改）
  例如：

  update user set deleted=1 where id = 1 and deleted=0
  

使用方法：
1.配置application.yml配置文件

mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: deleted  # 全局逻辑删除的实体字段名(since 3.3.0,配置后可以忽略不配置步骤2)
      logic-delete-value: 1 # 逻辑已删除值(默认为 1)
      logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)

2.实体类新增逻辑删除字段和@TableLogic注解

public class User {
    @TableId(type= IdType.AUTO)
    private Long id;
    private String name;
    private Integer age;
    private String email;
    /**
     * 增加逻辑删除注解
     */
    @TableLogic
    private Integer deleted;
}

3.config包编写MyBatisPlusConfig类(mybatis-plus3.1.1之后逻辑删除不用写配置文件)

@Configuration
@EnableTransactionManagement
public class MyBatisPlusConfig {
    /**
     * 逻辑删除插件,3.1之后不用再配置
     */
    @Bean
    public ISqlInjector sqlInjector() {
        return new LogicSqlInjector();
    }

    /**
     * 分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

5、自动填充功能

例子：商品表的一个实体——商品的创建时间和修改时间，总要创建和修改的时候填写，我们想让他自动填充。

例如阿里巴巴的开发手册对MySQL的建表提出的要求：
【强制】表必备的三个字段：

1. id 类型为unsigned bigint，表示无符号的bigint，单表时自增，步长为1
2. gmt_create 创建时间，类型data_time，主动创建
3. gmt_modified 修改时间，被动更新

如果没有使用mybatis-plus也有其他方法（对数据库设置依赖太强，不推荐）：
设计表，勾选“根据当前时间戳更新”

mybatis-plus的自动填充：

开启驼峰命名（自动驼峰命名规则，即从经典数据库列名 create_time 下划线命名到经典java属性名createTime）：

mybatis-plus:
  configuration:
    map-underscore-to-camel-case: true

1、在需要填充的字段上添加@TableField注解

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

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

关于@TableField注解的参数中，fill的值：

public enum FieldFill {
    /**
     * 默认不处理
     */
    DEFAULT,
    /**
     * 插入时填充字段
     */
    INSERT,
    /**
     * 更新时填充字段
     */
    UPDATE,
    /**
     * 插入和更新时填充字段
     */
    INSERT_UPDATE
}

2、创建处理包handler,在这个包下创建自动填充处理类

/**
 * 自动填充处理类,需要写在handler这个处理类的包
 */
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    /**
     * 增加的时候会执行的方法
     * @param metaObject 第一个参数（元数据）不用管
     *                   第二个参数：需要填充的字段名称
     *                   第三个参数：填充的字段的类型
     *                   第四个参数：填充的值
     */
    @Override
    public void insertFill(MetaObject metaObject) {
        this.strictInsertFill(metaObject, "createTime", Date.class, new Date());
        //这里有一个业务逻辑：新增的时候不但要填充createTime还要填充updateTime
        this.strictUpdateFill(metaObject, "updateTime", Date.class, new Date());
    }

    /**
     * 修改的时候会执行的方法
     * @param metaObject
     */
    @Override
    public void updateFill(MetaObject metaObject) {
        this.strictUpdateFill(metaObject, "updateTime", Date.class, new Date());
    }
}

6、高级查询

之前我们使用一些mybatis-plus提供的方法的时候，可以看到有些方法有条件参数

测试：

/**
     * 高级查询
     * 模糊查询姓名包含马的，并且年龄大于等于18的
     */
    @Test
    void Gj(){
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
        queryWrapper.like("name","马");
        //表示姓“马”,likeRight表示%占位符在右边
        //queryWrapper.likeRight("name","马");
        queryWrapper.ge("age",18);//表示这两个条件同时满足

        //表示这两个条件or来拼接，满足其一就可
        //queryWrapper.like("name","马").or().ge("age",18);
        List<User> list = userMapper.selectList(queryWrapper);
        list.forEach(user -> System.out.println(user));
        //还有其他很多，具体可以看AbstractWrapper的源码
    }

7、乐观锁

• 悲观锁：一种对数据的修改持有悲观态度的并发控制方式，总是假设最坏的情况，每次读取数据的时候都默认其他线程会更改数据
• 乐观锁：乐观锁是相对悲观锁而言的，乐观锁假设数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则返回给用户错误的信息，让用户决定如何去做。乐观锁适用于读操作多的场景，这样可以提高程序的吞吐量。

当要更新一条记录的时候，希望这条记录没有被别人更新
乐观锁实现方式：

• 取出记录时，获取当前version
• 更新时，带上这个version
• 执行更新时， set version = newVersion where version = oldVersion
• 如果version不对，就更新失败

实现方式：

1、实体类和表添加字段version

2、添加配置，写在配置类（被@Configuration注解的类）里面就可以了

@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
    return interceptor;
}

3、在实体类字段上加上@version注解

4、测试
注意：要先查询出这个对象，再在这个对象上做修改，再修改，才可以触发乐观锁

	/**
     * 测试乐观锁
     */
    @Test
    void version(){
        //先查询出来这个用户
        User user = userMapper.selectById(1);
        user.setAge(18);//再修改这个用户
        //再更新
        userMapper.updateById(user);//修改过后，version就会+1
    }

这是日志记录下来的sql，可以看到where条件中有对version的判断

==>  Preparing: UPDATE user SET name=?, age=?, email=?, create_time=?, update_time=?, version=? WHERE id=? AND version=? AND deleted=0
==> Parameters: 戴富豪(String), 18(Integer), 305592@qq.com(String), 2021-05-21 16:01:16.0(Timestamp), 2021-05-22 16:51:54.0(Timestamp), 3(Integer), 1(Long), 2(Integer)

体现乐观锁：

	/**
     * 乐观锁被插队测试
     */
    @Test
    void versionFail(){
        User user1 = userMapper.selectById(1);
        user1.setAge(38);

        //插队
        User user2 = userMapper.selectById(1);
        user2.setAge(88);
        userMapper.updateById(user2);
		//这时候，下面这条语句就不会执行成功，因为更新的时候会验证版本，经过插队的方法的执行，导致版本+1了
        userMapper.updateById(user1);
    }

8、自定义SQL查询和多表联查

直接使用mybatis的方法，在 mapper.xml 中写SQL语句多表联查
也可以利用注解，将SQL写在注解属性中，这样就不用起 mapper.xml 文件

@Repository
public interface FyUserMapper extends BaseMapper<FyUser> {


    @Select("SELECT * FROM fy_user u LEFT JOIN fy_role r ON u.role = r.id")
    List<UserRoleVo> selectUserListPage(Page<UserRoleVo> pagination);

}

同理，还有@Insert、@Update，@Delete，分别相对应SQL类型，匹配增删改查操作选择使用

9、代码生成器

1、引入代码生成器的相关依赖

		<!--代码生成器的相关依赖-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.4.1</version>
        </dependency>
        <!--添加 模板引擎 依赖，MyBatis-Plus 支持 Velocity（默认）、Freemarker、Beetl，用户可以选择自己熟悉的模板引擎，如果都不满足您的要求，可以采用自定义模板引擎。-->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.3</version>
        </dependency>
<!--Hutool工具的依赖-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.6.5</version>
        </dependency>
		<!--swagger-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>

		<!--还需要mysql的依赖-->
		<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.20</version>
        </dependency>

2、编写方法，修改有关参数（写在test包下，这个类没有必要参与打包，属于一个热插拔的类插件）

import org.apache.commons.lang3.StringUtils;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;

public class CodeGenerator {

    /**
     * <p>
     * 读取控制台内容
     * </p>
     */
    public static String scanner(String tip) {
        Scanner scanner = new Scanner(System.in);
        StringBuilder help = new StringBuilder();
        help.append("请输入" + tip + "：");
        System.out.println(help.toString());
        if (scanner.hasNext()) {
            String ipt = scanner.next();
            if (StringUtils.isNotEmpty(ipt)) {
                return ipt;
            }
        }
        throw new MybatisPlusException("请输入正确的" + tip + "！");
    }

    public static void main(String[] args) {
        // 创建代码生成器对象
        AutoGenerator mpg = new AutoGenerator();

        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        gc.setOutputDir(scanner("请输入你的项目路径") + "/src/main/java");
        //作者
        gc.setAuthor("tianyi");
        //生成之后是否打开资源管理器
        gc.setOpen(false);
        //重新生成时是否覆盖文件
        gc.setFileOverride(false);
        //%s 为占位符
        //mp生成service层代码,默认接口名称第一个字母是有I
        gc.setServiceName("%sService");
        //设置主键生成策略  自动增长
        gc.setIdType(IdType.AUTO);
        //设置Date的类型   只使用 java.util.date 代替
        gc.setDateType(DateType.ONLY_DATE);
        //开启实体属性 Swagger2 注解
        gc.setSwagger2(true);
        //是否要生成一个ResultMap
        gc.setBaseResultMap(true);
        //是否生成一个列名<sql></sql>
        gc.setBaseColumnList(true);
        mpg.setGlobalConfig(gc);

        // 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/smbms?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("root");
        //使用mysql数据库
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);

        // 包配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName(scanner("请输入模块名"));
        pc.setParent("com.tianyi");
        pc.setController("controller");
        pc.setService("service");
        pc.setServiceImpl("service.impl");
        pc.setMapper("mapper");
        pc.setEntity("entity");
        pc.setXml("mapper.xml");
        mpg.setPackageInfo(pc);

        // 策略配置
        StrategyConfig strategy = new StrategyConfig();
        //设置哪些表需要自动生成
        strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));

        //实体类名称驼峰命名
        strategy.setNaming(NamingStrategy.underline_to_camel);

        //列名名称驼峰命名
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        //使用简化getter和setter
        strategy.setEntityLombokModel(true);
        //设置controller的api风格  使用RestController
        strategy.setRestControllerStyle(true);
        //驼峰转连字符
        strategy.setControllerMappingHyphenStyle(true);
        //忽略表中生成实体类的前缀
        strategy.setTablePrefix("smbms_");
        mpg.setStrategy(strategy);
        mpg.execute();
    }
}

运行，填写相关数据就可以了。

3、要么在resources下创建包来存放*Mapper.xml，要么配置pom.xml，让程序编译java目录下的xml文件

<!--其他内容省略-->
<build>
    <resources>
      <!--编译src/main/java目录下的xml文件-->
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.xml</include>
        </includes>
        <filtering>true</filtering>
      </resource>
    </resources>
</build>

4、项目主程序入口添加**@MapperScan(“”)**注解，扫描mapper接口

10、mybatis的service

1、创建service包

2、编写service接口，继承IService接口，泛型为操作的实体类

public interface UserService extends IService<User> {
    
}

3、在service下创建impl的服务层接口实现包，编写相应的实现类，

继承ServiceImpl类，泛型参数为相应的mapper接口和操作的实体类，同时再实现service接口

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}

4、controller中测试

@RestController
public class UserController {
    @Autowired
    private UserService userService;

    @RequestMapping("/users")
    List<User> getAll(){
        return userService.list();
    }
}

11、swagger

导入依赖:

		<!--swagger-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>

定义在controller类上：@Api

定义在入参对象属性上：@ApiModelProperty

定义在controller方法上：@ApiOperation

定义在参数上：@ApiParam

例子：

• 实体类

  @ApiModel(value="Filterelement对象", description="滤芯表")
  public class Filterelement implements Serializable {
      @ApiModelProperty(value = "滤芯编号")
      @TableId(value = "id", type = IdType.ASSIGN_ID)
      private String id;
  }
  

• Controller

  @Api(tags ="讲师管理")
  @RestController
  @RequestMapping("/admin/edu/teacher")
  public class TeacherAdminController {
  
      @Autowired
      private TeacherService teacherService;
  
      @ApiOperation(value = "所有讲师列表")
      @GetMapping
      public List<Teacher> list(){
          return teacherService.list(null);
      }
  
      @ApiOperation(value = "根据ID删除讲师")
      @DeleteMapping("{id}")
      public boolean removeById(
              @ApiParam(name = "id", value = "讲师ID", required = true)
              @PathVariable String id){
          return teacherService.removeById(id);
      }
  }
  

• 根据端口适当调整，访问：http://localhost:8801/auth/swagger-ui.html

12、注意

1、实体类字段的注解

• 如果查询的标是关键字，让sql为查询的标字段加上`可以使用**@TableField**注解

   @TableField("`group`")
   private String group;
  

• 在实体类中，对非表字段添加TableField注解即可

  @TableField(exist = false)
  private List<Task> list;
  

2、时区问题

1. 链接字符串url的设置

serverTimezone=UTC

• UTC
• Asia/Shanghai
• GMT%2B8

2. 注解字段的设置

@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss" , timezone = "GMT+8")

• 数据库的设置
  查询数据库的时区

  show variables like '%time_zone%'
  

设置数据库的时区
sql语句设置

set global time_zone = '+8:00';
set time_zone = '+8:00';
flush privileges;

或者MySQL配置文件my.ini中设置
在[mysqld]节点下设置：

[mysqld]
default-time-zone='+08:00'

重启数据库就ok了