Mybatis-plus该这么用？

刺骨的言语ヽ痛彻心扉 2023-01-03 12:44 75阅读 0赞

MP 全称 Mybatis-Plus ，套用官方的解释便是成为 MyBatis 最好的搭档。它是在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。  
[官网入口][Link 1]

#### 1、基础启动案例 ####

1.  **导包**

<dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
            
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>3.1.2</version>
            </dependency>
            
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.10</version>
            </dependency>

1.  **配置文件**

spring:
      datasource:
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/order_food?serverTimezone = GMT
        username: root
        password: root

1.  **实体类**

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Builder
    @TableName("admin")
    public class Admin implements Serializable { 
        private static final long serialVersionUID = 703898688430542984L;
        
        @TableId(type = IdType.AUTO)
        private Integer aid;
        
        private String account;
        
        private String apassword;

@Data，@AllArgsConstructor，@NoArgsConstructor，@Builder都是属于lombok的注解。

**@builder：**[@builder注解][builder]

@Builder声明实体，表示可以进行Builder方式初始化

Admin p1 = Admin.builder().account("哈哈").build();

如果需要修改的话，需要实体类上添加 @Builder(toBuilder=true)

Admin p2 = p1.toBuilder().account("嘻嘻").build();

1.  **mapper**

使用@mapper或者配置类上使用@mapperscan

@Mapper
    public interface AdminMapper extends BaseMapper<Admin> { }

1.  **测试类**

@SpringBootTest
    class DeliveryApplicationTests { 
    
        @Autowired
        AdminMapper adminMapper;
    
        @Test
        void contextLoads() { 
            adminMapper.insert(new Admin(0,"2","2"));
            adminMapper.selectList(null).forEach((t)-> System.out.println(t));
        }
    
    }

#### 2、CURD ####

#### 1.insert ####

// 插入一条记录，entity表示为实体对象
    int insert(T entity);
    
    @Test
    void insert(){ 
       int count = adminMapper.insert(
           Admin.builder().account("嘻").apassword("123").build());
    }

#### 2.update ####

// 根据 whereEntity 条件，更新记录
    int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
    // 根据 ID 修改
    int updateById(@Param(Constants.ENTITY) T entity);

**案例：**

@Test
    void update(){ 
      // 根据id更新
      adminMapper.updateById(new Admin(1,"张三","123"));
        
      // 条件构造器更新
      UpdateWrapper<Admin> adminUpdateWrapper = new UpdateWrapper<Admin>();
      adminUpdateWrapper.set("account","马六").eq("aid",2);
      adminMapper.update(null,adminUpdateWrapper);
        
      // 也可以这样
      UpdateWrapper<Admin> adminUpdateWrapper = new UpdateWrapper<Admin>();
      adminUpdateWrappereq("aid",2);
      adminMapper.update(new Admin(1,"呼气","433"),adminUpdateWrapper);    
    }

#### 3.select ####

// 根据 ID 查询
    T selectById(Serializable id);
    
    // 根据 entity 条件，查询一条记录
    T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    
    // 查询（根据ID 批量查询）
    List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
    
    // 根据 entity 条件，查询全部记录
    List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    
    // 查询（根据 columnMap 条件）
    List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
    
    // 根据 Wrapper 条件，查询全部记录
    List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    
    // 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
    List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    
    // 根据 entity 条件，查询全部记录（并翻页）
    IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    // 根据 Wrapper 条件，查询全部记录（并翻页）
    
    IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    
    // 根据 Wrapper 条件，查询总记录数
    Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

**案例：**

@Test
        void select(){ 
            // 1.查询一条
            Admin admin = adminMapper.selectById(1);
    
            // 2.根据 entity 条件，查询一条记录
            QueryWrapper<Admin> adminQueryWrapper = new QueryWrapper<>();
            adminQueryWrapper.eq("account","呼气");
            Admin admin1 = adminMapper.selectOne(adminQueryWrapper);
    
            // 3.查询（根据ID 批量查询）
            List<Admin> admins = adminMapper.selectBatchIds(Arrays.asList(1, 2, 5, 6));
            // admins.forEach((t)->{ System.out.println(t); });
    
            // 4.根据 entity 条件，查询全部记录
            QueryWrapper<Admin> adminQueryWrapper1 = new QueryWrapper<>();
            adminQueryWrapper1.between("aid",2,6);
            List<Admin> admins1 = adminMapper.selectList(adminQueryWrapper1);
            // admins1.forEach((t)-> System.out.println(t));
    
            // 5.查询（根据 columnMap 条件）
            HashMap<String, Object> map = new HashMap<>();
            map.put("account","梵蒂冈");
            List<Admin> admins2 = adminMapper.selectByMap(map);
            // admins2.forEach((t)->{ 
            // System.out.println(t);
            // });
    
            // 6.根据 Wrapper 条件，查询全部记录
            QueryWrapper<Admin> adminQueryWrapper3 = new QueryWrapper<>();
            List<Map<String, Object>> maps = adminMapper.selectMaps(adminQueryWrapper3);
            // for (Map<String, Object> map1 : maps) { 
            // map1.forEach((key,value)->{ 
            // System.out.println(key+":"+value);
            // });
            // }
            
            // 7.根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
            List<Object> objects = adminMapper.selectObjs(new QueryWrapper<>());
            // objects.forEach((t)->{ 
            // System.out.println(t);
            // });
            
            // 8.根据 entity 条件，查询全部记录（并翻页）,需要先配置分页插件
            Page<Admin> adminPage = new Page<>(1,1);
            IPage<Admin> adminIPage = adminMapper.selectPage(adminPage, new QueryWrapper<Admin>());
            // System.out.println(adminPage.getRecords());
            // System.out.println("每页大小："+adminPage.getSize());
            // System.out.println("总页数："+adminPage.getPages());
            // System.out.println("当前页面："+adminPage.getCurrent());
            
            // 9.根据 Wrapper 条件，查询全部记录（并翻页）
            IPage<Map<String, Object>> mapIPage = adminMapper.selectMapsPage(adminPage, null);
            for (Map<String, Object> record : mapIPage.getRecords()) { 
                record.forEach((key,value)->{ 
                    System.out.println(key+":"+value);
                });
            }
            
            // 10.根据 Wrapper 条件，查询总记录数
            QueryWrapper<Admin> adminQueryWrapper2 = new QueryWrapper<>();
            Integer integer = adminMapper.selectCount(adminQueryWrapper2);
            // System.out.println(integer);
        }

#### 4.delete ####

// 根据 entity 条件，删除记录
    int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
    // 删除（根据ID 批量删除）
    int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
    // 根据 ID 删除
    int deleteById(Serializable id);
    // 根据 columnMap 条件，删除记录
    int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

**案例：**

@Test
        void delete(){ 
            // 1.根据 entity 条件，删除记录
            UpdateWrapper<Admin> adminUpdateWrapper = new UpdateWrapper<>();
            // 这里进行条件构造
            adminMapper.delete(adminUpdateWrapper);
    
            // 2. 删除（根据ID 批量删除
            adminMapper.deleteBatchIds(Arrays.asList(1,2,3,4));
    
            // 3.根据 ID 删除
            adminMapper.deleteById("1");
    
            // 4.根据 columnMap 条件，删除记录
            HashMap map = new HashMap<String,Object>();
            map.put("account","张三");
            adminMapper.deleteByMap(map);
        }

#### 3、 条件构造器 ####

说明：`boolean condition`表示该条件**是否**加入最后生成的sql中 ，默认值为true。

1.  **allEq**

allEq(Map<R, V> params)
    allEq(Map<R, V> params, boolean null2IsNull)
    allEq(boolean condition, Map<R, V> params, boolean null2IsNull)

`params` : `key`为数据库字段名,`value`为字段值  
`null2IsNull` : 为`true`则在`map`的`value`为`null`时调用 isNull\]方法,为`false`时则忽略

1.  **eq**

eq(R column, Object val)
    eq(boolean condition, R column, Object val)

我们来演示下：

@Test
        void eqTest(){ 
            QueryWrapper<Admin> wrapper = new QueryWrapper<>();
            HashMap<String, Object> map = new HashMap<>();
            map.put("account","张三");
            wrapper.allEq(map,false);
    
            List<Admin> admins = adminMapper.selectList(wrapper);
            admins.forEach((t)->{ 
                System.out.println(t);
            });
    
            QueryWrapper<Admin> wrapper1 = new QueryWrapper<>();
            wrapper1.eq("account","梵蒂冈");
            Admin admin = adminMapper.selectOne(wrapper1);
            System.out.println(admin);
        }

下面还有一大把这样的：

1.  ne：不等于
2.  gt：大于
3.  ge：大于等于
4.  lt：小于
5.  le：小于等于
6.  between：在两者之间
7.  notbetween：不在两者之间
8.  like：like ‘%值%’
9.  not like：not like ‘%值%’
10. likeleft：like ‘%值’
11. likeright：like ‘值%’
12. isNull：不为空
13. in：在集合中
14. notIn：不在集合中
15. inSql：在sql语句查询的结果中→ `inSql("id", "select id from table where id < 3")`—>`id in (select id from table where id < 3)`
16. notInSql：不在sql语句查询的结果中
17. group by：分组
18. orderByAsc：升序排序
19. orderByDesc：降序排序
20. orderBy：排序
21. having：分组后数据筛选
22. or：拼接 →`eq("id",1).or().eq("name","老王")`—>`id = 1 or name = '老王'`
23. and：嵌套
24. select：过滤查询字段→ select(“id”, “name”, “age”)

