# mybatis-plus

**Repository Path**: zoranwang/mybatis-plus

## Basic Information

- **Project Name**: mybatis-plus
- **Description**: No description available
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2021-09-24
- **Last Updated**: 2022-03-01

## Categories & Tags

**Categories**: Uncategorized

**Tags**: mybatis-plus

## README

# mybatis-plus基础代码知识点归纳

## 一、mp简介

### 1.1 依赖

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


### 1.2 配置

启动类（或者配置类）包扫描

```Java
//SpringBoot项目，扫描接口所在包，或者使用@Mapper
@MapperScan("zoran.wang.mybatisplus.mapper")

```


dao层接口

```Java
//dao接口需要继承BaseMapper<Bean>
@Repository
public interface UserMapper extends BaseMapper<User> {
    
}
```


查看sql输出日志

```.properties
#mybatis日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
```


常规操作

```Java
//插入一条记录
int result = userMapper.insert(user);
//根据过滤条件queryWrapper查询
List<User> users = userMapper.selectList(queryWrapper);

```


## 二、mp的主键策略

MyBatis-Plus默认的主键策略是：ASSIGN_ID （使用了雪花算法）

优点：整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞，并且效率较高

```Java
@TableId(type = IdType.ASSIGN_ID)
private String id;
```


AUTO自增策略

```Java
@TableId(type = IdType.AUTO)
private Long id;
```


在application.properties进行全局主键配置

```Java
#全局设置主键生成策略
mybatis-plus.global-config.db-config.id-type=auto
```


注意：优先遵循`@TableId`的主键策略，其次遵循全局主键策略

## 三、自动填充

项目中经常会遇到一些数据，每次都使用相同的方式填充，例如记录的创建时间，更新时间等。我们可以使用MyBatis Plus的自动填充功能，完成这些字段的赋值工作。

### 3.1 数据库字段

在User表中添加datetime类型的新的字段 创建时间 gmt_create、修改时间 gmt_modified

### 3.2 实体类上增加字段并添加自动填充注解

```Java
@Data
public class User {
    ......
        
    @TableField(fill = FieldFill.INSERT)
    private Date gmtCreate;

    //@TableField(fill = FieldFill.UPDATE)
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date gmtModified;
}
```


### 3.3 实现元对象处理器接口

```Java
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    /**
     * 在插入的时候自动填充日期到这两个字段
     * @param metaObject
     */
    @Override
    public void insertFill(MetaObject metaObject) {
        metaObject.setValue("gmtCreate",new Date());
        metaObject.setValue("gmtModified",new Date());
    }

    /**
     * 在更新表的时候自动填充日期到 gmtModified 字段
     * @param metaObject
     */
    @Override
    public void updateFill(MetaObject metaObject) {
        metaObject.setValue("gmtModified",new Date());
    }
}

```


## 四、乐观锁

### 4.1 数据库表和实体类

加`version`字段和`@Version`注解

```Java
@Version
private Integer version;
```


### 4.2 配置文件中注册乐观锁插件

```Java
//可以将包扫描放到配置中
@Configuration
public class MybatisPlusConfig {

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

}
```


## 五、查询

> 常见的查询：根据id查询、根据id集合查询、条件查询、分页查询、带条件的分页查询


### 5.1 通过多个id批量查询

完成了动态sql的foreach功能

```Java
    @Test
    public void testSelectBatchIds(){
        List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
        users.forEach(System.out::println);
    }
```


### 5.1 通过多个id批量查询

```Java
    @Test
    public void testSelectByMap(){
        //注意指定范型的key为String
        HashMap<String, Object> map = new HashMap<>();
        map.put("name","Tom");
        map.put("age",28);
        List<User> users = userMapper.selectByMap(map);
        users.forEach(System.out::println);
    }

```


### 5.2 通过QueryWrapper查询

```Java
    /**
     * 查询——通过QueryWrapper查询
     */
    @Test
    public void testSelectByQueryWrapper(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("name","Jack").or().eq("name","Jone");
        wrapper.eq("age",20);
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

    /**
     * 查询——通过LambdaQueryWrapper查询
     */
    @Test
    public void testSelectByLambdaQueryWrapper(){
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(User::getName,"Jack")
                .or()
                .eq(User::getName,"Jack");
        wrapper.eq(User::getAge,20);
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }
```


