Mybatis-plus学习笔记1

mybatisplus使用文档见官网：https://baomidou.com/introduce/

大纲：

一、快速入门

1、添加依赖

引入 MyBatis-Plus Starter 依赖

SpringBoot2

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.15</version>
</dependency>

SpringBoot3

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
    <version>3.5.15</version>
</dependency>

SpringBoot4（自3.5.13开始）

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-spring-boot4-starter</artifactId>
    <version>3.5.15</version>
</dependency>

2、配置数据源

在application.yml中配置数据源信息

# DataSource Config
spring:
  datasource:
    type: com.zaxxer.hikari.HikariDataSource
    driver-class-name: com.mysql.jdbc.Driver
    username: root
    password: root123456
    url: jdbc:mysql://localhost:3306/mybatis_plus?characterEncoding=UTF-8&useSSL=false

3、扫描mapper文件夹

在 Spring Boot 启动类中添加 @MapperScan 注解，扫描 Mapper 文件夹

4、实体类

package com.doumi.mybatisplus.pojo;

import lombok.Data;

@Data
public class User {
    private Long id;
    private String name;
    private Integer age;
    private Integer sex;
    private String email;
}

5、编写mapper接口类

package com.doumi.mybatisplus.mapper;

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

public interface UserMapper extends BaseMapper<User> {

}

6、测试类

@SpringBootTest
public class MybatisPlusTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectList(){
        //通过条件构造器查询一个list集合，若没有条件，可以设置null为参数
        List<User> users = userMapper.selectList(null);
        System.out.println(users);
    }
}

二、日志

application.yml中添加如下信息

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

三、自定义功能

如同mybatis中一样，

在UserMapper接口中添加对应的方法名

package com.doumi.mybatisplus.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.doumi.mybatisplus.pojo.User;
import org.springframework.stereotype.Repository;

import java.util.Map;

//@Repository
public interface UserMapper extends BaseMapper<User> {


    /**
     * 自定义查询信息
     */
    Map<String,Object> selectMapById(Integer id);
}

在UserMapper.xml文件中添加具体的sql定义

<?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.doumi.mybatisplus.mapper.UserMapper">

    <select id="selectMapById" resultType="map">
        select *
        from user
        where id = #{id};
    </select>
</mapper>

四、service功能

IService 是 MyBatis-Plus 提供的一个通用 Service 层接口，它封装了常见的 CRUD 操作，包括插入、删除、查询和分页等。通过继承 IService 接口，可以快速实现对数据库的基本操作，同时保持代码的简洁性和可维护性。

IService 接口中的方法命名遵循了一定的规范，如 get 用于查询单行，remove 用于删除，list 用于查询集合，page 用于分页查询，这样可以避免与 Mapper 层的方法混淆。

package com.doumi.mybatisplus.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.doumi.mybatisplus.pojo.User;

/**
 * mybatis_plus中提供的接口Iservice及实现类serviceImpl<xxxMapper,xxx>
 */
public interface UserService extends IService<User> {
}

package com.doumi.mybatisplus.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.doumi.mybatisplus.mapper.UserMapper;
import com.doumi.mybatisplus.pojo.User;
import com.doumi.mybatisplus.service.UserService;
import org.springframework.stereotype.Service;

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

测试类

package com.doumi.mybatisplus;

import com.doumi.mybatisplus.pojo.User;
import com.doumi.mybatisplus.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.ArrayList;
import java.util.List;

@SpringBootTest
public class ServiceTest {
    @Autowired
    UserService userService;

    @Test
    public void test() {
        //查询总记录数
        long count = userService.count();
        System.out.println("count:" + count);
    }

    /**
     * 批量添加
     */
    @Test
    public void testInsertBatch() {
        List<User> users = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            User user = new User();
            user.setName("test" + i);
            user.setAge(18+i);
            user.setEmail("test" + i + "@doumi.com");
            user.setSex(i%2==0?1:2);
            users.add(user);
        }
        boolean result = userService.saveBatch(users);
        System.out.println("result:" + result);

    }
}

五、常用注解

1、@TableName

设置实体类对应的表名

