mybatis中 N+1 查询问题的引出、分析和解决

已于 2024-06-05 11:17:16 修改
阅读量1.9k 收藏 18
点赞数 25
文章标签： java mybatis
于 2024-06-05 11:08:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46516427/article/details/139443534
版权

MyBatis 会将查询结果映射到实体类，如果这个实体类有个List属性，该怎么封装？

在 MyBatis 中，当你的实体类（通常称为 DTO、DO 或模型类）包含一个 List 类型的属性时，你通常会使用 标签在 MyBatis 的映射文件（如 xxxMapper.xml）中定义这个集合的映射。这个 List 可能是表示一对多（如订单与订单明细）或多对多（如学生与课程）关系的集合。

下面是一个简单的例子，说明如何在 MyBatis 的映射文件中处理 List 类型的属性。

假设你有一个 User 类，它有一个 List 类型的属性，表示用户下的所有订单：

public class User {  
    private Integer id;  
    private String name;  
    private List<Order> orders; // 用户的订单列表  
    // 省略 getter 和 setter  
}  
  
public class Order {  
    private Integer id;  
    private Integer userId; // 外键，指向用户  
    private String orderNumber;  
    // 省略 getter 和 setter  
}

在你的 MyBatis 映射文件中（例如 UserMapper.xml），你需要使用 来定义这个复杂的映射关系，并使用 标签来映射 List：

<mapper namespace="com.example.mapper.UserMapper">  
  
    <resultMap id="userResultMap" type="User">  
        <id property="id" column="user_id"/>  
        <result property="name" column="user_name"/>  
        <collection property="orders" column="user_id" foreignColumn="user_id" ofType="Order" select="getOrdersByUserId" fetchType="lazy"/>  
    </resultMap>  
  
    <select id="getUserById" resultMap="userResultMap">  
        SELECT * FROM users WHERE user_id = #{id}  
    </select>  
  
    <!-- 注意：这个查询是嵌套的，可能需要根据实际数据库结构调整 -->  
    <select id="getOrdersByUserId" resultType="Order" parameterType="int">  
        SELECT * FROM orders WHERE user_id = #{userId}  
    </select>  
  
</mapper>

在上面的例子中， 标签有几个重要的属性：

  • property：这是 User 类中 List 属性的名称。
  • column：用于传递给子查询的列名，通常与 foreignColumn 匹配。
  • foreignColumn：子查询中用于与 column 匹配的列名。在这个例子中，我们假设订单表有一个 user_id列，用于标识该订单属于哪个用户。
  • ofType：集合中元素的类型（在这个例子中是 Order）。
  • select：用于获取集合中元素的子查询的 ID。
  • fetchType：指定是立即加载（eager）还是延迟加载（lazy）。在 MyBatis 中，延迟加载通常通过 CGLIB 或 Javassist 这样的库实现。

请注意， 标签中的 select 属性是一个子查询的 ID，这意味着 MyBatis 会首先执行主查询（在这个例子中是 getUserById），然后对于主查询返回的每一行，它都会执行子查询（在这个例子中是 getOrdersByUserId）来获取相关的订单。这通常被称为 N+1 查询问题，因为它可能会导致性能问题，特别是当返回的行数很多时。为了避免这个问题，你可以考虑使用 JOIN 查询或批量加载策略来优化性能。

N+1 查询问题是什么？

N+1 查询问题（也称为 1+N 查询问题或 N+1 Selects 问题）是在使用对象关系映射（ORM）框架（如 MyBatis、Hibernate 等）时经常遇到的一个性能问题。它通常发生在你查询一个包含多个关联对象的对象时，而 ORM 框架没有有效地将这些关联查询合并成一个单独的查询。

具体来说，当你从数据库中查询一个对象（比如用户），而这个对象又关联了多个其他对象（比如用户的订单列表），你可能会期望 ORM 框架执行一个 JOIN 查询来获取所有必要的数据。但是，如果 ORM 框架没有正确配置或使用了默认的行为，它可能会执行一个初始查询来获取主对象（这里是用户），然后为每个关联的对象执行一个额外的查询。