## 六、分页插件

MyBatis Plus自带分页插件，只要简单的配置即可实现分页功能

### 6.1 添加分页插件

配置类中注入一个`PaginationInterceptor`实例对象到IOC容器中

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


### 6.2 简单分页查询

```Java
   /**
     * 测试selectPage分页
     * 最终通过page对象获取相关数据
     */
    @Test
    public void testSelectPage() {

        //分页对象：指定查询的页码和每页显示的记录条数
        int pageNum = 1;
        int pageSize = 3;
        Page<User> page = new Page<>(pageNum,pageSize);

        //分页查询的条件对象
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.gt("age",18);//年龄大于18

        //执行查询
        userMapper.selectPage(page , queryWrapper);

        //查询到的分页数据集合
        page.getRecords().forEach(System.out::println);

        //查询到的其他分页信息
        System.out.println(page.getCurrent());
        System.out.println(page.getPages());
        System.out.println(page.getSize());
        System.out.println(page.getTotal());
        System.out.println(page.hasNext());
        System.out.println(page.hasPrevious());
    }
```


### 6.3 部分字段对分页查询

```Java
    @Test
    public void testSelectMapsPageOfMine(){
        //区别在于：Page对范型指定对是Map<String,Object>，如果指定的是User，则返回结果集非选择字段为null
        Page<Map<String, Object>> page = new Page<>(1, 3);
        LambdaQueryWrapper<User> userLambdaQueryWrapper = new LambdaQueryWrapper<>();
        //带条件带分页查询
        userLambdaQueryWrapper.ge(User::getId,2).or().like(User::getName,"a");
        userLambdaQueryWrapper.select(User::getName,User::getAge);
        Page<Map<String, Object>> mapPage = userMapper.selectMapsPage(page, userLambdaQueryWrapper);
        List<Map<String, Object>> records = mapPage.getRecords();
        records.forEach(System.out::println);
    }
```


## 七、删除和逻辑删除

### 7.1 根据id删除

```Java
@Test
public void testDeleteById(){

    int result = userMapper.deleteById(5L);
    System.out.println(result);
}
```


### 7.2 批量删除

```Java
@Test
public void testDeleteBatchIds() {

    int result = userMapper.deleteBatchIds(Arrays.asList(8, 9, 10));
    System.out.println(result);
}
```


### 7.3 简单条件删除

```Java
@Test
public void testDeleteByMap() {

    HashMap<String, Object> map = new HashMap<>();
    map.put("name", "Helen");
    map.put("age", 18);

    int result = userMapper.deleteByMap(map);
    System.out.println(result);
}
```


### 7.4 逻辑删除

物理删除和逻辑删除：

- 物理删除：真实删除，将对应数据从数据库中删除，之后查询不到此条被删除的数据

- 辑删除：假删除，将对应数据中代表是否被删除字段的状态修改为“被删除状态”，之后在数据库中仍旧能看到此条数据记录

逻辑删除的使用场景：

1. 需要进行数据恢复时

2. 有关联数据，不便删除时

逻辑删除的实现流程：

1. 数据库添加`deleted`字段

```SQL
ALTER TABLE `user` ADD COLUMN `deleted` boolean DEFAULT false
```


2. 实体类添加`deleted`属性，并加上注解@TableLogic

```SQL
@TableLogic
private Integer deleted;
```


3. application.properties加入配置（以下是默认配置，不配置就是默认配置）

```SQL
mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0
```


## 八、条件构造器和常用接口

### 8.1 常用接口方法

[CRUD接口｜mybatis-plus](https://mp.baomidou.com/guide/crud-interface.html#saveorupdate)

### 8.2 常用条件构造器Wrapper方法

常用：

1. eq：equal 等于

2. ne：not equal 不等于

3. ge：greater than or equal 大于等于

4. le：less than or equal 小于等于

5. gt：greater than 大于

6. lt：less than 小于

其他：

1. between：[ a , b ] 包含边界

2. notBetween：( -∞ , a ) U ( b , +∞ ) 不包含边界