SpringBoot+Mybatis-Plus实现增删改查

1.Spring Boot 的特点

1. 独立运行的 Spring 项目

Spring Boot 可以以 jar 包的形式独立运行，Spring Boot 项目只需通过命令“ java–jar xx.jar” 即可运行。

2. 内嵌 Servlet 容器

Spring Boot 使用嵌入式的 Servlet 容器（例如 Tomcat、Jetty 或者 Undertow 等），应用无需打成 WAR 包 。

3. 提供 starter 简化 Maven 配置

Spring Boot 提供了一系列的“starter”项目对象模型（POMS）来简化 Maven 配置。

4. 提供了大量的自动配置

Spring Boot 提供了大量的默认自动配置，来简化项目的开发，开发人员也通过配置文件修改默认配置。

5. 自带应用监控

Spring Boot 可以对正在运行的项目提供监控。

6. 无代码生成和 xml 配置

Spring Boot 不需要任何 xml 配置即可实现 Spring 的所有配置。

2.配置开发环境

针对 idea 不同版本，使用不同的 maven 版本

IDEA 2022 兼容Maven 3.8.1及之前的所用版本​​
​IDEA 2021 兼容Maven 3.8.1及之前的所用版本​​
IDEA 2020 兼容Maven 3.6.3及之前所有版本​​
 

1、依赖版本jdk8以上, Springboot2.x用JDK8,maven用3.6.3以下
2、安装maven最新版本，下载地址 ：https://maven.apache.org/download.cgi

原文转载：

idea创建不了spring2.X版本，无法使用JDK8，最低支持JDK17 ， 如何用idea创建spring2.X版本，使用JDK8解决方案_spring3不支持jdk8-CSDN博客

1. 创建一个SpringBoot工程（尝试了很多方案SpringBoot整合Mybatis-Plus，我的建议是jdk 1.8，apache-maven-3.6.3（3.6.2），Java8）

Spring Boot 2.x 版本通常建议使用的 JDK（Java Development Kit）版本是 JDK 8、JDK 11 或更高版本，具体取决于 Spring Boot 的子版本。以下是 Spring Boot 2.x 版本与推荐的 JDK 版本的对应关系：

Spring Boot 2.0.x：推荐使用 JDK 8。
Spring Boot 2.1.x：推荐使用 JDK 8 或 JDK 11。
Spring Boot 2.2.x：推荐使用 JDK 8 或 JDK 11。
Spring Boot 2.3.x：推荐使用 JDK 8、JDK 11 或 JDK 14。
Spring Boot 2.4.x：推荐使用 JDK 8、JDK 11 或 JDK 15。
Spring Boot 2.5.x：推荐使用 JDK 8、JDK 11 或 JDK 16。
springboot3.x系列就要JDK17了

.配置maven步骤，打开IDEA的设置

配置好自己的本地maven，也可以不配置（用系统默认）

项目结构

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>jiu</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>Jiu</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.6.13</spring-boot.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <!--mysql连接依赖-->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--lombok简化代码-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--连接池依赖-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.16</version>
        </dependency>
        <!--mybatis-plus依赖-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.4.1</version>
            <exclusions>
                <exclusion>
                    <groupId>org.mybatis</groupId>
                    <artifactId>mybatis-spring</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--新加入的依赖 @ApiModelProperty这个才能用-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.7.0</version>
        </dependency>

    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
                <configuration>
                    <mainClass>com.example.jiu.JiuApplication</mainClass>
                    <skip>true</skip>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

yml文件

server:
  port: 85
#配置数据源
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/blog?serverTimezone=UTF-8
    username: root
    password: 123456
# 设置mp运行时行为
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

2.创建三层架构分别为 控制层（controller）、业务层（service）、数据访问层（mapper）、实体（entity）

3创建entity包下的User类

MySQL表绑定到spring boot（实体层）

让数据库字段和后端代码的绑定 

类名和数据库中的表名一样，首字母要大写，一个属性类对应一张数据库表。

实体类里面的属性要和数据库中的字段对应  。

Mybatis-Plus详解-原文链接：https://blog.csdn.net/m0_67296957/article/details/131723536

