MyBatisPlus（一）简介与基本CRUD

原创 已于 2025-07-27 10:25:40 修改 · 272 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #mybatis #数据库

于 2025-07-25 21:30:09 首次发布

一、MyBatis-Plus简介

1、简介

MyBatis-Plus （简称 MP）是一个 MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为 简化开发、提高效率而生。Mybatis-Plus提供了通用的Mapper和Service，可以在不编写任何SQL语句的前提下，快速的实现单表的增删改查（CURD），批量，逻辑删除，分页等操作。只要把MyBatis-Plus的特性到优秀插件，以及多数据源的配置进行详细讲解。

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

2、特性

  • 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
  • 损耗小：启动即会自动注入基本 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 操作智能分析阻断，也可自定义拦截规则，预防 误操作

3、支持数据库

任何能使用MyBatis进行 CRUD, 并且支持标准 SQL 的数据库，具体支持情况如下

MySQL ，Oracle ， DB2 ， H2 ， HSQL ，SQLite ， PostgreSQL ，SQLServer ， Phoenix ，Gauss ， ClickHouse ，Sybase ，OceanBase ， Firebird ，Cubrid ，Goldilocks ，csiidb

达梦数据库，虚谷数据库，人大金仓数据库，南大通用(华库)数据库，南大通用数据库，神通数据 库，瀚高数据库

4、框架结构

 

5、代码及文档地址

官方地址: http://mp.baomidou.com

代码发布地址:

Github: https://github.com/baomidou/mybatis-plus

Gitee: https://gitee.com/baomidou/mybatis-plus

文档发布地址: https://baomidou.com/pages/24112f

二、入门案例

1、开发环境

IDE： idea 2021

JDK：JDK8+

构建工具：  maven 3.6。0

MySQL版本：  MySQL 5.7

Spring Boot：2.6.3

MyBatis-Plus：3.5.1

2、创建数据库及表

a>创建表

CREATE DATABASE `mybatis_plus` /*!40100 DEFAULT CHARACTER SET utf8mb4 */; use `mybatis_plus`;

CREATE TABLE `user` (

`id` bigint(20) NOT NULL COMMENT '主键ID',

`name` varchar(30) DEFAULT NULL COMMENT '姓名 ',

`age` int(11) DEFAULT NULL COMMENT '年龄 ',

`email` varchar(50) DEFAULT NULL COMMENT '邮箱 ',

PRIMARY KEY (`id`)

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

b>添加数据

INSERT INTO user (id, name, age, email) VALUES

(1, 'Jone', 18, 'test1@baomidou.com'),

(2, 'Jack', 20, 'test2@baomidou.com'),

(3, 'Tom', 28, 'test3@baomidou.com'),

(4, 'Sandy', 21, 'test4@baomidou.com'),

(5, 'Billie', 24, 'test5@baomidou.com');

3、创建Spring Boot工程

a>初始化工程

b>引入依赖

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.qcby</groupId>
    <artifactId>myBatisPlus_demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.6</version>
    </parent>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>

        <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

    </dependencies>

</project>

c>idea中安装lombok插件

4、编写代码

a>配置application.yml

spring:
  # 配置数据源信息
  datasource:
# 配置数据源类型
    type: com.zaxxer.hikari.HikariDataSource
# 配置连接数据库信息
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatisplus_demo?characterEncoding=utf-8&useSSL=false
    username: root
    password: 2020

注意：

1、驱动类driver-class-name

spring boot 2.0（内置jdbc5驱动），驱动类使用

driver-class-name: com.mysql.jdbc.Driver

spring boot 2.1及以上（内置jdbc8驱动），驱动类使用：

driver-class-name: com.mysql.cj.jdbc.Driver

否则运行测试用例的时候会有 WARN 信息

2、连接地址url

MySQL5.7版本的url：

jdbc:mysql://localhost:3306/mybatis_plus?characterEncoding=utf-8&useSSL=false

MySQL8.0版本的url：

jdbc:mysql://localhost:3306/mybatis_plus?

serverTimezone=GMT%2B8&characterEncoding=utf-8&useSSL=false

否则运行测试用例报告如下错误：

java.sql.SQLException: The server time zone value'Öйú±ê׼ʱ¼ä' is unrecognized or represents more

b>启动类

    在Spring Boot启动类中添加@MapperScan注解，扫描mapper包

@SpringBootApplication
@MapperScan("com.qcby.mybatisplus.mapper")
public class MybatisplusApplication {

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

}

c>添加实体

@Data //lombok注解
public class User {

    private Long id;
    private String name;
    private Integer age;
    private String email;
}

User类编译之后的结果：

d>添加mapper

BaseMapper是MyBatis-Plus提供的模板mapper，其中包含了基本的CRUD方法，泛型为操作的 实体类型

public interface UserMapper extends BaseMapper<User> {

}

e>测试

@SpringBootTest
public class MybatisPlusTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectList(){
        //selectList()根据MP内置的条件构造器查询一个list集合，null表示没有条件，即查询所有
        userMapper.selectList(null).forEach(System.out::println);
    }

}

