Mbatis-Plus整合springboot详细学习笔记

阅读量：4166 次

发布时间：2019-05-26

本文共 12692 字，大约阅读时间需要 42 分钟。

文章目录

Mbatis-Plus 学习笔记

一、基本架构


   
       
    
     com.baomidou
        
    
     mybatis-plus-boot-starter
        
    
     3.3.1.tmp

启动类：

@SpringBootApplication// 扫描 mapper 所在的类@MapperScan(value = "cn.mesmile.mybatisplusdemo.mapper")public class MybatisplusDemoApplication {
       public static void main(String[] args) {
           SpringApplication.run(MybatisplusDemoApplication.class, args);    }}

实体类：

@Data@TableName("user")public class User extends Model
   
     {
       /**     *  IdType.AUTO  数据库id 自增     *  IdType.NONE  该类型为未设置主键类型(注解里等于跟随全局)，若传入id 则以传入的id为准     *  IdType.INPUT 用户输入ID   
    该类型可以通过自己注册自动填充插件进行填充
     */    /* 以下3种类型、只有当插入对象ID 为空，才自动填充。    *     ASSIGN_ID    雪花算法    主键类型为number或string    *     ASSIGN_UUID  UUID        string    *     局部策略 优于  全局策略    *  @TableId   指定主键，若没有 @TableId 指定主键，则默认找到名字叫 id 为主键    * */    @TableId(type= IdType.NONE)    private Long id;		   /**     *  insertStrategy = FieldStrategy.NOT_NULL     *  配置策略，插入数据的时候，不为空，若为空则不会出现该字段     *       *  condition = SqlCondition.LIKE     *  实体查询条件，用于实体作为查询条件     */    @TableField(condition = SqlCondition.LIKE,insertStrategy = FieldStrategy.NOT_NULL)    private String name;    private Integer age;    private String email;    private Date birthday;    /**    * 映射字段指明 数据库中的列名称    */    @TableField(value = "group_name")    private String groupName;    // 静态字段不会持久化到数据库    private static String remark;    public static String getRemark() {
           return remark;    }    public static void setRemark(String remark) {
           User.remark = remark;    }    // 不会持久化到数据    @TableField(exist = false)    private String ingest;}

mapper类：

/** *	继承 BaseMapper
   <实体类>
     *	自动拥有CRUD方法 */public interface UserMapper extends BaseMapper
    
     {
       }

二、查询方法

测试基本的CRUD：

/** *	基本的CRUD测试 */@Slf4j@RunWith(SpringRunner.class)@SpringBootTestpublic class MybatisplusDemoApplicationTests {
       @Autowired    private UserMapper userMapper;    // 简单查询    @Test    public void testSelect() {
            // 直接查询的出结果        List
   
     list = new QueryChainWrapper
    
     (userMapper).list();        // 两种方式构造查询条件 wrapper        QueryWrapper
     
       queryWrapper = new QueryWrapper<>();        QueryWrapper
      
        queryWrapper2 = Wrappers.query();        // 这里传入 wrapper 查询条件， 这里也可以传入 null  ，传入null则认为没有限制查询条件        List
       
         userList = userMapper.selectList(queryWrapper);        }}

2.1、构造条件查询

// 通过自带的构造条件查询// 两种方式构造查询条件 wrapper// QueryWrapper
   
     queryWrapper = new QueryWrapper<>();   QueryWrapper
    
      queryWrapper2 = Wrappers.query();   String testStr = "user";        /*            构造查询条件                 like       LIKE '%值%'                 likeLeft   LIKE '%值'                 likeRight  LIKE '值%'             更多构造查询条件，请看官网 		              https://mybatis.plus/guide/wrapper.html#abstractwrapper             第一个参数是判断，是否加入到sql条件中        */  queryWrapper2      .like(StrUtil.isNotEmpty(testStr), "name", testStr)      .eq(true,"age",18);  List
     
       users = userMapper.selectList(queryWrapper2);  QueryWrapper
      
        userQueryWrapper = new QueryWrapper<>();  /*   *  查询 【生日是 2020-03-20 或 年龄大于 28 岁】 并且 【姓名 里面有 ‘%测试%’】   */  QueryWrapper
       
         birthday = userQueryWrapper      .and(wq -> wq.eq("birthday", DateUtil.parse("2020-03-20", "yyyy-MM-dd"))      .or()      .gt("age",28))      .and(wq -> wq.like("name","测试"));  List
        
          userList = userMapper.selectList(birthday);

2.2、嵌入sql查询

// 嵌入sql查询   QueryWrapper
   
     userQueryWrapper = new QueryWrapper<>();   /*   *  查询生日是 2020-02-01 并且 它的id 等于嵌入sql 查询   */   QueryWrapper
    
      id = userQueryWrapper        // 时间解析,用这种方式两个参数避免了sql注入        .apply("date_format(birthday,'%Y-%m-%d')={0}", "2020-02-01")        // 这种方式一个参数的时候容易出现 sql 注入风险        //.apply("date_format(birthday,'%Y-%m-%d')= '2020-02-01' or true or true")        // sql        .inSql("id", "select id from user where id = 1236680720026488833");   List
     
       users = userMapper.selectList(id);