或者通过配置，对所有实体设置统一前缀

mybatis-plus:
#    mybatis-plus的全局配置
  global-config:
    db-config:
#      设置实体类所对应表的统一前缀
      table-prefix: t_

2、@TableId

mybatis默认把id作为主键，并默认采用雪花算法生成id，若数据库主键不是id那么需要使用注解声明

2.1、单独设置

package com.doumi.mybatisplus.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data
@TableName("t_user")
public class User {
    //设置某字段为主键，mybatis-plus将按照主键生成策略，生成主键值
    /**
     * @TableId 的
     * value属性用于指定主键的字段
     * type 用于设置主键的生成策略，默认采用雪花算法生成策略
     *
     */
    @TableId(value = "uid",type = IdType.AUTO)
    private Long id;
    private String name;
    private Integer age;
    private Integer sex;
    private String email;
}

2.2、 全局设置

此外，还可以通过全局配置，设置统一的主键生成策略

@TableId的value属性

用来指定主键对应的字段

@TableId的type属性

用来指定主键的生成策略

常用的主键生成策略

2.3 雪花算法

3、@TableField

通过此标签指定属性对应的字段名（和@TableId的区别是，@TableId设置主键，@TableField设置普通字段）

4、@TableLogic

1、逻辑删除

物理删除：真实删除，将对应数据从数据库中删除，之后查询不到此条被删除的数据

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

使用场景：可以进行数据恢复

2、实现逻辑删除的步骤

1）、数据库中创建逻辑删除状态列，设置默认值为0

2）、实体类中，增加逻辑删除字段及对应的注解@TableLogic

3）、测试删除方法，删除方法，默认增加了逻辑删除字段

4）、数据库中数据被逻辑删除

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

1、Wrapper介绍

2、QueryWrapper

2.1 组装查询条件

 @Test
    public void test01() {
        /**
         * 查询用户名包含i，年龄在20到30之间,邮箱信息不为null的用户信息
         * SELECT uid AS id,user_name AS name,age,sex,email,is_deleted
         * FROM t_user
         * WHERE is_deleted=0
         * AND (user_name LIKE ? AND age BETWEEN ? AND ? AND email IS NOT NULL)
         */
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<User>();
        userQueryWrapper.like("user_name", 'i').between("age", 20, 30).isNotNull("email");
        List<User> users = userMapper.selectList(userQueryWrapper);
        users.forEach(System.out::println);
    }

2.2 组装排序条件

 @Test
    public void test02() {
        /**
         * 按照年龄降序，如果年龄相同，则按照id升序
         * SELECT uid AS id,user_name AS name,age,sex,email,is_deleted
         * FROM t_user WHERE is_deleted=0
         * ORDER BY age DESC,id ASC
         */
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.orderByDesc("age").orderByAsc("id");
        List<User> users = userMapper.selectList(userQueryWrapper);
        users.forEach(System.out::println);
    }

2.3 组装删除条件

@Test
    public void test03() {
        /**
         * 删除邮箱地址为null的信息
         * UPDATE t_user SET is_deleted=1 WHERE is_deleted=0 AND (email IS NULL)
         */
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.isNull("email");
        int delete = userMapper.delete(userQueryWrapper);
        System.out.println(delete);
    }

2.4 条件的优先级

@Test
    public void test04() {
        /**
         * 将（年龄大于20并且用户名包含a）或者邮箱为null的用户信息修改
         * UPDATE t_user SET user_name=?, age=?, email=?
         * WHERE is_deleted=0
         * AND (age > ? AND user_name LIKE ? OR email IS NULL)
         */
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.gt("age", 20).like("user_name", "a").or().isNull("email");
        User user = new User();
        user.setAge(20);
        user.setEmail("a@gmail.com");
        user.setName("小明");
        int update = userMapper.update(user, userQueryWrapper);
        System.out.println(update);
    }

 @Test
    public void test05() {
        /**
         * 将用户名中包含a并且（年龄大于20或者邮箱为null）的用户信息修改
         * lambda表达式中的条件优先执行
         * 
         * UPDATE t_user SET user_name=?, age=?, email=? 
         * WHERE is_deleted=0 
         * AND (user_name LIKE ? AND (age > ? OR email IS NULL))
         */
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.like("user_name", "a")
                .and(i-> i.gt("age", 20).or().isNull("email"));
        User user = new User();
        user.setAge(20);
        user.setEmail("a@gmail.com");
        user.setName("小明");
        int update = userMapper.update(user, userQueryWrapper);
        System.out.println(update);
    }

