Mybatis-plus学习记录

1.新建spring-boot项目引入相关依赖

<?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.6.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>Vueadmin-api</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>Vueadmin-api</name>
    <description>Vueadmin-api</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>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </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>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2. 新建application.yml引入数据库配置

spring:
 datasource:
   driver-class-name: com.mysql.cj.jdbc.Driver
   username: root
   password: root
   url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8
mybatis-plus:
 configuration:
   log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

3.新建实体类

package com.example.vueadminapi.pojo;

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

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

4. 新建实体类对应Mapper接口(继承BaseMapper<实体类>)

package com.example.vueadminapi.mapper;

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

@Repository
public interface UserMapper extends BaseMapper<User> {

}

5. 项目启动类 添加扫描注解

package com.example.vueadminapi;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.example.vueadminapi.mapper")
public class VueadminApiApplication {

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

}

6. 测试

    @Autowired
    private UserMapper userMapper;
    @Test
    void contextLoads() {
        List<User> users = userMapper.selectList(null);
        for (User user : users) {
            System.out.println(user);
        }
    }

测试方法集合

1. 测试insert方法

 @Test
    public  void TestInsert(){
        User user = new User();
        user.setAge(18);
        user.setEmail("gek821330.com");
        user.setName("张三");
        int result = userMapper.insert(user);
        System.out.println("result:"+result);
        System.out.println("id:"+user.getId());
    }

2. 测试delete方法

//   根据id删除
       int result = userMapper.deleteById(1505752384428L);
        System.out.println("result:"+result);

使用deleteByMap（多条件删除）

//  使用deleteByMap
        HashMap<String, Object> map = new HashMap<>();
        map.put("name","张三2");
        map.put("age",18);
        int result = userMapper.deleteByMap(map);
        System.out.println("result:"+result);

使用deleteBatchIds(相当于在调用where in )

 List<Long> list = Arrays.asList(2L, 3L);
        int result = userMapper.deleteBatchIds(list);
        System.out.println("result:"+result);

3. 测试Update 方法

updateById

    @Test
    public  void  TestUpdate(){
        User user = new User();
        user.setId(1L);
        user.setName("李四");
        user.setAge(20);
        int result = userMapper.updateById(user);
        System.out.println("result:"+result);
    }

4. 测试select 方法

selectById方法

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

selectByMap(多条件查询)

        HashMap<String, Object> map = new HashMap<>();
        map.put("name","李四");
        map.put("age",20);
        List<User> users = userMapper.selectByMap(map);
        users.forEach(System.out::println);

selectBatchIds(where id in )

   List<Long> ids = Arrays.asList(1L, 2L);
        List<User> users = userMapper.selectBatchIds(ids);
        users.forEach(System.out::println);

selectList

        List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);

自定义方法

1. 在userMapper 接口中定义方法名

@Repository
public interface UserMapper extends BaseMapper<User> {
    /**
     * 根据id查询为map集合
     * @param id
     * @return
     */
    Map<String,Object> selectMapById(Long id);
}

2. 在resources下新建mapper 在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.example.vueadminapi.mapper.UserMapper">
    <select id="selectMapById" resultType="map">
        select name,age,email from user where id=#{id}
    </select>
</mapper>

3. 测试

    @Test
    public void TestSelf(){
        Map<String, Object> map = userMapper.selectMapById(2L);
        System.out.println(map);
    }

测试Service

1. Service基本配置

• 通用 Service CRUD 封装IService (opens new window)接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆，
• 泛型 T 为任意实体对象
• 建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类
• 对象 Wrapper 为 条件构造器

1. 写一个UserService继承IService,泛型填写实体类名称

package com.example.vueadminapi.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.example.vueadminapi.pojo.User;

public interface UserService extends IService<User> {
}

2. 写一个UserServiceImpl 实现自己创建的UserService 然后继承mybatis-plus自带的ServiceImpl

package com.example.vueadminapi.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.vueadminapi.mapper.UserMapper;
import com.example.vueadminapi.pojo.User;
import com.example.vueadminapi.service.UserService;

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

}

2.测试Sevice的方法

