mybatis 中的关系映射（一对一，一对多，多对多）——小马同学@Tian

于 2020-11-15 13:23:38 发布
阅读量519 收藏 2
点赞数
文章标签： mybatis 关系模型 sql java mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/SigleDog/article/details/109693266
版权
本文详细探讨了MyBatis中的一对多、多对一和多对多的关系映射。通过部门与员工、学生与课程的例子，阐述了嵌套查询和嵌套结果的区别及实现方式，包括表结构设计和XML配置文件的编写。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

关系映射

简介
MyBatis 有两种不同的关联方式:
嵌套查询:通过执行另外一个 SQL 映射语句来返回预期的复杂类型。
嵌套结果:使用嵌套结果映射来处理重复的联合结果的子集。

使用的标签：association 一的关系、collection 多的关系
嵌套查询和嵌套结果区别
嵌套查询的弊端：即嵌套查询的N+1问题
尽管嵌套查询大量的简化了存在关联关系的查询，但它的弊端也比较明显：即所谓的N+1问题。关联的嵌套查询显示得到一个结果集，然后根据这个结果集的每一条记录进行关联查询。
现在假设嵌套查询就一个（即resultMap 内部就一个association标签），现查询的结果集返回条数为N，那么关联查询语句将会被执行N次，加上自身返回结果集查询1次，共需要访问数据库N+1次。如果N比较大的话，这样的数据库访问消耗是非常大的！所以使用这种嵌套语句查询的使用者一定要考虑慎重考虑，确保N值不会很大。

嵌套结果查询：
嵌套语句的查询会导致数据库访问次数不定，进而有可能影响到性能。Mybatis还支持一种嵌套结果的查询：即对于一对多，多对多，多对一的情况的查询，Mybatis通过联合查询，将结果从数据库内一次性查出来，然后根据其一对多，多对一，多对多的关系和ResultMap中的配置，进行结果的转换，构建需要的对象。
对于关联结果的查询，只需要查询数据库一次，然后对结果的整合和组装全部放在了内存中。
1 一对多/多对一(部门和员工之间关系)
1.1表结构
CREATE TABLE `t_dept` (
  `deptId` int(11) NOT NULL AUTO_INCREMENT,
  `deptName` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`deptId`)
)

CREATE TABLE `t_employee` (
  `empId` int(11) NOT NULL AUTO_INCREMENT,
  `empName` varchar(20) DEFAULT NULL,
  `salary` double DEFAULT NULL,
  `dept_id` int(11) DEFAULT NULL,
  PRIMARY KEY (`empId`),
  KEY `FK_jgo5u3npdj1lborc1v50bsens` (`dept_id`),
  CONSTRAINT `FK_jgo5u3npdj1lborc1v50bsens` FOREIGN KEY (`dept_id`) REFERENCES `t_dept` (`deptId`)
)
1.2嵌套结果和嵌套查询
实体类的创建为重中之重 员工实体创建如下：

public class Employee {
    private Integer eid;
    private String ename;
    //一个员工对应一个部门
    private Department dept;
    public Integer getEid() {
        return eid;
    }
    public void setEid(Integer eid) {
        this.eid = eid;
    }
    public String getEname() {
        return ename;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public Department getDept() {
        return dept;
    }
    public void setDept(Department dept) {
        this.dept = dept;
    }
}

部门实体创建如下：


import java.util.List;

public class Department {
    private Integer did;
    private String dname;
    //一个部门下面有多个员工
    private List<Employee> empList;

    public Integer getDid() {
        return did;
    }

    public void setDid(Integer did) {
        this.did = did;
    }

    public String getDname() {
        return dname;
    }

    public void setDname(String dname) {
        this.dname = dname;
    }

    public List<Employee> getEmpList() {
        return empList;
    }

    public void setEmpList(List<Employee> empList) {
        this.empList = empList;
    }

    @Override
    public String toString() {
        return "Department{" +
                "did=" + did +
                ", dname='" + dname + '\'' +
                ", empList=" + empList +
                '}';
    }
}
1.2.1嵌套结果
<resultMap type="Department" id="deptMap">
		<!-- 主键 -->
		<id property="id" column="did"/>
		<!-- 其他字段 -->
		<result property="name" column="dname"/>
		
		<!-- 嵌套结果的设置方式 
		collention 表示集合关系
		ofType  指定集合中对象的类型
		javaType 指定存储数据的的集合的类型
		-->
		<collection property="emps" javaType="java.util.ArrayList" ofType="Employee" resultMap="com.rr.one2many.Employee.empMap"></collection>
		
	</resultMap>

<!-- 多表查询    必须使用resultMap -->
	<select id="findById" parameterType="int" resultMap="deptMap">
		select d.id as did, d.name as dname,e.* 
		from department d 
		inner join employee e
		on d.id=e.dept_id
		where d.id=#{id};
	</select>
1.2.2 嵌套查询（一个部门对应多个员工）
嵌套查询对应多条sql语句，部门映射如下：

<resultMap type="Department" id="deptMap1">
		<!-- 主键 -->
		<id property="id" column="id"/>
		<!-- 其他字段 -->
		<result property="name" column="name"/>
		
		<!-- 嵌套查询的设置方式 
		collention 表示集合关系
		ofType  指定集合中对象的类型
		javaType 指定存储数据的的集合的类型
		-->
		<collection property="emps" javaType="java.util.ArrayList" ofType="Employee" column="id" select="com.rr.one2many.Employee.findByDeptId"></collection>
		
	</resultMap>

