（八）mybatis学习之高级映射（一对一、一对多、多对多）

最新推荐文章于 2023-01-12 13:12:57 发布
最新推荐文章于 2023-01-12 13:12:57 发布
阅读量3.1k 收藏 5
点赞数 2
分类专栏： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cwh056056/article/details/51056425
版权

一对一关联查询

resultType

resultType的对于关联查询是实时查询的。

使用resultType来开发的话，就要将sql查询出来的结果映射到某个pojo中。

resultType的开发比较简单，就是查询结果是什么，就去定义一个pojo类，添加对应的属性名进行映射就OK。

resultMap

resultMap对于管理查询，可以设置一些延迟加载的配置。

resultMap里配置一对一关联，主要使用到association这个标签，指定类型用javaType。

订单pojo类：

public class OrderInfos {
	
	private String id;
	private String orderNo;			//订单号
	private String mark;			//留言（描述）
	private String address;			//地址（具体地址）
	private String phone;			//收货人电话
	private Integer quantity;		//数量
	private Double totalSum;		//订单总金额
	private Date createTime;		//订单生成时间
	private User user;
	
	//....get  set


用户信息pojo类：

public class User {
	
	private String id;
	private String userName;				//用户名
	private String nickName;				//昵称
	private String password;				//登录密码
	private Integer sex;					//性别
	private Date birthday;					//出生日期
	private String province;				//省
	private String city;					//市
	private String county;					//县
	private Date createTime;				//创建时间
	
	//... get set


配置文件内容：

<resultMap type="orderInfos" id="findOrderMap">
		<!-- 映射订单信息 
		id:指定查询列中的唯一标识，如果有组合主键，则配置对个id
		-->
		<id column="id" property="id"/>
		<result column="orderNo" property="orderNo"/>
		<result column="mark" property="mark"/>
		<result column="address" property="address"/>
		<result column="createTime" property="createTime"/>
		<!-- 订单所对应的用户信息 -->
		<!-- association：用于映射关联查询单个对象的信息
			property：要讲关联查询的用户信息映射到订单pojo列中的哪个属性里
			javaType:表示关联查询的对象类型（可以使用别名）
		 -->
		<association property="user" javaType="pojo.User">
			<id column="user_id" property="id"/>
			<result column="userName" property="userName"/>
			<result column="sex" property="sex"/>
			<result column="birthday" property="birthday"/>
			<result column="password" property="password"/>
		</association>
	</resultMap>
	
	<!-- 获取订单里的用户信息 -->
	<select id="findOrder" resultMap="findOrderMap">
		select A.*,B.userName,B.sex,B.birthday,B.`password`
		from tab_orderinfos as A
		inner join tab_user as B on A.user_id=B.id
	</select>

一对多关联查询

配置一对多关联，需要在resultMap里使用collection标签来实现，指定类型用ofType

订单pojo类：

public class OrderInfos {
	
	private String id;
	private String orderNo;			//订单号
	private String mark;			//留言（描述）
	private String address;			//地址（具体地址）
	private String phone;			//收货人电话
	private Integer quantity;		//数量
	private Double totalSum;		//订单总金额
	private Date createTime;		//订单生成时间
	
	private List<OrderInfosDetail> detailList;
	
	//... get  set


订单明细pojo类：

public class OrderInfosDetail {

	private String id;
	private String color;				//颜色
	private String size;				//尺寸
	private Double unitPrice;			//价格
	private Integer quantity;			//数量
	private Double totalSum;			//总金额
	//... get  set


配置文件内容：

<resultMap type="orderInfos" id="oneToManyFindOrderMap">
		<!-- 映射订单信息 
		id:指定查询列中的唯一标识，如果有组合主键，则配置对个id
		-->
		<id column="id" property="id"/>
		<result column="orderNo" property="orderNo"/>
		<result column="mark" property="mark"/>
		<result column="address" property="address"/>
		<result column="createTime" property="createTime"/>
		
