Lesson38_Mybatis

Mybatis_01（github）

环境

• JDK1.8
• MySQL5.7
• maven3.6.1
• IDEA

回顾

• JDBC
• mysql
• Java基础
• Maven
• Junit

框架：

配置文件，最后的方式就是看官方文档

1、简介

1.1、什么是Mybatis

• MyBatis是一流的持久性框架
• 支持自定义SQL，存储过程和高级映射
• MyBatis消除了几乎所有的JDBC代码以及参数的手动设置和结果检索。
• MyBatis可以使用简单的XML或注释进行配置，并将图元，映射接口和Java POJO（普通的旧Java对象）映射到数据库记录。
• MyBatis 本是apache的一个开源项目iBatis,
• 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis
• 2013年11月迁移到Github。

1.2、如何获得Mybatis

• maven仓库：https://mvnrepository.com/artifact/org.mybatis/mybatis/3.5.3
• GitHub：https://github.com/mybatis/mybatis-3/releases
• 中文文档：https://mybatis.org/mybatis-3/#

1.3、持久层

1.3.1、数据持久化

• 持久化就是将程序的数据在持久状态和瞬时状态转换的过程
• 内存：断电即失
• 数据库（jdbc），文件持久化（io）
• 生活：冷藏，罐头

1.3.2、为什么需要数据持久化

• 有一些对象，不能让它丢失
• 内存太贵了

1.4、持久层

Dao层，Service层，Controller层。。。

• 完成持久化工作的代码
• 层界限十分明显

1.5、为什么需要Mybatis？

• 帮助程序员将数据存入到数据库中
• 方便
• 传统的JDBC代码太复杂了，简化，框架，自动化
• 不用Mybatis也可以，更容易上手。技术没有高低之分
• 优点：
  • 简单易学
  • 灵活
  • sql和代码的分离，提高了可维护性。
  • 提供映射标签，支持对象与数据库的orm字段关系映射
  • 提供对象关系映射标签，支持对象关系组建维护
  • 提供xml标签，支持编写动态sql。
• 最重要的一点：使用的人多！

2、第一个Mybatis程序

• 思路：搭建环境–>导入Mybatis–>编写代码–>测试！

2.1、搭建环境

• 搭建数据库：

create databases mybatis;
use mybatis;
create table user(
    -> id int primary key auto_increment,
    -> name varchar(20) default null,
    -> pwd varchar(20) default null
    -> )engine=innodb default charset=utf8;
insert into user(name,pwd) values('张三','zhangsan'),('李四','lisi'),('王五','wangwu');

• 搭建父工程
  • 新建一个普通的maven项目
  • 删掉src等多余目录，把它当做父工程
  • 添加依赖到pom.xml文件中

<dependencies>
        <!--mybatis依赖包-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <!--数据库驱动包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.14</version>
        </dependency>
        <!--Junit测试包-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.9</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

2.2、创建一个普通的maven模块

2.2.1、编写核心配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--configurartion配置-->
    <environments default="development">
        <!--environments配置多个环境，选择一个默认的-->
        <environment id="development">
            <!--配置一个环境-->
            <transactionManager type="JDBC"/>
            <!--配置事物管理器，默认是JDBC事物管理-->
            <dataSource type="POOLED">
                <!--数据源-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <!--useSSL安全连接，useUnicode使用Unicode编码，serverTimezone设置时区，characterEncoding编码格式-->
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;serverTimezone=Hongkong&amp;useUnicod=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com\iotek\dao\UserMapper.xml"/>
    </mappers>
</configuration>

2.2.2、编写mybatis的工具类

package com.iotek.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

/**
 * @Author: 邪灵
 * @Date: 2019/12/5 21:37
 * @Description: Mybatis工具类
 * @Since: 1.0
 */
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    static {
        String xml = "mybatis-config.xml";
        try {
            //使用mybatis的第一步：获取SqlSession对象
            InputStream inputStream = Resources.getResourceAsStream(xml);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /*
    既然有了 SqlSessionFactory，顾名思义，我们就可以从中获得 SqlSession 的实例了。
    SqlSession 完全包含了面向数据库执行 SQL 命令所需的所有方法。
    你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。
     */
    public static SqlSession getSqlSessionFactory(){
        return sqlSessionFactory.openSession();
    }
}

2.2.3、编写代码

• 编写实体类

public class User implements Serializable {
    private Integer id;
    private String name;
    private String pwd;

    public User() {
    }

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

    public Integer getId() {
        return id;
    }

    public void setId(Integer 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;
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("User").append(":[")
                .append("id=")
                .append(id)
                .append(",name=")
                .append(name)
                .append(",pwd=")
                .append(pwd)
                .append("]  ");
        return sb.toString();
    }
}

• 编写Dao接口

public interface IUserDao {
    List<User> getUserList();
}

• 编写实现类(由原来的UserDaoImpl改为mapper)

<?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.iotek.dao.IUserDao">
    <select id="getUserList" resultType="com.iotek.entity.User">
        select * from user;
    </select>
</mapper>

• 编写测试类

public class UserDaoTest {
    @Test
    public void test1(){
    	//第一步：获得SqlSession 对象
        SqlSession sqlSession = MybatisUtils.getSqlSessionFactory();
        //第二步：执行SQL语句，方式一：getMapper（Class class）
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);
        List<User> userList = userDao.getUserList();
        //方式二：直接到具体的方法，一般不使用
        List<User> userList = sqlSession.selectList("com.iotek.dao.IUserDao.getUserList");
        for (User user : userList) {
            System.out.println(user);
        }
        //关闭资源
        sqlSession.close();
    }
}

• **注意：**org.apache.ibatis.binding.BindingException: Type interface com.iotek.dao.IUserDao is not known to the MapperRegistry.
• 出现此错误的原因是没有将mapper文件放到核心配置中去

3、CRUD

3.1、namespace

namespace中的包名要与Dao接口对应

3.2、select

选择，查询语句

<select id="getUserList" resultType="com.iotek.entity.User" parameterType="">
        select * from user;
    </select>

• id：就是namespace对应的接口中的方法名，可以理解为重写方法
• resultType：返回值类型
• parameterType：参数类型
• 参数用#{}来获取
• 通过id查询数据操作如下
  Dao层

    //根据id查询用户
    User getUserById(int id);

mapper

<select id="getUserById" parameterType="int" resultType="com.iotek.entity.User">
        select * from mybatis.user where id = #{id};
    </select>

测试类

@Test
    public void test2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);
        User userById = userDao.getUserById(2);
        System.out.println(userById);
        sqlSession.close();
    }

3.3、insert

注意:增删改操作需要手动提交事物，通过sqlSession.commit()方法提交事物
Dao层

//添加一个用户
    void saveUser(User user);

mapper：参数是对象时，可以直接访问属性

