【Springcloud微服务】MybatisPlus上篇

已于 2024-06-04 20:11:59 修改
阅读量951 收藏 22
点赞数 26
分类专栏： Springcloud微服务 文章标签： spring cloud 微服务 java mybatisplus
于 2024-06-04 14:45:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62511863/article/details/139065276
版权

🔥 本文由 程序喵正在路上 原创，CSDN首发！
💖 系列专栏：Springcloud微服务
🌠 首发时间：2024年6月4日
🦋 欢迎关注🖱点赞👍收藏🌟留言🐾

目录

资料下载

点击此处进入下载资料

微服务

微服务是一种软件架构风格，它是以专注于单一职责的很多小型项目为基础，组合出复杂的大型应用。

在这里插入图片描述

MybatisPlus介绍

官网：https://baomidou.com/

在这里插入图片描述

在这里插入图片描述

快速入门

入门案例

目标：

  • 学会 MP 的基本用法
  • 体会 MP 的无侵入和方便快捷的特点

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

  • 新增用户功能
  • 根据 id 查询用户
  • 根据 id 批量查询用户
  • 根据 id 更新用户
  • 根据 id 删除用户

在这里插入图片描述

具体步骤：

  1. 引入 MybatisPlus 的起步依赖

    MyBatisPlus 官方提供了 starter，其中集成了 Mybatis 和 MybatisPlus 的所有功能，并且实现了自动装配效果。因此我们可以用 MybatisPlus 的 starter 代替 Mybatis 的 starter：

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

    可将 UserMapper 里的方法和 UserMapper.xml 中的 SQL 语句删除，因为我们不再需要了

  2. 自定义 Mapper 继承 BaseMapper 接口

    自定义的 Mapper 需要继承 MybatisPlus 提供的 BaseMapper 接口：

    public interface UserMapper extends BaseMapper<User> {
    
}

在这里插入图片描述

  1. 将测试类中调用的方法改为 MybatisPlus 自带的方法：

    在这里插入图片描述

    在这里插入图片描述

  2. 自行测试一下即可

常见注解

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

public class User {
    private Long id;                //用户id
    private String username;        //用户名
    private String password;        //密码
    private String phone;           //注册手机号
    private String info;            //详细信息
    private Integer status;         //使用状态（1正常 2冻结）
    private Integer balance;        //账户余额
    private LocalDateTime createTime;//创建时间
    private LocalDateTime updateTime;//更新时间
}

MybatisPlus 是如何获取实现 CRUD 的数据库表信息的？

  • 默认以类名驼峰转下划线作为表名

  • 默认将名为 id 的字段作为主键

  • 默认将变量名驼峰转下划线作为表的字段名

    在这里插入图片描述

只要我们定义的类符合规则，MP 就能自动获取到对应的数据库表信息，从而帮我们生成 SQL 语句。如果不一样，我们就需要通过注解来指定。

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

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

IdType枚举：

  • AUTO：数据库自增长
  • INPUT：通过set方法自行输入
  • ASSIGN_ID：分配 ID，接口 IdentifierGenerator 的方法 nextId 来生成 id，默认实现类为 DefaultIdentifierGenerator 雪花算法

使用 @TableField 的常见场景：

  1. 成员变量名与数据库字段名不一致
  2. 成员变量名以 is 开头，且是布尔值
  3. 成员变量名与数据库关键字冲突
  4. 成员变量不是数据库字段

例子：

有一个用户表：

在这里插入图片描述

我们定义的实体类：

public class User {
    private Long id;
    private String name;
    private Boolean isMarried;
    private Integer order;
    private String address;
}

加上注解后：

@TableName("tb_user")
public class User {
    @TableId(value = "id", type = IdType.AUTO)  //自增
    private Long id;
    @TableField("username")     //不一致
    private String name;
    @TableField("is_married")   //遇到布尔型且以 is开头的变量，MP会自动去掉 is，即为 married
    private Boolean isMarried;
    @TableField("'order'")      //和 sql关键字一样
    private Integer order;
    @TableField(exist = false)  //表中没有该字段
    private String address;
}

将我们项目中定义的实体类修改一下：

