MyBatis-Plus快速入门

最新推荐文章于 2024-08-06 10:22:43 发布
最新推荐文章于 2024-08-06 10:22:43 发布
阅读量1k 收藏 22
点赞数 33
分类专栏： java 温故知新 文章标签： mybatis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42439945/article/details/135338144
版权

一、MyBatis-Plus快速入门

1.简介

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

image-20240101183427621

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

特性：

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

支持数据库：

  • MySQL，Oracle，DB2，H2，HSQL，SQLite，PostgreSQL，SQLServer，Phoenix，Gauss ，ClickHouse，Sybase，OceanBase，Firebird，Cubrid，Goldilocks，csiidb，informix，TDengine，redshift
  • 达梦数据库，虚谷数据库，人大金仓数据库，南大通用(华库)数据库，南大通用数据库，神通数据库，瀚高数据库，优炫数据库

2.快速入门

  1. 准备数据库脚本

    现有一张 User 表，其表结构如下：

idnameageemail
1Jone18test1@baomidou.com
2Jack20test2@baomidou.com
3Tom28test3@baomidou.com
4Sandy21test4@baomidou.com
5Billie24test5@baomidou.com
DROP TABLE IF EXISTS user;

CREATE TABLE user
(
    id BIGINT(20) NOT NULL COMMENT '主键ID',
    name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
    age INT(11) NULL DEFAULT NULL COMMENT '年龄',
    email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
    PRIMARY KEY (id)
);


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');
  1. 准备boot工程
  2. 导入依赖
<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>
    </dependency>

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

    <!-- 数据库相关配置启动器 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>

    <!-- druid启动器的依赖  -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.2.18</version>
    </dependency>

    <!-- 驱动类-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.28</version>
    </dependency>

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

</dependencies>


<!--    SpringBoot应用打包插件-->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>
  1. 配置文件和启动类
# 连接池配置
spring:
  datasource:
    #  指定数据库驱动类
    driver-class-name: com.mysql.cj.jdbc.Driver
    # 数据库连接信息
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&useSSL=false&zeroDateTimeBehavior=convertToNull
    username: root
    password: 2920749aaqq,.A
    hikari: # 数据库连接池使用 Hikari
      minimum-idle: 5 # 连接池中最小空闲连接数
      maximum-pool-size: 20 # 连接池中允许的最大连接数
      auto-commit: true # 是否自动提交事务
      idle-timeout: 30000 # 连接在连接池中闲置的最长时间，超过这个时间会被释放。
      pool-name: Weblog-HikariCP # 自定义连接池的名字
      max-lifetime: 1800000 # 连接在连接池中的最大存活时间，超过这个时间会被强制关闭。
      connection-timeout: 30000 # 连接的超时时间
      connection-test-query: SELECT 1 # 用于测试连接是否可用的SQL查询

启动类

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

  1. 功能编码

    编写实体类 User.java

@Data
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

编写 Mapper 包下的 UserMapper接口

public interface UserMapper extends BaseMapper<User> {

}

继承mybatis-plus提供的基础Mapper接口，自带crud方法！

  1. 测试和使用

    添加测试类，进行功能测试：

@SpringBootTest
public class Test {
    @Autowired
    private UserMapper userMapper;

    @org.junit.jupiter.api.Test
    public void testSelect() {
        System.out.println(("----- selectAll method test ------"));
        List<User> userList = userMapper.selectList(null);
        userList.forEach(System.out::println);
    }

}

  1. 小结

    通过以上几个简单的步骤，我们就实现了 User 表的 CRUD 功能，甚至连 XML 文件都不用编写！

    从以上步骤中，我们可以看到集成MyBatis-Plus非常的简单，只需要引入 starter 工程，并配置 mapper 扫描路径即可。

二、Mybatis-Plus核心功能

1.基于Mapper接口的CRUD

通用 CRUD 封装BaseMapper接口， Mybatis-Plus 启动时自动解析实体表关系映射转换为 Mybatis 内部对象注入容器! 内部包含常见的单表操作！

1.insert方法

// 插入一条记录
// T 就是要插入的实体对象
int insert(T entity);

测试

@Test

public void testInsert() {
    System.out.println(("----- insert method test ------"));
    User user = new User();
    user.setAge(18);
    user.setName("ts");
    user.setEmail("123@qq.com");
    int i = userMapper.insert(user);
    System.out.println(i);
}

