0


Mybatis-plus核心功能及一些插件的配置

前言

Mybatis-plus(简称 MP)是一个Mybatis的增强工具,在 MyBatis 的基础上只做增强不做改变,为简化开发、提高效率而生。本文基于mybatis_plus官方文档学习,主要对Mybatis-plus核心功能的CRUD接口、条件构造器、主键策略做个说明和扩展。在学习之前,需要对mybatis有所了解,可以参考博主以前的文章。(MP作者的愿景是让Mybatis-plus成为 MyBatis 最好的搭档,就像魂斗罗中的 1P、2P,基友搭配,效率翻倍。)

一、第一个Mybatis-plus程序

1、创建一个springboot的项目,可以参考博主以前的博客:

如何用IDEA创建SpringBoot项目_全村第二帅的博客-CSDN博客_idea创建springboot项目步骤

2、导入相关依赖

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

3、创建一个数据库,库名为mybatis_plus,表名为user(这里直接用官网的)

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, '[email protected]'),
(2, 'Jack', 20, '[email protected]'),
(3, 'Tom', 28, '[email protected]'),
(4, 'Sandy', 21, '[email protected]'),
(5, 'Billie', 24, '[email protected]');

4、配置数据库连接和输出日志

#数据库连接配置
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?useSSL=true&useUnicode=true&useCharacter=UTF-8
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#配置日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

5、配置实体类,使用lombok简化配置,无需再写set/get方法、toString方法

package com.study.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

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

6、编写UserMapper接口

可以直接在类上添加@Mapper注解,也可以在该类上加上@Repository注解、springboot启动类上加上@MapperScan("com.study.mapper")扫描mapper包的注解。然后在对应的Mapper上面继承基本的类BaseMapper,所有的CRUD操作依旧编写完成了,而不再需要像以前那样配置一大堆的文件了。

package com.study.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.study.pojo.User;
import org.apache.ibatis.annotations.Mapper;

//在对应的Mapper上面继承基本的类BaseMapper
@Mapper
public interface UserMapper extends BaseMapper<User> {
    
}

阅读源码BaseMapper.java,可以发现该接口封装了许多CRUD的操作方法

7、编写测试类

@SpringBootTest
class MybatisPlusStudyApplicationTests {
    @Autowired
    private UserMapper userMapper;

    @Test
    void contextLoads() {
        //查询全部的用户
        List<User> users = userMapper.selectList(null);
        //users.forEach(System.out::println);
        for (User user : users) {
            System.out.println(user);
        }
    }

我们编写一个测试类,查询所有的用户。使用selectList方法进行所有用户的查询,阅读源码可知,它的参数是一个条件构造器wrapper,且可以为空null。由于查询的是所有的用户,返回的是多条记录,所以用list集合接收,最后用增强for循环遍历输出,还可以用foreach遍历输出。(条件构造器后面再介绍,这里先不用)

8、测试结果

二、执行SQL打印

3.1.0 以下的版本叫性能分析插件,以上的版本叫作执行SQL分析打印。3.1.0以上的版本需要引入p6spy依赖。该插件有性能损耗,官方不建议我们在生产环境中使用,可以使用Druid数据源查看SQL执行(可以参照博主以往博客)。对于初学者来说,可以学习该插件,便于清楚地看到mybatis_plus怎么执行的SQL操作。

SpringBoot数据库连接池Druid的配置及log4j:WARN的解决_全村第二帅的博客-CSDN博客_springboot数据库连接池配置

1、首先导入p6spy依赖

<!-- p6spy 执行SQL分析打印 -->
        <dependency>
            <groupId>p6spy</groupId>
            <artifactId>p6spy</artifactId>
            <version>3.9.1</version>
        </dependency>

2、其次变更数据库的连接

#数据库连接配置
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.url=jdbc:p6spy:mysql://localhost:3306/mybatis_plus?useSSL=true&useUnicode=true&useCharacter=UTF-8
spring.datasource.driver-class-name=com.p6spy.engine.spy.P6SpyDriver
#配置日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

3、然后配置spy.properties文件

modulelist=com.baomidou.mybatisplus.extension.p6spy.MybatisPlusLogFactory,com.p6spy.engine.outage.P6OutageFactory
# 自定义日志打印
logMessageFormat=com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger
#日志输出到控制台
appender=com.baomidou.mybatisplus.extension.p6spy.StdoutLogger
# 使用日志系统记录 sql
#appender=com.p6spy.engine.spy.appender.Slf4JLogger
# 设置 p6spy driver 代理
deregisterdrivers=true
# 取消JDBC URL前缀
useprefix=true
# 配置记录 Log 例外,可去掉的结果集有error,info,batch,debug,statement,commit,rollback,result,resultset.
excludecategories=info,debug,result,commit,resultset
# 日期格式
dateformat=yyyy-MM-dd HH:mm:ss
# 实际驱动可多个
#driverlist=org.h2.Driver
# 是否开启慢SQL记录
outagedetection=true
# 慢SQL记录标准 2 秒
outagedetectioninterval=1

4、最后查看结果

三、主键策略

mybatis_plus支持多种主键生成策略,查看源码可知,它通过枚举类为我们提供多种生成方式。对于主键的生成方式,大概可以通过uuid,自增id,雪花算法,Redis,zookeeper等这些方式生成。

其通过在实体类中主键变量上添加注解@TableId,实现相应的主键自增策略

AUTO:数据库主键自增,需设置数据库自增(数据库需要支持主键自增,如:MySQL)

ASSIGN_ID:在比较早的版本,mybatis_plus默认使用ID_WORKER生成主键id,在新版本中,它默认使用ASSIGN_ID生成主键id,它们均会使用雪花算法自动生成主键ID(生成19位数字)。

NONE:不设置任何策略(注解里等于跟随全局,全局里约等于INPUT)

ASSIGN_UUID:使用UUID生成主键,随机唯一值

INPUT:可手动输入id

1、实体类上配置主键自增

@TableId(type =IdType.AUTO)//配置主键自增,数据库一定要是自增的
    private Long id;
@TableId(type =IdType.ASSIGN_ID)//该策略会使用雪花算法自动生成主键ID
    private Long id;
@TableId(type =IdType.NONE)//不设置任何策略,但是会跟随全局策略
    private Long id;
@TableId(type =IdType.INPUT)//自己定制id
    private Long id;

2、使用AUTO策略生成主键时,必须勾选数据库主键自动递增

不勾选自动递增,会出现以下的错误

3、测试