		<!-- 订单所对应的用户信息 -->
		<!-- association：用于映射关联查询单个对象的信息
			property：要讲关联查询的用户信息映射到订单pojo列中的哪个属性里
			javaType:表示关联查询的对象类型（可以使用别名）
		 -->
		<association property="user" javaType="pojo.User">
			<id column="user_id" property="id"/>
			<result column="userName" property="userName"/>
			<result column="sex" property="sex"/>
			<result column="birthday" property="birthday"/>
			<result column="password" property="password"/>
		</association>
		
		<!-- 获取订单明细信息,一个订单关联查询出多条明细，要使用collection来进行映射 -->
		<!-- collection：对关联查询到的多条记录进行映射
			property：要讲关联查询的明细信息映射到订单pojo列中的哪个属性里
			ofType:指要映射到集合属性中pojo的类型
		 -->
		<collection property="detailList" ofType="orderInfosDetail">
			<id column="detailId" property="id"/>
			<result column="quantity" property="quantity"/>
			<result column="color" property="color"/>
			<result column="unitPrice" property="unitPrice"/>
		</collection>
	</resultMap>
	
	<select id="oneToManyFindOrder" resultMap="oneToManyFindOrderMap">
		select A.*,B.userName,B.sex,B.birthday,B.`password`,C.id detailId,C.quantity,C.color,C.unitPrice
		from tab_orderinfos as A
		inner join tab_user as B on A.user_id=B.id
		left join tab_orderinfosdetail as C on A.id=C.orderInfos_id
	</select>

这里我们发现订单信息与用户信息的配置，跟上面的一对一里的配置一样。这种情况可以使用继承，就不需要再进行配置了。

使用extends属性设置了继承以后，配置文件内容变为：

<resultMap type="orderInfos" id="oneToManyFindOrderMap" extends="findOrderMap">
		<!-- 获取订单明细信息,一个订单关联查询出多条明细，要使用collection来进行映射 -->
		<!-- collection：对关联查询到的多条记录进行映射
			property：要讲关联查询的明细信息映射到订单pojo列中的哪个属性里
			ofType:指要映射到集合属性中pojo的类型
		 -->
		<collection property="detailList" ofType="orderInfosDetail">
			<id column="detailId" property="id"/>
			<result column="quantity" property="quantity"/>
			<result column="color" property="color"/>
			<result column="unitPrice" property="unitPrice"/>
		</collection>
	</resultMap>
	
	<select id="oneToManyFindOrder" resultMap="oneToManyFindOrderMap">
		select A.*,B.userName,B.sex,B.birthday,B.`password`,C.id detailId,C.quantity,C.color,C.unitPrice
		from tab_orderinfos as A
		inner join tab_user as B on A.user_id=B.id
		left join tab_orderinfosdetail as C on A.id=C.orderInfos_id
	</select>


多对多关联查询

多多对多的关联查询其实都是基于多对一，一对多的基础上进行配置的。

会了一对一、一对多，多对多也就会了。这里不再多说。


延迟加载

什么是延迟加载？就是需要用到的时候再进行查询，这就是延迟加载。
mybatis里association和collection都支持延迟加载。
这里就拿association来测试一下，collection用法一样。
需要说明的是，延迟加载跟上面所说的一对一、一对多的查询开发方式是不一样的。上面的查询都是实时的查询出所有的数据，不是延迟加载。
针对上面所说的一对一，我们来实现一下它的延迟加载。
此时需要配置两个sql配置：
（1）查询订单信息
（2）根据订单信息中的user_id，去查询对应的用户信息
最后的配置文件内容如下： 
<resultMap type="orderInfos" id="lazyMap">
		<!-- 映射订单信息 -->
		<id column="id" property="id"/>
		<result column="orderNo" property="orderNo"/>
		<result column="mark" property="mark"/>
		<result column="address" property="address"/>
		<result column="createTime" property="createTime"/>
		<!-- 延迟加载订单所对应的用户信息 
			select:指定延迟加载需要执行的sql配置id
			column:订单信息中关联查询用户信息的列（说白了，就是说订单表中是根据那个列去查询用户信息的）
		-->
		<association property="user" javaType="pojo.User" select="lazyFindUserById" column="user_id"></association>
	</resultMap>
	
