mybatis plus插件学习

蒋增奎

已于 2023-12-03 11:36:03 修改

阅读量993

点赞数 19

分类专栏： mysql数据库文章标签： mybatis

于 2023-11-22 22:56:33 首次发布

本文链接：https://blog.csdn.net/weixin_41158378/article/details/134564971

版权

mysql数据库专栏收录该内容

3 篇文章

订阅专栏

mybatis plus插件学习

1. 介绍
2.创建一个mp工程
3.mybatisPlus特性

mybatis plus插件

1. 介绍

mybatis plus插件对mybatis没有侵入性，可以做到完美扩展，解决单表的增删改查的相关操作

2.创建一个mp工程

###2.1 pom.xml
核心是导入mybatis-plus的依赖包，lombok是简化代码的工具类

<?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.jsoft</groupId>
    <artifactId>mybatis</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>basic</module>
    </modules>


    <dependencies>
        <!-- mybatis-plus插件依赖 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus</artifactId>
            <version>3.3.1</version>
        </dependency>
        <!-- MySql -->
        <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>

增加log日志-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.2mybatis-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>
    <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:///mybatis?useUnicode=true&amp;characterEncoding=utf8&amp;autoReconnect=true&amp;allowMultiQueries=true&amp;useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="111111"/>


            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="UserMapper.xml"/>
    </mappers>
</configuration>

2.3 创建实体类

这里使用lombok来简写 java bean
import lombok.AllArgsConstructor; //生成全参数的构造函数
import lombok.Data; //生成get set
import lombok.NoArgsConstructor; //生成无参构造函数

mybatisplus的注解说明

import com.baomidou.mybatisplus.annotation.TableName;
@TableName(“tb_user”) //mp如果表名和类名不一样，则需要使用TableName注解
@TableId(type= IdType.AUTO) //自增长主键，保存后，自动填充到实体类中
@TableField(exist = false) //在保存时候，不把此字段插入数据库。
注意：mp已经默认使用驼峰算法

package com.jsoft.po;

/**
 * @class: com.jsoft.po.User
 * @description:
 * @author: jiangzengkui
 * @company: 教育家
 * @create: 2023-11-15 22:58
 */

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 Integer id;
    @TableField(exist = false)
    private String user_name;
    private  String userName;
}

2.4 mapper接口类

注意的是，mp接口类需要继承BaseMapper接口，T要把实体类传入

package com.jsoft.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jsoft.po.User;

import java.util.List;

/**
 * @class: com.jsoft.mapper.UserMapper
 * @description:
 * @author: jiangzengkui
 * @company: 教育家
 * @create: 2023-11-15 22:57
 */
public interface UserMapper extends BaseMapper<User>{
    public List<User> getAll();

    public List<User> getUsers(User user);
}

2.5 代码结构

在这里插入图片描述

2.6测试

package com.jsoft.test;

import com.baomidou.mybatisplus.core.MybatisSqlSessionFactoryBuilder;
import com.jsoft.mapper.UserMapper;
import com.jsoft.po.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.Arrays;
import java.util.List;

/**
 * @class: com.jsoft.test.BasicTest
 * @description:
 * @author: jiangzengkui
 * @company: 教育家
 * @create: 2023-11-15 23:12
 */
public class BasicTest {
    /**
     * mybatis自身类构建
     * @throws Exception
     */
    @Test
    public void testBasic() throws Exception{


      
        SqlSession sqlSession = getMybatisSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        //测试查询
        List<User> users = userMapper.getAll();
        for (User user : users) {
            System.out.println(user);
        }

        closeSqlSession(sqlSession);
    }

    /**
     * mybatisplus 构建类构建
     * @throws Exception
     */
    @Test
    public void testPlus() throws Exception{

        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        //测试用mybatisPlus自带类
        List<User> users = userMapper.selectList(null);
        for (User user : users) {
            System.out.println(user);
        }

        //用mybatisPlus的mappy的定义方法

        List<User> users1 =userMapper.getAll();
        for (User user : users1) {
            System.out.println(user);
        }


        closeSqlSession(sqlSession);
    }

    @Test
    public void testSave()throws Exception{
        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user=new User(1,"gg","hhh");
        userMapper.insert(user);
        closeSqlSession(sqlSession);
    }