结果：

注意：

IDEA在 userMapper 处报错，因为找不到注入的对象，因为类是动态创建的，但是程序可以正确 的执行。

为了避免报错，可以在mapper接口上添加 @Repository 注解

f>添加日志

在application.yml中配置日志输出

# 配置MyBatis日志

mybatis-plus:

configuration:

log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

三、基本CRUD

1、 BaseMapper

MyBatis-Plus中的基本CRUD在内置的BaseMapper中都已得到了实现，我们可以直接使用，接口如 下：

BaseMapper中封装的19个基础CRUD方法：

package com.qcby;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.qcby.entity.User;
import com.qcby.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@SpringBootTest
public class MybatisPlusTest {

    @Autowired
    private UserMapper userMapper;

    /*1添加数据*/
    @Test
    public void testInsert() {
        //INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
        User user = new User();
        user.setName("李四");
        user.setAge(25);
        user.setEmail("123@qq.com");
        int result = userMapper.insert(user);
        System.out.println("影响行数：" + result);
    }

    /*2根据id值删除数据*/
    @Test
    public void testDeleteById() {
        //DELETE FROM user WHERE id=?
        int result = userMapper.deleteById(2);
        System.out.println("影响行数：" + result);
    }

    /*3根据实体类的id值删除数据*/
    @Test
    public void testDeleteByEntity() {
        //DELETE FROM user WHERE id=?
        User user = new User();
        user.setId(1L);
        int result = userMapper.deleteById(user);
        System.out.println("影响行数：" + result);
    }

    /*4通过map条件删除数据*/
    @Test
    public void testDeleteByMap() {
        //根据map集合中所设置的条件删除记录
        //DELETE FROM user WHERE name = ? AND age = ?
        Map<String, Object> map = new HashMap<>();
        map.put("name", "张三");
        map.put("age", 23);
        int result = userMapper.deleteByMap(map);
        System.out.println("受影响行数："+result);
    }

    /*5根据entity条件删除数据*/
    @Test
    public void testDeleteByEntityCondition() {
        //DELETE FROM user WHERE name=? AND age=?
        User user = new User();
        user.setName("张三");
        user.setAge(25);
        int result = userMapper.delete(new QueryWrapper<>(user));
        System.out.println("受影响行数："+result);
    }

    /*6批量删除数据*/
    @Test
    public void testDeleteBatchIds() {
        //批量删除id为3和4的记录
        //DELETE FROM user WHERE id IN ( ? , ? )
        List<Long> list = new ArrayList<>();
        list.add(3L);
        list.add(4L);
        int result = userMapper.deleteBatchIds(list);
        System.out.println("受影响行数："+result);
    }

    /*7根据id值修改数据*/
    @Test
    public void testUpdateById() {
        //UPDATE user SET age=?, email=? WHERE id=?
        User user = new User();
        user.setId(5L);
        user.setAge(26);
        user.setEmail("456@qq.com");
        int result = userMapper.updateById(user);
        System.out.println("受影响行数："+result);
    }

    /*8根据entity条件修改数据*/
    @Test
    public void testUpdateByEntityCondition() {
        // 假设有一个 UpdateWrapper 对象，设置查询条件为 age > 25，更新满足条件的用户的邮箱
        //UPDATE user SET email=? WHERE (age > ?)
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.gt("age", 25);
        User updateUser = new User();
        updateUser.setEmail("new.email@example.com");
        int rows = userMapper.update(updateUser, updateWrapper); // 调用 update 方法
        if (rows > 0) {
            System.out.println("Users updated successfully.");
        } else {
            System.out.println("No users updated.");
        }
    }

    /*9根据id值查询数据*/
    @Test
    public void testSelectById() {
        //SELECT id,name,age,email FROM user WHERE id=?
        User user = userMapper.selectById(5L);
        System.out.println(user);
    }

    /*10根据id值批量查询数据*/
    @Test
    public void testSelectBatchIds() {
        //SELECT id,name,age,email FROM user WHERE id IN ( ? , ? )
        List<Long> ids = new ArrayList<>();
        ids.add(5L);
        ids.add(1948664325964873730L);
        List<User> users = userMapper.selectBatchIds(ids);
        users.forEach(System.out::println);
    }

    /*11根据map条件查询数据*/
    @Test
    public void testSelectByMap() {
        // 根据map集合中所设置的条件查询记录
        // SELECT * FROM user WHERE name = ? AND age = ?
        Map<String, Object> map = new HashMap<>();
        map.put("name", "张三");
        map.put("age", 25);
        List<User> users = userMapper.selectByMap(map);
        users.forEach(System.out::println);
    }

