mybatIs-plus

MyBatis-Plus

为什么要学mybatis-plus，如果是之前学过了mybatis的小伙伴都知道，mybatis的功能已经简化了jdbc当时哪些繁琐的写法了，不用自己写sql，不用手动设置参数；但是如果你用了mybatis-plus你会感觉到，什么才叫简洁，之前的mapper.xml现在都不用写了，用了mybatis-plus你就发现回不去了；接下来是使用springboot项目开整

导入依赖

官网：简介 | MyBatis-Plus (baomidou.com)

先导入mybatis-plus的依赖，再导入一个lombok的依赖，为了不用写setter、getter方便，lomok可用可不用，主要是导入mybatis-plus的依赖就可以了

== 版本最好2.5+，官方推荐
<dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.2</version>
</dependency>
<dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
</dependency>

配置文件配置四要素和日志，日志为了方便看sql

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mysqlplus?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8
spring.datasource.username=
spring.datasource.password=

mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl			//日志配置

准备数据

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 '年龄',
    password VARCHAR(250) NULL DEFAULT NULL COMMENT '密码',
    PRIMARY KEY (id)
);

对应的数据如下

DELETE FROM user;		//先清除表中所有的数据，可选

INSERT INTO user (id, name, age, password) VALUES
(1, 'Jone', 18, 'a123456'),
(2, 'Jack', 20, 'b123456'),
(3, 'Tom', 28, 'c123456'),
(4, 'Sandy', 21, 'd123456'),
(5, 'Billie', 24, 'f123456');

接下来就是创建实体类、service、Xxxmapper.xml了，这里只是简单测试就不用展示service层了。

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

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

这里是不是发现我们的mapper里面什么都没有写，暂时还不用纠结这个，因为mybatis-plus的BaseMapper里面已经帮我们写好了

主键策略

=========常见的几种关系型数据库在主键生成上的实现方式===========
DB2KeyGenerator：IBM DB2 数据库的主键生成策略，采用序列生成器（Sequence）来生成主键。
H2KeyGenerator：H2 数据库的主键生成策略，使用内建算法来生成唯一标识符（UUID）。
KingbaseKeyGenerator：人大金仓数据库的主键生成策略，同样采用序列生成器（Sequence）来生成主键。
OracleKeyGenerator：Oracle 数据库的主键生成策略，也是使用序列生成器（Sequence）来生成主键。
PostgreKeyGenerator：PostgreSQL 数据库的主键生成策略，使用序列生成器（Sequence）或者自增字段来生成主键。

在使用mybatis-plus中你需要告诉它，你的主键生成使用的是什么策略，一般我们是自增，有些可能是雪花算法等，所以这里需要告示mybatis-plius你的主键策略

1、创建一个配置类MyConfig

@Configuration
public class MyConfig {
    @Bean
    public IKeyGenerator keyGenerator() {
        return new H2KeyGenerator();
    }
}

2、在你的实体类的主键属性上指定你的主键生成策略

public class User {
    @TableId(type = IdType.AUTO)    //主键生成策略
    private Long id;

3、去测试类测试一下，主键生成策略行不行

@SpringBootTest
class DemoApplicationTests {

    @Autowired
    private UserMapper userMapper;
    
    @Test
    void insert(){      //测试主键策略
        User user = new User(null, "zhangsan1", "123456", 19);
        int i = userMapper.insert(user);
        System.out.println(i);
    }
}

乐观锁插件

乐观锁插件只要是为了在多线程环境下保持数据的一致性，乐观锁就是通过版本来控制的，每修改一次数据，版本就+1

1、在配置类中注入一个Bean

@Bean
    public MybatisPlusInterceptor myOptimisticLocker() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return interceptor;
    }

2、在数据中修改user表，多加一个字段verson，设置默认值为1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-62ePGHLt-1687159278853)(C:\Users\24128\AppData\Roaming\Typora\typora-user-images\image-20230619110245531.png)]

3、在实体类User中添加上对应的属性

@Version            //乐观锁
private Integer version;

4、测试

@Test
void verson(){      //测试乐观锁(成功案例)
    User user = userMapper.selectById(5L);
    user.setAge(22);
    user.setName("王五");
    userMapper.updateById(user);
}


@Test
void verson2(){      //测试乐观锁(多线程案例)
    User user = userMapper.selectById(1668565553752989698L);
    user.setAge(22);
    user.setName("测试");

    User user1 = userMapper.selectById(1668565553752989698L);
    user.setAge(23);
    user.setName("张三2");
    userMapper.updateById(user1);		//先修改

    userMapper.updateById(user);	//后修改
}

在多线程环境下会发现它版本也只是更新了一次

逻辑删除

在我们的数据库操作中一般有时候，删除数据并不是一定意义上的删除，更多时候只是修改了它的状态来实现逻辑删除，但是数据还是存在的，mybatis-plus就提供了这样的功能

1、在数据库中添加一个字段

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xl9PJVjr-1687159278854)(C:\Users\24128\AppData\Roaming\Typora\typora-user-images\image-20230619111302197.png)]

2、在实体类上也加上对应的属性

@TableLogic
private int isDelete;

3、在配置文件中配置逻辑删除的值

mybatis-plus.global-config.db-config.logic-delete-field=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

4、测试

@Test
void delete(){      //逻辑删除
    userMapper.deleteById(5L);
 }

分页插件

1、在配置类MyConfig中添加以下

@Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {    //配置分页插件
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));  //指定数据库类型是MySQL
        return interceptor;
    }

2、测试效果

