Mybatis多表的关联查询、懒加载

已于 2022-11-21 21:12:35 修改
阅读量1.8k 收藏 5
点赞数 2
分类专栏： MyBatis 文章标签： java mybatis spring
于 2022-09-17 18:28:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53881899/article/details/126906766
版权

目录

导语：
关于＜resultMap＞标签映射，＜association＞＆＜collection＞的使用：跳转文章查看
无论是什么关联关系，如果某方持有另一方的集合，则使用<collection>标签完成映射，如果某方持有另一方的对象，则使用<association>标签完成映射。

一、多对一查询：

“多”的一方为主表，“一”的一方为副表，主表关联副表，应该在主表中加入副表对象作为属性。
根据订单ID查询订单信息 （多） 及该订单所属的顾客的信息 （一） 。
实现思路：
在这里插入图片描述

方式一：association

  • 创建订单类，存储订单信息：主表
    注意我们在订单类中封装了该订单下的顾客的信息。
package com.user.pojo;

public class Order {
    //订单信息
    private Integer id;
    private String orderNumber;
    private Double orderPrice;
    private Integer customer_id;
    //订单所属的客户
    private Customer customer;

    @Override
    public String toString() {
        return "Order{" +
                "id=" + id +
                ", orderNumber='" + orderNumber + '\'' +
                ", orderPrice=" + orderPrice +
                ", customer_id=" + customer_id +
                ", customer=" + customer +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getOrderNumber() {
        return orderNumber;
    }

    public void setOrderNumber(String orderNumber) {
        this.orderNumber = orderNumber;
    }

    public Double getOrderPrice() {
        return orderPrice;
    }

    public void setOrderPrice(Double orderPrice) {
        this.orderPrice = orderPrice;
    }

    public Integer getCustomer_id() {
        return customer_id;
    }

    public void setCustomer_id(Integer customer_id) {
        this.customer_id = customer_id;
    }

    public Customer getCustomer() {
        return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }

    public Order(Integer id, String orderNumber, Double orderPrice, Integer customer_id, Customer customer) {
        this.id = id;
        this.orderNumber = orderNumber;
        this.orderPrice = orderPrice;
        this.customer_id = customer_id;
        this.customer = customer;
    }

    public Order() {
    }
}
  • 创建顾客类，存储顾客信息：副表
package com.user.pojo;

import java.util.List;

public class Customer {
    //顾客信息
    private Integer id;
    private String name;
    private Integer age;

    @Override
    public String toString() {
        return "Customer{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Customer(Integer id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public Customer() {
    }
}
  • 动态代理接口：
    package com.user.mapper;

    import com.user.pojo.Customer;
    import com.user.pojo.Order;

    public interface OrderAndCustomerMapper{
        //根据主键查订单并同时查询该订单的客户信息
        Order getById(Integer id);
    }
  • Mapper.xml文件：
    因为我们的查询结果包括该订单信息和订单所属顾客的信息，所以我们的返回值需要自定义一个map集合来存储。我们这里使用 <resultMap>标签映射的方式创建我们的集合customermap，并将该集合作为我们的返回值类型。
<?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.user.mapper.OrderAndCustomerMapper">
    <!--
    type：map集合中存储的数据单位，是order对象
    id：该map结构的标识符
    -->
    <resultMap id="ordermap" type="order">
        <!--
        主键用id标签绑定，非主键用result标签绑定，集合用collection标签绑定，
        这里没有用collection标签，而是用了association,因为返回的只有一行数据（一个顾客的信息），不需要集合存储
        property是order类中的属性，column是属性对应存储的数据库表中的列名，javaType是返回的数据用什么存储
        -->
        <!--主键绑定-->
        <id  property="id" column="id"></id>
        <!--非主键绑定-->
        <result property="orderNumber" column="orderNumber"></result>
        <result property="orderPrice" column="orderPrice"></result>
        <result property="customer_id" column="customer_id"></result>
        <!--顾客数据，不在order表内-->
        <association property="customer" javaType="customer">
            <id property="id" column="id"></id>
            <result property="name" column="name"></result>
            <result property="age" column="age"></result>
        </association>
    </resultMap>
    <select id="getById" parameterType="Integer" resultMap="ordermap">
        select orders.id ,orderNumber ,orderPrice ,customer_id ,customer.id ,name,age
        from orders left join customer on orders.customer_id = customer.id
        where orders.id = #{id}
    </select>
</mapper>
  • 测试类：
package com.user;

import com.user.mapper.OrderAndCustomerMapper;
import com.user.pojo.Order;
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.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;

public class MyTest {
    SqlSession sqlSession;
    OrderMapper orderMapper;
    @Before
    public void openSqlSession() throws IOException {
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        sqlSession = factory.openSession();
        orderMapper = sqlSession.getMapper(OrderMapper.class);
    }
    @After
    public void closeSqlSession(){
        sqlSession.close();
    }
    @Test
    public void testGetOrderById(){
        Order order = orderMapper.getById(11);
        System.out.println(order);
    }
}
  • 其余基础配置文件：
<?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>
    <properties resource="jdbc.properties"></properties>
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    <typeAliases>
        <package name="com.user.pojo"/>
        <package name="com.user.mapper"/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driverClassName}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <package name="com.user.mapper"></package>
    </mappers>
