MyBatis详解(5)--MyBatis 高级查询

最新推荐文章于 2024-07-30 22:18:12 发布
最新推荐文章于 2024-07-30 22:18:12 发布
阅读量240 收藏 1
点赞数
分类专栏： MyBatis详解 文章标签： MyBatis详解 Springboot 整合 MyBatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m_sicily/article/details/102567734
版权

MyBatis详解5--MyBatis 高级查询

需求缘起

之前几节的示例，都是单表操作，但实际项目中，还有很多时候会用到多表查询，主要体现在一对一，一对多和多对多查询。这一节就来介绍下多表查询的用法。
本节将在上一节的基础上开发。

本小节代码
mybatis-demo-article(5)

1.一对一查询

1.1 创建一个订单表

# 创建表
CREATE TABLE orders
(
    id int(11) PRIMARY KEY NOT NULL AUTO_INCREMENT,
    user_id bigint(20) NOT NULL,
    number int(11) DEFAULT '1' NOT NULL
)ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT '用户表';

# 向表中添加数据：
insert into `orders`(user_id,number) values
  (2,'2'),
  (4,'4'),
  (2,'3');

1.2 创建订单实体类

@Data
public class Orders {
    //订单ID
    private int id;
    //用户ID
    private int userId;
    //订单数量
    private String number;
    //和用户表构成一对一的关系，即一个订单只能由一个用户创建
    private UserInfo user;
}

1.3 编写接口 OrdersMapper.java

package com.mybatis.demo.mapper;

import com.mybatis.demo.model.Orders;
import com.mybatis.demo.model.UserInfo;

/**
 * @auther kklu
 * @date 2019/10/15 15:44
 * @describe
 */

public interface OrdersMapper {

    /**
     * 方式一：嵌套结果
     * select * from orders o,user u where o.user_id=u.id and o.id=#{id}
     *
     * @param orderId
     * @return
     */
    //根据订单ID查询订单和用户信息
    Orders selectOrdersAndUserInfoByOrderID(int orderId);

    /**
     * 方式二：嵌套查询
     * select * from order WHERE id=1;//得到user_id
     * select * from user WHERE id=1   //1 是上一个查询得到的user_id的值
     *
     * @param orderId
     * @return
     */
    //根据订单ID得到订单信息(包含user_id)
    Orders getOrdersByOrderId(int orderId);

    //根据用户ID查询用户信息
    UserInfo getUserByUserId(int userID);
}

1.3 编写 OrdersMapper.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.mybatis.demo.mapper.OrdersMapper">
    <!--
    嵌套结果：使用嵌套结果映射来处理重复的联合结果的子集
                               封装联表查询的数据(去除重复的数据)
     select * from order o,user_inf u where o.user_id=u.id and o.id=#{id}
     -->
    <select id="selectOrderAndUserInfoByOrderID" resultMap="getOrderAndUserInfo">
        select * from order o,user_info u where o.user_id=u.id and o.id=#{id}
    </select>

    <resultMap type="com.mybatis.demo.model.Order" id="getOrderAndUserInfo">
        <!--
            id:指定查询列表唯一标识，如果有多个唯一标识，则配置多个id
            column:数据库对应的列
            property:实体类对应的属性名
          -->
        <id column="id" property="id"/>
        <result column="user_id" property="userId"/>
        <result column="number" property="number"/>
        <!--association:用于映射关联查询单个对象的信息
            property:实体类对应的属性名
            javaType:实体类对应的全类名
          -->
        <association property="userInfo" javaType="com.mybatis.demo.model.UserInfo">
            <!--
                id:指定查询列表唯一标识，如果有多个唯一标识，则配置多个id
                column:数据库对应的列
                property:实体类对应的属性名
              -->
            <id column="id" property="id"/>
            <result column="username" property="username"/>
            <result column="password" property="password"/>
            <result column="high" property="high"/>
            <result column="age" property="age"/>
            <result column="sex" property="sex"/>
        </association>
    </resultMap>


    <!--
         方式二：嵌套查询：通过执行另外一个SQL映射语句来返回预期的复杂类型
         select user_id from order WHERE id=1;//得到user_id
         select * from user WHERE id=1   //1 是上一个查询得到的user_id的值
         property:别名(属性名)    column：列名 -->
    <select id="getOrderByOrderId" resultMap="getOrderMap">
        select * from order where id=#{id}
    </select>
    <resultMap type="com.mybatis.demo.model.Order" id="getOrderMap">
        <id column="id" property="id"/>
        <result column="number" property="number"/>
        
        <!--property="userInfo" : orders 中要查询的属性-->
        <!--column="user_id" : user_id 要查询的条件属性-->
        <association property="userInfo"  column="user_id" select="getUserInfoByUserId">

        </association>
    </resultMap>

    <select id="getUserInfoByUserId" resultType="com.mybatis.demo.model.UserInfo">
        select * from user where id=#{id}
    </select>

