目 录CONTENT

文章目录

MybatisPlus

Josue
2022-03-14 / 0 评论 / 0 点赞 / 210 阅读 / 8,698 字 / 正在检测是否收录...
温馨提示:
本文最后更新于 2022-08-16,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

官方文档:http://mp.baomidou.com/

一、Mybatis-Plus简介

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

1.1、特性

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

1.2、支持数据库

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

二、入门案列

2.1、开发环境

  • JDK:JDK8+
  • 构建工具:maven 3.5.4
  • MySQL版本:MySQL 8.0
  • Spring Boot:2.6.3
  • MyBatis-Plus:3.5.1

2.2、创建数据库

  • 创建表
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;
  • 添加数据
INSERT INTO user (id, name, age, email) VALUES
	(1, 'Jone', 18, '[email protected]'),
	(2, 'Jack', 20, '[email protected]'),
	(3, 'Tom', 28, '[email protected]'),
	(4, 'Sandy', 21, '[email protected]'),
	(5, 'Billie', 24, '[email protected]')

2.3、创建Spring Boot工程

  • 依赖
<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>

2.4、编写代码

2.4.1、application.yml

spring:
  datasource:
    #配置数据元类型
    type: com.zaxxer.hikari.HikariDataSource
    #连接数据库得各个信息
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=GMT%2B8&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true
    password: a123456
    username: root

#  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

2.4.2、启动类

@SpringBootApplication
@MapperScan("com.jeffshaw.mybatis_plus.mapper")
public class MybatisPlusApplication {

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

}

2.4.3、实体

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

2.4.4、Mapper

public interface UserMapper extends BaseMapper<User> {
}

2.4.5、测试

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

三、基本CRUD

3.1、BaseMapper

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

public interface BaseMapper<T> extends Mapper<T> {
    /**
     * 插入一条记录
     * @param entity 实体对象
     */
    	int insert(T entity);
    
    /**
    * 根据 ID 删除
    * @param id 主键ID
    */
    	int deleteById(Serializable id);

    /**
    * 1、根据实体(ID)删除
    * @param entity 实体对象
    * @since 3.4.4
    */
   		int deleteById(T entity);

    /**
    * 2、根据 columnMap 条件,删除记录
    * @param columnMap 表字段 map 对象
    */
   		int deleteByMap(@Param("cm") Map<String, Object> columnMap);

    /**
    * 3、根据 entity 条件,删除记录
    * @param queryWrapper 实体对象封装操作类(可以为 null,里面的 entity 用于生成 where
    语句)
    *
   		int delete(@Param("ew") Wrapper<T> queryWrapper);

	/**
    * 4、删除(根据ID 批量删除)
    * @param idList 主键ID列表(不能为 null 以及 empty)
    */
   		int deleteBatchIds(@Param("coll") Collection<?> idList);

    /**
    * 5、根据 ID 修改
    * @param entity 实体对象
    */
    	int updateById(@Param("et") T entity);

    /**
    * 6、根据 whereEntity 条件,更新记录
    * @param entity 实体对象 (set 条件值,可以为 null)
    * @param updateWrapper 实体对象封装操作类(可以为 null,里面的 entity 用于生成
    where 语句)
    */
   		 int update(@Param("et") T entity, @Param("ew") Wrapper<T> updateWrapper);

    /**
    * 7、根据 ID 查询
    * @param id 主键ID
    */
    	T selectById(Serializable id);

    /**
    * 8、查询(根据ID 批量查询)
    * @param idList 主键ID列表(不能为 null 以及 empty)
    */
   		 List<T> selectBatchIds(@Param("coll") Collection<? extends Serializable> idList);

    /**
    * 9、查询(根据 columnMap 条件)
    * @param columnMap 表字段 map 对象
    */
   		 List<T> selectByMap(@Param("cm") Map<String, Object> columnMap);

    /** 10、根据 entity 条件,查询一条记录
    * 查询一条记录,例如 qw.last("limit 1") 限制取一条记录, 注意:多条数据会报异常
    * @param queryWrapper 实体对象封装操作类(可以为 null)
    */
        default T selectOne(@Param("ew") Wrapper<T> queryWrapper) {
            List<T> ts = this.selectList(queryWrapper);
            if (CollectionUtils.isNotEmpty(ts)) {
                if (ts.size() != 1) {
                    throw ExceptionUtils.mpe("One record is expected, but the query result is multiple records", new Object[0]);
                } else {
                    return ts.get(0);
                }
            } else {
                return null;
            }
        }