2.5 组装select子句

 @Test
    public void test06() {
        /**
         * 查询用户名，年龄、邮箱信息
         * 设置查询的字段
         * 
         * SELECT user_name,age,email FROM t_user WHERE is_deleted=0
         */
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.select( "user_name", "age","email");
        userMapper.selectMaps(userQueryWrapper).forEach(System.out::println);
    }

2.6 实现子查询

@Test
    public void test07() {
        /**
         * 查询id<=100的用户信息
         *
         * SELECT uid AS id,user_name AS name,age,sex,email,is_deleted
         * FROM t_user
         * WHERE is_deleted=0 AND (uid IN (select uid from t_user where uid<=100))
         */
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.inSql("uid","select uid from t_user where uid<=100");
        userMapper.selectList(userQueryWrapper).forEach(System.out::println);
    }

3、UpdateWrapper

@Test
    public void test08() {
        /**
         * 将用户名中包含a并且（年龄大于20或者邮箱为null）的用户信息修改
         *
         * UPDATE t_user SET user_name=?,age=?
         * WHERE is_deleted=0
         * AND (user_name LIKE ? AND (age > ? OR email IS NOT NULL))
         */
        UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
        userUpdateWrapper.like("user_name", "a")
                .and(i -> i.gt("age", 20).or().isNotNull("email"));
        userUpdateWrapper.set("user_name","小白").set("age",20);
        int update = userMapper.update(null,userUpdateWrapper);
        System.out.println(update);
    }

4、Condition

带condition条件的动态条件组装器

 /**
     * 条件组装
     */
    @Test
    public void test09() {
        String name ="J";
        Integer ageBegin = 20;
        Integer ageEnd = 30;
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        if(StringUtils.isNotBlank(name)){
            userQueryWrapper.like("user_name",name);
        }
        if(ageBegin != null){
            userQueryWrapper.gt("age",ageBegin);
        }
        if(ageEnd != null){
            userQueryWrapper.lt("age",ageEnd);
        }
        userMapper.selectList(userQueryWrapper).forEach(System.out::println);
    }

    /**
     * QueryWrapper提供了带有判断条件的条件组装器
     */
    @Test
    public void test10() {
        String name ="J";
        Integer ageBegin = 20;
        Integer ageEnd = 30;
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.like(StringUtils.isNotBlank(name),"user_name",name)
                .gt(ageBegin!=null,"age",ageBegin)
                .lt(ageEnd!=null,"age",ageEnd);
        userMapper.selectList(userQueryWrapper).forEach(System.out::println);
    }

5、LambdaQueryWrapper

/**
     * 测试使用LambdaQueryWrapper进行数据查询
     *
     */
    @Test
    public void test11() {
        /**
         * SELECT uid AS id,user_name AS name,age,sex,email,is_deleted
         * FROM t_user
         * WHERE is_deleted=0 AND (user_name LIKE ? AND age > ?)
         *
         */
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.like(User::getName,"J");
        lambdaQueryWrapper.gt(User::getAge,20);
        userMapper.selectList(lambdaQueryWrapper).forEach(System.out::println);
    }

6、LambdaUpdateWrapper

 /**
     * 测试使用LambdaUpdateWrapper 进行数据修改
     * UPDATE t_user SET age=? WHERE is_deleted=0 AND (user_name LIKE ?)
     */
    @Test
    public void test12() {
        LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.like(User::getName,"J");
        updateWrapper.set(User::getAge,20);
        int update = userMapper.update(null,updateWrapper);
        System.out.println(update);

    }

七、插件

1、分页插件

MybatisPlus自带分页插件，只需要简单的配置就可以实现分页功能

