您的位置:首页 > 其它

Mybatis-plus的快速集成和入门使用

2020-01-11 13:31 357 查看

Mybatis-plus的快速集成和入门使用

  • 三、Plus-入门 通用CRUD
  • 四、Plus-入门 配置
  • 五、条件构造器
  • 一、MyBatis Plus 介绍

    MyBatis Plus 是国内人员开发的 MyBatis 增强工具,

    在 MyBatis 的基础上只做增强不做改变,为简化开发、提高效率而生

    MyBatis Plus 的核心功能有:支持通用的 CRUD、代码生成器与条件构造器。

    1. 通用 CRUD:内置通用 Mapper,定义好 Mapper 接口后,只需要继承
      BaseMapper<T>
      接口即可获得通用的增删改查功能,无需编写任何接口方法与配置文件
    2. 条件构造器:通过
      Wrapper<T>
      (实体包装类),可以用于拼接 SQL 语句,并且支持排序、分组查询等复杂的 SQL
    3. 代码生成器:支持一系列的策略配置与全局配置,比 MyBatis 的代码生成更好用。

    这里就不过多叙述了 更多 Mybatis-plus 介绍 可以去官网了解。

    BaseMapper 接口中通用的 CRUD 方法:

    二、MyBatis Plus 集成

    将会讲解 Mybatis + MP 、Spring + Mybatis + MP 、SpringBoot + Mybatis + MP

    一、准备工作

    创建数据库以及表

    -- 创建测试表
    CREATE TABLE `tb_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 '年龄',
    `email` varchar(50) DEFAULT NULL COMMENT '邮箱',
    PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
    
    -- 插入测试数据
    INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
    ('1', 'zhangsan', '123456', '张三', '18', 'test1@test.cn');
    INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
    ('2', 'lisi', '123456', '李四', '20', 'test2@test.cn');
    INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
    ('3', 'wangwu', '123456', '王五', '28', 'test3@test.cn');
    INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
    ('4', 'zhaoliu', '123456', '赵六', '21', 'test4@test.cn');
    INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
    ('5', 'sunqi', '123456', '孙七', '24', 'test5@test.cn');

    二、Mybatis + MP 整合

    1、创建工程+导入依赖+日志配置

    <?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.plus.demo</groupId>
    <artifactId>mybatis-plus-simple</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    
    <dependencies>
    <dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus</artifactId>
    <version>3.3.0</version>
    </dependency>
    <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
    </dependency>
    <!-- 连接池 -->
    <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.0.11</version>
    </dependency>
    <!--简化bean代码的工具包-->
    <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
    <version>1.18.4</version>
    </dependency>
    <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    </dependency>
    <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.6.4</version>
    </dependency>
    </dependencies>
    <build>
    <plugins>
    <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <configuration>
    <source>1.8</source>
    <target>1.8</target>
    </configuration>
    </plugin>
    </plugins>
    </build>
    </project>

    log4j.properties:

    log4j.rootLogger=DEBUG,A1
    log4j.appender.A1=org.apache.log4j.ConsoleAppender
    log4j.appender.A1.layout=org.apache.log4j.PatternLayout
    log4j.appender.A1.layout.ConversionPattern=[%t] [%c]-[%p] %m%n

    有些人会问为啥不引 Mybatis 依赖 因为 Mybatis-plus 依赖包含了 还包含和spring整合的依赖

    2、Mybatis实现查询User

    2.1 编写mybatis-config.xml文件:

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
    PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
    <environments default="development">
    <environment id="development">
    <transactionManager type="JDBC"/>
    <dataSource type="POOLED">
    <property name="driver" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis_plus?useUnicode=true&amp;characterEncoding=utf8&amp;autoReconnect=true&amp;allowMultiQueries=true&amp;useSSL=false"/>
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
    </dataSource>
    </environment>
    </environments>
    <mappers>
    <mapper resource="UserMapper.xml"/>
    </mappers>
    </configuration>

    2.2 编写User实体对象:(这里使用lombok进行了进化bean操作)

    @Data //自动提供getter和setter、hashCode、equals、toString等方法
    @NoArgsConstructor //无参构造
    @AllArgsConstructor //全参构造
    public class User {
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email;
    }

    2.3 编写UserMapper接口:

    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.mp.boot.pojo.User;
    
    public interface UserMapper {
    
    User findById(Long id);
    
    }

    2.4 编写UserMapper.xml文件:

    <?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.mp.boot.mapper.UserMapper">
    <select id="findById" resultType="User">
    select * from tb_user where id = #{id}
    </select>
    </mapper>

    2.5 编写TestMybatis测试用例:

    package com.mp.simple;
    
    import com.baomidou.mybatisplus.core.MybatisSqlSessionFactoryBuilder;
    import com.mp.simple.mapper.UserMapper;
    import com.mp.simple.pojo.User;
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    import org.junit.Test;
    
    import java.io.InputStream;
    import java.util.List;
    
    public class TestMybatis {
    
    @Test
    public void testUserList() throws Exception{
    String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sqlSessionFactory = new
    SqlSessionFactoryBuilder().build(inputStream);
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    List<User> list = userMapper.findAll();
    for (User user : list) {
    System.out.println(user);
    }
    }
    
    }

    测试结果:
    User(id=1, userName=null, password=123456, name=张三, age=18, email=test1@163.cn)
    User(id=2, userName=null, password=123456, name=李四, age=20, email=test2@163.cn)
    User(id=3, userName=null, password=123456, name=王五, age=28, email=test3@163.cn)
    User(id=4, userName=null, password=123456, name=赵六, age=21, email=test4@163.cn)
    User(id=5, userName=null, password=123456, name=孙七, age=24, email=test5@163.cn)

    有些人会问为啥userName为null 因为实体类属性和数据库字段不匹配 我们也没配置驼峰!!!

    2.6 Mybatis+MP实现查询User

    第一步,将UserMapper继承BaseMapper,将拥有了BaseMapper中的所有方法:

    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.mp.simple.pojo.User;
    
    import java.util.List;
    
    public interface UserMapper extends BaseMapper<User> {
    List<User> findAll();
    }

    第二步,使用MP中的MybatisSqlSessionFactoryBuilder进程构建:

    import com.baomidou.mybatisplus.core.MybatisSqlSessionFactoryBuilder;
    import com.mp.simple.mapper.UserMapper;
    import com.mp.simple.pojo.User;
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    import org.junit.Test;
    
    import java.io.InputStream;
    import java.util.List;
    
    public class TestMybatis {
    
    @Test
    public void testUserList() throws Exception{
    String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    //这里使用的是MP中的MybatisSqlSessionFactoryBuilder
    SqlSessionFactory sqlSessionFactory = new MybatisSqlSessionFactoryBuilder().build(inputStream);
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    // 可以调用BaseMapper中定义的方法
    // queryWrapper 条件构造器 我们先不填 填null  直接查所有
    List<User> list = userMapper.selectList(null);
    for (User user : list) {
    System.out.println(user);
    }
    }
    
    }

    运行报错:

    原因:他会把实体类首字母小写 然后去数据库查user这张表 但我们定义的表是tb_user 所以是查不到的。

    解决:在User对象中添加

    @TableName
    ,指定数据库表名

    import com.baomidou.mybatisplus.annotation.TableName;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    //对象中添加@TableName,指定数据库表名
    @TableName("tb_user")
    public class User {
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email;
    }

    再次运行 就没有问题啦 现在userName就有值 那么就说明MP自带驼峰:

    User(id=1, userName=zhangsan, password=123456, name=张三, age=18, email=test1@163.cn)
    User(id=2, userName=lisi, password=123456, name=李四, age=20, email=test2@163.cn)
    User(id=3, userName=wangwu, password=123456, name=王五, age=28, email=test3@163.cn)
    User(id=4, userName=zhaoliu, password=123456, name=赵六, age=21, email=test4@163.cn)
    User(id=5, userName=sunqi, password=123456, name=孙七, age=24, email=test5@163.cn)

    简单说明:主要要让

    Mapper
    接口继承MP提供的
    BaseMapper
    由于使用了
    MybatisSqlSessionFactoryBuilder
    进行了构建,继承的BaseMapper中的方法就载入到了 SqlSession 中,所以就可以直接使用相关的方法;

    三、Spring + Mybatis + MP

    引入了Spring框架,数据源、构建等工作就交给了Spring管理。

    1、创建工程+导入依赖+配置

    <?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.plus.demo</groupId>
    <artifactId>mybatis-plus-spring</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    
    <properties>
    <spring.version>5.1.6.RELEASE</spring.version>
    </properties>
    
    <dependencies>
    <dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus</artifactId>
    <version>3.3.0</version>
    </dependency>
    <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
    </dependency>
    <!-- 连接池 -->
    <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.0.11</version>
    </dependency>
    <!--简化bean代码的工具包-->
    <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
    <version>1.18.4</version>
    </dependency>
    <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    </dependency>
    <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.6.4</version>
    </dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>${spring.version}</version>
    </dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>${spring.version}</version>
    </dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>${spring.version}</version>
    </dependency>
    </dependencies>
    <build>
    <plugins>
    <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <configuration>
    <source>1.8</source>
    <target>1.8</target>
    </configuration>
    </plugin>
    </plugins>
    </build>
    </project>

    编写jdbc.properties:

    jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://127.0.0.1:3306/mybatis_plus?
    useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false
    jdbc.username=root
    jdbc.password=123456

    编写applicationContext.xml:

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">
    <context:property-placeholder location="classpath:*.properties"/>
    <!-- 定义数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
    destroy-method="close">
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
    <property name="driverClassName" value="${jdbc.driver}"/>
    <property name="maxActive" value="10"/>
    <property name="minIdle" value="5"/>
    </bean>
    <!--这里使用Mybatis-plus提供的sqlSessionFactory,完成了Spring与MP的整合-->
    <bean id="sqlSessionFactory"
    class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--扫描mapper接口,使用的依然是Mybatis原生的扫描器-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.mp.spring.mapper"/>
    </bean>
    </beans>

    2、实现查询User

    2.1 编写User对象以及UserMapper接口:

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    //指定数据库表名
    @TableName("tb_user")
    public class User {
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email;
    }
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.mp.spring.pojo.User;
    
    public interface UserMapper extends BaseMapper<User> {
    }

    2.2 编写编写测试用例:

    import com.mp.spring.mapper.UserMapper;
    import com.mp.spring.pojo.User;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    import java.util.List;
    
    @RunWith(SpringJUnit4ClassRunner.class)
    // 拿到applicationContext.xml里面所有的配置   可以理解为加载xml文件
    // 这样就可以在测试类中使用注解简单的注入需要的bean了
    @ContextConfiguration(locations = "classpath:applicationContext.xml")
    public class TestMybatis {
    
    @Autowired
    private UserMapper userMapper;
    
    @Test
    public void testSelectList(){
    List<User> users = this.userMapper.selectList(null);
    for (User user : users) {
    System.out.println(user);
    }
    }
    }

    尴尬的是 又报错了:

    因为我们是在test里写的 他读取读的是test模块下的jdbc.properties 但我们test下面没有resources 所以读取不到 有两种解决方法 第一就是把数据库的参数写死 或者 在test模块里 加resources 加个jdbc.properties

    这样可以正常运行了:
    User(id=1, userName=zhangsan, password=123456, name=张三, age=18, email=test1@163.cn)
    User(id=2, userName=lisi, password=123456, name=李四, age=20, email=test2@163.cn)
    User(id=3, userName=wangwu, password=123456, name=王五, age=28, email=test3@163.cn)
    User(id=4, userName=zhaoliu, password=123456, name=赵六, age=21, email=test4@163.cn)
    User(id=5, userName=sunqi, password=123456, name=孙七, age=24, email=test5@163.cn)

    四、SpringBoot + Mybatis + MP

    1、创建工程+导入依赖+日志配置

    <?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>
    
    <!--
    使用SpringBoot将进一步的简化MP的整合,
    -->
    <groupId>com.boot.mybatis.plus</groupId>
    <artifactId>mybatis-plus-boot-test</artifactId>
    <version>1.0-SNAPSHOT</version>
    
    <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.4.RELEASE</version>
    </parent>
    
    <dependencies>
    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <exclusions>
    <exclusion>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-logging</artifactId>
    </exclusion>
    </exclusions>
    </dependency>
    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
    </dependency>
    <!--简化代码的工具包-->
    <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
    </dependency>
    <!--mybatis-plus的springboot支持-->
    <dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.1.1</version>
    </dependency>
    <!--mysql驱动-->
    <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
    </dependency>
    <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    </dependency>
    </dependencies>
    <build>
    <plugins>
    <plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
    </plugins>
    </build>
    </project>

    log4j.properties:

    log4j.rootLogger=DEBUG,A1
    log4j.appender.A1=org.apache.log4j.ConsoleAppender
    log4j.appender.A1.layout=org.apache.log4j.PatternLayout
    log4j.appender.A1.layout.ConversionPattern=[%t] [%c]-[%p] %m%n

    2、编写application.yml

    spring.application.name: mp-springboot
    spring.datasource.driver-class-name: com.mysql.jdbc.Driver
    spring.datasource.url: jdbc:mysql://127.0.0.1:3306/mybatis_plus?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false
    spring.datasource.username: root
    spring.datasource.password: 123456

    3、编写pojo、Mapper

    package com.mp.boot.pojo;
    
    import com.baomidou.mybatisplus.annotation.TableName;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @TableName("tb_user")
    public class User {
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email;
    }
    package com.mp.boot.mapper;
    
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.mp.boot.pojo.User;
    
    public interface UserMapper extends BaseMapper<User> {
    
    User findById(Long id);
    
    }

    4、编写boot启动类

    package com.mp.boot;
    
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class MyApplication {
    public static void main(String[] args) {
    SpringApplication.run(MyApplication.class, args);
    }
    }

    5、编写测试用例

    package com.mp.boot;
    
    import com.mp.boot.mapper.UserMapper;
    import com.mp.boot.pojo.User;
    import org.junit.Test;
    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 java.util.List;
    
    @RunWith(SpringRunner.class)   //等同于 SpringJUnit4ClassRunner  因为他继承了 SpringJUnit4ClassRunner
    @SpringBootTest //是springboot 用于测试的注解,可指定启动类或者测试环境等,这里直接默认
    public class TestMybatisSpringBoot {
    
    @Autowired
    private UserMapper userMapper;
    
    @Test
    public void testSelect() {
    //queryWrapper 是构建条件 咱们暂时不构建  直接查所有
    List<User> userList = userMapper.selectList(null);
    for (User user : userList) {
    System.out.println(user);
    }
    }
    
    }

    运行成功
    User(id=1, userName=zhangsan, password=123456, name=张三, age=18, email=test1@163.cn)
    User(id=2, userName=lisi, password=123456, name=李四, age=20, mail=test2@163.cn)
    User(id=3, userName=wangwu, password=123456, name=王五, age=28, email=test3@163.cn)
    User(id=4, userName=zhaoliu, password=123456, name=赵六, age=21, email=test4@163.cn)
    User(id=5, userName=sunqi, password=123456, name=孙七, age=24, email=test5@163.cn)

    三、Plus-入门 通用CRUD

    注意:
    以下所有操作都是使用 boot集成mybatis的项目

    一、插入操作

    insert

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserMapperTest {
    
    @Autowired
    private UserMapper userMapper;
    
    @Test
    public void testInsert(){
    User user = new User();
    user.setAge(21);
    user.setName("狗剩");
    user.setPassword("123456");
    user.setUserName("gousheng");
    
    //新增操作  需要给个user实体类
    int result = userMapper.insert(user);   //返回的result是受影响的行数,并不是自增后的id
    
    System.out.println("result="+result);
    
    System.out.println("result = " + result);
    System.out.println(user.getId()); //自增后的id会回填到对象中
    }
    }
    [main] [com.mp.boot.mapper.UserMapper.insert]-[DEBUG] ==>  Preparing: INSERT INTO tb_user ( id, user_name, password, name, age ) VALUES ( ?, ?, ?, ?, ? )
    [main] [com.mp.boot.mapper.UserMapper.insert]-[DEBUG] ==> Parameters: 1207198118517411842(Long), gousheng(String), 123456(String), 狗剩(String), 21(Integer)
    [main] [com.mp.boot.mapper.UserMapper.insert]-[DEBUG] <==    Updates: 1
    [main] [org.mybatis.spring.SqlSessionUtils]-[DEBUG] Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@160396db]
    result=1
    result = 1
    1207198118517411842

    可以看到,数据已经写入到了数据库,但是,id的值不正确,我们期望的是数据库自增长,实际是MP生成了id的值写入到了数据库。

    设置id生成策略 id自增长 @TableId(type = IdType.AUTO):

    package com.mp.boot.pojo;
    
    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 {
    //设置主键id的生成策略   默认是NONE
    //大家也可以点击这个注解进去看一下 有五种策略可以指定  默认的是是随机生成的
    @TableId(type = IdType.AUTO)   //指定id类型为自增长
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email;
    
    }

    数据插入成功:

    @TableField

    在MP中通过@TableField注解可以指定字段的一些属性,常常解决的问题有2个:
    1、对象中的属性名和字段名不一致的问题(非驼峰)
    2、对象中的属性字段在表中不存在的问题
    使用:

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @TableName("tb_user")
    public class User {
    //设置主键id的生成策略   默认是NONE
    @TableId(type = IdType.AUTO)
    private Long id;
    //指定映射字段
    @TableField(value = "user_name")
    private String userName;
    //字段不加入查询字段
    @TableField(select = false)
    private String password;
    private String name;
    private Integer age;
    
    @TableField(value = "email")  //解决字段名不一致   比如数据库里是email 变量写的是mail
    private String mail;
    
    //我们数据库中是没有这个字段的  新增的时候 给他也赋值了 他的sql 语句
    // INSERT INTO tb_user  ( user_name, password, name, age,  address )  VALUES  ( ?, ?, ?, ?,  ? )
    // 但我们数据库里根本没有  字段 所以会报错   我们加注解  可以指定对改属性不做操作
    @TableField(exist = false) // 该字段 在数据库里不存在  查询或新增 就不会查这个字段了
    private String address;
    }

    因为我password 设置不加入查询 所以就没查了 password为null
    sql=>SELECT id,user_name,name,age,email AS mail FROM tb_user
    User(id=1, userName=zhangsan, password=null, name=张三, age=18, mail=test1@163.cn, address=null)
    User(id=2, userName=lisi, password=null, name=李四, age=20, mail=test2@163.cn, address=null)
    User(id=3, userName=wangwu, password=null, name=王五, age=28, mail=test3@163.cn, address=null)
    User(id=4, userName=zhaoliu, password=null, name=赵六, age=21, mail=test4@163.cn, address=null)
    User(id=5, userName=sunqi, password=null, name=孙七, age=24, mail=test5@163.cn, address=null)

    二、更新操作

    updateById

    /**
    * 根据 ID 修改
    *
    * @param entity 实体对象
    */
    int updateById(@Param(Constants.ENTITY) T entity);
    
    @Test
    public void testUpdateById() {
    User user = new User();
    user.setId(6L); //主键
    user.setAge(23); //更新的字段
    
    //sql  UPDATE tb_user SET age=? WHERE id=?
    //根据id更新,更新不为null的字段
    int result = userMapper.updateById(user);
    System.out.println("result="+result);
    }

    根据条件更新 之前我们有个条件构造器 我们一直没填 现在开始来讲解它

    /**
    * 根据 whereEntity 条件,更新记录
    *
    * @param entity 实体对象 (set 条件值,可以为 null)
    * @param updateWrapper 实体对象封装操作类(可以为 null,里面的 entity 用于生成 where 语句)
    */
    int update(@Param(Constants.ENTITY) T entity,
    @Param(Constants.WRAPPER) Wrapper<T>
    updateWrapper);
    
    @Test
    public void testUpdate() {
    User user = new User();
    //更新数据
    user.setAge(30);
    
    //更新的条件
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.eq("user_name", "zhangsan"); //匹配user_name = zhangsan 的用户数据
    
    //sql UPDATE tb_user SET age=? WHERE user_name = ?
    int result = userMapper.update(user, wrapper);
    System.out.println("result="+result);
    }

    可以用两种条件的构造器 UpdateWrapper 和 QueryWrapper
    UpdateWrapper 可以直接set参数 Query是没有的set方法的

    @Test
    public void testUpdate2() {
    UpdateWrapper<User> wrapper = new UpdateWrapper<>();
    //QueryWrapper 是没有set方法的
    //这里都是字段名字  不是实体中的属性
    wrapper.set("age",888)  //更新的字段
    .eq("id",6);  //更新的条件
    
    int result = userMapper.update(null, wrapper); //返回的result是受影响的行数,并不是自增后的id
    System.out.println("result="+result);
    }

    三、删除操作

    deleteById

    /**
    * 根据 ID 删除
    *
    * @param id 主键ID
    */
    int deleteById(Serializable id);
    
    @Test
    public void testDeleteById() {
    //执行删除操作
    int result = userMapper.deleteById(6L);
    
    //result 是受影响的行数
    System.out.println("result="+result);
    }

    结果:

    deleteByMap

    /**
    * 根据 columnMap 条件,删除记录
    *
    * @param columnMap 表字段 map 对象
    */
    int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
    
    @Test
    public void testDeleteByMap() {
    //构造删除条件
    Map<String, Object> columnMap = new HashMap<>();
    columnMap.put("age",20);
    columnMap.put("user_name","zhangsan");
    
    //将columnMap中的元素设置为删除的条件,多个之间为and关系
    int result = this.userMapper.deleteByMap(columnMap);
    System.out.println("result = " + result);
    }

    结果:
    因为我们数据库中张三的年龄是30 所以没有对应的数据

    delete

    /**
    * 根据 entity 条件,删除记录
    *
    * @param wrapper 实体对象封装操作类(可以为 null)
    */
    int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
    
    @Test
    public void testDelete() {
    
    //方法一
    //        User user = new User();
    //        user.setAge(20);
    //        user.setName("张三");
    //        //将实体对象进行包装,包装为操作条件
    //        QueryWrapper<User> wrapper = new QueryWrapper<>(user);
    
    //方法二
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //多个eq  也是and 的关系
    wrapper.eq("name","张三").eq("password","123456");
    
    int result = this.userMapper.delete(wrapper);
    System.out.println("result = " + result);
    }

    结果:

    deleteBatchIds

    /**
    * 删除(根据ID 批量删除)
    *
    * @param idList 主键ID列表(不能为 null 以及 empty)
    */
    int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable>
    idList);
    
    @Test
    public void testDeleteBatchIds() {
    //根据id集合批量删除
    int result = this.userMapper.deleteBatchIds(Arrays.asList(2L,10L,20L));
    System.out.println("result = " + result);
    }

    结果:

    四、查询操作

    MP提供了多种查询操作,包括根据id查询、批量查询、查询单条数据、查询列表、分页查询等操作。

    selectById

    /**
    * 根据 ID 查询
    *
    * @param id 主键ID
    */
    T selectById(Serializable id);
    
    @Test
    public void testSelectById() {
    //根据id查询数据
    User user = this.userMapper.selectById(3L);
    System.out.println("result = " + user);
    }

    结果:

    selectBatchIds

    /**
    * 查询(根据ID 批量查询)
    *
    * @param idList 主键ID列表(不能为 null 以及 empty)
    */
    List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable>
    idList);
    
    @Test
    public void testSelectBatchIds() {
    //根据id集合批量查询
    List<User> users = this.userMapper.selectBatchIds(Arrays.asList(2L, 3L, 4L));
    for (User user : users) {
    System.out.println(user);
    }
    }

    结果:

    selectOne

    /**
    * 根据 entity 条件,查询一条记录
    *
    * @param queryWrapper 实体对象封装操作类(可以为 null)
    */
    T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    
    @Test
    public void testSelectOne() {
    QueryWrapper<User> wrapper = new QueryWrapper<User>();
    wrapper.eq("name", "王五");
    
    //根据条件查询一条数据,如果结果超过一条会报错
    User user = this.userMapper.selectOne(wrapper);
    
    System.out.println(user);
    }

    结果:

    selectCount

    /**
    * 根据 Wrapper 条件,查询总记录数
    *
    * @param queryWrapper 实体对象封装操作类(可以为 null)
    */
    Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    
    @Test
    public void testSelectCount() {
    QueryWrapper<User> wrapper = new QueryWrapper<User>();
    wrapper.gt("age", 23); //年龄大于23岁
    
    //根据条件查询数据条数
    //sql---> SELECT COUNT( 1 ) FROM tb_user WHERE age > ?
    Integer count = this.userMapper.selectCount(wrapper);
    System.out.println("count = " + count);
    }

    结果:

    selectList

    /**
    * 根据 entity 条件,查询全部记录
    *
    * @param queryWrapper 实体对象封装操作类(可以为 null)
    */
    List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    
    @Test
    public void testSelectList() {
    QueryWrapper<User> wrapper = new QueryWrapper<User>();
    wrapper.gt("age", 23); //年龄大于23岁
    
    //根据条件查询数据
    List<User> users = this.userMapper.selectList(wrapper);
    
    for (User user : users) {
    System.out.println("user = " + user);
    }
    }

    结果:

    selectPage

    /**
    * 根据 entity 条件,查询全部记录(并翻页)
    *
    * @param page 分页查询条件(可以为 RowBounds.DEFAULT)
    * @param queryWrapper 实体对象封装操作类(可以为 null)
    */
    IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    
    @Test
    public void testSelectPage() {
    
    //构造查询条件
    QueryWrapper<User> wrapper = new QueryWrapper<User>();
    wrapper.like("email","test");
    
    //构建分页
    Page<User> page = new Page<>(1,1); //查询第一页 查询一条数据
    
    //根据条件查询数据
    IPage<User> iPage = userMapper.selectPage(page, wrapper);
    System.out.println("数据总条数="+iPage.getTotal());
    System.out.println("总页数="+iPage.getPages());
    System.out.println("当前页="+iPage.getCurrent());
    
    List<User> records = iPage.getRecords();
    records.forEach(System.out::println);
    }

    配置分页插件:

    package com.mp.boot;
    
    import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration  //标记为这是一个配置类  可以理解有了这个注解就等于spring的xml
    @MapperScan("com.mp.boot.mapper") //设置mapper接口的扫描包
    public class MybatisPlusConfig {
    
    /**
    *  @Bean这个注解 就是产生一个bean  注入到ioc容器里 交给spring容器管理
    *  等同于 <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">     </bean>
    */
    @Bean //配置分页插件
    public PaginationInterceptor paginationInterceptor() {
    return  new PaginationInterceptor();
    }
    }

    使用分页一定要配置分页插件  不然会没用

    结果:

    四、Plus-入门 配置

    在MP中有大量的配置,其中有一部分是Mybatis原生的配置,另一部分是MP的配置。

    一、基本配置

    configLocation

    MyBatis 配置文件位置,如果您有单独的 MyBatis 配置,请将其路径配置到 configLocation 中。 MyBatis Configuration 的具体内容请参考MyBatis 官方文档

    Spring Boot:

    #指定全局的配置文件
    mybatis-plus.config-location: classpath:mybatis-config.xml

    把分页插件注释掉了

    创建mybatis-config.xml 设置分页插件 又可以使用分页了

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
    PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
    <plugins>
    <plugin interceptor="com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor"></plugin>
    </plugins>
    </configuration>

    Spring MVC:

    <!--这里使用Mybatis-plus提供的sqlSessionFactory,完成了Spring与MP的整合-->
    <bean id="sqlSessionFactory"
    class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <!--
    mybatis-config.xml 可以设置分页插件   然后这边也可以进行分页查询了
    -->
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>

    mapperLocations

    MyBatis Mapper 所对应的 XML 文件位置,如果您在 Mapper 中有自定义方法(XML 中有自定义实现),需要进行该配置,告诉 Mapper 所对应的 XML 文件位置。

    Spring Boot:

    #单表查询不满足需求  需要写xml 进行联查等 指定mapper.xml 文件的路径
    # classpath* 加上*是 可以扫描所有依赖中的classpath(即加载多个 jar 包下的 XML 文件)下面的xml文件    没有*号 是扫描当前resources下的文件
    mybatis-plus.mapper-locations: classpath*:mybatis/*.xml

    创建UserMapper,xml

    <?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.mp.boot.mapper.UserMapper">
    <select id="findById" resultType="com.mp.boot.pojo.User">
    select * from tb_user where id = #{id}
    </select>
    </mapper>

    目录结构:

    测试:

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

    结果:

    Spring MVC:

    <bean id="sqlSessionFactory"
    class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
    <property name="mapperLocations" value="classpath*:mybatis/*.xml"/>
    </bean>

    typeAliasesPackage

    MyBaits 别名包扫描路径,通过该属性可以给包中的类注册别名,注册后在 Mapper 对应的 XML 文件中可以直接使用类名,而不用使用全限定的类名(即 XML 中调用的时候不用包含包名)。

    Spring Boot:

    #实体对象扫描包
    mybatis-plus.type-aliases-package: com.mp.boot.pojo

    Spring MVC:

    <!--这里使用Mybatis-plus提供的sqlSessionFactory,完成了Spring与MP的整合-->
    <bean id="sqlSessionFactory"
    class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <!--
    mybatis-config.xml 可以设置分页插件   然后这边也可以进行分页查询了
    -->
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
    <!--实体类包扫描-->
    <property name="typeAliasesPackage"
    value="com.baomidou.mybatisplus.samples.quickstart.entity"/>
    </bean>
    <!--扫描mapper接口,使用的依然是Mybatis原生的扫描器-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.mp.spring.mapper"/>
    </bean>

    配置了这个 Mapper就可以这样填

    二、进阶配置

    本部分(Configuration)的配置大都为 MyBatis 原生支持的配置,这意味着您可以通过 MyBatis XML 配置文件的形式进行配置。

    mapUnderscoreToCamelCase

    是否开启自动驼峰命名规则(camel case)映射,即从经典数据库列名 A_COLUMN(下划线命名) 到经典 Java 属性名 aColumn(驼峰命名) 的类似映射。

    SpringBoot:

    #默认是开启的
    #关闭自动驼峰映射,该参数不能和mybatis-plus.config-location同时存在
    mybatis-plus.configuration.map-underscore-to-camel-case: false

    因为你指定了配置文件 文件里自己可以写这写插件 所以这里就让这两个配置不能同时存在

    cacheEnabled

    全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存,默认为 true

    #开启二级缓存
    mybatis-plus.configuration.cache-enabled: false

    三、DB 策略配置

    idType

    全局默认主键类型,设置后,即可省略实体对象中的@TableId(type = IdType.AUTO)配置。

    #全局默认主键类型,设置后,即可省略实体对象中的@TableId(type = IdType.AUTO)配置。
    mybatis-plus.global-config.db-config.id-type: auto

    SpringMVC:

    <bean id="sqlSessionFactory"
    class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <!--
    mybatis-config.xml 可以设置分页插件   然后这边也可以进行分页查询了
    -->
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
    <!--实体类包扫描-->
    <property name="typeAliasesPackage"
    value="com.baomidou.mybatisplus.samples.quickstart.entity"/>
    <property name="globalConfig">
    <bean class="com.baomidou.mybatisplus.core.config.GlobalConfig">
    <property name="dbConfig">
    <bean
    class="com.baomidou.mybatisplus.core.config.GlobalConfig$DbConfig">
    <property name="idType" value="AUTO"/>
    </bean>
    </property>
    </bean>
    </property>
    </bean>

    tablePrefix

    表名前缀,全局配置后可省略@TableName()配置。

    SpringBoot:

    #表名前缀,全局配置后可省略@TableName()配置。
    #类名首字母小写  加上这前缀 就等于tb_user
    mybatis-plus.global-config.db-config.table-prefix: tb_

    五、条件构造器

    在MP中,Wrapper接口的实现类关系如下:
    可以看到,AbstractWrapper和AbstractChainWrapper是重点实现,接下来我们重点学习AbstractWrapper以及其子类。

    一、allEq

    说明
    allEq(Map<R, V> params)
    allEq(Map<R, V> params, boolean null2IsNull)
    allEq(boolean condition, Map<R, V> params, boolean null2IsNull)

    个别参数说明: params : key 为数据库字段名, value 为字段值 null2IsNull : 为 true 则在 map 的 value 为null 时调用 isNull 方法,为 false 时则忽略 value 为 null 的:

    • 例1: allEq({id:1,name:“老王”,age:null}) —> id = 1 and name = ‘老王’ and
      age is null
    • 例2: allEq({id:1,name:“老王”,age:null}, false) —> id = 1 and name = ‘老王’

    allEq(BiPredicate<R, V> filter, Map<R, V> params)
    allEq(BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)
    allEq(boolean condition, BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)

    个别参数说明: filter : 过滤函数,是否允许字段传入比对条件中 params 与 null2IsNull : 同上

    • 例1: allEq((k,v) -> k.indexOf(“a”) > 0, {id:1,name:“老王”,age:null}) —> name = ‘老王’ and age is null
    • 例2: allEq((k,v) -> k.indexOf(“a”) > 0, {id:1,name:“老王”,age:null}, false) —> name =‘老王’

    测试用例:

    @Test
    public void testWrapper() {
    //条件构造器
    QueryWrapper<User> wrapper=new QueryWrapper<>();
    
    //设置条件
    Map<String,Object> params = new HashMap<>();
    params.put("name", "狗剩");
    params.put("age", "21");
    params.put("password", null);
    
    //      wrapper.allEq(params);
    //        wrapper.allEq(params,false);
    
    wrapper.allEq((k, v) -> (k.equals("names") || k.equals("age")),params);
    
    List<User> users = userMapper.selectList(wrapper);
    for (User user : users) {
    System.out.println(user);
    }
    }

    二、基本比较操作

    查询方式 说明
    eq 等于 =
    ne 不等于 <>
    gt 大于 >
    ge 大于等于 >=
    lt 小于 <
    le 小于等于 <=
    between BETWEEN 值1 AND 值2
    notBetween NOT BETWEEN 值1 AND 值2
    in 字段 IN (value.get(0), value.get(1), …)
    notIn 字段 NOT IN (v0, v1, …)
    like LIKE ‘%值%’
    likeLeft LIKE ‘%值’
    likeRight LIKE ‘值%’
    orderBy ORDER BY 字段, …
    orderByAsc ORDER BY 字段, … ASC
    orderByDesc ORDER BY 字段, … DESC
    or 拼接 OR
    and AND 嵌套

    测试用例:

    @Test
    public void testEqWrapper() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //SELECT id,user_name,password,name,age,email FROM tb_user WHERE password = ? AND age >= ? AND name IN (?,?,?)
    wrapper.eq("password","123456").gt("age",21).in("name",Arrays.asList("张三","李四","王五"));
    List<User> users = this.userMapper.selectList(wrapper);
    for (User user : users) {
    System.out.println(user);
    }
    }

    三、模糊查询

    测试用例:

    @Test
    public void testLikeWrapper() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //SELECT id,user_name,password,name,age,email FROM tb_user WHERE name LIKE ?
    //parameters '%曹%'
    //        wrapper.like("name", "曹");
    //parameters '%王'
    wrapper.likeLeft("name","王");
    List<User> users = this.userMapper.selectList(wrapper);
    for (User user : users) {
    System.out.println(user);
    }
    }

    四、排序

    @Test
    public void testOrderByWrapper() {
    //条件构造器
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //SELECT id,user_name,password,name,age,email FROM tb_user ORDER BY age DESC
    wrapper.orderByDesc("age");
    List<User> users = this.userMapper.selectList(wrapper);
    for (User user : users) {
    System.out.println(user);
    }
    }

    五、逻辑查询

    测试用例:

    @Test
    public void testOrWrapper() {
    //条件构造器
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //SELECT id,user_name AS userName,name,age,email AS mail FROM tb_user WHERE name = ? OR name = ?
    wrapper.eq("name","李四").or().eq("name","张三");
    List<User> users = this.userMapper.selectList(wrapper);
    for (User user : users) {
    System.out.println(user);
    }
    }

    六、select

    在MP查询中,默认查询所有的字段,如果有需要也可以通过select方法进行指定字段。

    @Test
    public void testSelectWrapper() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //SELECT id,name,age FROM tb_user WHERE name = ? OR age = ?
    wrapper.eq("name", "李四")
    .or()
    .eq("age", 24)
    .select("id", "name", "age");
    List<User> users = this.userMapper.selectList(wrapper);
    for (User user : users) {
    System.out.println(user);
    }
    }
    • 点赞 1
    • 收藏
    • 分享
    • 文章举报
    伟大的地球人 发布了2 篇原创文章 · 获赞 9 · 访问量 541 私信 关注
    内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
    标签: