微服务-MybatisPlus上

微服务-MybatisPlus上

源自黑马虎哥的微服务课程

1 MybatisPlus快速入门

1.1 入门案例

学会MP的基本用法

体会MP的无侵入和方便快捷的特点

需求：基于课前资料提供的项目，实现下列功能

1. 新增用户功能
2. 根据id查询用户
3. 根据id批量查询用户
4. 根据id更新用户
5. 根据id删除用户

步骤：

1. 引入MybatisPlus的起步依赖

   

2. 定义Mapper

   自定义的Mapper继承MybatisPlus提供的BaseMapper接口。

   

1.2 常见注解

MybatisPlus通过扫描实体类，并基于反射获取实体类信息作为数据库表信息

MybatisPlus中比较常用的几个注解如下：

• @TableName：用来指定表名
• @TableId：用来指定表中的主键字段信息
• @TableField：用来指定表中的普通字段信息

注意：

• 其中主键注解@TableId中还有一个枚举参数，如上图所示。分别是由数据库实现自增、程序员自己设置、mp帮我们自动生成主键值。
• 当成员变量名是以is开头且是布尔值时，比如图中的isMarried成员变量，那么经过反射处理，mp会把is去掉，也就是变量isMarried变成了数据库中的married。
• 当成员变量名与数据库关键字冲突时，比如图中的比成员变量名order，使用@TableField时，记得用两个`把变量名包裹。
• 当成员变量不存在数据库的表中时，使用@TableField（exist=false）

@TableId中默认使用雪花算法实现Id的值

1.3 常见配置

2 MybatisPlus核心功能

2.1 条件构造器

MybatisPlus支持各种复杂的where条件，可以满足日常开发的所有需求。

2.1.1 QueryWrapper

案例1

    @Test
    void testQueryWrapper() {
        //1. 构建查询条件
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.select("id", "username", "info", "balance")
                .like("username", "o")
                .ge("balance", 1000);
        //2. 查询
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

    @Test
    void testUpdateByQueryWrapper() {
        //1. 要更新的数据
        User user = new User();
        user.setBalance(2000);
        //2. 更新的条件
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.ge("username","jack");
        //3. 执行更新
        userMapper.update(user,wrapper);
    }

2.1.2 UpdateWrapper

案例2

    @Test
    void testUpdateWrapper() {
        List<Long> ids = List.of(1L,2L,3L);
        UpdateWrapper<User> wrapper = new UpdateWrapper<>();
        wrapper.setSql("balance = balance - 200")
                .in("id",ids);
        userMapper.update(null,wrapper);
    }

2.1.3 Lambda形式Wrapper

Lambda形式的Wrapper其实就是将字段名改成对象的字段get函数，比如LambdaQueryWrapper

   @Test
    void testLambdaQueryWrapper() {
        //1. 构建查询条件
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(User::getId, User::getUsername, User::getInfo, User::getBalance)
                .like(User::getUsername, "o")
                .ge(User::getBalance, 1000);
        //2. 查询
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

2.2 自定义SQL

我们可以利用MybatisPlus的Wrapper来构建复杂的Where条件，然后自己定义SQL语句中剩下的部分。

2.2.1 基本用法

需求：将id在指定范围的用户（例如1、2、4）的余额扣减指定值

可以看到此处案例中使用wrapper的动态sql语句（balance = balance - 200）只能在业务层写出来，但是有些企业规定sql语句只能在mapper或者.xml中实现，那就矛盾了，于是就有了自定义SQL的出现，解决这个矛盾。

• Service层

    @Test
    void testCustomSqlUpdate() {
        //更新条件
        List<Long> ids = List.of(1L,2L,3L);
        int amount = 200;
        //定义条件
        LambdaUpdateWrapper<User> wrapper = new LambdaUpdateWrapper<>();
        wrapper.in(User::getId,ids);
        //调用自定义方法
        userMapper.updateBalanceByIds(wrapper,amount);
    }

• mapper层

    /**
     * 自定义的Sql语句
     * @param wrapper
     * @param amount
     */
    void updateBalanceByIds(@Param(value = "ew") LambdaUpdateWrapper<User> wrapper,@Param("amount") int amount);

• xml文件

    <update id="updateBalanceByIds">
        update tb_user set balance = balance - #{amount} ${ew.customSqlSegment}
    </update>

2.2.2 多表关联

理论上来讲MyBatisPlus是不支持多表查询的，不过我们可以利用Wrapper中自定义条件结合自定义SQL来实现多表查询的效果。

例如，我们要查询出所有收货地址在北京的并且用户id在1、2、4之中的用户 要是自己基于mybatis实现SQL，大概是这样的：

<select id="queryUserByIdAndAddr" resultType="com.itheima.mp.domain.po.User">
      SELECT *
      FROM user u
      INNER JOIN address a ON u.id = a.user_id
      WHERE u.id
      <foreach collection="ids" separator="," item="id" open="IN (" close=")">
          #{id}
      </foreach>
      AND a.city = #{city}
  </select>

可以看出其中最复杂的就是WHERE条件的编写，如果业务复杂一些，这里的SQL会更变态。

但是基于自定义SQL结合Wrapper的玩法，我们就可以利用Wrapper来构建查询条件，然后手写SELECT及FROM部分，实现多表查询。

查询条件这样来构建：

@Test
void testCustomJoinWrapper() {
    // 1.准备自定义查询条件
    QueryWrapper<User> wrapper = new QueryWrapper<User>()
            .in("u.id", List.of(1L, 2L, 4L))
            .eq("a.city", "北京");

    // 2.调用mapper的自定义方法
    List<User> users = userMapper.queryUserByWrapper(wrapper);

    users.forEach(System.out::println);
}

然后在UserMapper中自定义方法：

@Select("SELECT u.* FROM user u INNER JOIN address a ON u.id = a.user_id ${ew.customSqlSegment}")
List<User> queryUserByWrapper(@Param("ew")QueryWrapper<User> wrapper);

当然，也可以在UserMapper.xml中写SQL：

<select id="queryUserByIdAndAddr" resultType="com.itheima.mp.domain.po.User">
    SELECT * FROM user u INNER JOIN address a ON u.id = a.user_id ${ew.customSqlSegment}
</select>

2.3 Service接口

Service接口直接在Service层实现，且比BaseMapper的接口更丰富。

两步骤：

1. 我们的接口UserService继承IService接口
2. 我们的实现类UserServiceImpl继承ServiceImpl实现类

2.3.1 CRUD

新增：

• save是新增单个元素
• saveBatch是批量新增
• saveOrUpdate是根据id判断，如果数据存在就更新，不存在则新增
• saveOrUpdateBatch是批量的新增或修改

删除：

• removeById：根据id删除
• removeByIds：根据id批量删除
• removeByMap：根据Map中的键值对为条件删除
• remove(Wrapper<T>)：根据Wrapper条件删除
• ~~removeBatchByIds~~：暂不支持

修改：

• updateById：根据id修改
• update(Wrapper<T>)：根据UpdateWrapper修改，Wrapper中包含set和where部分
• update(T，Wrapper<T>)：按照T内的数据修改与Wrapper匹配到的数据
• updateBatchById：根据id批量修改

Get：

• getById：根据id查询1条数据
• getOne(Wrapper<T>)：根据Wrapper查询1条数据
• getBaseMapper：获取Service内的BaseMapper实现，某些时候需要直接调用Mapper内的自定义SQL时可以用这个方法获取到Mapper

List：

• listByIds：根据id批量查询
• list(Wrapper<T>)：根据Wrapper条件查询多条数据
• list()：查询所有

Count：

• count()：统计所有数量
• count(Wrapper<T>)：统计符合Wrapper条件的数据数量

getBaseMapper： 当我们在service中要调用Mapper中自定义SQL时，就必须获取service对应的Mapper，就可以通过这个方法：

2.3.2 基本用法

• service层

public interface IUserService extends IService<User> {


}

• Impl层

/**
 * ServiceImpl<UserMapper, User>
 *     第一个参数指定用到哪个Mapper中，第二个参数是要操作的实体对象
 */
@Service
public class IUserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {


}

测试：

@SpringBootTest
class IUserServiceTest {

    @Autowired
    private IUserService userService;

    @Test
    void testSaveUser() {
        User user = new User();
        user.setId(5L);
        user.setUsername("ZW");
        user.setPassword("123");
        user.setPhone("18688990011");
        user.setBalance(200);
        user.setInfo("{\"age\": 24, \"intro\": \"英文老师\", \"gender\": \"female\"}");
        user.setCreateTime(LocalDateTime.now());
        user.setUpdateTime(LocalDateTime.now());
        userService.save(user);
    }

    @Test
    void testQuery() {
        List<User> users = userService.listByIds(List.of(1L, 2L, 4L));
        users.forEach(System.out::println);
    }
   
}

案例： 基于Restful风格实现下列接口

@RestController
@RequestMapping("/users")
@Slf4j
@Api(tags = "用户管理接口")
@RequiredArgsConstructor
public class UserController {

    private final IUserService userService ;

    @PostMapping
    @ApiOperation(value = "新增用户接口")
    public void saveUser(@RequestBody UserFormDTO userFormDTO){
        //1. 把DTO拷贝到PO
        User user = BeanUtil.copyProperties(userFormDTO, User.class);
        //2. 新增
        userService.save(user);
    }

    @DeleteMapping("{id}")
    @ApiOperation(value = "删除用户接口")
    public void deleteUser(@ApiParam("用户id") @PathVariable("id") Long id){
        userService.removeById(id);
    }

    @GetMapping("{id}")
    @ApiOperation(value = "根据id查询用户接口")
    public UserVO queryUserById(@ApiParam("用户id") @PathVariable("id") Long id){
        User user = userService.getById(id);
        UserVO userVO = BeanUtil.copyProperties(user, UserVO.class);
        return userVO;
    }

    @GetMapping()
    @ApiOperation(value = "根据id批量查询用户接口")
    public List<UserVO> queryUserByIds(@RequestParam("ids") @ApiParam("用户id集合") List<Long> ids){
        List<User> users = userService.listByIds(ids);
        List<UserVO> userVOS = BeanUtil.copyToList(users, UserVO.class);
        return userVOS;
    }

}

比较复杂的函数，自定义的SQL语句

• controller

    @ApiOperation("扣减用户余额接口")
    @PutMapping("{id}/deduction/{money}")
    public void deductMoneyById(@ApiParam("用户id") @PathVariable("id") Long id,
                                @ApiParam("扣除金额") @PathVariable("money") Long money){
        userService.deductBalance(id,money);
    }

• service层

   /**
     * 扣减余额
     * @param id
     * @param money
     */
    @Override
    public void deductBalance(Long id, Long money) {
        //1. 查询用户
        User user = this.getById(id); //service.getById()  就是自己的函数 所以直接this.
        //2. 校验用户状态
        if(user == null || user.getStatus() == 2){
            throw new RuntimeException("用户状态异常");
        }
        //3. 校验余额是否充足
        if(user.getBalance() < money){
            throw new RuntimeException("用户余额不足");
        }
        //4. 扣除余额 update tb_user set balance = balance - ?
//        LambdaUpdateWrapper<User> wrapper = new LambdaUpdateWrapper<>();
//        wrapper.setSql("balance = balance - " + money.toString())
//                        .eq(User::getId,id);
//        update(wrapper);
        baseMapper.deductBalance(id,money); //baseMapper 其实就是UserMapper

    }

• mapper

    /**
     * 此函数也可以用@Param(value = "ew") LambdaUpdateWrapper<User> wrapper
     * 但是考虑where条件太简单 就直接写了
     * @param id
     * @param money
     */
    @Update("update tb_user set balance = balance - #{money} where id = #{id}")
    void deductBalance(@Param("id") Long id,@Param("money") Long money);

感觉就是直接用Service接口，因为更丰富，如果有复杂where条件的，就用Wrapper条件构造器，看情况使用queryWrapper和UpdateWrapper条件构造器。如果有复杂的SQL语句不能直接用构造器构造出来，必须得setsql，而且在业务层又不允许直接写sql语句的条件下，那么就自定义SQL，把where条件使用构造器构造出来，sql语句直接在mapper或者xml中写，比如上述例子。

2.3.3 Lambda

案例：IService的Lambda查询

需求：实现一个根据复杂条件查询用户的接口，查询条件如下：

• name：用户名关键字，可以为空
• status：用户状态，可以为空
• minBalance：最小余额，可以为空
• maxBalance：最大余额，可以为空

定义一个查询条件实体，UserQuery实体：

package com.itheima.mp.domain.query;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

@Data
@ApiModel(description = "用户查询条件实体")
public class UserQuery {
    @ApiModelProperty("用户名关键字")
    private String name;
    @ApiModelProperty("用户状态：1-正常，2-冻结")
    private Integer status;
    @ApiModelProperty("余额最小值")
    private Integer minBalance;
    @ApiModelProperty("余额最大值")
    private Integer maxBalance;
}

• controller层

@GetMapping("/list")
@ApiOperation("根据id集合查询用户")
public List<UserVO> queryUsers(UserQuery query){
    // 1.组织条件
    String username = query.getName();
    Integer status = query.getStatus();
    Integer minBalance = query.getMinBalance();
    Integer maxBalance = query.getMaxBalance();
    LambdaQueryWrapper<User> wrapper = new QueryWrapper<User>().lambda()
            .like(username != null, User::getUsername, username)	//第一个参数是condition
            .eq(status != null, User::getStatus, status)
            .ge(minBalance != null, User::getBalance, minBalance)
            .le(maxBalance != null, User::getBalance, maxBalance);
    // 2.查询用户
    List<User> users = userService.list(wrapper);
    // 3.处理vo
    return BeanUtil.copyToList(users, UserVO.class);
}

在组织查询条件的时候，我们加入了 username != null 这样的参数，意思就是当条件成立时才会添加这个查询条件，类似Mybatis的mapper.xml文件中的<if>标签。这样就实现了动态查询条件效果了。

不过，上述条件构建的代码太麻烦了。 因此Service中对LambdaQueryWrapper和LambdaUpdateWrapper的用法进一步做了简化。我们无需自己通过new的方式来创建Wrapper，而是直接调用lambdaQuery和lambdaUpdate方法：

基于Lambda查询：

@GetMapping("/list")
@ApiOperation("根据id集合查询用户")
public List<UserVO> queryUsers(UserQuery query){
    // 1.组织条件
    String username = query.getName();
    Integer status = query.getStatus();
    Integer minBalance = query.getMinBalance();
    Integer maxBalance = query.getMaxBalance();
    // 2.查询用户
    // 这里也可以new QueryWrapper 再加条件构造器+函数
    // 但是LambdaQuery更好用 不用new 直接上条件并查询
    List<User> list = lambdaQuery()
                .like(name != null, User::getUsername, name)
                .eq(status != null, User::getStatus, status)
                .ge(minBalance != null, User::getBalance, minBalance)
                .le(maxBalance != null, User::getBalance, maxBalance)
                .list();    //查一个就是one(),查多个就是list(),分页就是page()
        List<UserVO> userVOS = BeanUtil.copyToList(list, UserVO.class);
        return userVOS;
    // 3.处理vo
    return BeanUtil.copyToList(users, UserVO.class);
}

可以发现lambdaQuery方法中除了可以构建条件，还需要在链式编程的最后添加一个list()，这是在告诉MP我们的调用结果需要是一个list集合。这里不仅可以用list()，可选的方法有：

• .one()：最多1个结果
• .list()：返回集合结果
• .count()：返回计数结果

MybatisPlus会根据链式编程的最后一个方法来判断最终的返回结果。

与lambdaQuery方法类似，IService中的lambdaUpdate方法可以非常方便的实现复杂更新业务。

案例：IService的Lambda更新

需求：改造根据id修改用户余额的接口，要求如下

• 完成对用户状态的校验
• 完成对用户余额的校验
• 如果扣减后余额为0，则将用户status修改为冻结状态（2）

    public void deductBalance(Long id, Long money) {
        //1. 查询用户
        User user = this.getById(id); //service.getById()  就是自己的函数 所以直接this.
        //2. 校验用户状态
        if (user == null || user.getStatus() == 2) {
            throw new RuntimeException("用户状态异常");
        }
        //3. 校验余额是否充足
        if (user.getBalance() < money) {
            throw new RuntimeException("用户余额不足");
        }
        //4. 扣除余额 update tb_user set balance = 
        Long remainBalance =  user.getBalance() - money;
        lambdaUpdate()
                .set(User::getBalance, remainBalance)
                .set(remainBalance == 0, User::getStatus, 2)   //如果余额小于零 冻结
                .eq(User::getId, id)
                .eq(User::getBalance,user.getBalance()) //防止多个用户同时查询 同时扣除  乐观锁
                .update();  //此update()别忘了 前面的语句是条件语句 最后这条才是更新操作
    }

也就是如果要用Iservice接口，对于简单的增删改善，就直接使用IService的get list remove等函数，如果涉及到的条件比较复杂，就可以使用LambdaQuery或者LambdaUpdate函数，直接在后面构造条件，最后加一个查询函数即可。

2.3.4 Iservice批量新增

案例： 批量插入10万条用户数据，并做出对比：

• 普通for循环插入
• IService的批量插入
• 开启&rewriteBatchedStatements=true参数

可以发现其实MybatisPlus的批处理是基于PrepareStatement的预编译模式，然后批量提交，最终在数据库执行时还是会有多条insert语句，逐条插入数据。SQL类似这样：

Preparing: INSERT INTO user ( username, password, phone, info, balance, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ?, ? )
Parameters: user_1, 123, 18688190001, "", 2000, 2023-07-01, 2023-07-01
Parameters: user_2, 123, 18688190002, "", 2000, 2023-07-01, 2023-07-01
Parameters: user_3, 123, 18688190003, "", 2000, 2023-07-01, 2023-07-01

而如果想要得到最佳性能，最好是将多条SQL合并为一条，像这样：

INSERT INTO user ( username, password, phone, info, balance, create_time, update_time )
VALUES 
(user_1, 123, 18688190001, "", 2000, 2023-07-01, 2023-07-01),
(user_2, 123, 18688190002, "", 2000, 2023-07-01, 2023-07-01),
(user_3, 123, 18688190003, "", 2000, 2023-07-01, 2023-07-01),
(user_4, 123, 18688190004, "", 2000, 2023-07-01, 2023-07-01);

该怎么做呢？

MySQL的客户端连接参数中有这样的一个参数：rewriteBatchedStatements。顾名思义，就是重写批处理的statement语句。参考文档：

https://dev.mysql.com/doc/connector-j/8.0/en/connector-j-connp-props-performance-extensions.html#cj-conn-prop_rewriteBatchedStatements

这个参数的默认值是false，我们需要修改连接参数，将其配置为true

修改项目中的application.yml文件，在jdbc的url后面添加参数&rewriteBatchedStatements=true:

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/mp?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: MySQL123

然后直接使用

userService.saveBatch(list)