count方法

   @Autowired
    private UserService userService;
    @Test
    public  void TestService(){
        long count = userService.count();
        System.out.println(count);
    }

批量添加 saveBatch

    @Test
    public  void TestService(){
        //count
//        long count = userService.count();
//        System.out.println(count);
        //批量添加
        List<User> list=new ArrayList<>();
        for (int i = 3; i < 10; i++) {
            User user = new User();
            user.setName("gek"+i);
            user.setAge(20+i);
            list.add(user);
        }
        boolean b = userService.saveBatch(list);
        System.out.println(b);
    }

注解使用

当表名和实体类的名字不一致的时候

1. @TableName

• 可以在实体类上面加上TableName注解（“表名”）

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("t_user")
public class User {
    private Long id;
    private int age;
    private String name;
    private String email;
}

第二种方法：配置项添加全局的前缀,下面的示列表示所有实体类都会加上t_这个前缀

#设置mybatis-plus的全局配置
  global-config:
    db-config:
      table-prefix: t_

2. @TableId(将属性对应的字段指定为主键)，因为mybatis-plus默认是以id为主键，若表不是id为主键的话，会报错

@Data
@AllArgsConstructor
@NoArgsConstructor
//@TableName("t_user")
public class User {
    @TableId
    private Long uid;
    private int age;
    private String name;
    private String email;
}

@TableId(value) value属性是当实体类注解字段名称和数据库主键字段名称不一致的时候，可以设置

package com.example.vueadminapi.pojo;

import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
//@TableName("t_user")
public class User {
    @TableId(value = "uid")
    private Long id;
    private int age;
    private String name;
    private String email;
}

@TableId(Type) type属性是主键生成策略

    /**
     * 数据库ID自增
     * <p>该类型请确保数据库设置了 ID自增 否则无效</p>
     */
    AUTO(0),
    /**
     * 该类型为未设置主键类型(注解里等于跟随全局,全局里约等于 INPUT)
     */
    NONE(1),
    /**
     * 用户输入ID
     * <p>该类型可以通过自己注册自动填充插件进行填充</p>
     */
    INPUT(2),

    /* 以下3种类型、只有当插入对象ID 为空，才自动填充。 */
    /**
     * 分配ID (主键类型为number或string）,
     * 默认实现类 {@link com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator}(雪花算法)
     *
     * @since 3.3.0
     */
    ASSIGN_ID(3),
    /**
     * 分配UUID (主键类型为 string)
     * 默认实现类 {@link com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator}(UUID.replace("-",""))
     */
    ASSIGN_UUID(4);

//表示id自增
    @TableId(value = "uid",type = IdType.AUTO)

通过全局配置主键的生成策略

#设置mybatis-plus的全局配置
  global-config:
    db-config:
      table-prefix: t_
	#设置主键生成策略
      id-type: auto

@TableField(当实体类的字段名和数据库不一致的时候使用)

    @TableField("user_name")
    private String name;

@TableLogic(逻辑删除)

1. 先在逻辑删除的字段上加上TableLogic

package com.example.vueadminapi.pojo;

import com.baomidou.mybatisplus.annotation.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
//@TableName("t_user")
public class User {
    @TableId(value = "uid",type = IdType.AUTO)
    private Long id;
    private int age;
    @TableField("user_name")
    private String name;
    private String email;
    @TableLogic
    @TableField("is_deleted")
    private int IsDeleted;
}

2. 测试删除

    @Test
    public  void  TestDelete(){
//        根据id删除
//        int result = userMapper.deleteById(1505752384428L);
//        System.out.println("result:"+result);
//  使用deleteByMap
//        HashMap<String, Object> map = new HashMap<>();
//        map.put("name","张三2");
//        map.put("age",18);
//        int result = userMapper.deleteByMap(map);
//        System.out.println("result:"+result);
        //使用deleteBatchIds
        List<Long> list = Arrays.asList(1L, 2L);
        int result = userMapper.deleteBatchIds(list);
        System.out.println("result:"+result);
    }

实际上，只是执行了更新is_deleted字段为删除状态，并没有真正删除数据