</mapper>

1.4 在配置文件 mybatis-configuration.xml 中注册 OrderMapper.xml 文件

    <mappers>
        <!--注册多个接口的方式，该包名下所有的接口-->
        <package name="com.mybatis.demo.mapper"/>
    </mappers>

1.5 测试

package com.mybatis.demo.mapper;

import com.mybatis.demo.model.Orders;
import com.mybatis.demo.model.UserInfo;
import lombok.extern.slf4j.Slf4j;
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.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.IOException;
import java.io.Reader;

/**
 * @auther kklu
 * @date 2019/10/15 16:18
 * @describe
 */

@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class OrdersMapperTest {
    private static SqlSessionFactory sqlSessionFactory;
    private static SqlSession sqlSession = null;
    private static OrderMapper orderMapper;

    @BeforeClass
    public static void init() {
        try {
            //将工具类读入 reader
            Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
            //创建 SqlSessionFactory 对象，该对象包含了mybatis-config.xml相关配置信息
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
            sqlSession = sqlSessionFactory.openSession();
            orderMapper = sqlSession.getMapper(OrderMapper.class);
            reader.close();
        } catch (IOException ignore) {
            ignore.printStackTrace();
        }
    }


    @Test
    public void selectOrderAndUserInfoByOrderID() {
        try {
            Orders result = orderMapper.selectOrdersAndUserInfoByOrderID(1);
            log.info("result={}", result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //不要忘记关闭 sqlSession
            sqlSession.close();
        }
    }

    @Test
    public void getOrdersByOrderId() {
        try {
            Orders result = orderMapper.getOrdersByOrderId(1);
            log.info("result={}", result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //不要忘记关闭 sqlSession
            sqlSession.close();
        }
    }

    @Test
    public void getUserInfoByUserId() {
        try {
            UserInfo result = orderMapper.getUserInfoByUserId(2);
            log.info("result={}", result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //不要忘记关闭 sqlSession
            sqlSession.close();
        }
    }
}

2.一对多查询

2.1 添加 orders 属性

以用户表 user_info 和 订单表 orders 为例，一个用户能创建多个订单。故用户和订单构成一对多的关联。
我们在 userInfo.java 中添加一个属性 public List orders;

@Data
public class UserInfo {
    private Long id;
    private String username;
    private String password;
    private Integer high;
    private Integer age;
    private Integer sex;
    //一个用户能创建多个订单，用户和订单构成一对多的关系
    private List<Orders> orders;
}

2.2 创建 UserInfoMapper.java 接口

将上一节的接口 UserInfoMapper.java 中的方法全部删除，然后添加新方法如下：

public interface UserInfoMapper {

    //根据用户id查询用户信息，以及用户下面的所有订单信息
    UserInfo selectUserInfoAndOrdersByUserId(int UserId);

}

2.3 修改 UserInfoMapper.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.mybatis.demo.mapper.UserInfoMapper">

    <!--
   方式一：嵌套结果：使用嵌套结果映射来处理重复的联合结果的子集
                              封装联表查询的数据(去除重复的数据)
    select * from user u,orders o where u.id=o.user_id and u.id=#{id}
    -->
    <select id="selectUserInfoAndOrdersByUserId" resultMap="getUserInfoAndOrders">
        select u.*,o.id oid,o.number number,o.user_id userId from user_info u,orders o where u.id=o.user_id and u.id=#{id}
    </select>
    <resultMap type="com.mybatis.demo.model.UserInfo" id="getUserInfoAndOrders">
        <!--id:指定查询列表唯一标识，如果有多个唯一标识，则配置多个id
            column:数据库对应的列
            property:实体类对应的属性名 -->
        <id column="id" property="id"/>
        <result column="username" property="username"/>
        <result column="password" property="password"/>
        <result column="high" property="high"/>
        <result column="age" property="age"/>
        <result column="sex" property="sex"/>
        <!--
            property:实体类中定义的属性名
            ofType：指定映射到集合中的全类名
          -->
        <collection property="orders" ofType="com.mybatis.demo.model.Orders">
            <id column="oid" property="id"/>
            <result column="number" property="number"/>
            <result column="userId" property="userId"/>
        </collection>
    </resultMap>

    <!--
     方式二：嵌套查询：通过执行另外一个SQL映射语句来返回预期的复杂类型
    -->
    <select id="getUserInfoAndOrdersByUserInfoId" parameterType="int" resultMap="getOrderMap">
        select * from user_info where id=#{id}
    </select>

    <resultMap type="com.mybatis.demo.model.UserInfo" id="getOrderMap">
        <id column="id" property="id"/>
        <id column="username" property="username"/>
        <result column="age" property="age"/>
        <result column="sex" property="sex"/>

        <!--property="orders" : userInfo 被查询表中要查询的属性-->
        <!--column="id" : id 被查询表中的条件属性-->
        <collection property="orders"  column="id" select="getOrdersByOrderId">

        </collection>
    </resultMap>

    <select id="getOrdersByOrderId" parameterType="int" resultType="com.mybatis.demo.model.Orders">
        select * from orders where user_id=#{id}
    </select>
</mapper>

2.4 测试

package com.mybatis.demo.mapper;

import com.mybatis.demo.model.UserInfo;
import com.mybatis.demo.form.UserInfoForm;
import lombok.extern.slf4j.Slf4j;
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.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;
import java.util.List;

/**
 * @auther kklu
 * @date 2019/9/29 15:49
 * @describe
 */

@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class UserInfoMapperTest {
    private static SqlSessionFactory sqlSessionFactory;
    private static SqlSession sqlSession = null;
    private static UserInfoMapper userInfoMapper;

    @BeforeClass
    public static void init() {
        try {
            //将工具类读入 reader
            Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
            //创建 SqlSessionFactory 对象，该对象包含了mybatis-config.xml相关配置信息
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
            sqlSession = sqlSessionFactory.openSession();
            userInfoMapper = sqlSession.getMapper(UserInfoMapper.class);
            reader.close();
        } catch (IOException ignore) {
            ignore.printStackTrace();
        }
    }


    @Test
    public void testSelectUserInfoByUsernameAndSex() {
        try {
            UserInfo result = userInfoMapper.selectUserInfoAndOrdersByUserId(2);
            log.info("result={}", result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //不要忘记关闭 sqlSession
            sqlSession.close();
        }
    }

}

3.多对多查询

为了更好的演示示例，我们增加一个 角色表 sys_role，一个用户可以有多个角色（比如管理员，会员等），同时一个角色也可以属于多个用户（比如一个admin角色可有属于多个用户），这就是多对多的关系。
需求：

  • 给定角色id，查询这个角色所属的所有用户信息
  • 给定用户id，查询这个用户所拥有的角色信息

3.1 创建角色表 sys_role 和用户角色关系表

用户表接着使用上面的表。

# 创建角色表
CREATE TABLE sys_role
(
    id int PRIMARY KEY AUTO_INCREMENT,
    name varchar(64) NOT NULL
)ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT '角色表';

# 创建用户角色关系表
CREATE TABLE user_role
(
    id int PRIMARY KEY AUTO_INCREMENT,
    user_id int NOT NULL,
    role_id int NOT NULL
)ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT '用户角色关系表';
# 添加角色信息
insert into sys_role(name) values
  ('admin1'),
  ('admin2'),
  ('member1'),
  ('member2'),
  ('member3');
# 添加用户和角色关系信息
insert into user_role(user_id,role_id) values
  (2,'1'),
  (2,'3'),
  (4,'3'),
  (4,'4');

3.2 创建实体类

  • 创建角色实体
@Data
public class SysRole {
    private Long id;
    private String name;
    //一个角色可以包含多个用户，即一个角色可以属于多个用户
    private List<UserInfo> userInfoList;
}
  • 创建用户实体
    在上一节的 UserInfo.java 中添加角色信息
@Data
public class UserInfo {
    private Long id;
    private String username;
    private String password;
    private Integer high;
    private Integer age;
    private Integer sex;
    //一个用户能创建多个订单，用户和订单构成一对多的关系
    private List<Orders> orders;
    //一个用户可以有多个角色，即一个用户可以是会员同时也是管理员
    private List<SysRole> sysRoleList;
}

3.3 添加接口


public interface UserInfoMapper {

    //多对多查询--给定角色id，查询这个角色所属的所有用户信息
    List<UserInfo> selectUserInfoByRoleId(int roleId);
    //多对多查询--给定用户id，查询这个用户所拥有的角色信息
    List<SysRole> selectSysRoleByUserInfoId(int userId);

}

3.4 编写 UserInfoMapper.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.mybatis.demo.mapper.UserInfoMapper">

    <!--多对多查询:给定角色id，查询这个角色所属的所有用户信息-->
    <select id="selectUserInfoByRoleId" resultMap="getUserInfoMap">
        select u.id,u.username,u.age,u.sex from user_role ur,user_info u where ur.user_id=u.id and ur.role_id=#{id}
    </select>

    <resultMap type="com.mybatis.demo.model.UserInfo" id="getUserInfoMap">
        <id column="id" property="id"/>
        <result column="username" property="username"/>
        <result column="age" property="age"/>
        <result column="sex" property="sex"/>
    </resultMap>

    <!--多对多查询:给定用户id，查询这个用户所拥有的角色信息-->
    <select id="selectSysRoleByUserInfoId" resultMap="getSysRoleMap">
        select r.id,r.name from user_role ur,sys_role r where ur.role_id=r.id and ur.user_id=#{id}
    </select>

    <resultMap type="com.mybatis.demo.model.SysRole" id="getSysRoleMap">
        <id column="id" property="id"/>
        <result column="name" property="name"/>
    </resultMap>
    
</mapper>

3.5 测试

package com.mybatis.demo.mapper;

import com.mybatis.demo.model.SysRole;
import com.mybatis.demo.model.UserInfo;
import com.mybatis.demo.form.UserInfoForm;
import lombok.extern.slf4j.Slf4j;
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.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;
import java.util.List;

/**
 * @auther kklu
 * @date 2019/9/29 15:49
 * @describe
 */

@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class UserInfoMapperTest {
    private static SqlSessionFactory sqlSessionFactory;
    private static SqlSession sqlSession = null;
    private static UserInfoMapper userInfoMapper;

    @BeforeClass
    public static void init() {
        try {
            //将工具类读入 reader
            Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
            //创建 SqlSessionFactory 对象，该对象包含了mybatis-config.xml相关配置信息
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
            sqlSession = sqlSessionFactory.openSession();
            userInfoMapper = sqlSession.getMapper(UserInfoMapper.class);
            reader.close();
        } catch (IOException ignore) {
            ignore.printStackTrace();
        }
    }

    //多对多查询--给定角色id，查询这个角色所属的所有用户信息
    @Test
    public void testSelectUserInfoByRoleId() {
        try {
            List<UserInfo> result = userInfoMapper.selectUserInfoByRoleId(3);
            log.info("result={}", result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //不要忘记关闭 sqlSession
            sqlSession.close();
        }
    }

    //多对多查询--给定用户id，查询这个用户所拥有的角色信息
    @Test
    public void testSelectSysRoleByUserInfoId() {
        try {
            List<SysRole> result = userInfoMapper.selectSysRoleByUserInfoId(4);
            log.info("result={}", result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //不要忘记关闭 sqlSession
            sqlSession.close();
        }
    }
}

4. 总结

在大型系统上，由于分库分表的原因，由逻辑来控制比价好，减少表之间的关联查询，方便系统进行扩展。
但是在一般的企业级应用中，可使用MyBatis的高级映射结果来处理一对一，一对多和多对多的关系。

kk鲁
关注
专栏目录
MyBatisPlus 让复杂查询如此简单
AI天才研究院
09-06 1580
作者：禅与计算机程序设计艺术 1.简介 Mybatis-Plus 是一款基于 MyBatis 的增强工具。它可以很方便地使 Java 和 SQL 不分离的开发模式统一起来，极大地简化了 CRUD 操作。我将从以下几个方面介绍 Mybatis-Plus ： 一、主要
spring-boot-starter-mybatis-spring-boot-1.0.2.zip
04-19
《Spring Boot集成MyBatis详解》 在Java开发领域，Spring Boot以其简洁的配置和快速的启动特性，已经成为构建微服务应用的首选框架。而MyBatis作为一款强大的持久层框架，深受开发者喜爱，它提供了灵活的SQL映射...
MybatisPlus实现复杂查询
天元白手的博客
04-11 1477
mp实现复杂查询，使用queryWrapper构建条件，创建QueryWrapper构建条件，使用方法实现各种条件查询： 1、ge大于等于、gt大于、le小于等于、lt小于、isNull、isNotNull //mp实现复杂查询 @Test public void testSelectQuery(){ QueryWrapper<User> wrapper = new QueryWrapper<>(); // 查询age >= 30记录
深入解析MybatisPlus多表连接查询
最新发布
chinaherolts2008的博客
07-30 598
多对多N条记录查询由于使用了批查询，因此最多访问数据库也是3次，先查询学生信息，然后查询学生与课程匹配信息，最后查询课程分数信息，查询时间复杂度为O(1)。多对多单条记录查询最多访问数据库3次，先查询学生信息，然后查询学生与课程匹配信息，最后查询课程分数信息，查询时间复杂度为O(1)。一对多查询最常见的场景是查询部门所包含的学生信息，由于一个部门对应多个学生，每个学生对应一个部门，因此称为一对多查询。通过上述分析，能够用 MybatisPlus 解决多表连接查询中的一对一、一对多、多对多查询。
mybatis一对多的查询方法详解
Steven_sf的博客
11-29 629
mybatis一对多的查询方法详解
mybatis-plus复杂查询
深漂小码哥
01-26 1398
// 复杂查询操作 @Test public void testSelect() { QueryWrapper<User> queryWrapper = new QueryWrapper<>(); // ge-大于等于,gt-大于,le-小于等于,lt-小于 queryWrapper.ge("age", 20); // eq-等于, ne-不等于 queryWrapper.eq("name", "Jack"); // between-在区间范围,not..
MybatisPlus复杂条件查询
weixin_51082643的博客
03-03 281
【代码】MybatisPlus复杂条件查询。
mybatis-generator-gui-plus
04-13
《mybatis-generator-gui-plus详解：提升MyBatis开发效率的利器》 在Java开发领域，MyBatis作为一款优秀的持久层框架，以其简洁、灵活的特性深受开发者喜爱。然而，面对大量的数据库操作，手动编写SQL映射文件、...
MyBatis-Plus Generator配置详解
09-07
MyBatis-Plus Generator是一款强大的代码生成工具，它是MyBatis-Plus框架的一部分，能够帮助开发者自动生成Java实体类、Mapper接口及XML配置文件等，大大提高了开发效率。下面将详细介绍如何配置和使用MyBatis-Plus ...
mybatis-3-mapper.dtd 和 mybatis-generator-config_1_0.dtd
05-18
博客原文的2个资源文件 博客：https://blog.csdn.net/gt18120588267/article/details/106190484 资源：mybatis-3-mapper.dtd 和 mybatis-generator-config_1_0.dtd
MyBatis-plus 模糊查询的使用
09-07
主要介绍了MyBatis-plus 模糊查询的使用，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
mybatis-plus案例 方法 一系列配置 增删改查
12-25
mybatis-plus案例 方法 一系列配置 增删改查 mybatis-plus将 mybatis封装成与hibernate一样的增删改查操作，同时也能自定义SQL
mybatis-plus复杂条件查询
qq_59536908的博客
07-29 942
UpdateWrapper 对象用于封装修改的条件。如果要封装方法则需要自己在server层自定义方法。MybatisPlus分页查询。的复杂条件，需要将条件封装到。对象用于封装查询，删除条件。： 查询，删除条件封装，自己的方法使用分页插件。
【谷粒学院项目开发】MybatisPlus复杂条件查询
taroriceball的博客
12-07 183
调用QueryWrapper的方法来实现复杂条件查询 QueryWrapper有很多方法可以帮助我们实现复杂条件查询数据库。此处只是写了一个例子，来演示如何使用QueryWrapper。 查询age>=30的字段
9. MyBatisPlus实现复杂查询
weixin_45267102的博客
10-18 6116
文章目录MyBatisPlus实现复杂查询1. wapper介绍2. AbstractWrapper2.1 ge、gt、le、lt、isNull、isNotNull2.2 eq、ne2.3 between、notBetween2.4 allEq2.5 like、notLike、likeLeft、likeRight2.6 in、notIn、inSql、notinSql、exists、notExists2.7 or、and2.8 嵌套or、嵌套and2.9 orderBy、orderByDesc、orderBy
基于MyBatis-Plus实现复杂查询
flash_love的博客
01-02 1060
在使用MyBatis-Plus开发过程中，不可避免的会出现有些略复杂的查询，需要熟练使用MyBatis-Plus来实现这些功能。
MybatisPlus使用QueryWrapper的基本操作
Kaaaakaki的博客
01-29 895
//mp实现复杂查询操作 @Test public void testSelectQuery() { //创建QueryWrapper对象 QueryWrapper<User> wrapper = new QueryWrapper<>(); //通过QueryWrapper设置条件 //ge、gt、le、lt //查询age>=30记录 //第一个参数字段名称，第二
mybatis-plus 使用更复杂的模糊查询
weixin_57101315的博客
06-07 465
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值