Mybatis-Plus

于 2024-09-16 13:06:30 发布
阅读量745 收藏 18
点赞数 18
分类专栏： # mybatis 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42810926/article/details/142301591
版权

Mybatis Plus

今日目标：

  • 了解mybatisplus的特点
  • 能够掌握mybatisplus快速入门
  • 能够掌握mybatisplus常用注解
  • 能够掌握mybatisplus常用的增删改查
  • 能够掌握mybatisplus自动代码生成
Mybatis: ✔
	需要程序员编写sql语句
    程序员可以干预sql对sql进行调优(优化)
MybatisPlus: 开发效率高
	在MybatisPlus中按照固定格式生成了单表的CRUD

01-MybatisPlus简介

【1】MybatisPlus概述

以前操作数据库的方式：

在这里插入图片描述

存在如下问题：

1.需要编写sql语句：

  • 注解形式
  • xml形式

2.表与实体类的ORM映射

  • 通过resultMap标签封装数据
  • 在这里插入图片描述

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

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

【2】MP愿景

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

在这里插入图片描述

【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 操作智能分析阻断，也可自定义拦截规则，预防误操作

【4】开发MP版本

<!--普通Maven项目下的依赖-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus</artifactId>
    <version>3.4.2</version>
</dependency>


<!--SpringBoot环境下的MP（项目中使用）-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.1</version>
</dependency>

02-MP快速入门

【1】MP入门流程分析

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

导入代码的半成品代码工程：

在这里插入图片描述

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

【2】数据库环境准备

CREATE DATABASE /*!32312 IF NOT EXISTS*/`mp` /*!40100 DEFAULT CHARACTER SET utf8 */;

USE `mp`;

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

【3】创建工程，引入场景依赖

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.12</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.itheima</groupId>
    <artifactId>mp_pro01</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mp_pro01</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!-- mysql  驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </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.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

【4】编写DataSource相关配置

# datasource
spring:
  datasource:
    url: jdbc:mysql://192.168.52.130:3306/mp?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&useSSL=false&serverTimezone=Asia/Shanghai
    username: root
    password: 1234
    driver-class-name: com.mysql.jdbc.Driver

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

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

【5】编码

​ 实体类：

package com.itheima.pojo;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@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;
}

建造者模式是设计模式的一种，将一个复杂对象的构建和他的表示分离，是同样的构建过程可以创建不同的表示。

这种模式又称为生成器模式，这种类型的设计模式提供一种创建对象的最佳方式。

1、定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
2、主要作用：在用户不知道对象的建造过程和细节的情况下就可以直接创建复杂的对象。
3、如何使用：用户只需要给出指定复杂对象的类型和内容，建造者模式负责按顺序创建复杂对象（把内部的建造过程和细节隐藏起来）
4、解决的问题：
（1）、方便用户创建复杂的对象（不需要知道实现过程）
（2）、代码复用性 & 封装性（将对象构建过程和细节进行封装 & 复用）
5、注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序，一般用来创建更为复杂的对象

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

​ 编写mapper：

package com.itheima.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.itheima.pojo.User;

/**
 * 使用mp定义Mapper，需要让Mapper接口继承 BaseMapper接口。
 */
public interface UserMapper extends BaseMapper<User> {
    
}

​ 启动类增加 @MapperScan 注解

package com.itheima;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/*
    启动类
 */
@SpringBootApplication
@MapperScan("com.itheima.mapper")
public class MpPro01Application {

    public static void main(String[] args) {
        SpringApplication.run(MpPro01Application.class, args);
    }

}

【6】测试

package com.itheima;

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

@SpringBootTest
class MpPro01ApplicationTests {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testFindById(){
        User user = userMapper.selectById(1);
        System.out.println(user);
    }

}

03-MP实现常规增删改操作

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

在这里插入图片描述

03-1-MP实现插入操作

【1】BaseMapper定义操作方法

在这里插入图片描述

注意事项：

1.如果主键对应的实体类属性中没有设置主键的生成策略，那么MP自动为主键生成值，且回填到实体对象下；
2.如果未指定主键生成策略，即使表的主键是主键自增，也不会使用主键自增；

【2】代码测试

package com.itheima.test;