        default boolean exists(Wrapper<T> queryWrapper) {
            Long count = this.selectCount(queryWrapper);
            return null != count && count > 0L;
    }
    
    /**
    * 11、根据 Wrapper 条件,查询总记录数
    * @param queryWrapper 实体对象封装操作类(可以为 null)
    */
    	Long selectCount(@Param("ew") Wrapper<T> queryWrapper);

    /**
    * 12、根据 entity 条件,查询全部记录
    * @param queryWrapper 实体对象封装操作类(可以为 null)
    */
   		 List<T> selectList(@Param("ew") Wrapper<T> queryWrapper);
    /**
    * 13、根据 Wrapper 条件,查询全部记录
    * @param queryWrapper 实体对象封装操作类(可以为 null)
    */
   		 List<Map<String, Object>> selectMaps(@Param("ew") Wrapper<T> queryWrapper);

    /**
    * 14、根据 Wrapper 条件,查询全部记录
    * <p>注意: 只返回第一个字段的值</p>
    * @param queryWrapper 实体对象封装操作类(可以为 null)
    */
   		 List<Object> selectObjs(@Param("ew") Wrapper<T> queryWrapper);

    /**
    * 15、根据 entity 条件,查询全部记录(并翻页)
    * @param page 分页查询条件(可以为 RowBounds.DEFAULT)
    * @param queryWrapper 实体对象封装操作类(可以为 null)
    */
   		 <P extends IPage<T>> P selectPage(P page, @Param("ew") Wrapper<T> queryWrapper);

    /**
    * 16、根据 Wrapper 条件,查询全部记录(并翻页)
    * @param page 分页查询条件
    * @param queryWrapper 实体对象封装操作类
    */
   		 <P extends IPage<Map<String, Object>>> P selectMapsPage(P page, @Param("ew") Wrapper<T> queryWrapper);
}

3.1.1、增

 @Test
    public void testInsert(){
        User user = new User();
        user.setName("jeff");
        user.setAge(25);
        user.setEmail("[email protected]");
		//INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
        int result = userMapper.insert(user);
        System.out.println("受影响行数:"+result);
		//1475754982694199298
        System.out.println("id自动获取:"+user.getId());
    }

3.1.2、删

   @Test
    public void testDeleteById(){
    //通过id删除用户信息
    //DELETE FROM user WHERE id=?
        int result = userMapper.deleteById(1501772394095247361L);
        System.out.println("受影响行数:"+result);
    }

    @Test
    public void testDeleteBatchIds(){
        //通过多个id批量删除
        //DELETE FROM user WHERE id IN ( ? , ? , ? )
        List<Long> idList = Arrays.asList(1L, 2L, 3L);
        int result = userMapper.deleteBatchIds(idList);
        System.out.println("受影响行数:"+result);
    }

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

3.1.3、改

@Test
public void testUpdateById(){
    User user = new User(4L, "admin", 22, null);
    //UPDATE user SET name=?, age=? WHERE id=?
    int result = userMapper.updateById(user);
    System.out.println("受影响行数:"+result);
}

3.1.4、查

	@Test
    public void testSelectById(){
    //根据id查询用户信息
    //SELECT id,name,age,email FROM user WHERE id=?
        User user = userMapper.selectById(4L);
        System.out.println(user);
    }


	@Test
	public void testSelectBatchIds(){
        //根据多个id查询多个用户信息
        //SELECT id,name,age,email FROM user WHERE id IN ( ? , ? )
        List<Long> idList = Arrays.asList(4L, 5L);
        List<User> list = userMapper.selectBatchIds(idList);
        list.forEach(System.out::println);
	}

    @Test
    public void testSelectBatchIds(){
        //根据多个id查询多个用户信息
        //SELECT id,name,age,email FROM user WHERE id IN ( ? , ? )
        List<Long> idList = Arrays.asList(4L, 5L);
        List<User> list = userMapper.selectBatchIds(idList);
        list.forEach(System.out::println);
    }

    @Test
    public void testSelectByMap(){
        //通过map条件查询用户信息
        //SELECT id,name,age,email FROM user WHERE name = ? AND age = ?
        Map<String, Object> map = new HashMap<>();
        map.put("age", 22);
        map.put("name", "admin");
        List<User> list = userMapper.selectByMap(map);
        list.forEach(System.out::println);
    }

    @Test
    public void testSelectList(){
        //查询所有用户信息
        //SELECT id,name,age,email FROM user
        List<User> list = userMapper.selectList(null);
        list.forEach(System.out::println);
    }

