mybatis_plus（个人学习笔记）

最新推荐文章于 2024-06-05 20:55:01 发布

呐喊ah

最新推荐文章于 2024-06-05 20:55:01 发布

阅读量794

点赞数

分类专栏：学习笔记文章标签： mysql java spring

本文链接：https://blog.csdn.net/HENG_YUAN/article/details/108931551

版权

学习笔记专栏收录该内容

14 篇文章 0 订阅

订阅专栏

mybatis_plus

特性

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 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、新建一个springboot项目，导入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.heng</groupId>
    <artifactId>springboot-08-mybatis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-08-mybatis</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>11</java.version>
    </properties>

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

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
             <dependency>
                 <groupId>com.baomidou</groupId>
                 <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>3.1.1</version>
            </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
                <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2、配置数据库

spring.datasource.username=root
spring.datasource.password=123
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=UTC&useUnicode=true$CharacterEncoding=utf-8
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

建立数据库表，以及插入原始数据

CREATE DATABASE mybatis_plus;
USE mybatis_plus;
DROP TABLE IF EXISTS USER;

CREATE TABLE USER
(
	id BIGINT(20) NOT NULL COMMENT '主键ID',
	username 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, username, age, email) VALUES
(1, 'Jone', 18, 'test1@baomidou.com'),
(2, 'Jack', 20, 'test2@baomidou.com'),
(3, 'Tom', 28, 'test3@baomidou.com'),
(4, 'Sandy', 21, 'test4@baomidou.com'),
(5, 'Billie', 24, 'test5@baomidou.com');

此时连接数据库，我们的环境和数据就搭建完成了

3、接着我们写一些基本的配置

User类

package com.heng.pojo;

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

@AllArgsConstructor
@Data
@NoArgsConstructor
public class User {
    private long id;
    private String username;
    private Integer age;
    private String email;
}

UserMapper

package com.heng.mapper;

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

//在原来的UserMapper接口实现基本的BaseMapper
@Mapper//代表这是一个mapper类
@Repository//代表的是调用dao层
public interface UserMapper extends BaseMapper<User>{

    //在这个接口类里面，所有的数据库的增删改查都已经写好了，只需要调用即可。
}

和原来的不同，在使用mybatis_plus时，我们就不需要写原来的方法名，和一大堆的配置了，在这里已经实现了。

为了学起来方便，直接在测试类实现

package com.heng;

import com.heng.mapper.UserMapper;
import com.heng.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;

@SpringBootTest
class Springboot08MybatisApplicationTests {

    @Autowired
    private UserMapper userMapper;
    @Test
    void contextLoads() {
        //这里的wrapper是一个条件构造器，在后面会有解释
        //查询全部用户就不需要条件，所以写为null
         List<User> users=userMapper.selectList(null);
        users.forEach(System.out::println);
    }

}

这时候就可以查询出全部用户了‘

在这里插入图片描述

从这里可以看出，明显比之前的更加方便了。

**为了看出执行过程，我们需要在配置文件中加入

mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

这样就可以看出执行过程了
在这里插入图片描述

4、插入测试以及雪花算法

@Test
void insert(){
    User user= new User();
    user.setUsername(("呐喊要减肥"));
    user.setAge(18);
    user.setEmail("5555@qq.com");
    //自动生成id
    int result=userMapper.insert(user);
    System.out.println(result);
    //将id回填到数据库
    System.out.println(user);
}

看日志输出

在这里插入图片描述

这时的id已经变成了一长串数字。这就是我们的雪花算法

平时我们用uuid 还有redis等都可以用于id自增。

5、主键自增策略

我们需要在实体类上的主键上加

@TableId(type = IdType.AUTO)

然后数据库里面的字段一定要是自增。

6、更新操作

@Test
void update(){
    User user = new User();
    user.setId(5L);
    user.setUsername("冰淇淋");
    int i=userMapper.updateById(user);
    System.out.println(i);
}

mybatis_plus里面的sql都是可以自动动态拼接的

@Test
void update(){
    User user = new User();
    user.setId(5L);
    user.setUsername("冰淇淋");
    user.setAge(16);
    int i=userMapper.updateById(user);
    System.out.println(i);
}

7、自动填充

自动填充就是创建时间、修改时间这些操作都是自动化完成的，不需要手动更新。

8、乐观锁

乐观锁是相对悲观锁而言的，乐观锁假设数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则返回给用户错误的信息，让用户决定如何去做。乐观锁适用于读操作多的场景，这样可以提高程序的吞吐量。

在数据库中增加一个version字段，设置默认值为1

然后在实体类里面增加

@Version//乐观锁
private Integer version

接着我们注册乐观锁组件

package com.heng.config;

import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@EnableTransactionManagement
@MapperScan("com.heng.mapper")
@Configuration
public class MybatisplusConfig {
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
}

编写测试类

