MybatisPlus

duration～2024-03-16 14:47

MybatisPlus

  • [1 MybatisPlus简介](#1 MybatisPlus简介)
    • [1.1 MybatisPlus概述](#1.1 MybatisPlus概述)
    • [1.2 MP愿景](#1.2 MP愿景)
    • [1.3 MP特性](#1.3 MP特性)
    • [1.4 开发MP版本](#1.4 开发MP版本)
  • [2 MP快速入门](#2 MP快速入门)
    • [2.1 MP入门流程分析](#2.1 MP入门流程分析)
    • [2.2 数据库环境准备](#2.2 数据库环境准备)
    • [2.3 创建工程，引入场景依赖](#2.3 创建工程，引入场景依赖)
    • [2.4 编写DataSource相关配置](#2.4 编写DataSource相关配置)
    • [2.5 编码](#2.5 编码)
    • [2.6 测试](#2.6 测试)
  • [3 MP实现常规增删改操作](#3 MP实现常规增删改操作)
    • [3.1 MP实现插入操作](#3.1 MP实现插入操作)
    • [3.2 MP主键字段注解-@TableId](#3.2 MP主键字段注解-@TableId)
    • [3.3 普通列注解-@TableField](#3.3 普通列注解-@TableField)
    • 3.4.MP实现删除操作
    • [3.5 MP实现更新操作](#3.5 MP实现更新操作)
  • 4.MP实现查询操作
    • [4.1 MP实现分页查询](#4.1 MP实现分页查询)
    • [4.2 QueryWrapper实现基础查询](#4.2 QueryWrapper实现基础查询)
    • [4.3 QueryWrapper逻辑查询or](#4.3 QueryWrapper逻辑查询or)
    • [4.4 QueryWrapper模糊查询like](#4.4 QueryWrapper模糊查询like)
    • [4.5 QueryWrapper排序查询](#4.5 QueryWrapper排序查询)
    • [4.6 QueryWrapper限定字段查询](#4.6 QueryWrapper限定字段查询)
    • [4.7 QueryWrapper实现分页条件查询](#4.7 QueryWrapper实现分页条件查询)
    • [4.8 LambdaQueryWrapper查询](#4.8 LambdaQueryWrapper查询)
    • [4.9 LambdaQueryWrapper实现删除和更新操作](#4.9 LambdaQueryWrapper实现删除和更新操作)
    • [4.10 自定义查询接口实现分页查询](#4.10 自定义查询接口实现分页查询)
  • [5 MP实现Service封装](#5 MP实现Service封装)
    • [5.1 MP封装Service介绍](#5.1 MP封装Service介绍)
    • [5.2 MP封装Service快速入门](#5.2 MP封装Service快速入门)
    • [5.3 MP封装Service实现CRUD操作](#5.3 MP封装Service实现CRUD操作)
  • [6 逻辑删除](#6 逻辑删除)
  • [7 乐观锁](#7 乐观锁)
  • [8 MP实现属性自动填充](#8 MP实现属性自动填充)

1 MybatisPlus简介

1.1 MybatisPlus概述

MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生（提供了快速使用mybatis的方式）。

官网：https://mybatis.plus/或 https://mp.baomidou.com/

1.2 MP愿景

MP愿景是成为 MyBatis 最好的搭档，就像 魂斗罗 中的 1P、2P，基友搭配，效率翻倍。

1.3 MP特性

  • 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
  • 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
  • 强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
  • 支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
  • 支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
  • 支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
  • 支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
  • 内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
  • 内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
  • 分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
  • 内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
  • 内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

1.4 开发MP版本

xml 复制代码 
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus</artifactId>
    <version>3.4.2</version>
</dependency>

2 MP快速入门

2.1 MP入门流程分析

SpringBoot 整合 MyBatis-Plus，并实现根据Id查询功能。

  1. 数据库环境准备
  2. 创建SpringBoot工程，引入MyBatisPlus场景依赖
  3. 在yml中编写DataSource相关配置
  4. 编写mapper
  5. 测试

2.2 数据库环境准备

sql 复制代码 
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for tb_user  没有给自增
-- ----------------------------
DROP TABLE IF EXISTS `tb_user`;
CREATE TABLE `tb_user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `user_name` varchar(255) DEFAULT NULL,
  `password` varchar(255) DEFAULT NULL,
  `name` varchar(255) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  `email` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- ----------------------------
-- Records of tb_user
-- ----------------------------
BEGIN;
INSERT INTO `tb_user` VALUES (1, '赵一伤', '123456', 'zys', 19, 'zys@qq.cn');
INSERT INTO `tb_user` VALUES (2, '钱二败', '123456', 'qes', 18, 'qes@qq.cn');
INSERT INTO `tb_user` VALUES (3, '孙三毁', '123456', 'ssh', 20, 'ssh@qq.cn');
INSERT INTO `tb_user` VALUES (4, '李四摧', '123456', 'lsc', 20, 'lsc@qq.cn');
INSERT INTO `tb_user` VALUES (5, '周五输', '123456', 'zws', 20, 'zws@qq.cn');
INSERT INTO `tb_user` VALUES (6, '吴六破', '123456', 'wlp', 21, 'wlp@qq.cn');
INSERT INTO `tb_user` VALUES (7, '郑七灭', '123456', 'zqm', 22, 'zqm@qq.cn');
INSERT INTO `tb_user` VALUES (8, '王八衰', '123456', 'wbs', 22, 'wbs@qq.cn');
INSERT INTO `tb_user` VALUES (9, '张无忌', '123456', 'zwj', 25, 'zwj@qq.cn');
INSERT INTO `tb_user` VALUES (10, '赵敏', '123456', 'zm', 26, 'zm@qq.cn');
INSERT INTO `tb_user` VALUES (11, '赵二伤', '123456', 'zes', 25, 'zes@qq.cn');
INSERT INTO `tb_user` VALUES (12, '赵三伤', '123456', 'zss1', 28, 'zss1@qq.cn');
INSERT INTO `tb_user` VALUES (13, '赵四伤', '123456', 'zss2', 29, 'zss2@qq.cn');
INSERT INTO `tb_user` VALUES (14, '赵五伤', '123456', 'zws', 39, 'zws@qq.cn');
INSERT INTO `tb_user` VALUES (15, '赵六伤', '123456', 'zls', 29, 'zls@qq.cn');
INSERT INTO `tb_user` VALUES (16, '赵七伤', '123456', 'zqs', 39, 'zqs@qq.cn');
COMMIT;

SET FOREIGN_KEY_CHECKS = 1;

2.3 创建工程，引入场景依赖

xml 复制代码 
<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.3.10.RELEASE</version>
  <relativePath/> <!-- lookup parent from repository -->
</parent>

<properties>
  <java.version>1.8</java.version>
</properties>

<dependencies>
  <!-- mysql  驱动-->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
  </dependency>
  <!-- lombok  ,自动生成get,Set 方法-->
  <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>
  <!--mybatisplus起步依赖-->
  <dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.2</version>
  </dependency>
</dependencies>

2.4 编写DataSource相关配置

yaml 复制代码 
#datasource
spring:
  datasource:
    url: jdbc:mysql://192.168.200.150:3306/mp?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver

说明：如果想在mybatis-plus自行是看打印的sql，可配置：

yaml 复制代码 
#mybatis-plus配置控制台打印完整带参数SQL语句
mybatis-plus:
	configuration:
		log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

2.5 编码

实体类：

java 复制代码 
package com.shen.sh.pojo;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

/**
 * @Description:
 * @Version: V1.0
 */
@TableName("tb_user") // 指定表名
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class User {
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email;
}

@TableName("tb_user") : 如果数据库的表名和实体类一致时可以省略

编写mapper：

java 复制代码 
package com.shen.sh.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.shen.sh.pojo.User;
/**
 * 使用mp定义Mapper，需要让Mapper接口继承 BaseMapper接口。
 */
public interface UserMapper extends BaseMapper<User> {
    
}

启动类增加 @MapperScan 注解

java 复制代码 
package com.shen.sh;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.shen.sh.mapper")
public class MpApplication {
    public static void main(String[] args) {
        SpringApplication.run(MpApplication.class, args);
    }
}

2.6 测试

java 复制代码 
package com.shen.sh;

import com.shen.sh.mapper.UserMapper;
import com.shen.sh.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class UserMapperTest {

    @Autowired
    private UserMapper userMapper;
    /**
     * 根据id查询
     */
    @Test
    public void testSelectById() { 
        User user = userMapper.selectById(1L);
        System.out.println(user);
    }
}

3 MP实现常规增删改操作

通过查看BaseMapper源码，我们发现该接口几乎定义了所有常规的增删改查操作：

3.1 MP实现插入操作

BaseMapper定义操作方法

注意事项：

1.如果主键对应的实体类属性中没有设置主键的生成策略，那么MP自动为主键生成值，且回填到实体对象下；

2.如果未指定主键生成策略，即使表的主键是主键自增，也不会使用主键自增；

代码测试

java 复制代码 
@Test
public void testInsert() {
  User user =
    User.builder() 
    .userName("shen")
    .name("qq")
    .age(15)
    .email("qq@qq.cn")
    .password("111111")
    .build();
  int insert = userMapper.insert(user);
  System.out.println(insert);
}

插入数据时，我们发现表中ID设置默认自增，但是实际生成的id却是很长串的数字？

3.2 MP主键字段注解-@TableId

注解@TableId介绍

@TableId注解作用：

  1. 映射表中主键字段与实体类属性的关系（尤其表中主键字段名称与实体类属性名称不一致时）；
  2. 定义主键生成策略；

@TableId使用：

添加在实体类的主键对应的成员属性上即可；

java 复制代码 
@TableName("tb_user") // 指定表名
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class User {
    @TableId(value="id")//字段不一致时，通过value值指定table中主键字段名称
    private Long userId;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email;
}

MP主键生成策略介绍

主键生成策略:

是指为数据库生成主键的方式，我们前面学的数据库主键自增也是一种生成主键的策略，当然除了数据库服务端帮助我们维护主键之外，客户端也可以对主键值进行生成维护。

MP主键生成策略示例：

java 复制代码 
//指定主键自增的生成策略
@TableId(value = "user_id",type = IdType.AUTO)
private Integet userId;

MP常用主键生成策略

MP提供的常用主键生成策略如下：

生成策略 应用场景 特点
IdType.AUTO 数据库主键自增(确保数据库设置了 主键自增 否则无效) 1.使用数据库自带的主键自增值； 2.数据库自增的主键值会回填到实体类中； 3.数据库服务端生成的；
IdType.ASSIGN_ID 主键类型为number类型或数字类型String 1.MP客户端生成的主键值； 2.生成的主键值是数字形式的字符串 3.主键对应的类型可以是数字类型或者数字类型的字符串 4.底层基于雪花算法，让数据库的唯一标识也参与id的生成运算，保证id在分布式环境下，全局唯一（避免id的主键冲突问题）；
IdType.ASSIGN_UUID 主键类型为 string（包含数字和字母组成） 1.生成的主键值包含数字和字母组成的字符串； 2.注意事项：如果数据库中主键值是number类型的，可不可用

雪花算法

通过翻阅源码，我们发现IdType.ASSIGN_ID底层基于雪花算法保证主键ID的唯一性：

说明：生成ID的过程让时间戳、数据库服务器标识、序列化号等参与运算，保证分布式环境下ID的唯一性，避免主键冲突；

雪花算法：说白了就是指定在那个机房（机房id）的那台机器（机器的id）在什么时间点（时间戳）下生成的，如果同一台机器存在并发生成主键值，则序列号参（并发的版本号）数运算；

3.3 普通列注解-@TableField

注解@TableField作用

注解@TableField作用：

  • 指定表中普通字段与实体类属性之间的映射关系；
  • 忽略实体类中多余属性与表中字段的映射关系(@TableField(exist = false))；

以下情况可以省略：

  • 名称一样
  • 数据库字段使用_分割，实体类属性名使用驼峰名称（自动开启驼峰映射）

代码示例

java 复制代码 
/**
 * 实体类的属性名和数据库的字段名自动映射：
 *  1. 名称一样
 *  2. 数据库字段使用_分割，实体类属性名使用驼峰名称
 */

@TableName("tb_user")
@Data
public class User {
    //设置id生成策略:AUTO 数据库自增
    @TableId(type = IdType.AUTO)
    private Long id;
    //@TableField("user_name")
    private String userName;

    private String password;
  
    @TableField("t_name")
    private String name;
    private Integer age;
    private String email;
    //增删改查操作时，忽略该属性
    @TableField(exist = false)
    private String address;
}

3.4.MP实现删除操作

BaseMaper定义的常用删除方法：

根据id删除

java 复制代码 
 int count = userMapper.deleteById(8L);

根据id集合批量删除

java 复制代码 
 List ids = new ArrayList();
        ids.add(6);
        ids.add(7);
userMapper.deleteBatchIds(ids);

根据map构造条件，删除

java 复制代码 
Map<String, Object> map = new HashMap<>();

//delete from tb_user where user_name = ? and age = ?
map.put("user_name","qq");
map.put("age","18");

userMapper.deleteByMap(map);

3.5 MP实现更新操作

根据实体对象中的id更新数据

注意事项：只更新实体类中存在的数据，如果对应的属性为null，不更新；

java 复制代码 
@Test
public void testUpdateById() {
  User user = new User();
  user.setId(2L);
  user.setPassword("1111111");
  int count = userMapper.updateById(user);
}

4.MP实现查询操作

MP查询API概览：

4.1 MP实现分页查询

配置分页拦截器

java 复制代码 
package com.shen.sh.config;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Description:
 * @Version: V1.0
 */
@Configuration
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        PaginationInnerInterceptor paginationInterceptor = new PaginationInnerInterceptor(DbType.MYSQL);
        // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求  默认false
        // paginationInterceptor.setOverflow(false);
        // 设置最大单页限制数量，-1不受限制
        paginationInterceptor.setMaxLimit(-1L);
        interceptor.addInnerInterceptor(paginationInterceptor);
        return interceptor;
    } 
}

查询测试

java 复制代码 
/**
  * 分页查询：
  *  1. 当前页码：currentPage
  *  2. 每页显示条数：size
  *
  *  注意：使用mp的分页要设置一个拦截器！！！
*/
@Test
public void testSelectPage() {
  int current = 1;//当前页码
  int size = 2;//每页显示条数
  IPage<User> page = new Page(current,size);
  userMapper.selectPage(page,null);
  List<User> records = page.getRecords();//当前页的数据
  long pages = page.getPages();//总页数 2
  long total = page.getTotal();//总记录数 4
  System.out.println(records);
  System.out.println(pages);
  System.out.println(total);
}

4.2 QueryWrapper实现基础查询

java 复制代码 
/**
 * 基础比较查询
 * Wrapper接口:
 *  1.QueryWrapper
 *    LambdaQueryWrapper //查询
 *  2.UpdateWrapper
 *    LambdaUpdateWrapper //更新
 */

QueryWrapper常用API

text 复制代码 
eq( ) :  等于 =
ne( ) :  不等于 <> 或者 !=
gt( ) :  大于 >
ge( ) :  大于等于  >=
lt( ) :  小于 <
le( ) :  小于等于 <=
between ( ) :  BETWEEN 值1 AND 值2 
notBetween ( ) :  NOT BETWEEN 值1 AND 值2 
in( ) :  in
notIn( ) ：not in

sql中反向查询eg:not like != 等等，查询时是不会走索引的；

查询实现

要求：查询用户中姓名包含"伤"，密码为"123456",且年龄为19或者25或者29，查询结果按照年龄降序排序；

java 复制代码 
    /**
     * @Description 测试条件查询
     * 要求：查询用户中姓名包含"伤"，密码为"123456",且年龄为19或者25或者29，查询结果按照年龄降序排序；
     * 如果查询的条件过于复杂，mp还适合么？
     *        简单的操作，直接使用mp
     *        但是非常复杂的操作，比如多表关联查询 复杂条件查询等，建议使用xml下sql实现；
     */
    @Test
    public void testcQuery1(){
        //构建添加包装对象
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //设置条件
        wrapper.like("user_name","伤")
                .eq("password","123456")
//                .in("age",19,25,29)
                .in("age",Arrays.asList(19,25,29))
                .orderByDesc("age");
        //查询
        /*
        ==> Preparing: SELECT id,user_name,password,name,age,email FROM tb_user WHERE (user_name LIKE ? AND password = ? AND age IN (?,?,?)) ORDER BY age DESC
        ==> Parameters: %伤%(String), 123456(String), 19(Integer), 25(Integer), 29(Integer)
         */
        List<User> users = userMapper.selectList(wrapper);
        System.out.println(users);
    }

4.3 QueryWrapper逻辑查询or

OR查询说明

  1. 通过QueryWrapper多条件查询时，默认使用and关键字拼接SQL;
  2. 通过QueryWrapper调用or()方法时，底层会使用or关键字拼接方法左右的查询条件;

代码示例

业务要求：查询用户名为"lisi"或者年龄大于23的用户信息；

java 复制代码 
@Test
public void testWrapper2(){
    //1.创建查询条件构建器
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //2.设置条件
    wrapper.eq("user_name","lisi")
        .or()
        .lt("age",23);
    /*
       select * from tb_user where user_name = ? or age < ? 
    */
    List<User> users = userMapper.selectList(wrapper);
    System.out.println(users);
}

4.4 QueryWrapper模糊查询like

模糊查询常用方法

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

代码演示

java 复制代码 
	/**
     * 模糊查询
     */
    @Test
    public void testWrapper3(){
        //1.创建查询条件构建器
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //2.设置条件
        wrapper.likeLeft("user_name","zhang");
        /*
            SELECT id,user_name,password,name,age,email
             from tb_user
             where user_name like ?
             %zhang
         */
        List<User> users = userMapper.selectList(wrapper);
        System.out.println(users);
    }

4.5 QueryWrapper排序查询

核心方法

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

代码实现

需求：先根据age升序排序，如果年龄相同则按照id降序排序；

java 复制代码 
@Test
    public void testWrapper4(){
        //1.创建查询条件构建器
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //2.设置条件
        wrapper.eq("user_name","lisi")
                .or()
                .lt("age",23)
                .in("name","李四","王五")
                //.orderBy(true,true,"age")
                .orderByDesc("age");
        /*
            select * from tb_user where user_name = ? or age < ? and name in (?,?) order by age asc
         */
        List<User> users = userMapper.selectList(wrapper);
        System.out.println(users);
    }

4.6 QueryWrapper限定字段查询

select方法说明

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

示例：

java 复制代码 
wrapper.select("字段1","字段2",......)

代码示例

java 复制代码 
@Test
    public void testWrapper5(){
        //1.创建查询条件构建器
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //2.设置条件
        wrapper.eq("user_name","lisi")
                .or()
                .lt("age",23)
                .in("name","李四","王五")
                //.orderBy(true,true,"age")
                .orderByDesc("age")
                .select("id","user_name");
        /*
            select id,user_name from tb_user where user_name = ? or age < ? and name in (?,?) order by age asc
         */
        List<User> users = userMapper.selectList(wrapper);
        System.out.println(users);
    }

4.7 QueryWrapper实现分页条件查询

方法说明

java 复制代码 
//参数1：分页对象
//参数2：查询条件
mapper.selectPage(page,wrapper);

代码实现

需求：查询年龄大于23的用户信息，并显示第2页，每页大小为3；

java 复制代码 
	@Test
    public void testWrapper6(){
        int current = 1;//当前页码
        int size = 2;//每页显示条数
        //1. 构建分页对象
        Page<User> page = new Page<>(current,size);
        //2. 构建条件对象
        QueryWrapper<User> wrapper = new QueryWrapper();
        wrapper.lt("age",23);
        userMapper.selectPage(page,wrapper);
        List<User> records = page.getRecords();
        long total = page.getTotal();
        long pages = page.getPages();
        System.out.println(records);
        System.out.println(total);//2
        System.out.println(pages);//1
    }

4.8 LambdaQueryWrapper查询

使用QueryWrapper开发存在的问题

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

LambdaQueryWrapper可以解决上述出现问题，开发推荐使用；

代码实现

java 复制代码 
@Test
public void testWrapper4() throws Exception{
  // LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
  LambdaQueryWrapper<User> wrapper = Wrappers.<User>lambdaQuery();

  //        wrapper.like("user_name", "%伤%")
  //                .eq("password","123456")
  //                .ge("age", 28)
  //                .between("age",29 , 39);  // 包含边界值
  wrapper.like(User::getUserName, "%伤%")
    .eq(User::getPassword, "123456")
    .ge(User::getAge, 28)
    .between(User::getAge, 29, 39)
    .orderByDesc(User::getAge)
    .select(User::getId, User::getUserName);
  List<User> users = userMapper.selectList(wrapper);
  System.out.println(users);
}

4.9 LambdaQueryWrapper实现删除和更新操作

条件删除

java 复制代码 
/**
     * 条件删除
     * @throws Exception
*/
@Test
public void testWrapper5() throws Exception{

  LambdaQueryWrapper<User> wrapper = Wrappers.<User>lambdaQuery().eq(User::getUserName, "武大郎");
  int i = userMapper.delete(wrapper);
  System.out.println(i);
}

条件更新

java 复制代码 
/**
     * 条件更新
     * @throws Exception
*/
@Test
public void testWrapper6() throws Exception{

  /**
     * UPDATE tb_user SET t_name=? WHERE (id = ?)
     */
  // 参数1： 最新的值
  User user = new User();
  user.setUserName("张三丰");

  // 参数2：更新时条件
  LambdaQueryWrapper<User> wrapper = Wrappers.<User>lambdaQuery();
  wrapper.eq(User::getId, 15);

  int update = userMapper.update(user, wrapper);
  System.out.println(update);
}


/**
     * 条件更新
     * @throws Exception
     */
@Test
public void testWrapper7() throws Exception{
  /**
         * UPDATE tb_user SET t_name=?, user_name=? WHERE (id = ?)
         */
  // 参数1： 最新的值
  // 参数2：更新时条件
  LambdaUpdateWrapper<User> wrapper = Wrappers.<User>lambdaUpdate();
  wrapper.eq(User::getId, 15)
    .set(User::getUserName, "张三丰666")
    .set(User::getName,"zsf666");

  int update = userMapper.update(null, wrapper);
  System.out.println(update);
}

4.10 自定义查询接口实现分页查询

说明

目前我们使用MP自带的分页插件可以很友好的实现分页查询操作，但是如果一些查询需要我们自定义SQL,那该如何实现分页查询操作呢？

实现流程

  • 自定义接口中直接传入Page分页对象即可；
java 复制代码 
package com.shen.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.shen.pojo.User;
import org.apache.ibatis.annotations.Param;

import java.util.List;

/**
 * @Description 定义mapper接口
 * @Created by shen
 */
//@Mapper
public interface UserMapper extends BaseMapper<User> {
/**
 * 查询大于指定id的用户信息，并分页查询实现
 * @param page
 * @param id
 * @return
 */
IPage<User> findGtIdByPage(IPage<User> page, @Param("id") Long id);
}
  • 定义xml映射文件
xml 复制代码 
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.shen.mapper.UserMapper">

<select id="findGtIdByPage" resultType="com.shen.pojo.User">
select * from tb_user where id > #{id}
</select>
</mapper>
  • 测试
java 复制代码 
/**
 * @Description 自定义sql分页查询实现
 */
@Test
public void test19(){
IPage<User> page=new Page<>(2,3);
IPage<User> users = userMapper.findGtIdByPage(page, 3l);
System.out.println(users.getRecords());
System.out.println(user.getPages());
System.out.println(user.getTotal());
}

5 MP实现Service封装

5.1 MP封装Service介绍

说明

MybatisPlus为了开发更加快捷，对业务层也进行了封装，直接提供了相关的接口和实现类;

我们在进行业务层开发时，可以继承它提供的接口和实现类，使得编码更加高效;

实现流程

  1. 定义一个服务扩展接口,该接口继承公共接口IService;
  2. 定义一个服务实现类，该类继承ServiceImpl<Mapper，Entity>,并实现自定义的扩展接口;

注意事项：

1.ServiceImpl父类已经注入了UserMapper对象，名称叫做baseMapper，所以当前实现类直接可以使用baseMapper完成操作

2.因为ServiceImpl已经实现了IService下的方法，所以当前服务类没有必要再次实现

思想：共性的业务代码交给框架封装维护，非共性的业务，在接口UserService定义，然后在当前的服务类下实现；

核心API介绍

5.2 MP封装Service快速入门

代码实现：

定义服务扩展接口

java 复制代码 
//在公共接口的基础上扩展
public interface UserService extends IService<User> {
}

定义服务实现

java 复制代码 
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {}

测试测试

java 复制代码 
package com.shen;

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.itheima.mapper.UserMapper;
import com.itheima.pojo.User;
import com.itheima.service.UserService;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.omg.PortableInterceptor.USER_EXCEPTION;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

/**
 * @Description
 * @Created by shen
 */
@SpringBootTest
public class MpTestService {
    @Autowired
    private UserService userService;

    /**
     * @Description 测试查询操作 根据id查询
     */
    @Test
    public void test1(){
        User user = userService.getById(3l);
        System.out.println(user);
    }
}

5.3 MP封装Service实现CRUD操作

服务层API的封装大致与持久层一致：

java 复制代码 
    /**
     * @Description 测试条件查询，且仅返回一个
     * getOne:sql查询的结果必须为1条或者没有，否则报错 ！！！！
     */
    @Test
    public void test2(){
        LambdaQueryWrapper<User> wrapper = Wrappers.lambdaQuery(User.class);
        wrapper.gt(User::getAge,20);
        User one = userService.getOne(wrapper);
        System.out.println(one);
    }

    /**
     * @Description 根据条件批量查询
     */
    @Test
    public void test3(){
        LambdaQueryWrapper<User> wrapper = Wrappers.lambdaQuery(User.class);
        wrapper.gt(User::getAge,20);
        List<User> list = userService.list(wrapper);
        System.out.println(list);
    }

    /**
     * @Description 根据条件批量查询并分页
     */
    @Test
    public void test4(){
        LambdaQueryWrapper<User> wrapper = Wrappers.lambdaQuery(User.class);
        wrapper.gt(User::getAge,20);
        //构建分页对象
        IPage<User> page=new Page<>(2,3);
        userService.page(page,wrapper);
        System.out.println(page.getRecords());
        System.out.println(page.getPages());
        System.out.println(page.getTotal());
    }

    /**
     * @Description 测试服务层save保存单条操作
     */
    @Test
    public void test5(){
        User user1 = User.builder().name("wangwu").userName("laowang4").
                email("444@163.com").age(20).password("333").build();
        boolean isSuccess = userService.save(user1);
        System.out.println(isSuccess?"保存成功":"保存失败");
    }

    /**
     * @Description 测试服务层批量保存
     */
    @Test
    public void test6(){
        User user2 = User.builder().name("wangwu2").userName("laowang2").
                email("444@163.com").age(20).password("333").build();
        User user3 = User.builder().name("wangwu3").userName("laowang3").
                email("444@163.com").age(20).password("333").build();
        boolean isSuccess = userService.saveBatch(Arrays.asList(user2, user3));
        System.out.println(isSuccess?"保存成功":"保存失败");
    }
    
    /**
     * @Description 根据id删除操作
     */
    @Test
    public void test7(){
        boolean isSuccess = userService.removeById(17l);
        System.out.println(isSuccess?"保存成功":"保存失败");
    }

    /**
     * @Description 根据条件批量删除
     */
    @Test
    public void test8(){
        LambdaQueryWrapper<User> wrapper = Wrappers.lambdaQuery(User.class);
        wrapper.gt(User::getId,12)
                .gt(User::getAge,20);
        boolean remove = userService.remove(wrapper);
        System.out.println(remove);
    }

    /**
     * @Description 测试根据id更新数据
     */
    @Test
    public void test9(){
        //UPDATE tb_user SET password=?, t_name=? WHERE id=?
        User user2 = User.builder().name("wangwu2").password("333").id(3l).build();
        boolean success = userService.updateById(user2);
        System.out.println(success);
    }

    /**
     * @Description 测试根据条件批量更新
     */
    @Test
    public void test10(){
        LambdaUpdateWrapper<User> wrapper = Wrappers.lambdaUpdate(User.class);
        //UPDATE tb_user SET age=? WHERE (id IN (?,?,?))
        wrapper.in(User::getId,Arrays.asList(1l,3l,5l)).set(User::getAge,40);
        boolean update = userService.update(wrapper);
        System.out.println(userService);
    }

6 逻辑删除

实际在删除数据时，为了数据留痕，一般选择逻辑删除，也就是为删除表添加逻辑删除字段，通过修改字段状态值来表示数据是否被删除；

案例：

为tb_user添加逻辑删除字段：

mp配置：

yaml 复制代码 
# 设置mp运行时行为
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 控制台输出sql
  global-config:
    db-config:
      logic-delete-field: deleted # 约定全局删除字段
      logic-delete-value: 1
      logic-not-delete-value: 0

调整实体类：

java 复制代码 
@Data
@NoArgsConstructor//主要用于mybatis底层反射构建user实体类对象
@AllArgsConstructor//主要是lombok基于构建者模式构建对象
@Builder
/**
 * 如果变的名称与实体类名称一致，该注解可省略
 */
@TableName("tb_user")
public class User {
	//......
    @TableLogic//指定逻辑删除字段
    private Integer deleted;
}

测试

java 复制代码 
    @Test
    public void testDelete(){
        //根据id删除
        int count = userMapper.deleteById(15l);
        System.out.println(count);
    }

输出的效果：

但是对应的查询如果不加添加，则删除的无法查询到：

java 复制代码 
    @Test
    public void testGetById(){
        User user = userMapper.selectById(15l);
        System.out.println(user);
    }

效果：

逻辑删除本质就是拦截sql，动态追加sql片段

​查询 deleted=0

删除： 将sql转化成update操作；

7 乐观锁

乐观锁就是当前操作者认为在自己操作资源的过程中，其他人操作相同资源的可能性极低，所以无需加锁，而是通过设置一个版本号来加以约束；

悲观锁：排它锁，比如synchronized关键字就是悲观锁，当前线程做操作时，不允许其它线程做操作；

乐观锁：当前线程做操作时，允许其它线程做操作，但是如果其它线程做了操作，则当前操作失败；

乐观锁在数据库中有什么优势？

​ 避免长事务场景锁定数据资源，导致其它线程操作该资源时阻塞，如果阻塞过多，那么导致数据库连接资源耗尽，进而数据库宕机了；

​ 本质上就是在操作前，先获取操作行的version版本号，然后再做前天操作，然后最后再更新这一行，更新时，给sql条件一个判断版本号的sql片段： select version，xxx from user where id=100; version=30 --> 做其他操作(20s);---> update user set xxx,version=version+1 where xxxx and version=30;

使用场景：

​ 1.业务操作周期长，如果业务整个加入事务，导致数据库资源锁定周期过长，性能降低；

​ 2.如果资源争抢过于激烈，会导致失败重试次数过多，导致性能降低；

示例：

实体类配置：

java 复制代码 
@Data
@NoArgsConstructor//主要用于mybatis底层反射构建user实体类对象
@AllArgsConstructor//主要是lombok基于构建者模式构建对象
@Builder
/**
 * 如果变的名称与实体类名称一致，该注解可省略
 */
@TableName("tb_user")
public class User {
	//......
    @Version
    private Integer version;
}

配置乐观锁拦截器：

java 复制代码 
    /**
     * 注册插件
     * @return
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        //构建mp的插件注册器bean，通过该bean可批量注册多个插件
        MybatisPlusInterceptor plusInterceptor = new MybatisPlusInterceptor();
        //配置乐观锁拦截器
        OptimisticLockerInnerInterceptor optimisticLockerInnerInterceptor = new OptimisticLockerInnerInterceptor();
        //注册
        plusInterceptor.addInnerInterceptor(optimisticLockerInnerInterceptor);
        return plusInterceptor;
    }

测试：

java 复制代码 
    /**
     * @Description 测试乐观锁
     */
    @Test
    public void testOp(){
        User user = userMapper.selectById(5l);
        System.out.println(user);
        user.setName("zws777");
        userMapper.updateById(user);
    }

使用mp的乐观锁，需要先自己根据主键id查询用户信息，信息中包含了此时的version数据，然后再更新，更新时会将查询的version值作为更新条件取更新；

效果：

8 MP实现属性自动填充

在插入和更新数据时，我们会写大量重复的代码去设置更新时间和创建时间。而MP则将这一点进行了考虑帮我们实现了。当然自己通过自定义注解和AOP的方式也可以实现这一功能。

自动填充是 MyBatis-Plus 提供的一个功能，它允许你在插入或更新记录时自动填充某些字段，例如自动设置创建时间或更新时间字段。这个功能特别适用于那些几乎在每个业务中都需要的公共字段，比如创建时间、修改时间、操作人等。

如何使用自动填充

要在 MyBatis-Plus 中使用自动填充，你需要进行几个步骤的设置：

  1. 定义字段：在你的实体类中，定义需要自动填充的字段。

  2. 使用注解标记字段 ：使用 @TableField 注解标记这些字段，并指定 fill 属性。例如，对于一个需要自动填充创建时间和更新时间的字段，你可以这样做：

    java 复制代码 
    import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.FieldFill;
import java.time.LocalDateTime;

public class YourEntity {
    // 其他字段...

    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createTime;

    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime updateTime;
}

    这里 createTime 在插入时自动填充，而 updateTime 在插入和更新时都会自动填充。

  3. 实现 MetaObjectHandler 接口 ：你需要创建一个类来实现 MetaObjectHandler 接口，并在这个类中重写 insertFill 和 updateFill 方法来指定自动填充的逻辑。

    java 复制代码 
    import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    @Override
    public void insertFill(MetaObject metaObject) {
        this.strictInsertFill(metaObject, "createTime", LocalDateTime.class, LocalDateTime.now()); // 起名createTime
        this.strictInsertFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());
    }
}

原理

MyBatis-Plus 实现自动填充的原理是基于 MyBatis 的拦截器（Interceptor）机制。当执行插入或更新操作时，MyBatis-Plus 会拦截这些操作，在 SQL 执行之前，根据你的配置调用 MetaObjectHandler 中相应的方法来自动填充指定的字段。

  • 拦截操作：MyBatis 允许通过插件（Plugin）机制拦截对数据库操作的调用，MyBatis-Plus 利用这一机制来实现自动填充功能。
  • 反射设置值 ：通过 MyBatis 提供的 MetaObject 对象，MyBatis-Plus 可以反射地访问和修改实体对象的属性，从而实现在 SQL 执行前自动填充指定字段的值。

这个过程大致如下：

  1. 在执行插入或更新前，MyBatis-Plus 的自动填充拦截器会被触发。
  2. 拦截器调用 MyMetaObjectHandler 实现类中的 insertFill 或 updateFill 方法。
  3. 在这些方法中，你定义了自动填充字段的逻辑，比如为 createTime 或 updateTime 设置当前时间。
  4. 这些值随后被设置到用户的实体对象中，并随着 SQL 的执行被插入或更新到数据库中。

通过这种方式，MyBatis-Plus 简化了数据持久层的开发工作，让开发者可以更专注于业务逻辑的实现。

通过AOP加上自定义注解的方式实现

引入依赖：

xml 复制代码 
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
</dependency>

自定义操作类型：

java 复制代码 
/**
 * 数据库操作类型
 */
public enum OperationType {

    /**
     * 更新操作
     */
    UPDATE,

    /**
     * 插入操作
     */
    INSERT

}

ThreadLocal存储登录对象的用户id。

java 复制代码 
public class BaseContext {

    public static ThreadLocal<Long> threadLocal = new ThreadLocal<>();

    public static void setCurrentId(Long id) {
        threadLocal.set(id);
    }

    public static Long getCurrentId() {
        return threadLocal.get();
    }

    public static void removeCurrentId() {
        threadLocal.remove();
    }

}

公共填充字段相关常亮。

java 复制代码 
/**
 * 公共字段自动填充相关常量
 */
public class AutoFillConstant {
    /**
     * 实体类中的方法名称
     */
    public static final String SET_CREATE_TIME = "setCreateTime";
    public static final String SET_UPDATE_TIME = "setUpdateTime";
    public static final String SET_CREATE_USER = "setCreateUser";
    public static final String SET_UPDATE_USER = "setUpdateUser";
}

自定义注解

java 复制代码 
import com.shen.enumeration.OperationType;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 自定义注解，用于标识某个方法需要进行功能字段自动填充处理
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AutoFill {
    //数据库操作类型，Update，Insert
    OperationType value();
}

切面编程

java 复制代码 
import com.shen.annotation.AutoFill;
import com.shen.constant.AutoFillConstant;
import com.shen.context.BaseContext;
import com.shen.enumeration.OperationType;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.time.LocalDateTime;

/**
 * 自定义切面，实现公共字段自动填充处理的逻辑
 */
@Aspect
@Component
@Slf4j
public class AutoFillAspect {
    /**
     * 切入点
     */
    @Pointcut("execution(* com.sky.mapper.*.*(..)) && @annotation(com.sky.annotation.AutoFill)")
    public void autoFillPointCut() {
    }

    /**
     * 前置通知，在通知中进行公共字段的赋值
     */
    @Before("autoFillPointCut()")
    public void autoFill(JoinPoint joinPoint) {
        log.info("开始进行公共字段自动填充....");
        //获取当前被拦截的方法上的数据库操作类型
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();//方法签名对象
        AutoFill autoFill = signature.getMethod().getAnnotation(AutoFill.class);//获取方法上的注解对象
        OperationType operationType = autoFill.value();//获取数据库的操作类行
        //获取当前被拦截的方法的参数--实体对象
        Object[] args = joinPoint.getArgs();
        if (args == null || args.length == 0) {
            return;
        }
        Object entity = args[0];
        //准备赋值的数据
        LocalDateTime now = LocalDateTime.now();
        Long currentId = BaseContext.getCurrentId();

        //根据当前不同的操作类型，为对应的属性通过反射来赋值
        if (operationType == OperationType.INSERT) {
            //为四个公共字段赋值
            try {
                Method setCreateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_CREATE_TIME, LocalDateTime.class);
                Method setCreateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_CREATE_USER, Long.class);
                Method setUpdateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class);
                Method setUpdateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class);
                //通过反射对对象赋值
                setCreateTime.invoke(entity, now);
                setCreateUser.invoke(entity, currentId);
                setUpdateTime.invoke(entity, now);
                setUpdateUser.invoke(entity, currentId);
            } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
                e.printStackTrace();
            }

        } else if (operationType == OperationType.UPDATE) {

            try {
                Method setUpdateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class);
                Method setUpdateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class);
                setUpdateTime.invoke(entity, now);
                setUpdateUser.invoke(entity, currentId);
            } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
                e.printStackTrace();
            }
        }

    }
}

在mapper层直接使用就OK了

java 复制代码 
    /**
     * 根据id修改分类
     * @param category
     */
    @AutoFill(value = OperationType.UPDATE)
    void update(Category category);
相关推荐
꧁惜若༒奔已꧂12 小时前
spring使用xml文件整合事务+druid+mybatis
xml·spring·mybatis
小桥流水人家jjh15 小时前
Mybatis执行自定义SQL并使用PageHelper进行分页
java·数据库·spring boot·sql·mybatis
黑马师兄16 小时前
Mybatis
java·mybatis
Neoest1 天前
场景解决之mybatis当中resultType= map时,因某个字段为null导致返回的map的key不存在怎么处理
mybatis
ZWZhangYu2 天前
【MyBatis源码】深入分析TypeHandler原理和源码
数据库·oracle·mybatis
小鸡脚来咯2 天前
springboot 整合mybatis
java·spring boot·mybatis
种树人202408192 天前
MyBatis xml 文件中 SQL 语句的小于号未转义导致报错
mybatis
码农派大星。2 天前
MyBatis操作--进阶
mybatis
爱读源码的大都督3 天前
MyBatis中的LanguageDriver的作用是什么
java·spring boot·mybatis
鹿屿二向箔3 天前
基于SSM（Spring + Spring MVC + MyBatis）框架的快递管理系统
spring·mvc·mybatis
热门推荐
01软件工程从理论到实践客观题汇总(头歌第一章至第八章)02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04VSCode插件 —— Cody AI （免费AI助手！）05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06Windows10安装PCL1.14.0及点云配准07【QuikGraph】C#调用第三方库实现迪杰斯特拉(Dijkstra)算法功能08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测10文件或文件夹名称中有空格如何批量去除