package com.example.jiu.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/*
 * 1.使用@Data注解(注在类上，提供类的get、set、equals、hashCode、toString等方法)
 * 2.使用@NoArgsConstructor注解(生成一个无参数的构造方法)
 * 3.使用@AllArgsConstructor注解（生成一个包含所有变量的构造方法。）
 * 4.使用注解@TableName(value = "user") （表名，当表名跟实体类类名不一致时，要使用@TableName注解进行映射）
 * 5.编写和数据库字段对应的属性
 * 6.加上文档注解@ApiModelProperty("用户的id")---里面的文字是相当于给自己看的备注
 * 7.使用@TableId(value = "id", type = IdType.AUTO)
 * 8.使用@TableField(value = "user_name")
 * */
@Data //1
@NoArgsConstructor //2
@AllArgsConstructor //3
@TableName(value = "tb_user")//4
public class User { //5

    @ApiModelProperty("用户的id") //6
    @TableId(value = "id", type = IdType.AUTO)//7
    private Integer id;

    @ApiModelProperty("用户名")
    @TableField(value = "user_name")//8
    private String username;

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

    @ApiModelProperty("姓名")
    private String name;

    @ApiModelProperty("年龄")
    private Integer age;

    @ApiModelProperty("邮箱")
    private String email;
}

@TableId

作用于主键上，指明主键字段，并设置主键的生成方式。

注解属性：
   value：指定表中主键字段，多用于主键字段和实体类字段不同
    type：id生成策略

@TableFiled

改注解作用众多，多用于表字段和实体类字段名称不统一，做映射处理，也可用于临时时字段，不存入数据库，或者是一些字段的填充处理。

常用的属性

@Bulider

 注解是 Lombok提供的一种注解，用于简化构建对象的过程。通过在类上添加 @Builder 注解，可以自动生成一个建造者模式相关的代码，使得对象的构建更加简洁和易读。

@Builder
public class Person {
    private String name;
    private int age;
    private String address;
}

在上述示例中，Person 类被标记为 @Builder 注解，Lombok 会自动生成一个内部静态类 PersonBuilder，其中包含了构建 Person 对象所需的方法。我们可以使用生成的建造者模式来创建 Person 对象，如下所示：

Person person = Person.builder()
                      .name("张三")
                      .age(25)
                      .address("北京")
                      .build();

4.创建mapper包下的UserMapper接口

springboot绑定到mybatis-plus（数据层）

把springboot获得的属性类再绑定给到mybatis-plus那边，然后绑定的这个接口给其他层调用。

（一）BaseMapper接口方法介绍

BaseMapper中提供了CRUD方法，具体方法如下：

// 插入一条记录
int insert(T entity);
 
// 根据 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);
 
// 根据 whereEntity 条件，更新记录
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
 
// 根据 ID 修改
int updateById(@Param(Constants.ENTITY) T 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);

5.创建service（实体类)

把数据层加工处理成逻辑业务（service服务层）

使用别人封装好的更好的方法以及各种逻辑

在service包下建立这个IUserService接口

（二）通用service常用方法介绍

/**
* 插入一条记录（选择字段，策略插入）
*
* @param entity 实体对象
*/
default boolean save(T entity) {
    return SqlHelper.retBool(getBaseMapper().insert(entity));
}
 
/**
* 根据 ID 选择修改
*
* @param entity 实体对象
*/
default boolean updateById(T entity) {
    return SqlHelper.retBool(getBaseMapper().updateById(entity));
}
 
/**
* TableId 注解存在更新记录，否插入一条记录
*
* @param entity 实体对象
*/
boolean saveOrUpdate(T entity);
 
/**
* 根据 Wrapper，查询一条记录 <br/>
* <p>结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT
1")</p>
*
* @param queryWrapper 实体对象封装操作类 {@link
com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
*/
default T getOne(Wrapper<T> queryWrapper) {
    return getOne(queryWrapper, true);
}
 
/**
* 根据 Wrapper，查询一条记录
*
* @param queryWrapper 实体对象封装操作类 {@link
com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
* @param throwEx 有多个 result 是否抛出异常
*/
T getOne(Wrapper<T> queryWrapper, boolean throwEx);

构建service接口(IUserService接口)

package com.example.mybatis.service;
 
import com.baomidou.mybatisplus.extension.service.IService;
import com.example.mybatis.entity.User;
 
 
//1.继承IService这个接口，<实体类名>
public interface IUserService extends IService<User> {
}
 