    /*12根据entity条件查询一条记录*/
    @Test
    public void testSelectOneByEntity() {
        //SELECT id,name,age,email FROM user WHERE name=? AND age=?
        User user = new User();
        user.setName("张三");
        user.setAge(25);
        User result = userMapper.selectOne(new QueryWrapper<>(user));
        System.out.println(result);
    }

    /*13根据Wrapper条件，判断是否存在记录*/
    @Test
    public void testExist() {
        //SELECT COUNT( * ) FROM user WHERE name=? AND age=?
        User user = new User();
        user.setName("张三");
        user.setAge(25);
        boolean exist = userMapper.exists(new QueryWrapper<>(user));
        System.out.println(exist);
    }

    /*14查询总记录数*/
    @Test
    public void testCount() {
        // 查询总记录数
        //SELECT COUNT( * ) FROM user WHERE name=? AND age=?
        User user = new User();
        user.setName("张三");
        user.setAge(25);
        Long count = userMapper.selectCount(new QueryWrapper<>(user));
        System.out.println(count);
    }

    /*15查询全部数据，返回List集合*/
    @Test
    public void testSelectList() {
        //SELECT id,name,age,email FROM user WHERE age=?
        User user = new User();
        user.setAge(25);
        List<User> users = userMapper.selectList(new QueryWrapper<>(user));
        users.forEach(System.out::println);
    }

    /*16根据warpper条件查询数据，返回Map集合*/
    @Test
    public void testSelectMaps() {
        //SELECT id,name,age,email FROM user WHERE age=?
        User user = new User();
        user.setAge(25);
        List<Map<String, Object>> maps = userMapper.selectMaps(new QueryWrapper<>(user));
        maps.forEach(System.out::println);
    }

    /*17根据Wrapper条件查询数据 返回第一个字段的值*/
    @Test
    public void testSelectOne() {
        //SELECT id,name,age,email FROM user WHERE (age = ?)
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("age", 25);
        List<Object> users =userMapper.selectObjs(wrapper);
        users.forEach(System.out::println);
    }

    /*18根据实体类分页条件查询*/
    @Test
    public void testSelectPage() {
        //SELECT COUNT(*) AS total FROM user WHERE (age = ?)
        //SELECT id,name,age,email FROM user WHERE (age = ?) LIMIT ?,?
        Page<User> page = new Page<>(2, 1);
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("age", 25);
        IPage<User> result = userMapper.selectPage(page, wrapper);
        result.getRecords().forEach(System.out::println);
        System.out.println(result.getTotal());
    }

    /*19根据Wrapper条件查询所有数据selectMapsPage*/
    @Test
    public void testSelectMapsPage() {
        // 假设要进行分页查询，每页显示10条记录，查询第1页，查询条件为 age > 25，并将结果映射为 Map
        //SELECT COUNT(*) AS total FROM user WHERE (age > ?)
        //SELECT id,name,age,email FROM user WHERE (age > ?) LIMIT ?,?   
        IPage<Map<String, Object>> page = new Page<>();
        page.setCurrent(1);
        page.setSize(1);
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.gt("age", 25);
        IPage<Map<String, Object>> userPageMaps = userMapper.selectMapsPage(page, queryWrapper); // 调用 selectMapsPage 方法
        List<Map<String, Object>> userMapList = userPageMaps.getRecords();
        long total = userPageMaps.getTotal();
        System.out.println("Total users (age > 25): " + total);
        for (Map<String, Object> userMap : userMapList) {
            System.out.println("User Map: " + userMap);
        }
    }

}

2、IService

通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用  get 查询单行 ，remove 删 除

list 查询集合 ，page 分页，前缀命名方式区分  Mapper 层避免混淆，

泛型 T 为任意实体对象

建议如果存在自定义通用 Service 方法的可能，请创建自己的  IBaseService  继承

Mybatis-Plus 提供的基类

​编辑   官网地址：  https://baomidou.com/pages/49cc81/#service-crud-%E6%8E%A5%E5%8F%A3

MyBatis-Plus中有一个接口 IService和其实现类 ServiceImpl，封装了常见的业务层逻辑

详情查看源码IService和ServiceImp

package com.qcby;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.qcby.entity.User;
import com.qcby.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.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@SpringBootTest
public class MyBatisPlusServiceTest {

    @Autowired
    private UserService userService;

    /*1插入一条记录*/
    @Test
    public void testSave() {
        //INSERT INTO user ( id, name, email ) VALUES ( ?, ?, ? )
        User user = new User();
        user.setName("崽崽");
        user.setEmail("test@test.com");
        userService.save(user);
    }

    /*2批量插入多条记录*/
    @Test
    public void testSaveBatch() {
        //INSERT INTO user ( id, name, email ) VALUES ( ?, ?, ? )
        User user1 = new User();
        user1.setName("崽崽1");
        user1.setEmail("test1@test.com");
        User user2 = new User();
        user2.setName("崽崽2");
        user2.setEmail("test2@test.com");
        User user3 = new User();
        user3.setName("崽崽3");
        user3.setEmail("test3@test.com");
        List<User> list = new ArrayList<>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        userService.saveBatch(list);
    }