@Test
    public void pageTest02() {
        /**
         * SELECT uid AS id,user_name AS name,age,sex,email,is_deleted
         * FROM t_user WHERE is_deleted=0 LIMIT ?,?
         */
        Page<User> page = new Page<>(2, 3);
        IPage<User> userIPage = userMapper.selectPage(page, null);
        System.out.println("records:"+page.getRecords());
        System.out.println(page.getPages());
        System.out.println(page.getTotal());
        System.out.println(page.hasNext());
        System.out.println(page.hasPrevious());
    }

2、乐观锁插件

乐观锁实现流程

1）、数据库增加version字段

2）、添加乐观锁插件

//添加乐观锁插件
interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());

package com.doumi.mybatisplus.config;

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

@Configuration
//扫描mapper接口的包,可以将次配置放置到MybatisPlusConfig类中
@MapperScan("com.doumi.mybatisplus.mapper")
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        //添加分页插件
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        //添加乐观锁插件
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return interceptor;
    }


}

3）、实体类使用@Version增加版本号

package com.doumi.mybatisplus.pojo;

import com.baomidou.mybatisplus.annotation.Version;
import lombok.Data;

@Data
public class Product {
    private Integer id;
    private String name;
    private Integer price;
    @Version//标识乐观锁版本号
    private Integer version;
}

4）、增加失败重试

package com.doumi.mybatisplus;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.doumi.mybatisplus.mapper.ProductMapper;
import com.doumi.mybatisplus.mapper.UserMapper;
import com.doumi.mybatisplus.pojo.Product;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class MybatisOptimizeLockTest {
    @Autowired
    private ProductMapper productMapper;

    @Test
    public void optimizeLockTest() {
        /**
         * 原价100元
         * 小李，查询并增加50
         * 小王，查询并减少30
         * 老板查询价格
         */
        Product product = productMapper.selectById(1);
        System.out.println("小李查询结果："+product);
        product.setPrice(product.getPrice()+50);

        Product productWang = productMapper.selectById(1);
        System.out.println("小王查询结果："+productWang);

        int i = productMapper.updateById(product);
        System.out.println("小李修改结果："+i);


        productWang.setPrice(productWang.getPrice()-30);
        int iWang = productMapper.updateById(productWang);
        System.out.println("小王修改结果："+iWang);
        if(iWang==0){//操作失败重试
            Product productNew = productMapper.selectById(1);
            productNew.setPrice(productNew.getPrice()-30);
            int iNew = productMapper.updateById(productNew);
            System.out.println("iNew:"+iNew);
        }
        System.out.println("老板查询价格："+productMapper.selectById(1));

    }
}

八、通用枚举

枚举属性使用 @EnumValue 注解，指定枚举值在数据库中存储的实际值。支持枚举类中的任意字段，如序号或编码。

1）、全局配置

2）、枚举定义，添加注解@EnumValue

package com.doumi.mybatisplus.enums;

import com.baomidou.mybatisplus.annotation.EnumValue;
import lombok.Getter;

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


    @EnumValue//将注解的值存入数据库中
    private Integer sex;
    private String sexName;

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

3、pojo属性中使用enum定义字段

4）、测试类：

package com.doumi.mybatisplus;

import com.doumi.mybatisplus.enums.SexEnum;
import com.doumi.mybatisplus.mapper.UserMapper;
import com.doumi.mybatisplus.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * 通用枚举测试类
 */
@SpringBootTest
public class MybatisPlusEnumTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void test() {
        User user = new User();
        user.setAge(18);
        user.setName("admin");
        user.setSex(SexEnum.FEMALE);
        userMapper.insert(user);

    }
}

九、代码生成器

AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。

1、添加依赖

<!--        代码生成器的依赖-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.5.15</version>
        </dependency>
        <!-- Source: https://mvnrepository.com/artifact/org.freemarker/freemarker -->
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.34</version>
            <scope>compile</scope>
        </dependency>

2、使用如下代码进行代码生成

package com.doumi.mybatisplus;

import com.baomidou.mybatisplus.generator.FastAutoGenerator;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;

import java.nio.file.Paths;