</configuration>

请添加图片描述

请添加图片描述

方式二：分布查询+延迟加载：常用

  • 分布查询+延迟加载优点：
    • 复用性强，多条语句可重复利用。
    • 充分利用延迟加载机制，提高性能。

延迟加载：又叫懒加载，顾名思义就是很懒。多表关联查询中查询的是多个表，如果我们在使用中只用到了第一个表的查询结果，那么只执行第一条sql，后续表的查询将不会执行。
请添加图片描述
请添加图片描述

代码同方式一，只需要改三个地方：

  • 动态代理接口：
package com.user.mapper;

import com.user.pojo.Customer;
import com.user.pojo.Order;

public interface OrderAndCustomerMapper{
    //因为是分布查询，所以我们就需要两条sql分开执行
    //根据主键查订单
    Order getOrderById(Integer id);
    //根据主键查客户信息
    Customer getCustomerById(Integer id);
}
  • Mapper.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.user.mapper.OrderAndCustomerMapper">
    <!--association标签：
        property：order类中的属性
        select：下一条要查询的语句
        column：指定下一条查询语句的查询条件
    -->
    <resultMap id="ordermap" type="order">
        <id  property="id" column="id"></id>
        <result property="orderNumber" column="orderNumber"></result>
        <result property="orderPrice" column="orderPrice"></result>
        <result property="customer_id" column="customer_id"></result>
        <association property="customer"
                     select="com.user.mapper.OrderMapper.getCustomerById"
                     column="customer_id"
        ></association>
    </resultMap>
    <!--因为是分布查询，所以我们就需要两条sql分开执行-->
    <select id="getOrderById" parameterType="Integer" resultMap="ordermap">
        select id ,orderNumber ,orderPrice ,customer_id
        from orders
        where orders.id = #{id}
    </select>
    <select id="getCustomerById" parameterType="Integer" resultType="Customer">
        select id ,name,age
        from customer
        where id = #{id}
    </select>
</mapper>
  • 核心配置文件中启动懒加载：
	<!--
	这里将所有分布查询都设置为懒加载。
	如果某个分布查询我们不希望它懒加载，那么我们可以在association 标签中设置属性 fetchType="eager"
	-->
    <settings>
        <setting name="lazyLoadingEnabled" value="true"/>
    </settings>

二、一对多查询：

“一”的一方为主表，“多”的一方为副表，主表关联副表，应该在主表中加入副表对象的集合作为属性。
根据顾客ID查询顾客信息 （一） ，同时将顾客名下所有订单查出 （多） 。
实现思路：
在这里插入图片描述

方式一：collection

  • 创建顾客类，存储顾客信息：
    注意我们在顾客类中用List集合封装了顾客名下的订单信息。
package com.user.pojo;

import java.util.List;

public class Customer {
    //customer表中的三个列
    private Integer id;
    private String name;
    private Integer age;
    //该客户名下所有订单集合
    private List<Order> orderList;

    @Override
    public String toString() {
        return "Customer{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", orderList=" + orderList +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public List<Order> getOrderList() {
        return orderList;
    }

    public void setOrderList(List<Order> orderList) {
        this.orderList = orderList;
    }

    public Customer(Integer id, String name, Integer age, List<Order> orderList) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.orderList = orderList;
    }

    public Customer() {
    }
}
  • 创建订单类，存储订单信息：
package com.user.pojo;

public class Order {
    private Integer id;
    private String orderNumber;
    private Double orderPrice;