3.2、通用Service

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

  • 泛型 T 为任意实体对象

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

/** UserService继承IService模板提供的基础功能 */
public interface UserService extends IService<User> {
}
/**
* ServiceImpl实现了IService,提供了IService中基础功能的实现
* 若ServiceImpl无法满足业务需求,则可以使用自定的UserService定义方法,并在实现类中实现
*/
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}

3.2.1、查询数据

    @Autowired
    private UserService userService;
    
    @Test
    public void testGetCount(){
        long count = userService.count();
        System.out.println("总记录数:" + count);
    }
    @Test
    public void testSaveBatch(){
        // SQL长度有限制,海量数据插入单条SQL无法实行,
        // 因此MP将批量插入放在了通用Service中实现,而不是通用Mapper
        ArrayList<User> users = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            User user = new User();
            user.setName("ybc" + i);
            user.setAge(20 + i);
            users.add(user);
        }
        //SQL:INSERT INTO t_user ( username, age ) VALUES ( ?, ? )
        userService.saveBatch(users);
    }

3.3、自定义Mapper

3.3.1、UserMapper

public interface UserMapper extends BaseMapper<User> {

    List selectByName(String name);
}

3.3.2、UserMapper.xml

  • 特别注意namespace 、id、parameterType、resultType
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.jeffshaw.mybatis_plus.mapper.UserMapper">
    <select id="selectByName" parameterType="String" resultType="com.jeffshaw.mybatis_plus.pojo.User">
        SELECT * FROM user WHERE name=#{name}
    </select>
</mapper>

3.3.3、配置文件yml