    /*3指定次数批量插入多条记录*/
    @Test
    public void testSaveBatchCount() {
        /*==>  Preparing: INSERT INTO user ( id, name, email ) VALUES ( ?, ?, ? )
        ==> Parameters: 1949022674715750402(Long), 崽崽1(String), test1@test.com(String)
        ==> Parameters: 1949022674787053570(Long), 崽崽2(String), test2@test.com(String)
        ==>  Preparing: INSERT INTO user ( id, name, email ) VALUES ( ?, ?, ? )
        ==> Parameters: 1949022674787053571(Long), 崽崽3(String), test3@test.com(String)*/
        User user1 = new User();
        user1.setName("崽崽1");
        user1.setEmail("test1@test.com");
        User user2 = new User();
        user2.setName("崽崽2");
        user2.setEmail("test2@test.com");
        User user3 = new User();
        user3.setName("崽崽3");
        user3.setEmail("test3@test.com");
        List<User> list = new ArrayList<>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        userService.saveBatch(list, 2);
    }

    /*4批量修改插入多条记录*/
    @Test
    public void testSaveOrUpdateBatch() {
        //UPDATE user SET name = ?, email = ? WHERE id = ?
        //INSERT INTO user ( id, name, email ) VALUES ( ?, ?, ? )
        User user1 = new User();
        user1.setId(1L);
        user1.setName("崽崽1");
        user1.setEmail("test1@test.com");
        User user2 = new User();
        user2.setName("崽崽2");
        user2.setEmail("test2@test.com");
        User user3 = new User();
        user3.setName("崽崽3");
        user3.setEmail("test3@test.com");
        List<User> list = new ArrayList<>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        userService.saveOrUpdateBatch(list);
    }

    /*5指定次数批量修改插入多条记录*/
    @Test
    public void testSaveOrUpdateBatchCount() {
        //UPDATE user SET name = ?, email = ? WHERE id = ?
        //INSERT INTO user ( id, name, email ) VALUES ( ?, ?, ? )
        User user1 = new User();
        user1.setId(1L);
        user1.setName("崽崽1");
        user1.setEmail("test1@test.com");
        User user2 = new User();
        user2.setName("崽崽2");
        user2.setEmail("test2@test.com");
        User user3 = new User();
        user3.setName("崽崽3");
        user3.setEmail("test3@test.com");
        List<User> list = new ArrayList<>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        userService.saveOrUpdateBatch(list, 2);
    }

    /*6根据id删除一条记录*/
    @Test
    public void testDeleteById() {
        //DELETE FROM user WHERE id = ?
        userService.removeById(1949023966351687682L);
    }

    /*7根据id删除一条记录是否启用填充*/
    //默认为true
    @Test
    public void testDeleteByIdWithFill() {
        //UPDATE user SET deleted=1 WHERE id=? AND deleted=0
        userService.removeById(2L, true);
    }

    /*8根据实体(id)删除一条记录*/
    @Test
    public void testDelete() {
        //DELETE FROM user WHERE id = ?
        User user = new User();
        user.setId(3L);
        userService.removeById(user);
    }

    /*9根据Map条件删除记录*/
    @Test
    public void testDeleteByMap() {
        //DELETE FROM user WHERE name = ? AND email = ?
        Map<String, Object> map = new HashMap<>();
        map.put("name", "崽崽3");
        map.put("email", "test3@test.com");
        userService.removeByMap(map);
    }

    /*10根据queryWrapper条件删除记录*/
    @Test
    public void testDeleteByQueryWrapper() {
        //DELETE FROM user WHERE name = ? AND email = ?
        User user = new User();
        user.setName("崽崽3");
        user.setEmail("test3@test.com");
        Wrapper<User> wrapper = Wrappers.query(user);
        userService.remove(wrapper);
    }

    /*11根据id批量删除记录*/
    @Test
    public void testRemoveByIds() {
        //DELETE FROM user WHERE id IN ( ?, ?, ? )
        List<Long> ids = new ArrayList<>();
        ids.add(4L);
        ids.add(2L);
        ids.add(5L);
        userService.removeByIds(ids);
    }

    /*12根据id批量删除记录是否启用填充*/
    //默认为true
    @Test
    public void testRemoveByIdsWithFill() {
        //UPDATE user SET deleted=1 WHERE id IN ( ?, ?, ? )
        List<Long> ids = new ArrayList<>();
        ids.add(4L);
        ids.add(2L);
        ids.add(5L);
        userService.removeByIds(ids, true);
    }

    /*13 批量删除记录jdbc批量操作*/
    @Test
    public void testRemoveBatchByIds() {
        //DELETE FROM user WHERE id IN ( ?, ?, ? )
        List<Long> ids = new ArrayList<>();
        ids.add(4L);
        ids.add(2L);
        ids.add(1949028782108868609L);
        userService.removeBatchByIds(ids);
    }