    @Override
    public String toString() {
        return "Order{" +
                "id=" + id +
                ", orderNumber='" + orderNumber + '\'' +
                ", orderPrice=" + orderPrice +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getOrderNumber() {
        return orderNumber;
    }

    public void setOrderNumber(String orderNumber) {
        this.orderNumber = orderNumber;
    }

    public Double getOrderPrice() {
        return orderPrice;
    }

    public void setOrderPrice(Double orderPrice) {
        this.orderPrice = orderPrice;
    }

    public Order(Integer id, String orderNumber, Double orderPrice) {
        this.id = id;
        this.orderNumber = orderNumber;
        this.orderPrice = orderPrice;
    }

    public Order() {
    }
}
  • 动态代理接口：
package com.user.mapper;

import com.user.pojo.Customer;

public interface OrderAndCustomerMapper{
    //根据客户id查询客户所有信息并同时查询该客户名下的所有订单
    Customer getById(Integer id);
}
  • Mapper.xml文件：
    因为我们的查询结果包括该顾客信息和顾客所有的订单信息，所以我们的返回值需要自定义一个map集合来存储。我们这里使用 <resultMap>标签映射的方式创建我们的集合customermap，并将该集合作为我们的返回值类型。
<?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.user.mapper.OrderAndCustomerMapper">
    <!--
    type：map集合中存储的数据单位，是customer对象
    id：该map结构的标识符
    -->
    <resultMap id="customermap" type="customer">
        <!--
        主键用id标签绑定，非主键用result标签绑定，集合用collection标签绑定
        property是customer类中的属性，column是属性对应存储的数据库表中的列名，ofType是集合中存储的数据类型
        -->
        <!--主键绑定-->
        <id  property="id" column="id"></id>
        <!--非主键绑定-->
        <result property="name" column="name"></result>
        <result property="age" column="age"></result>
        <!--订单数据，不在customer表内-->
        <collection property="orderList" ofType="order">
            <id property="id" column="id"></id>
            <result property="orderNumber" column="orderNumber"></result>
            <result property="orderPrice" column="orderPrice"></result>
        </collection>
    </resultMap>
    <select id="getById" parameterType="Integer" resultMap="customermap">
        select customer.id ,name,age ,orders.id ,orderNumber ,orderPrice ,customer_id
        from customer left join orders on customer.id = orders.customer_id
        where customer.id = #{id}
    </select>
    <!--#{id}为占位符，随便写的，表示所要查询的顾客ID-->
</mapper>
  • 测试程序：
import java.io.InputStream;
import java.util.List;

public class MyTest {
    SqlSession sqlSession;
    CustomerMapper customerMapper;
    @Before
    public void openSqlSession() throws IOException {
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        sqlSession = factory.openSession();
        customerMapper = sqlSession.getMapper(CustomerMapper.class);
    }
    @After
    public void closeSqlSession(){
        sqlSession.close();
    }
    @Test
    public  void testGetCustomerById(){
        Customer customer = customerMapper.getById(1);
        System.out.println(customer);
    }
}
  • 其余基础配置文件SqlMapConfig.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>
    <properties resource="jdbc.properties"></properties>
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    <typeAliases>
        <package name="com.user.pojo"/>
        <package name="com.user.mapper"/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driverClassName}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <package name="com.user.mapper"></package>
    </mappers>
</configuration>

请添加图片描述
请添加图片描述

方式二：分布查询+延迟加载：常用

代码同方式一，只需要改三个地方：

  • 动态代理接口：
package com.user.mapper;

import com.user.pojo.Customer;
import com.user.pojo.Order;

public interface OrderAndCustomerMapper{
    //因为是分布查询，所以我们就需要两条sql分开执行
    //根据主键查订单
    Order getOrderById(Integer id);
    //根据主键查客户信息
    Customer getCustomerById(Integer id);
}
  • Mapper.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.user.mapper.OrderAndCustomerMapper">
    <!--association标签：
        property：customer类中的属性
        select：下一条要查询的语句
        column：指定下一条查询语句的查询条件
    -->
    <resultMap id="customermap" type="customer">
        <id  property="id" column="id"></id>
        <result property="name" column="name"></result>
        <result property="age" column="age"></result>
        <collection  property="orderList"
                     select="com.user.mapper.OrderMapper.getOrderById"
                     column="id"
        ></collection>
    </resultMap>

    <!--因为是分布查询，所以我们就需要两条sql分开执行-->
    <select id="getCustomerById" parameterType="Integer" resultMap="customermap">
        select id ,name,age
        from customer
        where id = #{id}
    </select>
    <select id="getOrderById" parameterType="Integer" resultType="Order">
        select id ,orderNumber ,orderPrice ,customer_id
        from orders
        where customer_id = #{id}
    </select>
</mapper>
  • 核心配置文件中启动懒加载：
	<!--
	这里将所有分布查询都设置为懒加载。
	如果某个分布查询我们不希望它懒加载，那么我们可以在association 标签中设置属性 fetchType="eager"
	-->
    <settings>
        <setting name="lazyLoadingEnabled" value="true"/>
    </settings>