@Test
    void page(){        //测试分页功能
        Page<User> page = new Page<>(1,3);
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("password","1234567");
        wrapper.ge("age",24);
        Page<User> userPage = userMapper.selectPage(page, wrapper);
        for (User user : userPage.getRecords()) {
            System.out.println(user);
        }
        System.out.println(userPage.getTotal());
    }

条件构造器wrapper(重要)

是不是前面写了那么多，都没有看到主要的操作，比如模糊查询、排序、高级查询这些，那现在来看一下这些东西怎么搞，其实也挺简单，mybatis-plus都已经把你很多操作都已经写好了

下面来看几个测试

查询年龄在21-25岁的用户信息

@Test
    void wrapperTest(){
        //查询年龄在 [21,25]
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.between("age",21,25);
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

@Test
void wrapperTest2(){
    //查询以 李% 并且年龄小于等于20的人信息
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.likeRight("name","李")
            .le("age",20);
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}

查询以 李% 并且年龄小于等于20的人信息

@Test
    void wrapperTest2(){
        //查询以 李% 并且年龄小于等于20的人信息
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.likeRight("name","李")
                .le("age",20);
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

按年龄排序，并且要求年龄要大于20

@Test
    void wrapperTest3(){
        //按年龄排序，并且要求年龄要大于20
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.orderByDesc("age")
                .ge("age",20);
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

打印结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cpfrUXW5-1687159278855)(C:\Users\24128\AppData\Roaming\Typora\typora-user-images\image-20230619112425501.png)]

其他的差不多都是一样的操作，下面我把一些常用的方法列出来

eq			等于 =
例: eq("name", "张三")  --->  name = '张三'
ne			不等于 <>
例: ne("name", "张三")---> name <> '张三'   
gt			大于
例: gt("age", 18) --->   age > 18 
ge			大于等于 >=
例: ge("age", 18)  --->   age >= 18   
lt			小于 <
例: lt("age", 18)  --->   age < 18
le          小于等于 <=
例: le("age", 18)--->age <= 18
between				between 值1 and 值2
例: between("age", 18, 30)--->age between 18 and 30 
notBetween			not between	值1 and 值2
例: notBetween("age", 18, 30)--->age not between 18 and 30
like			LIKE '%值%'
例: like("name", "王")--->name like '%王%'
likeLeft		LIKE '%值'
例: likeLeft("name", "王")--->name like '%王'
notLikeLeft 	NOT LIKE '%值'	
例: notLikeLeft("name", "王")--->name not like '%王'
isNull			字段 IS NULL
例: isNull("name")--->name is null
 in				字段 IN (v1,v2...)  
例: in("id", 1, 2, 3)--->id in (1,2,3)

上面这些官网都有详细的写法和注释

一对一、一对多、多对多

一对一查询

​ 1、定义实体类：

@TableName("user")
public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String username;
    private String email;
    // 省略getter和setter方法
}

@TableName("user_profile")
public class UserProfile {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long userId;
    private String address;
    private String phone;
    // 省略getter和setter方法
}

​ 2、定义mapper接口

public interface UserMapper extends BaseMapper<User> {
    @Select("SELECT u.*, p.address, p.phone FROM user u LEFT JOIN user_profile p ON u.id = p.user_id WHERE u.id = #{id}")
    User getUserWithProfile(@Param("id") Long id);
}

​ 3、执行查询

User user = userMapper.getUserWithProfile(1L);
System.out.println(user.getUsername());
System.out.println(user.getUserProfile().getAddress());
System.out.println(user.getUserProfile().getPhone());

一对多查询

​ 1、定义实体类

@TableName("order")
public class Order {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String orderNumber;
    private Long userId;
    // 省略getter和setter方法
}

@TableName("order_item")
public class OrderItem {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long orderId;
    private String itemName;
    // 省略getter和setter方法
}

​ 2、定义Mapper接口

public interface OrderMapper extends BaseMapper<Order> {
    @Select("SELECT o.*, i.item_name FROM order o LEFT JOIN order_item i ON o.id = i.order_id WHERE o.id = #{id}")
    Order getOrderWithItems(@Param("id") Long id);
}

​ 3、执行查询

Order order = orderMapper.getOrderWithItems(1L);
System.out.println(order.getOrderNumber());
for (OrderItem item : order.getOrderItems()) {
    System.out.println(item.getItemName());
}

多对多查询

@TableName("user")
public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String username;
    private String email;
    // 省略getter和setter方法
}

@TableName("role")
public class Role {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String roleName;
    // 省略getter和setter方法
}

@TableName("user_role")
public class UserRole {
    private Long userId;
    private Long roleId;
    // 省略getter和setter方法
}

​ 2、定义mapper接口

public interface UserMapper extends BaseMapper<User> {
    @Select("SELECT u.*, r.role_name FROM user u LEFT JOIN user_role ur ON u.id = ur.user_id LEFT JOIN role r ON ur.role_id = r.id WHERE u.id = #{id}")
    User getUserWithRoles(@Param("id") Long id);
}

​ 3、执行查询

User user = userMapper.getUserWithRoles(1L);
System.out.println(user.getUsername());
for (Role role : user.getRoles()) {
    System.out.println(role.getRoleName());
}

``java
public interface UserMapper extends BaseMapper {
@Select(“SELECT u.*, r.role_name FROM user u LEFT JOIN user_role ur ON u.id = ur.user_id LEFT JOIN role r ON ur.role_id = r.id WHERE u.id = #{id}”)
User getUserWithRoles(@Param(“id”) Long id);
}

​	3、执行查询

```java
User user = userMapper.getUserWithRoles(1L);
System.out.println(user.getUsername());
for (Role role : user.getRoles()) {
    System.out.println(role.getRoleName());
}