select的时候，也会直接过滤出来逻辑删除的数据

条件构造器

queryWrapper

    @Test
    public  void TestWrapper(){
        //需求：查询用户名包含e ,并且年龄在20-30之间，邮箱不为空的用户数据
        QueryWrapper<User> Wrapper = new QueryWrapper<>();
        Wrapper.like("user_name","e")
                .between("age",20,30)
                .isNotNull("email");
        List<User> users = userMapper.selectList(Wrapper);
        users.forEach(System.out::println);
    }

由于之前加了逻辑删除，所以条件中会多一个is_deleted=0

通过条件构造器构造排序

    @Test
    public  void TestWrapperOrder(){
//        需求先通过年龄进行排序，如果年龄一致的情况下，通过uid进行排序
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.orderByDesc("age")
                .orderByAsc("uid");
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

使用条件构造器实现删除

    @Test
    public void  TestWrapperDelete(){
//        需求：删除邮箱为空的数据
        QueryWrapper<User> queryWrapper =new QueryWrapper<>();
        queryWrapper.isNull("email");
        int delete = userMapper.delete(queryWrapper);
        System.out.println(delete);
    }

通过条件构造器实现修改功能

    @Test
    public  void  TestWrapperUpdate(){
        // 需求：（年龄大于20 and username 中包含 e）或者邮箱不为空
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.gt("age",20)
                    .like("user_name","e")
                    .or()
                    .isNotNull("email");
        User user = new User();
        user.setName("小明");
        user.setEmail("gek22222@qq.com");
        int update = userMapper.update(user, queryWrapper);
        System.out.println(update);
    }

条件优先级

  @Test
    public void TestWrapperUpdate2(){
        //需求：年龄大于20 and (username 中包含 e or 邮箱不为空)
        QueryWrapper<User> queryWrapper =new QueryWrapper<>();
        queryWrapper.gt("age",19)
                .and(i->i.like("user_name","小").or().isNotNull("email"));
        User user = new User();
        user.setAge(28);
        user.setName("小红");
        user.setEmail("test@qq.com");
        int update = userMapper.update(user, queryWrapper);
        System.out.println(update);
    }

根据构造器查询部分字段

    @Test
    public void TestWrapperSelect(){
        //查询name,age,email字段信息
        QueryWrapper<User> queryWrapper =new QueryWrapper<>();
        queryWrapper.select("age","user_name","email");
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }

构造器构造子查询

 @Test
    public  void  TestWrapperSelect2(){
        //查询id >100的数据
        QueryWrapper<User> queryWrapper =new QueryWrapper<>();
        queryWrapper.inSql("uid","select uid from t_user where uid >100");
        List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
        maps.forEach(System.out::println);
    }

使用UpdateWrapper实现修改

    @Test
    public  void  TestUpdateWrapper(){
        //需求：年龄大于20 and (username 中包含 e or 邮箱不为空)
        UpdateWrapper<User> updateWrapper =new UpdateWrapper<>();
        //设置查询条件
        updateWrapper.gt("age",20)
                    .and(i->i.like("user_name","小").or().isNotNull("email"));
//                    设置修改条件
        updateWrapper.set("user_name","小明");
        updateWrapper.set("age",27);
        int update = userMapper.update(null, updateWrapper);
        System.out.println(update);
    }

通过条件构造器的condition来查询,从下面的sql语句看出，满足条件则执行相关条件，不满足就不拼接相关条件

    @Test
    public void TestCondition(){
        String name="小";
        Integer startAge=null;
        Integer EndAge=30;
        QueryWrapper<User> queryWrapper =new QueryWrapper<>();
        queryWrapper.like(StringUtils.isNotBlank(name),"user_name",name)
                .gt(startAge != null,"age",startAge)
                .lt(EndAge != null,"age",EndAge);
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }

LambdaQueryWrapper(可以写函数式接口来指定字段名，避免写错字段名字)

  @Test
    public  void TestLambdaQueryWrapper(){
        String name="小";
        Integer startAge=null;
        Integer EndAge=30;
        LambdaQueryWrapper<User> queryWrapper=new LambdaQueryWrapper<>();
        queryWrapper.like(StringUtils.isNotBlank(name),User::getName,name)
                .gt(startAge != null,User::getAge,startAge)
                .lt(EndAge !=null,User::getAge,EndAge);
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }

LambdaUpdateWrapper

  @Test
    public  void  TestLambdaUpdateWrapper(){
        //需求：年龄大于20 and (username 中包含 e or 邮箱不为空)
        LambdaUpdateWrapper<User> updateWrapper =new LambdaUpdateWrapper<>();
        //设置查询条件
        updateWrapper.gt(User::getAge,20)
                    .and(i->i.like(User::getName,"小").or().isNotNull(User::getEmail));
//                    设置修改条件
        updateWrapper.set(User::getName,"小明");
        updateWrapper.set(User::getAge,27);
        int update = userMapper.update(null, updateWrapper);
        System.out.println(update);
    }

插件

1. 分页插件

1. 编写配置类(mybatis-plus官网上有，可以直接拿来用)

package com.example.vueadminapi.config;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.autoconfigure.ConfigurationCustomizer;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
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
@MapperScan("com.example.vueadminapi.mapper")
public class MybatisPlusConfig {
    /**
     * 新的分页插件,一缓和二缓遵循mybatis的规则,需要设置 MybatisConfiguration#useDeprecatedExecutor = false 避免缓存出现问题(该属性会在旧插件移除后一同移除)
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }

}

2. 测试

package com.example.vueadminapi;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.vueadminapi.mapper.UserMapper;
import com.example.vueadminapi.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 TestPage {
    @Autowired
    private UserMapper userMapper;
    @Test
    public  void  TestPage(){
        Page<User> page = new Page<>(2,3);
        userMapper.selectPage(page,null);
   //        获取记录
        System.out.println(page.getRecords());
//        获取页数
        System.out.println(page.getPages());
//        获取当前页
        System.out.println(page.getCurrent());
//        获取pagesize
        System.out.println(page.getSize());
//        获取总记录数
        System.out.println(page.getTotal());
//        判断是否有下一页
        System.out.println(page.hasNext());
//        判断是否有上一页
        System.out.println(page.hasPrevious());
    }
}

3. 结果
   

自定义分页 方法
1.UserMapper接口定义方法

    Page<User> selectPageVo(@Param("page") Page<User> page,@Param("age") Integer age);

4. mybatis-plus配置别名

mybatis-plus:
#别名
  type-aliases-package: com.example.vueadminapi.pojo
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
#设置mybatis-plus的全局配置
  global-config:
    db-config:
      table-prefix: t_

5. UserMapper.xml配置相应的方法

    <select id="selectPageVo" resultType="User">
        select * from t_user where age >= #{age}
    </select>

6. 测试

    @Test
    public  void  testPage2(){
        Page<User> page =new Page<>(2,3);
        userMapper.selectPageVo(page,20);
        System.out.println(page);
     }

乐观锁
定义：当要更新一条记录的时候，希望这条记录没有被别人更新

• 原理：
• 取出记录时，获取当前 version
• 更新时，带上这个 version
• 执行更新时， set version = newVersion where version = oldVersion
• 如果 version 不对，就更新失败

1. 在mybatis-plus配置类上加拦截器

 interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());

2. 在实体类上加入@version注解

package com.example.vueadminapi.pojo;

import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.Version;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("product")
public class Product {
    private Integer id;
    private String name;
    private  Integer price;
    @Version
    private Integer version;
}

3. 测试

package com.example.vueadminapi;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.vueadminapi.mapper.ProductMapper;

import com.example.vueadminapi.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 TestVesion {
    @Autowired
    private ProductMapper productMapper;
    @Test
    public void  test01(){
//        第一个人查询价格
        Product product1 = productMapper.selectById(1);
        System.out.println(product1.getPrice());
//        第二个人查询价格
        Product product2 = productMapper.selectById(1);
        System.out.println(product2.getPrice());
//        第一个人修改价格
        product1.setPrice(product1.getPrice()+50);
        productMapper.updateById(product1);
//        第二个人修改价格
        product2.setPrice(product2.getPrice()-30);
        productMapper.updateById(product2);

        //最终查询价格
        Product product3 = productMapper.selectById(1);
        System.out.println(product3.getPrice());

    }
}

最终执行效果：第一个执行了修改，第二个未执行

通用枚举（主要应用场景：类似于数据库存的是1和2这种数字，实际要显示的是男和女这是性别）

1. 新建枚举类(在对应字段上加入 @EnumValue 注解)

package com.example.vueadminapi.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;
    }

}

2. 实体类中加入对应的枚举字段

    private SexEnum sex;

3. application.yml中配置mybatis-plus扫描枚举包

mybatis-plus:
  type-enums-package: com.example.vueadminapi.enums
  type-aliases-package: com.example.vueadminapi.pojo
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
#设置mybatis-plus的全局配置
  global-config:
    db-config:
      table-prefix: t_

4. 测试枚举

package com.example.vueadminapi;

import com.example.vueadminapi.enums.SexEnum;
import com.example.vueadminapi.mapper.UserMapper;
import com.example.vueadminapi.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 test01(){
        User user = new User();
        user.setName("admin");
        user.setAge(33);
        user.setSex(SexEnum.MALE);
        int insert = userMapper.insert(user);
        System.out.println(insert);
    }
}

代码生成器的使用

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>

遇到问题：怎么都下载不了3.5.1版本的。

解决方法：更改了maven的mirror地址为阿里云的，在settings.xml上添加

  <mirror>
      <id>aliyunmaven</id>
      <mirrorOf>*</mirrorOf>
      <name>阿里云公共仓库</name>
      <url>https://maven.aliyun.com/repository/public</url>
    </mirror>

intellij上配置maven环境，生效后就可以下载3.5.1的依赖

2. 复制官网代码生成器代码

package com.example.vueadminapi;


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

import java.util.Collections;

public class mybatisPlusCode {
    public static void main(String[] args) {
        FastAutoGenerator.create("jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8",
                        "root",
                        "root")
                .globalConfig(builder -> {
                    builder.author("gek") // 设置作者
                            .enableSwagger() // 开启 swagger 模式
                            .fileOverride() // 覆盖已生成文件
                            .outputDir("D://mybatis-plus"); // 指定输出目录
                })
                .packageConfig(builder -> {
                    builder.parent("com.example") // 设置父包名
                            .moduleName("vueadminapi") // 设置父包模块名
                            .pathInfo(Collections.singletonMap(OutputFile.mapperXml, "D://mybatis-plus")); // 设置mapperXml生成路径
                })
                .strategyConfig(builder -> {
                    builder.addInclude("t_user") // 设置需要生成的表名
                            .addTablePrefix("t_", "c_"); // 设置过滤表前缀
                })
                .templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板，默认的是Velocity引擎模板
                .execute();
    }
}

3. 执行得 相应文件
   

多数据源

1. 配置数据源

spring:
  datasource:
    dynamic:
      primary: master #设置默认的数据源或者数据源组,默认值即为master
      strict: false #严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源
      datasource:
        master:
          url: jdbc:mysql://xx.xx.xx.xx:3306/dynamic
          username: root
          password: 123456
          driver-class-name: com.mysql.jdbc.Driver # 3.2.0开始支持SPI可省略此配置
        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

注解	结果
没有@DS	默认数据源
@DS(“dsName”)	dsName可以为组名也可以为具体某个库的名称

2. 示例

@Service
@DS("slave")
public class UserServiceImpl implements UserService {

  @Autowired
  private JdbcTemplate jdbcTemplate;

  public List selectAll() {
    return  jdbcTemplate.queryForList("select * from user");
  }
  
  @Override
  @DS("slave_1")
  public List selectByCondition() {
    return  jdbcTemplate.queryForList("select * from user where age >10");
  }
}

MybatisX快速开发

1. 快速生成文件
   连接对应数据源
   
   右键想要创建的表，选择mybatisX-Generator
   
   填写相关信息
   
   

点完finish就自动创建相关文件

mybatisX CRUD

官网地址：官网地址