    @Test
    public void testDel()throws Exception{
        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
          userMapper.deleteBatchIds(Arrays.asList(1,2,4));
        closeSqlSession(sqlSession);
    }

    @Test
    public void testlist()throws Exception{
        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user=new User();user.setId(1);user.setUser_name("d");
        userMapper.getUsers(user);
        closeSqlSession(sqlSession);
    }


    /**
     * 普通mybatis构建
     * @return
     * @throws Exception
     */

    public static SqlSession getMybatisSession()throws Exception{
        String config = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(config);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        return  sqlSession;

    }

    /**
     * mybatisplus 构建
     * @return
     * @throws Exception
     */
    public static SqlSession getPlusSession()throws Exception{
        String config = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(config);
        SqlSessionFactory sqlSessionFactory = new MybatisSqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        return  sqlSession;

    }

    public static void closeSqlSession(SqlSession sqlSession){
        sqlSession.close();
    }
}

###2.7总结
1.mp对mybats无侵略性，只需要接口继承"BaseMapper"
2.用mp提供的构建类构建就可以使用mp提供的对单表的增删改查了，不需要在mpper.xml里面配置，简化了配置和代码
3.mp如果实体类和标明不一样，则需要注解，普通mybatis不需要
4.即使使用了mp，依然可以使用mybatis其他功能，无侵略性
5.mp默认实现了驼峰

3.mybatisPlus特性

3.1 新增-insert

插入一条数据直接用BaseMapper.insert(po)就OK
重点在实体类的注解上

package com.jsoft.po;
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 Integer id;
    @TableField(exist = false)
    private String user_name;
    private  String userName;
    private Long deptId;
    @TableField(exist = false)
    private String deptName;
}

3.1.1.标明注解 @TableName(“表名”)

import com.baomidou.mybatisplus.annotation.TableName;
如果实体类名和数据库名称不一致，则使用此注解

3.1.2.主键注解 @TableId

import com.baomidou.mybatisplus.annotation.IdType;
主键需要用@TableId注解
其全写是@TableId(value=“xxx”,type = IdType.xxx)

eg:

@TableId(value = “id”, type = IdType.ID_WORKER)
private Long uid;

在这里插入图片描述

如果属性名和字段名一样，value可以省略掉
重点讲解type
在这里插入图片描述
注意几种情况
（1.）如果全部使用默认值@TableId

  @TableId
    private Long id;

就是使用IdType.NONE,就是跟随全局，全局里是什么值呢？
在DbConfig类我们查询到：

public DbConfig() {
            this.idType = IdType.ASSIGN_ID;
            this.tableUnderline = true;
            ...
            }

其使用了IdType.ASSIGN_ID，如果我们没有对主键进行赋值，则使用了雪花算法生成主键，如果赋值了，则直接插入数据库
所以全部使用默认值，则相当于系统去选择使用IdType.ASSIGN_ID还是IdType.INPUT,推荐使用。

（2）.如果主键是自增长，则必须使用IdType.AUTO

@TableId(type=IdType.AUTO)
    private Long id;

（3）如果使用无意义的字符串作为主键，则需要使用IdType.ASSIGN_UUID

@TableId(type=IdType.ASSIGN_UUID)
    private String  id;

3.1.3.字段注解@TableField

这个注解有两个参数比较重要
（·1）实体属性名和数据库字段名不一致，值是数据库的字段名

  @TableField("nickname")
    private String name;

（2）在insert、update 忽略此属性，不生成对应的字段，这个常用于我多表查询时，懒得新增vo类，直接在主实体类扩展

   @TableField(exist = false)
    private String deptName;

(3)自动注入fill
我们常常创建表时增加创建人、创建时间、修改人、修改时间，可以利用此属性自动注入
3.1抽象父类

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.Data;

import java.util.Date;

@Data
public class BaseEntity{

    /**
     * 创建时间
     */
    @TableField(value = "create_time", fill = FieldFill.INSERT)
    private Date createTime;

    /**
     * 更新时间
     */
    @TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;

    /**
     * 创建人
     */
    @TableField(value = "create_by", fill = FieldFill.INSERT)
    private Long createBy;
    /**
     * 更新人
     */
    @TableField(value = "update_by", fill = FieldFill.INSERT_UPDATE)
    private Long updateBy;
}

3.2.实体类继承父类

@Data
@TableName("user")
public class User extends BaseEntity implements Serializable {
.....
}