    /*14 jdbc批量删除记录是否启用填充*/
    //默认为true
    @Test
    public void testRemoveBatchByIdsWithFill() {
        //UPDATE user SET deleted=1 WHERE id IN ( ?, ?, ? )
        List<Long> ids = new ArrayList<>();
        ids.add(4L);
        ids.add(2L);
        ids.add(1949028782108868609L);
        userService.removeByIds(ids, true);
    }

    /*15 jdbc批量删除记录分批操作*/
    @Test
    public void testRemoveBatchByIdsInBatches() {
        //DELETE FROM user WHERE id IN ( ?, ?, ? )
        List<Long> ids = new ArrayList<>();
        ids.add(4L);
        ids.add(2L);
        ids.add(1949028782108868609L);
        userService.removeBatchByIds(ids, 2);
    }

    /*16 jdbc批量删除记录分批操作是否启用填充*/
    //默认为true
    @Test
    public void testRemoveBatchByIdsInBatchesWithFill() {
        //UPDATE user SET deleted=1 WHERE id IN ( ?, ?, ? )
        List<Long> ids = new ArrayList<>();
        ids.add(4L);
        ids.add(2L);
        ids.add(1949028782108868609L);
        userService.removeBatchByIds(ids, 2, true);
    }

    /*17 根据id修改记录*/
    @Test
    public void testUpdateById() {
        //UPDATE user SET name = ?, email = ? WHERE id = ?
        User user = new User();
        user.setId(1L);
        user.setName("崽崽1");
        user.setEmail("test1@test.com");
        userService.updateById(user);
    }

    /*18 根据id批量修改记录*/
    @Test
    public void testUpdateBatchById() {
        //UPDATE user SET name = ?, email = ? WHERE id = ?
        User user1 = new User();
        user1.setId(1L);
        user1.setName("崽崽1");
        user1.setEmail("test1@test.com");
        User user2 = new User();
        user2.setId(2L);
        user2.setName("崽崽2");
        user2.setEmail("test2@test.com");
        User user3 = new User();
        user3.setId(3L);
        user3.setName("崽崽3");
        user3.setEmail("test3@test.com");
        List<User> list = new ArrayList<>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        userService.updateBatchById(list);
    }

    /*19 存在就更新，不存在就插入*/
    @Test
    public void testSaveOrUpdate() {
        //UPDATE user SET name = ?, email = ? WHERE id = ?
        //INSERT INTO user ( id, name, email ) VALUES ( ?, ?, ? )
        User user = new User();
        user.setId(1L);
        user.setName("崽崽1");
        user.setEmail("test1@test.com");
        userService.saveOrUpdate(user);
    }

    /*20 根据id查询一条记录*/
    @Test
    public void testSelectById() {
        //SELECT id, name, email FROM user WHERE id = ?
        User user = userService.getById(1L);
        System.out.println(user);
    }

    /*21 根据id批量查询记录*/
    @Test
    public void testSelectBatchIds() {
        //SELECT id, name, email FROM user WHERE id IN ( ?, ?, ? )
        List<Long> ids = new ArrayList<>();
        ids.add(1L);
        ids.add(2L);
        ids.add(3L);
        List<User> list = userService.listByIds(ids);
        System.out.println(list);
    }

    /*22 根据Map条件查询记录返回List*/
    @Test
    public void testSelectByMap() {
        //SELECT id, name, email FROM user WHERE name = ? AND email = ?
        Map<String, Object> map = new HashMap<>();
        map.put("name", "崽崽1");
        map.put("email", "test1@test.com");
        List<User> list = userService.listByMap(map);
        System.out.println(list);
    }

    /*23 根据queryWrapper条件查询一条记录*/
    @Test
    public void testSelectOneByQueryWrapper() {
        //SELECT id, name, email FROM user WHERE name = ? AND email = ?
        User user = new User();
        user.setName("崽崽1");
        user.setEmail("test1@test.com");
        Wrapper<User> wrapper = Wrappers.query(user);
        User result = userService.getOne(wrapper);
        System.out.println(result);
    }

    /*24 根据queryWrapper条件查询一条记录有多个结果时是否抛出异常*/
    //默认为false
    @Test
    public void testSelectOneByQueryWrapperWithException() {
        //SELECT id, name, email FROM user WHERE name = ? AND email = ?
        User user = new User();
        user.setName("崽崽2");
        user.setEmail("test2@test.com");
        Wrapper<User> wrapper = Wrappers.query(user);
        User result = userService.getOne(wrapper, false);
        System.out.println(result);
    }

    /*25 根据Wrapper条件查询一条记录返回Map*/
    @Test
    public void testSelectMapByQueryWrapper() {
        //SELECT id, name, email FROM user WHERE name = ? AND email = ?
        User user = new User();
        user.setName("崽崽2");
        user.setEmail("test2@test.com");
        Wrapper<User> wrapper = Wrappers.query(user);
        Map<String, Object> map = userService.getMap(wrapper);
        System.out.println(map);
    }