public class User {
    @TableId(type = IdType.AUTO)    //不指定的话，默认为随机生成id，也就是第三种方式
    private Long id;                //用户id
    private String username;        //用户名
    private String password;        //密码
    private String phone;           //注册手机号
    private String info;            //详细信息
    private Integer status;         //使用状态（1正常 2冻结）
    private Integer balance;        //账户余额
    private LocalDateTime createTime;//创建时间
    private LocalDateTime updateTime;//更新时间
}

常见配置

MyBatisPlus 的配置项继承了 MyBatis 原生配置和一些自己特有的配置。例如：

mybatis-plus:
  type-aliases-package: com.itheima.mp.domain.po  # 别名扫描包
  mapper-locations: "classpath*:/mapper/**/*.xml" # Mapper.xml文件地址，默认值
  configuration:
    map-upderscore-to-camel-case: true  # 是否开启下换线和驼峰的映射
    cache-enabled: false  # 是否开启二级缓存
  global-config:
    db-config:
      id-type: assign_id  # id为雪花算法生成
      update-strategy: not_null # 更新策略：只更新非空字段

别看上面代码这么多，其实除了第一个，其他都是默认的，可以不用配置，除非你要自己设置为别的值。至于其他的配置，需要用到的时候，可以百度搜索或者参考官方文档：使用配置 | MyBatis-Plus。

总结

MyBatisPlus 使用的基本流程是什么？

  1. 引入起步依赖
  2. 自定义 Mapper 基础 BaseMapper
  3. 在实体类上添加注解声明表信息
  4. 在 application.yml 中根据需要添加配置

核心功能

条件构造器

MyBatisPlus 支持各种复杂的 where 条件，可以满足日常开发的所有需求。在 MyBatisPlus 中，Wrapper 类是构建查询和更新条件的核心工具。

Wrapper 类及其子类：

在这里插入图片描述

BaseMapper 中很多方法都是支持用 Wrapper 对象作为参数的：

在这里插入图片描述
AbstractWrapper类：

在这里插入图片描述

QueryWrapper类：

在这里插入图片描述
UpdateWrapper类：

在这里插入图片描述

基于QueryWrapper的查询

需求：

  1. 查询出名字中带 o 的，存款大于等于 1000 元的人的 id、username、info、balance字段

    sql 语句这样写：

    select id,username,info,balance
from user
where username like ? and balance >= ?

    QueryWrapper 这样写：

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

  2. 更新用户名为 jack 的用户的余额为 2000

    sql 语句这样写：

    update user
set balance = 2000
where (username = "jack")

    QueryWrapper 这样写：

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

基于UpdateWrapper的查询

  1. 需求：更新 id 为 1,2,4 的用户的余额，扣 200

    sql 语句这样写：

    update user
set balance = balance - 200
where id in (1, 2, 4)

    UpdateWrapper 这样写：

    @Test
void testUpdateWrapper() {
    //准备数据和更新条件
    List<Long> ids = List.of(1L, 2L, 4L);
    UpdateWrapper<User> wrapper = new UpdateWrapper<User>()
            .setSql("balance = balance - 200")
            .in("id", ids);
    //执行更新
    userMapper.update(null, wrapper);
}

LambdaQueryWrapper

一个基于 Lambda 表达式的查询条件构造器，它通过 Lambda 表达式来引用实体类的属性，从而避免了硬编码字段名。这种方式提高了代码的可读性和可维护性，尤其是在字段名可能发生变化的情况下。

我们用 LambdaQueryWrapper 改进 QueryWrapper 的第一个需求的代码，如下：

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

LambdaUpdateWrapper 的用法类似。

总结

条件构造器的用法：

  • QueryWrapper 和 LambdaQueryWrapper 通常用来构建 select、delete、update 的 where 条件部分
  • UpdateWrapper 和 LambdaUpdateWrapper 通常只有在 set 语句比较特殊才使用
  • 尽量使用 LambdaQueryWrapper 和 LambdaUpdateWrapper，避免硬编码

自定义SQL

在演示 UpdateWrapper 的案例中，我们在代码中编写了更新的 SQL 语句。

@Test
void testUpdateWrapper() {
    //准备数据和更新条件
    List<Long> ids = List.of(1L, 2L, 4L);
    UpdateWrapper<User> wrapper = new UpdateWrapper<User>()
            .setSql("balance = balance - 200")
            .in("id", ids);
    //执行更新
    userMapper.update(null, wrapper);
}

