MyBatis2----配置文件解析、属性名和字段名不一致、日志、MyBatis分页、注解开发、Lombok、一对多和多对一关系的select语句

ps:

1. 增删改需要提交事务
2. 注册中心的注册的mapper的resource路径用的是 / 不是 句号 ,句号是在Mapper.xml中的命名空间中使用的 。
3. 程序报错的时候要从下往上读报错原因。

---

3.4 MyBatis中传递参数的Map。

假如实体类、数据库中的表、字段或者是参数过多，应当考虑使用Map!

  //万能的Map,好处：不需要知道数据库里有什么
    int insertUserByMap(Map<String,Object> map);

 <!--    使用Map插入用户-->
    <insert id="insertUserByMap" parameterType="map">
        insert into mybatis.user(id,name,pwd) values (#{userId},#{userName},#{passWord})
    </insert>

 @Test
    public void  insertUserByMap(){
        SqlSession sqlSession = MyBatisUtil.getSession();

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

        Map<String,Object> map = new HashMap<String, Object>();
		//通过设置map的key-value值进行传递参数
        map.put("userId",5);
        map.put("userName","里源码");
        map.put("passWord","123456");
		//执行SQL
        mapper.insertUserByMap(map);

        sqlSession.commit();

        sqlSession.close();
    }

1. 就单单说Mapper中实现功能时传递给数据库的名字不用和数据库的字段名一一对应。
2. 写parameterType可以只写map

Map 传递参数，直接在sql中取出key ------[parameterType=“map”]
对象传递参数，直接在sql中取出对象的属性 -----[parameterType=“Object”]
只有一个基本数据类型的情况下，可以直接在sql中取到

多个参数使用Map、或者是注解！

模糊查询之like

• 通配符写在java代码中。

//在MapperTestDemo中
List<User> userLike = mapper.getUserLike("李%");

-- 在Mapper.xml中
 select * from `mybatis`.`user` where name like #{value}

• 写在Mapper.xml文件里。

//MapperTestDemo中
 List<User> userLike = mapper.getUserLike("李");

 -- Mapper.xml中
 select * from `mybatis`.`user` where name like #{value}"%"

---

4. 配置解析

4.1 核心配置文件

mybatis-config.xml

configuration
	properties
	settings
	typeAliases
	typeHandlers
	objectFactory
	plugins
	environments
		environment
		transactionManager
		dataSource
	databaseIdProvider
	mappers

4.1.1 环境配置 environments

MyBatis可以适用多种环境。

尽管可以选择多套环境，但是每个SqlSessionFactory实例都只能选择一套环境。

事务管理器有两种 JDBC 和 MANAGED 。默认使用JDBC。

DataSource 的类型有三种 UNPOOLED | POOLED |JNDI，默认使用的是 POOLED。

4.1.2 属性（properties）

我们可以通过properties属性来引用配置文件.(db.properties)

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

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

编写一个db.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&characterEncoding=utf8&useUnicode&serverTimezone=UTC
username=root
password=123456789

在mybatis-config.xml中加入属性：

<!--    引入外部db.properties-->
    <properties resource="db.properties">
        <property name="username" value="root"/>
        <property name="password" value="111111"/>
    </properties>

在核心配置文件中，每个标签都有自己位置不能插队写。
properties作用：

• 引用外部文件。
• 可以添加propertie属性(在里面写name和value，完成外部文件的功能)，也可以完成数据库信息的配置。
• 当properties中存在有propertie和外部文件中属性重复的时候，优先使用外部文件中的属性。

4.1.3 类型别名（TypeAliases）

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

得到作用：

• 为Java类型设置一个缩写名字；
• 降低全限定类名书写的冗余

在返回值类型中原先我们要返回pojo包里的User类，要写上User的完整的包路径，在开发过程中很别扭。
起别名的两种方式：

1. 直接定义包下类的别名：

<!--第一种方式，直接对类型 定义名字-->
<typeAliases>
    <typeAlias type="com.swrici.pojo.User" alias="User"/>
</typeAliases>

2. 通过扫描包然后获取到的别名是首字母小写的类名。（大写也可以用），在那个类名前如果有别名注解，则是注解内容做别名。

 <!--指定包名，当使用到的时候去包下搜索JavaBean-->
   <!--通过扫描包然后获取到的别名是首字母小写的类名-->
   <typeAliases>
       <package name="com.swrici.pojo"/>
   </typeAliases>

当实体类中少的时候，使用第一种，
当实体类种多的时候，使用第二种。

第一种可以自己取别名。
第二种默认是类名首字母小写做别名，但也可以通过注解自己取别名。

@Alise("user")
Class User{}

一些常见的Java对象也内置了别名，基本数据类型在获取的时候要加‘_’下划线，而其他类的别名是小写获取。

4.1.4 设置（settings）

设置名	描述	有效值	默认值
cacheEnabled	全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。	true | false	true
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态	true | false	false
logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING	无设置

4.1.5 其他配置

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

4.1.6 映射器（mappers）

这里相当于是一个注册中心。每一个mapper都要在这里进行注册才能够使用。

• 方式1：通过resource注册

<mappers>
    <mapper resource="com/swrici/dao/UserMapper.xml"/>
</mappers>    

• 方式2：通过class注册

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

易报错点：
- 接口和它的配置文件必须同名。
- 接口和它的配置文件必须在同一个包下。

• 方式3 ，使用包扫描进行注册：

<!--注册方式3 使用包扫描进行注入绑定-->
 <mappers>
        <package name="com.swrici.dao"/>
</mappers>

易报错点（同class）：
- 接口和它的配置文件必须同名。
- 接口和它的配置文件必须在同一个包下。

4.2 作用域（Scope）和生命周期

错误的使用生命周期和作用域会导致非常严重的并发问题。
详细内容请看MyBatis1里SqlSessionFactoryBuilder,SqlSessionFactory,SqlSession三者的理解。

---

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

5.1 问题

属性名：pojo包下的User类里的属性名字。
字段名：数据库里表内的字段名字。
原来两者是相同的，现在我们把它们改成不同。
例如：
数据库里的字段，

pojo类里的User类的属性：

进行查询后，结果为：

为什么呢？
让我们看到我们的查询语句：

 select * from mybatis.user where id = #{id}
 --上面的查询语句等价于
  select id,name,pwd from mybatis.user where id = #{id}

这就要涉及到一个东西，查询到的结果是怎么和User类里的属性联系上的，
通过MyBatis自带的类型处理器，他会根据返回的结果名，去User类里找对应的属性名。

这里我们可以发现，数据库返回的是pwd这个名字，类型处理器并不能在User类里找到这个名字，所有返回的类的password属性的默认值只能为空。

解决方法：

• 起别名，既然它是因为找不到返回的名字和类里的属性名对不上，我们就把返回的名字改成和类里的属性名一样就好，通过as来修改

select id,name,pwd as password from mybatis.user where id = #{id}

修改后返回结果：

5.2 通过问题要引出的-----resultMap

官网描述：resultMap 元素是 MyBatis 中最重要最强大的元素。
ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。个人理解：对于字段名和属性名相同的不用写，对于两者不同的就可以写它们的映射关系。

---

6 日志

6.1 日志工厂

当数据库操作出现了异常，排错的时候，日志工厂就是最好的助手。

在核心配置文件中，配置相关的setting:

<!-- 
	name是对应的setting的属性名，
	value是该属性名对应的有效值 
	name和value中的内容都有绝对的书写格式，
	不能多空格，大小写也要一模一样
-->
<settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

6.2 Log4j

什么是Log4j？（来自百度百科）

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

6.2.1 导入log4j的包

<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

6.2.2 建立log4j.properties

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
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/swrici.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

6.2.3 在Setting中配置logImpl

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

6.2.4 简单使用log4j

1. Logger类是

org.apache.log4j.Logger

2. 在创建完对象之后要在类中创建一个静态变量，因为可能由多个方法使用，但是类只要有一个日志就好了。

static Logger logger = Logger.getLogger(UserMapperTest.class);

getLogger()方法中加载的是当前使用的类

---

7 分页

为什么我们要使用分页技术呢？
减少数据处理量

7.1 使用limit进行分页

-- 使用limit 分页 语法
-- startIndex 是从开始展示的第几条，下标从0开始
-- pageSize,是从一页可以装载多少条数据
select * from user limit startIndex,pageSize;
-- endIndex 是一个int ,下面这个语句是表示展示从0到endIndex位置的数
select * from user limit endIndex;

• 接口中编写相关的方法

//通过Limit展示数据
List<User> getUserByLimit(Map<String,Integer> map);

• 对应的XML编写方法

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

• 在对应的testDemo中

@Test
//搜说所有用户信息，并通过分页展示
public void getUserByLimit(){
    SqlSession session = MyBatisUtil.getSession();

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

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

    map.put("startIndex",0);

    map.put("pageSize",2);

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

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

    session.close();
}

7.2 RowBounds分页

1. 接口

//通过RowBounds分页
List<User> getUserByRowBounds(Map<String,Integer> map);

2. XML文件

<select id="getUserByRowBounds" resultMap="userMap" >
    select * from mybatis.user
</select>

3. 测试是否实现

 @Test
public  void  getUserByRowBounds(){
    SqlSession session = MyBatisUtil.getSession();

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

    RowBounds rowBounds = new RowBounds(1,2);

    List<User> userList = session.selectList("com.swrici.dao.UserMapper.getUserByRowBounds()",null,rowBounds);

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

    session.close();
}

7.3 分页插件

MyBatis PageHelper 了解即可。

---

8 使用注解开发

8.1 面向接口编程

在开发过程中，大多情况下我们都会选择使用面向接口编程，为什么呢？
根本原因：解耦，让程序变得可拓展，提高了复用，分层开发中，上层不用管具体的实现，大家遵守共同的标准，使开发变得更容易，规范性更好。

关于接口的理解

• 接口应是定义（规范、约束）与实现（名实分离的原则）的分离。
• 接口本身反映了系统设计人员对系统的抽象理解。
• 接口应有两类：
  • 第一类是对一个个体的抽象，它可对应为一个抽象体（abstract class）。
  • 第二类是对一个个体某一方面的抽象，既形成一个抽象面（interface）。
• 一个个体可能有多个抽象面，抽象体和抽象面是有区别的。

三个面向的区别

• 面向对象我们在考虑问题时，以对象为单位，考虑它的属性和方法。
• 面向过程是指，我们考虑问题时，以一个具体的流程(事务过程)为单位，考虑它的实现。
• 接口设计和非接口设计是针对复用技术而言的,与面向对象（过程）考虑的不是同个方向的。面向接口编程更多的是考虑系统整体的架构。

8.2 注解开发

1. 接口

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

2.要在核心配置文件去绑定这个接口

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

3 测试

本质：反射机制实现
底层：动态代理

MyBatis详细流程图片

8.3 使用注解的CRUD

开启自动提交事务

//开启自动提交事务
public static SqlSession getSqlSession(){
    return sqlSessionFactory.openSession(true);
}

• 增加
  接口中

@Insert("insert into `mybatis`.`user` values(#{id},#{name},#{password})")
int insertUser(User user);

TestDemo中：

@Test
public void insertUser(){
    SqlSession session = MyBatisUtil.getSession();

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

    mapper.insertUser(new User(7,"白居易","123456"));

    session.commit();

    session.close();
}

• 删除
  接口中

@Delete("delete from `mybatis`.`user` where id =7")
int deleteUser(@Param("id") int id);

TestDemo中：

@Test
public void deleteUser(){
    SqlSession session = MyBatisUtil.getSession();

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

    mapper.deleteUser(7);

    session.commit();

    session.close();
}

• 修改
  接口中

@Update("update `mybatis`.`user` set `pwd`=#{password} where id =#{id}")
int updateUser(User user);

TestDemo中：

@Test
public void updateUser(){
    SqlSession session = MyBatisUtil.getSession();

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

    mapper.updateUser(new User(7,"白居易","996_god_job"));

    session.commit();

    session.close();
}

注意点：要将接口注册到核心配置文件里的mappers标签中

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

在使用过程中，如果使用resource方式注册的话可以最后使用.../*Mapper.xml这样就不用因为多个接口写太多注册代码。...省略的是包路径。

8.4 关于@Param()注解

• 基本类型和String类型的参数需要加上。
• 引用类型不需要加上
• 如果只有一个基本类型的话，可以忽略，但是建议都加上。比较规范。
• 在SQL中引用的就是@Param(“id”)中设定的属性名。

8.5 #{}、${} 两者的区别

• #{} 相当于起了一个预编译的作用，可以防止SQL注入，更安全。
• ${},会起到一种拼接字符串的功能例如：'rid_id’会编程ridid可能会导致报错。也不阻止SQL注入，不安全。

9 Lombok

使用步骤：

• 在idea中安装lombok插件
• 导入相关的jar包

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
    <scope>provided</scope>
</dependency>

//相关的注解
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows
@val
@var
experimental @var
@UtilityClass

• 在实体类上加注解

@Data
生成了无参构造，getter()/setter(),toString(),hashcode(),equals()
@NoArgsConstructor :生成无参构造方法
@AllArgsConstructor  :生成有参构造方法

好与坏：
好：减少了写一些重复的源码。
坏：减少了写一些重复的源码。

---

10 多对一处理

对于学生来说：

• 很多个学生对应一个老师，很多个学生关联一个老师。也就是多对一。
• 对于老师来说，一个老师下集合了多个学生。也就是一对多。

10.1数据库表创建

//建表语句和插入语句
//创建一个teacher表
CREATE TABLE `teacher` (
`id` INT(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

//往teacher表插入一个秦老师的数据
INSERT INTO teacher(`id`, `name`) VALUES (1, '秦老师');

//创建一个student表
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

//往student表插入下一些学生的数据
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');

测试环境搭建

10.2 导入lombok包

10.3 编写实体类Teacher、Student。

@Data
public class Student {
    private int id;
    private String name;
    //装入了一个Teacher类成员变量
    private Teacher teacher;
}

@Data
public class Teacher{
    private int id;
    private String name;
}

10.4 建立Mapper接口

public interface StudentMapper {
    //查询所有的学生，以及对应的老师
    public List<Student> getStudent();
	//查询所有的学生，以及对应的老师
    public List<Student> getStudent2();
}

10.5 建立Mapper.xml文件（按照结果或查询处理）

<mapper namespace="com.swrici.dao.StudentMapper">
	<!-- ============ 按照查询嵌套处理 ============-->
    <resultMap id="StudentTeacher" type="Student">
        <!--result只适合单一的属性-->
        <result property="id" column="id" />
        <result property="name" column="name"/>
        <!-- 复杂的时候我们要用association:对象 collection:集合 -->
        <!-- 单个对象使用association，
        	property对应着的是对象的属性名
			column对应着的是搜索出来的列名，用于传递
			javaType用于标识普通单个对象的类型
			select里面写的是一个要被调用select标签的id。
 -->
        <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
    </resultMap>

    <!--
        思路:
        Student类里装的是一个Teacher对象,
        当从数据库搜出来的时候只有老师的id,
        需要在去老师表里查老师的信息
    -->
    <select id="getStudent" resultMap="StudentTeacher">
        select * from student
    </select>

    <select id="getTeacher" resultType="Teacher">
        select * from teacher  where id = #{id}
    </select>
	<!-- ============ 按照结果嵌套处理 ============-->
	<!-- 
		编写了sql直接搜出结果，
		sql直接把两个对象连接好，
		只需要输出就行
	 -->
    <select id="getStudent2" resultMap="StudentTeacher2">
        select s.id sid,s.name sname,t.name tname
        from student s,teacher t
        where s.tid = t.id
    </select>
	<!-- 
		单个对象使用association接受，
		property对应着对象的属性名
		javaType对应着这个单个对象的类名
		association 里面的result是用来形容这个对象自己的属性
	 -->
    <resultMap id="StudentTeacher2" type="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="Teacher">
            <result property="name" column="tname"/>
        </association>
    </resultMap>
</mapper>

10.6 在Mappers中绑定mapper

<mappers>
    <mapper class="com.swrici.dao.TeacherMapper"/>
    <mapper class="com.swrici.dao.StudentMapper"/>
</mappers>

10.7 编写案例测试

//获取学生表内的信息
    @Test
    public void getStudent(){
        SqlSession session = MyBatisUtil.getSession();

        StudentMapper mapper = session.getMapper(StudentMapper.class);

        List<Student> student = mapper.getStudent();

        for (Student student1 : student) {
            System.out.println(student1.toString());
        }

        session.close();
    }

    //获取学生表内的信息
    @Test
    public void getStudent2(){
        SqlSession session = MyBatisUtil.getSession();

        StudentMapper mapper = session.getMapper(StudentMapper.class);

        List<Student> student = mapper.getStudent2();

        for (Student student1 : student) {
            System.out.println(student1.toString());
        }

        session.close();
    }

---

11 一对多处理

研究对象：一个老师对应多个学生。

11.1 编写实体类

@Data
public class Student {
    private int id;
    private String name;
    //老师的id号
    private int tid;
}

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

11.2 编写接口类

public interface TeacherMapper {

    //获取指定老师下的所有学生和老师的信息
    Teacher getTeacher(@Param("tid") int id);

    //获取指定老师下的所有学生和老师的信息
    Teacher getTeacher2(@Param("tid") int id);
}

11.3 编写Mapper.xml来实现接口功能：（按照结果或查询处理）

<mapper namespace="com.swrici.dao.TeacherMapper">
    <!--按结果嵌套查询-->
	 <!--sql语句按对应的关系直接建好表
	 	 一个老师的id号在学生表里对应的全部学生-->
    <select id="getTeacher" resultMap="teacherMap">
        select s.id sid,s.name sname,t.name tname,t.id tid
        from teacher t
        inner join student s
        on t.id = s.tid
        where t.id = #{tid}
    </select>
	  <!-- 集合用collection接受
	  		property表式这个集合的属性名
	  		ofType表示的式集合内部的泛型对象类型
	  		因为是集合所以不要使用javaType
	  		collection内部写了的result
	  		表述着泛型对象内部的属性和搜索出来的字段的关系 -->
    <resultMap id="teacherMap" 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>

    <!--==============按查询嵌套处理=============-->
      <!--
      		一个简单的根据id搜索老师的select语句，
      	   	返回类型用自定义的teacherMap2进行接受
      -->
    <select id="getTeacher2" resultMap="teacherMap2">
        select * from teacher where id=#{tid}
    </select>
	
	 <!--
      		一个简单的根据tid搜索学生的select语句，
      	   	返回类型用Student进行接受
      -->
    <select id="getStudent" resultType="Student">
        select * from student where tid=#{tid}
    </select>

	<!--
      		在接受到在数据库根据老师id搜索老师的返回结果之后
      		两个teacher对象的基本属性id和name被省略了
      		调用collection接受集合对象
      		property表示集合在对象中的属性名
      		column表示返回的列中的字段名，可以用于后续的select
      		javaType表示集合的类型，这里和上面多对一的调用不同，
      		可能是底层实现需要用到这个类来装ofType接受到的类（猜测，坑1）
      		ofType用于表示集合内泛型对象类型
      		select调用了一个叫id为`getStudent`的select标签
      -->
    <resultMap id="teacherMap2" type="Teacher">
        <collection property="students" column="id" javaType="ArrayList" ofType="Student"  select="getStudent">

        </collection>
    </resultMap>
</mapper>

11.4 编写测试类查看是否能成功执行。

public class MyTest {
    @Test
    public void getTeacher(){
        SqlSession session = MyBatisUtil.getSession();

        TeacherMapper mapper = session.getMapper(TeacherMapper.class);

        Teacher teacher = mapper.getTeacher(1);

        System.out.println(teacher.toString());

        session.close();
    }

    @Test
    public void getTeacher2(){
        SqlSession session = MyBatisUtil.getSession();

        TeacherMapper mapper = session.getMapper(TeacherMapper.class);

        Teacher teacher = mapper.getTeacher2(1);

        System.out.println(teacher.toString());

        session.close();
    }
}

11.5 小结

• 关联：association 多对一，多个学生对应一个老师
• 集合：collection 一对多，一个老师对应多个学生
• javaType & ofType
  • javaType用来描述Java实体类中属性的类型。
  • ofType用来指定集合映射集合中的pojo类型，泛型中约束类型。

注意点：

• 保证SQL的可读性
• 注意一对多、多对一 中属性和字段的问题
• 如果问题不好排除建议使用日志。

面试高频：

• MySQL引擎
• InnoDB底层原理
• 索引
• 索引优化

学习于狂神说_秦老师发布于Bilibili的MyBatis视频！感恩！！