3.3 自定义实现MetaObjectHandler，实现公共字段自动写入

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.Objects;

@Component
public class DefaultDBFieldHandler implements MetaObjectHandler {

    @Override
    public void insertFill(MetaObject metaObject) {
        if (Objects.nonNull(metaObject)) {
            this.setFieldValByName("createTime", new Date(), metaObject);
            this.setFieldValByName("updateTime", new Date(), metaObject);

            //获取当前用户id
            if (Objects.nonNull(1L)){
                this.setFieldValByName("createBy", 1L, metaObject);
                this.setFieldValByName("updateBy", 1L, metaObject);
            }
        }
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        // 更新时间为空，则以当前时间为更新时间
        // Object modifier = getFieldValByName("updater", metaObject);

        if (Objects.nonNull(metaObject)) {
            this.setFieldValByName("updateTime",new Date(),metaObject);
            //获取当前用户id
            if (Objects.nonNull(2L)){
                this.setFieldValByName("updateBy", 2L, metaObject);
            }
        }
    }
}

3.2 修改-update

在 MP 中，更新操作有 2 种，⼀种是根据 id 更新，另⼀种是根据条件更新。

3.2.1根据主键值更新updateById(实体类)

实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_user")
public class User {
    @TableId(type= IdType.AUTO)
    private Integer id;
    @TableField(exist = false)
    private String user_name;
    private  String userName;
    private Long deptId;
    @TableField(exist = false)
    private String deptName;
    private String address;
    private BigDecimal weight;

}

测试

 @Test
    public void testPlus3() throws Exception{


        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //用mybatisPlus的mappy的定义方法

        User user =new User();
        user.setUser_name("大哥");
        user.setUserName("大哥dd");
        user.setId(3);
       // user.setDeptId(3l);
        user.setDeptName("教育部");
        user.setAddress("天府大道");
        user.setWeight(new BigDecimal(5));
        userMapper.updateById(user);
        System.out.println(user);



        closeSqlSession(sqlSession);
    }

注意事项：

1.属性里有@TableField(exist = false)，不会更新
2.没有赋值的，值为null的不会更新

3.2.2.根据条件更新update

BaseMapper基类有一个方法
int update(@Param(“et”) T entity, @Param(“ew”) Wrapper updateWrapper);

这里Warpper接口就是要修改的条件，可以传递QueryWrapper、UpdateWrapper两个实现类
(1)QueryWrapper

