一、创建表结构
1.学生表
SET NAMES utf8mb4; SET FOREIGN_KEY_CHECKS = 0; -- ---------------------------- -- Table structure for student -- ---------------------------- DROP TABLE IF EXISTS `student`; CREATE TABLE `student` ( `id` int(11) NOT NULL AUTO_INCREMENT, `Sname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL, `sex` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL, `age` int(11) DEFAULT NULL, `t_id` int(11) DEFAULT NULL, PRIMARY KEY (`id`) USING BTREE ) ENGINE = InnoDB AUTO_INCREMENT = 11 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact; -- ---------------------------- -- Records of student -- ---------------------------- INSERT INTO `student` VALUES (1, '张三', '男', 18, 1); INSERT INTO `student` VALUES (2, '李四', '女', 18, 1); INSERT INTO `student` VALUES (3, '王五', '男', 18, 1); INSERT INTO `student` VALUES (4, '小白', '女', 18, 1); INSERT INTO `student` VALUES (5, '小黑', '男', 18, 1); INSERT INTO `student` VALUES (6, '小红', '女', 20, 2); INSERT INTO `student` VALUES (7, '小李', '男', 20, 2); INSERT INTO `student` VALUES (8, '小张', '女', 20, 2); INSERT INTO `student` VALUES (9, '小赵', '男', 20, 2); INSERT INTO `student` VALUES (10, '小王', '女', 20, 2); SET FOREIGN_KEY_CHECKS = 1;2.老师表
SET NAMES utf8mb4; SET FOREIGN_KEY_CHECKS = 0; -- ---------------------------- -- Table structure for teacher -- ---------------------------- DROP TABLE IF EXISTS `teacher`; CREATE TABLE `teacher` ( `id` int(11) NOT NULL AUTO_INCREMENT, `Tname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL, PRIMARY KEY (`id`) USING BTREE ) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact; -- ---------------------------- -- Records of teacher -- ---------------------------- INSERT INTO `teacher` VALUES (1, '张老师'); INSERT INTO `teacher` VALUES (2, '李老师'); SET FOREIGN_KEY_CHECKS = 1;二、一对一、多对一
1.第一种形式 连表查询
SELECT student.id,student.name,teacher.name FROM student LEFT JOIN teacher on student.t_id = teacher.id①:设置实体类
public class Student { private Integer id; private String Sname; private String sex; private Integer age; private Integer t_id; //这个是重点 private Teacher teacher; }public class Teacher { private Integer id; private String Tname; }②:查询语句
<!-- 按照结果嵌套处理--> <select id="getStudent1" resultMap="StudentTeacher1"> SELECT student.id,student.Sname,teacher.Tname FROM student LEFT JOIN teacher on student.t_id = teacher.id </select> <resultMap id="StudentTeacher1" type="com.qcby.entity.Student"> <result property="id" column="id"/> <result property="Sname" column="Sname"/> <result property="sex" column="sex"/> <result property="age" column="age"/> <result property="t_id" column="t_id"/> <!-- 复杂的属性我们需要单独去处理 对象:association 集合：collection --> <!-- property="teacher" student类当中的关联字段 --> <!-- javaType="com.javen.model.Teacher" 为复杂属性设置类类型--> <association property="teacher" javaType="com.qcby.entity.Teacher"> <result property="id" column="id"/> <result property="Tname" column="Tname"/> </association> </resultMap>查询每个学生的对应的老师
2.第二种形式 分步查询
SELECT s.id,s.Sname,t.Tname FROM student s,teacher t where s.t_id = t.id①:设置实体类
这里的实体类不需要变动
②:查询语句
<select id = "getStudent" resultMap="StudentTeacher"> select * from student; </select> <!--结果映射集--> <resultMap id="StudentTeacher" type="com.qcby.entity.Student"> <result property="id" column="id"/> <result property="Sname" column="Sname"/> <result property="sex" column="sex"/> <result property="age" column="age"/> <result property="t_id" column="t_id"/> <!-- select="getTeacher" :调用下一个查询语句 --> <!-- column="t_id" 两个表的关联字段--> <association property="teacher" column="t_id" javaType="com.qcby.entity.Teacher" select="getTeacher"/> </resultMap> <select id="getTeacher" resultType="com.qcby.entity.Teacher"> select * from teacher where id = #{t_id}; <!-- #{id}; 可以写任何东西，因为会自动匹配 t_id --> </select>三、一对多
查询每个老师有多少学生
1.第一种形式：按照结果嵌套处理
SELECT teacher.id,teacher.name,student.name FROM teacher LEFT JOIN student on student.t_id = teacher.id①.设置实体类
public class Student { private Integer id; private String Sname; private String sex; private Integer age; private Integer t_id; }这里需要将student类当中关于teacher的字段删除
public class Teacher { private Integer id; private String Tname; //这个一定要有 private List<Student> students; }②.查询语句
<!--按照结果进行查询--> <select id="getTeacher" resultMap="TeacherStudent"> SELECT teacher.id,teacher.Tname,student.Sname FROM teacher LEFT JOIN student on student.t_id = teacher.id </select> <resultMap id="TeacherStudent" type="com.qcby.entity.Teacher"> <result property="id" column="id"/> <result property="Tname" column="Tname"/> <!-- 复杂的属性我么需要单独去处理 对象:association 集合：collection 在集合中的泛型信息，我们使用ofType获取 --> <collection property="students" ofType="com.qcby.entity.Student"> <result property="Sname" column="Sname"/> </collection> </resultMap>2.第二种形式：按照查询嵌套处理
SELECT s.id,s.Sname,t.Tname FROM student s,teacher t where s.t_id = t.id①.设置实体类
这里的实体类不需要变动
②.查询语句
<!--按照查询嵌套处理--> <select id="getTeacher" resultMap="TeacherStudent2"> select * from teacher </select> <resultMap id="TeacherStudent2" type="com.qcby.entity.Teacher"> <collection property="students" column="id" ofType="com.qcby.entity.Student" select="getStudentByTeacherId" /> </resultMap> <select id="getStudentByTeacherId" resultType="com.qcby.entity.Student"> select * from student where t_id = #{t_id} </select>四、MyBatis延迟加载策略
以上有两种写法来表示查询信息，分别是链表查询和分步查询的方法。那么既然我么能用一个SQL语句能够执行完，那为什么还要分开来写呢？
原因很简单：同学们可以发现如果我们把他们连在一起那么他们就是一个多表查询语句，如果不放在一起执行，那那就是单独一个表的查询语句。但是这需要我们设置mybatis的延迟加载(懒加载)
分步查询的优点:可以实现延迟加载，但是必须在核心配置文件中设置全局配置信息
lazyLoadingEnabled:延迟加载的全局开关。当开启时，所有关联对象都会延迟加载
aggressiveLazyLoding:当开启时，任何方式的调用都会加载该对象的所有属性。否则，该属性会按需加载
此时就可以实现按需加载，需要获取的数据是什么，就只会执行相应的sql.此时会通过association和collection中的fetchType属性设置当前的分步查询是否使用懒加载
fetchType=“lazy(延迟加载) | eager(立即加载)”
1.在主配置文件当中设置延迟加载
<settings> <setting name="lazyLoadingEnabled" value="true"/> <setting name="aggressiveLazyLoading" value="false"/> </settings>2.在studentDao.xml当中设置分步查询
<select id = "getStudent" resultMap="StudentTeacher"> select * from student; </select> <!--结果映射集--> <resultMap id="StudentTeacher" type="com.qcby.entity.Student"> <result property="id" column="id"/> <result property="Sname" column="Sname"/> <result property="sex" column="sex"/> <result property="age" column="age"/> <result property="t_id" column="t_id"/> <!-- select="getTeacher" :调用下一个查询语句 --> <!-- select="com.qcby.dao.TeacherDao.getTeacher" :调用下一个查询语句 --> <association property="teacher" column="t_id" javaType="com.qcby.entity.Teacher" select="com.qcby.dao.TeacherDao.getTeacher" fetchType="lazy"/> </resultMap>3.在TeacherDao.xml当中设置关于教师的查询
<select id="getTeacher" resultType="com.qcby.entity.Teacher" parameterType="java.lang.Integer"> select * from teacher where id = #{t_id}; <!-- #{id}; 可以写任何东西，因为会自动匹配 t_id --> </select>4.配置TeacherDao
Teacher getTeacher(Integer id);5.访问设置
①：只访问student当中的内容
@Test public void getStudent(){ List<Student> student = mapper.getStudent(); for (Student student1:student) { System.out.println(student1.getSex()); } }②：访问全部的内容和有关Teacher表当中的内容时
@Test public void getStudent(){ List<Student> student = mapper.getStudent(); for (Student student1:student) { // System.out.println(student1); System.out.println(student1.getTeacher().getTname()); } }6.一些特殊情况下的查询
我们在主配置文件当中设置的懒加载，对于任何一个分步查询都是有效的，但是在一些特殊的情况下，我们希望有些语句不分开查询，这个时候我们就需要设置该语句只能立即加载
<select id = "getStudent" resultMap="StudentTeacher"> select * from student; </select> <!--结果映射集--> <resultMap id="StudentTeacher" type="com.qcby.entity.Student"> <result property="id" column="id"/> <result property="Sname" column="Sname"/> <result property="sex" column="sex"/> <result property="age" column="age"/> <result property="t_id" column="t_id"/> <!-- select="com.qcby.dao.TeacherDao.getTeacher" :调用下一个查询语句 --> <!-- column="t_id" 两个表的关联字段--> <!--fetchType="eager" 立即加载--> <association property="teacher" column="t_id" javaType="com.qcby.entity.Teacher" select="com.qcby.dao.TeacherDao.getTeacher" fetchType="eager"/> </resultMap>测试语句
@Test public void getStudent(){ List<Student> student = mapper.getStudent(); for (Student student1:student) { System.out.println(student1.getSex()); } }五、核心总结
1. 多表关联映射：
多对一 / 一对一：使用association标签映射单个关联对象，指定javaType；
一对多：使用collection标签映射关联集合，指定ofType（集合元素类型）。
2.查询方式对比：
连表查询：SQL 一次联表，性能取决于联表复杂度，适合需要一次性获取所有数据的场景；
分步查询：SQL 拆分，支持延迟加载，按需查询，适合大表 / 多表关联的性能优化。
3.延迟加载关键配置：
全局开关：lazyLoadingEnabled=true+aggressiveLazyLoading=false；
局部覆盖：fetchType="lazy/eager"可单独控制某一分步查询的加载策略。
通过以上方式，MyBatis 可以灵活处理多表关联场景，同时结合延迟加载有效优化查询性能，适配不同的业务需求。