<!--如果要返回新增加数据的id值，则可以利用mysql自增方法获取，此时就要告诉它要把自增主键的值赋值给谁即可
useGeneratedKdys="true":表示启用数据库自增
keyProperty="id":将自增主键赋值给id属性
当设置好以后将一个没有id的数据添加到数据库以后再去查该数据时，id会被赋予值
-->
<insert id="saveUser" parameterType="com.iotek.entity.User">
        insert into user(name, pwd) values (#{name},#{pwd});
    </insert>
<!--如果数据库是Oracle等不支持自增主键的数据库时，想要完整添加数据且拿到id，则用到下面的语句-->
<selectKey keyProperty="id" order="BEFORE" resultType="Interger">
 select EMPLOYEES_SEQ.nextval from dual
</selectKey>
<!--上面这个语句就是查询Oracle数据库中根据序列的id，先查出下一个序列号，然后赋值给数据的id属性，然后添加，其中
order属性的值也可以是AFTER，就是之后，表示在插入语句之后执行查询，然后给数据赋值，此时可以是在插入语句中直接将id查询序列然后添加，然后插入操作，插入以后再查询出刚刚添加数据的id，给数据赋值。-->
<insert id="saveUser" parameterType="com.iotek.entity.User">
    insert into user(id,name, pwd) values (#{id},#{name},#{pwd})
</insert>

测试类

    @Test
    public void test3(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);
        userDao.saveUser(new User("赵六","zhaoliu"));
        sqlSession.commit();
        sqlSession.close();
    }

3.4、update

Dao层

    //修改数据
    void updateUser(User user);

Mapper

    <update id="updateUser" parameterType="com.iotek.entity.User">
        update user set name = #{name} where id=#{id};
    </update>

测试类

    @Test
    public void test4(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);
        userDao.updateUser(new User(6,"哈哈","hahah"));
        sqlSession.commit();
        sqlSession.close();
    }

3.5、delete

Dao层

    //删除数据
    void deleteUser(User user);

Mapper

    <delete id="deleteUser" parameterType="com.iotek.entity.User">
        delete from user where id = #{id};
    </delete>

测试类

    @Test
    public void test5(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);
        userDao.deleteUser(new User(6));
        sqlSession.commit();
        sqlSession.close();
    }

3.6、万能的map

3.6.1、当参数只有一个时

当参数只有一个试，mybatis不做任何处理，此时可以任意取，取参时的名字跟传入的参数名不一致也没有问题，比如在方法中定义的参数是id，取参时用#{idabc}也可以正常取出参数

3.6.2、但参数有多个时

当参数有多个时，mybatis会做一些处理，mybatis会默认将所有参数封装为一个map，键就是用prama1，parama2等等依次，比如方法中定义的参数是name和id两个参数，取参时如果用#{name}，#{id}是娶不到的，此时要用#{parama1}，#{parama2}就可以取到，或者是用下标也是可以取到的
第二种方式就是在方法参数上显示的什么参数名称，用@Param（“id”）,此时就可以用#{id}取到
当参数较多时，这样写不方便，就可以直接传入对象，取参时直接用对象的属性就可以取到，比如传入user，用#{id}，#{name}就可以取到id与name的值
在参数类型的选择上，除了可以使用对象跟基本数据类型之外，还可以使用map
如参数可以是Map<String,Object> map = new Ma<>();在SQL中直接写键名取值

1. 当参数是基本数据类型且只有一个参数时，可以直接在SQL中取到，参数类型可以省略。
2. 当单数是对象时，可以直接在SQL中取出对象的属性
3. 当参数是map时，SQL中是根据map中的键来取的，可以随意定义键名，SQL中直接根据键取
   以上各种类型都不用声明paramaryType，此参数mybatis已经弃用
   以上是常规参数，如果参数是一个基本类型，一个对象时比如（id，user），此时如果要用id跟name，同样mybatis会特殊处理为map，此时要取值就要用#{param1}，#{param2.name}，如果参数是一个list或者是set时，mybatis也会特殊处理，此时不可以用param来取，connection类型的对象map的key就是connection，或者是更精确的list，数组是array，如果是取第一个，就是#{array[0],通过这种方式来取出数组类型参数中的第一个值，list也是同样的用#{list[0]}

3.7、模糊查询

1. 第一种方式就是在代码中用通配符%%;
   List queryByName("%张%")，查询名字中有张字的人
2. 第二种方式就是在SQL中拼接通配符%;
   select * from user where name like “%”#{name} “%”;
3. 第三种就是利用${}字符串拼接
   select * from user where name like ‘%${name}%’;
4. 利用bind标签
   bind可以将OGNL表达式的值绑定到一个变量中

<select id="getUserById" resultType="com.iotek.entity.User">
	<bind name="_name" value="'%'+#{name}+'%'"/>
        select * from mybatis.user where like #{_name};
</select>

4、配置解析

4.1、核心配置

• mybatis-config.xml文件，名字随时，官方推荐使用此名
• MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。
• 配置文档的顶层结构如下：

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

4.1.1、environments（环境配置）

• MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中， 现实情况下有多种理由需要这么做。
• 不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。
• 每个数据库对应一个 SqlSessionFactory 实例
• 环境元素定义了如何配置环境。

<environments default="development">
  <environment id="development">
    <transactionManager type="JDBC">
      <property name="..." value="..."/>
    </transactionManager>
    <dataSource type="POOLED">
      <property name="driver" value="${driver}"/>
      <property name="url" value="${url}"/>
      <property name="username" value="${username}"/>
      <property name="password" value="${password}"/>
    </dataSource>
  </environment>
</environments>

• 这里有几个注意的点：

默认使用的环境 ID（比如：default="development"）。
每个 environment 元素定义的环境 ID（比如：id="development"）。
事务管理器的配置（比如：type="JDBC"）。
数据源的配置（比如：type="POOLED"）。

4.1.1.1、事务管理器

• 在 MyBatis 中有两种类型的事务管理器（也就是 type=”[JDBC|MANAGED]”）：
• JDBC – 这个配置就是直接使用了 JDBC 的提交和回滚设置，它依赖于从数据源得到的连接来管理事务作用域。
  MANAGED – 这个配置几乎没做什么。它从来不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接，然而一些容器并不希望这样，因此需要将 closeConnection 属性设置为 false 来阻止它默认的关闭行为。
  如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器， 因为 Spring 模块会使用自带的管理器来覆盖前面的配置。

4.1.1.2、数据源

dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源。

• 许多 MyBatis 的应用程序会按示例中的例子来配置数据源。虽然这是可选的，但为了使用延迟加载，数据源是必须配置的。
  有三种内建的数据源类型（也就是 type=”[UNPOOLED|POOLED|JNDI]”）
• UNPOOLED– 这个数据源的实现只是每次被请求时打开和关闭连接。虽然有点慢，但对于在数据库连接可用性方面没有太高要求的简单应用程序来说，是一个很好的选择。 不同的数据库在性能方面的表现也是不一样的，对于某些数据库来说，使用连接池并不重要，这个配置就很适合这种情形。UNPOOLED 类型的数据源具有以下属性。

driver – 这是 JDBC 驱动的 Java 类的完全限定名（并不是 JDBC 驱动中可能包含的数据源类）。
url – 这是数据库的 JDBC URL 地址。
username – 登录数据库的用户名。
password – 登录数据库的密码。
defaultTransactionIsolationLevel – 默认的连接事务隔离级别。
defaultNetworkTimeout – The default network timeout value in milliseconds to wait for the database operation to complete. See the API documentation of java.sql.Connection#setNetworkTimeout() for details.

作为可选项，你也可以传递属性给数据库驱动。只需在属性名加上“driver.”前缀即可，例如：
driver.encoding=UTF8

• POOLED– 这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来，避免了创建新的连接实例时所必需的初始化和认证时间。 这是一种使得并发 Web 应用快速响应请求的流行处理方式。
  除了上述提到 UNPOOLED 下的属性外，还有更多属性用来配置 POOLED 的数据源：