#### 4、注解 ####

主要的注解有如下三个：

**@TableName：** 表名注解

先来看下注解，有5个属性：value，schema，keepGlobalPrefix，resultMap，autoResultMap

public @interface TableName { 
        String value() default "";
    
        String schema() default "";
    
        boolean keepGlobalPrefix() default false;
    
        String resultMap() default "";
    
        boolean autoResultMap() default false;
    }

<table> 
 <thead> 
  <tr> 
   <th align="center">属性</th> 
   <th align="center">类型</th> 
   <th align="center">默认值</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">value</td> 
   <td align="center">String</td> 
   <td align="center">“”</td> 
   <td>指定表名，与数据库中表对应</td> 
  </tr> 
  <tr> 
   <td align="center">schema</td> 
   <td align="center">String</td> 
   <td align="center">“”</td> 
   <td>配置此值将覆盖全局配置的 schema</td> 
  </tr> 
  <tr> 
   <td align="center">keepGlobalPrefix</td> 
   <td align="center">boolean</td> 
   <td align="center">false</td> 
   <td>是否保持使用全局的 tablePrefix 的值</td> 
  </tr> 
  <tr> 
   <td align="center">resultMap</td> 
   <td align="center">String</td> 
   <td align="center">“”</td> 
   <td>xml 中 resultMap 的 id，实体映射结果集</td> 
  </tr> 
  <tr> 
   <td align="center">autoResultMap</td> 
   <td align="center">boolean</td> 
   <td align="center">false</td> 
   <td>是否自动构建 resultMap 并使用</td> 
  </tr> 
  <tr> 
   <td align="center">excludeProperty</td> 
   <td align="center">String[]</td> 
   <td align="center">{}</td> 
   <td>需要排除的属性名</td> 
  </tr> 
 </tbody> 
</table>

keepGlobalPrefix搭配下面配置使用，目的就是统一给表加前缀

<bean id="globalConfig" class="com.baomidou.mybatisplus.core.config.GlobalConfig">
            
            <property name="dbConfig">
                <bean id="dbConfig" class="com.baomidou.mybatisplus.core.config.GlobalConfig$DbConfig">
                    
                    <property name="tablePrefix" value="t_"></property>
                </bean>
            </property>
        </bean>