import com.itheima.dao.UserMapper;
import com.itheima.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 TestMybatisPlus02 {

    @Autowired
    private UserMapper userMapper;

      /*
     * 要求：添加名为小明的user数据
     * sql语句：insert into tb_user(xx,xx,xx,...) values (xx,xx,xx,....)
     * */

    /**
     * 添加:
     *      在添加数据信息时,如果没有提供id的值,则id由MybatisPlus自动维护
     *      添加成功后,会自动将新增的数据的id回填到当前对象中.
     */
    @Test
    public void testAddUesrById() {

        //User user = new User();
        //user.setUserName("damimi");
        //user.setAge(18);
        //user.setName("大幂幂");
        //user.setPassword("666");
        //user.setEmail("damimi@qq.com");
        // 使用java的构建者模式,帮我们创建对象
        User user = User.builder()
                .userName("liuyan")
                .age(38)
                .name("柳岩")
                .email("liuyan@itcast.cn")
                .password("123")
                .build();
        int i = userMapper.insert(user);
        if (i>0) {
            System.out.println("添加成功");
        }
        System.out.println(user);
    }
}

03-2-MP主键生成策略-@TableId

在测试插入操作时，我们发现数据库表中主键id设置了自增，但是却生成了一段很长的数字(没有使用数据库自带的主键自增)，这是什么原因呢？

在这里插入图片描述

【1】注解@TableId介绍

@TableId注解作用：
	1.标识实体类中主键对应属性；
	2.定义主键生成策略；
@TableId使用：
	添加在实体类的主键对应的成员属性上即可；
image-20210507161829917

【2】主键生成策略介绍

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

/**
     * @TableId: 指定当前表的主键
     *      value: 建立数据库主键字段与实体字段的对应关系
     *      type: 设置主键生成策略,
     *          默认情况下使用雪花算法
     *          IdType.AUTO:使用数据库的主键自增
     */
@TableId(type = IdType.AUTO)
private Long id;

MP主键生成策略示例：

package com.itheima.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
// @TableName: 指定当前对象对应的数据库表
@TableName("tb_user")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class User {

    /**
     * @TableId: 指定当前表的主键
     *      value: 建立数据库主键字段与实体字段的对应关系
     *      type: 设置主键生成策略,
     *          默认情况下使用雪花算法
     *          IdType.AUTO:使用数据库的主键自增
     */
    @TableId(type = IdType.AUTO)
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email;
}

【3】MP常用主键生成策略

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

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

在这里插入图片描述

代码演示：

  • 主键自增策略

需要重启mysql：

在这里插入图片描述

然后修改数据表的数据id如下：

在这里插入图片描述

在这里插入图片描述

效果：

在这里插入图片描述

  • 自己给id赋值

在这里插入图片描述

在这里插入图片描述

效果：

在这里插入图片描述

  • 雪花算法生成策略

在这里插入图片描述

在这里插入图片描述

效果：

在这里插入图片描述

  • UUID生成策略

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

【4】雪花算法(了解)

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

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

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

补充：

在这里插入图片描述

  1. 1bit，不用，因为二进制中最高位是符号位，1表示负数，0表示正数。生成的id一般都是用整数，所以最高位固定为0。

  2. 41bit时间戳，毫秒级。可以表示的数值范围是 （2^41-1），转换成单位年则是69年。

  3. 10bit工作机器ID，用来表示工作机器的ID，包括5位datacenterId和5位workerId。

  4. 12bit序列号，用来记录同毫秒内产生的不同id，12位可以表示的最大整数为4095，来表示同一机器同一时间截（毫秒)内产生的4095个ID序号。

PS：雪花算法是为了同一种类型的数据在分布式系统中的数据唯一性。

由于在Java中64bit的整数是long类型，所以在Java中SnowFlake算法生成的id就是long来存储的。

03-3-普通列注解-@TableField

【1】注解@TableField作用

​ 1.通过@TableField(“表列名”) 指定除了id属性和数据库其他字段的映射关系

​ 以下情况可以省略：

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

​ 2.忽略某个字段的查询和插入 @TableField(exist = false)

【2】代码示例

package com.itheima.pojo;

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 lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
//mybatisplus注解
@TableName("tb_user") // 指定表名
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class User {
    //id生成策略是自动增长
    @TableId(type = IdType.AUTO)
    //自己书写id值
//    @TableId(type = IdType.NONE)
//    @TableId(type = IdType.INPUT)
    //雪花算法生成的id
//    @TableId(type = IdType.ASSIGN_ID)
    //UUID生成策略
//    @TableId(type = IdType.ASSIGN_UUID)
    private Long id;
    // 建立数据库字段与实体字段的对应关系 @TableField("与数据库字段名对应")
    @TableField("user_name")
//    private String userName;
    private String uName;
    private String password;
    private String name;
    private Integer age;
    private String email;
}

  /*
     * 要求：添加名为小明的user数据
     * sql语句：insert into tb_user(xx,xx,xx,...) values (xx,xx,xx,....)
     * */

    /**
     * 添加:
     *      在添加数据信息时,如果没有提供id的值,则id由MybatisPlus自动维护
     *      添加成功后,会自动将新增的数据的id回填到当前对象中.
     */
    @Test
    public void testAddUesrById() {
        //User user = new User();
        //user.setUserName("damimi");
        //user.setAge(18);
        //user.setName("大幂幂");
        //user.setPassword("666");
        //user.setEmail("damimi@qq.com");
        // 使用java的构建者模式,帮我们创建对象
        User user = User.builder()
                .uName("liuyan")
                .age(38)
                .name("柳岩")
                .email("liuyan@itcast.cn")
                .password("123")
                .build();
        int i = userMapper.insert(user);
        if (i>0) {
            System.out.println("添加成功");
        }
        System.out.println(user);
    }