    /*26 根据Wrapper条件查询记录getObj转换为指定类型*/
    @Test
    public void testSelectObjByQueryWrapper() {
        //SELECT id, name, email FROM user WHERE name = ? AND email = ?
        User user = new User();
        user.setName("崽崽2");
        user.setEmail("test2@test.com");
        Wrapper<User> wrapper = Wrappers.query(user);
        Long id = userService.getObj(wrapper,obj -> (Long) obj);
        System.out.println(id);
    }

    /*27 查询总记录数*/
    @Test
    public void testSelectCount() {
        //SELECT COUNT(*) FROM user
        long count = userService.count();
        System.out.println(count);
    }

    /*28 查询总记录数*/
    @Test
    public void testSelectCountByQueryWrapper() {
        //SELECT COUNT(*) FROM user WHERE name = ? AND email = ?
        User user = new User();
        user.setName("崽崽2");
        user.setEmail("test2@test.com");
        Wrapper<User> wrapper = Wrappers.query(user);
        long count = userService.count(wrapper);
        System.out.println(count);
    }

    /*29 根据Wrapper条件查询记录返回List*/
    @Test
    public void testSelectListByQueryWrapper() {
        //SELECT id, name, email FROM user WHERE name = ? AND email = ?
        User user = new User();
        user.setName("崽崽2");
        user.setEmail("test2@test.com");
        Wrapper<User> wrapper = Wrappers.query(user);
        List<User> list = userService.list(wrapper);
        System.out.println(list);
    }

    /*30 查询所有返回List*/
    @Test
    public void testSelectAll() {
        //SELECT id, name, email FROM user
        List<User> list = userService.list();
        System.out.println(list);
    }

    /*31 根据Wrapper条件分页查询*/
    @Test
    public void testSelectPageByQueryWrapper() {
        //SELECT id, name, email FROM user WHERE name = ? AND email = ? LIMIT ?, ?
        User user = new User();
        user.setName("崽崽2");
        user.setEmail("test2@test.com");
        Wrapper<User> wrapper = Wrappers.query(user);
        Page<User> page = new Page<>(1, 1);
        IPage<User> result = userService.page(page, wrapper);
        System.out.println(result.getRecords());
        System.out.println(result.getTotal());
    }

    /*32 无条件分页查询*/
    @Test
    public void testSelectPage() {
        //SELECT id, name, email FROM user LIMIT ?, ?
        Page<User> page = new Page<>(2, 2);
        IPage<User> result = userService.page(page);
        System.out.println(result.getRecords());
        System.out.println(result.getTotal());
    }

    /*33 根据Wrapper条件查询返回ListMap*/
    @Test
    public void testSelectListMapByQueryWrapper() {
        //SELECT id, name, email FROM user WHERE name = ? AND email = ?
        User user = new User();
        user.setName("崽崽2");
        user.setEmail("test2@test.com");
        Wrapper<User> wrapper = Wrappers.query(user);
        List<Map<String, Object>> list = userService.listMaps(wrapper);
        System.out.println(list);
    }

    /*34 查询所有返回ListMap*/
    @Test
    public void testSelectAllListMap() {
        //SELECT id, name, email FROM user
        List<Map<String, Object>> list = userService.listMaps();
        System.out.println(list);
    }

    /*35 查询所有返回第一个字段*/
    @Test
    public void testSelectAllList() {
        //SELECT id, name, email FROM user
        List<Object> list = userService.listObjs();
        System.out.println(list);
    }

    /*36 条件查询所有返回第一个字段*/
    @Test
    public void testSelectListByQueryWrapperList() {
        //SELECT id, name, email FROM user WHERE name = ? AND email = ?
        User user = new User();
        user.setName("崽崽2");
        user.setEmail("test2@test.com");
        Wrapper<User> wrapper = Wrappers.query(user);
        List<Object> list = userService.listObjs(wrapper);
        System.out.println(list);
    }

    /*37 查询所有返回第一个字段转换为指定类型*/
    @Test
    public void testSelectAllListWithConvert() {
        //SELECT id, name, email FROM user
        // 获取所有用户的用户名列表
        // 假设有一个UserService接口继承了包含listObjs方法的接口
        List<Long> userIds = userService.listObjs(obj -> (Long) obj);
        System.out.println(userIds);
    }

    /*38 条件查询所有返回第一个字段转换为指定类型*/
    @Test
    public void testSelectListByQueryWrapperListWithConvert() {
        //SELECT id, name, email FROM user WHERE name = ? AND email = ?
        User user = new User();
        user.setName("崽崽2");
        user.setEmail("test2@test.com");
        Wrapper<User> wrapper = Wrappers.query(user);
        // 获取指定条件的用户的用户名列表
        // 假设有一个UserService接口继承了包含listObjs方法的接口
        List<Long> userIds = userService.listObjs(wrapper, obj -> (Long) obj);
        System.out.println(userIds);
    }