假设你有一个用户（User），每个用户有多个订单（Order）。如果你查询一个用户，并且希望同时获取该用户的所有订单，你可能会遇到以下情况：

  1. 执行一个查询来获取用户信息（1次查询）。
  2. 对于用户关联的每个订单，执行一个单独的查询来获取订单信息（N次查询，其中 N 是用户的订单数量）。

因此，总共执行了 N+1 次查询，这就是 N+1 查询问题的由来。

这个问题可能会导致严重的性能问题，特别是在处理大量数据或高并发请求时。为了减少数据库查询次数和提高性能，你可以考虑以下几种方法：

  1. 显式 JOIN：在映射文件中显式地编写 JOIN 查询来一次性获取所有需要的数据。
  2. 批量加载：使用 ORM 框架提供的批量加载策略来减少查询次数。例如，Hibernate 提供了 @BatchSize 注解来实现批量加载。
  3. DTO 映射：创建一个数据传输对象（DTO），该对象包含你需要的所有数据，并在查询时直接映射到DTO，而不是映射到包含多个关联对象的复杂对象。
  4. 延迟加载（LazyLoading）：虽然延迟加载可以减少初始查询时的数据加载量，但它可能会导致在应用程序的不同部分多次执行额外的查询。因此，在使用延迟加载时需要谨慎考虑。
  5. 缓存：使用 ORM 框架提供的缓存机制（如 Hibernate 的二级缓存）或应用程序级别的缓存（如Redis）来缓存查询结果，从而避免重复查询。

使用 JOIN 查询来解决 N+1 查询问题

使用 JOIN 查询来解决 N+1 查询问题是一种有效的方法，特别是在你需要一次性加载主对象和关联对象的数据时。下面是一个使用 JOIN 查询在 MyBatis 中加载 User 和其 Orders 的示例。

首先，我们需要定义 User 和 Order 的实体类（DTO 或领域模型类）。假设你已经有了这些类，但为了示例，我会给出简化的版本：

public class User {  
    private Long id;  
    private String username;  
    // 其他属性...  
    private List<Order> orders;  
      
    // getters and setters...  
}  
  
public class Order {  
    private Long id;  
    private Long userId; // 关联的用户ID  
    private String orderNumber;  
    // 其他属性...  
      
    // getters and setters...  
}

接下来，在 MyBatis 的映射文件中，我们将使用 JOIN 查询来同时加载 User 和 Order 的数据。由于 MyBatis 默认不支持直接映射到一个包含集合的对象，我们需要自定义结果映射或者使用 来处理这种关系。

在 中，我们可以使用 、 来映射简单的字段，以及使用 来处理集合字段，但这次我们不使用 的 select 属性来执行额外的查询，而是直接在 JOIN 查询中加载所有数据。

<resultMap id="userOrdersResultMap" type="User">  
    <id property="id" column="user_id"/>  
    <result property="username" column="username"/>  
    <!-- 其他User属性映射... -->  
      
    <!-- 使用<collection>来处理Order集合，但这次不设置select属性 -->  
    <collection property="orders" ofType="Order" foreignColumn="user_id" column="user_id"  
                 resultMap="orderResultMap" />  
</resultMap>  
  
<!-- 这是一个内部ResultMap，用于映射Order对象 -->  
<resultMap id="orderResultMap" type="Order">  
    <id property="id" column="order_id"/>  
    <result property="userId" column="user_id"/>  
    <result property="orderNumber" column="order_number"/>  
    <!-- 其他Order属性映射... -->  
</resultMap>  
  
<!-- 完整的JOIN查询 -->  
<select id="selectUserWithOrders" resultMap="userOrdersResultMap">  
    SELECT  
        u.id AS user_id,  
        u.username,  
        -- 其他User字段...  
        o.id AS order_id,  
        o.user_id,  
        o.order_number  
        -- 其他Order字段...  
    FROM users u  
    LEFT JOIN orders o ON u.id = o.user_id  
    WHERE u.id = #{userId}  
</select>

在这个例子中，我们创建了两个 ：一个是 userOrdersResultMap 用于映射 User 对象及其关联的 Order 集合，另一个是 orderResultMap 用于映射单个 Order 对象。在 selectUserWithOrders 查询中，我们使用了 LEFT JOIN 来连接 users 和 orders 表，并通过别名指定了结果集中的列名，以便与 中的列名对应。