03-4-MP实现删除操作

BaseMaper定义的常用删除方法：

在这里插入图片描述

【1】根据id删除

 int count = userMapper.deleteById(8L);

【2】根据id集合批量删除

 List ids = new ArrayList();
        ids.add(6);
        ids.add(7);
userMapper.deleteBatchIds(ids);

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

课堂代码

  /*
     * 要求：删除id为 16 的用户
     * sql语句：DELETE FROM tb_user WHERE id=?
     * */
    @Test
    public void testDelUesrById() {
        int i = userMapper.deleteById(16L);
        System.out.println("i = " + i);

    }

    /*
     * 要求：删除id为 15、14 的用户
     * sql语句：DELETE FROM tb_user WHERE id=? or id=?
     * sql语句：DELETE FROM tb_user WHERE id IN ( ? , ? )
     * */
    @Test
    public void testDelUesrByIds() {
        ArrayList<Long> list = new ArrayList<>();
        list.add(14L);
        list.add(15L);
        /**
         * int deleteBatchIds(Collection idList);
         */
        int i = userMapper.deleteBatchIds(list);
        System.out.println("i = " + i);

    }

    /*
     * 要求：删除user_name为王八衰 age 为22 的用户
     * sql语句：DELETE FROM tb_user WHERE user_name = ? AND age = ?
     * */
    @Test
    public void testDelUesrByCondition() {
        // 将删除的条件设置到map集合中
        Map<String, Object> map = new HashMap<>();
        // map的键为数据库字段名
        map.put("age",22);
        map.put("user_name","王八衰");
        // int deleteByMap(Map<String, Object> columnMap)
        int i = userMapper.deleteByMap(map);
        System.out.println("i = " + i);
    }

03-5-MP实现更新操作

在这里插入图片描述

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

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

	/*
     * 修改用户id为 4 的username修改为 李催
     * sql语句：UPDATE tb_user SET user_name=? WHERE id=?
     */
    @Test
    public void testUpdate() {
        // 构建修改后的数据信息
        User user = User.builder()
                .userName("王五")
                .password("1234")
                .build();
//        int i = userMapper.updateById(user);
        UpdateWrapper<User> wrapper = new UpdateWrapper<>();
        wrapper.eq("name", "zws");
        wrapper.eq("id", 5L);
        // UPDATE tb_user SET user_name=?, password=? WHERE (name = ? AND id = ?)
        int i = userMapper.update(user, wrapper);
        System.out.println("i = " + i);

    }

04-MP实现查询操作

MP查询API概览：

在这里插入图片描述

04-1-MP实现分页查询

参考代码
https://gitee.com/baomidou/mybatis-plus-samples/tree/master/mybatis-plus-sample-pagination

【1】配置分页拦截器

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

package com.itheima.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;
    }
}

【2】查询测试

package com.itheima;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.itheima.mapper.UserMapper;
import com.itheima.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
public class UserMapperQueryTest {

    @Autowired
    private UserMapper userMapper;

    /*
     * 要求：分页查询user数据，每页5条数据,查询第一页数据
     * sql语句：SELECT * FROM tb_user LIMIT 0,5
     * sql语句：SELECT * FROM tb_user LIMIT 5 （简写形式）
     */
    @Test
    public void testPage() {
        // 创建分页对象 public class Page<T> implements IPage<T>
        IPage<User> page = new Page<>(1, 5);//1 表示当前页是第一页   5表示每页显示5条数据
        //第二个参数null表示没有查询条件
        IPage<User> userPage = userMapper.selectPage(page, null);
        System.out.println(page==userPage);//true

        // 获取分页数据信息
        List<User> userList = page.getRecords();
        for (User user : userList) {
            System.out.println(user);
        }
        // 当前页
        long current = page.getCurrent();
        // 每页显示条数
        long size = page.getSize();
        // 总条数
        long total = page.getTotal();
        // 总页数
        long pages = page.getPages();
        System.out.println(current);//1
        System.out.println(size);//5
        System.out.println(total);//22
        System.out.println(pages);//5

    }

}

