Mybatis Plus-526互联

Mybatis Plus

1,创建数据表并插入数据(注意`和‘的区别)

CREATE TABLE user(
id BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
user_name VARCHAR(20) NOT NULL COMMENT '用户名',
password VARCHAR(20) NOT NULL COMMENT '密码',
name VARCHAR(30) DEFAULT NULL COMMENT '姓名',
age INT(11) DEFAULT NULL COMMENT '年龄',
adress VARCHAR(100) DEFAULT NULL COMMENT'地址',
PRIMARY KEY (id)
) ENGINE=INNODB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;
INSERT INTO user(id,user_name,password,name,age,adress)VALUES
(1,'ruiwen','123','瑞文','12','山东'),(2,'gailun','1332','盖伦',13,'平顶山'),
(3,'timo','123','提莫','22','蘑菇石'),(4,'daji','1222','妲己',221,'王者峡谷');

新建一个maven工程，导入相关依赖

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.sangeng</groupId>
    <artifactId>_01_Mybatis_Puls_QuickStart_SanGeng</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.0</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </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.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>


        <!--mybatisplus代码生成器-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.4.1</version>
        </dependency>
        <!--模板引擎-->
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
        </dependency>
    </dependencies>
</project>

1.创建启动类

package com.sangeng;

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

@SpringBootApplication
@MapperScan("com.sangeng.mapper")
public class SGApplication {
    public static void main(String[] args) {
        SpringApplication.run(SGApplication.class,args);
    }
}

2.创建实体类

package com.sangeng.domian;

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

@Data
@NoArgsConstructor
@AllArgsConstructor
//@TableName("tb_user")
public class User {
//    @TableId(type = IdType.AUTO)
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;

//    @TableField("address")
    private String address;
}

3.使用MybatisPlus

导入相关依赖

com.baomidou
mybatis-plus-boot-starter
3.4.3//mybatis plus 启动器

//数据库驱动
mysql

mysql-connector-java

配置文件

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mplus?characterEncoding=utf-8&serverTimezone=UTC
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
mybatis-plus:
  global-config:
    db-config:
      #表名前缀
#      table-prefix: tb_
      id-type: auto
      logic-delete-field: delFlag
      logic-delete-value: 1
      logic-not-delete-value: 0
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  mapper-locations: classpath*:/mapper/**/*.xml
#  configuration:
#    map-underscore-to-camel-case: false

创建mapper接口

创建mapper接口继承BaseMapper接口

package com.sangeng.mapper;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.sangeng.domian.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;


public interface UserMapper extends BaseMapper<User> {//<>内指定对应的实体类

    User findMyUser(Long id);

    User findMyUserByWrapper(@Param(Constants.WRAPPER) Wrapper<User> wrapper);
}

UserMapper继承了BaseMapper接口的增删改查方法，不需要自己再去写sql语句，除非遇到BaseMapper接口里没有的方法。

mybatis plus会用动态代理帮我们生成Mapper接口对应的实现类对象，注入到Spring容器当中。

配置mapper扫描

可以在每一个mapper接口上加上@mapper注解让mapper被扫描,但是这样比较的麻烦，更优解是直接在Springboot启动类上加上@MapperScan注解，并指向mapper包所在位置.

package com.sangeng;

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

@SpringBootApplication
@MapperScan("com.sangeng.mapper")
public class SGApplication {
    public static void main(String[] args) {
        SpringApplication.run(SGApplication.class,args);
    }
}

Springboot测试类

package com.sangeng;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.metadata.TableFieldInfo;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.sangeng.domian.Orders;
import com.sangeng.domian.User;
import com.sangeng.mapper.OrdersMapper;
import com.sangeng.mapper.UserMapper;
import com.sangeng.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.*;
import java.util.function.Predicate;

@SpringBootTest
public class MPTest {
    //获取UserMapper的实现类对象
    //由于mybatis plus 动态代理会根据mapper接口自动生成Mapper实现类对象注入到Spring容器当中
    //我们只需要定义一个mapper接口类型的成员变量，通过autowrited注解注入到容器里获取实现类对象。

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testQueryList(){
        // select id,username,password,name,age,address from user
        List<User> users = userMapper.selectList(null);
        System.out.println(users);
    }
    @Test
    public void testInsert(){
        User user = new User();
        user.setUserName("三更草堂333");
        user.setPassword("7777888");
        int r = userMapper.insert(user);
        System.out.println(r);
    }

    @Test
    public void testDelete(){
        List<Integer> ids = new ArrayList<>();
        ids.add(5);
        ids.add(6);
        ids.add(7);
        int i = userMapper.deleteBatchIds(ids);
        System.out.println(i);
    }
    @Test
    public void testDeleteById(){
        int i = userMapper.deleteById(8);
        System.out.println(i);
    }
    @Test
    public void testDeleteByMap(){
        Map<String, Object> map = new HashMap<>();
        map.put("name","提姆");
        map.put("age",22);
        int i = userMapper.deleteByMap(map);
        System.out.println(i);
    }
    @Test
    public void testUpdate(){
        //把id为2的用户的年龄改为14
        User user = new User();
        user.setId(2L);
        user.setAge(14);
        int i = userMapper.updateById(user);
        System.out.println(i);
    }

    @Test
    public void testWrapper01(){
        QueryWrapper wrapper = new QueryWrapper();
        wrapper.gt("age",18);
        wrapper.eq("address","狐山");
        List<User> users = userMapper.selectList(wrapper);
        System.out.println(users);
    }

    @Test
    public void testMyMethod(){
        QueryWrapper wrapper = new QueryWrapper();
        wrapper.eq("id",1);
//        wrapper.eq("address","山东");
        User user = userMapper.findMyUserByWrapper(wrapper);
        System.out.println(user);
    }

    @Test
    public void testWrapper02(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.in("id",1,2,3);
        wrapper.between("age",12,29);
        wrapper.like("address","山");
        List<User> users = userMapper.selectList(wrapper);

        System.out.println(users);
    }


    @Test
    public void testPage(){
        IPage<User> page = new Page<>();
        //设置每页条数
        page.setSize(2);
        //设置查询第几页
        page.setCurrent(1);
        userMapper.selectPage(page, null);
        System.out.println(page.getRecords());//获取当前页的数据
        System.out.println(page.getTotal());//获取总记录数
        System.out.println(page.getCurrent());//当前页码
    }

    @Autowired
    private UserService userService;


    @Test
    public void testSeervice(){
//        List<User> list = userService.list();
//        System.out.println(list);

        Page<User> page = new Page<>();
        //设置每页大小
        page.setSize(2);
        //设置当前页码
        page.setCurrent(2);
        userService.page(page);
        System.out.println(page.getRecords());

    }

    @Autowired
    private OrdersMapper ordersMapper;
    @Test
    public void testOrdersPage(){
        Page<Orders> page = new Page<>();
        //设置每页大小
        page.setSize(2);
        //设置当前页码
        page.setCurrent(2);
        ordersMapper.findAllOrders(page);
        System.out.println(page.getRecords());
        System.out.println(page.getTotal());
    }

    @Test
    public void testFill(){
        Orders orders = new Orders();
        orders.setPrice(123);
        orders.setId(12L);

        ordersMapper.update(orders,null);
//        ordersMapper.insert(orders);
    }
    @Test
    public void testDelete02(){
//        int i = ordersMapper.deleteById(12L);

        ordersMapper.selectList(null);
    }

    @Test
    public void testWrapper03(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.in("id",1,2,3);
        queryWrapper.gt("age",10);
        queryWrapper.orderByDesc("age");
        List<User> users = userMapper.selectList(queryWrapper);
        System.out.println(users);
    }
    @Test
    public void testSelect01(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("id","user_name");
        List<User> users = userMapper.selectList(queryWrapper);
        System.out.println(users);
    }

    @Test
    public void testSelect02(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.select(User.class, new Predicate<TableFieldInfo>() {
            @Override
            public boolean test(TableFieldInfo tableFieldInfo) {
                return "user_name".equals(tableFieldInfo.getColumn());
            }
        });
        List<User> users = userMapper.selectList(queryWrapper);
        System.out.println(users);
    }

    @Test
    public void testSelect03(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>(new User());
        queryWrapper.select(new Predicate<TableFieldInfo>() {
            @Override
            public boolean test(TableFieldInfo tableFieldInfo) {
                return !"address".equals(tableFieldInfo.getColumn());
            }
        });
        List<User> users = userMapper.selectList(queryWrapper);
        System.out.println(users);
    }


    @Test
    public void testUpdateWrapper(){


        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.gt("id",1);
        updateWrapper.set("age",99);
        userMapper.update(null,updateWrapper);
    }

    @Test
    public void testVersion(){
        //查询id为3的数据
        QueryWrapper<Orders> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("id",3);
        Orders orders = ordersMapper.selectOne(queryWrapper);


        //对id为3的数据进行更新  把price修改为88
        orders.setPrice(88);
        ordersMapper.updateById(orders);
    }

    @Test
    public void testOrdersPage2(){
        Page<Orders> page = new Page<>();
        page.setSize(2);
        page.setCurrent(2);
        ordersMapper.selectPage(page,null);
    }

    @Test
    public void testLambdaWrapper(){
        QueryWrapper<User> queryWrapper = new QueryWrapper();
        queryWrapper.gt("age",18);
        queryWrapper.eq("address","狐山");

        List<User> users = userMapper.selectList(queryWrapper);
    }

    @Test
    public void testLambdaWrapper2(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.gt(User::getAge,18);
        queryWrapper.eq(User::getAddress,"狐山");
        List<User> users = userMapper.selectList(queryWrapper);
    }

    @Test
    public void testMyMehtod(){
        User myUser = userMapper.findMyUser(1L);
        System.out.println(myUser);
    }
}

Mybatis Plus相比于mybatis新增的内容

添加了mybatis plus依赖

com.baomidou
mybatis-plus-boot-starter
3.4.3//mybatis plus 启动器

mapper接口继承了BaseMapper接口并指定了实现类。

public interface UserMapper extends BaseMapper {//<>内指定对应的实体类

User findMyUser(Long id);

User findMyUserByWrapper(@Param(Constants.WRAPPER) Wrapper<User> wrapper);

}

其余的如配置数据库，实体类，配置数据库驱动等等都和mybatis一致

然后你就可以放心大胆的在测试类中通过@autowrited 注入对应的mapper对象，使用对象的相关方法。

Mybatis Plus常用设置

设置表映射规则

默认情况下MP操作的表名就是实体类的类名，但是如果表名和类型不一致就是需要我们自己设置映射规则

1.单独设置

可以在实体类的类名上加上@TableName注解进行标识

例如：

如果表名是tb_user,而实体类名是User可以采用以下写法

//@TableName("tb_user")
public class User {

}

全局配置

如果一个项目中表名都相比于类名多了个前缀tb_,则可以通过mybatis plus全局配置

mybatis-plus:
  global-config:
    db-config:
      #表名前缀
      table-prefix: tb_

设置主键生成策略

单独设置

默认情况下使用MP插入数据时，如果我们没有设置主键生成策略的情况下默认的策略是基于雪花算法的自增id

如果我们需要使用别的策略可以在定义实体类时，在代表主键的字段上加上@TableId注解，使用其type属性指定主键生成策略

例如我们要设置主键自动增长可以设置如下

public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;

如果不设置主键生成策略,在执行数据库插入操作时，根据根据雪花算法的自增id是不可控的。。

Snipaste_2023-03-29_17-28-24

全局设置

mybatis-plus:
  global-config:
    db-config:
      #表名前缀
#      table-prefix: tb_
#id生成策略，auto为数据库自增
      id-type: auto

设置字段和列名的驼峰映射

默认情况下MP会开启字段名列名的驼峰映射，即从经典数据库列名A_COLUMN到经典java属性名aColumn（驼峰命名）的类似映射。

如果关闭我们可以使用如下配置.

mybatis-plus:
	configuration:
   	 map-underscore-to-camel-case: false

设置字段映射关系

默认情况下MP会根据实体类的属性去映射表的列名

如果数据库的列表和实体类的属性名不一致我们可以使用@TableFiled注解的Value属性去设置映射关系。

例如：

如果一个数据库表名的属性叫adress而实体类中的属性名为adressStr则可以使用如下方式进行配置。

@TableField("address")
 private String addressStr;

日志

如果需要打印MP操作对应的SQL语句等，可以配置日志输出

配置方式如下：

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

MP基本使用

插入数据

@Test
public void testInsert(){
    User user = new User();
    user.setUserName("三更草堂333");
    user.setPassword("7777888");
    int r = userMapper.insert(user);
    System.out.println(r);
}

删除数据

1.根据id列表删除数据

@Test
public void testDelete(){
    List<Integer> ids = new ArrayList<>();
    ids.add(1);
    ids.add(2);
    ids.add(3);
    int i = userMapper.deleteBatchIds(ids);
    System.out.println(i);
}

2.删除单个id

@Test
public void testDeleteById(){
    int i = userMapper.deleteById(8);
    System.out.println(i);
}

3.根据map集合删除

@Test
public void testDeleteByMap(){
    //选择键值对都符合要求的进行删除
    Map<String, Object> map = new HashMap<>();
    map.put("name","提姆");
    map.put("age",22);
    int i = userMapper.deleteByMap(map);
    System.out.println(i);
}

更新数据

@Test
public void testUpdate(){
    //把id为2的用户的年龄改为14
    User user = new User();
    user.setId(2L);
    user.setAge(14);
    int i = userMapper.updateById(user);
    System.out.println(i);
}