poolMaximumActiveConnections – 在任意时间可以存在的活动（也就是正在使用）连接数量，默认值：10
poolMaximumIdleConnections – 任意时间可能存在的空闲连接数。
poolMaximumCheckoutTime – 在被强制返回之前，池中连接被检出（checked out）时间，默认值：20000 毫秒（即 20 秒）
poolTimeToWait – 这是一个底层设置，如果获取连接花费了相当长的时间，连接池会打印状态日志并重新尝试获取一个连接（避免在误配置的情况下一直安静的失败），默认值：20000 毫秒（即 20 秒）。
poolMaximumLocalBadConnectionTolerance – 这是一个关于坏连接容忍度的底层设置， 作用于每一个尝试从缓存池获取连接的线程。 如果这个线程获取到的是一个坏的连接，那么这个数据源允许这个线程尝试重新获取一个新的连接，但是这个重新尝试的次数不应该超过 poolMaximumIdleConnections 与 poolMaximumLocalBadConnectionTolerance 之和。 默认值：3 （新增于 3.4.5）
poolPingQuery – 发送到数据库的侦测查询，用来检验连接是否正常工作并准备接受请求。默认是“NO PING QUERY SET”，这会导致多数数据库驱动失败时带有一个恰当的错误消息。
poolPingEnabled – 是否启用侦测查询。若开启，需要设置 poolPingQuery 属性为一个可执行的 SQL 语句（最好是一个速度非常快的 SQL 语句），默认值：false。
poolPingConnectionsNotUsedFor – 配置 poolPingQuery 的频率。可以被设置为和数据库连接超时时间一样，来避免不必要的侦测，默认值：0（即所有连接每一时刻都被侦测 — 当然仅当 poolPingEnabled 为 true 时适用）。

• JNDI – 这个数据源的实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的引用。这种数据源配置只需要两个属性：

initial_context – 这个属性用来在 InitialContext 中寻找上下文（即，initialContext.lookup(initial_context)）。这是个可选属性，如果忽略，那么将会直接从 InitialContext 中寻找 data_source 属性。
data_source – 这是引用数据源实例位置的上下文的路径。提供了 initial_context 配置时会在其返回的上下文中进行查找，没有提供时则直接在 InitialContext 中查找。

和其他数据源配置类似，可以通过添加前缀“env.”直接把属性传递给初始上下文。比如：
env.encoding=UTF8

4.1.2、属性（properties）

我们可以通过properties属性来实现引用配置文件
这些属性都是可外部配置且可动态替换的，既可以在典型的 Java 属性文件中配置，亦可通过 properties 元素的子元素来传递【db.properties】

• 编写一个properties配置文件。db.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&serverTimezone=Hongkong&useUnicod=true&characterEncoding=UTF-8
jdbc.user=root
jdbc.password=root

• 在核心配置文件中引入

<!--
url:引入资源，可以是网络资源或者是磁盘路径。
resource:引入资源，类路径下的资源。
-->
<properties resource="db.properties">
	<property name="username" value="root"/>
</properties>

1. 可以直接引入配置文件
2. 可以在其中添加一些属性
3. 如果外部文件与添加的属性有相同字段，优先使用外部文件的值

4.1.3、类型别名（typeAliases）

类型别名是为 Java 类型设置一个短的名字。 它只和 XML 配置有关，存在的意义仅在于用来减少类完全限定名的冗余。例如：

1. 精确配置

<typeAliases>
  <typeAlias alias="Author" type="domain.blog.Author"/>
  <typeAlias alias="Blog" type="domain.blog.Blog"/>
  <typeAlias alias="Comment" type="domain.blog.Comment"/>
  <typeAlias alias="Post" type="domain.blog.Post"/>
  <typeAlias alias="Section" type="domain.blog.Section"/>
  <typeAlias alias="Tag" type="domain.blog.Tag"/>
</typeAliases>

当这样配置时，Blog 可以用在任何使用 domain.blog.Blog 的地方。
2. 也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean，比如：

<typeAliases>
  <package name="domain.blog"/>
</typeAliases>

每一个在包 domain.blog 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 domain.blog.Author 的别名为 author；也可以使用大写，但是官方推荐使用小写，若有注解，则别名为其注解值

@Alias("author")
public class Author {
    ...
}

当实体类较少的时候推荐使用第一种，实体类较多时推荐使用第二种方式。
第一种方式可以实现DIY（自定义）别名，第二种不可以，只能通过注解的方式实现自定义，当指定包以及其子包下有 相同类名的类时，如果不用注解声明，则会报错，必须用注解声明两个不同的别名。

4.1.5、设置（settings）

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。

• 下表描述了设置中各项的意图、默认值等。

设置名	描述	有效值	默认值
cacheEnabled	全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存。	true/false	true
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。	true/false	false
aggressiveLazyLoading	当开启时，任何方法的调用都会加载该对象的所有属性。 否则，每个属性会按需加载（参考 lazyLoadTriggerMethods)。	true/false	false
multipleResultSetsEnabled	是否允许单一语句返回多结果集（需要驱动支持）。	true/false	true
useColumnLabel	使用列标签代替列名。不同的驱动在这方面会有不同的表现，具体可参考相关驱动文档或通过测试这两种不同的模式来观察所用驱动的结果。	true/false	true
useGeneratedKeys	允许 JDBC 支持自动生成主键，需要驱动支持。 如果设置为 true 则这个设置强制使用自动生成主键，尽管一些驱动不能支持但仍可正常工作（比如 Derby）。	true/false	false
autoMappingBehavior	指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示取消自动映射；PARTIAL 只会自动映射没有定义嵌套结果集映射的结果集。 FULL 会自动映射任意复杂的结果集（无论是否嵌套）	NONE, PARTIAL, FULL	PARTIAL
autoMappingUnknownColumnBehavior	指定发现自动映射目标未知列（或者未知属性类型）的行为。NONE: 不做任何反应.WARNING: 输出提醒日志 (‘org.apache.ibatis.session.AutoMappingUnknownColumnBehavior’ 的日志等级必须设置为 WARN).FAILING: 映射失败 (抛出 SqlSessionException)	NONE, WARNING, FAILING	NONE
defaultExecutorType	配置默认的执行器。SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（prepared statements）； BATCH 执行器将重用语句并执行批量更新。	SIMPLE REUSE BATCH	SIMPLE
defaultStatementTimeout	设置超时时间，它决定驱动等待数据库响应的秒数	任意正整数	未设置 (null)
defaultFetchSize	为驱动的结果集获取数量（fetchSize）设置一个提示值。此参数只可以在查询设置中被覆盖。	任意正整数	未设置 (null)
defaultResultSetType	Specifies a scroll strategy when omit it per statement settings. (Since: 3.5.2)	FORWARD_ONLY/SCROLL_SENSITIVE/SCROLL_INSENSITIVE/DEFAULT(same behavior with ‘Not Set’)	Not Set (null)
safeRowBoundsEnabled	允许在嵌套语句中使用分页（RowBounds）。如果允许使用则设置为 false。	true/false	False
safeResultHandlerEnabled	允许在嵌套语句中使用分页（ResultHandler）。如果允许使用则设置为 false。	true/false	True
mapUnderscoreToCamelCase	是否开启自动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN 到经典 Java 属性名 aColumn 的类似映射。	true/false	False
localCacheScope	MyBatis 利用本地缓存机制（Local Cache）防止循环引用（circular references）和加速重复嵌套查询。 默认值为 SESSION，这种情况下会缓存一个会话中执行的所有查询。 若设置值为 STATEMENT，本地会话仅用在语句执行上，对相同 SqlSession 的不同调用将不会共享数据。	SESSION 、STATEMENT	SESSION
jdbcTypeForNull	当没有为参数提供特定的 JDBC 类型时，为空值指定 JDBC 类型。 某些驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。	JdbcType 常量，常用值：NULL, VARCHAR 或 OTHER。	OTHER
lazyLoadTriggerMethods	指定哪个对象的方法触发一次延迟加载。	用逗号分隔的方法列表	equals,clone,hashCode,toString
defaultScriptingLanguage	指定动态 SQL 生成的默认语言。	一个类型别名或完全限定类名	org.apache.ibatis.scripting.xmltags.XMLLanguageDriver
defaultEnumTypeHandler	指定 Enum 使用的默认 TypeHandler 。（新增于 3.4.5）	一个类型别名或完全限定类名	org.apache.ibatis.type.EnumTypeHandler
callSettersOnNulls	指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这在依赖于 Map.keySet() 或 null 值初始化的时候比较有用。注意基本类型（int、boolean 等）是不能设置成 null 的。	true/false	false
returnInstanceForEmptyRow	当返回行的所有列都是空时，MyBatis默认返回 null。 当开启这个设置时，MyBatis会返回一个空实例。 请注意，它也适用于嵌套的结果集 （如集合或关联）。（新增于 3.4.2）	true/false	false
logPrefix	指定 MyBatis 增加到日志名称的前缀	任何字符串	未设置
logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找	SLF4J、LOG4J、LOG4J2、JDK_LOGGING、COMMONS_LOGGING、STDOUT_LOGGING、NO_LOGGING	未设置
proxyFactory	指定 Mybatis 创建具有延迟加载能力的对象所用到的代理工具。	CGLIB 、JAVASSIST	JAVASSIST （MyBatis 3.3 以上）
vfsImpl	指定 VFS 的实现	自定义 VFS 的实现的类全限定名，以逗号分隔	未设置
useActualParamName	允许使用方法签名中的名称作为语句参数名称。 为了使用该特性，你的项目必须采用 Java 8 编译，并且加上 -parameters 选项。（新增于 3.4.1）	true/false	true
configurationFactory	指定一个提供 Configuration 实例的类。 这个被返回的 Configuration 实例用来加载被反序列化对象的延迟加载属性值。 这个类必须包含一个签名为static Configuration getConfiguration() 的方法。（新增于 3.2.3）	类型别名或者全类名	未设置

