第3章
MyBatis进阶







视频讲解


学习目标

 掌握MyBatis的映射文件的使用方法和规范，能够编写映射文件。

 掌握MyBatis一对一关系的映射方法，能够完成一对一应用程序。

 掌握MyBatis一对多关系的映射方法，能够完成一对多应用程序。

 掌握MyBatis多对多关系的映射方法，能够完成多对多应用程序。

为了灵活运用MyBatis框架，开发人员需要掌握MyBatis映射文件的结构及使用方法。通过深入理解映射文件的组成和重要参数，开发人员能够根据项目需求对映射文件进行灵活配置，以达到最佳的性能和扩展性。本章将对MyBatis的映射文件和关联映射的内容进行讲解，同时通过一个实战演练——智慧农业果蔬系统普通用户的数据管理项目巩固Mapper和XML映射文件的相关知识。

3.1映 射 文 件

在2.4.8节中提到，MyBatis配置文件中的<mappers>元素用于引入映射文件。这些映射文件是MyBatis框架的核心，定义了SQL语句和数据库中的数据如何映射到Java对象，是MyBatis的“翻译器”，将数据库信息翻译成Java对象，使开发者能够更轻松地与数据库交互，而不必过分关注数据库连接和底层细节，从而大幅度降低编码的工作量。本节将对MyBatis的映射文件结构及元素用法进行讲解。

3.1.1映射文件结构

通过映射文件，我们能够将数据从应用程序的POJO对象映射到持久化存储中，实现数据的创建、读取、更新和删除操作。映射文件以XML文件的形式存在，一般采用“POJO类的名称+Mapper”的规则进行命名，例如EducationMapper.xml。MyBatis规定了其映射文件的层次结构，具体如下所示。



<?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="">

<!-- 参数映射 -->

<parameterMap id="" type="">

<parameter property="" jdbcType=""/>

<parameter property="" jdbcType=""/>

</parameterMap>








<!-- 返回值映射 -->

<resultMap id="" type="">

<id property="" column="" jdbcType=""/>

<result property="" column="" jdbcType=""/>

<result property="" column="" jdbcType=""/>

</resultMap>

<!-- SQL语句 -->

<select id="" resultMap="">

</select>

<insert id="" parameterMap="">

</insert>

<update id="" parameterMap="">

</update>

<delete id="" parameterType="">

</delete>

</mapper>






上述代码中列出了MyBatis映射文件的常见元素，例如<mapper>、<select>、<insert>、<update>和<delete>等。本书将带领读者学习MyBatis中常用元素的功能语法和使用方法。

3.1.2<mapper>元素

<mapper>元素是MyBatis映射文件的根元素，它用于定义数据库操作的SQL语句以及数据库记录与Java对象的映射规则。整个映射文件的内容都必须包含在这个元素内部，示例配置如下。



<mapper namespace="com.qfedu.EducationMapper">

<!-- 这里包含了SQL语句和映射关系的定义 -->

</mapper>






上述代码中，namespace属性是<mapper>元素的必需属性，它用于定义映射文件的命名空间。通常，这个命名空间会关联到一个对应的数据访问层的Java接口，该接口定义了映射文件中的SQL操作方法，使得数据库操作可以通过接口方法进行调用。映射文件的命名空间应该与其关联的接口文件的包名和类名一致，以便正确关联映射文件和接口文件，此处为com.qfedu.EducationMapper接口。

<mapper>元素内部可以包含SQL语句的定义，包括查询、插入、更新和删除等操作。SQL语句的定义通常使用<select>、<insert>、<update>和<delete>等元素来实现。此外，<mapper>元素还用于定义如何将数据库记录映射到Java对象的规则，通常通过<resultMap>元素来实现。后续将对上述元素进行详细讲解。

<mapper>元素还可以通过resource、url、class等属性引入其他映射文件，这有助于将映射配置分解成多个文件，使得映射文件更易于维护和组织。具体使用规则可参考2.4.8节。

3.1.3<select>元素

<select>元素是MyBatis中常用的元素之一，主要用于定义数据库查询操作，它包含了SQL语句、参数映射、结果映射以及其他与数据库操作相关的细节。

为了更加灵活地映射查询语句，<select>元素中提供了一些属性，如表31所示。


表31select元素属性



属 性 名 称说明


id必需属性，用于给查询SQL定义一个唯一的标识符
parameterType指定传递给查询SQL的参数类型，默认为unset
resultType指定查询结果的返回类型，通常是一个Java类。不能与resultMap同时使用
resultMap指定一个映射结果集的规则，不能与resultType同时使用
flushCache控制是否刷新缓存，默认值为false
useCache控制是否使用二级缓存，默认值为true
timeout查询的超时时间，以秒为单位
fetchSize指定数据库游标的数量
statementType指定用于查询的PreparedStatement类型，可选STATEMENT、PREPARED或CALLABLE，通常为PREPARED，默认为unset

resultSetType指定返回的结果集类型，可选FORWARD_ONLY、SCROLL_SENSITIVE、SCROLL_INSENSITIVE或DEFAULT，通常为FORWARD_ONLY，默认为unset

resultOrdered控制多列结果集的顺序，通常为false
resultSets指定存储过程执行的多个结果集


表31列举出了<select>元素中的属性，每个属性都有其独特的作用，开发人员根据查询的要求选择适当的属性来定制查询操作。

接下来，通过<select>元素定义一条查询表education中所有记录的SQL语句，具体步骤如下。

(1) 在IDEA中新建Web项目chapter03，并完成MyBatis框架的集成和数据库配置。本案例使用第2章的数据表education。

(2) 在项目的src目录下创建com.qfedu.pojo包，在该包中新建类Education，具体代码参考第2章的例21。

(3) 在项目的src目录下创建包com.qfedu.mapper，在该包中新建接口EducationMapper，作为数据库访问层接口，具体代码如例31所示。

例31EducationMapper.java。



 1package com.qfedu.mapper;

 2import com.qfedu.pojo.Education;

 3import java.util.List;

 4public interface EducationMapper {

 5List<Education> findAllEducation();

 6}






(4) 在com.qfedu.mapper包中新建名为EducationMapper的XML文件，映射配置如例32所示。

例32EducationMapper.xml。



 1<mapper namespace="com.qfedu.mapper.EducationMapper">

 2<select id="findAllEducation" resultType="com.qfedu.pojo.Education">

 3select * from education

 4</select>

 5</mapper>