现在，当你调用 selectUserWithOrders 方法并传入一个用户 ID 时，MyBatis 将返回一个 User 对象，其 orders 属性已经填充了与该用户关联的所有 Order 对象，而无需执行任何额外的查询。

但又有个问题，如果想为每个用户获取其所有订单，但是又要对用户列表进行分页呢？

假设你正在使用 MySQL，并且你想对 User 和他们的 Orders 进行分页，但只返回前 10 个用户及其订单。你不能简单地对整个 JOIN 结果应用分页，因为这可能会导致每个用户的订单数量不完整（尤其是当某个用户的订单跨越了分页边界时）。

相反，你应该首先对用户进行分页，然后再为每个用户加载他们的订单。但是，如果你仍然想在一个查询中完成这个操作，你可以这样做：

  • 对用户进行分页：首先，你需要一个查询来仅选择用户，并应用分页逻辑。这个查询会给你一个用户 ID 的列表。
  • 使用 IN 子句和 JOIN：然后，你可以使用这些用户 ID 来在 JOIN 查询中筛选用户，并加载他们的订单。由于你已经有了用户 ID
    的列表，所以你可以确保只加载这些用户的订单。

由于 UserOrderDto 包含一个 List，这实际上意味着你想为每个用户获取其所有订单，但是又要对用户列表进行分页。在 SQL 中，这通常意味着你会执行一个主查询来获取用户列表（带有分页），然后在应用程序层为每个用户执行额外的查询来获取其订单。

但是，如果你想在一个 SQL 查询中模拟这种行为（即在一个结果集中返回每个用户及其所有订单），那么你需要将结果集映射到一个能够包含这种嵌套结构的对象上。这通常通过 MyBatis 的 来实现，但这样做在 SQL 层面会非常复杂，因为 SQL 本身不支持直接的嵌套集合。

不过，如果你真的想尝试，你可以使用 MyBatis 的 标签在 中来映射集合。但请注意，这并不意味着 SQL 会返回嵌套的行集；它只是在 MyBatis 的结果映射过程中创建了一个嵌套结构。

下面是一个简化的示例，展示了如何使用 和 来映射用户及其订单，但请注意这通常不会与分页直接结合使用，因为分页通常是对顶级记录（即用户）进行的。

UserOrderDto.java

public class UserOrderDto {  
    private Long userId;  
    private String username;  
    private List<OrderDto> orders;  
  
    // getters, setters, toString 等方法  
}  
  
public class OrderDto {  
    private Long orderId;  
    private Long userId; // 可能是外键  
    // ... 其他订单字段  
  
    // getters, setters, toString 等方法  
}

UserMapper.xml

<resultMap id="userOrderResultMap" type="UserOrderDto">  
    <id property="userId" column="user_id"/>  
    <result property="username" column="username"/>  
    <collection property="orders" column="user_id" foreignColumn="user_id" ofType="OrderDto"  
                 select="selectOrdersByUserId" fetchType="lazy"/>  
</resultMap>  
  
<select id="selectUsersWithOrders" resultMap="userOrderResultMap" parameterType="map">  
    SELECT * FROM users  
    <!-- 添加 WHERE、ORDER BY 等，以及 LIMIT 和 OFFSET 用于分页 -->  
    LIMIT #{offset}, #{limit}  
</select>  
  
<select id="selectOrdersByUserId" resultType="OrderDto" parameterType="long">  
    SELECT * FROM orders WHERE user_id = #{userId}  
</select>

在上面的示例中， 标签的 select 属性指定了一个单独的查询，用于根据用户 ID 获取订单。fetchType=“lazy” 表示订单列表的加载将是延迟的（即，当首次访问 orders 属性时才会执行查询）。

但是，请注意这种方法的缺点：

  • 对于每个用户，都会执行一个额外的查询来获取其订单，这可能导致又 N+1 查询问题（尽管它是延迟加载的）。
  • 分页是在用户级别进行的，而不是在订单级别。

如果你真的想在一个查询中返回每个用户及其所有订单，并对其进行分页，你可能需要考虑在应用程序层面处理这个问题，即首先获取用户列表（带有分页），然后为每个用户分别获取其订单。这可以通过批量查询或其他优化技术来提高效率。

那如何在MyBatis中解决N+1查询问题并同时实现分页呢？