/*
IService接口里面有mybatis-plus封装好我们经常会用到的增删改查的一些方法
里面本质上还调用了上数据层mapper，是对mapper的封装优化
*/

构建service实现类(UserServiceImpl)

package com.example.jiu.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.jiu.entity.User;
import com.example.jiu.mapper.UserMapper;
import com.example.jiu.service.IUserService;
import org.springframework.stereotype.Service;
/*
 * 1.@Service--------使用@Service注解，让人知道这个是服务层
 * 2.extends ServiceImpl<UserMapper, User> ---继承和UserService类里面继承的方法一样，
 * 但是这里面继承了UserService自定义的方法
 * 3.implements IUserService---实现接口
 * */

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
    //登录业务
    //登录校验业务
    //创建用户检查业务等等
}

编写自己定义的UserService(UserService)

package com.example.jiu.service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.jiu.entity.User;
import com.example.jiu.mapper.UserMapper;
import org.springframework.stereotype.Service;

/*
 * 1.使用@Service注解，要不然咱自己定义的类，谁知道他是服务层
 * 2.继承ServiceImpl，这个是MP内置增删改查接口的一个实现，牛逼的是还能自定义直接调取数据层的数据
 * 3.定义需要的方法，根据自己的需要定义，定义MP内置里面没有的
 * */
@Service
public class UserService extends ServiceImpl<UserMapper, User> {
    //下面这个方法是对数据库操作时候多加了一层封装，用不到去掉也没有影响。
    // 、作用可以定义密码加密、数据校验、关联数据处理、日志记录、通知或触发事件等
    public boolean saveUser(User user){
        return saveOrUpdate(user);
    }
}

6.调用服务层（UserController）

package com.example.jiu.controller;

import com.example.jiu.entity.User;
import com.example.jiu.service.IUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
/*
 * 1·@RestController：这个注解告诉Spring该类是一个Controller，并且会自动将处理方法的返回值转换为HTTP响应。
 * 2·@RequestMapping：这个注解用于指定该Controller处理的URL路径的前缀。在这个例子中，所有与图书相关的请求都需要加上/books前缀。--- user代表默认访问路径在/user下可以访问
 * @GetMapping和@PostMapping：这些注解分别指定了处理HTTP GET和POST请求的方法。我们可以使用其他注解（如@PutMapping、@DeleteMapping等）来处理不同类型的请求。
 * */

@RestController//1
@RequestMapping("/user")//2
public class UserController {


    @Autowired  //3.自动注解
    private IUserService userService;  //4.定义调用服务层的接口
    /*
    *5.查询全部的数据
       5.1使用 @GetMapping注解，没有括号不定义就代表使用get方式，url访问上面默认路径/user
       5.2查询全部肯定使用的方法是集合<实体类>方式去自定义一个findAll方法名
       5.3再用服务层返回一个集合就好了
     */
    @GetMapping
    public List<User> findAll(){
        return userService.list();
    }


    /*6.根据id查询一条
      6.1查询使用@GetMapping注解，既然是根据id查询，那么就要把id传给后端。但是get是不能传递请求体的，
       只能传递请求头，那么只能把这个值放在请求头上面，就是这样("/{id}")放
      6.2自定义一个方法名(@PathVariable 类型 id),为什么要用id呢？这不是你前端这个"/{id}"说要吗
      @PathVariable这个注解的方式就是把请求头中的数字以Json传递给后端去识别，后端不能直接识别url上面的数字
      6.3 再用服务层返回获取id的方法就好了
    */
    @GetMapping("/{id}")
    public User findById(@PathVariable Integer id){
        return userService.getById(id);
    }