04-2-Wrapper介绍

  • Wrapper 是 MyBatis-Plus 中封装的一个条件查询构造器，其目的是为了简化查询条件的构造，使代码更容易阅读和维护。Wrapper 可以用于查询单表数据，也支持关联查询，不同的 Wrapper 子类可以构造不同的查询条件

  • Wrapper类的常见子类如下：

    • QueryWrapper：普通的 Wrapper，可以设置等于、不等于、大于、小于、between、in、like、not like、or、and 等等各种查询条件，支持设置排序、分组等操作；

      • 代码：
      QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "Tom").ne("age", 18).orderByAsc("age");
List<User> userList = userMapper.selectList(queryWrapper);

      在上面的示例中，我们通过 eq、ne 和 orderByAsc 等方法来设置查询条件。这些方法都是对应于 SQL 中的操作符。需要注意的是，QueryWrapper 在设置查询条件时需要使用表字段名称，这样的话如果表结构发生变化，使用 QueryWrapper 的代码也需要相应地修改。

    • LambdaQueryWrapper：基于 lambda 表达式的查询构造器，可以使用类似于 Java 语法的方式来构造查询条件；LambdaQueryWrapper 是在 QueryWrapper 基础上增加了一种 Lambda 表达式的方式来设置查询条件，查询条件更加直观和优雅。例如：

      • 代码：
      LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(User::getName, "Tom").ne(User::getAge, 18).orderByAsc(User::getAge);
List<User> userList = userMapper.selectList(lambdaQueryWrapper);

      在上面的示例中，我们直接通过 Lambda 表达式调用 Java 类的 getter 方法来设置查询条件，可以避免使用表字段名称带来的问题。同时，Lambda 表达式的语法也更加简洁和优雅。

      总体来说，使用 LambdaQueryWrapper 可以让代码更加简洁、可读性更好，并且可以在表结构变化时减少代码修改量。但需要注意的是，目前 Lambda 表达式的性能相对于 QueryWrapper 略低一些，当需要对大量数据做批量查询时，可以根据实际场景选择使用哪种 Wrapper。

    • UpdateWrapper：用于构造更新操作的条件，支持 set、where、and、or 等等操作

    • LambdaUpdateWrapper：用于构造更新操作的条件，支持 set、where、and、or 等等操作，支持lambda

  • Wrapper常用API

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

04-3-QueryWrapper实现基础查询

【1】查询实现

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

/*
     * 要求：查询用户中姓名包含"伤"，密码为"123456",且年龄为19或者25或者29，查询结果按照年龄降序排序；
     * sql语句：SELECT * FROM tb_user WHERE (user_name LIKE ? AND password = ? AND age IN (?,?,?)) ORDER BY age DESC
     */
    @Test
    public void testConditions1Query() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.like("user_name","伤")
                .eq("password","123456")
                .in("age",19,25,29)
                .orderByDesc("age");
        // 查询所有
        //List<User> list = userMapper.selectList(null);
        List<User> list = userMapper.selectList(wrapper);
        for (User user : list) {
            System.out.println(user);
        }
    }

04-4-QueryWrapper逻辑查询or

【1】OR查询说明

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

【2】代码示例

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

/*
     * 要求：查询用户名为"liuyan"或者年龄大于23的用户信息；
     * sql语句：SELECT id,user_name,password,name,age,email FROM tb_user WHERE (user_name = ? OR age > ?)
     */
    @Test
    public void testConditions2Query() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("user_name","liuyan")
                .or()
                .gt("age",23);
        // 查询所有
        //List<User> list = userMapper.selectList(null);
        List<User> list = userMapper.selectList(wrapper);
        for (User user : list) {
            System.out.println(user);
        }

    }

04-5-QueryWrapper模糊查询like

【1】模糊查询常用方法

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

【2】代码演示

 /**
     * 模糊查询
     * 需求：模糊查询含有 伤 的用户信息
     * sql语句：SELECT id,user_name,password,name,age,email FROM tb_user WHERE (user_name LIKE ?)
     */
    @Test
    public void testFind3(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.like("user_name","伤");
        // 查询所有
        //List<User> list = userMapper.selectList(null);
        List<User> list = userMapper.selectList(wrapper);
        for (User user : list) {
            System.out.println(user);
        }
    }