在MyBatis中解决N+1查询问题并同时实现分页，通常我们会避免在分页查询中嵌套N个子查询来获取每个用户的订单。相反，我们会使用两种主要策略之一：

  • 批量查询（Batch Queries）:
    首先，执行一个分页查询来获取用户列表。然后，收集这些用户的ID，并使用这些ID执行一个单独的查询来获取所有相关的订单。最后，在应用程序代码中将这些订单与用户匹配起来。
    这种方法可以减少数据库查询次数，因为只需要两个查询（一个用于用户，一个用于订单）。但是，它需要在应用程序代码中处理订单与用户的匹配。
  • 使用JOIN查询并在应用程序中重构数据:
    执行一个JOIN查询来获取用户和他们的订单，但在这个查询中不包含分页逻辑。然后，在应用程序中处理结果集，重构出用户和他们订单的列表，并在需要时应用分页逻辑。
    这种方法可以减少数据库查询次数，但可能会增加应用程序的复杂性，因为你需要处理一个扁平化的结果集，并将其转换为你需要的数据结构。

下面是一个使用批量查询的示例：

Mapper XML:

<!-- 查询用户列表（带分页） -->  
<select id="selectUsersPaged" resultType="User" parameterType="map">  
    SELECT * FROM users  
    ORDER BY some_column  
    LIMIT #{offset}, #{limit}  
</select>  
  
<!-- 查询订单列表，根据用户ID列表 -->  
<select id="selectOrdersByUserIds" resultType="Order" parameterType="list">  
    SELECT * FROM orders WHERE user_id IN  
    <foreach item="userId" index="index" collection="userIds" open="(" separator="," close=")">  
        #{userId}  
    </foreach>  
</select>

Mapper Interface:

public interface UserMapper {  
    List<User> selectUsersPaged(@Param("offset") int offset, @Param("limit") int limit);  
    List<Order> selectOrdersByUserIds(@Param("userIds") List<Long> userIds);  
}

Service Layer:

@Service  
public class UserService {  
    @Autowired  
    private UserMapper userMapper;  
  
    public Page<UserWithOrdersDto> getUsersWithOrdersPaged(int pageNum, int pageSize) {  
        int offset = (pageNum - 1) * pageSize;  
        List<User> users = userMapper.selectUsersPaged(offset, pageSize);  
  
        // 收集用户ID  
        List<Long> userIds = users.stream().map(User::getId).collect(Collectors.toList());  
  
        // 获取订单  
        List<Order> orders = userMapper.selectOrdersByUserIds(userIds);  
  
        // 在应用程序中重构数据  
        List<UserWithOrdersDto> userWithOrdersDtos = new ArrayList<>();  
        for (User user : users) {  
            UserWithOrdersDto dto = new UserWithOrdersDto();  
            dto.setUser(user);  
            dto.setOrders(orders.stream()  
                    .filter(order -> order.getUserId().equals(user.getId()))  
                    .collect(Collectors.toList()));  
            userWithOrdersDtos.add(dto);  
        }  
  
        // 计算总记录数（可能需要另一个查询）  
        int totalCount = // ... 调用另一个查询来获取总记录数  
  
        Page<UserWithOrdersDto> page = new Page<>(pageNum, pageSize, totalCount);  
        page.setRecords(userWithOrdersDtos);  
        return page;  
    }  
}

在上面的示例中，UserWithOrdersDto 是一个包含 User 和 List 的数据传输对象。服务层首先获取用户列表，然后获取订单列表，并在应用程序中重构数据以匹配用户和他们的订单。这种方法可以避免N+1查询问题，并允许你使用分页。但是，请注意，你可能需要执行一个额外的查询来获取总记录数以填充分页信息。