上述配置定义了一个名为findAllEducation的MyBatis查询操作，它的功能是从名为education的数据库表中检索所有记录，并将结果映射为com.qfedu.pojo.Education类型的Java对象列表。<select>元素的id属性的值与命名空间关联的接口文件中的方法名一致，此处为com.qfedu.mapper.EducationMapper接口中的findAllEducation()方法； resultType属性用于指定返回结果的映射类型，此处为com.qfedu.Education。

(5) 在项目的src目录下创建包com.qfedu.test，在该包中新建类TestEducationMapper，通过调用EducationMapper接口的方法，执行映射文件中的SQL操作。首先，在TestEducationMapper类中定义一个静态方法testFindAllEducation()，然后，在main()方法中调用该方法，具体代码如例33所示。

例33TestEducationMapper.java。



 1package com.qfedu.test;

 2//此处省略导包的代码

 3public class TestEducationMapper {

 4public static void main(String［］ args) {

 5testFindAllEducation();

 6}

 7public static void testFindAllEducation(){

 8InputStream inputStream = null;

 9try {

 10inputStream =

 11Resources.getResourceAsStream("mybatis-config.xml");

 12} catch (IOException e) {

 13e.printStackTrace();

 14}

 15SqlSessionFactory build =

 16new SqlSessionFactoryBuilder().build(inputStream);

 17SqlSession sqlSession = build.openSession();

 18EducationMapper mapper = sqlSession.getMapper(

 19EducationMapper.class);

 20List<Education> educations = mapper.findAllEducation();

 21for (Education education : educations) {

 22System.out.println(education.toString());

 23}

 24sqlSession.close();

 25}

 26}






(6) 执行例33中的main()方法，对<select>元素定义的数据库查询操作进行测试，结果如图31所示。



图31测试<select>元素查询操作的结果


从图31中可以看出，通过映射文件中的<mapper>元素成功将映射文件EducationMapper.xml与数据库访问接口EducationMapper建立了关联，并通过<select>元素成功执行查询表education中所有记录的SQL语句。

3.1.4<insert>元素、<delete>元素、<update>元素

<insert>元素用于映射数据库插入操作的SQL语句，<update>元素用于映射数据库更新操作的SQL语句，而<delete>元素则用于映射数据库删除操作的SQL语句。与<select>元素相似，这3个元素在结构上都包含了SQL语句及参数类型等相关信息，接下来分别进行演示。

1. <insert>元素

通过<insert>元素定义一条向表education中插入数据的SQL语句，具体步骤如下。

(1) 在EducationMapper.xml文件中添加如下配置。



<insert id="addEducation" parameterType="com.qfedu.pojo.Education">