/**
 * 使用代码生成器，根据数据库的表自动自动生成代码
 * 包括Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码
 *
 */
public class FastAutoGenerateTest {

    public static void main(String[] args) {
        //对应数据库连接信息，需要修改
        FastAutoGenerator.create("jdbc:mysql://localhost:3306/mybatis_plus?characterEncoding=UTF-8&useSSL=false", "root", "root123456")
                .globalConfig(builder -> builder
                        .author("lyl")
                                .outputDir("/Users/luyulong/liyongli/test/src/main/java")//代码生成路径，需要根据需求修改
//                        .outputDir(Paths.get(System.getProperty("user.dir")) + "/src/main/java")
                        .commentDate("yyyy-MM-dd")
                )
                .packageConfig(builder -> builder
                        .parent("com.doumi.mybatisplus")
                        .entity("entity")
                        .mapper("mapper")
                        .service("service")
                        .serviceImpl("service.impl")
                        .xml("mapper.xml")
                )
                .strategyConfig(builder -> builder
                        .entityBuilder()
                        .enableLombok()
                )
                .templateEngine(new FreemarkerTemplateEngine())
                .execute();
    }
}

十、多数据源

dynamic-datasource 是一个开源的 Spring Boot 多数据源启动器，提供了丰富的功能，包括数据源分组、敏感信息加密、独立初始化表结构等。

1、创建数据库及表

2、引入依赖

3、配置多数据源

spring:
  datasource:
    dynamic:
      primary: master
      strict: false
      datasource:
        master:
          url: jdbc:mysql://xx.xx.xx.xx:3306/dynamic
          username: root
          password: 123456
          driver-class-name: com.mysql.jdbc.Driver
        slave_1:
          url: jdbc:mysql://xx.xx.xx.xx:3307/dynamic
          username: root
          password: 123456
          driver-class-name: com.mysql.jdbc.Driver
        slave_2:
          url: ENC(xxxxx)
          username: ENC(xxxxx)
          password: ENC(xxxxx)
          driver-class-name: com.mysql.jdbc.Driver

4、创建用户service

在 Service 层的方法或类上使用 @DS 注解即可轻松切换数据源。方法上的注解优先级高于类上的注解。

package com.doumi.mybatis_plus_datasource.service.impl;

import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.doumi.mybatis_plus_datasource.mapper.ProductMapper;
import com.doumi.mybatis_plus_datasource.pojo.Product;
import com.doumi.mybatis_plus_datasource.service.ProductService;
import org.springframework.stereotype.Service;

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


//    @DS("master") //数据源标签可以写在方法上，方法上的优先于类上的
    public Product getMyObjectById(Integer id) {
        return super.getById(id);
    }
}

package com.doumi.mybatis_plus_datasource.service.impl;

import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.doumi.mybatis_plus_datasource.mapper.UserMapper;
import com.doumi.mybatis_plus_datasource.pojo.User;
import com.doumi.mybatis_plus_datasource.service.UserService;
import org.springframework.stereotype.Service;

@Service
@DS("master") //不写使用默认数据源
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}

5、创建测试类

package com.doumi.mybatis_plus_datasource;

import com.doumi.mybatis_plus_datasource.service.ProductService;
import com.doumi.mybatis_plus_datasource.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class TestDataSource {

    @Autowired
    private UserService userService;

    @Autowired
    private ProductService productService;

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


}

十一、MybatisX插件

官网地址：https://baomidou.com/guides/mybatis-x/

1、安装插件

2、核心功能

1）、xml映射跳转

MybatisX 提供了便捷的 XML 映射文件与 Java 接口之间的跳转功能，让开发者能够快速地在两者之间切换，提高开发效率

2）、代码生成

通过 MybatisX，您可以轻松地根据数据库表结构生成对应的 Java 实体类、Mapper 接口及 XML 映射文件。

如上图，会生成对应的pojo、mapper、service等文件

3）、JPA 风格提示

MybatisX 支持 JPA 风格的代码提示，包括新增、查询、修改和删除操作的自动代码生成。

根据提示，写出方法名，可以自动生成对应的sql语句

生成新增操作

生成查询操作

生成删除操作