mybatisPlus的使用

1.导入Maven依赖

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

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

2.application.properties配置

#环境设置：dev、test、prod
spring.profiles.active=dev

#mysql数据库连接
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatisplus?useSSL=false
spring.datasource.username=root
spring.datasource.password=root

#mybatis日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
# 指定删除和不删除的状态
mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

3.entity

@Data
public class User {

    private Long id;

    private String name;

    private Integer age;

    private String email;

    @TableField(fill = FieldFill.INSERT)
    @TableLogic // 逻辑删除，和属性文件中配置的删除和不删除的状态绑定
    private Boolean isDelete; // 在代码程序中我们使用false/true； 在数据库中不认识；他们会自动帮我们转成0/1

    @TableField(fill = FieldFill.INSERT)
    @Version // 是标示版本关键字 被乐观锁加载
    private Integer version;

    @TableField(fill = FieldFill.INSERT) // 当你做插入的时候，被拦截
    private Date createTime;
    @TableField(fill = FieldFill.INSERT_UPDATE) // / 当你做插入和修改的时候，被拦截
    private Date updateTime;

}

4.config

@EnableTransactionManagement
@Configuration
public class MPConfig {

    //配置一个乐观锁
    /**
     * 乐观锁插件
     */
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }

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

    /**
     * 逻辑删除的插件
     */
    @Bean
    public ISqlInjector sqlInjector() {
        return new LogicSqlInjector();
    }

    /**
     * SQL 执行性能分析插件
     * 开发环境使用，线上不推荐。 maxTime 指的是 sql 最大执行时长
     */
    @Bean
    @Profile({"dev","test"})// 设置 dev test 环境开启
    public PerformanceInterceptor performanceInterceptor() {
        PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
        performanceInterceptor.setMaxTime(100);//ms，超过此处设置的ms则sql不执行
        performanceInterceptor.setFormat(true);
        return performanceInterceptor;
    }
}

5.handler

@Component
public class DateMetaObjectHandler implements MetaObjectHandler {

    /**
     * 当做insert的时候被拦截
     * @param metaObject
     */
    @Override
    public void insertFill(MetaObject metaObject) {

        this.setFieldValByName("createTime", new Date(), metaObject);
        this.setFieldValByName("updateTime", new Date(), metaObject);

    }

    /**
     * 做update的时候被拦截
     * @param metaObject
     */
    @Override
    public void updateFill(MetaObject metaObject) {
        this.setFieldValByName("updateTime", new Date(), metaObject);
    }
}

6.测试类

@RunWith(SpringRunner.class)
@SpringBootTest
public class MybatisplusApplicationTests {

   @Autowired
   private UserMapper userMapper;

   @Test
   public void selectList() {

      List<User> userList = userMapper.selectList(null);
      userList.forEach(System.err::println);

   }

   @Test
   public void insertUser(){
      User user = new User();
      //user.setId();
      user.setName("小66");
      user.setAge(50);
      user.setEmail("xiaobai@xyyyy.com");
      userMapper.insert(user);
   }

   /**
    * 修改用户信息
    */
   @Test
   public void updateUserById(){
      User user = new User();
      user.setId(1L);
      user.setName("无情");
      userMapper.updateById(user);
   }

   /**
    * 在修改数据的时候有两个问题：
    * 1、记录修改的日志，时间；
    *      一般在企业中会有一个单独的日志系统：
    *      记录：谁，点击什么请求（操作），做了什么事？， 什么时间， 状态！
    *      我们需要有一个记录修改的时间！
    * 2、在修改的时候：
    *     应用场景：
    *     当A用户根据ID获取了数据打算修改，此时B用户也获取了数据打算修改；
    *     此时：A用户修改成了，B用户是否修改成功！
    *     锁：
    *     行锁，列所；
    *     悲观锁：认为任何操作都是非法的，所以每一个操作都给你加了锁； 优点：安全； 缺点：效率低；
    *     乐观锁：认为任何操作都是正常的，所以每一个操作都不会加锁！   优点：效率高；缺点：不安全；
    *     为了提高效率，在企业这种使用：乐观锁；
    *     version : 版本！
    *     当每一个用户过来操作的时候，都根据这个版本操作，如果这个版本不是你操作之前的版本号了，那么就修改失败了！
    *     A用户过来读取了version = 1; B 过来读取了Version = 1 ；
    *     此时A用户修改了数据库 update set name = ? , version = version + 1 from user where id = ? and veriosn = 1
    *      被A修改后 version = 2 ;
    *     此时B用户修改了数据库： update set name = ? , version = version + 1 from user where id = ? and veriosn = 1
    *      那么B来修改就不会成功！
    */
   /**
    * 解决第一个问题：
    * 在修改的时候，自动补全修改时间，在创建的时候，自动补全创建时间
    */
   @Test
   public void updateUserDateById(){
//
//        User user = userMapper.selectById(2L);
//        user.setName("zhuzhuqing");
//    userMapper.updateById(user);

      User user3 = userMapper.selectById(3L);

      User user4 = userMapper.selectById(3L);

      user4.setName("niefeng");
      userMapper.updateById(user4);

      user3.setName("bujingyun");
      userMapper.updateById(user3);

   }

   /**
    * 查询用户
    */
   @Test
   public void selectUserBtIds(){

      //1、根据ID查询
      User user = userMapper.selectById(1L);
      System.err.println(user.getId() + "===" +  user.getAge());
      //2、多个ID查询

        List<User> userList = userMapper.selectBatchIds(Arrays.asList(1,2,3));
        userList.forEach(System.err::println);
      //3、根据Map条件查询
      Map<String,Object> map = new HashMap<>();
      map.put("name", "小三");
      map.put("age",18);
      //map中存放的是数据库字段的名称；

      List<User> list1 = userMapper.selectByMap(map);
      list1.forEach(System.err::println);

   }

   /**
    * 分页查询
    */
   @Test
   public void selectUserByPage(){

      // 1、当前页码；2、每页显示记录数
      Page<User> page = new Page<>(2,3);

//    userMapper.selectPage(page, null);
//        List<User> userList = page.getRecords(); // 记录数集合
//        userList.forEach(System.err::println);

      IPage<Map<String, Object>> mapIPage = userMapper.selectMapsPage(page, null);

      //注意：此行必须使用 mapIPage 获取记录列表，否则会有数据类型转换错误
      mapIPage.getRecords().forEach(System.out::println);

      System.err.println("总页数：" + page.getPages());
      System.err.println("总记录数：" + page.getTotal());
      System.err.println("当前页码：" + page.getCurrent());
      System.err.println("是否有下一页：" + page.hasNext());
      System.err.println("是否有上一页：" + page.hasPrevious());

   }

   /**
    * 删除用户
    */
   @Test
   public void deleteUserById(){
      //根据多个ID删除
        /*mapper.deleteBatchIds(Arrays.asList(1,2,3));
        mapper.deleteById(1L);
        Map<String,Object> map = new HashMap<>();
        mapper.deleteByMap(map);

        在企业中删除不是从数据库直接删除：物理删除；
        逻辑删除！在企业中使用；
        update操作！

        */

      userMapper.deleteById(2L);

   }

   /**
    * 条件查询
    * Wrapper
    */
   @Test
   public void wrapprtTest(){
      QueryWrapper<User> wrapper = new QueryWrapper<>();
      //查询的时候就根据is_delete = 0 未删除的查询
      //wrapper.eq("is_delete",1);
      //wrapper.like("name","白");
      wrapper.ge("age",20);
      List<User> userList = userMapper.selectList(wrapper);
      userList.forEach(System.err::println);
   }

}