 @Test
    void testInsert() {
        User user = new User();
        user.setAge(13);
        user.setName("隔壁老王");
        user.setEmail("[email protected]");
        int insert = userMapper.insert(user);//会帮我们自动生成id
        System.out.println(insert);//受影响的行数
        System.out.println(user);
    }

4、结果

四、基本的CRUD操作

1、根据id进行更新操作

 @Test
    void testUpdate() {
        User user = new User();
        //通过条件自动拼接动态sql
        user.setId(7L);
        user.setName("范文");
        user.setAge(18);
        int i = userMapper.updateById(user);
        System.out.println(i);
    }

2、根据id查询用户

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

3、批量查询

BaseMapper.java里封装了selectBatchIds,该方法可以实现批量查询,参数是一个集合

 @Test
    void testSelectByBatchId() {
        List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3, 4));
        users.forEach(System.out::println);
    }

查询id=1,2,3,4的四个用户

4、按条件查询

使用方法selectByMap方法,该方法利用Map<String,Object>参数,实现根据字段查询特定的用户,比如:查询name字段为Jack的用户

@Test
    void test() {
        HashMap<String, Object> map = new HashMap<>();
        //自定义查询
        map.put("name", "Jack");
        List<User> users = userMapper.selectByMap(map);
        users.forEach(System.out::println);
    }

查询出了名字是Jack的用户

5、删除操作

这里主要涉及按Id删除指定用户、批量删除用户、按某个特定条件删除用户,为了直观显示删除效果,这里采用逻辑删除。

 //测试删除
    //根据id删除
    @Test
    void testDelete() {
        userMapper.deleteById(7);
    }

    //批量删除
    @Test
    void testDelete2() {
        userMapper.deleteBatchIds(Arrays.asList(1528921098298281990L, 1529669686078959618L));
    }

    //通过map删除
    @Test
    void testDelete3() {
        HashMap<String, Object> map = new HashMap<>();
        map.put("name", "老王");
        userMapper.deleteByMap(map);
    }
    

五、条件构造器

Mybatis_plus可以通过条件构造器组成复杂的SQL语句,在第一个Mybatis_plus程序中,参数是一个条件构造器Wrapper,只是上面将其置为了null而已。在接口方法中,会出现各种Wrapper,比如:queryWrapper、updateWrapper 等。Wrapper 的作⽤就是⽤于定义各种各样的条件(where)。所以不管是查询、更新、删除都会用到Wrapper。一些条件判断的写法可参考官网:条件构造器 | MyBatis-Plus

1、queryWrapper

(1)查询name不为空的用户,并且邮箱不为空的用户,年龄大于等于20的用户

@Test
    void contextLoads() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.isNotNull("name")
                .isNotNull("email")
                .ge("age", 20);
        userMapper.selectList(wrapper).forEach(System.out::println);
    }

(2)查询年龄小于18岁的且名字叫老王的信息

@Test
    void test2() {
        //查询年龄小于18岁的且名字叫老王的信息
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("name", "老王").lt("age",18);
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

(3)查询名字中不含"e",且邮箱以t开头的用户信息

@Test
    void test4() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.notLike("name", "e")
                .likeRight("email", "t");
        List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
        maps.forEach(System.out::println);
    }