• 一个配置完整的 settings 元素的示例如下：

<settings>
  <setting name="cacheEnabled" value="true"/>
  
  <setting name="lazyLoadingEnabled" value="true"/>
  <setting name="aggressiveLazyLoading" value="false"/>
  <!--当级联查询的时候需要懒加载时，需要设置上面两个属性，默认值即可，但通常会显示的声明,此处的配置为全局配置-->
  <setting name="multipleResultSetsEnabled" value="true"/>
  <setting name="useColumnLabel" value="true"/>
  <setting name="useGeneratedKeys" value="false"/>
  <setting name="autoMappingBehavior" value="PARTIAL"/><!--自动映射，如果开启驼峰，则此属性必须使用默认，如果设置该属性值为null，则关闭自动映射-->
  <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
  <setting name="defaultExecutorType" value="SIMPLE"/>
  <setting name="defaultStatementTimeout" value="25"/>
  <setting name="defaultFetchSize" value="100"/>
  <setting name="safeRowBoundsEnabled" value="false"/>
  <setting name="mapUnderscoreToCamelCase" value="false"/><!--开启驼峰命名映射,解决字段名与属性名不一致问题，但仅限于字段对应驼峰命名情况。如果不是，则用resultMap解决-->
  <setting name="localCacheScope" value="SESSION"/>
  <setting name="jdbcTypeForNull" value="OTHER"/>
  <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

4.1.6、映射器（mappers）

既然 MyBatis 的行为已经由上述元素配置完了，我们现在就要定义 SQL 映射语句了。 但是首先我们需要告诉 MyBatis 到哪里去找到这些语句。 Java 在自动查找这方面没有提供一个很好的方法，所以最佳的方式是告诉 MyBatis 到哪里去找映射文件。 你可以使用相对于类路径的资源引用， 或完全限定资源定位符（包括 file:/// 的 URL），或类名和包名等。

• 使用相对路径的资源引用（推荐试用）一般是类路径下的资源

<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
  <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
  <mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>

• 使用完全限定资源定位符URL（一般不使用），指网络路径下的资源

<mappers>
  <mapper url="file:///var/mappers/AuthorMapper.xml"/>
  <mapper url="file:///var/mappers/BlogMapper.xml"/>
  <mapper url="file:///var/mappers/PostMapper.xml"/>
</mappers>

• 使用映射器接口实现类的完全限定名

1. 接口和配置文件必须同名
2. 接口和配置文件必须同一文件夹下
3. 基于注解则用该方法，此时没有映射文件。

<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
  <mapper class="org.mybatis.builder.BlogMapper"/>
  <mapper class="org.mybatis.builder.PostMapper"/>
</mappers>

• 将包内的映射器接口实现全部注册为映射器

4. 接口和配置文件必须同名
5. 接口和配置文件必须同一文件夹下

<mappers>
  <package name="org.mybatis.builder"/>
</mappers>

• 这些配置会告诉了 MyBatis 去哪里找映射文件，剩下的细节就应该是每个 SQL 映射文件了，也就是接下来我们要讨论的。

4.1.7、其他配置

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

4.2、生命周期和作用域

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

1. 一旦创建了SqlSessionFactory，就不再需要它了
2. 局部变量

• SqlSessionFactory：

3. 说白了就是可以想象为：数据库连接池
4. 一旦创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或者重新创建另一个实例
5. 因此SqlSessionFactory的最佳作用域就是应用的作用域
6. 最简单的就是使用单例模式或者静态单例模式

• SqlSession：

7. 连接到连接池的一个请求
8. SqlSession的实例不是线程安全的，因此是不能被共享的，所有它的最佳作用域是请求作用域或方法作用域
9. 用完之后要赶紧关闭，否则资源被占用
   

• 这里的每一个Mapper就代表一个业务

5、解决属性名和字段名不一致的问题（ResultMapper）

5.1、问题

• 数据库中的字段

id int primary key auto_increment,
    -> name varchar(20) default null,
    -> pwd varchar(20) default null

• 实体类中的属性

private Integer id;
private String name;
private String pass;

• 查询结果

User:[id=1,name=张三,pass=null]  
User:[id=2,name=李四,pass=null]  
User:[id=3,name=王五,pass=null] 

• 解决方法：
  • 起别名

  select id,name,pwd as pass from user;
  

5.2、resultMap

结果集映射

id		name	pwd
id		name	pass

    <!--结果集映射-->
    <resultMap id="userMap" type="User">
        <!--column数据库中的字段，property实体类中的属性-->
        <id column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="pwd" property="pass"/>
    </resultMap>
    <select id="getUsers" resultMap="userMap">
        select * from user;
    </select>

• resultMap 元素是 MyBatis 中最重要最强大的元素。
• ResultMap 的设计思想是，对于简单的语句根本不需要配置显式的结果映射，而对于复杂一点的语句只需要描述它们的关系就行了。
• ResultMap 最优秀的地方在于，虽然你已经对它相当了解了，但是根本就不需要显式地用到他们
• 如果世界总是这么简单就好了。

6、日志

6.1、日志工厂

• 在核心配置文件中settings中设置
  
• 在mybatis中具体使用哪个日志实现，在settings中设置
• STDOUT_LOGGING标准日志输出

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

• 结果
  

6.2、log4j

6.2.1、什么是log4j

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

1. 先导入log4j的包

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

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/log4j.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.fileThreshold=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

3. 配置log4j为日志的实现

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

4. log4j的使用，直接运行刚才的查询
   

6.2.2、简单使用

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

@Test
    public void test2(){
        Logger logger = Logger.getLogger(UserDaoTest.class);
        logger.info("info:进入了test2");
        logger.debug("debug:进入了test2");
        logger.error("error:进入了test2");
    }

3. 日志级别

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

7、分页

思考：为什么使用分页？

• 减少数据的处理量

7.1、使用Limit分页

# 语法：select * from user limit startIndex,pageSize;
select * from user limit 3; #[0,n]

7.2、使用mybatis实现分页，核心SQL

1. 接口

//分页查询
    List<User> getUserByLimit(Map<String,Integer> map);

2. 配置

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

3. 测试

@Test
public void test3(){
   SqlSession sqlSession = MybatisUtils.getSqlSession();
   IUserDao userDao = sqlSession.getMapper(IUserDao.class);
   HashMap<String, Integer> stringIntegerHashMap = new HashMap<String, Integer>();
   stringIntegerHashMap.put("startIndex",2);
   stringIntegerHashMap.put("pageSize",2);
   List<User> users = userDao.getUserByLimit(stringIntegerHashMap);
   for (User user : users) {
      System.out.println(user);
    }
    sqlSession.close();
}

7.3、RowBounds分页

1. 接口

//分页2
List<User> getUserByRowBouns();

2. 配置

<select id="getUserByRowBouns" resultMap="userMap">
  select * from user;
</select>

3. 测试

    @Test
    public void test4(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        RowBounds rowBounds = new RowBounds(1,2);
        List<User> users = sqlSession.selectList("com.iotek.dao.IUserDao.getUserByRowBouns",null,rowBounds);
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }

7.4、mybatis分页插件

pagehelper.github.io/

8、使用注解开发

8.1、面向接口编程

• 大家之前都学过面向对象编程，也学习过接口，但是在真正的开发中，很多时候我们会选择面向接口编程；
• 根本原因：解耦，可拓展，提高复用，分层开发中，上层不用管具体的实现，大家都遵守共同的标准，使得开发变得容易，规范性更好；
• 在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的，在这种情况下，各个对象内部是如何实现自己的，对系统设计人员来讲就不那么重要了；
• 而各个对象质检的协作关系则成为系统设计的关键，小到不同类之间的通信，大到各模块质检的交互，在系统设计之初都是要考虑的，这也是系统设计的主要工作内容，面向接口编程就是指按照这种思想来编程。
  关于接口的理解

• 接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离
• 接口的本身反映了系统设计人员对系统的抽象理解
• 接口应有两类：
  • 第一类是对一个个体的抽象，它可对应为一个抽象体（abstract class）
  • 第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）
• 一个体有可能有多个抽象面，抽象体与抽象面是有区别的。
  三个面向对象
• 面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性及方法。
• 面向过程是指，我们考虑问题时，以一个具体的流程（事物过程）为单位，考虑它的实现。
• 接口设计与非接口设计是针对复用技术而言的，与面向对象（过程）不是一个问题，更多的体现就是对系统整体的架构

8.2、注解开发

1. 注解在接口上实现

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

2. 需要在核心文件中绑定接口

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

3. 测试

    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> users = userDao.getUsers();
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }

4. 本质：反射机制实现
   底层：动态代理
   mybatis详细的执行流程
   

8.3、注解实现CRUD

我们可以在工具类创建的时候实现自动提交

public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static SqlSession getSqlSession(){
        //创建SqlSession时设置事物的自动提交
        return sqlSessionFactory.openSession(true);
    }
}

• 编写接口，添加注释

public interface UserDao {
    @Select("select * from user")
    List<User> getUsers();
    @Insert("insert into user(name,pwd) values(#{name},#{pwd});")
    void addUser(User user);
    @Update("update user set name=#{name},pwd=#{pwd} where id=#{id};")
    void updateUser(User user);
    @Delete("delete from user where id=#{uid}")
    void deleteUser(@Param("uid") int id);
}

• 测试类

public class UserDaoTest {
    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> users = userDao.getUsers();
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }
    @Test
    public void test1(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        userDao.addUser(new User("哈哈","hahaha"));
        sqlSession.close();
    }
    @Test
    public void test2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        User user = new User("嘿嘿","heihei");
        user.setId(7);
        userDao.updateUser(user);
        sqlSession.close();
    }
    @Test
    public void test3(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        userDao.deleteUser(7);
        sqlSession.close();
    }
}

【注意：我们必须要将接口注册绑定到我们的核心配置文件中】
关于@Param(" ")注解

• 基本类型的参数或者是String类型，需要加上
• 引用类型不需要加
• 如果只有一个基本类型的话，可以忽略，但是建议都加上
• 我们在SQL中引用的就是我们这里的@Param（）中的设定的属性名
  #{} 和 ${} 的区别
  #{}:表示一个占位符号，通过#{}可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换，#{}可以有效防止sql注入。 #{}可以接收简单类型值或pojo属性值。 如果parameterType传输单个简单类型值，#{}括号中可以是value或其它名称。

${}:表示拼接sql串，通过${}可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换， ${}可以接收简单类型值或pojo属性值，如果parameterType传输单个简单类型值，${}括号中只能是value

9、Lombok

Project Lombok is a java library that automatically plugs into your editor and build tools, spicing up your java.
Never write another getter or equals method again, with one annotation your class has a fully featured builder, Automate your logging variables, and much more.

• java library
• plugs
• build tools
• with one annotation your class

9.1、使用Lombok

1. 在IDEA中安装Lombok插件

• 
• 
• 
• 

2. 导入Lombokjar包

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

3. 注解：

@Getter and @Setter //getter和setter方法
@FieldNameConstants
@ToString //tostring方法
@EqualsAndHashCode //equals和hashcode方法
//全参的构造方法									  //无参构造方方达
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data//无参构造，getter，setter，tostring，equals，hashcode方法
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows
@val
@var
experimental @var
@UtilityClass

总结：
lombok虽然有很多的有点，但是lombok更类似于一种IDEA插件，项目也需要依赖相应的jar包，lombok依赖jar包是因为编译时需要用它的注解，为什么说它又类似插件？因为使用时，eclipse或Intellij IDEA都需要安装相应的插件，在编译器编译时通过操作AST（抽象语法树）改变字节码生成，变相的就是说它在改变java语法。
它不想spring的依赖注入或者mybatis的ORM一样是运行时的特性，而是编译时的特性，这里我个人最感觉不爽的地方就是对插件的依赖，因为lombok只是省去了一些人工生成代码的麻烦，但IDE都有快捷键类协助生成getter/setter等方法，也非常方便。
知乎上有位大神发表过对于lombok的看法：
这是一种低级趣味的插件，不建议使用，JAVA发展到今天，各种插件层出不穷，如何甄别各种插件的优劣？能从架构上优化你的设计的，能提高应用程序性能的，实现高度封装可扩展的……，像lombok这种，像这种插件，已经不仅仅是插件了，改变了你如何编写代码，事实上，少去了的代码，你写上去又如何？如果JAVA家族到处充斥这种东西，那只不过是披着金属颜色的屎，迟早会被其他语言取代。
虽然话糙但是理确实不糙，试想一个项目有非常多类似lombok这样的插件，个人觉得真的会极大的降低阅读原代码的舒适度，虽然不建议在属性的getter/setter写一些业务代码，但在多年项目的实战中，有时在getter/setter加一点点业务代码，能极大的简化某些业务场景的代码，所谓取舍，也许就是这时的舍弃一定的规范，取得极大的方便。
我现在非常坚信一条理念，任何编程语言或插件，都仅仅是工具而已，即时工具再强大也在于用的人，结合具体业务场景和项目实际情况，无需一味追求高大上的技术，适合才是王道。
lombok有它得天独厚的有点，也有它避之不及的缺点，熟知其优缺点，在实战中灵活运用才是根本。

10、多对一处理

10.1、图示关系

10.2、理解

• 多个学生，对应一个老师
• 对应学生而言，关联，多个学生关联一个老师【多对一】
• 对老师而言，集合
• sql

 create table teacher(
    -> id int primary key auto_increment,
    -> name varchar(30) default null
    -> )engine=innodb default charset=utf8;
insert into teacher(name) values("张三");
create table student(
    -> id int primary key auto_increment,
    -> name varchar(30) default null,
    -> tid int default null,
    -> foreign key (tid) references teacher(id)
    -> )engine=innodb default charset=utf8;

10.3、测试环境搭建

1. 导入lombok
2. 新建实体类Teacher，Student
3. 建立Mapper接口
4. 建立Mapper.xml文件
5. 在核心配置文件中绑定注册我们的Mapper接口或者文件
6. 测试查询是否能够成功

10.4、处理方式

10.4.1、按照查询嵌套处理（子查询）

• 接口

public interface StudentDao {
    //查询所有的学生信息以及对应老师的信息
    List<Student> getStudents();
}

• 映射文件配置

<mapper namespace="com.iotek.dao.StudentDao">
    <!--思路
    1. 查询出所有的学生信息
    2. 根据查询出来的学生的tid，寻找对应的老师
    -->
    <select id="getStudents" resultMap="students">
        select * from student;
    </select>
    <resultMap id="students" type="student">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <!--复杂的属性，我们需要单独处理 association：对象（多对一）  collection：集合（一对多）
        column：将查询出来的那一列作为子查询的参数。如果需要传递多个列，则封装为map，如column={tid=tid，tname=name}
        -->
        <association property="teacher" column="tid" javaType="teacher" select="getTeacher"/>
    </resultMap>
    <select id="getTeacher" resultType="teacher">
        select * from teacher where id=#{tid}
    </select>
</mapper>

• 测试

    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        List<Student> students = studentDao.getStudents();
        students.forEach(System.out::println);
        sqlSession.close();
    }

10.4.2、按照结果嵌套处理（多表联查）

• 接口

public interface StudentDao {
    //查询所有的学生信息以及对应老师的信息
    List<Student> getStudent1();
}

• 映射文件配置

<mapper namespace="com.iotek.dao.StudentDao">
    <select id="getStudent1" resultMap="student1">
        select s.id sid,s.name sname,t.id tid,t.name tname from student s,teacher t where t.id=s.tid;
    </select>
    <resultMap id="student1" type="student">
        <id property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="teacher">
            <id property="id" column="tid"/>
            <result property="name" column="tname"/>
        </association>
    </resultMap>
</mapper>

• 测试

    @Test
    public void test1(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        List<Student> students = studentDao.getStudent1();
        students.forEach(System.out::println);
        sqlSession.close();
    }

11、一对多处理

比如一个老师拥有多个学生，对于老师而言，就是一对多的关系。

• 环境搭建，和上面一样
• 实体类

@Data
public class Student implements Serializable {
    private Integer id;
    private String name;
    private Integer tid;
}

@Data
public class Teacher implements Serializable {
    private Integer id;
    private String name;
    private List<Student> list;
}

11.1、按照结果嵌套处理（多表联查）

• 接口

public interface TeacherDao {
    Teacher getTeacherById(@Param("id")int id);
}

• 映射配置

<mapper namespace="com.iotek.dao.TeacherDao">
    <!--按照结果嵌套查询-->
    <select id="getTeacherById" resultMap="teachers">
        select t.id tid,t.name tname,s.id sid,s.name sname,s.tid stid
        from teacher t,student s
        where t.id=s.tid
        and t.id=#{id};
    </select>
    <resultMap id="teachers" type="teacher">
        <id property="id" column="tid"/>
        <result property="name" column="tname"/>
        <!--复杂属性要单独处理，对象用association,集合用collection-->
        <!--
        fetchType:虽然开启了全局的懒加载，但是这里可以设置单个查询的加载方式
        column：传递参数的列
        javaType：指定属性类型
        ofType：集合中泛型的信息
        -->
        <collection property="list" ofType="student">
            <id property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="stid"/>
        </collection>
    </resultMap>
</mapper>

• 测试

    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        Teacher teacher = sqlSession.getMapper(TeacherDao.class).getTeacherById(2);
        System.out.println(teacher);
        sqlSession.close();
    }
}

11.2、按照查询嵌套处理

• 接口

public interface TeacherDao {
    List<Teacher> getTeachers();
}

• 映射配置

<mapper namespace="com.iotek.dao.TeacherDao">
    <select id="getTeachers" resultMap="teacher">
        select t.id tid,t.name tname from teacher t;
    </select>
    <resultMap id="teacher" type="teacher">
        <id property="id" column="tid"/>
        <result property="name" column="tname"/>
        <collection property="list" column="tid" javaType="ArrayList" ofType="student" select="students" fetchType="lazy"/>
    </resultMap>
    <select id="students" resultType="student">
        select * from student s where s.tid=#{tid}
    </select>
</mapper>

• 测试

    @Test
    public void test1(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        sqlSession.getMapper(TeacherDao.class).getTeachers().forEach(System.out::println);
        sqlSession.close();
    }

11.3、鉴别器

在resultMap中，有一个discriminator属性，称为鉴别器，其作用是可以根据某一列的值，来改变我们的封装规则

<resultMap id="test" type="user">
        <!--
        鉴别器discriminator:
        其中JavaType是指某一列的类型，column是指我们用来做条件判断的列，JavaType就是该列的类型
        case中的value就是指当我们指定 的列的值是多少的时候，所对应的封装规则就写在case标签里面，有几种情况就写几个case
        -->
        
        <discriminator javaType="string" column="name">
            <case value="0">具体的封装规则1</case>
            <case value="1">具体的封装规则2</case>
        </discriminator>
    </resultMap>

11.4、总结

1. 关联–association 【多对一】
2. 集合–collection 【一对多】
3. JavaType & ofType
   • JavaType 用来指定实体类中属性的类型
   • ofType 用来指定映射到list或者集合中的pojo类型，泛型中的约束类型
     注意点：

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

12、动态SQL

• 什么是动态SQL：动态SQL就是根据不同的条件生成不同的SQL语句
• MyBatis 的强大特性之一便是它的动态 SQL。如果你有使用 JDBC 或其它类似框架的经验，你就能体会到根据不同条件拼接 SQL 语句的痛苦。例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL 这一特性可以彻底摆脱这种痛苦。

动态 SQL 元素和 JSTL 或基于类似 XML 的文本处理器相似。在 MyBatis 之前的版本中，有很多元素需要花时间了解。MyBatis 3 大大精简了元素种类，现在只需学习原来一半的元素便可。MyBatis 采用功能强大的基于 OGNL 的表达式来淘汰其它大部分元素。

if
choose (when, otherwise)
trim (where, set)
foreach

12.1、搭建环境

• 创建数据库表

create table blog(
    -> id varchar(50) not null comment'博客id',
    -> title varchar(100) not null comment'博客标题',
    -> author varchar(30) not null comment'博客作者',
    -> create_time datetime not null comment'创建时间',
    -> views int not null comment'浏览量'
    -> )engine=innodb default charset=utf8;

• 创建一个基础工程
  1. 导包
  2. 编写配置文件及工具类
     配置文件

<configuration>
    <properties resource="db.properties"/>
    <settings>
        <!--默认日志-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <!--开启驼峰命名，会转换匈牙利的字段跟驼峰的属性-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    <typeAliases>
        <package name="com.iotek.entity"/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.user}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <package name="com/iotek/dao"/>
    </mappers>
</configuration>

工具类

/**
 * @Author: 邪灵
 * @Date: 2019/12/10 10:54
 * @Description: Mybatis工具类
 * @Since: 1.0
 */
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
            sqlSessionFactory=new SqlSessionFactoryBuilder().build(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession(true);
    }
}

/**
 * @Author: 邪灵
 * @Date: 2019/12/10 10:56
 * @Description: 生成随机id工具类
 * @Since: 1.0
 */
public class CreateIdUtils {
    public static String getId(){
        return UUID.randomUUID().toString().replaceAll("-","");
    }
}

3. 编写实体类

/**
 * @Author: 邪灵
 * @Date: 2019/12/10 10:52
 * @Description: 博客实体类
 * @Since: 1.0
 */
@Data
public class Blog implements Serializable {
    private String id;
    private String title;
    private String author;
    private Date createTime;
    private int views;
}

4. 编写接口对应的映射文件

<mapper namespace="com.iotek.dao.BlogDao">
    <insert id="addBlog" parameterType="blog">
        insert into blog(id, title, author, create_time, views) VALUES (#{id},#{title},#{author},#{createTime},#{views});
    </insert>
</mapper>

• 测试

    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogDao blogDao = sqlSession.getMapper(BlogDao.class);

        Blog blog = new Blog();

        blog.setId(CreateIdUtils.getId());
        blog.setTitle("javaEE框架");
        blog.setAuthor("张三");
        blog.setCreateTime(new Date());
        blog.setViews(1000);
        blogDao.addBlog(blog);

        blog.setId(CreateIdUtils.getId());
        blog.setTitle("java设计模式");
        blog.setAuthor("李四");
        blog.setCreateTime(new Date());
        blog.setViews(2000);
        blogDao.addBlog(blog);

        blog.setId(CreateIdUtils.getId());
        blog.setTitle("java前端");
        blog.setAuthor("李四");
        blog.setCreateTime(new Date());
        blog.setViews(3000);
        blogDao.addBlog(blog);

        blog.setId(CreateIdUtils.getId());
        blog.setTitle("java表达式");
        blog.setAuthor("张三");
        blog.setCreateTime(new Date());
        blog.setViews(5000);
        blogDao.addBlog(blog);

        sqlSession.close();
    }

12.3、IF

• 接口

public interface BlogDao {
    List<Blog> queryBlogIf(Map map);
}

• 映射文件

<mapper namespace="com.iotek.dao.BlogDao">
    <select id="queryBlogIf" parameterType="map" resultType="blog">
        select * from blog where 1=1
        <if test="title != null">
            and title=#{title}
        </if>
        <if test="author !=null">
            and author=#{author}
        </if>
    </select>
</mapper>

• 测试

    @Test
    public void test1(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogDao blogDao = sqlSession.getMapper(BlogDao.class);
        Map map = new HashMap();
        map.put("title","java前端");
        map.put("author","李四");
        List<Blog> blogs = blogDao.queryBlogIf(map);
        blogs.forEach(System.out::println);
        sqlSession.close();
    }

12.4、trim, where, set

• where

1. where 元素只会在至少有一个子元素的条件返回 SQL 子句的情况下才去插入“WHERE”子句。而且，若语句的开头为“AND”或“OR”，where 元素也会将它们去除。

2.      select * from blog
        <where>
            <if test="title != null">
                title=#{title}
            </if>
            <if test="author !=null">
                and author=#{author}
            </if>
        </where>
    </select>
   

• set

3. 类似的用于动态更新语句的解决方案叫做 set。set 元素可以用于动态包含需要更新的列，而舍去其它的。
4. set 元素会动态前置 SET 关键字，同时也会删掉无关的逗号，因为用了条件语句之后很可能就会在生成的 SQL 语句的后面留下这些逗号

    <update id="updateBlog" parameterType="blog">
        update blog
        <set>
            <if test="title != null">
                title=#{title},
            </if>
            <if test="author != null">
                author=#{author}
            </if>
        </set>
        where id=#{id}
    </update>

• trim

<!--
prefix是指前缀，会自动添加，比如where或者是set标签中会自动添加where跟set（**可以理解为trim里面的就是一个拼接后的整体，perfix就是给这个整体加一个前缀**）
prefixOverrides是指前缀替换，比如where中第一个条件出现add 或者是or会自动去掉（可以理解为替换掉前缀）
suffix是指后缀，与前缀用法一样，比如SQL结束都加上封号。（可以理解为给trim这个整体加一个后缀）
suffixOverrides是指后缀替换，比如set中只有一个条件时，后面的逗号会自动去掉
-->
<trim prefix="" prefixOverrides="" suffix="" suffixOverrides=""/>

12.5、choose, when, otherwise

• 有时我们不想应用到所有的条件语句，而只想从中择其一项。针对这种情况，MyBatis 提供了 choose 元素，它有点像 Java 中的 switch 语句。
• 接口

public interface BlogDao {
    List<Blog> queryBlogChoose(Map map);
}

• 映射文件

<mapper namespace="com.iotek.dao.BlogDao">
    <select id="queryBlogChoose" parameterType="map" resultType="blog">
        select * from blog
        <where>
            <choose>
                <when test="title != null">
                    title=#{title}
                </when>
                <when test="author">
                    and author=#{author}
                </when>
                <otherwise>
                    and views>=#{views}
                </otherwise>
            </choose>
        </where>
    </select>
</mapper>

• 测试

    @Test
    public void test2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogDao blogDao = sqlSession.getMapper(BlogDao.class);
        Map map = new HashMap();
        map.put("views",3000);
        map.put("title","java前端");
        map.put("author","李四");
        List<Blog> blogs = blogDao.queryBlogChoose(map);
        blogs.forEach(System.out::println);
        sqlSession.close();
    }

所谓的动态SQL，本质上还是SQL，只是我们可以在SQL层面，去执行一些逻辑代码

12.6、foreach

select * from user where id=1 or id=2 or id=3

• 动态 SQL 的另外一个常用的操作需求是对一个集合进行遍历，通常是在构建 IN 条件语句的时候。
• 

<!--select * from blog where (id=1 or id=2 or id=3);-->
<select id="queryBlogForeach" parameterType="map" resultType="blog">
	select * from blog
	<where>
		<foreach collection="ids" item="id" open="(" colse=")" separator="or">
			id=#{id}
		</foreach>
	</where>
</select>

12.7、mybatis中的两个内置参数

在上面动态SQL中我们判断的参数都是传递进来的参数，除此之外在mybatis中有两个内置参数。

• _parameter:代表整个参数
  • 单个参数：_paremeter就是这个参数
  • 多个参数：mybatis会封装为map，_parameter就是这个map
• _databaseId：如果配置了databaseIdProvider标签，_databaseId就代表当前数据库别名。

12.8、SQL片段

有的时候，我们会将公共的部分抽取出来，方便复用
在需要的地方使用include标签引用即可,在include标签内部还可以定义property标签，在其他SQL标签就可以用${}来取出这些值。不能用#{}

• SQL片段复用对比

    <select id="queryBlogIf" parameterType="map" resultType="blog">
        select * from blog
        <where>
            <if test="title != null">
                title=#{title}
            </if>
            <if test="author !=null">
                and author=#{author}
            </if>
        </where>
    </select>

    <select id="queryBlogIf" parameterType="map" resultType="blog">
        select * from blog
        <where>
            <include refid="if-title-author"/>
        </where>
    </select>
    <sql id="if-title-author">
        <if test="title != null">
            title=#{title}
        </if>
        <if test="author !=null">
            and author=#{author}
        </if>
    </sql>

• 注意事项：