@Test
//测试乐观锁
void testOptimistic(){
    //查询用户信息
    User user = userMapper.selectById(1L);
    //修改用户信息
    user.setUsername("呐喊要减肥");
    user.setEmail("789798@qq.com");
    //更新
    userMapper.updateById(user);

通过日志查看version的变化

在这里插入图片描述

这时在数据库中的version字段变为2了

9、测试查询

9.1、查询一个用户

@Test
//测试查询
void testSelectById(){
    User user = userMapper.selectById(1L);
    System.out.println(user);

}

查询多个用户

@Test
//查询多个用户
void testSelectList(){
    List<User> userList = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
    userList.forEach(System.out::println);
}

条件查询

    @Test
    //条件查询
    void SelectBybacthId(){
       Map<String,Object> map = new HashMap<>();
       map.put("username","呐喊要减肥");
       map.put("age",18);
        List<User> userList = userMapper.selectByMap(map);
        userList.forEach(System.out::println);
    }

10、分页查询

在配置类上面注册

//分页插件
@Bean
public PaginationInterceptor paginationInterceptor(){
    return new PaginationInterceptor();
}

编写测试类

    @Test
    //分页查询
    void testPage(){
        //参数一：当前页数
        //参数二：页面大小
        Page<User> page = new Page<>(1,5);
        userMapper.selectPage(page,null);
        page.getRecords().forEach(System.out::println);
        System.out.println(page.getTotal());
    }

查看日志输出

在这里插入图片描述

可以看出也是用limit进行分页的

另外page里面还有查询总页数，是否有一页，是否有上一页

10、逻辑删除

其实删除测试和查询差不多的，都是删除一个，批量删除。

在这里重点就是使用逻辑删除，逻辑删除实际上并没有删除，而是在对于用户来说是删除了，对于管理员来说就是没有删除，这就是逻辑删除。

我们平常所用的删除是物理删除，这个是直接从数据库中直接移除的。

首先在数据库中增加一个deleted字段，默认值为0。然后再实体类中增加

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

接着在配置类里面注册

//逻辑删除插件
@Bean
public ISqlInjector sqlInjector(){
    return new LogicSqlInjector();
}

接着还要再配置文件中

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

编写测试类

@Test
//测试删除
void deleted(){
    userMapper.deleteById(1L);
}

通过日志我们可以看出

在这里插入图片描述

虽然是删除操作，却是更新路线，在数据库中的deleted中也由0–》1

如果再查询该用户就已经查不到了，因为会自动过滤被逻辑删除的字段。

11、条件构造器

属性有很多，不懂的可以去看下官方文档，在这里只测试几个。

在这里插入图片描述

编写测试类

package com.heng;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.heng.mapper.UserMapper;
import com.heng.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 WrapperTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    void contextLoads() {
        //查询name不为空，并且邮箱不为空的用户，并且年龄大于等于20
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper
                .isNotNull("username")
                .isNotNull("email")
                .ge("age",20);
        userMapper.selectList(wrapper).forEach(System.out::println);
    }
    @Test
    void selectByOne(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("username","Tom");
        //查询一个使用selectOne，多个使用list或者Map
        User user = userMapper.selectOne(wrapper);
        System.out.println(user);
    }
    @Test
    void test1(){
        //查询年龄在20-30之间的用户
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.between("age",20,30);
        //查询结果数
        Integer integer = userMapper.selectCount(wrapper);
        System.out.println(integer);
    }
    @Test
    void test2(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper
                //名字里面不包含j的用户,这个好像还会识别中文名的拼音
                .notLike("username","j")
                //右边以t开始的email
                .likeRight("email","t");
        List<Map<String,Object>> maps =userMapper.selectMaps(wrapper);
        for (Map<String,Object> map : maps) {
            System.out.println(map);

        }
    }

}

12、代码自动生成器

package com.heng;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.po.TableFill;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;

import java.util.ArrayList;

public class AutoCode {
    public static void main(String[] args) {
        //需要构建一个代码生成器对象
        AutoGenerator mpg = new AutoGenerator();

        //配置策略
        //1、全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        //将生成的代码输出到此文件下
        gc.setOutputDir(projectPath + "/src/main/java");
        //作者名
        gc.setAuthor("呐喊");
        gc.setOpen(false);
        gc.setFileOverride(false);
        // gc.setSwagger2(true); 实体属性 Swagger2 注解
        gc.setIdType(IdType.ID_WORKER);
        gc.setDateType(DateType.ONLY_DATE);
        mpg.setGlobalConfig(gc);
        //2、数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=UTC&useUnicode=true$CharacterEncoding=utf-8");
        // dsc.setSchemaName("public");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("123");
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);
        //3、包的配置

        PackageConfig pc = new PackageConfig();
       pc.setModuleName("blog");
        pc.setParent("com.heng");
        pc.setMapper("mapper");
        pc.setController("controller");
        pc.setEntity("entity");
        mpg.setPackageInfo(pc);
        //4、策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setInclude("user");//表名映射，根据表名生成代码
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        strategy.setSuperEntityClass("你自己的父类实体,没有就不用设置!");
        strategy.setEntityLombokModel(true);//自动lombok
        strategy.setLogicDeleteFieldName("deleted");//逻辑删除
        //自动填充
        TableFill gmtCreate = new TableFill("gm_create", FieldFill.INSERT);
        TableFill gmtModifile = new TableFill("gm_update", FieldFill.UPDATE);
        ArrayList<TableFill> table=new ArrayList<>();
        table.add(gmtCreate);
        table.add(gmtModifile);
        strategy.setTableFillList(table);
        strategy.setVersionFieldName("version");
        strategy.setRestControllerStyle(true);
        strategy.setControllerMappingHyphenStyle(true);

        mpg.setStrategy(strategy);
        mpg.execute();



    }
}
tegy.setLogicDeleteFieldName("deleted");//逻辑删除
        //自动填充
        TableFill gmtCreate = new TableFill("gm_create", FieldFill.INSERT);
        TableFill gmtModifile = new TableFill("gm_update", FieldFill.UPDATE);
        ArrayList<TableFill> table=new ArrayList<>();
        table.add(gmtCreate);
        table.add(gmtModifile);
        strategy.setTableFillList(table);
        strategy.setVersionFieldName("version");
        strategy.setRestControllerStyle(true);
        strategy.setControllerMappingHyphenStyle(true);

        mpg.setStrategy(strategy);
        mpg.execute();



    }
}

呐喊ah

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
mybatis_plus（个人学习笔记）

mybatis_plus特性无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器
复制链接

扫一扫