【漫漫Java路】mybatis-plus

mybatis-plus

入门案例

建表

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

导入依赖

<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>
    <!--导入mysql驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.17</version>
    </dependency>
    <!--简化实体类,用@Data代替getset方法-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.8</version>
    </dependency>

数据源配置

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8
    username: root
    password: mzf200314
    type: com.zaxxer.hikari.HikariDataSource

pojo

package com.fate.demo1.pojo;

import lombok.Data;

/**
 * @author m
 */
@Data
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;

    public User(Long id, String name, Integer age, String email) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.email = email;
    }
}

mapper

继承直接用

package com.fate.demo1.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.fate.demo1.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

/**
 * @author m
 */
@Repository
@Mapper
public interface UserMapper extends BaseMapper<User> {
}

开启日志信息

#日志配置
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

添加

@Test
void add(){
    User user = new User(null, "fate", 17, "asdhjfgah");
    System.out.println(mapper.insert(user));
    System.out.println(user);
}

会获取主键(默认雪花算法生成id)

删除

@Test
void delete(){
    int i = mapper.deleteById(1521849298382331905L);
    System.out.println(i);
}
@Test
void deleteByMap(){
    HashMap<String, Object> stringObjectHashMap = new HashMap<>();
    //会匹配map中设置的条件进行删除操作
    stringObjectHashMap.put("name","张三");
    stringObjectHashMap.put("age",16);
    int i = mapper.deleteByMap(stringObjectHashMap);
    System.out.println(i);
}
@Test
void deleteB(){
    //批量删除
    LinkedList<Integer> integers = new LinkedList<>();
    for (int i = 9; i < 100; i++) {
        integers.add(i);
    }
    int i = mapper.deleteBatchIds(integers);
    System.out.println(i);
}

修改

@Test
void update(){
    //属性如果为null的话该属性不会进行更新
    User fate = new User(11L, "fate", null, null);
    int i = mapper.updateById(fate);
}

查找

@Test
void select(){
    //根据id查询
    User user = mapper.selectById(1);
    //根据id集合查询
    List<Long> asList = Arrays.asList(1L, 2L, 3L, 4L);
    List<User> users = mapper.selectBatchIds(asList);
    //根据map中的条件查询
    HashMap<String, Object> map = new HashMap<>();
    map.put("name","fate");
    List<User> userList = mapper.selectByMap(map);
    //根据条件构造器查询
    LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
    mapper.selectList(wrapper);
    //自定义查询(mybatis怎么写,它就怎么写)
    Map<String, Object> mapById = mapper.selectMapById(1L);
}

Service CRUD接口

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

• 泛型T为任意实体对象

• 建议如果存在自定义通用Service方法的可能,请创建自己的IBaseService继承Mybatis-Plus提供的基类

• 对象 Wrapper 为 条件构造器

public interface UserService extends IService<User> {
}

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

测试

获取记录

@Test
void getCount(){
    System.out.println(userService.count());
}

批量添加

@Test
void insert(){
    //批量添加
    LinkedList<User> users = new LinkedList<User>();
    for (int i = 0; i < 10; i++) {
        User user = new User(null, "test" + i, i, i + "@fate.com");
        users.add(user);
    }
    userService.saveBatch(users);
}

底层采取每个记录分别添加的方式

常见注解

@TableName注解

用于标识实体类在数据库中对应的表名

@Data
@TableName("user")
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;

    public User(Long id, String name, Integer age, String email) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.email = email;
    }
}

使用全局配置,配置表名前缀

global-config:
  db-config:
    table-prefix: 前缀

@TableId注解