这种写法在某些企业也是不允许的，因为 SQL 语句最好都维护在持久层，而不是业务层。就当前案例来说，由于条件是 in 语句，只能将 SQL 写在 Mapper.xml 文件，利用 foreach 来生成动态 SQL，但是这实在是太麻烦了。假如查询条件更复杂，动态 SQL 的编写也会更加复杂。

所以，MybatisPlus 提供了自定义 SQL 功能，可以让我们利用 Wrapper 生成查询条件部分，再结合我们自己在 Mapper.xml 编写 SQL。

基本用法

改写上面那个例子：

  1. 基于 Wrapper 构建 where 条件

    @Test
void testCustomWrapper() {
    //准备查询条件
    List<Long> ids = List.of(1L, 2L, 4L);
    LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<User>().in(User::getId, ids);
    int amount = 200;

    //调用mapper的自定义方法，直接传递mapper
    userMapper.deductBalanceByIds(wrapper, amount);
}

  2. 在 mapper 方法参数中用 Param 注解声明 wrapper 变量名称，必须是 ew

  3. 自定义 SQL，并使用 Wrapper 条件，注解或者 xml 文件皆可

    @Mapper
public interface UserMapper extends BaseMapper<User> {

    @Update("update user set balance = balance - #{amount} ${ew.customSqlSegment}")
    void deductBalanceByIds(@Param("ew") LambdaQueryWrapper<User> wrapper, @Param("amount") int amount);
}

多表查询

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

例如，我们要查询出所有收货地址在北京的并且用户 id 在 1、2、4 之中的用户。

@Test
void testCustomJoinWrapper() {
    //准备查询条件
    QueryWrapper<User> wrapper = new QueryWrapper<User>()
            .in("u.id", List.of(1L, 2L, 4L))
            .eq("a.city", "北京");
    //调用mapper的自定义方法
    List<User> users = userMapper.queryUserByWrapper(wrapper);
    users.forEach(System.out::println);
}

@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);

在这里插入图片描述

Service接口

MybatisPlus 不仅提供了 BaseMapper，还提供了通用的 Service 接口及默认实现，封装了一些常用的 service 模板方法。

通用接口为 IService，默认实现为 ServiceImpl，其中封装的方法可以分为以下几类：

  • save：新增
  • remove：删除
  • update：更新
  • get：查询单个结果
  • list：查询集合结果
  • count：计数
  • page：分页查询

CRUD

新增：

在这里插入图片描述

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

删除：

在这里插入图片描述

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

修改：

在这里插入图片描述

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

查询：

在这里插入图片描述

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

批量查询：

在这里插入图片描述

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

计数：

在这里插入图片描述

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

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

基本用法

由于 Service 中经常需要定义与业务有关的自定义方法，因此我们不能直接使用 IService，而是自定义 Service 接口，然后继承 IService 以拓展方法。同时，让自定义的 Service 实现类继承 ServiceImpl，这样就不用自己实现 IService 中的接口了。

在这里插入图片描述

首先，定义 IUserService，继承 IService：

import com.baomidou.mybatisplus.extension.service.IService;
import com.itheima.mp.domain.po.User;

public interface IUserService extends IService<User> {
}

然后，编写 UserServiceImpl 类，继承 ServiceImpl，实现 UserService：

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.itheima.mp.domain.po.User;
import com.itheima.mp.mapper.UserMapper;
import com.itheima.mp.service.IUserService;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
}

项目结构如下：

在这里插入图片描述

双击选中 IUserService 右键选择 Generate → \rightarrow → Test → \rightarrow → Ok 生成测试类：

在这里插入图片描述

调用 IService 的一些方法，测试是否成功：

import com.itheima.mp.domain.po.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.time.LocalDateTime;
import java.util.List;

@SpringBootTest
class IUserServiceTest {

    @Autowired
    private IUserService userService;