mybatis-plus:
	#自定义扫描路径
  mapper-locations: classpath:com/jeffshaw/mybatis_plus/mapper/*.xml 

3.3.4、pom文件

解决:maven项目运行时打包,而java目录下的xml资源在打包时会被忽略。

<build>
    <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
</build>

四、常用注解

4.1、@TableName

用MyBatis-Plus实现基本的CRUD时,我们并没有指定要操作的表,只是在 Mapper接口继承BaseMapper时,设置了泛型User,而操作的表为user表 由此得出结论,MyBatis-Plus在确定操作的表时,由BaseMapper的泛型决定,即实体类型决定,且默认操作的表名和实体类型的类名一致

  • 实体类类型的类名和要操作的表的表名不一致,将报错,实体类类型上添加@TableName(“t_user”),标识实体类对应的表。例如:
@TableName("t_user")
public class user{
	private Long id;
	....
}
  • 如果实体类所对应的表都有固定前缀,可以通过全局配置解决
ybatis-plus:
    configuration:
        # 配置MyBatis日志
        log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    global-config:
        db-config:
        # 配置MyBatis-Plus操作表的默认前缀
        table-prefix: t_

4.2、@TableId

MyBatis-Plus在实现CRUD时,会默认将id作为主键列,并在插入数据时,默认 基于雪花算法的策略生成id。

  • 若实体类和表中表示主键的不是id,而是其他字段,例如uid-------体类中的属性id改为uid,将表中的字段id也改为uid,报错

解决:

@Data
public class User {

    @TableId
    private Long uid ;
    private String name ;
    private Integer age;
    private String  email;
}

  • 实体类中主键对应的属性为id,而表主键的字段为uid要通过@TableId注解的value属性,指定表中的主键字段,@TableId(value=“uid”)

  • 数据库主键需要为自增

A、@TableId的type属性

a、IdType.ASSIGN_ID(默 认)

基于雪花算法的策略生成数据id,与数据库id是否设置自增无关;

b、IdType.AUTO

使用数据库的自增策略,注意,该类型请确保数据库设置了id自增, 否则无效

c、全局配置yml
mybatis-plus:
	global-config:
		db-config:
			id-type: auto	# 配置MyBatis-Plus的主键策略,自增
			id-type: ASSIGN_ID  #配置MyBatis-Plus的主键策略,雪花算法,默认
d、雪花算法

为应对逐渐增长的访问压力和数据量。

数据库的扩展方式主要包括:业务分库、主从复制,数据库分表。

  • 数据库分表:不同业务数据分散存储到不同的数据库服务器,单表数据拆分有两种方式:垂直分表和水平分表。

  • 垂直分表:垂直分表适合将表中某些不常用且占了大量空间的列拆分出去。

  • 水平分表:适合表行数特别大的表。

  • 水平分表相比垂直分表,会引入更多的复杂性,例如要求全局唯一的数据id该如何处理

    • 主键自增。

      以最常见的用户 ID 为例,可以按照 1000000 的范围大小进行分段,1 ~ 999999 放到表 1中,1000000 ~ 1999999 放到表2中,以此类推。
      	- 优点:可以随着数据的增加平滑地扩充新的表。例如,现在的用户是 100 万,如果增加到 1000 万,只需要增加新的表就可以了,原有的数据不需要动.
      	- 缺点:分布不均匀。假如按照 1000 万来进行分表,有可能某个分段实际存储的数据量只有 1 条,而另外一个分段实际存储的数据量有1000万条.
      
    • 取模。

      同样以用户ID为例,假如我们一开始就规划了10个数据库表,可以简单地用user_id % 10 的值来表示数据所属的数据库表编号,ID为985的用户放到编号为5的子表中,ID为10086 的用户放到编号为6的子表中。
      	- 复杂点:初始表数量的确定。表数量太多维护比较麻烦,表数量太少又可能导致单表性能存在问题。
      	- 优点:表分布比较均匀。
      	-缺点:扩充新的表很麻烦,所有数据都要重分布。
      
    • 雪花算法

      由Twitter公布的分布式主键生成算法,它能够保证不同表的主键的不重复性,以及相同表的主键的有序性。
      长度共64bit(一个long型)。
      - 一个符号位,1bit标识。
      - 41bit时间截(毫秒级),存储的是时间截的差值。
      - 10bit作为机器的ID(5个bit是数据中心,5个bit的机器ID,可以部署在1024个节点)
      - 12bit作为毫秒内的流水号(意味着每个节点在每毫秒可以产生4096个ID)
      

4.3、@TableField

MyBatis-Plus在执行SQL语句时,要保证实体类中的属性名和表中的字段名一致。

  • 实体类中的属性使用的是驼峰命名风格,而中的字段使用的是下划线命名风格,mybaits_plus自动转化,mybatis中需要配置。
  • 实体类属性name,表中字段username。实体类属性上使用**@TableField(“username”)**设置属性所对应的字段名。

4.4、@TableLogic

逻辑删除,假删除,将对应数据中代表是否被删除字段的状态修改为“被删除状态”,之后在数据库中仍旧能看到此条数据记录。

实现逻辑删除:

//1.数据库增加id_deleted行,默认0,删除为1;

///、实体类
@Data
public class User {

    @TableId
    private Long uid ;
    private String name ;
    private Integer age;
    private String  email;
    @TableLogic  #逻辑删除
    private Integer isDeleted;
}

五、条件构造器和常用接口

5.1、wapper介绍

Wrapper: 条件构造抽象类,最顶端父类 
	AbstractWrapper : 用于查询条件封装,生成 sql 的 where 条件 
        QueryWrapper : 查询条件封装 
        UpdateWrapper : Update条件封装 
        AbstractLambdaWrapper : 使用Lambda 语法 
            LambdaQueryWrapper :用于Lambda语法使用的查询Wrapper
            LambdaUpdateWrapper : Lambda更新封装Wrapper

5.2、 QueryWrapper

5.2.1、组装查询条件

//查询用户名包含a,年龄在20到30之间,并且邮箱不为null的用户信息
        @Test
    public void queryWrapper(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.like("name","a")
                .between("age",20,30)
                .isNull("email");

        List<User> list = userMapper.selectList(wrapper);
        list.forEach(System.out::println);
    }

5.2.2、组装排序条件

 //按年龄降序查询用户,如果年龄相同则按id升序排列
    @Test
    public void queryWrapperOrder(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.orderByDesc("age").orderByAsc("uid");

        List<User> list = userMapper.selectList(wrapper);
        list.forEach(System.out::println);
    }

5.2.3、条件优先级

//将(年龄大于20并且用户名中包含有a)或邮箱为null的用户信息修改
    @Test
    public void queryWrapper3(){

        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.like("name","a").gt("age",20).or().isNull("email");
        User user = new User();
        user.setAge(100);
        user.setName("AAAAAAA");
        user.setEmail("[email protected]");

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

//将用户名中包含有a并且(年龄大于20或邮箱为null)的用户信息修改
    //UPDATE user SET name=?, age=?, email=? WHERE is_deleted=0 AND (name LIKE ? AND (age > ? OR email IS NULL))
        @Test
        public void queryWrapper4(){

            QueryWrapper<User> wrapper = new QueryWrapper<>();
            wrapper.like("name","a")
                    .and(i->i.gt("age",20).or().isNull("email"));

            User user = new User();
            user.setAge(200);
            user.setName("BBBBB");
            user.setEmail("[email protected]");

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

5.2.4、查询部分字段

//查询用户信息的username和age字段
        @Test
        public void queryWrapper5(){

            QueryWrapper<User> wrapper = new QueryWrapper<>();
            wrapper.select("name","age");

            List<User> list = userMapper.selectList(wrapper);
            list.forEach(System.out::println);
        }

5.2.5、实现子查询

//查询id小于等于3的用户信息
        @Test
        public void queryWrapper6(){
            QueryWrapper<User> wrapper = new QueryWrapper<>();
            wrapper.inSql("uid","select uid from user where uid <= 3");
            List<User> list = userMapper.selectList(wrapper);
            list.forEach(System.out::println);
        }
    }

5.3、UpdateWrapper

//使用UpdateWrapper进行操作
//将(年龄大于20或邮箱为null)并且用户名中包含有a的用户信息修改
//更新数据
UpdateWrapper<User> updateWrapper = new UpdateWrapper();
updateWrapper.set("name","123456")
        .set("age",123)
        .set("email","[email protected]")
        .like("name","a")
        .and(i->i.gt("age",20).or().isNull("email"));
int update = userMapper.update(null, updateWrapper);
System.out.println(update);

5.4、Condition

在真正开发的过程中,组装条件是常见的功能,而这些条件数据来源于用户输入,是可选的,因此我们在组装这些条件时,必须先判断用户是否选择了这些条件,若选择则需要组装该条件,若没有选择则一定不能组装,以免影响SQL执行的结果。

5.4.1、思路一

@Test
public void test08() {
    //定义查询条件,有可能为null(用户未输入或未选择)
    String username = null;
    Integer ageBegin = 10;
    Integer ageEnd = 24;
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    
    //StringUtils.isNotBlank()判断某字符串是否不为空且长度不为0且不由空白符(whitespace)
    if(StringUtils.isNotBlank(username)){
        queryWrapper.like("username","a");
    }
    if(ageBegin != null){
        queryWrapper.ge("age", ageBegin);
    }
    if(ageEnd != null){
        queryWrapper.le("age", ageEnd);
    }
    //SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE (age >=? AND age <= ?)
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

5.4.2、思路二

 //Cndition--02
        @Test
        public void test09() {
            //定义查询条件,有可能为null(用户未输入或未选择)
            String username = null;
            Integer ageBegin = 10;
            Integer ageEnd = 24;
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
           
           //StringUtils.isNotBlank()判断某字符串是否不为空且长度不为0且不由空白符(whitespace)
           
            queryWrapper.like(StringUtils.isNotBlank(username),"username","a");
            queryWrapper.ge(ageBegin!=0,"age", ageBegin);
            queryWrapper.le(ageEnd!=0,"age", ageEnd);
            
            //SELECT id,username ,age,email,is_deleted FROM t_user WHERE (age >=? AND age <= ?)
            List<User> users = userMapper.selectList(queryWrapper);
            users.forEach(System.out::println);
        }

5.5、LambdaQueryWrapper

@Test
public void test10() {
     //定义查询条件,有可能为null(用户未输入)
    String username = "a";
    Integer ageBegin = 10;
    Integer ageEnd = 24;
    LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
    //避免使用字符串表示字段,防止运行时错误
    queryWrapper
        .like(StringUtils.isNotBlank(username), User::getName, username)
        .ge(ageBegin != null, User::getAge, ageBegin)
        .le(ageEnd != null, User::getAge, ageEnd);
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

5.6、LambdaUpdateWrapper

@Test
public void test11(){
    String username = "a";
    Integer ageBegin = 10;
    Integer ageEnd = 24;
    LambdaUpdateWrapper<User> lambdaUpdateWrapper = new LambdaUpdateWrapper();

    lambdaUpdateWrapper.set(User::getAge,313)
        .set(User::getEmail,"[email protected]")
        .set(User::getName,"6666")
        .like(StringUtils.isNotBlank(username),User::getName,"a")
        .gt(ageBegin!=0,User::getAge,ageBegin)
        .lt(ageEnd!=0,User::getAge,ageEnd);
    userMapper.update(null,lambdaUpdateWrapper);
}

六、插件

6.1、分页插件

MyBatis Plus自带分页插件,只要简单的配置即可实现分页功能

6.1.1、配置类

@Configuration
//@MapperScan("com.jeffshaw.mybatis_plus.mapper") //主类是否配置
public class MybatisPlusConfig {

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

6.1.2、使用

@Test
public void testPage(){
    Page<User> page = new Page<>(1,5);
    Page<User> userPage = userMapper.selectPage(page, null);
    List<User> userList = page.getRecords();
    userList.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());
 }

6.2、UserMapper.xml中编写SQL

<!--分页插件xml版-->
    <sql id="BaseColumns" >uid,name,age,email</sql>
    <select id="selectPageVo" resultType="com.jeffshaw.mybatis_plus.pojo.User">
        select <include refid="BaseColumns"></include> from user where is_Deleted = 0 And age > #{age}
</select>
@Test
public void testXmlPageVo(){
    Page<User> page = new Page<>(2,5);
    List list = userMapper.selectPageVo(page, 20);
    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());
}

6.3、乐观锁与悲观锁

6.3.1、场景

一件商品,成本价是80元,售价是100元。老板先是通知小李,说你去把商品价格增加50元。小 李正在玩游戏,耽搁了一个小时。正好一个小时后,老板觉得商品价格增加到150元,价格太 高,可能会影响销量。又通知小王,你把商品价格降低30元。 此时,小李和小王同时操作商品后台系统。

小李操作的时候,系统先取出商品价格100元;小王也在操作,取出的商品价格也是100元

小李将价格加了50元,并将100+50=150元存入了数据库;小王将商品减了30元,并将100-30=70元存入了数据库。

如果没有锁,小李的操作就完全被小王的覆盖了。

6.3.2、乐观锁与悲观锁

**乐观锁:**小王保存价格前,会检查下价格是否被人修改过了。如果被修改过 了,则重新取出的被修改后的价格,150元,这样他会将120元存入数据库。

**悲观锁:**小李取出数据后,小王只能等小李操作完之后,才能对价格进行操作,也会保证最终的价格是120元。

6.3.3、模拟修改冲突

  • 创建表
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)
);
INSERT INTO t_product (id, NAME, price) VALUES (1, '笔记本', 100);
  • 常规操作
/*查询商品数据*/
@Test
public void testConcurrentUpdate() {
    //1、小李
    Product p1 = productMapper.selectById(1L);
    System.out.println("小李取出的价格:" + p1.getPrice());
    //2、小王
    Product p2 = productMapper.selectById(1L);
    System.out.println("小王取出的价格:" + p2.getPrice());

    //3、小李将价格加了50元,存入了数据库
    p1.setPrice(p1.getPrice() + 50);
    int result1 = productMapper.updateById(p1);
    System.out.println("小李修改结果:" + result1);

    //4、小王将商品减了30元,存入了数据库
    p2.setPrice(p2.getPrice() - 30);
    int result2 = productMapper.updateById(p2);
    System.out.println("小王修改结果:" + result2);

    //最后的结果
    Product p3 = productMapper.selectById(1L);
    //价格覆盖,最后的结果:70
    System.out.println("最后的结果:" + p3.getPrice());

}