(4)查询年龄在20-50岁之间的用户,并按年龄降序排序,最后输出记录条数

 @Test
    void test3() {
        //查询年龄在20-50岁之间的用户,并按年龄降序排序,最后输出记录条数
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.between("age", 20, 50).orderByDesc("age");//区间
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
        //输出查询结果数
        Long count = userMapper.selectCount(wrapper);
        System.out.println("共有多少条记录:" + count);
    }

(5)查询id小于6的用户,且查询出的用户年龄<20岁,使用子查询

@Test
    void test7(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.lt("age",20).inSql("id","select id from user where id<6");
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

(6)查询名字为老姓或者年龄>=25的用户,按照年龄降序排序,年龄相同按照id升序排列

 @Test
    void test() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.likeRight("name", "老").or()
                .ge("age", 25)
                .orderByDesc("age")
                .orderByAsc("id");
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

(7)指定字段查询

可以查询指定的字段,比如:查询年龄大于30的用户名字,id,年龄

@Test
        //查询年龄大于30的用户名字,id,年龄
    void test9() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.select("id","name","age")
                .gt("age",30);
        List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
        maps.forEach(System.out::println);
    }

已知数据库中老滑头只有一个人,要求使用selectOne查询老滑头的姓名、年龄、邮箱。 注:selectOne返回的是一条实体记录,当出现多条时,会报错。

2、updateWrapper

将名字带有老王的或者年龄在20-30岁之间的用户都改成王富贵

@Test
    //将名字带有老王的或者年龄在20-30岁之间的用户都改成王富贵
    void test11(){
        //修改值
        User user=new User();
        user.setName("王富贵");
        //修改条件
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.like("name","老王")
                .or()
                .between("age",20,30);
        int result = userMapper.update(user, updateWrapper);
        System.out.println(result);
    }

六、一些插件配置

这里主要是对乐观锁插件、分页插件、逻辑删除插件进行配置。首先创建一个config包,在包里创建一个MybatisPlusConfig类。

package com.study.config;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.BlockAttackInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@EnableTransactionManagement
@Configuration //配置类
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        //注册乐观锁插件
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        //添加分页插件
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        //逻辑删除插件
        interceptor.addInnerInterceptor(new BlockAttackInnerInterceptor());
        return interceptor;
    }

}

1、乐观锁配置

乐观锁:假设数据一般情况不会造成冲突,所以在数据进行提交更新的时候,才会正式对数据的冲突与否进行检测,如果冲突,则返回给用户异常信息,让用户决定如何去做。简单来说,就是当要更新一条记录的时候,希望这条记录没有被别人更新。乐观锁比较适用于读多写少的情况。

悲观锁:具有强烈的独占和排他特性。它指的是对数据被外界(包括本系统当前的其他事务,以及来自外部系统的事务处理)修改持保守态度。悲观锁比较适用于写多读少的情况。

(1)实体类上的配置

 @Version //乐观锁注解
    private Integer version;

(2) 测试类

//测试乐观锁成功
    @Test
    void testOptimisticLocker() {
        //1、查询用户信息
        User user = userMapper.selectById(1L);
        //2、修改用户信息
        user.setName("阿满");
        user.setEmail("[email protected]");
        //3、执行更新操作
        userMapper.updateById(user);
    }

(3)结果

注:多线程下,一个线程执行了插队操作,如果没有乐观锁原来的线程就会覆盖插队线程的值。

2、逻辑删除配置:逻辑删除是为了方便数据恢复和保护数据本身价值等等的一种方案。进行逻辑删除时,数据库的记录并未真正被删除,但再进行查询时,却查不出被逻辑删除的记录了。

(1)实体类上的配置

@TableLogic //逻辑删除
    private Integer deleted;

(2)测试类上的配置

//测试删除
    //根据id删除
    @Test
    void testDelete() {
        userMapper.deleteById(6);
    }

(3)配置文件中配置逻辑删除,1表示逻辑已删除,0表示逻辑未删除

#配置逻辑删除
mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

(4)结果,6号在数据库中并没有真正被删除,但是逻辑上已被删除,字段deleted被置为1

3、分页插件配置:主要是对数据库查询分页,可以不用写limit等分页语句

(1)测试类上的配置

注:(1,3)是new Page<>(current,size)的两个参数,表示当前分页是第一页,每页三条记录也即查询出id=1,2,3三条记录(相当于limit(0,3))。(2,4)表示,当前分页为第二页,每页四条记录,也即查询出id=5,6,7,8四条记录(相当于limit(4,4))

//测试分页查询
    @Test
    void testPage() {
        Page<User> page = new Page<>(1, 3);
        userMapper.selectPage(page, null);
        page.getRecords().forEach(System.out::println);
        System.out.println(page.getTotal());
    }

(2)结果

事实上,这个分页插件也是进行了limit的操作,下面显示查出了三条记录

标签: java MybatisPlus maven

本文转载自: https://blog.csdn.net/qq_53860947/article/details/124973423
版权归原作者 全村第二帅 所有, 如有侵权,请联系我们删除。

“Mybatis-plus核心功能及一些插件的配置”的评论:

还没有评论