• 用于标识主键(mp默认将id作为主键)
• 通过value属性可以设置该属性在表中对应的字段名
• type属性表示主键生成的策略
  • IdType.AUTO(常用):数据库ID自增
    该类型需要确保数据库设置了 ID自增 否则无效
  • IdType.NONE:该类型为未设置主键类型
  • IdType.INPUT:用户输入ID,该类型可以通过自己注册自动填充插件进行填充
  • IdType.ASSIGN_ID(常用):分配ID (主键类型为number或string）, 默认实现类 com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator(雪花算法)
  • IdType.ASSIGN_UUID:分配UUID (主键类型为 string) 默认实现类 com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator(UUID.replace(“-”,“”))

可以使用全局配置来修改主键生成策略

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xpvfyJC3-1651797024023)(https://gitee.com/fatem/markdown_imgs/raw/master/img/202205051101322.png)]

雪花算法

1. 背景
   需要选择合适的方案去应对数据规模的增长,以应对逐渐增长的访问压力和数据量
   数据库的扩展方式主要包括:业务分库、主从复制,数据库分表
2. . 数据库分表
   将不同业务数据分散存储到不同的数据库服务器,能够支撑百万甚至千万用户规模的业务,但如果业务继续发展,同一业务的单表数据也会达到单台数据库服务器的处理瓶颈。例如,淘宝的几亿用户数据,如果全部存放在一台数据库服务器的一张表中,肯定是无法满足性能要求的,此时就需要对单表数据进行拆分。
   单表数据拆分有两种方式:垂直分表和水平分表。示意图如下:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XPz9g0RH-1651797024024)(https://gitee.com/fatem/markdown_imgs/raw/master/img/202205051109112.png)]
3. 垂直分表
   垂直分表适合将表中某些不常用且占了大量空间的列拆分出去
   例如,前面示意图中的nickname和description字段,假设我们是一个婚恋网站,用户在筛选其他用户的时候,主要是用age和sex两个字段进行查询,而nickname和description两个字段主要用于展示,一般不会在业务查询中用到。description本身又比较长,因此我们可以将这两个字段独立到另外一张表中,这样在查询age和sex时,就能带来一定的性能提升
4. 水平分表
   水平分表适合表行数特别大的表,有的公司要求单表行数超过5000万就必须进行分表,这个数字可以作为参考,但并不是绝对标准,关键还是要看表的访问性能。对于一些比较复杂的表,可能超过1000万就要分表了。而对于一些简单的表,即使存储数据超过1亿行,也可以不分表。
   但不管怎样,当看到表的数据量达到千万级别时,作为架构师就要警觉起来,因为这很可能是架构的性能瓶颈或者隐患。
   水平分表相比垂直分表,会引入更多的复杂性,例如要求全局唯一的数据id该如何处理
5. 主键自增
   以最常见的用户ID为例,可以按照1000000 的范围大小进行分段,1 ~ 999999 放到表 1中,1000000 ~ 1999999 放到表2中,以此类推
   复杂点:分段大小的选取。分段太小会导致切分后子表数量过多,增加维护复杂度；分段太大可能会导致单表依然存在性能问题,一般建议分段大小在100万至2000万之间,具体需要根据业务选取合适的分段大小。
   优点:可以随着数据的增加平滑地扩充新的表。例如,现在的用户是100万,如果增加到1000万,只需要增加新的表就可以了,原有的数据不需要动。
   缺点:分布不均匀。假如按照1000万来进行分表,有可能某个分段实际存储的数据量只有1条,而另外一个分段实际存储的数据量有1000万条。
6. 取模
   同样以用户ID为例,假如我们一开始就规划了10个数据库表,可以简单地用user_id%10的值来表示数据所属的数据库表编号,ID为985的用户放到编号为5的子表中,ID为10086的用户放到编号为6的子表中。
   复杂点:初始表数量的确定。表数量太多维护比较麻烦,表数量太少又可能导致单表性能存在问题。
   优点:表分布比较均匀。
   缺点:扩充新的表很麻烦,所有数据都要重分布。
7. 雪花算法:是由Twitter公布的分布式主键生成算法,它能够保证不同表的主键的不重复性,以及相同表的主键的有序性
   长度共64bit(一个long型)。
   首先是一个符号位,1bit标识,由于long基本类型在Java中是带符号的,最高位是符号位,正数是0,负数是1,所以id一般是正数,最高位是0。
   41bit时间截(毫秒级),存储的是时间截的差值(当前时间截-开始时间截),结果约等于69.73年。
   10bit作为机器的ID(5个bit是数据中心,5个bit的机器ID,可以部署在1024个节点)。
   12bit作为毫秒内的流水号(意味着每个节点在每毫秒可以产生4096个ID)

@TableField(“name”)

通过@TableField注解表示属性在数据库中的字段名

@TableLogic(逻辑删除)

设置此注解时,调用删除方法,仅仅只会将对应的属性设置为1,并不会真正删除

wrapper

见名知意

package com.fate.demo1.wapper;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.fate.demo1.mapper.UserMapper;
import com.fate.demo1.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;
import java.util.Map;

@SpringBootTest
public class WapperTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    void select(){
        //条件查询
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.like("name","1")
                .between("age",1,10)
                .isNotNull("email");

        userMapper.selectList(wrapper).forEach(System.out::println);
    }
    @Test
    void select1(){
//        SELECT id,name,age,email,is_deleted FROM user WHERE is_deleted=0 ORDER BY age ASC,id ASC
//        排序查询
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.orderByAsc("age").orderByAsc("id");
        userMapper.selectList(wrapper).forEach(System.out::println);
    }
    @Test
    void delete(){
//        UPDATE user SET is_deleted=1 WHERE is_deleted=0 AND (age BETWEEN ? AND ?)
//        因为设置了逻辑删除,删除语句变为了update
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.between("age",0,1);
        userMapper.delete(wrapper);
    }
    @Test
    void update(){
//        UPDATE user SET age=? WHERE is_deleted=0 AND (age > ? AND email IS NOT NULL)
//        条件修改,修改需要的参数,由实体类传入
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.gt("age",20).isNotNull("email");
        User user = new User(null,null,100,null);
        userMapper.update(user,queryWrapper);
    }
    @Test
    void update1(){
        //lambda表达式中的条件优先执行
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.and(i->i.gt("age",99));
    }
    @Test
    void selectForSome(){
//        SELECT name,age FROM user WHERE is_deleted=0
//        仅查询了部分指定字段
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("name","age");
        List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
        maps.forEach(System.out::println);
    }
    @Test
    void selectSon(){
//        子查询
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.inSql("id","SELECT id FROM user");
        userMapper.selectList(queryWrapper).forEach(System.out::println);
    }
    @Test
    void updateByWrapper(){
//        UPDATE user SET email=? WHERE is_deleted=0 AND (name LIKE ? AND (age > ? OR age BETWEEN ? AND ?))
//        修改属性直接写在wrapper里面
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.like("name","test").
                and(i->i.gt("age",5).or().between("age",10,100));
        updateWrapper.set("email","12345@test.com");
        userMapper.update(null,updateWrapper);
    }
    @Test
    void condition(){
//        SELECT id,name,age,email,is_deleted FROM user WHERE is_deleted=0
        String name=null;
//        SELECT id,name,age,email,is_deleted FROM user WHERE is_deleted=0 AND (name LIKE ?)
        name="test";
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.like(StringUtils.isNotBlank(name),"name",name);
        userMapper.selectList(queryWrapper).forEach(System.out::println);
    }
    @Test
    void lambdaQueryWrapper(){
        //基本使用大差不差(把字段名改成了User::getName格式)LambdaUpdateWrapper同理
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(User::getName,"test");
        userMapper.selectList(wrapper).forEach(System.out::println);
    }
}