2.3、分组查询

// 分组查询  QueryWrapper
   
     userQueryWrapper = new QueryWrapper<>();  // 查询平均年龄、最小年龄、最大年龄  // SELECT avg(age) avg_age,min(age) min_age,max(age) max_age  // FROM user GROUP BY group_name HAVING sum(age) > ?  QueryWrapper
    
      group = userQueryWrapper      .select("avg(age) avg_age", "min(age) min_age", "max(age) max_age")      .groupBy("group_name")      .having("sum(age) > {0}", 70);  List
     
      
       > maps = userMapper.selectMaps(group);

2.4、只返回一条数据

/*  *   批量查询   有sql 注入风险  *   .last("limit 1")  只返回一条数据  */   QueryWrapper
   
     userQueryWrapper = new QueryWrapper<>();  QueryWrapper
    
      age = userQueryWrapper       .in("age", Arrays.asList(18, 20, 21,40))       .last("limit 1");  List
     
       users = userMapper.selectList(age);  users.forEach(System.out::println);

2.5、返回指定列数据

/*   * 只查询出映射的字段  id,name   */    QueryWrapper
   
     userQueryWrapper = new QueryWrapper<>();    QueryWrapper
    
      gt = userQueryWrapper         .select("id", "name")         .gt("age", 18);    List
     
       users = userMapper.selectList(gt);   QueryWrapper
      
        userQueryWrapper = new QueryWrapper<>();   // 返回指定列  SELECT id,name,birthday,group_name FROM user   QueryWrapper
       
         id = userQueryWrapper         .select(User.class, info -> !info.getColumn().equals("age") &&         !info.getColumn().equals("email"));  List
        
          users = userMapper.selectList(id);

2.6、在字段上加上查询实体作为条件

User whereUser = new User();    /*     *  实体作为查询条件     *   @TableField(condition = SqlCondition.LIKE)     *   private String name;     *	 这里就相当于在在对名字进行模糊查询     */     whereUser.setName("测试");     // 若不在 字段上设置值，默认则为 eq     whereUser.setAge(28);     // 将实体作为默认查询条件     QueryWrapper
   
     userQueryWrapper = new QueryWrapper<>(whereUser);     List
    
      users = userMapper.selectList(userQueryWrapper);

2.7、lambda方式构造查询条件

// lambda的方式   这种方法，防止了 误写,三中方式生成 lambdaWrapper//  LambdaQueryWrapper
   
     lambda = new QueryWrapper
    
     ().lambda();//  LambdaQueryWrapper
     
       objectLambdaQueryWrapper = Wrappers.
      
       lambdaQuery();      LambdaQueryWrapper
       
         userLambdaQueryWrapper = new LambdaQueryWrapper<>();        // 查询 姓名中有 测试 的，年龄 小于 30 的        userLambdaQueryWrapper.like(User::getName, "测试")                .lt(User::getAge, 30)                .eq(User::getGroupName,"C");        List
        
          users = userMapper.selectList(userLambdaQueryWrapper); // 这里需要传入 userMapper 对象 List
         
           users = new LambdaQueryChainWrapper
          
           (userMapper) .likeLeft(User::getName, "测试") .le(User::getAge, 30) .list(); users.forEach(System.out::println);

2.8、分页条件查询

写分页配置类：