image-20240101211029387

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

2.delete方法

// 根据 entity 条件，删除记录
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);

// 删除（根据ID 批量删除）
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

// 根据 ID 删除
int deleteById(Serializable id);

// 根据 columnMap 条件，删除记录
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
类型参数名描述
Wrapperwrapper实体对象封装操作类（可以为 null）
Collection<? extends Serializable>idList主键 ID 列表(不能为 null 以及 empty)
Serializableid主键 ID
Map<String, Object>columnMap表字段 map 对象

测试

@Test
public void testDelete() {
    System.out.println(("----- delete method test ------"));
    //根据id删除
    int i = userMapper.deleteById(1741809013728202753L);
    System.out.println(i);
    //根据年龄删除
    Map map = new HashMap();
    map.put("age",18);
    int i1 = userMapper.deleteByMap(map);
    log.info(String.valueOf(i1));
}

image-20240101211719132

image-20240101211757432

3.update方法

// 根据 whereWrapper 条件，更新记录
int update(@Param(Constants.ENTITY) T updateEntity, 
            @Param(Constants.WRAPPER) Wrapper<T> whereWrapper);

// 根据 ID 修改  主键属性必须值
int updateById(@Param(Constants.ENTITY) T entity);
类型参数名描述
Tentity实体对象 (set 条件值,可为 null)
WrapperupdateWrapper实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）

测试

@Test
public void testUpdate() {
    System.out.println(("----- update method test ------"));
    //根据id=1修改年龄为30
    User user = new User();
    user.setId(1L);
    user.setAge(30);
    int i = userMapper.updateById(user);
    System.out.println(i);

    //将所有人年龄改为18
    User user1 = new User();
    user1.setAge(18);
    int update = userMapper.update(user1, null);
    System.out.println(update);

}

image-20240101212521029

image-20240101212530931

4.select方法

// 根据 ID 查询
T selectById(Serializable id);

// 根据 entity 条件，查询一条记录
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 查询（根据ID 批量查询）
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

// 根据 entity 条件，查询全部记录
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 查询（根据 columnMap 条件）
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

// 根据 Wrapper 条件，查询全部记录
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 根据 entity 条件，查询全部记录（并翻页）
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 根据 Wrapper 条件，查询全部记录（并翻页）
IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 根据 Wrapper 条件，查询总记录数
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

参数说明

类型参数名描述
Serializableid主键 ID
WrapperqueryWrapper实体对象封装操作类（可以为 null）
Collection<? extends Serializable>idList主键 ID 列表(不能为 null 以及 empty)
Map<String, Object>columnMap表字段 map 对象
IPagepage分页查询条件（可以为 RowBounds.DEFAULT）

测试

@Test
public void testSelect1() {
    System.out.println(("----- select method test ------"));
    User user = userMapper.selectById(2L);

    //根据集合查询
    List<Long> ids = new ArrayList<>();
    ids.add(2L);
    ids.add(3L);
    List<User> users = userMapper.selectBatchIds(ids);
    System.out.println(users);
}

image-20240101213059148

image-20240101213228771

5.自定义和多表映射

mybatis-plus的默认mapperxml位置