    /*39 无条件分页查询返回IPageMap*/
    @Test
    public void testSelectPageListMap() {
        //SELECT id, name, email FROM user LIMIT ?, ?
        Page<Map<String, Object>> page = new Page<>(2, 2);
        IPage<Map<String, Object>> result = userService.pageMaps(page);
        System.out.println(result.getRecords());
        System.out.println(result.getTotal());
    }

    /*40 条件分页查询返回IPageMap*/
    @Test
    public void testSelectPageListByQueryWrapperListMap() {
        //SELECT id, name, email FROM user WHERE name = ? AND email = ? LIMIT ?, ?
        User user = new User();
        user.setName("崽崽2");
        user.setEmail("test2@test.com");
        Wrapper<User> wrapper = Wrappers.query(user);
        Page<Map<String, Object>> page = new Page<>(2, 1);
        IPage<Map<String, Object>> result = userService.pageMaps(page, wrapper);
        System.out.println(result.getRecords());
        System.out.println(result.getTotal());
    }

    /*41 获取对应实体类的baseMapper*/
    @Test
    public void testGetBaseMapper() {
        BaseMapper<User> baseMapper = userService.getBaseMapper();
        System.out.println(baseMapper);
        // 演示如何使用baseMapper 执行sql
        // SELECT id, name, email FROM user WHERE id = ?
        User user = baseMapper.selectById(1L);
        System.out.println(user);
    }

    /*42 获取对应实体类的class*/
    @Test
    public void testGetEntityClass() {
        Class<User> entityClass = userService.getEntityClass();
        System.out.println(entityClass);
    }

}

 