04-6-QueryWrapper排序查询

【1】核心方法

orderByAsc  	升序排序
orderByDesc 	降序排序

【2】代码实现

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

 /**
     * 排序查询
     * 	需求：先根据age升序排序，如果年龄相同则按照id降序排序；
     * 	sql语句：SELECT id,user_name,password,name,age,email FROM tb_user ORDER BY age ASC,id DESC
     */
    @Test
    public void testFind4(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.orderByAsc("age").orderByDesc("id");
        // 查询所有
        List<User> list = userMapper.selectList(wrapper);
        for (User user : list) {
            System.out.println(user);
        }
    }

04-7-QueryWrapper限定字段查询

【1】select方法说明

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

示例：

wrapper.select("字段1","字段2",......)

【2】代码示例

  /**
     * 指定查询字段
     * 需求：先根据age升序排序，如果年龄相同则按照id降序排序，查询出id user_name age字段
     * sql语句：SELECT id,user_name,age FROM tb_user ORDER BY age ASC,id DESC
     */
    @Test
    public void testFind5(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.orderByAsc("age").orderByDesc("id").select("id","user_name","age");
        // 查询所有
        List<User> list = userMapper.selectList(wrapper);
        for (User user : list) {
            System.out.println(user);
        }
    }

04-8-QueryWrapper实现分页条件查询

【1】方法说明

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

【2】代码实现

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

/**
     * 分页查询
     * 需求：查询年龄大于23的用户信息，并显示第2页，每页大小为3；
     * sql语句： SELECT id,user_name,password,name,age,email FROM tb_user WHERE (age > ?) LIMIT ?,?
     */
    @Test
    public void testFind6(){
        // 创建分页对象 2表示当前页是2  3表示每页显示条数
        IPage<User> page = new Page<>(2, 3);
        // 拼接分页条件
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.gt("age", 23);
        userMapper.selectPage(page, wrapper);


        // 获取分页数据信息
        List<User> userList = page.getRecords();
        for (User user : userList) {
            System.out.println(user);
        }
        // 当前页
        long current = page.getCurrent();
        // 每页显示条数
        long size = page.getSize();
        // 总条数
        long total = page.getTotal();
        // 总页数
        long pages = page.getPages();
        System.out.println(current);//2
        System.out.println(size);//3
        System.out.println(total);//15
        System.out.println(pages);//5
    }

04-9-LambdaQueryWrapper查询

【1】使用QueryWrapper开发存在的问题

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

在这里插入图片描述

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

【2】代码实现

 /**
     * LambdaQueryWrapper替换QueryWrapper
     * 1.使用QueryWrapper查询数据时需要手写对应表的列名信息，及其容易写错，开发体验不好；
     * 2.使用QueryWrapper查询数据时，表的列名硬编码书写，后期一旦表结构更改，则会带来很大的修改工作量，维护性较差；
     */
    @Test
    public void testFind7(){
        // 存在硬编码问题,扩展维护成本高
        /*QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.like("user_name","伤")
                .eq("password","123456")
                .in("age",19,25,29)
                .orderByDesc("age");*/
        // 创建LambdaQueryWrapper对象
        // User::getUserName: 动态读取实体中成员属性的名称.
//        LambdaQueryWrapper<User> wrapper = Wrappers.lambdaQuery();
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(User::getUserName,"伤")
                .eq(User::getPassword,"123456")
                .in(User::getAge,19,25,29)
                .orderByDesc(User::getAge);
        // 查询所有
        List<User> list = userMapper.selectList(wrapper);
        for (User user : list) {
            System.out.println(user);
        }
    }

原理说明：

在这里插入图片描述

04-10-LambdaQueryWrapper实现删除和更新操作

【1】条件删除

在这里插入图片描述

 /**
     * LambdaUpdateWrapper完成根据条件删除id是31的用户
     */
    @Test
    public void deleteTest1(){
//        LambdaUpdateWrapper<User> wrapper = Wrappers.lambdaUpdate();
        LambdaUpdateWrapper<User> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(User::getId,31L);
        int i = userMapper.delete(wrapper);
        System.out.println(i);
    }

【2】条件更新

在这里插入图片描述

 /**
     * 根据条件更新
     * 需求：更新id是1并且年龄是19的用户
     * sql:UPDATE tb_user SET user_name=?, password=?, name=?, age=?, email=? WHERE (id = ? AND age = ?)
     */
    @Test
    public void updateTest2(){
        User user = User.builder()
                .userName("liuyan")
                .password("6669")
                .name("柳岩")
                .age(18)
                .email("liuyan@qq.com")
                .build();
        // 封装修改条件
        LambdaUpdateWrapper<User> wrapper = Wrappers.lambdaUpdate();
        wrapper.eq(User::getId,1L)
                .eq(User::getAge,19);
        int i = userMapper.update(user, wrapper);
        System.out.println(i);
    }