    @Test
    void testSaveUser() {
        User user = new User();
        user.setId(5L);
        user.setUsername("Lucy");
        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风格实现接口

需求：基于 Restful 风格实现下面的接口：

在这里插入图片描述

首先，我们在项目中引入几个依赖：

<!--swagger-->
<dependency>
    <groupId>com.github.xiaoymin</groupId>
    <artifactId>knife4j-openapi2-spring-boot-starter</artifactId>
    <version>4.1.0</version>
</dependency>
<!--web-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

然后需要配置 swagger 信息：

knife4j:
  enable: true
  openapi:
    title: 用户管理接口文档
    description: "用户管理接口文档"
    email: zhanghuyi@itcast.cn
    concat: 嘻嘻
    url: https://www.itcast.cn
    version: v1.0.0
    group:
      default:
        group-name: default
        api-rule: package
        api-rule-resources:
          - com.itheima.mp.controller

然后，接口需要两个实体：

  • UserFormDTO：代表新增时的用户表单
  • UserVO：代表查询的返回结果

首先是 UserFormDTO：

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

@Data
@ApiModel(description = "用户表单实体")
public class UserFormDTO {

    @ApiModelProperty("id")
    private Long id;

    @ApiModelProperty("用户名")
    private String username;

    @ApiModelProperty("密码")
    private String password;

    @ApiModelProperty("注册手机号")
    private String phone;

    @ApiModelProperty("详细信息，JSON风格")
    private String info;

    @ApiModelProperty("账户余额")
    private Integer balance;
}

然后是 UserVO：

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

@Data
@ApiModel(description = "用户VO实体")
public class UserVO {

    @ApiModelProperty("用户id")
    private Long id;

    @ApiModelProperty("用户名")
    private String username;

    @ApiModelProperty("详细信息")
    private String info;

    @ApiModelProperty("使用状态（1正常 2冻结）")
    private Integer status;

    @ApiModelProperty("账户余额")
    private Integer balance;
}

项目结构如下：

在这里插入图片描述

最后，按照 Restful 风格编写 Controller 接口方法：

import cn.hutool.core.bean.BeanUtil;
import com.itheima.mp.domain.dto.UserFormDTO;
import com.itheima.mp.domain.po.User;
import com.itheima.mp.domain.vo.UserVO;
import com.itheima.mp.service.IUserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
@Api(tags = "用户管理接口")
@RequiredArgsConstructor   //注入对象所需
public class UserController {

    //spring不推荐使用@Autoweird这种方式注入对象，而是推荐使用构造器的方式
    private final IUserService userService;

    /**
     * 新增用户
     *
     * @param userFormDTO
     */
    @PostMapping
    @ApiOperation("新增用户接口")
    public void saveUser(@RequestBody UserFormDTO userFormDTO) {
        //转换DTO为PO
        User user = BeanUtil.copyProperties(userFormDTO, User.class);
        userService.save(user);
    }

    /**
     * 删除用户
     *
     * @param userId
     */
    @DeleteMapping("/{id}")
    @ApiOperation("删除用户接口")
    public void deleteById(@ApiParam("用户id") @PathVariable("id") Long userId) {
        userService.removeById(userId);
    }

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

    /**
     * 根据id集合查询用户
     *
     * @param ids
     * @return
     */
    @GetMapping
    @ApiOperation("根据id集合查询用户")
    public List<UserVO> queryUserByIds(@RequestParam("ids") List<Long> ids) {
        List<User> users = userService.listByIds(ids);
        return BeanUtil.copyToList(users, UserVO.class);
    }
}

可以看到上述接口都直接在 controller 即可实现，无需编写任何 service 代码，非常方便。

不过，一些带有业务逻辑的接口则需要在 service 中自定义实现了，最后一个接口就是。

根据 id 扣减用户余额，这看起来是个简单的修改功能，只要修改用户余额即可。其实这个业务包含一些业务逻辑处理：

  • 判断用户状态是否正常
  • 判断用户余额是否充足

这些业务逻辑都要在 service 层来做，另外更新余额需要自定义 SQL，要在 mapper 中来实现。因此，我们除了要编写 controller 以外，具体的业务还要在 service 和 mapper 中编写，我们工作中遇到的接口也是很复杂的。

首先在 UserController 中定义一个方法：

/**
 * 根据id扣减用户余额
 *
 * @param id
 * @param money
 */
@PutMapping("/{id}/deduction/{money}")
@ApiOperation("扣减用户余额接口")
public void deductBalance(
        @ApiParam("用户id") @PathVariable("id") Long id,
        @ApiParam("扣减的金额") @PathVariable("money") Integer money
) {
    userService.deductBalance(id, money);
}

然后是 UserService 接口：

/**
 * 根据id扣减用户余额
 *
 * @param id
 * @param money
 */
void deductBalance(Long id, Integer money);

UserServiceImpl 实现类：

/**
 * 根据id扣减用户余额
 *
 * @param id
 * @param money
 */
public void deductBalance(Long id, Integer money) {
    // 1.查询用户
    User user = getById(id);
    // 2.校验用户状态
    if (user == null || user.getStatus() == 2) {
        throw new RuntimeException("用户状态异常！");
    }
    // 3.校验余额是否充足
    if (user.getBalance() < money) {
        throw new RuntimeException("用户余额不足！");
    }
    // 4.扣减余额
    baseMapper.deductBalance(id, money);    //继承的ServiceImpl已经注入了mapper，直接使用即可
}

最后是 mapper：

@Update("update user set balance = balance - #{money} where id = #{id}")
void deductBalance(@Param("id") Long id, @Param("money") Integer money);

启动服务，浏览器访问 http://localhost:8080/doc.html 接口文档，自行测试一下。

Lambda

IService 中还提供了 Lambda 功能来简化我们的复杂查询及更新功能。我们通过两个案例来学习一下。

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

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

可以理解成一个用户的后台管理界面，管理员可以自己选择条件来筛选用户，因此上述条件不一定存在，需要做判断。

我们首先需要定义一个查询条件实体，用来接口前端传过来的数据，UserQuery 实体：

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;
}

在这里插入图片描述

在 UserController 中定义一个 controller 方法：

/**
 * 根据复杂条件查询用户
 *
 * @param query
 * @return
 */
@GetMapping("/list")
@ApiOperation("根据复杂条件查询用户接口")
public List<UserVO> queryUsers(UserQuery query) {
    // 1.查询用户PO
    List<User> users = userService.queryUsers(query.getName(), query.getStatus(), query.getMinBalance(), query.getMaxBalance());
    // 2.把PO拷贝到VO
    return BeanUtil.copyToList(users, UserVO.class);
}

在 IUserService 接口中定义方法：

/**
 * 根据复杂条件查询用户
 *
 * @param name
 * @param status
 * @param minBalance
 * @param maxBalance
 * @return
 */
List<User> queryUsers(String name, Integer status, Integer minBalance, Integer maxBalance);

在 UserServiceImpl 中实现方法：

Service 中对 LambdaQueryWrapper 和 LambdaUpdateWrapper 的用法进一步做了简化。我们无需自己通过 new 的方式来创建 Wrapper，而是直接调用 lambdaQuery 和 lambdaUpdate 方法即可实现。

/**
 * 根据复杂条件查询用户
 *
 * @param name
 * @param status
 * @param minBalance
 * @param maxBalance
 * @return
 */
public List<User> queryUsers(String name, Integer status, Integer minBalance, Integer maxBalance) {
    return 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();
}

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

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

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

测试一下：

在这里插入图片描述

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

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