insert into education(name,price) values(#{name},#{price})

</insert>






上述配置定义了一个名为addEducation的插入操作，该操作使用参数占位符#{}，将com.qfedu.pojo.Education对象的name属性和price属性的值嵌入到SQL语句中，从而实现将它们的值分别插入数据库表education中的name和price列。开发人员在Java代码中需要使用addEducation()方法执行插入操作，并通过传递Education对象指定要插入的数据。

(2) 在EducationMapper接口中声明方法addEducation()，具体代码如下。



int addEducation(Education education);






(3) 在TestEducationMapper类中定义静态方法testAddEducation()，具体代码如下。



public static void testAddEducation(){

InputStream inputStream = null;

try {

inputStream =

Resources.getResourceAsStream("mybatis-config.xml");

} catch (IOException e) {

e.printStackTrace();

}

SqlSessionFactory build =

new SqlSessionFactoryBuilder().build(inputStream);

SqlSession sqlSession = build.openSession();








EducationMapper mapper = sqlSession.getMapper(EducationMapper.class);

Education education = new Education("Java",100);

//插入名称为Java，价格为100的记录

int num = mapper.addEducation(education); 

System.out.println(num);

sqlSession.commit();   //DML操作需要提交事务

sqlSession.close();

}






(4) 在TestEducationMapper类的main()方法中调用testAddEducation()方法，并执行main()方法，对<insert>元素定义的数据库插入操作进行测试，结果如下。



1






由测试结果可以看出，返回受影响的行数为1，通过<insert>元素成功执行向表education中插入数据的SQL语句。此时，调用testFindAllEducation()方法查询表education中的所有数据，结果如下。



Education{id=1, name='语文', price=23}

Education{id=2, name='数学', price=18}

Education{id=3, name='英语', price=35}

Education{id=6, name='Java', price=100}






2. <delete>元素

通过<delete>元素定义一条删除表education中指定数据的SQL语句，具体步骤如下。

(1) 在EducationMapper.xml文件中添加如下配置。



<delete id="deleteEducation" parameterType="Integer">

delete from education where id= #{id}

</delete>






上述配置定义了一个名为deleteEducation的删除操作，该操作将通过一个整数参数id来指定要删除的数据标识。通过在Java代码中调用deleteEducation()方法和传递合适的参数，可以执行表education中的数据删除操作。

(2) 在EducationMapper接口中声明方法deleteEducation()，具体代码如下。



int deleteEducation(int id);






(3) 在TestEducationMapper类中定义静态方法testDeleteEducation()，关键代码如下。



EducationMapper mapper = sqlSession.getMapper(EducationMapper.class);

int num = mapper.deleteEducation(1);   //删除id为1的记录

System.out.println(num);






(4) 在TestEducationMapper类的main()方法中调用testdeleteEducation()方法，并执行main()方法，对<delete>元素定义的数据库删除操作进行测试，结果如下。



1






由测试结果可以看出，返回受影响的行数为1，通过<delete>元素成功执行删除表education中数据的SQL语句。此时，调用testFindAllEducation()方法查询表education中的所有数据，结果如下。



Education{id=2, name='数学', price=18}

Education{id=3, name='英语', price=35}

Education{id=6, name='Java', price=100}






3. <update>元素

通过<update>元素定义一条更新表education中指定数据的SQL语句，具体步骤如下。

(1) 在EducationMapper.xml文件中添加如下配置。



<update id="updateEducation" parameterType="com.qfedu.pojo.Education">

update education set price = #{price} where id =#{id}

</update>






这个配置定义了一个名为updateEducation的更新操作，该操作将通过com.qfedu.pojo.Education对象的id属性和price属性的值来指定要更新的数据的条件和新值。通过在Java代码中调用updateEducation()方法和传递合适的参数，可以执行表education中的数据更新操作。

(2) 在EducationMapper接口中声明方法updateEducation()，具体代码如下。



int updateEducation(int id);






(3) 在TestEducationMapper类中定义静态方法testUpdateEducation()，关键代码如下。



EducationMapper mapper = sqlSession.getMapper(EducationMapper.class);

//将id为2的记录的price值更新为111

int num = mapper.updateEducation(2,111); 

System.out.println(num);






(4) 在TestEducationMapper类的main()方法中调用testUpdateEducation()方法，并执行main()方法，对<update>元素定义的更新数据库的操作进行测试，结果如下。



1






由测试结果可以看出，返回受影响的行数为1，通过<update>元素成功执行更新表education中数据的SQL语句。此时，调用testFindAllEducation()方法查询表education中的所有数据，结果如下。



Education{id=2, name='数学', price=111}

Education{id=3, name='英语', price=35}

Education{id=6, name='Java', price=100}






3.1.5<resultMap>元素

<resultMap>元素是MyBatis映射文件中用于定义结果集映射关系的重要元素。通过使用<resultMap>元素，可以灵活地配置映射规则，使得查询结果的列能够正确地映射到Java对象的属性，从而处理更加复杂的映射情况，例如3.2节中讲解的一对多关联映射和多对多关联映射。MyBatis映射文件中<resultMap>元素的完整结构代码如下所示。



<resultMap id="resultMapId" type="com.example.Person">

<!-- 主键映射，使用 <id> 元素 -->

<id property="id" column="person_id" />

<!-- 普通字段映射，使用 <result> 元素 -->

<result property="name" column="person_name" />

<result property="age" column="person_age" />

<!-- 一对一关联映射，使用 <association> 元素 -->

<association property="address" javaType="com.example.Address">

<result property="street" column="street_name" />

<result property="city" column="city_name" />

</association>

<!-- 一对多关联映射，使用 <collection> 元素 -->

<collection property="phoneNumbers" ofType="com.example.PhoneNumber">

<id property="id" column="phone_id" />

<result property="number" column="phone_number" />

</collection>

</resultMap>






上述代码的<resultMap>元素的子元素及子元素属性的说明如下所示。

 <resultMap>元素的id属性用于标志这个映射规则，通常是一个唯一的名称。

 <id>元素用于定义主键字段的映射规则，其中，property属性指定了Java属性名，column属性指定了数据库列名。

 <result>元素用于定义普通字段的映射规则，与<id>类似但适用于非主键字段。

 <association>元素用于定义一对一关联映射，其中property属性指定关联对象的Java属性，javaType属性指定关联对象的Java类型。内部使用<result>元素定义关联对象的字段映射。3.2.1节将使用案例进行演示。

 <collection>元素用于定义一对多关联映射，其中property属性指定集合属性，ofType属性指定集合元素的类型。同样，内部使用<result>元素定义集合元素的字段映射。3.2.2节将使用案例进行演示。

3.1.6<sql>元素

<sql>元素用于定义可重用的SQL代码片段。在MyBatis应用程序开发中，经常需要编写多条SQL语句以满足各种业务需求，而这些SQL语句可能包含相同的代码段。为了提高代码的可维护性和重用性，可以使用<sql>元素将这些共享的代码片段提取出来并进行定义，从而避免了重复编写相同的代码，使代码更加整洁和易于管理。

通过<sql>元素定义代码片段，具体示例如下所示。



<sql id="educationCols">

id,name,price

</sql>







上述代码中，id属性用于指定该代码片段在命名空间的唯一标志，此处为educationCols。当完成上述代码片段的定义后，可以在MyBatis映射文件中使用这个代码片段，以避免在多个地方重复编写相同的列名，示例代码如下。



<select id="selectEducation" resultType="com.qfedu.Education">

select <include refid="educationCols"/> from education








</select>

<insert id = "insertEducation" parameterType="com.qfedu.Education">

insert into education(<include refid="educationCols"/>) values(#{id}, 

#{name},#{price})

</insert>






上述代码中，<include>元素用于包含<sql>元素定义的SQL代码片段，其refid属性匹配<sql>元素的id属性。

3.2关 联 映 射

MyBatis的关联映射可以帮助开发人员在数据库中进行复杂的查询操作，避免手动拼接SQL语句。它可以将多个表之间的关系映射到Java对象之间的关系，从而简化了复杂的多表查询工作。关联映射支持三种主要类型的映射： 一对一、一对多、多对多。本节将对MyBatis关联映射的功能和语法进行讲解。

3.2.1一对一关联映射
1. 设计背景
一对一关联映射是指一个表中的一条记录对应着另一个表中的一条记录。在数据库模型中，这种关系通常表示两个实体之间的一对一关系。例如，一个人只有一个身份证号，一个身份证号也只对应一个人，这就是一对一关联。

在一个OA管理系统中，涉及两个实体： 员工和工号。每个员工都会对应一个唯一的工号。在前面讲解的<resultMap>元素中包含了<association>子元素，MyBatis通过该元素来处理一对一关联关系。

2. 创建实体类和数据库

在chapter03项目的com.qfedu.pojo包下新建Employee类和Card类，分别表示员工类和工号类，具体代码如例34与例35所示。

例34Employee.java。



 1public class Employee {

 2private int id;   //主键

 3private String name;   //姓名

 4private int cid;   //工号表外键

 5private int did;   //部门表外键

 6private Card card;   //工号表实体类

 7//此处省略构造方法、Getter()、Setter()和toString()方法

 8}






例35Card.java。



 1public class Card {

 2private  int id;

 3private  int number;

 4private String introduce;

 5//此处省略构造方法、Getter()、Setter()和toString()方法

 6}






(1) 在数据库student中创建员工表employee，SQL语句如下所示。



DROP TABLE IF EXISTS 'employee';

CREATE TABLE 'employee'  (

'id' int(0) NOT NULL AUTO_INCREMENT,

'name' varchar(255) NULL DEFAULT NULL,

'cid' int(0) NULL DEFAULT NULL,

PRIMARY KEY ('id') USING BTREE

) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci 

ROW_FORMAT = Dynamic;






(2) 向employee表中插入数据，SQL语句如下所示。



INSERT INTO 'employee' VALUES (1, '余*兴', 1);

INSERT INTO 'employee' VALUES (2, '谭*端', 2);

INSERT INTO 'employee' VALUES (3, '宋*桥', 3);






(3) 在数据库student中创建工号表card，SQL语句如下所示。



DROP TABLE IF EXISTS 'card';

CREATE TABLE 'card'  (

'id' int(0) NOT NULL AUTO_INCREMENT,

'number' int(0) NULL DEFAULT NULL,

'introduce' varchar(255) NULL DEFAULT NULL,

PRIMARY KEY ('id') USING BTREE

) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci 

ROW_FORMAT = Dynamic;






(4) 向card表中插入数据，SQL语句如下所示。



INSERT INTO 'card' VALUES (1, 77000, '组长');

INSERT INTO 'card' VALUES (2, 66789, '组员');

INSERT INTO 'card' VALUES (3, 22960, '组员');






将card表的id和employee表的cid进行关联，即每个员工记录在employee表中有一个cid字段，用于指示员工持有的工号。

3. 编写MyBatis的配置文件和映射文件

(1) 在chapter03项目下创建resource文件夹，将其标注为资源文件夹。在resource文件夹下新建MyBatis的配置文件，具体代码如例36所示。

例36mybatisconfig.xml。



 1<?xml version="1.0" encoding="UTF-8" ?>

 2<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"

 3"http://mybatis.org/dtd/mybatis-3-config.dtd">

 4<configuration>

 5<!--引入配置文件-->

 6<properties resource="db.properties"/>

 7<!--设置 -->

 8<settings>

 9<!--开启数据库日志检测-->

 10<setting name="logImpl" value="STDOUT_LOGGiNG"/>

 11</settings>

 12<!--包名简化缩写-->

 13<typeAliases>

 14<package name="com.qfedu.pojo"/>








 15</typeAliases>

 16<!--配置环境-->

 17<environments default="dev">

 18<!--配置mysql环境-->


 19<environment id="dev">

 20<!--配置事务管理器-->

 21<transactionManager type="JDBC"/>

 22<!--配置数据库连接-->

 23<dataSource type="POOLED">

 24<!--配置数据库连接驱动-->

 25<property name="driver" value="${jdbc.myDriver}"/>

 26<!--配置数据库连接地址-->

 27<property name="url" value="${jdbc.myUrl}"/>

 28<!--配置用户名-->

 29<property name="username" value="${jdbc.myUsername}"/>

 30<!--配置密码-->

 31<property name="password" value="${jdbc.myPassword}"/>

 32</dataSource>

 33</environment>

 34</environments>

 35<!--配置mapper映射文件-->

 36<mappers>

 37<!--将com.mapper包下的所有mapper接口引入-->

 38<package name="com.qfedu.mapper" />

 39</mappers>

 40</configuration>






在例36中，第6行代码表示引用外部配置文件db.properties，其具体代码如例37所示。

例37db.properties。



 1jdbc.Driver = com.mysql.cj.jdbc.Driver

 2jdbc.Url = jdbc:mysql://localhost:3306/textbook

 3jdbc.Username = root

 4 jdbc.Password = root






需要注意的是，db.properties文件必须存放于resource目录下，否则，mybatisconfig.xml文件无法读取db.properties中的内容。

(2) 在chapter03项目的com.qfedu.mapper包中新建EmployeeMapper接口，并在该接口中声明查询所有员工的方法，具体代码如例38所示。

例38EmployeeMapper.java。



 1public interface EmployeeMapper {

 2List<Employee> findAllEmployee();

 3}






(3) 在chapter03项目的com.qfedu.mapper包中新建名为EmployeeMapper的XML文件，作为EmployeeMapper接口的映射文件，具体代码如例39所示。

例39EmployeeMapper.xml。



 1<?xml version="1.0" encoding="UTF-8"?>

 2<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"








 3"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

 4<mapper namespace="com.qfedu.mapper.EmployeeMapper">

 5<resultMap id="" type="employee">

 6<id property="id" column="id"/>

 7<result property="name" column="name"/>

 8<result property="cid" column="cid"/>

 9<association property="card" javaType="card">

 10<id property="id" column="id"/>

 11<result property="number" column="number"/>

 12<result property="introduce" column="introduce"/>

 13</association>

 14</resultMap>

 15<select id="findAllEmployee" resultMap="employeeMap">

 16select * from employee e left join card c on e.cid = c.id

 17</select>

 18</mapper>






在例39中，定义了一个名为employeeMap的映射规则，用<association>元素将employee表的数据映射到employee对象和关联的card对象中。同时，本例中还定义了一个查询操作findAllEmployee，用于查询员工信息，并在查询结果中包含了与员工关联的工号信息。

4. 编写测试类

(1) 在chapter03项目的com.qfedu.test包中创建TestFindAllEmployee类，用于验证一对一关联映射，具体代码如例310所示。

例310TestFindAllEmployee.java。



 1public class TestFindAllEmployee {

 2public static void main(String［］ args) {

 3/*创建输入流*/

 4InputStream inputStream = null;

 5/*将MyBatis配置文件转化为输入流*/

 6try {

 7inputStream =

 8Resources.getResourceAsStream("mybatis-config.xml");

 9} catch (IOException e) {

 10e.printStackTrace();

 11}

 12/*通过SqlSessionFactoryBuilder()创建SqlSessionFactory对象*/

 13SqlSessionFactory build =

 14new SqlSessionFactoryBuilder().build(inputStream);

 15/*通过SqlSessionFactory对象创建SqlSession对象*/

 16SqlSession sqlSession = build.openSession();

 17EmployeeMapper mapper = 

 18sqlSession.getMapper(EmployeeMapper.class);

 19List<Employee> allEmployee = mapper.findAllEmployee();

 20for (Employee employee : allEmployee) {

 21System.out.println(employee.toString());

 22}

 23/*关闭事务*/

 24sqlSession.close();

 25}

 26}






(2) 执行TestFindAllEmployee类的main()方法。测试一对一关联映射的结果如图32所示。



图32测试一对一关联映射的结果


从图32中可以看出，employee对象中的card属性一对一映射成功。did字段此处不做处理，3.2.3节中将使用该字段对一对多关联映射进行详细讲解。

3.2.2一对多关联映射
1. 设计背景
一对多关联映射是指一个表中的一条记录对应着另一个表中的多条记录。在本节中，员工表包含了一个部门外键did，其中每位员工归属于一个部门，但一个部门可以包含多位员工。为了实现一对多关联映射，可以借助<collection>元素来完成这样的映射。

2. 创建实体类和数据库

(1) 员工类Employee已存在，在chapter03项目的com.qfedu.pojo包中新建部门实体类Department，具体代码如例311所示。

例311Department.java。



 1public class Department {

 2private int id;   //部门表id

 3private String name;   //部门名称

 4private List<Employee> employees;   //员工集合

 5//此处省略构造方法、Getter()、Setter()和toString方法

 6}






(2) 在数据库student中创建部门表department，SQL语句如下所示。



DROP TABLE IF EXISTS 'department';

CREATE TABLE 'department' (

'id' int(0) NOT NULL AUTO_INCREMENT,

'name' varchar(255) NULL DEFAULT NULL,

PRIMARY KEY('id') USING BTREE

)ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci 

ROW_FORMAT = Dynamic;






(3) 向部门表插入数据，SQL语句如下所示。



INSERT INTO 'department' VALUES (1, '宣传部');

INSERT INTO 'department' VALUES (2, '行政部');






3. 编写映射文件

(1) 在chapter03项目的com.qfedu.mapper包中新建DepartmentMapper接口，具体代码如例312所示。

例312DepartmentMapper.java。



 1public interface DepartmentMapper{

 2List<Department> findAllDepartment();

 3}






(2) 在chapter03项目的com.qfedu.mapper包中新建名为DepartmentMapper的XML文件，作为DepartmentMapper接口的映射文件，具体代码如例313所示。

例313DepartmentMapper.xml。



 1<?xml version="1.0" encoding="UTF-8"?>

 2<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

 3"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

 4<mapper namespace="com.qfedu.mapper.DepartmentMapper">

 5<resultMap id="departmentMap" type="department">

 6<id property="id" column="did"/>

 7<result property="name" column="name"/>

 8<collection property="employees" ofType="employee">

 9<id property="eid" column="id"/>

 10<result property="name" column="name"/>

 11</collection>

 12</resultMap>

 13<select id="findAllDepartment" resultMap="departmentMap">

 14select d.id did,d.name,e.name,e.id eid  from department d 

 15left join employee  e on e.did = d.id

 16</select>

 17</mapper>






在例313中，定义了一个名为departmentMap的映射规则，用<collection>元素将department表的数据映射到department对象和关联的employees对象中。同时，本示例中还定义了一个查询操作employees，用于查询部门信息，并在查询结果中包含了与部门关联的员工信息。

4. 编写测试类

(1) 在chapter03项目的com.qfedu.test包中创建TestFindAllDepartment类，用于验证一对多关联映射，具体代码如例314所示。

例314TestFindAllDepartment.java。



 1public class TestFindAllDepartment {

 2public static void main(String［］ args) {

 3/*创建输入流*/

 4InputStream inputStream = null;

 5/*将MyBatis配置文件转化为输入流*/

 6try {

 7inputStream =

 8Resources.getResourceAsStream("mybatis-config.xml");

 9} catch (IOException e) {

 10e.printStackTrace();








 11}

 12/*通过SqlSessionFactoryBuilder()创建SqlSessionFactory对象*/

 13SqlSessionFactory build =

 14new SqlSessionFactoryBuilder().build(inputStream);

 15/*通过SqlSessionFactory对象创建SqlSession对象*/

 16SqlSession sqlSession = build.openSession();

 17DepartmentMapper mapper = 

 18sqlSession.getMapper(DepartmentMapper.class);

 19List<Department> departments = mapper.findAllDepartment();

 20for (Department department : departments) {

 21System.out.println(department.toString());

 22}

 23/*关闭事务*/

 24sqlSession.close();

 25}

 26}






(2) 执行例314中的main()方法。测试一对多关联映射的结果如图33所示。



图33测试一对多关联映射的结果


从图33可以看出，Department类中的集合对象employees一对多映射成功，输出该部门员工的详细信息。

3.2.3多对多关联映射
1. 设计背景
多对多关联映射是指两个实体之间存在多对多的关系，通常需要中间表来建立它们之间的连接。

在一个OA管理系统中，涉及两个实体： 员工和技能培训课程。由于培训需求中，每个员工可以选择参加多门技能培训课程，同时每门技能培训课程也可以有多名员工参加。每个员工有对应的工号。为了有效地处理这种多对多的关系，可以通过MyBatis的<collection>元素实现这种关联映射。

2. 创建实体类和数据库

(1) 在chapter03项目的com.qfedu.pojo包中新建技能培训课程的实体类Course，具体代码如例315所示。

例315Course.java。



 1public class Course {

 2Integer id;

 3String courseName;

 4List<Employee> employees;

 5此处省略Getter()、Setter()、toString()和构造方法

 6}






(2) 员工类中需要课程类的实体类集合属性，在Employee类中添加集合对象courses，具体代码如例316所示。

例316Employee.java。



 1public class Employee {

 2private int id;

 3private String name;

 4private List<Course> courses;

 5}






(3) 创建技能培训课程表course，SQL语句如下所示。



DROP TABLE IF EXISTS 'course';

CREATE TABLE 'course' (

'id' int(0) NOT NULL AUTO_INCREMENT,

'course_name' varchar(255) CHARACTER NOT NULL,

PRIMARY KEY('id') USING BTREE

) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = 

utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;






(4) 向技能培训课程表中插入数据，SQL语句如下所示。



INSERT INTO 'course' VALUES (1, '礼仪培训');

INSERT INTO 'course' VALUES (2, '话术培训');






(5) 多对多关联映射需要中间表做关联，创建中间表employee_course的SQL语句如下所示。



DROP TABLE IF EXISTS 'employee_course';

CREATE TABLE 'employee_course' (

'id' int(0) NOT NULL AUTO_INCREMENT,

'e_id' int(0) NOT NULL,

'c_id' int(0) NOT NULL,

PRIMARY KEY('id') USING BTREE

) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = 

utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;






中间表employee_course包括3个字段： 主键id、表示员工id的e_id和表示课程id的c_id。

(6) 向中间表中插入数据，SQL语句如下所示。



INSERT INTO 'employee_course' VALUES (1, 1, 1);

INSERT INTO 'employee_course' VALUES (2, 2, 1);

INSERT INTO 'employee_course' VALUES (3, 3, 2);






3. 创建接口文件和映射文件

(1) 在chapter03项目的EmployeeMapper接口中新增查询员工的技能培训课程的方法，具体代码如例317所示。

例317EmployeeMapper.java。



 1public interface EmployeeMapper {  

 2List<Employee> findEmployeeCourse();

 3}






(2) 在chapter03项目的EmployeeMapper.xml文件中创建多对多映射关系，具体代码如例318所示。

例318EmployeeMapper.xml。



 1<?xml version="1.0" encoding="UTF-8"?>

 2<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

 3"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

 4<mapper namespace="com.qfedu.mapper.EmployeeMapper">

 5<resultMap id="courseMap" type="employee">

 6<id column="eid" property="id" />

 7<result column="ename" property="name"/>

 8<collection property="courses" ofType="com.qfedu.pojo.Course">

 9<id column="id" property="cid"/>

 10<result column="course_name" property="courseName"></result>

 11</collection>

 12</resultMap>

 13<select id="findEmployeeCourse" resultMap="courseMap">

 14select  e.id eid,e.name ename,c.id cid,c.course_name courseName

 15from  employee e

 16left join employee_course ec

 17on e.id = ec.e_id

 18left join

 19course c

 20on

 21ec.c_id = c.id

 22</select>

 23</mapper>






在例318中，定义了一个名为courseMap的映射规则，用<collection>元素将员工与其参与的课程相关联。同时，本例中还定义了一个查询操作findEmployeeCourse，从数据库中选择员工信息以及他们参与的课程，并将结果映射到Java对象中，以便获取员工与课程的多对多关联信息。

4. 编写测试类

(1) 在chapter03项目的com.qfedu.test包中新建TestFindAEmployeeCourse类，用于验证多对多关联映射，具体代码如例319所示。

例319TestFindAEmployeeCourse.java。



 1public class TestFindAEmployeeCourse {

 2public static void main(String［］ args) {

 3/*创建输入流*/

 4InputStream inputStream = null;

 5/*将MyBatis配置文件转化为输入流*/

 6try {

 7inputStream =

 8Resources.getResourceAsStream("mybatis-config.xml");








 9} catch (IOException e) {

 10e.printStackTrace();

 11}

 12/*通过SqlSessionFactoryBuilder()创建SqlSessionFactory对象*/

 13SqlSessionFactory build =

 14new SqlSessionFactoryBuilder().build(inputStream);

 15/*通过SqlSessionFactory对象创建SqlSession对象*/

 16SqlSession sqlSession = build.openSession();

 17EmployeeMapper mapper = sqlSession.getMapper(

 18EmployeeMapper.class);

 19List<Employee> employeeCourse = mapper.findEmployeeCourse();

 20for (Employee employee : employeeCourse) {

 21System.out.println(employee);

 22}

 23/*关闭事务*/

 24sqlSession.close();

 25}

 26}






(2) 执行例319中的main()方法，测试多对多关联映射的结果如图34所示。



图34测试多对多关联映射的结果


从图34可以看出，Employee类中的集合对象course多对多映射成功。

MyBatis的关联映射可以提高查询效率、避免冗余数据、简化代码、提高可读性、支持高级查询等，对于开发大型数据库应用程序具有重要意义。

3.3实战演练： 智慧农业果蔬系统中普通
用户的数据管理
为了加深对MyBatis核心组件相关编程知识的理解，本节以智慧农业果蔬系统为例，开发该系统中普通用户的管理模块。通过对该模块的实现，读者可以掌握Mapper和XML映射文件的相关知识。本实战演练的实战描述、实战分析和实现步骤如下所示。

【实战描述】

使用IDEA软件搭建一个Web项目chapter03，通过MyBatis框架的SqlSession语法完成对MySQL数据库chapter03下普通用户表user的增、删、改、查操作，并在控制台输出日志信息。

【实战分析】

(1) 创建一个名为chapter03的数据库，并在该数据库下创建数据表user。 

(2) 向表中插入测试数据。 

(3) 在IDEA软件中创建一个名为chapter03的项目，并引入MyBatis的相关JAR包。 

(4) 在chapter03项目下创建对应的POJO类、接口、映射文件、配置文件和测试类。 

(5) 编写和执行测试类，验证数据库中的数据表信息是否同步，并查看控制台的打印日志是否正确。

【实现步骤】

1. 搭建开发环境

(1) 在MySQL中创建数据库chapter03和数据表user，SQL语句如例320所示。

例320user.sql。



 1DROP TABLE IF EXISTS 'user';

 2CREATE TABLE 'user'  (

 3'id' int(0) NOT NULL AUTO_INCREMENT COMMENT '注解ID',

 4'userName' varchar(255) CHARACTER SET DEFAULT NULL COMMENT '用户名',

 5'passWord' varchar(255) CHARACTER SET DEFAULT NULL COMMENT '密码',

 6'phone' varchar(255) CHARACTER SET DEFAULT NULL COMMENT '手机号',

 7'realName' varchar(255) CHARACTER DEFAULT NULL COMMENT '真实姓名',

 8'sex' varchar(255) CHARACTER SET DEFAULT NULL COMMENT '性别',

 9'address' varchar(255) CHARACTER SET DEFAULT NULL COMMENT '地址',

 10'email' varchar(255) CHARACTER SET DEFAULT NULL COMMENT '邮箱',

 11PRIMARY KEY('id') USING BTREE

 12) ENGINE = InnoDB AUTO_INCREMENT = 9 CHARACTER SET = utf8 COLLATE = 

 13utf8_general_ci ROW_FORMAT = Dynamic;






(2) 向数据表user中插入数据，SQL语句如下所示。



INSERT INTO 'user' VALUES (1, '曾*梁', '2', '138****6907', '曾*梁', '男', '北京市昌平区', '138****6907@163.com');

INSERT INTO 'user' VALUES (2, 'wu', 'dd', '156****1543', '吴*英', '男', '北京市海淀区', '156****1543@163.com');

INSERT INTO 'user' VALUES (3, '吴*德', '111111', '192****9012', '吴*德', '女', '北京市丰台区', '192****9012@163.com');

INSERT INTO 'user' VALUES (6, 'wang', '123456', '155****2130', '王*强', '女', '北京市房山区', '155****2130@163.com');

INSERT INTO 'user' VALUES (7, 'fang', '123456', '170****1239', '方*智', '女', '北京市通州区', '170****1239@163.com');

INSERT INTO 'user' VALUES (8, 'jian', '11', '166****8613', '*坚', '男', '北京市密云区', '166****8613@163.com');






(3) 在Windows的命令提示符窗口中输入查询user表数据的SQL语句，具体语句如下所示。



select * from user;






(4) 执行查询user表数据的SQL语句，查询结果如图35所示。



图35user表查询结果


从图35中可以看出，user表数据添加成功。

2. 创建项目

(1) 在IDEA中新建Web项目chapter03，将MyBatis的JAR包mybatis3.5.6.jar复制到WEBINF下的lib文件夹中，完成JAR包的导入。

(2) 在chapter03项目的src目录下创建com.qfedu.pojo包，并在该包下新建User类，具体代码如例321所示。

例321User.java。



 1public class User {

 2private int id;

 3private String userName;

 4private String passWord;

 5private String phone;

 6private String realName;

 7private String sex;

 8private String address;

 9private String email;

 10//此处省略Getter/Setter、toString()和构造方法

 11}






需要注意的是，在上述代码中，User类必须提供Setter方法，这样MyBatis框架才能通过配置文件映射User类和数据表user的关系。

(3) 在resource目录下新建MyBatis的配置文件mybatisconfig.xml，具体代码如例322所示。

例322mybatisconfig.xml。



 1<?xml version="1.0" encoding="UTF-8" ?>

 2<!DOCTYPE configuration

 3PUBLIC "-//mybatis.org//DTD Config 3.0//EN"

 4"http://mybatis.org/dtd/mybatis-3-config.dtd">

 5<configuration>

 6<!--设置 -->

 7<settings>

 8<!--开启数据库日志检测-->

 9<setting name="logImpl" value="STDOUT_LOGGiNG"/>

 10</settings>

 11<!--包名简化缩进-->

 12<typeAliases>

 13<!--typeAlias方式-->

 14<package name="com.qfedu.pojo"/>

 15</typeAliases>

 16<!--配置环境-->

 17<environments default="dev">

 18<!--配置MySQL环境-->

 19<environment id="dev">

 20<!--配置事务管理器-->

 21<transactionManager type="JDBC"/>

 22<!--配置数据库连接-->

 23<dataSource type="POOLED">








 24<!--配置数据库连接驱动-->

 25<property name="driver" value="com.mysqljdbc.Driver"/>

 26<!--配置数据库连接地址-->

 27<property name="url" value="localhost:3306/chapter02"/>

 28<!--配置用户名-->

 29<property name="username" value="root"/>

 30<!--配置密码-->

 31<property name="password" value="root"/>

 32</dataSource>

 33</environment>

 34</environments>

 35<mappers>

 36<package name="com.qfedu.mapper"/>

 37</mappers>

 38</configuration>






在例322中，第23～32行代码用于配置数据库的连接信息，其中<dataSource>元素的4个属性分别配置数据库的驱动、URL、用户名和密码； 第35～37行代码通知MyBatis在包com.qfedu.mapper下寻找并加载映射文件。

(4) 在src目录下创建com.qfedu.mapper包，在该包下新建UserMapper接口，用于声明查询、新增、修改和删除的方法，具体代码如例323所示。

例323UserMapper.java。



 1public interface UserMapper {

 2//查询

 3List<User> findAllUser();

 4//新增

 5Integer insertUser(User User);

 6//修改

 7Integer updateUser(User User);

 8//删除

 9Integer deleteUser(User User);

 10}






(5) 在com.qfedu.mapper包下新建UserMapper接口对应的映射文件UserMapper.xml，具体代码如例324所示。

例324UserMapper.xml。



 1<?xml version="1.0" encoding="UTF-8"?>

 2<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

 3"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

 4<mapper namespace="com.qfeud.mapper.UserMapper">

 5<select id="findAllUser" resultType="com.qfedu.pojo.User">

 6select * from User

 7</select>

 8<insert id="insertUser" parameterType="com.qfedu.pojo.User">

 9insert into user(userName,passWord,phone,relName,sex,address,email)

 10values(#{userName},#{passWord},#{phone},#{relName},#{sex},

 11#{address},#{email})

 12</insert>

 13<update id="updateUser" parameterType="com.qfedu.pojo.User">

 14update User set passWord= #{passWord} where id =#{id}








 15</update>

 16<delete id="deleteUser">

 17delete from User where id= #{id}

 18</delete>

 19</mapper>






在例324中，第5行代码<select>元素中的id属性值findAllUser用于映射UserMapper接口中的findAllUser()方法； 第8行代码<insert>元素中的id属性值insertUser用于映射UserMapper接口中的insertUser()方法； 第13行代码<update>元素中的id属性值updateUser用于映射UserMapper接口中的updateUser()方法； 第16行代码<delete>元素中的id属性值deleteUser用于映射UserMapper接口中的deleteUser()方法。

3. 编写测试类

(1) 在src目录下创建com.qfedu.test包，在该包下新建TestFindAllUser类，该类测试查询user表中所有普通用户的数据信息操作，具体代码如例325所示。

例325TestFindAllUser.java。



 1public class TestFindAllUser {

 2public static void main(String［］ args) {

 3/*创建输入流*/

 4InputStream inputStream = null;

 5/*将MyBatis配置文件转化为输入流*/

 6try {

 7inputStream =

 8Resources.getResourceAsStream("mybatis-config.xml");

 9} catch (IOException e) {

 10e.printStackTrace();

 11}

 12/*通过SqlSessionFactoryBuilder()创建SqlSessionFactory对象*/

 13SqlSessionFactory build =

 14new SqlSessionFactoryBuilder().build(inputStream);

 15/*通过SqlSessionFactory对象创建SqlSession对象*/

 16SqlSession sqlSession = build.openSession();

 17List<User> Users = sqlSession.selectList

 18("com.qfedu.mapper.UserMapper.findAllUser");

 19for (User User : Users) {

 20System.out.println(User);

 21}

 22/*关闭事务*/

 23sqlSession.close();

 24}

 25}






(2) 执行TestFindAllUser类的main()方法，查询智慧农业果蔬系统中普通用户信息的结果如图36所示。



图36查询智慧农业果蔬系统中普通用户信息的结果


从图36可以看出，控制台输出智慧农业果蔬系统中普通用户的6条数据信息，查询普通人员的操作执行成功。

(3) 在com.qfedu.test包下新建TestInsertUser类，该类用于实现向user表中新增一条记录，用户名为“周*扬”，密码为“24”，地址为“北京”，具体代码如例326所示。

例326TestInsertUser.java。



 1public class TestInsertUser {

 2public static void main(String［］ args) {

 3/*创建输入流*/

 4InputStream inputStream = null;

 5/*将MyBatis配置文件转化为输入流*/

 6try {

 7inputStream =

 8 Resources.getResourceAsStream("mybatis-config.xml");

 9} catch (IOException e) {

 10e.printStackTrace();

 11}

 12/*通过SqlSessionFactoryBuilder()创建SqlSessionFactory对象*/

 13SqlSessionFactory build =

 14new SqlSessionFactoryBuilder().build(inputStream);

 15/*通过SqlSessionFactory对象创建SqlSession对象*/

 16SqlSession sqlSession = build.openSession(true);

 17User User = new User();

 18User.setUserName("周*扬");

 19User.setPassWord("24");

 20User.setAddress("北京"); 

 21sqlSession.insert("com.qfedu.mapper.UserMapper.insertUser",User);

 22/*关闭事务*/

 23sqlSession.close();

 24}

 25}






(4) 执行TestInsertUser类的main()方法，控制台的新增日志如图37所示。



图37控制台的新增日志


从图37中可以看出，控制台的日志输出一条用户名为“周*扬”、密码为“24”、地址为“北京”的插入语句，并返回受影响的行数为1，新增普通用户的操作执行成功。

(5) 在com.qfedu.test包下新建TestUpdateUser类，该类用于实现修改id为10的记录，具体代码如例327所示。

例327TestUpdateUser.java。



 1public class TestUpdateUser {

 2public static void main(String［］ args) {

 3/*创建输入流*/

 4InputStream inputStream = null;

 5/*将MyBatis配置文件转化为输入流*/

 6try {

 7inputStream =

 8Resources.getResourceAsStream("mybatis-config.xml");

 9} catch (IOException e) {

 10e.printStackTrace();

 11}

 12/*通过SqlSessionFactoryBuilder()创建SqlSessionFactory对象*/

 13SqlSessionFactory build =

 14new SqlSessionFactoryBuilder().build(inputStream);

 15/*通过SqlSessionFactory对象创建SqlSession对象*/

 16SqlSession sqlSession = build.openSession(true);

 17User User = new User();

 18User.setId(10);

 19User.setPassWord("123456");

 20sqlSession.update("com.qfedu.mapper.UserMapper.updateUser",User);

 21/*关闭事务*/

 22sqlSession.close();

 23}

 24}






(6) 执行TestUpdateUser类的main()方法，控制台的修改日志如图38所示。



图38控制台的修改日志


从图38中可以看出，控制台的日志输出一条id为10、账号密码为123456的修改语句，修改普通用户的操作执行成功。

(7) 在com.qfedu.test包下新建TestDeleteUser类，用于测试删除id为10的记录的操作，具体代码如例328所示。

例328TestDeleteUser.java。



 1public class TestDeleteUser {

 2public static void main(String［］ args) {

 3/*创建输入流*/

 4InputStream inputStream = null;

 5/*将MyBatis配置文件转化为输入流*/

 6try {

 7inputStream =

 8Resources.getResourceAsStream("mybatis-config.xml");

 9} catch (IOException e) {

 10e.printStackTrace();

 11}

 12/*通过SqlSessionFactoryBuilder()创建SqlSessionFactory对象*/

 13SqlSessionFactory build =

 14new SqlSessionFactoryBuilder().build(inputStream);

 15/*通过SqlSessionFactory对象创建SqlSession对象*/

 16SqlSession sqlSession = build.openSession(true);   

 17sqlSession.delete("com.qfedu.mapper.UserMapper.deleteUser",10);

 18/*关闭事务*/

 19sqlSession.close();

 20}

 21}






(8) 执行TestDeleteUser类的main()方法，控制台输出的删除普通用户的日志如图39所示。



图39控制台输出的删除普通用户的日志


从图39中可以看出，控制台的日志输出一条id为10的删除语句，并返回受影响的行数1，删除普通用户的操作执行成功。

本节使用MyBatis的基础知识实现了智慧农业果蔬系统中普通用户的数据管理模块，要求读者掌握MyBatis的映射文件、关联映射、基本语法和使用规范。

3.4本 章 小 结

本章首先介绍了MyBatis的映射文件结构和元素的使用方法，然后讲解了MyBatis的关联关系映射，最后通过一个实战演练帮助读者巩固MyBatis的映射文件、关联映射、基本语法和使用规范的灵活运用。通过对本章的学习，读者可以更好地理解和应用MyBatis的映射文件，实现高效、灵活的数据库操作，了解如何处理复杂的关联映射数据。

3.5习题

一、 填空题

1. MyBatis的映射文件名一般为。

2. 在MyBatis的映射文件中，用于映射查询语句的元素是。

3. 在MyBatis的映射文件中，用于定义可重用SQL代码片段的元素是。

4. 在MyBatis中，如果关联关系的Java对象名称与数据库表字段名称不一致，可以使用标签对它们进行映射。

5. MyBatis的3种关联关系映射分别是、和。

二、 选择题

1. 在MyBatis中，以下哪个标签用于定义关联关系映射？()



A. <select>B. <insert>C. <update>D. <association>

2. 在MyBatis的关联关系映射中，以下哪个标签用于定义一对一关联关系?()

A. <association>B. <collection>


C. <resultMap>D. <parameterMap>

3. 在MyBatis的关联关系映射中，以下哪个标签用于定义一对多关联关系?()

A. <association>B. <collection>

C. <resultMap>D. <parameterMap>

4. 关于MyBatis的映射文件，下列描述错误的是()。

A. 一个MyBatis配置文件中可引入多个映射文件

B. 在编写MyBatis的映射文件时，开发人员无须关心元素顺序

C. <mappers>元素是MyBatis映射文件的根元素

D. 在编写MyBatis映射文件时，不是所有的元素都必须配置

5. 在下列选项中，不属于<select>元素的属性是()。

A. idB. resultTypeC. resultMapD. value

三、 简答题

1. 简述常见的MyBatis映射文件元素的功能和用法。

2. 简述一对一表关系的处理过程。

3. 简述一对多表关系的处理过程。

四、 操作题

请编写一个程序，实现使用MyBatis标签对Dog类进行增、删、改、查操作，具体步骤可参考下方内容。

(1) 创建Dog类，在该类中添加name、age属性。 

(2) 搭建MyBatis框架，使用MyBatis标签对Dog类进行增、删、改、查操作。