6.3.4、乐观锁

  • 数据库中添加version字段 取出记录时,获取当前version
SELECT id,`name`,price,`version` FROM product WHERE id=1
  • 更新时,version + 1,如果where语句中的version版本不对,则更新失败
UPDATE product SET price=price+50, `version`=`version` + 1 WHERE id=1 AND `version`=1

Mybatis-Plus实现乐观锁

  • 实体
@Data
public class Product {
    private Long id;
    private String name;
    private Integer price;
    @Version
    private Integer version;
}
  • 添加乐观锁插件配置
@Configuration
//@MapperScan("com.jeffshaw.mybatis_plus.mapper") //主类是否配置
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 分页插件
        interceptor.addInnerInterceptor(new
                PaginationInnerInterceptor(DbType.MYSQL));
        //乐观锁
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return interceptor;
    }
}
  • 代码实现
 /*		乐观锁
        实现数据库中添加version字段
        取出记录时,获取当前version
* */
@Test
public void testConcurrenttVersionUpdate() {
    //1、小李
    Product p1 = productMapper.selectById(1L);
    System.out.println("小李取出的价格:" + p1.getPrice());
    //2、小王
    Product p2 = productMapper.selectById(1L);
    System.out.println("小王取出的价格:" + p2.getPrice());

    //3、小李将价格加了50元,存入了数据库
    p1.setPrice(p1.getPrice() + 50);
    int result1 = productMapper.updateById(p1);
    System.out.println("小李修改结果:" + result1);

    //4、小王将商品减了30元,存入了数据库
    p2.setPrice(p2.getPrice() - 30);
    int result2 = productMapper.updateById(p2);

    if (result2==0){
        //2、小王
        p2 = productMapper.selectById(1L);
        p2.setPrice(p2.getPrice() - 30);
        result2 = productMapper.updateById(p2);
        System.out.println("小王再次取出的价格:" + p2.getPrice());

    }
    System.out.println("小王修改结果:" + result2);

    //最后的结果
    Product p3 = productMapper.selectById(1L);
    //价格覆盖,最后的结果:70
    System.out.println("最后的结果:" + p3.getPrice());

}