  • 如果扣减后余额为 0，则将用户 status 修改为冻结状态（2）
/**
 * 根据id扣减用户余额
 *
 * @param id
 * @param money
 */
@Transactional
public void deductBalance(Long id, Integer money) {
    // 1.查询用户
    User user = getById(id);
    // 2.校验用户状态
    if (user == null || user.getStatus() == 2) {
        throw new RuntimeException("用户状态异常！");
    }
    // 3.校验余额是否充足
    if (user.getBalance() < money) {
        throw new RuntimeException("用户余额不足！");
    }
    // 4.扣减余额
    int 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();
}

批量新增

需求：如果我们往数据库中批量插入 10 万条用户数据，并对以下三种方式作出对比：

  1. 使用普通 for 循环插入
  2. 使用 IService 的批量插入
  3. 配置 MySQL 的 rewriteBatchedStatements=true 参数

方式一：

@Test
void testSaveOneByOne() {
    long b = System.currentTimeMillis();
    for (int i = 1; i <= 100000; i++) {
        userService.save(buildUser(i));
    }
    long e = System.currentTimeMillis();
    System.out.println("耗时：" + (e - b));
}

private User buildUser(int i) {
    User user = new User();
    user.setUsername("user_" + i);
    user.setPassword("123");
    user.setPhone("" + (18688190000L + i));
    user.setBalance(2000);
    user.setInfo("{\"age\": 24, \"intro\": \"英文老师\", \"gender\": \"female\"}");
    user.setCreateTime(LocalDateTime.now());
    user.setUpdateTime(user.getCreateTime());
    return user;
}

在这里插入图片描述

耗时 3 分钟多，可以看到速度非常慢。

方式二：

@Test
void testSaveBatch() {
    // 准备10万条数据
    List<User> list = new ArrayList<>(1000);
    long b = System.currentTimeMillis();
    for (int i = 1; i <= 100000; i++) {
        list.add(buildUser(i));
        // 每1000条批量插入一次
        if (i % 1000 == 0) {
            userService.saveBatch(list);
            list.clear();
        }
    }
    long e = System.currentTimeMillis();
    System.out.println("耗时：" + (e - b));
}

将前面插入的数据删除后，我们进行方式二的测试：

在这里插入图片描述

耗时 31 秒，性能还可以。

方式三：

MySQL 的客户端连接参数中有这样的一个参数：rewriteBatchedStatements。顾名思义，就是重写批处理的 statement 语句。参考文档：https://dev.mysql.com/doc/connector-j/en/connector-j-connp-props-performance-extensions.html

在这里插入图片描述

配置该参数后，可以将 MybatisPlus 批处理的 SQL 语言合并成一句，从而大大提升性能。

在配置文件中，数据库的 url 后面加上 &rewriteBatchedStatements=true 即可：

在这里插入图片描述

在这里插入图片描述

现在，使用 MybatisPlus 的批处理只耗时 8 秒钟，性能极大提升，而且随着数据量的增大效果会越明显。

程序喵正在路上
关注
专栏目录
SpringCloud微服务架构搭建
weixin_56162501的博客
08-19 2165
可以创建springboot工程，也可以使用maven工程，但spring工程里一些东西使用不到，这里使用的是springboot工程创建的父工程。客户向订单微服务发起一个下单的请求，在进行保存订单之前需要调用商品微服务查询商品的信息。在这种场景下，订单微服务就是一个服务消费者， 商品微服务就是一个服务提供者。父工程 ----jar的版本管理 公共jar的引入。在微服务架构中，最常见的场景就是。我们一般把服务的主动调用方称为。技术栈 druid。，把服务的被调用方称为。微服务之间的相互调用。
SpringCloud微服务整合Spring Security进行统一鉴权
lyy的博客
04-15 3884
有一个大坑，记得如果是单机操作多个微服务项目，要给每个微服务添加session cookie name，如下server : port : 8003 servlet : session : cookie : #防止 Cookie 冲突，冲突会导致登录验证不通过一定一定要做这一步。
spring cloud整合mybatis
04-09
spring cloud整合mybatis,spring cloud整合mybatis,spring cloud整合mybatis
spring cloud + spring boot + ...分布式微服务云架构
qq_40354025的博客
10-11 1985
spring cloud + spring boot + springmvc+mybatis分布式做一个微服务架构需要的技术整理
springcloud整合mybatis-plus
liuchaozhi的博客
07-05 4794
项目整合mybatis-plus
快速搭建springcloud+mybatisplus
hq1148365306的博客
08-12 1864
快速搭建springcloud+mybatisplus
Spring Cloud集成MyBaties-Plus
PigeonEssence的博客
12-14 2177
最近的个人官网开始了后台的开发，为了偷懒选择了更简单的MyBaties Plus开进行数据库操作，在nacos和Spaing Cloud的基础上进行开发，做一下记录。 所有的新技术我们都是从快速开始入手的，首先我们通过官方文档，可以看到这个快速开始： 快速开始 | MyBatis-Plus 简单梳理一下这个快速开始： 1.创建数据库 首先在数据库中创建一个mybaties_plus数据库 ： 在查询中输入准备好的sql语句： DROP TABLE IF ...
SpringCloud+MybatisPlus+XXL-JOB+redis+Vue前后端分离、分布式、微服务架构Java商城系统
04-24
Smart Shop是一款基于 Spring Cloud +MybatisPlus+XXL-JOB+redis+Vue的前后端分离、分布式、微服务架构的Java商城系统，采用稳定框架开发及优化核心，减少依赖，具备出色的执行效率，扩展性、稳定性高，H5/小程序/...
基于SpringBoot+SpringCloud微服务的商城项目+源代码+文档说明
11-28
基于SpringCloud微服务的商城项目 这是一个 B2C 商城，用户可以登录注册浏览商品下单购买等，使用当下最流行的 SpringBoot+SpringCloud 组合基于微服务的架构模式，各微服务之间通信使用 RestFul 接口进行访问，使用...
SpringCloud微服务项目搭建与部署教程
西里古里的博客
10-18 4723
一款 Java 语言基于 SpringCloud、Vue、ElementUI、MySQL等框架精心打造的一款前后端分离框架，致力于实现模块化、组件化、可插拔的前后端分离架构敏捷开发框架，可用于快速搭建前后端分离后台管理系统，本着简化开发、提升开发效率的初衷，目前框架已集成了完整的RBAC权限架构和常规基础模块，前端Vue端支持多主题切换，可以根据自己喜欢的风格选择想一个的主题的个性化呈现的需
微服务springcloud集成mybatis
06-06
该项目通过springcloud集成了mybatis操作mysql数据库，项目主要分为7个model模块，配置模块（config），注册模块（discovery），监控模块（monitor），服务模块_mybatisService（通过mybatis操作mysql），服务模块_person（通过hibernate操作hsql），服务模块_some（通过@Value获取配置信息），消费模块_ui（通过RestTemplate调用服务） 浏览器通过如下地址进行测试使用 http://localhost/#/user http://localhost/#/person http://localhost/#/some
Spring Cloud集成新版MyBaties-Plus
PigeonEssence的博客
12-17 2195
目录 一.快速开始 1.创建数据库 2.插入数据 3.编写项目，导入依赖 4.配置数据库 5.pojo层： 6.mapper层： 7.编写启动类 8.编写测试类（和application相同路径创建）： 8.测试结果： 二.配置日志 三.基础CRUD 1.插入测试 算法选用： 3.更新测试 4.自动填充 1.数据库级别（一般生产上不使用）： 2.代码级别： 四.乐观锁插件 1.增加version字段 2.实体类添加字段 3.注册组件 4.测试 五.查询测试：.
SpringCloud
最新发布
2301_80098154的博客
07-20 740
我们可以利用MyBatisPlus的Wrapper来构建复杂的Where条件，然后自己定义SQL语句中剩下的部分。①基于Wrapper构建where条件@Test// 1.更新条件// 2.定义条件// 3.调用自定义的SQL方法②在Mapper方法参数中用Param注解声明Wrapper变量名称，必须是ew③自定义SQL，并使用Wrapper条件。
spring-cloud集成mybatis-plus
weixin_30888707的博客
03-07 577
　　mybatis-plus插件是对mybatis做出系列增强插件，后面简称MP，MP可免去开发者重复编写xml、mapper、service、entity等代码，通过MP提供的实体注解来完成单表的CRUD简单操作，MP同样配套有代码生成工具，可通过简单的配置来生成xml、mapper、service、entity等文件，极大提升了开发速度，本文是在spring-cloud的环境下集成mybati...
SpringCloud整合Mybatis-Plus
qq_35232654的博客
08-11 565
官网地址 https://mp.baomidou.com/ 第一步：pom.xml添加依赖 <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.4.3</version> </dependency> 第二步：Main主函数添加
Spring Cloud 整合mybatis-plus (五)
GMaya的博客
03-27 3749
前言 其实这个整合,和spring 或者 spring boot 整合一样的 其实都是一键生成的,自己把模板配好就行,从controller到service,dao,实体,增删改查 我只是拷贝过来几个测试这个项目 之前刚接触mybatis-plus的时候也写过自动生成的文章 引入jar <dependency> <groupId>co...
SpringCloud微服务01-MybatisPlus-Docker
qq_52439738的博客
05-13 891
一、微服务介绍 单体架构所有功能集群在一个架构中，难以维护复杂需求微服务之间是不同的TomCat要跨服务查询，学习是如何拆分单体架构为微服务这个mapper继承BaseMapper后就可以直接使用它的方法，增删改查。继承就可以直接操作对应的数据表原因在于实体类，我们需要遵循一些约定才能自动实现如果有不想遵循这些约定的内容就需要在实体类中注解。除了实体包名和mapper地址，其余都是默认设置即可。 MyBatisPlus适合单表查询，多表还是需要自己写SQLwhere的条件不一定是id可能更加负责，Wrap
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序喵正在路上

你的鼓励是我创作最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值