提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  后端

当前栏目

MyBatis-Plus 快速开始及详测 SpringBoot 集成Mybatis-Plus

SpringBoot集成mybatis 快速 开始 Plus
2023-06-13 09:14:15 时间

MyBatis-Plus 快速开始及详测

简介

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

特性：

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

架构：

步骤：

建库建表

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)
);
DELETE FROM user;

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

创建项目

导入依赖

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

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.1</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.4</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
        </dependency>
    </dependencies>

yaml 配置文件

server:
  port: 8484
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    username: root
    password: // 这里用自己的密码  下面的数据库名也是一样
    url: jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=UTC&useSSL=false&characterEncoding=utf8&serverTimezone=GMT

pojo层 ： 这里是使用lombok 的插件 简单易写（就是方便偷懒）

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)  // 这个也是lombok的注解 方便 链式书写
@TableName(value = "user")
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

mapper层

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.crush.pojo.User;

public interface UserMapper extends BaseMapper<User> {

}

config：

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

//Spring boot方式
@Configuration
public class MybatisPlusConfig {

    // 分页   这里用的是mybatis-plus自带的分页
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

详细测试：

  • 增删改查齐全 mybatis-plus 自带的单表增删改查基本都测了
  • 多表的感觉还是要像原来一样 那样子应该会更方便。
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.crush.mapper.UserMapper;
import com.crush.pojo.User;
import org.junit.Assert;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.junit.Test;

import java.util.*;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootMybatsiPlusStudyApplicationTests {


    @Autowired
    private UserMapper userMapper;

    //TODO 查询全部
    @Test
    public void testSelect() {
        System.out.println(("----- selectAll method test ------"));
        List<User> userList = userMapper.selectList(null);
//        Assert.assertEquals(8, userList.size());
        userList.forEach(System.out::println);
    }

    //TODO 分页查询
    @Test
    public void select2(){
        System.out.println("====分页查询====");
        Page<User> page=new Page<User>();
        page.setSize(2);
        page.setMaxLimit(10L);
        Page<User> userPage = userMapper.selectPage(page, null);
        System.out.println("获取列表==>"+userPage.getRecords());
        System.out.println("总数==>"+page.getTotal());
        System.out.println("是否有上一页==>"+page.hasPrevious());
        System.out.println("当前页==>"+page.getCurrent());
        System.out.println("是否有下一页==>"+page.hasNext());
        System.out.println("size()==>"+page.getSize());
        System.out.println("getMaxLimit==>"+page.getMaxLimit());
        System.out.println("是否进行 count 查询==>"+page.isSearchCount());
    }

    //TODO 条件查询
    @Test
    public void select3(){
        System.out.println("====条件查询====");
        Map<String, Object> map = new HashMap<>();
        map.put("name","李小斌");
        List<User> users = userMapper.selectByMap(map);
        users.forEach(System.out::println);
    }

    //TODO 批量查询
    @Test
    public void select4(){
        System.out.println("====批量查询====");
        List<User> users = userMapper.selectBatchIds(new ArrayList<String>(Arrays.asList("1", "2", "3")));
        users.forEach(System.out::println);
    }

    //TODO 根据实体类存在条件查询
    @Test
    public void select5(){
        System.out.println("====根据实体类存在条件查询====");
        User user = new User().setName("李小斌");
        QueryWrapper<User> wrapper = new QueryWrapper<>(user);
        System.out.println(userMapper.selectOne(wrapper));
    }

    //TODO 根据ID查询
    @Test
    public void select6(){
        System.out.println("====根据ID查询====");
        System.out.println(userMapper.selectById(100L));
    }

    //TODO 查询count 总条数
    @Test
    public void select7(){
        System.out.println("====查询count 总条数====");
        User user = new User().setName("李小斌");
        QueryWrapper<User> wrapper = new QueryWrapper<>(user);
        System.out.println(userMapper.selectCount(wrapper));
    }

    //TODO 根据条件查询 分页 map 转换
    @Test
    public void select8(){
        System.out.println("====根据条件查询 分页 map 转换 ====");
        User user = new User().setEmail("951930136@qq.com");
        QueryWrapper<User> wrapper = new QueryWrapper<>(user);
        IPage<Map<String, Object>> page = new Page<>(1, 2);
        IPage<Map<String, Object>> userPage = userMapper.selectMapsPage(page, wrapper);
        System.out.println("当前分页总页数==>"+userPage.getPages());
        System.out.println("当前分页总页数==>"+userPage.getTotal());
        List<Map<String, Object>> users = userPage.getRecords();
        users.forEach(System.out::println);
    }

    //TODO 查询 获取id 获取id
    @Test
    public void select9(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        User user = new User().setName("李小斌");
        wrapper.setEntity(user);
        List<Object> objects = userMapper.selectObjs(wrapper);
        objects.forEach(System.out::println);
    }

    //TODO 根据ID更新数据
    @Test
    public void update1(){
        User user = new User().setId(100L).setName("王小慧");
        int i = userMapper.updateById(user);
        System.out.println(i);
    }

    //TODO 根据给出的实体类的条件更新数据
    @Test
    public void update2(){
        User user = new User().setId(100L);
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        User user1 = new User().setName("李小斌");
        wrapper.setEntity(user);
        int update = userMapper.update(user1, wrapper);
        System.out.println(update);
    }

    //TODO insert
    @Test
    public void insert() {
        int i = userMapper.insert(new User(100L, "李小斌", 3, "951930136@qq.com"));
        Assert.assertEquals(1, i);
    }

    //TODO 根据id删除
    @Test
    public void delete1() {
        int i = userMapper.deleteById(100);
        System.out.println(i);
    }

    //TODO 批量删除
    @Test
    public void delete2(){
        int i = userMapper.deleteBatchIds(new ArrayList<String>(Arrays.asList("1337575143814062082", "1337575143814062083", "1337575143814062084")));
        System.out.println(i);
    }

    //TODO 删除全部
    @Test
    public void delete3(){
        userMapper.delete(null);
    }

    //TODO 条件删除
    @Test
    public void delete4(){
        Map<String, Object> map = new HashMap<>();
        map.put("name","李小斌");
        int i = userMapper.deleteByMap(map);
        System.out.println(i);
    }

}

个人见解：

使用 Mybatis-Plus 感觉是方便快捷很多，给我一种 简单的sql 语句要被干掉的感觉

因为我使用下来 单表的操作 根本不需要看到 sql 语句。

看了一些项目 多表的话 还是需要自己写的 。

建议：

不过 mybatis-plus 它没有写sql 但是执行sql语句

里面的问题还是很值的探究 有兴趣的一定要进去康康 多打打断点

后面接着学的话 肯定还会接着更新滴 。

在这次学习中 发现一个技巧 如果什么不会了 立马点进源码里面慢慢看

再慢慢测试 这比看别人的博客和视频 学习还会更快和更牢固一些。

共勉。

相关文章