**@TableId：** 主键注解

type的值有：

<table> 
 <thead> 
  <tr> 
   <th align="center">值</th> 
   <th align="center">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">AUTO</td> 
   <td align="center">数据库ID自增</td> 
  </tr> 
  <tr> 
   <td align="center">NONE</td> 
   <td align="center">无状态,该类型为未设置主键类型(注解里等于跟随全局,全局里约等于 INPUT)</td> 
  </tr> 
  <tr> 
   <td align="center">INPUT</td> 
   <td align="center">insert前自行set主键值</td> 
  </tr> 
  <tr> 
   <td align="center">ASSIGN_ID</td> 
   <td align="center">分配ID(主键类型为Number(Long和Integer)或String),使用接口<code>IdentifierGenerator</code>的方法<code>nextId</code>(默认实现类为<code>DefaultIdentifierGenerator</code>雪花算法)</td> 
  </tr> 
  <tr> 
   <td align="center">ASSIGN_UUID</td> 
   <td align="center">分配UUID,主键类型为String,使用接口<code>IdentifierGenerator</code>的方法<code>nextUUID</code>(默认default方法)</td> 
  </tr> 
 </tbody> 
</table>

**@TableField：** 普通字段注解

<table> 
 <thead> 
  <tr> 
   <th align="center">属性</th> 
   <th align="center">类型</th> 
   <th align="center">默认值</th> 
   <th align="center">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">value</td> 
   <td align="center">String</td> 
   <td align="center">“”</td> 
   <td align="center">数据库字段名</td> 
  </tr> 
  <tr> 
   <td align="center">exist</td> 
   <td align="center">boolean</td> 
   <td align="center">true</td> 
   <td align="center">数据库表中是否存在该字段</td> 
  </tr> 
  <tr> 
   <td align="center">condition</td> 
   <td align="center">String</td> 
   <td align="center">“”</td> 
   <td align="center">字段 <code>where</code> 实体查询比较条件,有值设置则按设置的值为准,没有则为默认全局的 <code>%s=#{%s}</code></td> 
  </tr> 
  <tr> 
   <td align="center">update</td> 
   <td align="center">String</td> 
   <td align="center">“”</td> 
   <td align="center">字段 <code>update set</code> 部分注入, 例如：update="%s+1"：表示更新时会set version=version+1</td> 
  </tr> 
  <tr> 
   <td align="center">fill</td> 
   <td align="center">Enum</td> 
   <td align="center">FieldFill.DEFAULT</td> 
   <td align="center">字段自动填充策略</td> 
  </tr> 
  <tr> 
   <td align="center">typeHandler</td> 
   <td align="center">Class&lt;? extends TypeHandler&gt;</td> 
   <td align="center">UnknownTypeHandler.class</td> 
   <td align="center">类型处理器</td> 
  </tr> 
 </tbody> 
</table>

**update：** 下面这么写，每一次执行update语句，会将字段值填充到%s，执行%s+1操作再写会，而不是直接写入，也就是每个update就+1。

@TableField(update = "%s+1")
        private String apassword;

**condition：** 这个属要结合下面看，默认的为condition.EQUAL，也就是等于，我们换个就是换中筛选方式

public class SqlCondition { 
        public static final String EQUAL = "%s=#{%s}";
        public static final String NOT_EQUAL = "%s<>#{%s}";
        public static final String LIKE = "%s LIKE CONCAT('%%',#{%s},'%%')";
        public static final String LIKE_LEFT = "%s LIKE CONCAT('%%',#{%s})";
        public static final String LIKE_RIGHT = "%s LIKE CONCAT(#{%s},'%%')";
    
        public SqlCondition() { 
        }
    }

#### 5、配置 ####

**mapperLocations：** 用于指明 Mapper 所对应的 XML 的文件位置