七、通用枚举

表中的有些字段值是固定的,例如性别(男或女),此时我们可以使用MyBatis-Plus的通用枚举来实现。

image-20220314162041724

7.1、创建通用枚举类型

@Getter
public enum SexNum {
    MALE(1,"男"),
    FEMALE(2,"女");

    @EnumValue
    private Integer sex;
    private String sexName;

    SexNum(Integer sex, String sexName) {
        this.sex = sex;
        this.sexName = sexName;
    }
}

7.2、配置文件

mybatis-plus:
	# 配置扫描通用枚举
  type-enums-package: com.jeffshaw.mybatis_plus.enums

7.3、代码实现

@Test
public void testSexEnum(){
    User user = new User();
    user.setName("Enum");
    user.setAge(20);
    //设置性别信息为枚举项,会将@EnumValue注解所标识的属性值存储到数据库
    user.setSex(SexNum.MALE);
    //INSERT INTO t_user ( username, age, sex ) VALUES ( ?, ?, ? )
    //Parameters: Enum(String), 20(Integer), 1(Integer)
    userMapper.insert(user);
    System.out.println("-------------");
    List anEnum = userMapper.selectByName("Enum");
    anEnum.forEach(System.out::println);

八、代码生成器

8.1、依赖

<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

8.2、快速生成

@SpringBootTest
public class FastAutoGeneratorTest {

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

        // 1、创建代码生成器
        AutoGenerator mpg = new AutoGenerator();

        // 2、全局配置
        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        //gc.setOutputDir(projectPath + "/src/main/java");
        gc.setOutputDir("D:\\Java\\01_OpenSourceProject\\ggkt-parent\\service\\service_wechat"+"/src/test/java");
        // D:\Java\01_OpenSourceProject\ggkt-parent\service\service_vod\src\test\java

        gc.setServiceName("%sService");	//去掉Service接口的首字母I
        gc.setAuthor("Zephon");
        gc.setOpen(false);
        mpg.setGlobalConfig(gc);

        // 3、数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/glkt_wechat");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("a123456");
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);

        // 4、包配置
        PackageConfig pc = new PackageConfig();
       // pc.setModuleName("service_vod"); //模块名
        pc.setParent("com.zepho");
        pc.setController("controller");
        pc.setEntity("entity");
        pc.setService("service");
        pc.setMapper("mapper");
        mpg.setPackageInfo(pc);

        // 5、策略配置
        StrategyConfig strategy = new StrategyConfig();

//        strategy.setInclude("hospital_set");

        strategy.setNaming(NamingStrategy.underline_to_camel);//数据库表映射到实体的命名策略

        strategy.setColumnNaming(NamingStrategy.underline_to_camel);//数据库表字段映射到实体的命名策略
        strategy.setEntityLombokModel(true); // lombok 模型 @Accessors(chain = true) setter链式操作

        strategy.setRestControllerStyle(true); //restful api风格控制器
        strategy.setControllerMappingHyphenStyle(true); //url中驼峰转连字符

        mpg.setStrategy(strategy);

        // 6、执行
        mpg.execute();
    }

}