1. 最好基于单标定义SQL片段
2. 片段中不用包含where标签
   动态SQL就是在拼接SQL语句，我们只要保证SQL的正确性，按照SQL的格式，去配列组合就可以了
   建议：
   先在数据库中写出完整的SQL语句，测试无误后再对应的去修改成为我们的动态SQL

13、缓存

查询 ：连接数据库，消耗资源！
	一次查询的结果，给它暂存在一个可以直接取到的地方！--->内存：缓存
我们两次查询相同数据的时候，直接走缓存，就不用走数据库了

13.1、简介

1. 什么是缓存【cache】

• 存在内存中的临时数据
• 将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上（关系型数据库数据文件）查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。

2. 为什么使用缓存？

• 减少和数据库的交互次数，减少系统开销，提交系统效率。

3. 什么样的数据能使用缓存

• 经常查询并且不经常改变的数据

13.2、Mybatis缓存

• mybatis包含一个非常强大的查询缓存特性，它可以非常方便的定制和配置缓存，缓存可以极大的提升查询效率。
• Mybatis系统中默认定义了两极缓存：一级缓存和二级缓存
  • 默认情况下，只有一集缓存开启，（SqlSession级别的缓存，也称为本地缓存）
  • 二级缓存需要手动开启和配置，它是基于namespace级别的缓存
  • 为了提交扩展性，Mybatis定义了缓存接口cache。我们可以通过是极限cache接口来自定义二级缓存

13.3、一级缓存

• 一级缓存也叫本地缓存：
  • 与数据库同一次会话期间查询到的数据会放在本地缓存中。
  • 以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库
• 缓存失效的情况：
  1. 映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。
  2. 缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不需要的缓存。
  3. 缓存不会定时进行刷新（也就是说，没有刷新间隔）。
  4. 查询不同的东西
  5. 手动清理缓存
  6. 查询不同的mapper.xml
     小结：一级缓存默认是开启的，只是一次SqlSession中有效，也就是拿到连接到关闭连接这个区间段，一级缓存相当于一个Map。

13.4、二级缓存

• 二级缓存也叫全局缓存，一级缓存的作用域太低了，所有诞生了二级缓存
• 基于namespace级别的缓存，一个名称空间，对应一个二级缓存
• 工作机制
  • 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中
  • 如果当前会话关闭了，这个会话对应的一级缓存就没有了；但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中
  • 新的会话查询信息，就可以从二级缓存中获取内容；
  • 不同的mapper查询出来的数据会放在自己对应的缓存（map）中
• 步骤：
  1. 开启全局缓存

  <!--显示的开启全局缓存-->
  <setting name="cacheEnabled" value="true"/>
  

  2. 在要使用二级缓存的Mapper中使用缓存

  <cache/>
  

  也可以自定义一些参数

  <cache
  eviction="FIFO"<!--回收策略-->
  flushInterval="60000"<!--刷新时间间隔，默认不刷新，单位毫秒-->
  size="512"<!--缓存可以存储的大小，设置数字，表示多少个元素-->
  type=""<!--自定义缓存中使用，我们使用默认值就不用，使用自定义缓存时实现mybatis中的cache接口即可，type写自定义缓存的全类名即可。-->
  readOnly="true"/><!--是否只读，true表示只读，false非只读-->
  <!--
  只读：mybatis认为所有从缓存中获取的数据都是只读操作，不会修改数据，mybatis为了加快速度，会直接将数据在缓存中的引用交给用户。不安全，速度快
  非只读：mybatis任务交给用户的数据会被修改。会利用序列化&反序列化的技术克隆一份数据交给用户，安全，速度慢。同时POJO需要实现序列化。
  -->
  

  3. 问题
     我们需要将实体类序列化
  4. 和缓存有关的设置/属性：
     cacheEnabled=“true/false”:开启/关闭缓存，全局中关闭二级缓存，一级缓存一直有效。
     每一个select标签都有useCache=“true”
     false：二级缓存关闭，一级缓存依然不受影响
     每一个增删改标签都有一个flushCache=“true”,执行增删改刷新缓存。一级缓存二级缓存都会清空。
     查询标签中flushCache=“false”,如果改为true，每次查询结束都会清空缓存。
     sqlSession.clearCache();只会清空当前SqlSession的一级缓存，二级缓存不受影响。
     localCacheScope：本地缓存作用域。全局配置中的属性，默认值是session。如果改为STATEMENT，可以禁用一级缓存。
  5. 小结：
     • 只要开启了二级缓存，在同一个Mapper下就有效
     • 所有的数据会先放在一级缓存中；
     • 只有当会话提交，或者是关闭的时候，才会提交到二级缓存中！

13.5、缓存原理

13.6、自定义缓存ehcache

Ehcache是一种广泛使用的开源Java分布式缓存，只要面向通用缓存。

要在程序中使用：

1. 导包

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-ehcache -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.0.0</version>
</dependency>

2.在Mapper中引用即可

<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

3. ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <!--
    diskStore:为缓存路径ehcache分为内存和磁盘两极，此属性定义磁盘的缓存位置，参数解释如下：
    user.home-用户主目录
    user.dir-用户当前工作目录
    java.io.tmpdir-默认临时文件路径
    -->
    <diskStore path="./tmpdir/Tmp_EhCache"/>
    <defaultCache
        eternal="false"
        maxElementsInMemory="10000"
        overflowToDisk="false"
        diskPersistent="false"
        timeToIdleSeconds="1800"
        timeToLiveSeconds="259200"
        memoryStoreEvictionPolicy="LRU"/>

    <cache
            name="cloud_user"
            eternal="false"
            maxElementsInMemory="5000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="1800"
            memoryStoreEvictionPolicy="LRU"/>
    <!--
    defaultCache:默认缓存策略，当ehcache找不到定义的缓存时，则使用这个缓存策略，只能定义一个
    -->
    <!--
    name：缓存名称
    maxElementsInMemory：缓存最大数目
    maxElementsOnDisk：硬盘最大缓存数
    eternal：对象是否永久有效，一但设置了，timeout将不起作用
    overflowToDisk：是否保存到硬盘，当系统宕机时
    timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒），仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可以闲置
    timeToLiveSeconds：设置对象在失效前的允许存活时间（单位：秒），最大时间介于创建时间和失效时间之间，仅当eternal=false对象不是永久有效时使用
    diskPersistent：是否缓存虚拟机重启期数据whether the dish store persists between restarts of the Virtual Machine.
    diskSpoolBufferSizeMB:这个参数设置DiskStore（磁盘缓存）的缓存区间大小，默认是30MB，每个cache都应该存在自己的一个缓冲区
    diskExpiryThreadIntervalSeconds:磁盘失效线程运行时间间隔，默认是120秒
    memoryStoreEvictionPolicy：当达到maxElementsInMemory界限时，Ehcache将会根据指定的策略去清理内存，默认是LRU（最近最少使用）
    clearOnFlush：内存数量最大时是否清除
    memoryStoreEvictionPolicy：可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）
    -->
</ehcache>

13.7、引用缓存

<cache-ref namespace="引用地址"/>，当在一个mapper中使用如Ehcache等第三方缓存后，可以在其他mapper中直接引用该mapper的地址，表示两个mapper用同一个缓存。

12、mybatis整合spring

13、mybatis逆向工程

• Mybatis Generator
  简称MBG，是一个专门为Mybatis框架使用者定制的代码生成器，可以快速的根据表生产映射文件，接口，以及javaBean。支持基本的增删改查以及QBC风格的条件查询。但是表连接，存储过程等复杂的SQL的定义需要我们手工书写。
• 官方文档www.mybatis.org/generator
• 官方工程github.com/mybatis/generator/releases
• 下载官方工程，新建工程，导入jar包，编写配置文件，运行，生成逆向工程。