BAT 大厂Java 面试题集锦之核心篇附参考答案
AI天才研究院
11-05 1万+
核心篇数据结构与算法网路:TCP/IP,HTTP操作系统, 文件, shell, CPU, IO, epoll, 非阻塞IO,进程/线程/协程,锁HashMap, Co...
Mybatis N+1问题解析
RuiDer的博客
06-26 3416
Mybatis N+1问题解析 因为热爱，所以拼搏。 –RuiDer 前导必备 Mybatis 数据库 级联 N+1问题？？ N+1问题来源于数据库中常见的级联技术，即N个数据库表形成关联关系，当再增加一个关联表时，也就是N+1个级联关系，由于某些时候，我们并不需要加载数据库的所有数据，而是某一个数据库表中数据，这时Mybatis会自动加载所有表...
MyBatis中的N+1问题——MyBatis学习笔记之十四
weixin_34393428的博客
02-04 476
      掐指一算，居然三个多月没有写MyBatis的博客了，一直在瞎忙，真是罪过！o(╯□╰)o       网友xunke515在看完《MyBatis association的两种形式》一文后留言提到官方文档不建议使用嵌套的select语句的形式，希望我在文中指出。今天我们就来讨论这个话题。       官方文档之所以不建议使用这种嵌套的select语句的形...
MyBatis中的N+1问题
Codelong的专栏
11-30 1万+
官 方文档之所以不建议使用这种嵌套的select语句的形式，是因为这会导致所谓的“N+1问题”。这个问题，无论是association元素还是 collection元素都会遇到，本文以更为典型的collection元素为例。在本系列所使用的示例场景下，当需要查询教师及其所指导的学生（一个 教师可指导多个学生）信息时，我们会这么做：先用一条SQL语句（“N+1问题”中的1）查询教师的信息，即
mybatis的N+1问题
贺天远 廊坊师范学院信息技术提高班十五期
06-03 1322
Mybatis的N+1问题主要说的是当查询一个表的时候这个表的一个信息用外键链接另外一个表的多条信息的时候就会出现mybatis的N+1问题。这样会导致数据库负载过大，从而导致程序运行过慢 如以下实例： 当查询班级表的时候 <select id="select" resultMap="studentResultMap"> select * from t_class </select> 根据如下映射，将会调用selectStudent此查询语句，根据外键c_id查询学生信息，
什么是N+1查询？
热门推荐
xtayhicbladwin的专栏
10-28 3万+
 在Session的缓存中存放的是相互关联的对象图。默认情况下，当Hibernate从数据库中加载Customer对象时，会同时加载所有关联的Order对象。以Customer和Order类为例，假定ORDERS表的CUSTOMER_ID外键允许为null，图1列出了CUSTOMERS表和ORDERS表中的记录。 以下Session的find()方法用于到数据库中检索所有的Cust
