前期准备
数据库资源准备：
CREATE DATABASE mybatis;
USE mybatis;
CREATE TABLE `teacher`(
`id` INT PRIMARY KEY AUTO_INCREMENT COMMENT '主键id',
`name` VARCHAR (30) NOT NULL COMMENT '姓名'
)ENGINE=INNODB DEFAULT CHARSET=utf8;
INSERT INTO teacher(`name`) VALUES ('胡老师');
INSERT INTO teacher(`name`) VALUES ('黄老师');
CREATE TABLE `student`(
`id` INT PRIMARY KEY AUTO_INCREMENT COMMENT '主键id',
`name` VARCHAR (30) NOT NULL COMMENT '姓名',
`tid` INT DEFAULT NULL,
KEY `fktid`(`tid`),
CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher`(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8;
INSERT INTO `student`( `name`,`tid`) VALUES ('小明',1);
INSERT INTO `student`( `name`,`tid`) VALUES ('小红',1);
INSERT INTO `student`( `name`,`tid`) VALUES ('小刚',1);
INSERT INTO `student`( `name`,`tid`) VALUES ('小张',2);
INSERT INTO `student`( `name`,`tid`) VALUES ('小丽',2);
INSERT INTO `student`( `name`,`tid`) VALUES ('小美',2);
虽然只有简单的两个表，但是可以很明显的反映一对一和一对多的情景。
如果学生对老师，就是一对一的情况，如果是老师对学生，就是一对多。
我们可以理解为一个学生有一个老师，但是一个老师就包含多个学生。
这里不再赘述Mybatis的配置，仅列出较为重要的代码。
一对一
这里我们就以一个学生包含一个唯一的老师为例：
需求：这里我们需要查询出学生的信息，其学生的信息包含老师的信息。
实体类如下（为节省文章篇幅，省略了实体类的构造方法、getter、setter和toString）：
Teacher类
package com.ara.pojo;
//老师
public class Teacher {
private int id;
private String name;
}
Student类
//学生
public class Student {
private int id;
private String name;
//学生要关联一个老师 一个学生对应一个老师
private Teacher teacher;
}
TeacherMapper接口（由于这里演示仅需要这一个方法，为了简便就直接使用注解了）：
package com.ara.dao;
import com.ara.pojo.Teacher;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
public interface TeacherMapper {
/**
* 通过老师的id查询出老师的信息
*
* @param id 老师的唯一主键id
* @return 返回id对应的老师信息
*/
@Select("select * from teacher where id = #{id}")
Teacher getTeacherById(@Param("id") int id);
}
StudentMapper接口：
package com.ara.dao;
import com.ara.pojo.Student;
import org.apache.ibatis.annotations.Param;
public interface StudentMapper {
/**
* 根据学生的主键id查询学生的详细信息 其中包含老师的信息
* 方式一
*
* @param id 主键id
* @return 返回对应的学生信息
*/
Student getStudentById1(@Param("id") int id);
/**
* 根据学生的主键id查询学生的详细信息 其中包含老师的信息
* 方式二
*
* @param id 主键id
* @return 返回对应的学生信息
*/
Student getStudentById2(@Param("id") 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="com.ara.dao.StudentMapper">
<!-- 直接使用联表查询 start -->
<select id="getStudentById1" parameterType="_int" resultMap="StudentMap1">
select s.id sid,s.name sname,t.id tid,t.name tname from student s,teacher t where s.tid = t.id and s.id = #{id};
</select>
<resultMap id="StudentMap1" type="Student">
<result column="sid" property="id" />
<result column="sname" property="name" />
<!--
由于这里属于嵌套组合的属性 我们采用association标签
因为我们需要对Student中Teacher进行再次封装 所以我们需要制定如下属性
property：Student类中的属性名
javaType：制定属性的Java类型
-->
<association property="teacher" javaType="Teacher">
<result column="tid" property="id" />
<result column="tname" property="name" />
</association>
</resultMap>
<!-- 方式一：直接使用联表查询 end -->
<!-- 方式二：查询中嵌套查询 start -->
<select id="getStudentById2" parameterType="_int" resultMap="StudentMap2">
select * from student where id = #{id};
</select>
<resultMap id="StudentMap2" type="Student">
<result column="id" property="id" />
<result column="name" property="name" />
<!--
由于这里属于分两次查询 所以我们直接利用外键这列来查询Teacher信息
column：查询后的列名
property：Student类中的属性名
javaType：制定属性的Java类型
select：需要引用的查询Id
-->
<association column="tid" property="teacher" javaType="Teacher" select="com.ara.dao.TeacherMapper.getTeacherById"/>
</resultMap>
<!-- 方式二：查询中嵌套查询 end -->
</mapper>
测试代码：
package com.ara.test;
import com.ara.dao.StudentMapper;
import com.ara.pojo.Student;
import com.ara.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
public class StudentMapperTest {
@Test
public void getStudentByIdTest1(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
Student student = studentMapper.getStudentById1(1);
System.out.println(student);
sqlSession.close();
}
@Test
public void getStudentByIdTest2(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
Student student = studentMapper.getStudentById2(5);
System.out.println(student);
sqlSession.close();
}
}
getStudentByIdTest1结果：
getStudentByIdTest2结果：
两种方式都可以查询出结果，但是两者的过程并不相同，联表查询虽然SQL语句较为复杂，但是它的执行就只运行了一条SQL语句，嵌套查询虽然SQL语句简单，但是它却执行了两个SQL语句，具体开发中，还是要根据自己的需要来酌情选择。
一对多
这里我们就以一个老师有多个学生为例：
需求：根据对应老师的Id查询老师的信息及其所有的学生信息。
实体类如下（为节省文章篇幅，省略了实体类的构造方法、getter、setter和toString）：
Student类：
package com.ara.pojo;
//学生类
public class Student {
private int id;
private String name;
//学生要关联一个老师id
private int tid;
}
Teacher类：
package com.ara.pojo;
import java.util.List;
//老师
public class Teacher {
private int id;
private String name;
//老师含有多个学生
private List<Student> students;
}
StudentMapper接口：
package com.ara.dao;
import com.ara.pojo.Student;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import java.util.List;
public interface StudentMapper {
/**
* 老师的id查询其学生列表
* @param tid 老师id
* @return 返回学生列表
*/
@Select("select * from student where tid = #{tid}")
List<Student> getStudentByTId(@Param("tid")int tid);
}
TeacherMapper接口：
package com.ara.dao;
import com.ara.pojo.Teacher;
import org.apache.ibatis.annotations.Param;
public interface TeacherMapper {
/**
* 根据教师的id查询教师的信息 包含其名下学生信息
* 方式一
*
* @param id 教师id
* @return 返回对应教师的信息
*/
Teacher getTeacherById1(@Param("id") int id);
/**
* 根据教师的id查询教师的信息 包含其名下学生信息
* 方式二
*
* @param id 教师id
* @return 返回对应教师的信息
*/
Teacher getTeacherById2(@Param("id") int id);
}
TeacherMapper.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.ara.dao.TeacherMapper">
<!-- 方式一：结果嵌套查询 start -->
<select id="getTeacherById1" parameterType="_int" resultMap="teacherInfoMap1">
select t.id tid,t.name tname,s.id sid,s.name sname from teacher t,Student s where t.id = s.tid and t.id = #{id}
</select>
<resultMap id="teacherInfoMap1" type="Teacher">
<result column="tid" property="id" />
<result column="tname" property="name" />
<!--
复杂的属性 我们需要单独处理 集合使用collection
javaType：指定属性的类型
ofType：指定集合中的泛型信息
-->
<collection property="students" ofType="Student" >
<result column="sid" property="id" />
<result column="sname" property="name" />
<result column="tid" property="tid" />
</collection>
</resultMap>
<!-- 方式一：结果嵌套查询 end -->
<!-- 方式二：查询嵌套查询 start -->
<select id="getTeacherById2" parameterType="_int" resultMap="teacherInfoMap2" >
select * from teacher where id = #{id};
</select>
<resultMap id="teacherInfoMap2" type="Teacher">
<result column="id" property="id" />
<result column="name" property="name" />
<!--
复杂的属性 我们需要单独处理 集合使用collection
column：指定需要再次查询的列名
property：指定Teacher中的students属性
javaType：指定Teacher中的students属性的Java类型
ofType：指定Teacher中的students属性的Java类型的泛型类型
select：指定我们需要做再次查询的方法id
-->
<collection column="id" property="students" javaType="ArrayList" ofType="Student" select="com.ara.dao.StudentMapper.getStudentByTId"/>
</resultMap>
<!-- 方式二：查询嵌套查询 end -->
</mapper>测试代码如下：
package com.ara.dao.test;
import com.ara.dao.TeacherMapper;
import com.ara.pojo.Teacher;
import com.ara.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
public class TeacherMapperTest {
@Test
public void getTeacherByIdTest1(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
Teacher teacher = sqlSession.getMapper(TeacherMapper.class).getTeacherById1(1);
System.out.println(teacher);
sqlSession.close();
}
@Test
public void getTeacherByIdTest2(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
Teacher teacher = sqlSession.getMapper(TeacherMapper.class).getTeacherById2(2);
System.out.println(teacher);
sqlSession.close();
}
}
getTeacherByIdTest1测试结果：
getTeacherByIdTest2测试结果：
这两种方式都能实现我们的需求，但是也存在着上述一对一的情况，就是联表查询的SQL语句虽然较为复杂，但是它只运行了一条SQL，通过查询中嵌套查询，虽然SQL简单了，但是它分了两条SQL进行查询。
都各有优缺点，结果中嵌套只是理解起来可能较为复杂，但是它的效率就相对较高，查询中嵌套查询，虽然SQL语句很简单，但是它的执行效率就相对来说较为低下。
实际的开发中，根据具体的情况具体斟酌即可。
382
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