	<select id="findByDId" parameterType="int" resultMap="deptMap1">
		select * 
		from department d
		where d.id=#{id};
	</select>

员工映射如下：

EmployeeMapper.xml
<resultMap type="Employee" id="empMap1">
		<!-- 主键 -->
		<id property="id" column="id"/>
		<!-- 其他字段 -->
		<result property="name" column="name"/>
		<result property="age" column="age"/>
		<result property="birth" column="birth"/>
		<!-- 嵌套查询 -->
		<association property="dept" column="dept_id" select="com.rr.one2many.Department.findByDId" fetchType="eager"></association>
		
	</resultMap>
<select id="findByDeptId" parameterType="int" resultMap="empMap">
		select * from employee where dept_id=#{id};
	</select>
	
	<select id="findAll" resultMap="empMap1">
		select * from employee;
	</select>

2 多对多（学生和课程之间的关系）

其实多对多就是一对多的延伸，即	多—>壹<—多
学生表 和课程表之间多了一个表来进行关系的对应
2.1 表结构
CREATE TABLE `t_student` (
  `sid` int(11) NOT NULL AUTO_INCREMENT,
  `sname` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`sid`)
)
CREATE TABLE `t_course` (
  `cid` int(11) NOT NULL AUTO_INCREMENT,
  `cname` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`cid`)
)
CREATE TABLE `t_relation` (
  `sid` int(11) NOT NULL,
  `cid` int(11) NOT NULL,
  PRIMARY KEY (`sid`,`cid`),
  KEY `FK_ma6ynxw6eng27dnn2h242ec6g` (`sid`),
  CONSTRAINT `FK_fje0x78jps0jamjagtdc80r8d` FOREIGN KEY (`sid`) REFERENCES `t_student` (`sid`),
  CONSTRAINT `FK_ma6ynxw6eng27dnn2h242ec6g` FOREIGN KEY (`cid`) REFERENCES `t_course` (`cid`)
)

学生实体创建，由于一个学生可选多门课程：

import java.util.List;

public class Student {
    private Integer sid;
    private String sname;
    private List<Course> courseList;

    public Integer getSid() {
        return sid;
    }

    public void setSid(Integer sid) {
        this.sid = sid;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public List<Course> getCourseList() {
        return courseList;
    }

    public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }

    @Override
    public String toString() {
        return "Student{" +
                "sid=" + sid +
                ", sname='" + sname + '\'' +
                ", courseList=" + courseList +
                '}';
    }
}

课程对应多个学生，课程实体为：

import java.util.List;

public class Course {
    private Integer cid;
    private String cname;
    private List<Student> stuList;

    public Integer getCid() {
        return cid;
    }

    public void setCid(Integer cid) {
        this.cid = cid;
    }

    public String getCname() {
        return cname;
    }

    public void setCname(String cname) {
        this.cname = cname;
    }

    public List<Student> getStuList() {
        return stuList;
    }

    public void setStuList(List<Student> stuList) {
        this.stuList = stuList;
    }

    @Override
    public String toString() {
        return "Course{" +
                "cid=" + cid +
                ", cname='" + cname + '\'' +
                ", stuList=" + stuList +
                '}';
    }
}
2.2嵌套结果

StudentMapper.xml

<resultMap type="Student" id="stuMap">
		<!-- 主键 -->
		<id property="id" column="stuid"/>
		<!-- 其他字段 -->
		<result property="name" column="stuname"/>
		
		<!-- 嵌套结果的设置方式 
		collention 表示集合关系
		ofType  指定集合中对象的类型
		javaType 指定存储数据的的集合的类型
		-->
		<collection property="courses" javaType="java.util.ArrayList" ofType="Course" resultMap="com.rr.many2many.Course.courseMap"></collection>
		
	</resultMap>
	
	
	<select id="findById" parameterType="int" resultMap="stuMap">
		select s.id as stuid, s.name as stuname,c.id,c.name
		from student s
		inner join stu_course sc
		on s.id=sc.sid
		inner join course c
		on c.id=sc.cid
		where s.id=#{id};
	</select>

CourseMapper.xml

<resultMap type="Course" id="courseMap">
		<!-- 主键 -->
		<id property="id" column="id"/>
		<!-- 其他字段 -->
		<result property="name" column="name"/>
		
		<!-- 嵌套结果的设置方式 
		collention 表示集合关系
		ofType  指定集合中对象的类型
		javaType 指定存储数据的的集合的类型
		-->
		<collection property="students" javaType="java.util.ArrayList" ofType="Student" resultMap="com.rr.many2many.Student.stuMap"></collection>
		
	</resultMap>
	
	<!-- 使用嵌套查询，传过来的是学生id -->
	<select id="findByStuId" parameterType="int" resultMap="courseMap">
		select c.*
		from course c
		inner join stu_course sc
		on c.id=sc.cid
		where sc.sid=#{id};
	</select>
2.3 嵌套查询

StudentMapper.xml

<resultMap type="Student" id="stuMap1">
		<!-- 主键 -->
		<id property="id" column="id"/>
		<!-- 其他字段 -->
		<result property="name" column="name"/>
		
		<!-- 嵌套查询的设置方式 -->
		<collection property="courses" javaType="java.util.ArrayList" ofType="Course" column="id" select="com.rr.many2many.Course.findByStuId"></collection>
		
	</resultMap>
	
	<select id="findBySId" parameterType="int" resultMap="stuMap1">
		select *
		from student s
		where s.id=#{id};
	</select>
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值