05-MP实现Service封装

05-1-MP封装Service介绍

【1】说明

MybatisPlus为了开发更加快捷，对业务层也进行了封装，直接提供了相关的接口和实现类;
我们在进行业务层开发时，可以继承它提供的接口和实现类，使得编码更加高效;

【2】实现流程

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

​ 思考：

注意事项：
      1.ServiceImpl父类已经注入了UserMapper对象，名称叫做baseMapper，所以当前实现类直接可以使用baseMapper完成操作
      2.因为ServiceImpl已经实现了IService下的方法，所以当前服务类没有必要再次实现
思想：共性的业务代码交给框架封装维护，非共性的业务，在接口UserService定义，然后在当前的服务类下实现；

【3】核心API介绍

在这里插入图片描述

05-2-MP封装Service实现

代码实现：

【1】定义服务扩展接口

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

【2】定义服务实现

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

【3】测试

需求：

1.查询id是3的用户信息
2.分页查询年龄大于20的所有用户信息
3.向数据库中插入User对象数据
4.删除id是17的数据
5.更新id是3的用户的姓名为wangwu2,密码为333

package com.itheima;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
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.pojo.User;
import com.itheima.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

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

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

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



    /**
     * @Description 根据条件批量查询
     */
    @Test
    public void test2(){
        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 test3(){
        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 test4(){
        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 test5(){
        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 test6(){
        boolean isSuccess = userService.removeById(17l);
        System.out.println(isSuccess?"保存成功":"保存失败");
    }

    /**
     * @Description 根据条件批量删除
     */
    @Test
    public void test7(){
        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 test8(){
        //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 test9(){
        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);

    }
}

06-自动填充功能

​ 有些时候我们可能会有这样的需求，插入或者更新数据时，希望有些字段可以自动填充数据，比如密码、version等。在MP中提供了这样的功能，可以实现自动填充。

【1】添加@TableField注解

在这里插入图片描述

@TableField(fill = FieldFill.INSERT) //插入数据时进行填充
private String password;

为password添加自动填充功能，在新增数据时有效。

FieldFill提供了多种模式选择：

public enum FieldFill {
    /**
     * 默认不处理
     */
    DEFAULT,
    /**
     * 插入时填充字段
     */
    INSERT,
    /**
     * 更新时填充字段
     */
    UPDATE,
    /**
     * 插入和更新时填充字段
     */
    INSERT_UPDATE
}

【2】编写MyMetaObjectHandler

在这里插入图片描述

package com.itheima.config;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

/*
    MetaObjectHandler接口是mybatisPlus为我们提供的的一个扩展接口，
    我们可以利用这个接口在我们插入或者更新数据的时候，为一些字段指定默认值。
    实现这个需求的方法不止一种，在sql层面也可以做到，在建表的时候也可以指定默认值
 */
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    /*
        MetaObject类相当于一个工具类，Mybatis在sql参数设置和结果集映射里经常使用到这个对象
        其具体功能如下：
        查找属性：勿略大小写，支持驼峰、支持子属性 如：blog.comment.user_name（需要开启useCamelCaseMapping）
     */
    @Override
    public void insertFill(MetaObject metaObject) {
        //从metaObject获取password的字段值
        Object password = getFieldValByName("password", metaObject);
        if(null == password){
            //字段为空，可以进行填充
            setFieldValByName("password", "123456", metaObject);
        }
    }

    @Override
    public void updateFill(MetaObject metaObject) {

    }
}

【3】测试

    @Test
    public void addUser() {
        User user1 = User.builder().age(18)
                .email("aa@itheima.com")
                .name("小明")
                .age(18)
                .build();
        userMapper.insert(user1);
    }

07-MP代码生成器

【1】开发现状

​ 开发中当有一个新的业务要实现时，通常我们需要构建一下信息：

  • 定义PO类

    数据库表和实体类的映射 Java Bean。

  • 定义DAO层

    需要编写接口 Mapper ，接口 Mapper 需要去继承 MP 中的 BaseMapper 接口。

  • 定义Service层

    编写 Service 层接口和实现类。

    业务接口需要去继承 MP 中的 IService，业务实现类需要继承 MP 中的 ServiceImpl 和 实现业务接口。

  • 定义Controller层

    编写 Controller 并标注 Spring MVC 中的相关注解。

    显然上述存在固定的流程，且存在大量重复操作，you now 代码价值低且没效率!

【2】MP逆向工程介绍

针对目前开发的现状，MP的代码生成器就可以一展身手了;

通过MP代码生成器可以生成模板性的代码，减少手工操作的繁琐，使开发人员聚焦于业务开发之上，提升开发效率;

AutoGenerator 类是MyBatis-Plus 的核心代码生成器类，通过 AutoGenerator 可以快速生成 Mapper接口、Entity实体类、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。

【3】代码生成

参考代码：资料\mp_generator

或者是gitee开源链接：https://gitee.com/jitheima/mp_generator.git

完整代码：

在这里插入图片描述

在这里插入图片描述

说明：

以后在项目中使用时，先在本工程生成，然后就可以把代码拷贝到对应的项目目录中使用了;

08-MybatisX插件

【1】MybatisX插件介绍

MybatisX 是一款基于 IDEA 的快速开发插件，为效率而生。

安装方法：打开 IDEA，进入 File -> Settings -> Plugins -> Browse Repositories，输入 mybatisx 搜索并安装。

功能：

  • Java 与 XML 调回跳转
  • Mapper 方法自动生成 XML

在这里插入图片描述

【2】基于MybatisX实现逆向工程

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

Java千年老妖
关注
专栏目录
【MyBatis】 MyBatis与MyBatis-Plus的区别
四季轮换叶，一路招摇胜
09-12 5万+
mybatis-plus 是 mybatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
mybatis-plus代码生成器模版代码
08-17
<artifactId>mybatis-plus-boot-starter <version>3.4.3</version> <!-- 请根据最新版本号替换 --> ``` 接着，配置代码生成器的相关参数，包括数据源信息、生成的包路径、作者信息等。这些参数可以通过Java代码...
Mybatis-Plus开发提速器mybatis-plus-generator-ui
夜郎King的博客
11-28 2万+
​本文简要介绍一款基于Mybatis-Plus的代码自助生成器，地址:mybatis-plus-generator-ui。文章通过实例集成的方式来详细讲解mybatis-plus-generator-ui，从相关概念到实际集成案例，以及具体的扩展开发介绍。
mybatis-plus分页查询详解
弹指天下
07-15 8万+
本文主要对mybatis-plus分页查询的原理和使用进行了详细介绍。
MyBatis-Plus 自定义sql语句
热门推荐
贱男
06-12 10万+
一、引言 Good Good Study，Day Day Up，童鞋点个关注，不迷路，么么哒～～～
深入探究MyBatis-Plus自动生成代码技术
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
04-24 3万+
MyBatis-Plus（简称MP）提供了强大的代码生成器功能，可以帮助开发者快速生成与数据库表结构对应的Java实体类、Mapper接口、Mapper XML文件、Service接口及实现类、Controller类等。
Mybatis-plus的介绍与使用
小威的博客
07-19 7992
本文主要介绍了Mybatis-Plus相关的概念与使用，Mybatis-Plus大大简化了我们的开发，感兴趣的大佬看过来哟
如何使用Mybatis-plus进行分页
AALouisaa的博客
08-20 9万+
利用mybatis-plus进行分页！！！
Mybatis-Plus介绍
nine06的博客
02-28 1617
MyBatis-Plus 官方文档MyBatis-Plus（简称 MP）是⼀个 MyBatis 的增强⼯具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
MyBatis-plus 分页查询
qq_33807380的博客
03-20 1万+
MyBatis-Plus的 IPage 分页插件主要是通过AOP（面向切面编程）技术来实现的，它可以在运行时动态地拦截方法调用，并在方法执行前后添加额外的行为。这种方式使得分页功能可以很容易地集成到现有的代码中，而不需要对现有查询逻辑做出大的改动。PageHelper分页插件的工作原理基于MyBatis的拦截器模式，通过拦截MyBatis的执行过程，动态地在查询语句前添加分页逻辑。
【Mybatis-Plus】分页简单使用
人类所有真实的快乐，一定是恒久的努力
09-09 8万+
【Mybatis-Plus】分页简单使用
Mybatis-plus自动生成代码
10-12
Mybatis-plus是一款基于Mybatis和Spring的轻量级框架，它扩展了Mybatis的功能，提供了更便捷的操作数据库的方式。在项目开发中，Mybatis-plus的一个重要特性就是其代码生成器，能够极大地提高开发效率，减少手动编写...
mybatis-plus-boot-starter-3.1.0.jar
04-13
mybatis-plus-boot-starter.jar 各个版本下载， SpringBoot 集成 MybatisPlus jar 包下载， Mybatis-Plus（简称MP）是一个基于MyBatis的增强工具库，它简化了与数据库的交互操作并提供了一系列增强功能，使开发者...
mybatis-plus-boot-starter-3.4.3.3.jar
04-13
mybatis-plus-boot-starter.jar 各个版本下载， SpringBoot 集成 MybatisPlus jar 包下载， Mybatis-Plus（简称MP）是一个基于MyBatis的增强工具库，它简化了与数据库的交互操作并提供了一系列增强功能，使开发者...
mybatis-plus源码（mybatis-plus-3.5.1.zip）
03-03
此源码包`mybatis-plus-3.5.1.zip`包含了MyBatis-Plus 3.5.1版本的全部源代码，有助于我们深入理解其内部实现机制和工作原理。 MyBatis-Plus的主要功能包括： 1. **CRUD操作**：MyBatis-Plus提供了简化版的CRUD...
MybatisPlus的LambdaQueryWrapper用法
2301_79693537的博客
08-21 4884
【代码】MybatisPlus的LambdaQueryWrapper用法。
c#实现俄罗斯方块，面向对象实现
09-15
俄罗斯方块（Tetris）是一款经典的益智游戏，由俄罗斯程序员阿列克谢·帕基特诺夫于1984年开发。游戏的主要目标是通过旋转和移动不同形状的方块（称为“砖块”或“Tetrominoes”），将它们填充到屏幕底部的水平行中。当一行被完全填满时，该行会消失，玩家将获得积分。 游戏特点： 砖块形状：游戏中有七种不同形状的砖块，每种砖块由四个方块组成。 下落机制：砖块从屏幕顶部逐渐下落，玩家需要快速做出决策。 得分系统：消除的行越多，得分越高，连续消除多行会获得额外分数。 难度递增：随着游戏进行，砖块下落的速度会逐渐加快，增加了游戏的挑战性。 文化影响： 俄罗斯方块不仅在游戏界取得了巨大的成功，还成为了流行文化的一部分，影响了许多后续的游戏设计。它的简单性和上瘾性使其成为了历史上最畅销的电子游戏之一。 版本与平台： 自发布以来，俄罗斯方块已经在多个平台上推出，包括家用游戏机、电脑、手机等，形成了众多不同的版本和变种。
5G网络优化案例：关于解决诺基亚5G 700M站点小区闪断问题解决.pdf
最新发布
09-15
这份文件是关于解决诺基亚5G 700M站点小区闪断问题的详细案例报告，主要内容和关键要点如下： 问题背景与初步分析： 问题描述：随着5G 700M网络建设的推进，诺基亚700M现网出现较多误码告警和小区闪断问题，故障比例明显高于其他厂家站点。 初步定位：通过归类法分析，发现绝大部分误码问题发生在烽火单芯双向光模块小区，占比高达95.65%。 故障根因深入探究： 光模块适配问题：初步认为烽火单纤双向光模块存在问题，但更换后问题依旧，进一步分析为光模块与诺基亚设备的适配问题。 深入测试与定位：选取5个长期误码小区进行深入分析，与烽火厂家合作对光模块进行程序升级，问题得到初步解决。 AUTOBYPASS机制分析： 机制介绍：烽火光模块采用25G模块速率兼容10G，并开启AUTOBYPASS（CPR自动旁路模式）功能。 影响分析：AUTOBYPASS机制与诺基亚设备不适配，导致交互失败和误码产生。关闭AUTOBYPASS后，CDR时钟校验和恢复周期缩短，交互频繁，误码问题消失。 解决方案与实施： 解决方案：针对所有使用此类光模块的诺基亚站点，通过优化升级烽火光模块，关闭AUTOBYPASS功
在线请假管理系统.zip
09-15
这是一个基于Python Flask的Web应用程序，采用Bulma uI框架和Postgresql数据库，用于管理和处理员工的请假事宜。用户可以通过这个系统创建安全的用户账户并登录，员工可以提交请假申请等待上级审批，并查看历史请假记录。经理可以审批或拒绝员工的请假申请，并查看团队的请假记录。此外，管理员还可以查看所有员工信息，添加新员工并分配经理，编辑和删除员工信息。该项目在heroku上托管，提供在线服务。安装步骤包括克隆项目、创建虚拟环境、激活环境并安装依赖项等。还提供了数据库迁移和初始化、运行应用程序以及数据重置等实用工具命令。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.文md件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Java千年老妖

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

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

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

打赏作者

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

抵扣说明：

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

余额充值