	<!-- 查询订单信息,用户信息需要延迟加载,因为延迟加载是在association或collection中才能实现，所以这里需要使用resultMap来做映射 -->
	<select id="findOrderAll" resultMap="lazyMap">
		select * from tab_orderinfos
	</select>
	
	<!-- 根据id查询用户信息 -->
	<select id="lazyFindUserById" parameterType="java.lang.String" resultType="user">
		select * from tab_user where id=#{id}
	</select>

注意：mybatis默认是不开启延迟加载的。所以我们需要在sqlMapConfig.xml的settings里配置开启延迟加载。具体的settings的信息请看文档《3.1.2 settings》
在sqlMapConfig.xml配置settings开启延迟加载： 
<settings>
		<!-- 开启延迟加载 
		lazyLoadingEnabled:全局配置懒加载，如果设置为false，则所有关联查询都会被初始化加载。默认值是fasle。所以这里要设为true
		aggressiveLazyLoading:当设置为true时，会对全部查询发出sql了。所以我们应该要设置为false。为false时，需要用什么就查询什么，按需加载。默认值是true
		-->
		<setting name="lazyLoadingEnabled" value="true"/>
		<setting name="aggressiveLazyLoading" value="false"/>
	</settings>

测试类： 
@Test
	public void test() throws Exception {
		//获取代理对象
		OrderMapper orderMapper = (OrderMapper) context.getBean("orderMapper");
		
		
		List<OrderInfos> list =  orderMapper.findOrderAll();
		
		for(OrderInfos order :list){
			User user = order.getUser();
			System.out.println(user.getUserName());
		}
		
		System.out.println(list);
				
	}

}
结果： 
2016-04-04 16:16:04,370 [main] DEBUG [mapper.OrderMapper.findOrderAll] - ==>  Preparing: select * from tab_orderinfos 
  2016-04-04 16:16:04,418 [main] DEBUG [mapper.OrderMapper.findOrderAll] - ==> Parameters: 
  2016-04-04 16:16:04,980 [main] DEBUG [mapper.OrderMapper.findOrderAll] - <==      Total: 22
  2016-04-04 16:16:04,987 [main] DEBUG [org.mybatis.spring.SqlSessionUtils] - Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@4fb686]
  2016-04-04 16:16:04,987 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Returning JDBC Connection to DataSource
  2016-04-04 16:16:18,278 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Fetching JDBC Connection from DataSource
  2016-04-04 16:16:18,279 [main] DEBUG [org.mybatis.spring.transaction.SpringManagedTransaction] - JDBC Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@104f568 [wrapping: com.mysql.jdbc.JDBC4Connection@1bd7522]] will not be managed by Spring
  2016-04-04 16:16:18,281 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - ==>  Preparing: select * from tab_user where id=? 
  2016-04-04 16:16:18,284 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - ==> Parameters: 2c9381ed460abc1101460abddf830000(String)
  2016-04-04 16:16:18,302 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - <==      Total: 1
  2016-04-04 16:16:18,303 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Returning JDBC Connection to DataSource
  abc
2016-04-04 16:16:30,678 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Fetching JDBC Connection from DataSource
  2016-04-04 16:16:30,679 [main] DEBUG [org.mybatis.spring.transaction.SpringManagedTransaction] - JDBC Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@43690f [wrapping: com.mysql.jdbc.JDBC4Connection@1bd7522]] will not be managed by Spring
  2016-04-04 16:16:30,681 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - ==>  Preparing: select * from tab_user where id=? 
  2016-04-04 16:16:30,684 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - ==> Parameters: 2c9381ed460abc1101460abddf830000(String)
  2016-04-04 16:16:30,702 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - <==      Total: 1
  2016-04-04 16:16:30,703 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Returning JDBC Connection to DataSource
  abc