三、一对一查询：

同多对一。

  • 实体类：
    在这里插入图片描述
  • 动态代理接口：
    在这里插入图片描述
  • mapper.xml文件：
    在这里插入图片描述

四、多对多查询：

多对多关联中，需要通过中间表化解关联关系。中间表描述两张主键表的关联。

姓蔡小朋友
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
mybatis思维导图总结.zip
08-21
mybatis看这一篇就够了MyBatis 思维导图总结： 1. MyBatis 简介 ORM（对象关系映射）的定义和作用。 MyBatis 是什么以及它的核心思想。 MyBatis 的优点和适用场景。 2. 环境搭建与配置 下载 MyBatis jar 包。 配置 mybatis-config.xml 文件。 数据库连接和事务管理配置。 3. 映射器文件 映射器文件的结构和作用。 SQL 映射的基本元素：<select>、<insert>、<update>、<delete>。 参数映射和结果映射。 4. 动态 SQL 使用 <if>、<choose>、<when>、<otherwise> 构建动态 SQL。 动态 SQL 的应用场景和语法示例。 5. 注解配置 使用注解替代映射器文件。 常用注解：@Select、@Insert、@Update、@Delete。 6. 一级缓存与二级缓存 一级缓存（本地缓存）的原理和作用。 配置和使用二级缓存。 缓存的失效和刷新机制。 7. 延迟加载与关联查询 延迟加载的概念和使用场景。 使用 <association>、<collec
MyBatis的关联关系 一对多关系 、collection 标签
12-14
什么是一对多？ 　　一对多关系应该是开发人员接触得最多的关联关系。打个比方，淘宝上，一个用户他拥有多个订单，而这几个订单单独属于此用户，这个关联关系就叫一对多关系。在数据库中则表示为两张表互相关联，如用户表(A表)关联订单表(B表),那么A表的一行数据就和B表的多条数据产生关联。 　　 　 　　　 MyBatis加载关联关系对象主要通过两种方式 嵌套查询： 　　1、嵌套查询是通过另一条SQL映射语句来返回预期的复杂类型 　　2、嵌套查询是查询语句中插入一个子SQL语句 　　3、嵌套查询会执行多条SQL语句 　　4、嵌套查询编写SQL语句较为简单，但消耗资源大，可配置延迟加载解决 嵌套结果： 　
Mybatis简单关系查询案例
09-12
含关联查询方式-- 方案1：嵌套查询，发送N+1条，效率低 -- 方案2**：嵌套结果 一条sql,效率高 多对一查询-嵌套结果 懒加载配置
mybatis的关联映射及延迟加载的使用
05-27
java学习-java学习-mybatis的关联映射(一对一关联映射/一对多关联映射/多对多关联映射)，mybatis的延迟加载的好处及使用。
MyBatisDemo：MyBatis 框架知识案例
10-16
1.创建第一个 MyBatis 程序案例 2.MyBatis 配置文件案例 3.MyBatis 关联查询与懒加载案例 4.MyBatis 缓存案例 5.MyBatis 动态 SQL 标签案例 6.MyBatis Generator 、批量操作与分页查询案例 7.MyBatis 自定义 typeHandler 处理枚举类型案例
MyBatis——级联映射与懒加载
qq_16500963的博客
11-05 126
MyBatis其中一个比较强大的功能是支持查询结果级联映射。使用MyBatis级联映射，我们可以很轻松地实现一对多、一对一或者多对多关联查询，甚至可以利用MyBatis提供的级联映射实现懒加载。所谓的懒加载，就是当我们在一个实体对象中关联其他实体对象时，如果不需要获取被关联的实体对象，则不需要为被关联的实体执行额外的查询操作，仅当调用当前实体的Getter方法获取被关联实体对象时，才会执行一次额外的查询操作。通过这种方式在一定程度上能够减轻数据库的压力。
Mybatis懒加载
qq_52519008的博客
09-30 2715
顾名思义，懒加载就是懒得加载，只有使用的时候才进行加载。其实，懒加载也加延迟加载，主要以应用与Mybatis的关联查询，按照设置的延迟规则，推迟对延迟对关联对象的select查询，例如，我们在用Mybatis进行一对多的时候，先查询出一方，当程序需要多方数据时，mybatis会再次发出sql语句进行查询，减轻了对我们数据库的压力。Mybatis的延迟加载，只对关联对象有延迟设置。
mybatis-plus查询结果id都为0的解决办法
乾坤未定，你我皆是黑马
03-14 2629
例如， 1.我的id字段是user_id，是自增主键 2.我使用了selectlist或者select * 查询所有数据 3.获取返回集合的对象的user_id都为0（int默认值） 4.原因：没有关闭mybatis的驼峰命名，它需要匹配userId 5.解决办法：在配置文件中关闭 mybatis-plus.configuration.map-underscore-to-camel-case=false ...
Mybatis小功能
Mr_ming_a_probie的博客
11-22 340
本门是在学习了mybatis整理的一些小知识点结合springboot使用的
Mybatis 关联查询
HeathlX的博客
02-20 1139
多表查询是在企业中必不可少的，无论多么简单的项目里都会出现多表查询操作。因为只要是关系型数据库，在设计表时都需要按照范式进行设计，为了减少数据冗余，都会拆成多个表。当需要表中数据时，在进行联合查询。
ibatis的实现（包含模糊查询、关联查询、增删改查）
08-05
ibatis的实现（包含模糊查询、关联查询、增删改查） 数据库sql server 2005
mybatis 第七天 关联查询 一对多 一对一 多对多 多对一 懒加载
最新发布
weixin_58026642的博客
01-26 333
【代码】mybatis 第七天 关联查询 一对多 一对一 多对多 多对一。
优秀的持久层框架-Mybatis(下)
qq_52173163的博客
11-25 610
文章目录前言一、懒加载二、注解方式三、动态SQL四、缓存总结 前言 mybatis是一个轻量级的ORM框架,之前我们已经学习了mybatis的基本概念,环境的搭建以及参数和结果处理,本章我们将继续学习mybatis剩余的内容,包括动态Sql,注解方式以及缓存。 一、懒加载 当我们在进行多表查询时,启动懒加载可以有效的缓解数据库的压力。首次查询我们只先查询主表中的信息,当用户需要用到关联表的信息时,才进行获取。Mybatis 一对一关联的 association 和一对多的 collection 可以实现
Mybatis高级多表查询学习 --懒加载 SQL
weixin_45374181的博客
06-18 413
今天学习的课程是mybatis中的多表查询,SQL中的多表查询主要有一对多,一对一,多对多, 本章主要讲解的是多表联查和加上懒加载的多表查询 所以讲解的就是对一和对多。
Mybatis 通用Mapper获取表数据id全等于0的情况
weixin_30402085的博客
12-04 201
解决：自增主键类型int型改为Integer 转载于:https://www.cnblogs.com/hnzkljq/p/10063740.html
Mybatis关联查询【附实战案例】
qq_53317005的博客
04-14 2764
Mybatis关联查询，一对一，一对多，多对多
【mybatis】懒加载的应用 一对一、一对多 实例
编程学习集装箱
07-25 677
懒加载（延迟加载）的使用 懒加载是一种延迟技术，当我们没有使用被标记延迟加载的元素时，mybatis便不会执行select的语句的实现。 通俗的讲，有使用到，就会被加载即被association或者collection标签关联的数据。 本例中用户对应多个账户，账户对应一个用户。 表信息如下 主配置文件mybatis-config.xml 需要添加 懒加载的配置。 <settings> <setting name="lazyLoadingEnable
mybatis级联查询
无名之鑫的博客
08-18 156
查询返回对象里面包含一个对象 <?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.bdm.mappers.EmpMapper"> <resultMap id="EmpRe.
Mybatis的关联查询（association和collection）
0
12-22 454
分析：用户信息和他的账户信息为一对多关系，并且查询过程中如果用户没有账户信息，此时也要将用户信息查询出来，此时左外连接查询比较合适。分析：一个用户可以拥有多个角色，一个角色也可以赋予多个用户，用户和角色为双向的一对多关系，多对多关系其实我们看成是双向的一对多关系。当访问关系的一方时，如果需要查看与之关联的另一方数据，则必须使用表链接查询，将查询到的另一方数据，保存在本方的属性中。com.by.dao下的AcountDao.xml文件。com.by.dao下的UserDao.xml。
mybatis跨库关联查询
08-31
在MyBatis中，实现跨库关联查询可以通过连接查询的方式来实现。可以使用多表查询SQL语句进行关联查询。 此外，还可以通过使用延迟加载策略来查询关联对象。延迟加载要求查询方式需要使用N次查询，并在映射配置文件或全局配置文件中开启延迟加载。 另外，MyBatis还提供了一种操作映射的关联对象触发其他查询的方式，即在一次查询中执行部分SQL语句来实现延迟加载。 综上所述，MyBatis可以通过连接查询和延迟加载的方式来实现跨库关联查询。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [通过几个案例帮你轻松搞懂Mybatis 的多表关联查询](https://blog.csdn.net/kangkang12221222/article/details/123259149)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

姓蔡小朋友

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值