    /*7.新增和修改
         需要传递body传递全部参数，
        7.1对数据的操作使用@PostMapping，括号里面不定义就代表使用post方式，url访问上面默认路径/user
        7.2自定义一个方法，括号里面使用(@RequestBody 属性类 自定义属性昵称)
        为什么这里用Boolean而不是User，因为对数据的修改希望返回的结果就两种，要么成功，要么失败，所以用布尔值
        @RequestBody这个注解用于映射传递来的json参数映射为到java对象里面，特别是适用与请求体的参数
        7.3然后再用服务层返回获取的saveOrUpdate方法就好了
    */
    @PostMapping
    public Boolean add(@RequestBody User user){
        return userService.saveOrUpdate(user);
    }
    /*
    8.删除的方法
     8.1使用@DeleteMapping注解，因为删除只需要传递一个特定的id给后端就可以了，
     所以括号里面使用("/{id}")
     8.2创建一个自定义的方法，删除也是要么成功要么失败，所以使用Boolean作为返回值
     @PathVariable在上面已经解释过了
     8.3再用服务层次返回对应的方法，括号里面的值就是上面括号里面需要的值
    * */
    @DeleteMapping("/{id}")
    public Boolean delete(@PathVariable Integer id){
        return userService.removeById(id);
    }

}
/*    //修改数据的另一种写法
    @PostMapping("/update")
    public Boolean update(@RequestBody User user){
        return userService.updateById(user);
    }*/

1. @RestController：定义RESTful控制器

作用：标记类为RESTful风格的控制器，自动将返回值序列化为JSON。(相当于@Controller + @ResponseBody的组合，返回值默认序列化为JSON)

@RestController = @Controller + @ResponseBody，无需在方法上重复使用@ResponseBody。

@RestController
@RequestMapping("/users")
public class UserController {
    // 方法定义
}

2. HTTP方法映射注解(请求映射注解)

@GetMapping：处理HTTP GET请求，常用于查询操作。

@GetMapping("/{id}")
public User getUser(@PathVariable Long id) { /* 查询用户 */ }

@PostMapping：处理HTTP POST请求，常用于新增操作。

@PostMapping
public void addUser(@RequestBody User user) { /* 新增用户 */ }

@PutMapping：处理HTTP PUT请求，常用于修改操作。

@PutMapping("/{id}")
public void updateUser(@PathVariable Long id, @RequestBody User user) { /* 修改用户 */ }

@DeleteMapping：处理HTTP DELETE请求，常用于删除操作。

@DeleteMapping("/{id}")
public void deleteUser(@PathVariable Long id) { /* 删除用户 */ }

3. 参数绑定注解
@PathVariable：从URL路径中提取参数。

@GetMapping("/{id}")
public User getById(@PathVariable("id") Long userId) { /* ... */ }

@RequestParam：从查询参数中获取值，可设置默认值和是否必需。

@GetMapping("/search")
public List<User> search(@RequestParam("name") String name) { /* 按名称搜索 */ }

@RequestBody：将请求体中的JSON反序列化为Java对象（常用于POST/PUT）。

@PostMapping
public void createUser(@RequestBody User user) { /* 新增用户 */ }

7.QueryWrapper实现基础查询

QueryWrapper实现基础查询

eq( ) :  等于 =
ne( ) :  不等于 <> 或者 !=
gt( ) :  大于 >
ge( ) :  大于等于  >=
lt( ) :  小于 <
le( ) :  小于等于 <=
between ( ) :  BETWEEN 值1 AND 值2 
notBetween ( ) :  NOT BETWEEN 值1 AND 值2 
in( ) :  in
notIn( ) ：not in
like() : like 模糊查询，左右都加%
RightLike()  :只有右边加%
LeftLike():只有左边加%

QueryWrapper模糊查询like 

like("表列名","条件值"); 作用：查询包含关键字的信息，底层会自动添加匹配关键字，比如:%条件值%
likeLeft("表列名","条件值"); 作用：左侧模糊搜索，也就是查询以指定条件值结尾的数据，比如:%条件值
likeRight("表列名","条件值");作用：右侧模糊搜索，也就是查询以指定条件值开头的数据，比如:条件值%

QueryWrapper排序查询 

核心方法

• orderByAsc 升序排序，方法内可传入多个字段
• orderByDesc 降序排序，方法内可传入多个字段、

QueryWrapper限定字段查询

MP查询时，默认将表中所有字段数据映射查询，但是有时我们仅仅需要查询部分字段信息，这是可以使用select()方法限定返回的字段信息，避免I/O资源的浪费； 

mp是直接使用select方法的值进行拼接，这样一来就不会识别到realName成员变量的@TableFileld注解 