mybatis-plus: # mybatis-plus的配置
  # 默认位置 private String[] mapperLocations = new String[]{"classpath*:/mapper/**/*.xml"};    
  mapper-locations: classpath:/mapper/*.xml

自定义mapper方法：

public interface UserMapper extends BaseMapper<User> {

    //正常自定义方法！
    //可以使用注解@Select或者mapper.xml实现
    List<User> queryAll();
}

基于mapper.xml实现：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- namespace = 接口的全限定符 -->
<mapper namespace="com.ts.mapper.UserMapper">

   <select id="queryAll" resultType="com.ts.pojo.User" >
       select * from user
   </select>
</mapper>

测试

@Test
public void testSelect_all() {
    System.out.println(("----- select method test ------"));
    List<User> users = userMapper.queryAll();
    System.out.println(users);
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

image-20240101214027122

2.基于Service接口的CRUD

通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆，

1.对比Mapper接口CRUD区别：

  • service添加了批量方法
  • service层的方法自动添加事务

接口继承IService接口

public interface UserService extends IService<User> {
}

类继承ServiceImpl实现类

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

}

2.CRUD方法介绍

保存：
// 插入一条记录（选择字段，策略插入）
boolean save(T entity);
// 插入（批量）
boolean saveBatch(Collection<T> entityList);
// 插入（批量）
boolean saveBatch(Collection<T> entityList, int batchSize);

修改或者保存：
// TableId 注解存在更新记录，否插入一条记录
boolean saveOrUpdate(T entity);
// 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

移除：
// 根据 queryWrapper 设置的条件，删除记录
boolean remove(Wrapper<T> queryWrapper);
// 根据 ID 删除
boolean removeById(Serializable id);
// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);
// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);

更新：
// 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
boolean update(Wrapper<T> updateWrapper);
// 根据 whereWrapper 条件，更新记录
boolean update(T updateEntity, Wrapper<T> whereWrapper);
// 根据 ID 选择修改
boolean updateById(T entity);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList, int batchSize);

数量： 
// 查询总记录数
int count();
// 根据 Wrapper 条件，查询总记录数
int count(Wrapper<T> queryWrapper);

查询：
// 根据 ID 查询
T getById(Serializable id);
// 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
T getOne(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
T getOne(Wrapper<T> queryWrapper, boolean throwEx);
// 根据 Wrapper，查询一条记录
Map<String, Object> getMap(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

集合：
// 查询所有
List<T> list();
// 查询列表
List<T> list(Wrapper<T> queryWrapper);
// 查询（根据ID 批量查询）
Collection<T> listByIds(Collection<? extends Serializable> idList);
// 查询（根据 columnMap 条件）
Collection<T> listByMap(Map<String, Object> columnMap);
// 查询所有列表
List<Map<String, Object>> listMaps();
// 查询列表
List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
// 查询全部记录
List<Object> listObjs();
// 查询全部记录
<V> List<V> listObjs(Function<? super Object, V> mapper);
// 根据 Wrapper 条件，查询全部记录
List<Object> listObjs(Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录
<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

3.分页查询实现

1.导入分页插件

新建com/ts/config/MybatisPlusConfig.java

@Configuration
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return interceptor;
    }
}

2.使用分页查询

@Test
public void testPageQuery(){
    //设置分页参数
    Page<User> page = new Page<>(1, 2);
    userMapper.selectPage(page, null);
    //获取分页数据
    List<User> list = page.getRecords();
    list.forEach(System.out::println);
    System.out.println("当前页："+page.getCurrent());
    System.out.println("每页显示的条数："+page.getSize());
    System.out.println("总记录数："+page.getTotal());
    System.out.println("总页数："+page.getPages());
    System.out.println("是否有上一页："+page.hasPrevious());
    System.out.println("是否有下一页："+page.hasNext());
}

image-20240101220943095

3.自定义mapper方法使用分页

在接口中自定义方法

//传入参数携带Ipage接口
//返回结果为IPage
IPage<User> selectPageList(IPage<?> page, Integer id);

接口实现

<select id="selectPageList" resultType="com.ts.pojo.User">
    select * from user where age = #{id}
</select>

测试

@Test
public void testQuick(){
    IPage page = new Page(1,3);
    userMapper.selectPageList(page,18);
    long current = page.getCurrent();
    System.out.println("current = " + current);
    long pages = page.getPages();
    System.out.println("pages = " + pages);
    long total = page.getTotal();
    System.out.println("total = " + total);
    List records = page.getRecords();
    System.out.println("records = " + records);
}

image-20240101221052884

4.条件构造器使用

1.条件构造器作用

实例代码：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "ts"); // 添加等于条件
queryWrapper.ne("age", 18); // 添加不等于条件
queryWrapper.like("email", "@gmail.com"); // 添加模糊匹配条件
等同于： 
delete from user where name = "ts" and age != 18
                                  and email like "%@gmail.com%"
// 根据 entity 条件，删除记录
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);

使用MyBatis-Plus的条件构造器，可以构建灵活、高效的查询条件，而不需要手动编写复杂的 SQL 语句。它提供了许多方法来支持各种条件操作符，并且可以通过链式调用来组合多个条件。这样可以简化查询的编写过程，并提高开发效率。

2.条件构造器继承结构

条件构造器类结构：

image-20240101222221450

Wrapper ： 条件构造抽象类，最顶端父类

  • AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件
    • QueryWrapper ： 查询/删除条件封装
    • UpdateWrapper ： 修改条件封装
    • AbstractLambdaWrapper ： 使用Lambda 语法
      • LambdaQueryWrapper ：用于Lambda语法使用的查询Wrapper
      • LambdaUpdateWrapper ： Lambda 更新封装Wrapper

3.基于QueryWrapper组装条件

image-20240101222621019

组装查询条件：

@Test
public void test01(){
    //查询用户名包含a，年龄在20到30之间，并且邮箱不为null的用户信息
    //SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0 AND (name LIKE ? AND age BETWEEN ? AND ? AND email IS NOT NULL)
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.like("name", "ts")
            .between("age", 20, 30)
            .isNotNull("email");
    List<User> list = userMapper.selectList(queryWrapper);
    list.forEach(System.out::println);
}

image-20240102075130144

组装排序条件:

@Test
public void test02(){
    //按年龄降序查询用户，如果年龄相同则按id升序排列
    //SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0 ORDER BY age DESC,id ASC
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper
            .orderByDesc("age")
            .orderByAsc("id");
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

image-20240102075112339

组装删除条件:

@Test
public void test03(){
    //删除email为空的用户
    //DELETE FROM t_user WHERE (email IS NULL)
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.isNull("email");
    //条件构造器也可以构建删除语句的条件
    int result = userMapper.delete(queryWrapper);
    System.out.println("受影响的行数：" + result);
}

image-20240102075226746

and和or关键字使用(修改)：

@Test
public void test04() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //将年龄大于20并且用户名中包含有a或邮箱为null的用户信息修改
    //UPDATE t_user SET age=?, email=? WHERE name LIKE ? AND age > ? OR email IS NULL)
    queryWrapper
            .like("name", "a")
            .gt("age", 20)
            .or()
            .isNull("email");
    User user = new User();
    user.setAge(18);
    user.setEmail("user@atguigu.com");
    int result = userMapper.update(user, queryWrapper);
    System.out.println("受影响的行数：" + result);
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

指定列映射查询：

@Test
public void test05() {
    //查询用户信息的name和age字段
    //SELECT name,age FROM t_user
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.select("name", "age");
    //selectMaps()返回Map集合列表，通常配合select()使用，避免User对象中没有被查询到的列值为null
    List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
    maps.forEach(System.out::println);
}

image-20240102075348482

condition判断组织条件:

@Test
public void testQuick3(){
    
    String name = "root";
    int    age = 18;

    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //判断条件拼接
    //当name不为null拼接等于, age > 1 拼接等于判断
    //方案1: 手动判断
    if (!StringUtils.isEmpty(name)){
        queryWrapper.eq("name",name);
    }
    if (age > 1){
        queryWrapper.eq("age",age);
    }
    
    //方案2: 拼接condition判断
    //每个条件拼接方法都condition参数,这是一个比较运算,为true追加当前条件!
    //eq(condition,列名,值)
    queryWrapper.eq(!StringUtils.isEmpty(name),"name",name)
            .eq(age>1,"age",age);  
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

image-20240102075558377

4.基于UpdateWrapper组装条件

使用queryWrapper:

@Test
public void test04() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //将年龄大于20并且用户名中包含有a或邮箱为null的用户信息修改
    //UPDATE t_user SET age=?, email=? WHERE name LIKE ? AND age > ? OR email IS NULL)
    queryWrapper
            .like("name", "a")
            .gt("age", 20)
            .or()
            .isNull("email");
    User user = new User();
    user.setAge(18);
    user.setEmail("123@ts.com");
    int result = userMapper.update(user, queryWrapper);
    System.out.println("受影响的行数：" + result);
}

image-20240102094301866

注意：使用queryWrapper + 实体类形式可以实现修改，但是无法将列值修改为null值！

使用updateWrappe

@Test
public void test16(){

    UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
    //将id = 3 的email设置为null, age = 18
    updateWrapper.eq("id",3)
            .set("email",null)  // set 指定列和结果
            .set("age",18);
    //如果使用updateWrapper 实体对象写null即可!
    int result = userMapper.update(null, updateWrapper);
    System.out.println("result = " + result);

}

使用updateWrapper可以随意设置列的值！！

image-20240102094401819

5.基于LambdaQueryWrapper组装条件

1.LambdaQueryWrapper对比QueryWrapper优势

LambdaQueryWrapper与QueryWrapper使用一样，只是对QueryWrapper做了增强，通过类名::形式，防止列明写错。

QueryWrapper 示例代码：

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "John")
  .ge("age", 18)
  .orderByDesc("create_time")
  .last("limit 10");
List<User> userList = userMapper.selectList(queryWrapper);

LambdaQueryWrapper 示例代码：

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.eq(User::getName, "John")
  .ge(User::getAge, 18)
  .orderByDesc(User::getCreateTime)
  .last("limit 10");
List<User> userList = userMapper.selectList(lambdaQueryWrapper);

从上面的代码对比可以看出，相比于 QueryWrapper，LambdaQueryWrapper 使用了实体类的属性引用（例如 User::getName、User::getAge），而不是字符串来表示字段名，这提高了代码的可读性和可维护性。

2.lambda表达式回顾

方法引用是 Java 8 中引入的一种语法特性，它提供了一种简洁的方式来直接引用已有的方法或构造函数。方法引用可以替代 Lambda 表达式，使代码更简洁、更易读。

Java 8 支持以下几种方法引用的形式：

  1. 静态方法引用： 引用静态方法，语法为 类名::静态方法名。
  2. 实例方法引用： 引用实例方法，语法为 实例对象::实例方法名。
  3. 对象方法引用： 引用特定对象的实例方法，语法为 类名::实例方法名。
  4. 构造函数引用： 引用构造函数，语法为 类名::new。

演示代码:

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class MethodReferenceExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("John", "Tom", "Alice");
        // 使用 Lambda 表达式
        names.forEach(name -> System.out.println(name));
        // 使用方法引用
        names.forEach(System.out::println);
    }
}

使用案例：

@Test
public void tes17(){
    String name = "Tom";
    int age = 18;
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //每个条件拼接方法都condition参数,这是一个比较运算,为true追加当前条件!
    //eq(condition,列名,值)
    queryWrapper.eq(!StringUtils.isBlank(name),"name",name)
            .eq(age>1,"age",age);

    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //注意: 需要使用方法引用
    //技巧: 类名::方法名
    lambdaQueryWrapper.eq(!StringUtils.isBlank(name), User::getName,name);
    List<User> users= userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

image-20240102100050002

6.基于LambdaUpdateWrapper组装条件

使用案例:

@Test
public void test18(){

    UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
    //将id = 3 的email设置为null, age = 18
    updateWrapper.eq("id",3)
            .set("email",null)  // set 指定列和结果
            .set("age",18);

    //使用lambdaUpdateWrapper
    LambdaUpdateWrapper<User> updateWrapper1 = new LambdaUpdateWrapper<>();
    updateWrapper1.eq(User::getId,3)
            .set(User::getEmail,null)
            .set(User::getAge,18);

    //如果使用updateWrapper 实体对象写null即可!
    int result = userMapper.update(null, updateWrapper1);
    System.out.println("result = " + result);
}

image-20240102100234630

image-20240102100346665

5.核心注解使用

MyBatis-Plus是一个基于MyBatis框架的增强工具，提供了一系列简化和增强的功能，用于加快开发人员在使用MyBatis进行数据库访问时的效率。

MyBatis-Plus提供了一种基于注解的方式来定义和映射数据库操作，其中的注解起到了重要作用。

1.@TableName注解

表名注解，标明实体类对应的表

@Data
@TableName("t_user")//数据库表名
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

特殊情况：如果表名和实体类名相同（忽略大小写）可以省略该注解！

也可以设置全局前缀：

在配置文件中

mybatis-plus:
  global-config:
    db-config:
      table-prefix: t_

2.@TableId 注解

主键注解

@TableName("t_user")
public class User {
    @TableId(value="主键列名",type=主键策略)
    private Long id;
    private String name;
    private Integer age;
    private String email;
}
属性类型必须指定默认值描述
valueString否“”主键字段名
typeEnum否IdType.NONE指定主键类型

IdType属性可选值：

值描述
AUTO数据库 ID 自增 (mysql配置主键自增长)
ASSIGN_ID（默认）分配 ID(主键类型为 Number(Long )或 String)(since 3.3.0),使用接口IdentifierGenerator的方法nextId(默认实现类为DefaultIdentifierGenerator雪花算法)

全局配置修改主键策略:

mybatis-plus:
  global-config:
    db-config:
      # 配置MyBatis-Plus的主键策略
      id-type: auto

在以下场景下，添加@TableId注解是必要的：

  1. 实体类的字段与数据库表的主键字段不同名：如果实体类中的字段与数据库表的主键字段不一致，需要使用@TableId注解来指定实体类中表示主键的字段。
  2. 主键生成策略不是默认策略：如果需要使用除了默认主键生成策略以外的策略，也需要添加@TableId注解，并通过value属性指定生成策略。

3.@TableField

描述：字段注解（非主键）

@Data
@TableName("t_user")//数据库表名
public class User {
    private Long id;
    @TableField(value = "name",exist = true)
    private String name;
    private Integer age;
    private String email;
}
属性类型必须指定默认值描述
valueString否“”数据库字段名
existboolean否true是否为数据库表字段

MyBatis-Plus会自动开启驼峰命名风格映射!!!

三、Mybatis-Plus高级扩展

1.逻辑删除实现

概念:

逻辑删除，可以方便地实现对数据库记录的逻辑删除而不是物理删除。逻辑删除是指通过更改记录的状态或添加标记字段来模拟删除操作，从而保留了删除前的数据，便于后续的数据分析和恢复。

  • 物理删除：真实删除，将对应数据从数据库中删除，之后查询不到此条被删除的数据
  • 逻辑删除：假删除，将对应数据中代表是否被删除字段的状态修改为“被删除状态”，之后在数据库中仍旧能看到此条数据记录

逻辑删除实现:

1.数据库和实体类添加逻辑删除字段

可以是一个布尔类型、整数类型或枚举类型。

ALTER TABLE USER ADD deleted INT DEFAULT 0 ;  # int 类型 1 逻辑删除 0 未逻辑删除

2.实体类添加逻辑删除属性

单一指定

@Data
public class User {

   // @TableId
    private Integer id;
    private String name;
    private Integer age;
    private String email;
    
    @TableLogic
    //逻辑删除字段 int mybatis-plus下,默认 逻辑删除值为1 未逻辑删除 1 
    private Integer deleted;
}

全局指定

mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: deleted # 全局逻辑删除的实体字段名(since 3.3.0,配置后可以忽略不配置步骤2)
      logic-delete-value: 1 # 逻辑已删除值(默认为 1)
      logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)

3.演示逻辑删除操作

逻辑删除以后,没有真正的删除语句,删除改为修改语句!

删除代码:

//逻辑删除
@Test
public void test19(){
    //逻辑删除
    userMapper.deleteById(5);
}

执行效果:

image-20240102103738266

4.测试查询数据

@Test
public void testQuick6(){
    //正常查询.默认查询非逻辑删除数据
    userMapper.selectList(null);
}

//SELECT id,name,age,email,deleted FROM user WHERE deleted=0

image-20240102103841543

2.乐观锁实现

1.悲观锁和乐观锁场景和介绍

image-20240102105806690

**解决思路: **

乐观锁和悲观锁是在并发编程中用于处理并发访问和资源竞争的两种不同的锁机制!!

悲观锁：
悲观锁的基本思想是，在整个数据访问过程中，将共享资源锁定，以确保其他线程或进程不能同时访问和修改该资源。悲观锁的核心思想是"先保护，再修改"。在悲观锁的应用中，线程在访问共享资源之前会获取到锁，并在整个操作过程中保持锁的状态，阻塞其他线程的访问。只有当前线程完成操作后，才会释放锁，让其他线程继续操作资源。这种锁机制可以确保资源独占性和数据的一致性，但是在高并发环境下，悲观锁的效率相对较低。

乐观锁：
乐观锁的基本思想是，认为并发冲突的概率较低，因此不需要提前加锁，而是在数据更新阶段进行冲突检测和处理。乐观锁的核心思想是"先修改，后校验"。在乐观锁的应用中，线程在读取共享资源时不会加锁，而是记录特定的版本信息。当线程准备更新资源时，会先检查该资源的版本信息是否与之前读取的版本信息一致，如果一致则执行更新操作，否则说明有其他线程修改了该资源，需要进行相应的冲突处理。乐观锁通过避免加锁操作，提高了系统的并发性能和吞吐量，但是在并发冲突较为频繁的情况下，乐观锁会导致较多的冲突处理和重试操作。

具体技术和方案:

  1. 乐观锁实现方案和技术：
    • 版本号/时间戳：为数据添加一个版本号或时间戳字段，每次更新数据时，比较当前版本号或时间戳与期望值是否一致，若一致则更新成功，否则表示数据已被修改，需要进行冲突处理。
    • CAS（Compare-and-Swap）：使用原子操作比较当前值与旧值是否一致，若一致则进行更新操作，否则重新尝试。
    • 无锁数据结构：采用无锁数据结构，如无锁队列、无锁哈希表等，通过使用原子操作实现并发安全。
  2. 悲观锁实现方案和技术：
    • 锁机制：使用传统的锁机制，如互斥锁（Mutex Lock）或读写锁（Read-Write Lock）来保证对共享资源的独占访问。
    • 数据库锁：在数据库层面使用行级锁或表级锁来控制并发访问。
    • 信号量（Semaphore）：使用信号量来限制对资源的并发访问。

介绍版本号乐观锁技术的实现流程:

  • 每条数据添加一个版本号字段version
  • 取出记录时，获取当前 version
  • 更新时，检查获取版本号是不是数据库当前最新版本号
  • 如果是[证明没有人修改数据], 执行更新, set 数据更新 , version = version+ 1
  • 如果 version 不对[证明有人已经修改了]，我们现在的其他记录就是失效数据!就更新失败
2.使用mybatis-plus数据使用乐观锁

1.添加版本号更新插件

@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor(){
    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    //  版本号更新插件
    interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
    return interceptor;
}

2.乐观锁字段添加@Version注解

注意: 数据库也需要添加version字段

ALTER TABLE USER ADD VERSION INT DEFAULT 1 ;  # int 类型 乐观锁字段
  • 支持的数据类型只有:int,Integer,long,Long,Date,Timestamp,LocalDateTime
  • 仅支持 updateById(id) 与 update(entity, wrapper) 方法
@Version
private Integer version;

@Test
public void test21(){
    //步骤1: 先查询,在更新 获取version数据
    //同时查询两条,但是version唯一,最后更新的失败
    User user  = userMapper.selectById(1);
    User user1  = userMapper.selectById(1);
    System.out.println(user);
    user.setAge(20);
    user1.setAge(30);

    userMapper.updateById(user);
    //乐观锁生效,失败!
    userMapper.updateById(user1);
}

image-20240102123745309

3.防全表更新和删除实现

针对 update 和 delete 语句 作用: 阻止恶意的全表更新删除

添加防止全表更新和删除拦截器

@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
  MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
  interceptor.addInnerInterceptor(new BlockAttackInnerInterceptor());
  return interceptor;
}
}

测试全部更新或者删除

@Test
public void test22(){
    User user = new User();
    user.setName("ts");
    //Caused by: com.baomidou.mybatisplus.core.exceptions.MybatisPlusException: Prohibition of table update operation
    //全局更新,报错
    userService.saveOrUpdate(user,null);
}
伊泽瑞尔ts
关注
  • 33
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mybatis-plus快速入门项目-mybatis-plus基本操作大全-附带sql+项目文档
11-24
这个“mybatis-plus快速入门项目”是专为初学者设计的，旨在帮助他们快速掌握MyBatis-Plus的基本操作。在这个项目中，你将学习到如何配置、使用以及执行各种SQL操作。 1. **MyBatis-Plus简介** MyBatis-Plus（简称...
MyBatis-Plus 快速入门案例(小白教程)
08-24
MyBatis-Plus 快速入门案例 MyBatis-Plus 是一个基于 MyBatis 的增强型持久层框架，提供了许多实用的功能，例如自动化的 SQL 生成、分页插件、performance analysis 等。本文将指导读者快速入门 MyBatis-Plus，并...
Mybatis-Plus快速入门
qi341500的博客
08-27 702
一、基础工程 1、创建一个数据库：mp 2、添加数据 3、创建初始工程 4、添加依赖
Mybatis-plus快速入门
qq_48575500的博客
08-10 1092
MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
mybatis-plus快速入门
weixin_43785508的博客
04-08 1349
mybatis-plus是什么 MyBatis-Plus（简称 MP）是一个 MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生 快速入门 开发环境 IDE：idea 2019.2 JDK：JDK8 构建工具：maven 3.x MySQL版本：MySQL 8.0.27 Spring Boot：2.x MyBatis-Plus：3.5.1 创建表 CREATE DATABASE `mybatis_plus` /*!40100 DEFAULT CHARACTER
MyBatis-Plus快速入门-(干货满满+超详细)
热门推荐
一个爱运动的程序员的博客
01-15 6万+
文章目录一、MyBatis VS JPA二、MyBatis-Plus简介三、MyBatis-Plus快速入门1、lombok简介及安装2、入门小案例四、基本使用1、通用传统模式简介及通用mapper新增方法2、常用注解3、排除非表字段的三种方式五、MyBatis-Plus查询方法 一、MyBatis VS JPA JPA： java持久层API，可以理解为一种规范，Hibernate就是其具体一个实现。（目前比较常用的是SpringDataJpa，它是Spring提供的一套简化开发的框架，按照约定好的方法命
史上最简单的mybatis-plus快速入门
qq_51269815的博客
04-16 1820
mybatis-plus快速入门 介绍： Mybatis-Plus(简称MP）是一个Mybatis的增强工具，在Mybatis的基础上只做增强不做改变，为简化开发，提高效率而生。 数据库表： -- 创建表 CREATE TABLE tbl_employee( id INT(11) PRIMARY KEY AUTO_INCREMENT, last_name VARCHAR(50), email VARCHAR(50), gender CHAR(1), age INT ); INS
SpringBoot集成MyBatis-Plus快速入门Demo
mickey2007的博客
03-31 2115
MyBatis-Plus（简称 MP）是一个MyBatis的增强工具，在MyBatis的基础上只做增强不做改变，为简化开发、提高效率而生。
SpringBoot集成Mybatis-Plus快速入门（详细）
lj20020302的博客
03-06 1094
SpringBoot集成Mybatis-Plus
Mybatis-Plus快速入门开发
m0_63144319的博客
07-17 219
其他的字段正常，但是自增属性的id却是有误的，可以看到，数据已经写入到了数据库，但是，id的值不正确，我们期望的是数据库自增长，实际是MP生成了id的值写入到了数据库。自此，编写数据库语句的操作就不用再自己编写，全部继承自BaseMapper中。如何设置id的生成策略呢？
Mybatis-Plus 快速入门
qq_57389269的博客
07-26 451
MP是对Mybatis的开发简化，目前我们可以简单将其理解为MP封装了各种SQL语句。这样一来我们在开发时便可以利用MP提供的BaseMapper接口完成对数据库的各种操作，而不是亲自编写Mapper接口，同时mapper.xml也变得不必要。.........
MyBatis-Plus入门+MyBatis-Plus文档手册 中文pdf高清版.rar
11-09
mybatis在持久层框架中还是比较火的，一般项目都是基于ssm。虽然mybatis可以直接在xml中...《MyBatis-Plus入门文档》主要介绍了MyBatis-Plus入门使用，以及关于mybatis-plus的更多介绍及特性，感兴趣的可以下载学习一下
持久层开源工具MyBatis-Plus快速入门，Spring Boot整合MyBatis-Plus简化开发示例代码
06-27
MyBatis-Plus是一个在MyBatis基础上进行扩展的轻量级框架，它极大地简化了对数据库的操作，提供了包括插入、删除、更新、查询在内的多种便捷功能。在本示例中，我们将探讨如何使用MyBatis-Plus与Spring Boot集成，以...
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 422
使用TCP协议支持与多个客户端同时通信。
C++ - 函数重载
最新发布
jiaowenjie的专栏
08-06 180
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
枚举工具类
qq_43049583的博客
08-04 407
java枚举工具类
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 1253
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
MyBatis-Plus快速入门与特性详解
MyBatis-Plus（简称MP）是...MyBatis-Plus作为MyBatis的增强工具，为开发者提供了丰富的功能和易用性，尤其适合那些寻求快速开发和简化开发流程的项目。通过合理的利用其特性，可以显著提升开发效率，降低代码复杂度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值