MyBatis（四）MyBatis关联（级联）查询
MyBatis 目录
- MyBatis（一）MyBatis初识 - 青杉 - 博客园 (cnblogs.com)
- MyBatis（二）MyBatis标签 - 青杉 - 博客园 (cnblogs.com)
- MyBatis（三）MyBatis resultMap和注解 - 青杉 - 博客园 (cnblogs.com)
- MyBatis（四）MyBatis关联（级联）查询 - 青杉 - 博客园 (cnblogs.com)
- MyBatis（五）MyBatis动态SQL - 青杉 - 博客园 (cnblogs.com)
MyBatis关联（级联）查询
级联关系是一个数据库实体的概念，有 3 种级联关系，分别是一对一级联、一对多级联以及多对多级联。例如，一个角色可以分配给多个用户，也可以只分配给一个用户。大部分场景下，我们都需要获取角色信息和用户信息，所以会经常遇见以下 SQL。s
SELECT r.*,u.* FROM t_role r
INNER JOIN t_user_role ur ON r.id = ur.id
INNER JOIN t_user u ON ur.user_id = u.id
WHERE r.id = #{id}
在级联中存在 3 种对应关系。
- 一对多的关系，如角色和用户的关系。通俗的理解就是，一家软件公司会存在许多软件工程师，公司和软件工程师就是一对多的关系。
- 一对一的关系。每个软件工程师都有一个编号（ID），这是他在公司的标识，它与工程师是一对一的关系。
- 多对多的关系，有些公司一个角色可以对应多个用户，但是一个用户可以兼任多个角色。通俗的说，一个人既可以是总经理，同时也是技术总监，而技术总监这个职位可以对应多个人，这就是多对多的关系。
MyBatis一对一关联查询
一对一级联关系在现实生活中是十分常见的，例如一个大学生只有一个学号，一个学号只属于一个学生。同样，人与身份证也是一对一的级联关系。
在 MyBatis 中，通过 <resultMap> 元素的子元素 <association> 处理一对一级联关系。示例代码如下。
<association property="studentCard" column="cardId"
javaType="org.mybatis.example.StudentCard"
select="org.mybatis.example.StudentCardMapper.selectStuCardById" />
在<association>元素中通常使用以下属性。
- property：指定映射到实体类的对象属性。
- column：指定表中对应的字段（即查询返回的列名）。
- javaType：指定映射到实体对象属性的类型。
- select：指定引入嵌套查询的子 SQL 语句，该属性用于关联映射中的嵌套查询。
一对一关联查询可采用以下两种方式：
- 单步查询，通过关联查询实现
- 分步查询，通过两次或多次查询，为一对一关系的实体 Bean 赋值
示例
下面以学生和学号为例讲解一对一关联查询的处理过程。
1.创建数据表
创建 student（学生）和 studentcard（学号）数据表，SQL 语句如下。
DROP TABLE IF EXISTS `studentcard`;
CREATE TABLE `studentcard` (
`id` int(20) NOT NULL AUTO_INCREMENT,
`studentId` int(20) DEFAULT NULL,
`startDate` date DEFAULT NULL,
`endDate` date DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `studentId` (`studentId`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;
insert into `studentcard`(`id`,`studentId`,`startDate`,`endDate`) values (1,20200311,'2021-03-01','2021-03-11'),(2,20200314,'2021-03-01','2021-03-11'),(3,20200709,'2021-03-01','2021-03-11'),(4,20200508,'2021-03-01','2021-03-11'),(5,20207820,'2021-03-01','2021-03-11');
CREATE TABLE `student` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(20) CHARACTER SET utf8 COLLATE utf8_unicode_ci DEFAULT NULL,
`sex` tinyint(4) DEFAULT NULL,
`cardId` int(20) DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `cardId` (`cardId`),
CONSTRAINT `student_ibfk_1` FOREIGN KEY (`cardId`) REFERENCES `studentcard` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
insert into `student`(`id`,`name`,`sex`,`cardId`) values (1,'C语言中文网',0,1),(2,'编程帮',0,2),(3,'赵小红',1,3),(4,'李晓明',0,4),(5,'李紫薇',1,5),(6,'钱百百',0,NULL);
2. 创建持久化类
关于Lombok的介绍：Lombok介绍、使用方法和总结 - 猿人谷 - 博客园 (cnblogs.com)
在应用的org.mybatis.example包下创建数据表对应的持久化类 Student 和 StudentCard。
package org.mybatis.example;
import lombok.Data;
import lombok.ToString;
@Data
@ToString
public class Student {
private int id;
private String name;
private int sex;
private StudentCard studentCard;
}
package org.mybatis.example;
import lombok.Data;
import lombok.ToString;
import java.util.Date;
@Data
@ToString
public class StudentCard {
private int id;
private int studentId;
private Date startDate;
private Date endDate;
}
3.分步查询
新建 StudentCardMapper 接口，代码如下。
package org.mybatis.example;
public interface StudentCardMapper {
StudentCard selectStuCardById(int id);
}
在resources->mapper新建 StudentCardMapper.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="org.mybatis.example.StudentCardMapper">
<select id="selectStuCardById"
resultType="org.mybatis.example.StudentCard">
SELECT * FROM studentCard WHERE id = #{id}
</select>
</mapper>
StudentMapper 接口方法代码如下。
package org.mybatis.example;
public interface StudentMapper {
Student selectStuById1(int id);
Student selectStuById2(int id);
}
StudentMapper.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="org.mybatis.example.StudentMapper">
<!-- 一对一根据id查询学生信息：级联查询的第一种方法（嵌套查询，执行两个SQL语句） -->
<resultMap type="org.mybatis.example.Student" id="cardAndStu1">
<id property="id" column="id" />
<result property="name" column="name" />
<result property="sex" column="sex" />
<!-- 一对一级联查询 -->
<association property="studentCard" column="cardId"
javaType="org.mybatis.example.StudentCard"
select="org.mybatis.example.StudentCardMapper.selectStuCardById" />
</resultMap>
<select id="selectStuById1" parameterType="Integer"
resultMap="cardAndStu1">
select * from student where id=#{id}
</select>
</mapper>
4. 创建配置文件
在resources文件夹下新建 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.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/jdbc_test?characterEncoding=utf8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="mapper/StudentCardMapper.xml"/>
<mapper resource="mapper/StudentMapper.xml"/>
</mappers>
</configuration>
5.测试
MainApplication
package org.mybatis.example;
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 java.io.IOException;
import java.io.InputStream;
public class MainApplication {
public static void main(String[] args) throws IOException {
InputStream config = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory ssf = new SqlSessionFactoryBuilder().build(config);
SqlSession ss = ssf.openSession();
Student stu = ss.getMapper(StudentMapper.class).selectStuById1(2);
System.out.println(stu);
}
}
Student(id=2, name=编程帮, sex=0, studentCard=StudentCard(id=2, studentId=20200314, startDate=Mon Mar 01 00:00:00 CST 2021, endDate=Thu Mar 11 00:00:00 CST 2021))
6.打印sql
开启控制台sql语句打印的多种方式
在mybatis的配置文件中添加：
<settings>
<!-- 打印sql日志 -->
<setting name="logImpl" value="STDOUT_LOGGING" />
</settings>
mybatis的配置文件----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>
<settings>
<!-- 打印sql日志 -->
<setting name="logImpl" value="STDOUT_LOGGING" />
</settings>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/jdbc_test?characterEncoding=utf8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="mapper/StudentCardMapper.xml"/>
<mapper resource="mapper/StudentMapper.xml"/>
</mappers>
</configuration>
运行输出如下
==> Preparing: select * from student where id=?
==> Parameters: 2(Integer)
<== Columns: id, name, sex, cardId
<== Row: 2, 编程帮, 0, 2
====> Preparing: SELECT * FROM studentCard WHERE id = ?
====> Parameters: 2(Integer)
<==== Columns: id, studentId, startDate, endDate
<==== Row: 2, 20200314, 2021-03-01, 2021-03-11
<==== Total: 1
<== Total: 1
Student(id=2, name=编程帮, sex=0, studentCard=StudentCard(id=2, studentId=20200314, startDate=Mon Mar 01 00:00:00 CST 2021, endDate=Thu Mar 11 00:00:00 CST 2021))
由于我们使用的分布查询 所以执行了两次sql语句
7.单步查询
修改StudentMapper.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="org.mybatis.example.StudentMapper">
<!-- 一对一根据id查询学生信息：级联查询的第一种方法（嵌套查询，执行两个SQL语句） -->
<resultMap type="org.mybatis.example.Student" id="cardAndStu1">
<id property="id" column="id" />
<result property="name" column="name" />
<result property="sex" column="sex" />
<!-- 一对一级联查询 -->
<association property="studentCard" javaType="org.mybatis.example.StudentCard">
<id property="id" column="id" />
<result property="studentId" column="studentId" />
</association>
</resultMap>
<select id="selectStuById1" parameterType="Integer"
resultMap="cardAndStu1">
SELECT s.*,sc.studentId FROM student s,studentCard sc
WHERE
s.cardId = sc.id AND s.id=#{id}
</select>
</mapper>
输出结果
==> Preparing: SELECT s.*,sc.studentId FROM student s,studentCard sc WHERE s.cardId = sc.id AND s.id=?
==> Parameters: 2(Integer)
<== Columns: id, name, sex, cardId, studentId
<== Row: 2, 编程帮, 0, 2, 20200314
<== Total: 1
Student(id=2, name=编程帮, sex=0, studentCard=StudentCard(id=2, studentId=20200314, startDate=null, endDate=null))
MyBatis一对多关联查询
在 MyBatis 中，通过 <resultMap> 元素的子元素 <collection> 处理一对多级联关系，collection 可以将关联查询的多条记录映射到一个 list 集合属性中。示例代码如下。
<collection property="orderList"
ofType="net.biancheng.po.Order" column="id"
select="net.biancheng.mapper.OrderMapper.selectOrderById" />
在<collection>元素中通常使用以下属性。
- property：指定映射到实体类的对象属性。
- column：指定表中对应的字段（即查询返回的列名）。
- javaType：指定映射到实体对象属性的类型。
- select：指定引入嵌套查询的子 SQL 语句，该属性用于关联映射中的嵌套查询。
一对多关联查询可采用以下两种方式：
- 分步查询，通过两次或多次查询，为一对多关系的实体 Bean 赋值
- 单步查询，通过关联查询实现
示例
下面以用户和订单为例讲解一对多关联查询（实现“根据 id 查询用户及其关联的订单信息”的功能）的处理过程。
1. 创建数据表
本实例需要两张数据表，一张是用户表 user，一张是订单表 order，这两张表具有一对多的级联关系。SQL 语句如下：
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(20) DEFAULT NULL,
`pwd` varchar(20) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
insert into `user`(`id`,`name`,`pwd`) values (1,'编程帮','123'),(2,'C语言中文网','456'),(3,'赵小红','123'),(4,'李晓明','345'),(5,'杨小胤','123'),(6,'谷小乐','789');
CREATE TABLE `order` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`ordernum` int(25) DEFAULT NULL,
`userId` int(11) DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `userId` (`userId`),
CONSTRAINT `order_ibfk_1` FOREIGN KEY (`userId`) REFERENCES `user` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;
insert into `order`(`id`,`ordernum`,`userId`) values (1,20200107,1),(2,20200806,2),(3,20206702,3),(4,20200645,1),(5,20200711,2),(6,20200811,2),(7,20201422,3),(8,20201688,4);
2. 创建持久化类
创建持久化类 User 和 Order，代码分别如下。
package org.mybatis.example;
import lombok.Data;
import lombok.ToString;
import java.util.List;
@Data
@ToString
public class User {
private int id;
private String name;
private String pwd;
private List<Order> orderList;
}
package org.mybatis.example;
import lombok.Data;
import lombok.ToString;
@Data
@ToString
public class Order {
private int id;
private int ordernum;
}
3.查询
分布查询
OrderMapper 接口代码如下
package org.mybatis.example;
import java.util.List;
public interface OrderMapper {
List<Order> selectOrderById(int id);
}
OrderMapper.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="org.mybatis.example.OrderMapper">
<!-- 根据id查询订单信息 -->
<select id="selectOrderById" resultType="org.mybatis.example.Order"
parameterType="Integer">
SELECT * FROM `order` where userId=#{id}
</select>
</mapper>
UserMapper
package org.mybatis.example;
public interface UserMapper {
User selectUserOrderById1(int id);
}
UserMapper.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="org.mybatis.example.UserMapper">
<!-- 一对多 根据id查询用户及其关联的订单信息：级联查询的第一种方法（分步查询） -->
<resultMap type="org.mybatis.example.User" id="userAndOrder1">
<id property="id" column="id" />
<result property="name" column="name" />
<result property="pwd" column="pwd" />
<!-- 一对多级联查询，ofType表示集合中的元素类型，将id传递给selectOrderById -->
<collection property="orderList"
ofType="org.mybatis.example.Order" column="id"
select="org.mybatis.example.OrderMapper.selectOrderById" />
</resultMap>
<select id="selectUserOrderById1" parameterType="Integer"
resultMap="userAndOrder1">
select * from user where id=#{id}
</select>
</mapper>
在配置文件中添加mapper扫描
<mappers>
<mapper resource="mapper/OrderMapper.xml"/>
<mapper resource="mapper/UserMapper.xml"/>
</mappers>
测试代码如下
public class Test {
public static void main(String[] args) throws IOException {
InputStream config = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory ssf = new SqlSessionFactoryBuilder().build(config);
SqlSession ss = ssf.openSession();
User us = ss.getMapper(UserMapper.class).selectUserOrderById1(1);
System.out.println(us);
}
}
输出
==> Preparing: select * from user where id=?
==> Parameters: 1(Integer)
<== Columns: id, name, pwd
<== Row: 1, 编程帮, 123
====> Preparing: SELECT * FROM `order` where userId=?
====> Parameters: 1(Integer)
<==== Columns: id, ordernum, userId
<==== Row: 1, 20200107, 1
<==== Row: 4, 20200645, 1
<==== Total: 2
<== Total: 1
User(id=1, name=编程帮, pwd=123, orderList=[Order(id=1, ordernum=20200107), Order(id=4, ordernum=20200645)])
单步查询
该种方式实现一对多关联查询需要修改 Order 持久化类，因为 Order 中的 id 不能和 User 中的 id 重复。
package org.mybatis.example;
import lombok.Data;
import lombok.ToString;
@Data
@ToString
public class Order {
private int oId;
private int ordernum;
}
UserMapper 类代码如下。
User selectUserOrderById1(int id);
UserMapper.xml 中相关映射 SQL 语句如下。
<?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="org.mybatis.example.UserMapper">
<!-- 一对多 根据id查询用户及其关联的订单信息：级联查询的第一种方法（分步查询） -->
<resultMap type="org.mybatis.example.User" id="userAndOrder1">
<id property="id" column="id" />
<result property="name" column="name" />
<result property="pwd" column="pwd" />
<!-- 一对多级联查询，ofType表示集合中的元素类型，将id传递给selectOrderById -->
<collection property="orderList"
ofType="org.mybatis.example.Order">
<id property="oId" column="oId" />
<result property="ordernum" column="ordernum" />
</collection>
</resultMap>
<select id="selectUserOrderById1" parameterType="Integer"
resultMap="userAndOrder1">
SELECT u.*,o.id as oId,o.ordernum FROM `user` u,`order` o
WHERE
u.id=o.`userId` AND u.id=#{id}
</select>
</mapper>
测试运行如下
==> Preparing: SELECT u.*,o.id as oId,o.ordernum FROM `user` u,`order` o WHERE u.id=o.`userId` AND u.id=?
==> Parameters: 1(Integer)
<== Columns: id, name, pwd, oId, ordernum
<== Row: 1, 编程帮, 123, 1, 20200107
<== Row: 1, 编程帮, 123, 4, 20200645
<== Total: 2
User(id=1, name=编程帮, pwd=123, orderList=[Order(oId=1, ordernum=20200107), Order(oId=4, ordernum=20200645)])
MyBatis多对多关联查询
实际应用中，由于多对多的关系比较复杂，会增加理解和关联的复杂度，所以应用较少。MyBatis 没有实现多对多级联，推荐通过两个一对多级联替换多对多级联，以降低关系的复杂度，简化程序。
例如，一个订单可以有多种商品，一种商品可以对应多个订单，订单与商品就是多对多的级联关系。可以使用一个中间表（订单记录表）将多对多级联转换成两个一对多的关系。
下面以订单和商品（实现“查询所有订单以及每个订单对应的商品信息”的功能）为例讲解多对多关联查询。
1. 创建数据表
创建 order（订单），product（商品）和 order_details（订单和商品中间表），SQL 语句如下。
DROP TABLE IF EXISTS `order`;
CREATE TABLE `order` (
`oid` int(11) NOT NULL AUTO_INCREMENT,
`ordernum` int(25) DEFAULT NULL,
`userId` int(11) DEFAULT NULL,
PRIMARY KEY (`oid`),
KEY `userId` (`userId`),
CONSTRAINT `order_ibfk_1` FOREIGN KEY (`userId`) REFERENCES `user` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8;
insert into `order`(`oid`,`ordernum`,`userId`) values (1,20200107,1),(2,20200806,2),(3,20206702,3),(4,20200645,1),(5,20200711,2),(6,20200811,2),(7,20201422,3),(8,20201688,4),(9,NULL,5);
DROP TABLE IF EXISTS `orders_detail`;
CREATE TABLE `orders_detail` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`orderId` int(11) DEFAULT NULL,
`productId` int(11) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
insert into `orders_detail`(`id`,`orderId`,`productId`) values (1,1,1),(2,1,2),(3,1,3),(4,2,3),(5,2,1),(6,3,2);
DROP TABLE IF EXISTS `product`;
CREATE TABLE `product` (
`pid` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(25) DEFAULT NULL,
`price` double DEFAULT NULL,
PRIMARY KEY (`pid`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;
insert into `product`(`pid`,`name`,`price`) values (1,'Java教程',128),(2,'C语言教程',138),(3,'Python教程',132.35);
2.创建持久化类
Order 类代码如下。
package org.mybatis.example;
import lombok.Data;
import lombok.ToString;
import java.util.List;
@Data
@ToString
public class Order {
private int oid;
private int ordernum;
private List<Product> products;
}
Product 类方法如下。
package org.mybatis.example;
import lombok.Data;
import lombok.ToString;
import java.util.List;
@Data
@ToString
public class Product {
private int pid;
private String name;
private Double price;
// 多对多中的一个一对多
private List<Order> orders;
}
3.创建接口和映射文件
OrderMapper 接口代码如下。
package org.mybatis.example;
import java.util.List;
public interface OrderMapper {
List<Order> selectAllOrdersAndProducts();
}
OrderMapper.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="org.mybatis.example.OrderMapper">
<resultMap type="org.mybatis.example.Order" id="orderMap">
<id property="oid" column="oid" />
<result property="ordernum" column="ordernum" />
<collection property="products"
ofType="org.mybatis.example.Product">
<id property="pid" column="pid" />
<result property="name" column="name" />
<result property="price" column="price" />
</collection>
</resultMap>
<select id="selectAllOrdersAndProducts" parameterType="Integer"
resultMap="orderMap">
SELECT o.oid,o.`ordernum`,p.`pid`,p.`name`,p.`price` FROM
`order` o
INNER JOIN orders_detail od ON o.oid=od.`orderId`
INNER JOIN
product p
ON p.pid = od.`productId`
</select>
</mapper>
配置文件添加
<mapper resource="mapper/OrderMapper.xml"/>
4. 测试
package org.mybatis.example;
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 java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class MainApplication {
public static void main(String[] args) throws IOException {
InputStream config = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory ssf = new SqlSessionFactoryBuilder().build(config);
SqlSession ss = ssf.openSession();
List<Order> orderList = ss.getMapper(OrderMapper.class).selectAllOrdersAndProducts();
for (Order or : orderList) {
System.out.println(or);
}
}
}
输出如下
==> Preparing: SELECT o.oid,o.`ordernum`,p.`pid`,p.`name`,p.`price` FROM `order` o INNER JOIN orders_detail od ON o.oid=od.`orderId` INNER JOIN product p ON p.pid = od.`productId`
==> Parameters:
<== Columns: oid, ordernum, pid, name, price
<== Row: 1, 20200107, 1, Java教程, 128.0
<== Row: 1, 20200107, 2, C语言教程, 138.0
<== Row: 1, 20200107, 3, Python教程, 132.35
<== Row: 2, 20200806, 3, Python教程, 132.35
<== Row: 2, 20200806, 1, Java教程, 128.0
<== Row: 3, 20206702, 2, C语言教程, 138.0
<== Total: 6
Order(oid=1, ordernum=20200107, products=[Product(pid=1, name=Java教程, price=128.0, orders=null), Product(pid=2, name=C语言教程, price=138.0, orders=null), Product(pid=3, name=Python教程, price=132.35, orders=null)])
Order(oid=2, ordernum=20200806, products=[Product(pid=3, name=Python教程, price=132.35, orders=null), Product(pid=1, name=Java教程, price=128.0, orders=null)])
Order(oid=3, ordernum=20206702, products=[Product(pid=2, name=C语言教程, price=138.0, orders=null)])
Process finished with exit code 0