九、多数据源

适用于多种场景:纯粹多库、 读写分离、 一主多从、 混合模式等 目前我们就来模拟一个纯粹多库的一个场景,其他场景类似。

9.1、场景说明

我们创建两个库,分别为:mybatis_plus(以前的库不动)与mybatis_plus_1(新建),将 mybatis_plus库的product表移动到mybatis_plus_1库,这样每个库一张表,通过一个测试用例 分别获取用户数据与商品数据,如果获取到说明多库模拟成功。

9.1、创建数据库及表

  • 创建数据库mybatis_plus_1和表product
CREATE DATABASE `mybatis_plus_1` /*!40100 DEFAULT CHARACTER SET utf8mb4 */;
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)
);
//添加数据
INSERT INTO product (id, NAME, price) VALUES (1, '外星人笔记本', 100);

//删除原mybatis_plus库product表
use mybatis_plus;
DROP TABLE IF EXISTS product;

9.2、依赖

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

9.3、配置多数据源

spring:
# 配置多数据源信息
  datasource:
    dynamic:
# 设置默认的数据源或者数据源组,默认值即为master
      primary: master
# 严格匹配数据源,默认false.true未匹配到指定数据源时抛异常,false使用默认数据源
      strict: false
      datasource:
        master:
          url: jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=GMT%2B8&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root
          password: a123456
        slave_1:
          url: jdbc:mysql://localhost:3306/mybatis_plus_1?serverTimezone=GMT%2B8&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root
          password: a123456
# 多主多从                      纯粹多库(记得设置primary)                   混合配置
spring:                               spring:                               spring:
  datasource:                           datasource:                           datasource:
    dynamic:                              dynamic:                              dynamic:
      datasource:                           datasource:                           datasource:
        master_1:                             mysql:                                master:
        master_2:                             oracle:                               slave_1:
        slave_1:                              sqlserver:                            slave_2:
        slave_2:                              postgresql:                           oracle_1:
        slave_3:                              h2:                                   oracle_2:

9.4、创建用户service

public interface UserService extends IService<User> {

}
@DS("master") //指定所操作的数据源
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}

9.5、创建用户product

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

@DS 可以注解在方法上或类上,同时存在就近原则 方法上注解 优先于 类上注解

9.6、代码实现

@Autowired
private UserService userService;
@Autowired
private ProductService productService;

@Test
public void testDynamicDataSource(){
    System.out.println(userService.getById(1L));
    System.out.println(productService.getById(1L));
}

十、MyBatisX插件

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

  • 安装方法:打开 IDEA,进入 File -> Settings -> Plugins -> Browse Repositories,输入 mybatisx 搜索并安装

  • 见官方文档

0

评论区