控制原理 详细总结卡尔曼滤波原理+具体案例分析_卡尔曼滤波应用实例分析报告(1)
2401_84003554的博客
05-03 973
现在正是金三银四的春招高潮，前阵子小编一直在搭建自己的网站，并整理了全套的**【一线互联网大厂Java核心面试题库+解析】：包括Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等**v(t)符合高斯分布。要求用卡尔曼滤波器估计真实运动轨迹。解决方案首先建立随机系统的真实模型。以码头出发点为原点，采样周期(雷达扫描周期)为TTT，用sks(k)
Shiro+JWT
qq_32699009的博客
09-13 2337
apache旗下的一个开源框架，实现用户身份认证，权限授权，加密，会话管理等功能 内容均转载自Shiro和JWT MD5加密 概述 MD5消息摘要算法，属Hash算法一类。MD5算法对输入任意长度的消息进行运行，产生一个128位的消息摘要(32位的数字字母混合码)。 也就是0123456789ABCDEF构成的混合数字码 特点 不可逆：相同数据的MD5值肯定一样，不同数据的MD5值不一样。 压缩性：任意长度的数据，算出的MD5值长度都是固定的 弱抗碰撞：已知原数据和MD5值，想找到一个具有相同MD5值是非常
输出映射：关联嵌套标签association和集合嵌套标签collection
大力海棠的博客
07-22 2392
前言 为了配置好这两个标签并实现其功能，从数据库录入数据到持久化实体类创建，SQL映射配置和测试等都手动肝了一遍，虽然有点小累，但配置好，测试正确后，长舒了一口气，想起之前参加华为云开发者沙龙时看到的一句话：“选择不凡”。现在写下这一篇日志，总结一下这两个输出映射标签的使用，以及自己的配置过程。既然两个标签都是在输出映射（resultMap）中配置，在讲这两个标签之前，先来简单回顾MyBatis...
java中的关键词汇含义和细碎知识点
qq_38702393的博客
04-28 1764
JAVA关键词汇一： java1.1 HandleInterceptor拦截器 一： java 记录java项目中的关键词汇 1.1 HandleInterceptor拦截器 SpringMVC的处理器拦截器，类似于Servlet开发中的过滤器Filter，用于对请求进行拦截和处理。 preHandle：在业务处理器处理请求之前被调用。预处理，可以进行编码、安全控制、权限校验等处理； postH...
解决MyBatis的N+1问题
最新发布
常备不懈
06-04 824
N+1问题通常出现在一对多关联查询中。当我们查询主表数据（如订单）并希望获取关联的从表数据（如订单的商品）时，如果每获取一条主表记录都要执行一次从表查询，就会产生N+1次查询的问题。假设有10个订单，主查询执行1次，从查询执行10次，总共执行了11次查询。这种情况显然会导致性能低下。
mybatis n+1问题
weixin_33973609的博客
04-08 239
　　mybatis的一对多或者多对多的时候，2中方式解决，一种是嵌套select，但是会有n+1问题，不推荐；另外一种是使用一条sql，在该sql里面使用子查询的方式来完成。比如 select * from clazz m left join student mm on m.id = mm.clazz_id where m.id in (select t.id from clazz t limi...
Mybatis解决n+1问题
磐石长的博客~
03-06 3022
简介 在orm框架中，比如hibernate和mybatis都可以设置关联对象，比如user对象关联dept 假如查询出n个user，那么需要做n次查询dept，查询user是一次select，查询user关联的 dept，是n次，所以是n+1问题，其实叫1+n更为合理一些。 mybatis配置 UserMapper.xml <resultMap id="BaseResult...
mybatis N+1问题解决
dihu6677的博客
10-17 373
关联嵌套查询 示例: <resultMap id="blogResult" type="Blog"> <association property="author" column="author_id" javaType="Author" select="selectAuthor"/> </resultMap> <sele...
MyBatis 延迟加载 & N+1问题
扛麻袋的少年的博客
03-01 2733
MyBatis笔记(六)： Mybatis 在解决一对多或者多对多的时候，共有两种解决方式： 嵌套查询 嵌套结果 嵌套查询：即将一条SQL中的多个子查询，分成多个SQL进行查询的方式； 嵌套结果：即使用一条SQL，在 SQL 中使用子查询的方式来完成。       官方推荐使用嵌套结果的方式，可以减少与 SQL 的多次连接，减少资源消耗等；并且不推荐使用嵌套查询...
MyBatis中多表查询（N+1方式）
wyy的博客
04-19 1113
N+1查询方式 [1]什么是N+1的查询方式 如果没有N+1的方式我们想要实现多表的查询，自己书写查询的业务逻辑代码（java） mybatis希望通过自己标签配置的方式来解决这个问题 [2]执行的操作 查询学生所在班级的信息（一对一） 查询班级中所有学生的信息（一对多） 使用的时候书写标签需要注意： 查询出来返回的是一个对象：association 查询出来返回的是一个集合：collection 总结： 业务装配方式和N+1查询方式 共同点：执行SQL语句的条数上都是N+1条语句 不同点：
n点不能开设mysql数据库_Mysql解决数据库N+1查询问题
weixin_30705133的博客
01-18 159
简介在orm框架中，比如hibernate和mybatis都可以设置关联对象，比如user对象关联dept假如查询出n个user，那么需要做n次查询dept，查询user是一次select，查询user关联的dept，是n次，所以是n+1问题，其实叫1+n更为合理一些。mybatis配置UserMapper.xml数据表如下：department表|id|name|user表|id|name|de...
MyBatis N+1问题(在页面每条相同的结果只显示一遍)
kaituozhe_sh的博客
05-28 239
<association property="appVersion" column="versionId" select="cn.appsys.mapper.AppVersionMapper.selById" javaType="cn.appsys.pojo.AppVersion"></association> 当使用级联查询的时候,mybatis会先查询出所有符合条件的...
使用Mybatis 解决（N+1）
java爱分享
11-18 8111
使用Mybatis高级映射的困惑（N+1）40   为了解决“N+1”问题，Mybatis推荐使用left join等关联查询，并结合等标签来映射高级查询结果。 比如：   Xml代码   resultMap type="Order" id="baseResultMap">    id property="id" column="order_id" />    
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值