/**
 * 根据 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 testPlus4() throws Exception{


        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //用mybatisPlus的mappy的定义方法

        User user =new User();
        user.setUserName("我是睡");
        user.setWeight(new BigDecimal(55));

        //更新的条件
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("dept_id", 3); //注意这里是数据库字段名，不是属性名驼峰


        userMapper.update(user,wrapper);
        System.out.println(user);



        closeSqlSession(sqlSession);
    }

(2)UpdateWrapper
测试类

 @Test
    public void testPlus5() throws Exception{


        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //用mybatisPlus的mappy的定义方法

        User user =new User();
        user.setUserName("我");
        user.setWeight(new BigDecimal(33));

        //更新的条件
        UpdateWrapper<User> wrapper = new UpdateWrapper<User>();
        wrapper.eq("dept_id", 3); //注意这里是数据库字段名，不是属性名驼峰
        //wrapper不仅可以设置条件，还可以设置修改的值，优先级高于实体类
        wrapper.set("user_name","蒋");

        //两个修改都可以修改
        //生成SQL:UPDATE tb_user SET user_name=?, weight=?, user_name=? WHERE (dept_id = ?) ,有两个user_name
        userMapper.update(user,wrapper);
        //UpdateWrapper里面的set值起修改作用
        //生成SQL:UPDATE tb_user SET user_name=? WHERE (dept_id = ?)
        userMapper.update(null,wrapper);
        System.out.println(user);



        closeSqlSession(sqlSession);
    }

1.update(Entity,QueryWrapper) 第一个参数是set 修改值，null则不会变更
2.QueryWrapper生成where条件
3.QueryWrapper和UpdateWrapper的区别是UpdateWrapper可以使用set直接给字段赋修改值

3.2.3mybatis的update注解

注解使用mybatis的update注解
接口

  @Update("update tb_user set user_name=#{userName} where dept_id=#{deptId}")
    public void updateByDeptId(@Param("userName") String userName,@Param("deptId") Long deptId );

测试类

 @Test
    public void testPlus6() throws Exception{


        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //用mybatisPlus的mappy的定义方法

        userMapper.updateByDeptId("鸡哥",3l);

        closeSqlSession(sqlSession);
    }

3.2.4更新null值

想把一个字段设置为null值，但是发现更新后数据没有为null还是原来的值，这是因为mybatis-plus在更新的时候做了null判断，默认不更新为null的传参。
应用场景

修改form表单，有些值可以为非必填

我们可以使用UpdateWrapper.set(“字段名”,null),来清空null值

 @Test
    public void testPlus6() throws Exception{


        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //用mybatisPlus的mappy的定义方法

        UpdateWrapper<User> wrapper = new UpdateWrapper<User>();
        wrapper.eq("dept_id", 3); //注意这里是数据库字段名，不是属性名驼峰
        //wrapper不仅可以设置条件，还可以设置修改的值，优先级高于实体类
        wrapper.set("user_name",null);

        userMapper.update(null,wrapper);
       

        closeSqlSession(sqlSession);
    }

查看执行sql

  Preparing: UPDATE tb_user SET user_name=? WHERE (dept_id = ?) 
 Parameters: null, 3(Integer)

3.3删除操作

3.3.1.通过主键删除-deleteById

 @Test
    public void testPlus8() throws Exception{


        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //用mybatisPlus的mappy的定义方法
        userMapper.deleteById(7);
        closeSqlSession(sqlSession);
    }

-[DEBUG] Opening JDBC Connection
PooledDataSource]-[DEBUG] Created connection 293907205.
-[DEBUG] ==>  Preparing: DELETE FROM tb_user WHERE id=? 
-[DEBUG] ==> Parameters: 7(Integer)
 [com.jsoft.mapper.UserMapper.deleteById]-[DEBUG] <==    Updates: 1

3.3.2.通过map组合and删除条件-deleteByMap

用map把查询条件压入，获得and = 的删除条件

  @Test
    public void testPlus9() throws Exception{
        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        HashMap<String, Object> map=new HashMap<String,Object>();
        map.put("user_name","jzk");
        map.put("dept_id",3);
        userMapper.deleteByMap(map);
        closeSqlSession(sqlSession);
    }

[main] [com.jsoft.mapper.UserMapper.deleteByMap]-[DEBUG] ==>  Preparing: DELETE FROM tb_user WHERE user_name = ? AND dept_id = ? 
[main] [com.jsoft.mapper.UserMapper.deleteByMap]-[DEBUG] ==> Parameters: jzk(String), 3(Integer)
[main] [com.jsoft.mapper.UserMapper.deleteByMap]-[DEBUG] <==    Updates: 1

3.3.3.批量删除通过主键-deleteBatchIds

@Test
    public void testPlus10() throws Exception{
        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        userMapper.deleteBatchIds(Arrays.asList(5,6));
        closeSqlSession(sqlSession);
    }

[main] [org.apache.ibatis.datasource.pooled.PooledDataSource]-[DEBUG] Created connection 644345897.
[main] [com.jsoft.mapper.UserMapper.deleteBatchIds]-[DEBUG] ==>  Preparing: DELETE FROM tb_user WHERE id IN ( ? , ? ) 
[main] [com.jsoft.mapper.UserMapper.deleteBatchIds]-[DEBUG] ==> Parameters: 5(Integer), 6(Integer)

3.4查询操作

3.4.1.通过主键查询-selectById

无值返回null

    @Test
    public void testPlus11() throws Exception{
        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user=userMapper.selectById(10);
        System.out.println(user);
        closeSqlSession(sqlSession);
    }

3.4.2.多个主键查-selectBatchIds

 @Test
    public void testPlus12() throws Exception{
        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> users=userMapper.selectBatchIds(Arrays.asList(8,9));
        for (User user:users){
            System.out.println(user);
        }

        closeSqlSession(sqlSession);
    }

3.4.3.一条记录selectOne

查询结果只能是一条记录或者没有记录，否则报错，没有记录返回对象为null

 @Test
    public void testPlus13() throws Exception{
        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        QueryWrapper<User> wapper=new QueryWrapper<User>();
        wapper.eq("user_name","sss");
        User user=userMapper.selectOne(wapper);
        System.out.println(user);
        closeSqlSession(sqlSession);
    }

[main] [org.apache.ibatis.datasource.pooled.PooledDataSource]-[DEBUG] Created connection 550402284.
[main] [com.jsoft.mapper.UserMapper.selectOne]-[DEBUG] ==>  Preparing: SELECT id,user_name,dept_id,address,weight FROM tb_user WHERE (user_name = ?) 
[main] [com.jsoft.mapper.UserMapper.selectOne]-[DEBUG] ==> Parameters: sss(String)
[main] [com.jsoft.mapper.UserMapper.selectOne]-[DEBUG] <==      Total: 1
User(id=8, user_name=null, userName=sss, deptId=2, deptName=null, address=2222, weight=3.00)

3.4.4.查询记录数-selectCount

   @Test
    public void testPlus14() throws Exception{
        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        QueryWrapper<User> wapper=new QueryWrapper<User>();
        wapper.eq("user_name","sss");
        int num=userMapper.selectCount(wapper);
        System.out.println(num);
        closeSqlSession(sqlSession);
    }

[main] [com.jsoft.mapper.UserMapper.selectCount]-[DEBUG] ==>  Preparing: SELECT COUNT( 1 ) FROM tb_user WHERE (user_name = ?) 
[main] [com.jsoft.mapper.UserMapper.selectCount]-[DEBUG] ==> Parameters: sss(String)
[main] [com.jsoft.mapper.UserMapper.selectCount]-[DEBUG] <==      Total: 1

3.4.5.多条记录-selectList

  @Test
    public void testPlus15() throws Exception{
        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        QueryWrapper<User> wapper=new QueryWrapper<User>();
        wapper.gt("dept_id",3);
        List<User> users=userMapper.selectList(wapper);
        for(User user:users){
            System.out.println(user);
        }

        closeSqlSession(sqlSession);
    }

[main] [com.jsoft.mapper.UserMapper.selectList]-[DEBUG] ==>  Preparing: SELECT id,user_name,dept_id,address,weight FROM tb_user WHERE (dept_id > ?) 
[main] [com.jsoft.mapper.UserMapper.selectList]-[DEBUG] ==> Parameters: 3(Integer)
[main] [com.jsoft.mapper.UserMapper.selectList]-[DEBUG] <==      Total: 2
User(id=10, user_name=null, userName=bb, deptId=4, deptName=null, address=44, weight=4.00)
User(id=11, user_name=null, userName=sss, deptId=4, deptName=null, address=44, weight=4.00)

3.5 条件构造器-Wrapper

Wrapper接口的实现类关系如下：
在这里插入图片描述
可以看到，AbstractWrapper和AbstractChainWrapper是重点实现，接下来我们重点学习AbstractWrapper以及其子类。

QueryWrapper(LambdaQueryWrapper) 和 UpdateWrapper(LambdaUpdateWrapper) 的父类用于生成 sql
的 where 条件, entity 属性也用于生成 sql 的 where 条件注意: entity 生成的 where 条件与使用各个 api 生成
的 where 条件没有任何关联行为

语法	说明
eq	等于 =
ne	不等于 <>
gt	大于 >
ge	大于等于 >=
lt	小于 <
le	小于等于
between	between and between(字段名,开始值,结束值)
notBetween	not between and
in	字段 IN (value.get(0), value.get(1), …) in (字段名,值1，值2…)
notIn	字段 not IN (value.get(0), value.get(1), …)
like	like like(字段名,值)=like ‘%val%’ likeLeft(字段名,值)=like ‘%val’ likeRight(字段名,值)=like ‘val%’
notLike	not like
orderBy	orderBy(true,false,“id”,“dept_id”); //第一个boolean,是否执行order,第二个:true表示Asc, ORDER BY id DESC,dept_id DESC orderByAsc(“id”,“dept_id”); //ORDER BY id ASC,dept_id ASC orderByDesc(“id”,“dept_id”); // ORDER BY id DESC,dept_id DESC orderByAsc(“id”).orderByDesc(“dept_id”);// ORDER BY id ASC,dept_id DESC
or	or()映射成or 连接，默认是and
select	select 哪些字段 select(“id”,“user_name”) =select id,user_name from

3.5.1.wrapper条件

wrapper.eq gt等等都有一个条件condition
condition的意思是，如果condition为false，将不把这个字段作为查询条件，默认为true

public Children eq(boolean condition, R column, Object val) {
        return this.addCondition(condition, column, SqlKeyword.EQ, val);
    }

eg:

@Test
    public void testPlus16() throws Exception{
        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        QueryWrapper<User> wapper=new QueryWrapper<User>();
        wapper.eq(false,"user_name","sss");

        List<User> users=userMapper.selectList(wapper);
        for(User user:users){
            System.out.println(user);
        }
        closeSqlSession(sqlSession);
    }

查看执行SQL,并没有把user_name作为查询条件

[main] [com.jsoft.mapper.UserMapper.selectList]-[DEBUG] ==>  Preparing: SELECT id,user_name,dept_id,address,weight FROM tb_user 
[main] [com.jsoft.mapper.UserMapper.selectList]-[DEBUG] ==> Parameters: 
[main] [com.jsoft.mapper.UserMapper.selectList]-[DEBUG] <==      Total: 5

3.5.2.比较 eq ne gt ge lt le in betwween等

  @Test
    public void testPlus17() throws Exception{
        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        QueryWrapper<User> wapper=new QueryWrapper<User>();
        wapper
                .eq(false,"user_name","sss")  //user_name=‘sss’
                .gt("dept_id",3)  //dept_id>3
                .between("weight",4,20)  //weight between 4 and 20
                .in("id",8,9,10)  //id in(8,9,10)
                .ne("id",10)   //id <> 10
                .select("id","user_name"); // select id, user_name  from ....


        List<User> users=userMapper.selectList(wapper);
        for(User user:users){
            System.out.println(user);
        }
        closeSqlSession(sqlSession);
    }

==>  Preparing: SELECT id,user_name FROM tb_user WHERE (dept_id > ? AND weight BETWEEN ? AND ? AND id IN (?,?,?) AND id <> ?) 
 ==> Parameters: 3(Integer), 4(Integer), 20(Integer), 8(Integer), 9(Integer), 10(Integer), 10(Integer)

3.5.3.模糊 like

like like %x% ;
likeLeft like ‘%x’ ;
likeRight like ‘x%’

  @Test
    public void testPlus17() throws Exception{
        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        QueryWrapper<User> wapper=new QueryWrapper<User>();
        wapper
               .like("user_name","s")  // user_name like '%s%'
                .likeLeft("address","a") // user_name like '%s'
                .likeRight("address","f")  user_name like 's%'
                .select("id","user_name"); // select id, user_name  from ....
        
        List<User> users=userMapper.selectList(wapper);
        for(User user:users){
            System.out.println(user);
        }
        closeSqlSession(sqlSession);
    }

==>  Preparing: SELECT id,user_name FROM tb_user WHERE (user_name LIKE ? AND address LIKE ? AND address LIKE ?) 
 ==> Parameters: %s%(String), %a(String), f%(String)

3.5.4.排序

@Test
    public void testPlus19() throws Exception{
        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        QueryWrapper<User> wapper=new QueryWrapper<User>();
        //1.orderBy
        wapper.orderBy(true,false,"id","dept_id");
        //第一个boolean,是否执行order,第二个:true表示Asc
        //ORDER BY id DESC,dept_id DESC

        //2.orderByAsc
        wapper.orderByAsc("id","dept_id"); //ORDER BY id ASC,dept_id ASC

       // 3.orderByDesc
        wapper.orderByDesc("id","dept_id"); // ORDER BY id DESC,dept_id DESC

        //4.有升有降
        wapper.orderByAsc("id").orderByDesc("dept_id");// ORDER BY id ASC,dept_id DESC


        List<User> users=userMapper.selectList(wapper);
        for(User user:users){
            System.out.println(user);
        }
        closeSqlSession(sqlSession);
    }

3.5.5.逻辑or

or()映射成or

@Test
    public void testPlus20() throws Exception{
        SqlSession sqlSession = getPlusSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        QueryWrapper<User> wapper=new QueryWrapper<User>();

        wapper.gt("dept_id",3)
                .or()
                .gt("weight",4.5); //dept_id>3 or weight>4.5

        List<User> users=userMapper.selectList(wapper);
        for(User user:users){
            System.out.println(user);
        }
        closeSqlSession(sqlSession);
    }