*  类型：`String[]`
 *  默认值：`["classpath*:/mapper/**/*.xml"]`
 *  mybatis-plus.mapper-locations = classpath\*:mybatis/\*.xml

**configLocation：** 用于指明 MyBatis 配置文件的位置

*  类型：`String`
 *  默认值：`null`
 *  mybatis-plus.config-location = classpath:mybatis-config.xml

**typeAliasesPackage：** 用于 MyBatis 别名包扫描路径

*  类型：`String`
 *  默认值：`null`
 *  mybatis-plus.type-aliases-package = cbuc.life.bean

**mapUnderscoreToCamelCase：** 是否开启自动驼峰命名规则（camel case）映射

*  类型：`boolean`
 *  默认值：`true`
 *  mybatis-plus.configuration.map-underscore-to-camel-case = false

**cacheEnabled** ： 全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存

*  类型：`boolean`
 *  默认值： `true`
 *  mybatis-plus.configuration.cache-enabled = false

#### 6、其他扩展 ####

**自动填充：**

有时候我们在插入或更新数据的时候，希望有些字段可以自动填充。

@TableField(fill = FieldFill.INSERT)
        private String account;

fieldfill的可选项：

public enum FieldFill { 
        DEFAULT,
        INSERT,
        UPDATE,
        INSERT_UPDATE;
    
        private FieldFill() { 
        }
    }

自定义的填充处理模式：

@Component
    public class MyMetaObjectHandler implements MetaObjectHandler { 
    
        @Override
        public void insertFill(MetaObject metaObject) { 
            Object account = getFieldValByName("account", metaObject);
            if(account == null ){ 
                setFieldValByName("account","你说呢",metaObject);
            }
    
        }
    
        @Override
        public void updateFill(MetaObject metaObject) { 
            // 字段填充
        }
    }

测试案例：

@Test
        void test2(){ 
            adminMapper.insert(Admin.builder().apassword("156").build());
        }
    	// admin(null,你说呢,156);

**逻辑删除：**

@TableLogic
        private Integer aid;

配置文件：

mybatis-plus:
      global-config:
        db-config:
          logic-delete-field: aid  # 全局逻辑删除的实体字段名(配置后可以不配置实例类)
          logic-delete-value: 0
          logic-not-delete-value: 1

测试：

@Test
        void test3(){ 
            adminMapper.deleteById(6);
        }

**通用枚举：**

通过建立一个枚举类，来配置mybatis-plus，来达到实体类中的字段从K到V的映射关系。

[夜深了，案例连接][Link 2]

数据库中加字段：

ALTER TABLE `admin` ADD COLUMN `sex` INT ( 1 ) NULL;

编写枚举类：

public enum SexEnum implements IEnum<Integer> { 
    
    	MAN(1, "男"), WOMAN(2, "女");
    
    	private int value;
    	private String desc;
    
    	SexEnum(int value, String desc) { 
    		this.value = value;
    		this.desc = desc;
    	}
    
    	@Override
    	public Integer getValue() { 
    		return this.value;
    	}
    
    	@Override
    	public String toString() { 
    		return this.desc;
    	}
    
    }

实体类添加字段：

private SexEnum sex; // 性别，枚举类型

配置文件：

mybatis-plus:
      type-enums-package: com.order.food.delivery.enums

测试：

@Test
        void test3(){ 
    	    // 插入
            Admin build =Admin.builder().account("as").apassword("f")
                 .sex(SexEnum.MAN).build();
            adminMapper.insert(build);
    
            // 查询
            Admin admin = adminMapper.selectById(12);
            System.out.println(admin);
        }

这样我们就可以达到，插入的数值是1，查询出来的数值为’男’。

[Link 1]: https://baomidou.com/guide/
[builder]: https://blog.csdn.net/qq_35568099/article/details/80438538
[Link 2]: https://blog.csdn.net/weixin_45730091/article/details/107361513