QueryWrapper限定字段查询

    @Test
    public void test09(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper
                .select("user_name as realName","email")
                .orderByDesc("age");
        List<User> users = userMapper.selectList(wrapper);
        System.out.println(users);
    }

 QueryWrapper实现分页条件查询

    @Test
    public void test10(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.ge("age",20)
                .orderByDesc("age");
        //构建分页对象
        IPage<User> page = new Page<>(2,2);
        userMapper.selectPage(page, wrapper);
        //获取当前页的对象
        List<User> users = page.getRecords();
        System.out.println(users);
        long pages = page.getPages();
    }

LambdaQueryWrapper查询

使用QueryWrapper开发存在的问题

• 使用QueryWrapper查询数据时需要手写对应表的列名信息，及其容易写错，开发体验不好；
• 使用QueryWrapper查询数据时，表的列名硬编码书写，后期一旦表结构更改，则会带来很大的修改工作量，维护性较差；

      @Test
      public void test11(){
          //直接new一个对象
          //LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
          //使用工具类生成一个对象
          LambdaQueryWrapper<User> wrapper = Wrappers.<User>lambdaQuery();
          //TODO:数据中的字段名通过类的成员变量名以及成员变量上的注解获取，解耦合
          wrapper.select(User::getRealName,User::getEmail)
                  .like(User::getRealName,"伤")
                  .eq(User::getPassword,"123456");
          List<User> users = userMapper.selectList(wrapper);
          System.out.println(users);
      }

  测试

  package com.example.jiu;
  
  import com.baomidou.mybatisplus.annotation.IdType;
  import com.baomidou.mybatisplus.annotation.TableField;
  import com.baomidou.mybatisplus.annotation.TableId;
  import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
  import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
  import com.baomidou.mybatisplus.core.metadata.IPage;
  import com.baomidou.mybatisplus.core.toolkit.Wrappers;
  import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
  import com.example.jiu.entity.User;
  import com.example.jiu.mapper.UserMapper;
  import com.example.jiu.service.UserService;
  import com.example.jiu.service.impl.UserServiceImpl;
  import io.swagger.annotations.ApiModelProperty;
  import jdk.internal.dynalink.beans.StaticClass;
  import org.junit.jupiter.api.Test;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.boot.test.context.SpringBootTest;
  
  import java.io.Serializable;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  @SpringBootTest
  class JiuApplicationTests {
  
      @Autowired
      private UserMapper userMapper;
      private UserService userService;
      @Test
      //插入功能
      public void testInsert(){
          User user=new User();
          user.setName("ll");
          user.setUsername("刘龙");
          user.setAge(25);
          user.setPassword("123456");
          user.setEmail("liulong@163.com");
          userMapper.insert(user);
      }
      @Test
      //@Build注解插入
      public void testInsert2(){
          User user1=User.builder()
                  .username("陈龙")
                  .email("153@qq.com")
                  .age(18)
                  .name("cl")
                  .password("123")
                  .build();
          int insert = userMapper.insert(user1);
          System.out.println(insert);
      }
  
      @Test
      //删除功能
      public void testdeleteById() {
          User user = new User();
          //1.根据id删除
          userMapper.deleteById(16);
          int i =userMapper.deleteById(17);
          // 2.根据id批量删除
          int j = userMapper.deleteBatchIds(Arrays.asList(10,12));
          //3.根据map构造条件，删除
          Map<String, Object> map = new HashMap<>();
          //delete from tb_user where user_name = ? and age = ?
          map.put("user_name","itcast");
          map.put("age","18");
  
          userMapper.deleteByMap(map);
          System.out.println(i);
          System.out.println(j);
      }
      @Test
      //修改，更新
      public void testUpdate(){
          User user=User.builder()
                  .id(2)
                  .password("1277")
                  .build();
          //根据主键id来修改数据库的信息，如果这个对象的成员变量值为null，就不修改数据库的字段名
          int i = userMapper.updateById(user);
          System.out.println(i);
      }
      @Test
      public void testSelect(){
          User user=new User();
          int page=2;
          int pageSize=4;
          //构建分页对象
          IPage<User> pageInfo =  new Page<>(page, pageSize);
          //pageInfo==userIPage-->true，这两个对象是同一个,地址相同
          //null为无条件查询
          IPage<User> userIPage = userMapper.selectPage(pageInfo, null);
          System.out.println(pageInfo==userIPage);
          //获取分页参数
          long total = userIPage.getTotal();//获取总记录数
          long pages = userIPage.getPages();//获取总页数
          long size = userIPage.getSize();//获取当前页大小
          long current = userIPage.getCurrent();//获取当前的页数
          List<User> users = userIPage.getRecords();//获取当前页的对象集合
          System.out.println(total);
          System.out.println(pages);
          System.out.println(size);
          System.out.println(current);
          System.out.println(users);
      }
  
      @Test
      //基础查询实现
      public void testLike(){
          //要求：查询用户中姓名包含"伤"，密码为"123456",且年龄为19或者25或者29，查询结果按照年龄降序排序；
          QueryWrapper<User> wrapper = new QueryWrapper<>();
          //设置查询条件
          //TODO:条件之间默认使用and关键字
          //第一个参数是数据库字段名
          wrapper.like("user_name","伤")
                  .eq("password","123456")
                  .in("age",Arrays.asList(19,25,29))
                  .orderByDesc("age");
          List<User> users = userMapper.selectList(wrapper);
          System.out.println(users);
  
      }
      @Test
      // OR查询
      public void testOR(){
          //"lisi"或者年龄大于29的用户信息；
          QueryWrapper<User> wrapper = new QueryWrapper<>();
          wrapper.eq("user_name","lisi")
                  .or()//使用or关键字关联条件，默认失and
                  .gt("age",29);
          List<User> users = userMapper.selectList(wrapper);
          System.out.println(users);
      }
      @Test
      // 左边模糊
      public void likeLeft(){
          QueryWrapper<User> wrapper = new QueryWrapper<>();
          wrapper.likeLeft("user_name","二");
          List<User> users = userMapper.selectList(wrapper);
          System.out.println(users);
      }
      @Test
      public void order(){
          QueryWrapper<User> wrapper = new QueryWrapper<>();
          wrapper
                  .select("user_name as realName","email")
                  .orderByDesc("age");
          List<User> users = userMapper.selectList(wrapper);
          System.out.println(users);
      }
      @Test
      //QueryWrapper实现分页条件查询
      public void pageOrder(){
          QueryWrapper<User> wrapper = new QueryWrapper<>();
          wrapper.ge("age",20)
                  .orderByDesc("age");
          //构建分页对象
          IPage<User> page = new Page<>(2,2);
          userMapper.selectPage(page, wrapper);
          //获取当前页的对象
          List<User> users = page.getRecords();
          System.out.println(users);
          long pages = page.getPages();
      }
      @Test
      public void  LambdaQuery(){
          //直接new一个对象
          LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
          //使用工具类生成一个对象
          //LambdaQueryWrapper<User> wrapper = Wrappers.<User>lambdaQuery();
          //TODO:数据中的字段名通过类的成员变量名以及成员变量上的注解获取，解耦合
          wrapper.select(User::getUsername,User::getEmail)
                  .like(User::getUsername,"伤")
                  .eq(User::getPassword,"123456");
          List<User> users = userMapper.selectList(wrapper);
          System.out.println(users);
      }
      @Test
      //LambdaQueryWrapper实现条件删除和更新操作
      public void  LambdaQueryUpdate(){
          //使用wrapper实现条件删除
          LambdaQueryWrapper<User> wrapper = Wrappers.<User>lambdaQuery().
                  eq(User::getUsername, "hhh");
          int delete = userMapper.delete(wrapper);
          System.out.println(delete);
      }
      @Test
      public void test13(){
          User user=User.builder()
                  .name("hhh")
                  .build();
          LambdaQueryWrapper<User> wrapper = Wrappers.<User>lambdaQuery().eq(User::getId, 1L);
          int update = userMapper.update(user, wrapper);
      }
      @Test
      //直接使用lambdaUpdate的set方法直接进行赋值
      public void test14(){
          //直接使用lambdaUpdate
          LambdaUpdateWrapper<User> wrapper = Wrappers.<User>lambdaUpdate()
                  .eq(User::getId, 1L)//更新条件
                  .set(User::getName, "aaa")
                  .set(User::getPassword, "1243");
          userMapper.update(null,wrapper);
  
      }
  
  }
  

  文章借鉴https://blog.csdn.net/m0_67296957/article/details/131723536     https://blog.csdn.net/luosuss/article/details/142706906