@Slf4j@Configurationpublic class MybatisPlusConfig {
    	/**     *  mybatis-plus 的配置  分页配置     * @return     */    @Bean    public PaginationInterceptor paginationInterceptor() {
           // 分页插件        return new PaginationInterceptor();    }    }

进行分页查询：

LambdaQueryWrapper
   
     userLambdaQueryWrapper = new LambdaQueryWrapper<>();        userLambdaQueryWrapper.gt(User::getAge,18)                .like(User::getName,"测试");        // 第 3 个参数 ， false 为 不查询总条数 ，默认为 true 为要查询总条数        // 第 3 个参数 ， 不填写默认为 true        Page
    
      userPage = new Page<>(1, 3,true);        Page
     
       result = userMapper.selectPage(userPage, userLambdaQueryWrapper);        long current = result.getCurrent();        List
      
        records = result.getRecords();        long size = result.getSize();        long total = result.getTotal();        long pages = result.getPages();        log.info("当前页 {} ， 每页显示条数 {} ， 总共条数 {} , 总共页数 {}", current                , size , total , pages            );

2.9、自定义查询方法

public interface UserMapper extends BaseMapper
   
     {
       /**     *  自定义查询方法     * @param wrapper     * @return     */    // @Select("select * from user ${ew.customSqlSegment}")    List
    
      selectAll(@Param(Constants.WRAPPER)Wrapper
     
       wrapper);    /**     *  自定义分页查询方法     * @param page     * @param wrapper     * @return     */    Page
      
        selectUserPage(Page
       
         page, @Param(Constants.WRAPPER)Wrapper
        
          wrapper);}

如果要用xml,需要在配置文件中，指定xml地址

# 配置 xml 文件所在位置mybatis-plus:  mapper-locations: classpath*:/mapper/**/*.xml

例xml文件：

三、更新方法

3.1、基础更新

// 修改方式一下        User user = new User();        user.setId(1L);        user.setName("test");        user.setAge(20);        // 传入实体的id 需有值        int i = userMapper.updateById(user);

3.2、传入实体并更新

UpdateWrapper
   
     updateWrapper = Wrappers.update();        // 构造条件        updateWrapper.eq("id", 1L);        // 修改参数        User user = new User();        user.setName("test2");        user.setEmail("test@qq.com");        // 第一参数是实体，第二个参数是条件        int update1 = userMapper.update(user, updateWrapper);

3.3、快速修改

// 简便修改方式        boolean update = new UpdateChainWrapper
   
    (userMapper)                .eq("id", 1L)                .set("name", "user")                .update();

3.4、lambda的方式修改

// lambda 构造条件的方式        LambdaUpdateWrapper
   
     lambdaUpdateWrapper = Wrappers.lambdaUpdate();        LambdaUpdateWrapper
    
      world = lambdaUpdateWrapper.eq(User::getId, 1L)                .set(User::getName, "world");        int update = userMapper.update(null, world);        // lambda 直接修改        boolean hello_world = new LambdaUpdateChainWrapper
     
      (userMapper)                .eq(User::getId, 1L)                .set(User::getName, "hello world")                .update();

四、删除方法

4.1、基础删除

// 删除一条数据  int i = userMapper.deleteById(12L);  // 批量删除  int i = userMapper.deleteBatchIds(Arrays.asList(23, 1237223696960188417L, 89));

4.2、根据查询条件来删除

HashMap
   
     map = new HashMap<>(2); map.put("id" , 1237224478493155329L); map.put("name", "测试一波4"); // 多条件之间是 and 的关联，并且每个条件之间值 eq 关系 int i = userMapper.deleteByMap(map);

4.3、lambda的方式删除

LambdaQueryWrapper
   
     lambdaQueryWrapper = Wrappers.lambdaQuery();   lambdaQueryWrapper.eq(User::getId, 1237226278776565762L)       .or()       .eq(User::getName, "测试一波5");   int delete = userMapper.delete(lambdaQueryWrapper);   LambdaQueryWrapper
    
      lambdaQueryWrapper = Wrappers.lambdaQuery();   lambdaQueryWrapper.and(info -> info.eq(User::getId, 1237227238806626306L)        .eq(User::getName, "测试一波5"))        .or()        .eq(User::getEmail, "test22@qq.com");   int delete = userMapper.delete(lambdaQueryWrapper);

五、添加方法

5.1、基本添加方法

User user = new User(); user.setAge(23); user.setEmail("test@qq.com"); int insert = userMapper.insert(user); userService.save(user);

5.2、批量添加方法

userService.saveBatch(Arrays.asList(new User()));

六、其他模式

6.1、AR模式

AR 模式  ① 实体类继承 Model   ② 继承 BaseMapper

@TableName("user")public class User extends Model
   
     {
       }

AR模式的基本使用：

User user = new User();        user.setAge(23);        user.setEmail("test@qq.com");        user.setName("测试一波5");        user.setIngest("sdfasdf");        user.setBirthday(new Date());        user.setGroupName("C");        User.setRemark("dsfajsklfja");		// 实体类直接调用方法        boolean insert = user.insert();        // 单例模式        User user1 = user.selectById(1237245719815929858L);		// 插入或者保存		boolean insertOrUpdate = user.insertOrUpdate();

6.2、主键策略

/**     *  IdType.AUTO  数据库ID自增     *  IdType.NONE  该类型为未设置主键类型(注解里等于跟随全局,全局里约等于 INPUT)     *  IdType.INPUT 用户输入ID   该类型可以通过自己注册自动填充插件进行填充
     */    /** 以下2种类型、只有当插入对象ID 为空，才自动填充。    *     ASSIGN_ID    雪花算法    主键类型为number或string    *     ASSIGN_UUID  UUID        string    *     局部策略 优于  全局策略    *  @TableId   指定主键，若没有 @TableId 指定主键，则默认找到名字叫 id 为主键    * */        @TableId(type= IdType.NONE)    private Long id;

在springboot中的配置:

# 配置全局的 主键策略，默认为 ASSIGN_ID 默认为 【雪花算法】mybatis-plus:  global-config:    db-config:      id-type: assign_id  # 开启驼峰命名 默认开启驼峰命名  configuration:    map-underscore-to-camel-case: true

配置全局的表名前缀：

# 配置全局的表名前缀mybatis-plus: global-config:  db-config:   table-prefix: xx_

6.3、通用service层

service层：

public interface UserService extends IService
   
     {
   }

service实现层：

@Transactional(rollbackFor = Exception.class, propagation = Propagation.SUPPORTS, readOnly = true)@Servicepublic class UserServiceImpl extends ServiceImpl
   
     implements UserService {
   }

通用service的通用层基本方法：

// lambda 方式查询 List
   
     list = userService.lambdaQuery().gt(User::getAge, 25).list(); // lambda方式修改 boolean update = userService.lambdaUpdate().eq(User::getAge, 23).set(User::getAge, 25).update();