一对多 & 多对一 关联查询
数据库准备:
一个班级表,字段:班级ID + 班级名称
一个学生表,字段:学生ID + 学生姓名 + 所属的班级ID
# 班级表 班级ID+班级名称
CREATE TABLE t_clazz(
`id` INT(2) PRIMARY KEY AUTO_INCREMENT,
`name` VARCHAR(50)
);
INSERT INTO t_clazz(`name`)
VALUES
('Java01'),
('Java02'),
('Java03'),
('Java04'),
('Java05');
# 学生表 对应一个班级
CREATE TABLE t_student(
`id` INT(2) PRIMARY KEY AUTO_INCREMENT,
`name` VARCHAR(50),
`clazz_id` INT(2),
FOREIGN KEY(`clazz_id`) REFERENCES t_clazz(`id`)
);
# 插入学生信息
INSERT INTO t_student(`name`,`clazz_id`)
VALUES
('学员1',1),
('学员2',1),
('学员3',1),
('学员4',2),
('学员5',2),
('学员6',2),
('学员7',3),
('学员8',3),
('学员9',3),
('学员10',4),
('学员11',4),
('学员12',4),
('学员13',5),
('学员14',5),
('学员15',5);
为了保证演示整洁,重新建立一个模块演示
建立ORM实体类
班级类
一个班级中存在若干个学生
所以如果查询一个班级的全学生信息,应该使用集合容器存储学生的信息
package main.java.cn.dai.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.ibatis.type.Alias;
import java.util.List;
/**
* @author ArkD42
* @file Mybatis
* @create 2020 - 05 - 30 - 12:54
*/
@Alias("clazz")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Clazz {
private Integer id;
private String name;
private List<Student> students;
}
学生类
学生只能所属于一个班级之中,没有必要再关联
package main.java.cn.dai.pojo;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import org.apache.ibatis.type.Alias;
/**
* @author ArkD42
* @file Mybatis
* @create 2020 - 05 - 30 - 12:55
*/
@Alias("student")
@NoArgsConstructor
@AllArgsConstructor
public class Student {
private Integer id;
private String name;
}
核心配置文件
<?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="mybatis.properties"/>
<settings>
<!-- 日志实现 -->
<setting name="logImpl" value="LOG4J"/>
<!-- 映射驼峰命名 -->
<setting name="mapUnderscoreToCamelCase" value="true"/>
<!-- 开启懒加载 -->
<setting name="lazyLoadingEnabled" value="true"/>
<setting name="aggressiveLazyLoading" value="false"/>
</settings>
<typeAliases>
<package name="cn.dai.pojo"/>
</typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username:root}"/>
<property name="password" value="${password:123456}"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="mapper/ClazzMapper.xml"/>
<mapper resource="mapper/StudentMapper.xml"/>
</mappers>
</configuration>
查询SQL
SELECT
*
FROM
t_clazz LEFT JOIN
t_student
ON
t_clazz.id = t_student.clazz_id
WHERE
t_clazz.id = #{id}
但是我们根本分不清哪个是班级表的字段,那个是学生表的字段
应该从表引用选中字段进
t_clazz.*,t_student.id stu_id,t_student.name stu_name,t_student.clazz_id
映射接口
package cn.dai.mapper;
import cn.dai.pojo.Clazz;
/**
* @author ArkD42
* @file Mybatis
* @create 2020 - 05 - 30 - 13:06
*/
public interface ClazzMapper {
/**
* 根据班级ID查询,这个班级的信息,包括整个班级的全部学生的信息
* @param id
* @return
*/
Clazz queryClazzById(Integer id);
}
所以在映射器配置文件的配置是这样的
【使用集合表示一对多的多那个关系】
<?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接口名称-->
<mapper namespace="cn.dai.mapper.ClazzMapper">
<resultMap id="qcb" type="clazz">
<id column="id" property="id" />
<result column="name" property="name"/>
<!--
声明的是集合,用的也就是集合
property 属性是集合的标识
ofType 该集合元素所属的泛型属性
-->
<collection property="students" ofType="student">
<id column="id" property="id"/>
<result column="name"property="name" />
</collection>
</resultMap>
<select id="queryClazzById" parameterType="int" resultMap="qcb" >
SELECT
t_clazz.*,t_student.id stu_id,t_student.name stu_name
FROM
t_clazz LEFT JOIN
t_student
ON
t_clazz.id = t_student.clazz_id
WHERE
t_clazz.id = #{id}
</select>
</mapper>
测试类
import cn.dai.mapper.ClazzMapper;
import cn.dai.pojo.Clazz;
import cn.dai.util.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
/**
* @author ArkD42
* @file Mybatis
* @create 2020 - 05 - 30 - 13:36
*/
public class OneToManyTest {
@Test
public void queryClazzById(){
SqlSession sqlSession = MybatisUtil.getSqlSession(true);
ClazzMapper clazzMapper = sqlSession.getMapper(ClazzMapper.class);
Clazz clazz = clazzMapper.queryClazzById(3);
System.out.println(clazz);
sqlSession.close();
}
}
对象成功返回,但是输出个这个。。
原因可能在集合字段绑定的属性不对
更改一下
应该是这个问题了,成功打印出来
一对多的懒加载查询
新增一个查询的方法
【按班级ID查询这个班级的信息,和里面学生无关】
Clazz queryClazzByIdForTwoStep(Integer id);
跟08结果集映射中的一样,对一对多也可以实现一个懒加载的查询
然后对学生表也要设置映射接口,编写二次查询的方法
【按班级ID查询这个班级所有学生】
package cn.dai.mapper;
import cn.dai.pojo.Student;
import java.util.List;
/**
* @author ArkD42
* @file Mybatis
* @create 2020 - 05 - 30 - 13:53
*/
public interface StudentMapper {
List<Student> queryStudentsByClazzId(Integer id);
}
映射器:
学生表只需要这样
<?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接口名称-->
<mapper namespace="cn.dai.mapper.StudentMapper">
<select id="queryStudentsByClazzId" resultType="cn.dai.pojo.Student" >
SELECT
*
FROM
t_student
WHERE
clazz_id = #{clazz_id}
</select>
</mapper>
然后是班级表
<resultMap id="qcb2" type="clazz">
<!-- 同懒加载的查询一样,这个select属性的值写SQL查询 column传递值的列 -->
<collection
property="students"
column="id"
select="cn.dai.mapper.StudentMapper.queryStudentsByClazzId"
/>
</resultMap>
<select id="queryClazzByIdForTwoStep" parameterType="int" resultMap="qcb2" >
SELECT
id,name
FROM
t_clazz
WHERE
id = #{id}
</select>
测试类
import cn.dai.mapper.ClazzMapper;
import cn.dai.pojo.Clazz;
import cn.dai.util.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
/**
* @author ArkD42
* @file Mybatis
* @create 2020 - 05 - 30 - 13:36
*/
public class OneToManyTest {
@Test
public void queryClazzById(){
SqlSession sqlSession = MybatisUtil.getSqlSession(true);
ClazzMapper clazzMapper = sqlSession.getMapper(ClazzMapper.class);
Clazz clazz = clazzMapper.queryClazzByIdForTwoStep(3);
System.out.println(clazz);
sqlSession.close();
}
}
测试结果
如果全打印出来,就会发现班级表的主键列空了,
似乎作为参数,就不再返回给对象了
在我们懒加载开启的情况下,但只调用班级对象本身,学生集合是不会查询的
比如我们只打印班级名称,就只会查询一个表
System.out.println(clazz.getName());
但是要查询ID还是会这样为NULL
这个问题要排查一下到底是为什么了
还是跟之前的那个问题一样,必须要声明主键,否则默认不返回给对象
【Mybatis官方不是说好的默认可以不写吗。。。】
然后查询就有结果了
双向关联查询实现
通过学生表来查询所在班级信息
类似上面的懒加载查询,这也需要分两次完成
要建立关联,首先学生表也需要一个来自班级表的关联
新增一个由学生表查询的方法
List<Student> queryStudentsByClazzIdForTwoStep(Integer clazz_id);
【学生分两次查询,第二次用于查询班级】
对应的学生映射器配置
<resultMap id="rm01" type="student">
<id column="id" property="id"/>
<result column="name" property="name"/>
<!--
因为一个clazz
对应的只是一个班级
select 调用的是前面的班级映射接口的方法
column 传递的参数是这个班级ID
-->
<association
property="clazz"
select="cn.dai.mapper.ClazzMapper.queryClazzByIdForTwoStep"
column="clazz_id"
/>
</resultMap>
<select id="queryStudentsByClazzIdForTwoStep" resultMap="rm01" >
SELECT
id,name,clazz_id
FROM
t_student
WHERE
clazz_id = #{clazz_id}
</select>
同时班级映射器也需要更改一下
是对应调用结果查询,注释的方法是只按照班级ID查询
<resultMap id="qcb2" type="clazz">
<id column="id" property="id"/>
<!-- 同懒加载的查询一样,这个select属性的值写SQL查询 column传递值的列 -->
<collection
property="students"
column="id"
select="cn.dai.mapper.StudentMapper.queryStudentsByClazzIdForTwoStep"
/>
<!-- "cn.dai.mapper.StudentMapper.queryStudentsByClazzId"-->
</resultMap>
<select id="queryClazzByIdForTwoStep" parameterType="int" resultMap="qcb2" >
SELECT
id,name
FROM
t_clazz
WHERE
id = #{id}
</select>
测试类
@Test
public void queryClazzById2(){
SqlSession sqlSession = MybatisUtil.getSqlSession(true);
ClazzMapper clazzMapper = sqlSession.getMapper(ClazzMapper.class);
Clazz clazz = clazzMapper.queryClazzByIdForTwoStep(3);
System.out.println("班级名:" + clazz.getName() + "班级id:" + clazz.getName());
List<Student> students = clazz.getStudents();
for (Student student:students){
System.out.println("学号 " + student.getId() + "名字" + student.getName() +"所在班级" +student.getClazz().getName());
}
sqlSession.close();
}
注意我们测试类调用是查询的班级的这个部分,如果调用这个班级对象,就会造成内存溢出
请看我这样调用
然后测试结果就会堆溢出
为什么会造成这种错误?请回想之前我们为什么懒加载,分两次查询
因为如果不需要全部获取,那就只需要一部分的即可,也就是两次查询中的第一次
剩下的第二次,对象在不获取那个副表实体属性时,是不会调用的,这就是懒加载的神奇之处
所以这也就是为什么会堆溢出错误的原因
解决的办法有几种:
- 不调用toString,也就是不打印,就不会触发二次查询
- 设置结果集映射更改为结果集类型处理,但是一样会出现BUG,那就是空指针问题
【我不想因为一个BUG解决之后,还要再解决产生的第二个BUG,这么做不够优雅,所以第一个就行了】