插件

添加插件之前需要创建配置类

@Configuration
@MapperScan("com.fate.demo1.mapper")
public class MPConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        //添加分页插件(设置数据库类型)
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return mybatisPlusInterceptor;
    }
}

分页插件

@Test
void page(){
    Page<User> userPage = new Page<>(1,5);
    mapper.selectPage(userPage,null).getRecords().forEach(System.out::println);
    System.out.println(userPage);
}

拦截SQL并添加分页语句

自定义查询的分页操作

IPage<User> getUserToPage(@Param("page") IPage<User> page);

<select id="getUserToPage" resultType="com.fate.demo1.pojo.User">
    select id,name,age,email from user
</select>

@Test
void page2(){
    Page<User> userPage = new Page<>(1,5);
    mapper.getUserToPage(userPage).getRecords().forEach(System.out::println);
    System.out.println(userPage);
}

mp会自动识别你的方法是否是需要返回分页数据

乐观锁

场景

一件商品，成本价是80元，售价是100元。老板先是通知小李，说你去把商品价格增加50元。小李正在玩游戏，耽搁了一个小时。正好一个小时后，老板觉得商品价格增加到150元，价格太高，可能会影响销量。又通知小王，你把商品价格降低30元。
此时，小李和小王同时操作商品后台系统。小李操作的时候，系统先取出商品价格100元；小王也在操作，取出的商品价格也是100元。小李将价格加了50元，并将100+50=150元存入了数据库；小王将商品减了30元，并将100-30=70元存入了数据库。是的，如果没有锁，小李的操作就完全被小王的覆盖了。
现在商品价格是70元，比成本价低10元。几分钟后，这个商品很快出售了1千多件商品，老板亏1万多。