2016-04-04 16:16:41,684 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Fetching JDBC Connection from DataSource
  2016-04-04 16:16:41,685 [main] DEBUG [org.mybatis.spring.transaction.SpringManagedTransaction] - JDBC Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@160e1bb [wrapping: com.mysql.jdbc.JDBC4Connection@1bd7522]] will not be managed by Spring
  2016-04-04 16:16:41,685 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - ==>  Preparing: select * from tab_user where id=? 
  2016-04-04 16:16:41,685 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - ==> Parameters: 2c9381ed460abc1101460abddf830000(String)
  2016-04-04 16:16:41,689 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - <==      Total: 1
  2016-04-04 16:16:41,690 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Returning JDBC Connection to DataSource
  abc
2016-04-04 16:16:41,690 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Fetching JDBC Connection from DataSource
  2016-04-04 16:16:41,690 [main] DEBUG [org.mybatis.spring.transaction.SpringManagedTransaction] - JDBC Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@163eb77 [wrapping: com.mysql.jdbc.JDBC4Connection@1bd7522]] will not be managed by Spring
  2016-04-04 16:16:41,690 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - ==>  Preparing: select * from tab_user where id=? 
  2016-04-04 16:16:41,691 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - ==> Parameters: 2c9381ed460abc1101460abddf830000(String)
  2016-04-04 16:16:41,695 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - <==      Total: 1
  2016-04-04 16:16:41,696 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Returning JDBC Connection to DataSource
  abc
2016-04-04 16:16:41,696 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Fetching JDBC Connection from DataSource
  2016-04-04 16:16:41,696 [main] DEBUG [org.mybatis.spring.transaction.SpringManagedTransaction] - JDBC Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@edd5f4 [wrapping: com.mysql.jdbc.JDBC4Connection@1bd7522]] will not be managed by Spring
  2016-04-04 16:16:41,697 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - ==>  Preparing: select * from tab_user where id=? 
  2016-04-04 16:16:41,698 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - ==> Parameters: 2c9381ed460abc1101460abddf830000(String)
  2016-04-04 16:16:41,702 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - <==      Total: 1
  2016-04-04 16:16:41,702 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Returning JDBC Connection to DataSource
  abc
2016-04-04 16:16:41,702 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Fetching JDBC Connection from DataSource
  2016-04-04 16:16:41,702 [main] DEBUG [org.mybatis.spring.transaction.SpringManagedTransaction] - JDBC Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@b759cd [wrapping: com.mysql.jdbc.JDBC4Connection@1bd7522]] will not be managed by Spring
  2016-04-04 16:16:41,702 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - ==>  Preparing: select * from tab_user where id=? 
  2016-04-04 16:16:41,703 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - ==> Parameters: 2c9381ed460abc1101460abddf830000(String)
  2016-04-04 16:16:41,705 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - <==      Total: 1
  2016-04-04 16:16:41,705 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Returning JDBC Connection to DataSource
  abc
2016-04-04 16:16:41,705 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Fetching JDBC Connection from DataSource
  2016-04-04 16:16:41,705 [main] DEBUG [org.mybatis.spring.transaction.SpringManagedTransaction] - JDBC Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@1497c25 [wrapping: com.mysql.jdbc.JDBC4Connection@175982a]] will not be managed by Spring
  2016-04-04 16:16:41,705 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - ==>  Preparing: select * from tab_user where id=? 
  2016-04-04 16:16:41,706 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - ==> Parameters: 2c9381ed460abc1101460abddf830000(String)
  2016-04-04 16:16:41,727 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - <==      Total: 1
  2016-04-04 16:16:41,727 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Returning JDBC Connection to DataSource
  abc
2016-04-04 16:16:41,728 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Fetching JDBC Connection from DataSource
  2016-04-04 16:16:41,728 [main] DEBUG [org.mybatis.spring.transaction.SpringManagedTransaction] - JDBC Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@1825bfb [wrapping: com.mysql.jdbc.JDBC4Connection@175982a]] will not be managed by Spring
  2016-04-04 16:16:41,728 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - ==>  Preparing: select * from tab_user where id=? 
  2016-04-04 16:16:41,728 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - ==> Parameters: 2c9381ed460abc1101460abddf830000(String)
  2016-04-04 16:16:41,731 [main] DEBUG [mapper.OrderMapper.lazyFindUserById] - <==      Total: 1
  2016-04-04 16:16:41,731 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Returning JDBC Connection to DataSource
  abc