MyBatisPlus Service层的CRUD
qq_44525150的博客
10-25 6841
与Mapper层类似,MybatisPlus也提供了具有通用CRUD功能的Service层接口.本文将介绍如何使用MybatisPlus提供的基类与接口构建我们的Service层,以及如何使用Service层的通用CRUD. 创建UserService接口 在包com.example.service中创建一个UserService接口，并使其继承mybatis-plus提供的IService<T>接口(T表示对应实体类类型)。 package com.example.service; impo
mybatis-plus 批量操作 开启驱动
weixin_47827594的博客
11-12 393
测试插入一万条数据的发现除了拼接SQL的方式需要用5秒多的时间外，Mybatis Batch和原生JDBC Batch都需要50多秒，怎么想都觉得不可能，写法没有问题一定是数据库或者数据库连接配置上有问题。 后来才发现要批量执行的话，JDBC连接URL字符串中需要新增一个参数：rewriteBatchedStatements=true master.jdbc.url=jdbc:mysql://112.126.84.3:3306/outreach_platform?useUnicode=true&ch
006 MyBatis-Plus：Boot方式配置，驱动、url和版本有关，自带日志，理解自增/雪花生效，雪花算法id，逻辑删除，分页，乐/悲观锁，通用枚举，代码生成器，多数据源，MyBatisX插件
aa35434的博客
04-12 3054
一、MyBatis-Plus简介 1、简介 MyBatis-Plus（简称 MP）是一个 MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为 简化开发、提高效率而生。 愿景 我们的愿景是成为 MyBatis 最好的搭档，就像魂斗罗中的 1P、2P，基友搭配，效率翻倍。 2、特性 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作 强大的 CRUD 操作：内置通用 Mapper、通用 Serv
MyBatisPlus（一）概述介绍
星海IT学习之路
09-08 721
一、概述 需要的基础：把MyBatis、Spring、SpringMVC学习了。 为什么要学习它呢？ MyBatisPlus 可以节省我们大量工作时间，所有的CRUD 代码它都可以自动化完成。 比如：JPA、tk-mapper、MyBatisPlus 1.简介 MyBatis-Plus(简称 简称 MP)，是一个 MyBatis 的增强工具包，只做增强不做改变。为简化开发工作、提高生产率而生。 我们的愿景是成为 Mybatis 最好的搭档，就像 魂斗罗 中的 1P 、2P ，基友搭配，效率翻倍。 2.官网
MybatisPlus学习(一)
weixin_47109902的博客
11-08 498
MybatisPlus是基于Mybatis框架基础上开发的增强型工具。主要是为了简化开发、提高效率。
mybatis-plas使用
weixin_43910192的博客
04-19 513
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、mybatis-plas是什么？二、mybatis-plas使用步骤1简单使用2.扩展插入更新自动填充锁查询分页查询删除条件构造器自动生成代码 更加详细的操作：https://baomidou.com 提示：以下是本篇文章正文内容，下面案例可供参考 一、mybatis-plas是什么？ MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window)的.
MybatisPlus,无XML分分钟实现CRUD操作
08-24
与传统的Mybatis不同，MybatisPlus无需编写XML配置文件，即可实现CRUD操作。 MybatisPlus的优点 1. 简洁易用：MybatisPlus提供了简洁易用的API，开发者可以快速实现CRUD操作，无需编写复杂的SQL语句。 2. 自动映射...
MybatisPlus无XML快速实现CRUD教程
"本文将详细介绍如何利用MybatisPlus在不依赖XML的情况下，快速实现数据库CRUD（Create、Read、Update、Delete）操作，以及提供一个实际的案例作为参考。首先，我们创建了一个名为'user'的测试表，包含了基本的字段...
SpringBoot与MybatisPlus整合实现单表CRUD操作示例
- MybatisPlus：一个简化数据库操作的框架，与SpringBoot无缝集成。 - MySQL或其他数据库：数据存储工具，MybatisPlus用于操作数据库表。 - IntelliJ IDEA或Eclipse：常用Java集成开发环境，用于编写和运行...
尚硅谷MyBatisPlus实战教程：通用CRUD与高级技术解析
"尚硅谷MyBatisPlus视频教程" 在当今的Java开发领域，MyBatisPlus（简称MP）...通过这个视频教程，学习者不仅可以掌握MyBatis-Plus的基本使用，还能深入理解其高级特性，从而在实际开发中更高效地利用这一强大的工具。
MyBatis Plus详细教程
code_xiaotian的博客
04-15 14万+
详细介绍了mybatisplus的各个功能，简单又好用！
MybatisPlus
最新发布
luosuss的博客
10-05 1万+
MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生（提供了快速使用mybatis的方式）。或Redirect/*** 编写接口继承BaseMapper接口，* 其中泛型是是与数据表对应的entity类，会根据泛型类的@TableName注解值获取要操作的数据表*/@Mapper/*** 分页查询id大于id的用户集合。
MyBatis-Plus详解
火车头的博客
09-05 3万+
MyBatis-Plus 是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。官网连接池： 传统开发中，每一次请求都要建立一次数据库连接。每一次数据库连接，使用完后都得断开。频繁的数据库连接操作势必占用很多的系统资源，响应速度必定下降。另外，在高并发时，系统资源被毫无顾及的分配出去，如连接过多，也可能导致内存泄漏，服务器崩溃。解决方案： 为数据库连接建立一个“缓冲池”（连接池）。
mybatis-plus的配置和基本的增删改
weixin_40864484的博客
07-24 2万+
第一步 配置数据库和xml 1.数据库配置:根据类的字段创建数据库 CREATE DATABASE mp; USE mp; CREATE TABLE tbl_employee( id INT(11) PRIMARY KEY AUTO_INCREMENT, last_name VARCHAR(50), email VARCHAR(50), gender CHAR(1),...
Mybatis Plus————代码生成器
Morty的技术乐园
06-17 11万+
代码生成器MyBatis Plus是MyBatis的扩展框架，而代码生成器是MP的核心功能之一，另外还有 “条件构造器”和“通用CRUD”等功能。步骤演示mp的代码生成器有两种方式自动生成代码，一种是通过main方法来执行程序，另一种是通过maven插件build产生。第二种方法需要在pom.xml中添加大量的配置信息，因此本人偏向于使用第一种方式。步骤如下：一、添加mybatis plus依赖：...
mybatis-plus超详细讲解
热门推荐
zdsg45的博客
03-27 24万+
mybatis-puls超详细讲解 本文笔记都是观看狂神老师视频手敲的，敲完的时候发现一件挺奔溃的事，视频地址：https://www.bilibili.com/video/BV17E411N7KN视频地址 这个老师讲课真的很好，学java后端的都可以去看一下，从基础到架构很详细，推荐给大家https://space.bilibili.com/95256449/狂神说 最近做项目听到老师讲到使用...
MybatisPlus配置双数据库驱动
马明的博客
01-21 2747
个人博客纯净版 MybatisPlus配置双数据库驱动 | 代码搬运工 最近项目中需要用到2种数据库驱动连接数据库，下面我们基于MybatisPlus实现一下 具体实现 1、在pom.xml中添加如下依赖: <properties> <java.version>1.8</java.version> <lombok.version>1.18.2</lombok.version> <mybatis-plus
Mybatis-Plus使用全解
weixin_33850015的博客
08-06 1万+
2019独角兽企业重金招聘Python工程师标准>>> ...
3. mysql的注解驱动的三种方式_MybatisPlus的各种功能使用笔记综合！
weixin_35120666的博客
01-26 468
零、MybatisPlus特性：无侵入，损耗小，强大的CRUD操作。支持Lambda形式调用，支持多种数据库。支持主键自动生成，支持ActiveRecord模式。支持自定义全局通用操作，支持关键词自动转义。内置全局拦截插件，内置sql注入剥离器。一、快速开始引入依赖com.baomidoumybatis-plus-boot-starter3.4.0配置ymlspring:# MysqL数据库连接d...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值