乐观锁与悲观锁

上面的故事，如果是乐观锁，小王保存价格前，会检查下价格是否被人修改过了。如果被修改过了，则重新取出的被修改后的价格，150元，这样他会将120元存入数据库。
如果是悲观锁，小李取出数据后，小王只能等小李操作完之后，才能对价格进行操作，也会保证最终的价格是120元。

模拟修改冲突

CREATE TABLE t_product
(
id BIGINT(20)NOT NULL COMMENT'主键ID',
NAME VARCHAR(30)NULL DEFAULT NULL COMMENT'商品名称',
price INT(11) DEFAULT 0 COMMENT'价格',
VERSION INT(11)DEFAULT 0 COMMENT'乐观锁版本号',PRIMARY KEY(id)
);

pojo,Mapper,service三件套

@TableName("t_product")
@Data
public class Product {
    private Long id;
    private String name;
    private Integer price;
    private Integer version;

    public Product() {
    }

    public Product(Long id, String name, Integer price, Integer version) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.version = version;
    }
}

@Version

表示版本号(表示乐观锁的识别字段)

添加插件

@Configuration
@MapperScan("com.fate.demo1.mapper")
public class MPConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        //添加分页插件(设置数据库类型)
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        //添加乐观锁插件
        mybatisPlusInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return mybatisPlusInterceptor;
    }
}

通用枚举

@EnumValue

将枚举对应的值添加到数据库里

#扫描通用枚举的包
  type-enums-package:  com.fate.demo1.enums

代码生成器

依赖

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.5.1</version>
</dependency>
<dependency>
    <groupId>org.freemarker</groupId>
    <artifactId>freemarker</artifactId>
    <version>2.3.31</version>
</dependency>

运行代码

public class FastAutoGeneratorTest {
public static void main(String[] args) {
    FastAutoGenerator.create("jdbc:mysql://127.0.0.1:3306/mybatis_plus？characterEncoding=utf-8&userSSL=false", "root", "123456").globalConfig(builder -> {
                    builder.author("atguigu") // 设置作者
                    //.enableSwagger() // 开启 swagger 模式
                    .fileOverride() // 覆盖已生成文件
                    .outputDir("D://mybatis_plus"); // 指定输出目录
                    })
                    .packageConfig(builder -> {
                    builder.parent("com.atguigu") // 设置父包名
                    .moduleName("mybatisplus") // 设置父包模块名
                    .pathInfo(Collections.singletonMap(OutputFile.mapperXml,                  
                               "D://mybatis_plus"));
                    // 设置mapperXml生成路径
                    })
                    .strategyConfig(builder -> {
                    builder.addInclude("t_user") // 设置需要生成的表名
                    .addTablePrefix("t_", "c_"); // 设置过滤表前缀
                    })
                    .templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker
                    引擎模板，默认的是Velocity引擎模板
                    .execute();
        }
}

多数据源

创建数据库mybatis_plus_1和表product

CREATE DATABASE mybatis_plus_1;

USE mybatis_plus_1;


CREATE TABLE product
(
    id BIGINT(20) NOT NULL COMMENT '主键id',
    NAME VARCHAR(30) NULL DEFAULT NULL COMMENT '商品名称',
    price INT(11) DEFAULT 0 COMMENT '价格',
    VERSION INT(11) DEFAULT 0 COMMENT '乐观锁版本号',
    PRIMARY KEY (id)
);

依赖

<dependency>
	<groupId>com.baomidou</groupId>
    <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
    <version>3.5.0</version>
</dependency>

配置

spring:
  # 配置数据源信息
  datasource:
    dynamic:
      # 设置默认的数据源或数据源组，默认值即为master
      primary: master
      # 严格匹配数据源，默认false，true未匹配到指定数据源时抛异常，false使用默认数据源
      strict: false
      datasource:
        master:
          url: jdbc:mysql://localhost:3306/mybatis_plus?useSSL=false&serverTimezone=GMT%2B8
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root
          password: root
        save_1:
          url: jdbc:mysql://localhost:3306/mybatis_plus_1?useSSL=false&serverTimezone=GMT%2B8
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root
          password: root

service

@DS("master")
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}

@DS("slave_1")
@Service
public class ProductServiceImpl extends ServiceImpl<ProductMapper, Product> implements ProductService {
}