通过上面的日志打印，可以很清楚的看到，在for循环遍历订单信息时，当我们使用getUser（）时，才发出sql，查询数据获取结果。这样就实现了延迟加载。








cwh056056
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis中的高级映射一对一、一对多、多对多
09-01
在Mybatis中，高级映射是处理复杂关系的重要手段，主要包括一对一、一对多和多对多这三种映射关系。这些映射关系在实际的业务场景中非常常见，例如在订单系统中，订单与商品之间的关系可能是一对多，商品与属性之间...
mybatis关系映射之一对多和多对一
08-26
MyBatis关系映射之一对多和多对一 MyBatis是一款流行的Java持久化框架，提供了丰富的关系映射功能。关系映射是指在数据库中建立实体之间的关联关系，例如，一对多、多对一、多对多等。今天，我们将探讨MyBatis关系...
MyBatis 一对一，一对多，多对一，多对多详解
小鱼星空的博客
11-24 4739
目录 1、什么是MyBatis? 2、MyBatis 入门实例基于xml配置 3、MyBatis 入门实例注解配置 4、MyBatis 入门实例 一对一 基于xml配置 4、MyBatis 入门实例 一对多，多对一 基于xml配置 5、MyBatis 入门实例 多对多 基于xml配置 1、什么是MyBatis? MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为My
MyBatis实现一对一、一对多查询
weixin_45914112的博客
03-22 3120
Mybatis一对一查询，一对多查询
Mybatis实现一对一
xiao-啸
03-17 1324
Mybatis实现一对一 项目结构 配置文件 pom.xml <?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" ...
MyBatis实现多表的一对一、一对多、多对多关联查询
pan_junbiao的博客
12-13 6146
MyBatis是一个基于数据库映射的框架，本文将介绍如何使用MyBatis处理多张数据库表之间的关联关系。 1、一对一查询 一对一外键关联的配置比较简单，以公民实体对象和身份证实体对象为例，在表tab_people（公民表）中添加一个字段“card_id”，作为该表的外键，同时需要保证该字段的唯一性，否则就不是一对一映射关系了，而是一对多映射关系。表tab_people和tab_idcard（...
【笔记】Mybatis高级查询（四）--使用resultMap的<collection>标签实现一对多和多对多查询
q283614346的博客
10-21 5671
&amp;amp;amp;amp;lt;collection&amp;amp;amp;amp;gt;集合的嵌套结果映射就是指通过一次SQL查询将所有的结果查询出来，然后映射到不同的对象中。在一对多的关系中，主表一条数据会对应关联表的多条数据。因此一般查询时会查询出多条结果，按照一对多的数据映射时，最终的结果数会小于等于查询的总记录数。 在RBAC权限系统中一个用户拥有多个角色，一个角色又拥有多个权限。以下例子通过嵌套查询查出某个用户及用户角色。 1. ...
mybatis高级映射一对多查询实现代码
08-30
在MyBatis中，高级映射是一门技术，它允许我们处理复杂的数据库查询结果，包括一对多、多对一和一对一的关系映射。本篇文章主要关注的是一对多的映射，即一个订单可能包含多个订单明细的情况。下面将详细阐述如何在...
Mybatis一对多关联关系映射实现过程解析
08-25
Mybatis的一对多关联关系映射实现过程解析 Mybatis是一款基于Java的持久层框架，它提供了对数据库的操作接口，包括数据的增删改查等操作。在实际开发中，我们经常会遇到一对多关联关系映射的问题，例如用户和订单...
Mybatis一对一一多映射.rar
09-22
在MyBatis框架中，一对多和一对一映射是数据对象关系映射的重要概念，用于处理数据库中的关联关系。在本资源包"Mybatis一对一一多映射.rar"中，我们主要探讨这两个映射方式以及如何在MyBatis配置中实现它们。 首先...
Mybatis 一对一、一对多、多对多
最新发布
Xiang想
01-12 526
基于配置文件的Mybatis复杂映射开发，一对一、一对多、多对多场景
MyBatis——使用 resultMap 配置一对一、一对多关系详解
suitianshuang
09-13 7896
MyBatis——使用resultMap 映射一对一、一对多问题详解 ##### 1. MyBaits简介 > MyBatis 是一个优秀的持久层框架，它对 jdbc 的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需 要花费精力去处理例如注册驱动、创建 connection、创建 statement、手动设 置参数、结果集检索等 jdbc 繁杂的过程代码。Mybatis 通过 xml 或注解的方 式将要执行的各种 statement(statement、preparedStat
mybatis：javaType和ofType的区别
qq_52117632的博客
02-06 1218
mybatis：javaType和ofType的区别。
Mybatis的一对一、一对多以及多对多
weixin_44764019的博客
12-10 3041
一、前言 之前自学了Mybatis框架，但实在搞不明白这些一对多、多对多之间的关系，前段时间，自己开发了个小项目，用到mybatis，才算彻底搞明白，结合案例来说明下，在看这个之前，必须知道ResultMap。 二、一对一 当我们播放歌曲时，需要显示这首歌所对应的专辑的图片，所以我们在查询歌曲的时候，需要把它对应的专辑信息来查询出来 1. 歌曲类 public class Song { private Integer songId; private String songName;
MyBatis 详解（一对一，一对多，多对多）
Detemination的博客
03-06 1490
MyBatis 详解（一对一，一对多，多对多） - YSOcean - 博客园 <link rel="stylesheet" href="/css/blog-common.min.css?v=B_5UVCW8qI0lb4V0JCXKUmP6qqTWWtz1MVIkW-DhBkg" /> <link type="text/css" rel="stylesheet" href="https:...
20Mybatis_订单商品数据模型_一对一查询——resultType和resultMap两种方式以及两种方式的总结...
weixin_34023863的博客
08-18 92
上一篇文章分析了数据模型，这篇文章就给出一个需求，这个需求是一对一查询，并完成这个需求。   -------------------------------------------------------------------------------------------------------------------------------------------- 需求：     ...
MyBatisPlus 一对多、多对一、多对多的解决方案
热门推荐
07-19 4万+
在学些MyBatisPlus 时，简单的查询非常简单只要继承了相关类，就能够进行增删改。但是在实际运用时对象之间的关系非常复杂，一对多、多对一、多对多。网上查询了大量质量都无法解决此问题。难道要把所有的用Mybatis的重写一次，重写一次Plus的方法还能不能用。实在没办只能查看官网https://mp.baomidou.com/guide/在注解处找到了可能的解决方案 @TableName注解...
【MyBatis学习15】mybatis-generator生成逆向工程两种方式
程序老兵的博客
03-21 2万+
本文博客地址：http://blog.csdn.net/soonfly/article/details/64499423 （转载请注明出处） mybatis官方提供了一个逆向工程包，可以针对数据库表自动生成mybatis执行所需要的Pojo、Mapper xml文件、Mapper Interface接口文件。 mybatis-generator有很多种用法：命令行、eclipse/IDEA、Mav
mybatis一对多多对一的映射关系
m0_54067126的博客
12-18 585
一.一对多 一.用逆向工程生成实体类/mapper接口/mapper.xml generatorConfig.xml 用的是订单和订单项来来表示一对多和多对一的关系 目标 传入订单id查询到订单本身以及订单本身所对应的所有订单项 传入订单项id查询到订单项本身以及订单项本身所对应的订单 二.建vo类 但是订单和订单实体类里面并没有这么多字段所以我们需要建一个vo类 订单里面包含了订单id和订单名称但是没有订单所对应的订单详细信息 所以新建订单的vo类 继承订单类 有一个订单项的集合的属性 因为一个订单对应
Mybatis高级映射：一对一、一对多解析
在MyBatis中，高级映射是核心功能之一，它涵盖了多种数据关系的处理，如一对一、一对多、多对多的映射，还包括延迟加载和查询缓存等特性。这些映射机制允许开发者更加灵活地处理数据库查询结果，并将其转换为Java...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值