Mybatis详细教程

前言

环境：
· JDK1.8
· Mysql 5.7
· maven3.6.1
· IDEA
回顾：
· JDBC
· Mysql
· Java基础
· Maven
· Junit

一、简介

1、什么是Mybatis

​ · MyBatis 是一款优秀的持久层框架，
​ · 它支持自定义 SQL、存储过程以及高级映射。
​ · MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
​ · MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

2、如何获取Mybatis

· GitHub：[Releases · mybatis/mybatis-3 · GitHub](https://github.com/mybatis/mybatis-3/releases)

· 中文文档：[mybatis – MyBatis 3 | 简介](https://mybatis.org/mybatis-3/zh/index.html)

· Maven仓库：
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.2</version>
</dependency>

3、持久化

数据持久化：
· 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
· 内存：断电即失
· 数据库：io文件持久化

为什么需要持久化：
· 有一些对象，不能让他丢失
· 内存太贵了

4、持久层

Dao层、Service层、Controller层…
· 完成持久化工作的代码块
· 层界限十分明显

5、为什么需要Mybatis

• ​ · 方便。
• ​ · 传统的JDBC代码太复杂了，简化。
• ​ · 帮助程序员将数据存入到数据库中。
• ​ · 不用Mybatis也可以。
• ​ · 用了更容易上手。
• ​ · 使用的人多

二、第一个Mybatis程序

搭建环境–>导入Mybatis–>编写代码–>测试

1、 搭建环境

创建数据库；新建项目；新建一个普通的maven项目，不使用自带的archetype；删除src目录；导入maven依赖

<!--导入依赖-->
<dependencies>
<!--    mysql驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
<!--    mybatis-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>
<!--    junit-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>建一个模块

2、创建一个模块

编写mybatis的核心配置文件

<!--configuration核心配置文件-->
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value=""/>
            </dataSource>
        </environment>
    </environments>
</configuration>

编写mybatis工具类

public class MybatisUtils {
    
    private static SqlSessionFactory sqlSessionFactory;
    
    static {
        try {
            //使用mybatis获取sqlSessionFactory的第一步
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
    
    public static SqlSession getSqlSession(){

        return sqlSessionFactory.openSession();
    }
}

3、 编写代码

实体类

public class User {

    private int id;
    private String name;
    private String pwd;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

Dao接口

package com.wang.dao;

import com.wang.pojo.User;

import java.util.List;

/**
 * @author Wang
 * @date 2021/5/3 0003 17:19
 * description Dao===Mapper
 */
public interface UserDao {

    List<User> getUserList();
}

接口实现类

<?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是绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.wang.dao.UserDao">
<!--    select查询语句-->
    <select id="getUserList" resultType="com.wang.pojo.User">
        select * from Mybatis.user where id = #{id}
    </select>
</mapper>

4、 测试

​ · 遇到的问题1
​ org.apache.ibatis.binding.BindingException: Type interface com.wang.dao.UserDao is not known to the MapperRegistry.
​ MapperRegistry是什么？
​ 核心配置文件中注册mybatis。

<!--    每一个Mapper.xml都需要在Mybatis核心配置文件中注册-->
    <mappers>
        <mapper resource="com/wang/dao/UserMapper.xml"/>
    </mappers>

​ 加入这些代码之后，运行可能还会报错：说找不到UserMappet.xml文件
​ 修改方法如下，在pom文件中加入如下代码

<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

三、CRUD

​ · 编写接口
​ · 编写mapper中的sql语句
​ · 编写测试类

1、namespace

​ namespace中的包名要和Dao中的包名一致。

2、select

选择、查询语句

<mapper namespace="com.wang.dao.UserMapper">
<!--    查询语句-->
    <select id="getUserList" resultType="com.wang.pojo.User">
        select * from Mybatis.user
    </select>
</mapper>

id是UserMapper中对应的getUserList()方法
resultType：sql语句执行的返回值
parameType：参数类型

3、 insert

//    增删改需要提交事务
    @Test
    public void addUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

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

        User user = new User(5,"杜兰特","12345");

        int a = mapper.addUser(user);

        if(a > 0){
            System.out.println("插入成功！！！");
        }
//        提交事务
        sqlSession.commit();
        sqlSession.close();
    }

这里必须要提交事务，sqlSession.commit()不然就会插入失败。

4、delete

<delete id="deleteUser" parameterType="int">
    delete from Mybatis.user where id=#{id}
</delete>

5、update

<update id="updateUser" parameterType="com.wang.pojo.User">
    update Mybatis.user set name=#{name},pwd=#{pwd} where id=#{id}
</update>

6、注意点

增删改需要提交事务！！！

7、分析错误

​ · 标签必须要一致
​ · resource绑定mapper，需使用路径
​ · 程序配置文件必须符合规范

8、万能Map

<!--    后面传递的值是map中的数值 userName，也就是map中的键-->
    <insert id="addUser2" parameterType="map">
        insert into mybatis.user(name,pwd) values(#{userName},#{password})
    </insert>

@Test
public void addUser2(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    HashMap<String,Object> map = new HashMap<String, Object>();
    map.put("userName","我是增加");
    map.put("password","12345");
    int a = mapper.addUser2(map);
    if(a>0){
        System.out.println("添加成功！！！");
    }
    sqlSession.commit();
    sqlSession.close();
}

当我们的实体类，或者数据库中的表、字段或者参数过多，我们应当考虑使用Map！！！

9、思考题

​ 1、java代码执行的时候，传递通配符% %
​ List<User> userList = mapper.getUserLike("%小%");

​ 2、在sql拼接中使用通配符！
​ select * from Mybatis.user where from name like "%"#{value}"%"

四、配置解析

1、核心配置文件

​ · mybatis-config.xml
​ · MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。 配置文档的顶层结构如下：

• configuration（配置）
  • properties（属性）
  • settings（设置）
  • typeAliases（类型别名）
  • typeHandlers（类型处理器）
  • objectFactory（对象工厂）
  • plugins（插件）
  • environments（环境配置）
    • environment（环境变量）
      • transactionManager（事务管理器）
      • dataSource（数据源）
  • databaseIdProvider（数据库厂商标识）
  • mappers（映射器）

2、环境配置

Mybatis可以配置适应多种环境。
不过要记住，尽管可以配置多个环境，但每个SqlSessionFactory实例只能选择一种环境。
学会配置多种运行环境！！！
Mybatis默认的事务管理器就是JDBC，连接池：POOLED。

3、属性（properties）

这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 db.properties 元素的子元素中设置。例如：

<properties resource="org/mybatis/example/config.properties">
  <property name="username" value="dev_user"/>
  <property name="password" value="F2Fa3!33TYyg"/>
</properties>

设置好的属性可以在整个配置文件中用来替换需要动态配置的属性值。比如:

<dataSource type="POOLED">
  <property name="driver" value="${driver}"/>
  <property name="url" value="${url}"/>
  <property name="username" value="${username}"/>
  <property name="password" value="${password}"/>
</dataSource>

编写一个配置文件db.properties

driver = com.mysql.jdbc.Driver
url = jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8
username = root
password = 

在核心配置文件中引入

<!--    引入外部配置文件-->
    <properties resource="db.properties" />

可以直接引入外部文件
可以在其中增加一些属性配置
如果两个文件有同一个字段，优先使用外部配置文件

4、类型别名优化（typeAliases）

类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写

<!--    可以给实体类起别名-->
    <typeAliases>
        <typeAlias type="com.wang.pojo.User" alias="User"/>
    </typeAliases>

<select id="getUserList" resultType="User">    
    select * from Mybatis.user
</select>

​ 也可以指定一个包名，MyBatis会在包名下面搜索需要的Java Bean，比如扫描实体类的包，它的默认别名就是这个类的类名，首字母小写！！！

<typeAliases>        
    <package name="com.wang.pojo"/>    
</typeAliases>

之前的select中的resultType=“com.wang.pojo.User”，现在在上方起了别名之后，即可修改为User别名即可。

• 如果实体类十分多，建议使用第二种方式。
• 在实体类比较少的时候，使用第一种方式。

​第一种可以DIY别名，第二种则不行，如果非要改，需要在实体类上增加注解。

5、其他配置

• 类型处理器（typeHandlers）
• 对象工厂（objectFactory）
• plugins插件
  • mybatis-generator-core
  • mybatis-plus
  • 通用mapper

6、映射器

​ MapperRegistry：注册绑定我们的Mapper文件；

方式一：

!--    每一个Mapper.xml都需要在Mybatis核心配置文件中注册-->    <mappers>        <mapper resource="com/wang/dao/UserMapper.xml"/>    </mappers>

方式二：使用class文件注册

	<mappers>	        <mapper class="com.wang.dao.UserMapper"/>    </mappers>

方式三：使用扫描包进行注入

	<mappers>
        <package name="com.wang.dao"/>
    </mappers>

注意点：

• 接口和他的Mapper配置文件必须同名。
• 接口和他的Mapper配置文件必须在同一个包下。

练习时间：

• 将数据库配置文件外部引入。
• 实体类类名。
• 保证UserMapper接口和UserMapper.xml改为一致，并且放在同一个包下。

五、生命周期

生命周期和作用域是至关重要的，因为错误的使用会导致非常严重的并发问题。
SqlSessionFactoryBuilder：

• 一旦创建了SqlSessionFactory，就不再需要他了。
• 局部变量。

SqlSessionFactory：

• 说白了就是可以想象为：数据库连接池
• SqlSessionFactory一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或者重新创建另一个实例。
• 因此SqlSessionFactory的最佳作用域是应用作用域。
  SqlSession
• 连接到连接池的一个请求。
• 用完之后赶紧关闭，否则资源被占用！

六、解决属性名和字段名不一致的问题

数据库中的字段

1、方法1

新建一个项目，拷贝之前的，测试实体类字段不一致的情况。

public class User {

    private int id;
    private String name;
    private String password;
}

测试出现的问题

解决方法：

<select id="getUserById" resultType="com.wang.pojo.User" parameterType="int">
    select id,name,pwd as password from Mybatis.user where id = #{id}
</select>

2、方法2

<resultMap id="UserMap" type="User">
    <result column="id" property="id" />
    <result column="name" property="name"/>
    <result column="pwd" property="password"/>
</resultMap>

<select id="getUserById" resultMap="UserMap">
    select * from Mybatis.user where id = #{id}
</select>

· ResultMap元素是MyBatis中最重要最强大的元素。

· ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

· 在学习了上面的知识后，你会发现上面的例子没有一个需要显式配置 ResultMap，这就是 ResultMap 的优秀之处——你完全可以不用显式地配置它们。 虽然上面的例子不用显式配置 ResultMap。 但为了讲解，我们来看看如果在刚刚的示例中，显式使用外部的 resultMap 会怎样，这也是解决列名不匹配的另外一种方式。

· 如果世界也这么简单就好了。

七、日志

1、日志工厂

如果一个数据库操作，出现了异常，我们需要排错。日志就是最好的助手！
曾经：sout、debug
现在：日志工厂！

• SLF4J【掌握】
• LOG4J ·
• LOG4J2 ·
• JDK_LOGGING
• COMMONS_LOGGING ·
• STDOUT_LOGGING【掌握】 ·
• NO_LOGGING

在mybatis中具体使用哪一个日志实现，在设置中设定。
STDOUT_LOGGING标准日志输出

配置日志：

<settings>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

输出日志：

3、Log4j

什么是log4j

• Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的是控制台、文件、GUI组件。
• 我们也可以控制每一条日志的输出格式。
• 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
• 通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

先导入log4j包

在pom文件中导入log4j依赖

<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

log4j.properties

log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=【%c】-%m%n

#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/kuang.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=【%p】【%d{yy-MM-dd}】【%c】%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

配置log4j为日志的实现

    <settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>  

Log4j的使用

简单使用

1、在要使用Log4j的类中导入包import org.apache.log4j.Logger;
2、日志对象，参数为当前类的class

static Logger logger = Logger.getLogger(String.valueOf(UserDaoTest.class));

3、日志级别

logger.info("info:进入了testLog4j");
logger.debug("debug:进入了testLog4j");
logger.error("error:进入了testLog4j");

八、分页

1、为什么要分页？

· 减少数据的处理量，提高效率。

2、分页方式

方式一：limit分页

SELECT * FROM user limit 0,5; //表示每页显示5个，从第0个开始。
SELECT * FROM user limit 2; //如果只给定一个参数，就默认从0开始，每页显示2个。

方式二：使用Mybatis实现分页，核心SQL

1、接口

List<User> getUserByLimit(Map<String,Integer> map);

2、Mapper.xml

<select id="getUserByLimit" resultMap="UserMap" parameterType="Map">
        select * from mybatis.user limit #{startIndex},#{pageSize}
    </select>

3、测试

@Test
    public void getUserByLimit(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

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

        HashMap<String,Integer> map = new HashMap<String, Integer>();

        map.put("startIndex",0);
        map.put("pageSize",2);

        List<User> list = mapper.getUserByLimit(map);

        for(User user : list){
            System.out.println(user);
        }

        sqlSession.close();
    }

3、RowBounds分页

不再使用SQL实现分页。

1、接口：

List<User> getUserByRowBounds();

2、Mapper.xml：

<!--    分页2-->
    <select id="getUserByRowBounds" resultMap="UserMap">
        select * from mybatis.user
    </select>

3、测试：

@Test
    public void getUserByRowBounds(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

//        RowBounds实现
        RowBounds rowBounds = new RowBounds(1,2);
//        通过java代码层面实现分页
        List<User> userList = sqlSession.selectList("com.wang.dao.UserMapper.getUserByRowBounds",null,rowBounds);

        for(User user : userList){
            System.out.println(user);
        }

        sqlSession.close();
    }

九、使用注解开发

1、注解在接口上实现

 @Select("select * from user")
 List<User> getUsers();

2、需要在核心配置文件中绑定接口

<!--    绑定接口-->
<mappers>
    <mapper class="com.wang.dao.UserMapper" />
</mappers>

3、测试

@Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

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

        List<User> userList = mapper.getUsers();

        for(User user:userList){
            System.out.println(user);
        }

        sqlSession.close();
    }

5、CRUD

public static SqlSession getSqlSession(){
//        设置为true之后，进行增删改的时候不需要再去提交事务了
        return sqlSessionFactory.openSession(true);
}

加上true之后，不需要在进行增删改的时候提交事务了

@Test
public void addUser(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();

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

    mapper.addUser(new User(1,"增加注解用户","12345"));

    sqlSession.close();
}

没有设置为true的时候是这样的：

@Test
    public void addUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

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

        User user = new User(5,"杜兰特","12345");

        int a = mapper.addUser(user);

        if(a > 0){
            System.out.println("插入成功！！！");
        }
//        提交事务
        sqlSession.commit();
        sqlSession.close();
    }

关于@Param注解

• 基本类型的参数或者String类型，需要加上
• 引用类型不需要加
• 如果只有一个基本类型的话，可以忽略，但是建议大家加上！
• 我们在SQL中引用的就是我们这里的@Param(“uid”)中设定的属性名

十、多对一处理(mybatis-06)

​ · 多个学生，对应一个老师
​ · 对于学生这边而言，关联…多个学生，关联一个老师【多对一】
​ · 对于老师而言，集合，一个老师，有很多学生【一对多】

SQL语句：

CREATE TABLE `teacher` (
`id` INT(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT INTO teacher(`id`, `name`) VALUES (1, '秦老师');

CREATE TABLE `student` (
`id` INT(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
`tid` INT(10) DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `fktid` (`tid`),
CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8


INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('1', '小明', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('2', '小红', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('3', '小张', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('4', '小李', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('5', '小王', '1');

1、IDEA中安装lombox插件

lombox插件如何使用：
第一步：pom.xml文件中添加lombox依赖

<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.10</version>
        </dependency>

第二步：新建实体类，添加@Data注解

@Data
public class Student {

    private int id;
    private String name;
//    学生需要关联一个老师
    private Teacher teacher;
}

第三步：查看结果，可以简略去手动添加实体类的get和set等方法

2、按照查询嵌套处理

① 核心代码

<!--    思路？
    1、查询所有的学生信息
    2、根据查询出来的学生的tid对应寻找对应的老师
    3、把getStudent和getTeacher连起来
-->
    <select id="getStudent" resultMap="StudentTeacher">
        select * from student
    </select>

    <resultMap id="StudentTeacher" type="Student">
        <result property="id" column="id"/>
        <result property="name" column="name"/>
<!--        复杂的属性需要单独处理-->
<!--        对象就用 association-->
        <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
<!--        集合用collection-->
<!--        <collection property=""/>-->
    </resultMap>

    <select id="getTeacher" resultType="Teacher">
        select * from teacher where id = #{id}
    </select>

② 查询结果

3、按照结果嵌套处理

① 核心代码

<!--    =======================================方法2-->
    <select id="getStudent2" resultMap="StudentTeacher2">
        select s.id sid,s.name sname,t.name tname,t.id tid
        from student s,teacher t
        where s.tid=t.id
    </select>
    <resultMap id="StudentTeacher2" type="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="Teacher">
            <result property="id" column="tid"/>
            <result property="name" column="tname"/>
        </association>
    </resultMap>

② 运行结果

十一、一对多处理(mybatis-07)

1、环境搭建

2、实体类

① Student.class

@Datapublic class Student {    
	private int id;    
	private String name;    
	private int tid;
}

② Teacher.class

@Datapublic class Teacher {    
	private int id;    
	private String name;
	//    一个老师拥有多个学生    
	private List<Student> students;
}

3、按照查询嵌套查询

<select id="getTeacher2" resultMap="TeacherStudent2">
    select * from teacher where id = #{tid}
</select>
<resultMap id="TeacherStudent2" type="teacher">
    <result property="id" column="id"/>
    <result property="name" column="name"/>
    <collection property="students" column="id" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId"/>
</resultMap>
<select id="getStudentByTeacherId" resultType="Student">
    select * from student where tid = #{tid}
</select>

4、按照结果嵌套查询

<select id="getTeacher" resultMap="TeacherStudent">
        select s.id sid,s.name sname,t.name tname,t.id tid
        from student s,teacher t
        where s.tid=t.id and t.id = #{tid}
    </select>
    <resultMap id="TeacherStudent" type="Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
<!--        javaType=""指定属性的类型-->
<!--        集合中的泛型信息，我们使用ofType获取-->
        <collection property="students" ofType="Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>

5、小结

① 关联- association [多对一]

② 集合- collection [一对多]

③ javaType & oftype

• JavaType 用来指定实体类中属性的类型
• ofType 用来指定映射到list或者集合中的pojo，泛型中的约束类型

④ 注意点

• 保证SQL的可读性，尽量保证通俗易懂
• 注意一对多和多对一中，属性名和字段的问题
• 如果问题不好排查，建议启动日志