1.Mybatis定义：

MyBatis 是一款优秀的 持久层框架
MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集的过程
MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 实体类 【Plain Old，Java Objects,普通的 Java对象】映射成数据库中的记录。

mybatis – MyBatis 3 | 简介http://www.mybatis.org/mybatis-3/zh/index.html

2.持久化

持久化是将程序数据在持久状态和瞬时状态间转换的机制。
即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。持久化的主要应用是将内存中的对象存储在数据库中，或者存储在磁盘文件中、XML数据文件中等等。
JDBC就是一种持久化机制。文件IO也是一种持久化机制。
在生活中 : 将鲜肉冷藏，吃的时候再解冻的方法也是。将水果做成罐头的方法也是。
为什么需要持久化服务呢？那是由于内存本身的缺陷引起的,内存断电后数据会丢失，但有一些对象是无论如何都不能丢失的，比如银行账号等，遗憾的是，人们还无法保证内存永不掉电。

3.持久层

完成持久化工作的代码块 . ----> dao层 【DAO (Data Access Object) 数据访问对象】
大多数情况下特别是企业级应用，数据持久化往往也就意味着将内存中的数据保存到磁盘上加以固化，
而持久化的实现过程则大多通过各种 关系数据库 来完成。
不过这里有一个字需要特别强调，也就是所谓的“层”。对于应用系统而言，数据持久功能大多是必不可少的组成部分。也就是说，我们的系统中，已经天然的具备了“持久层”概念？也许是，但也许实际情况并非如此。之所以要独立出一个“持久层”的概念,而不是“持久模块”，“持久单元”，也就意味着，我们的系统架构中，应该有一个相对独立的逻辑层面，专注于数据持久化逻辑的实现.
与系统其他部分相对而言，这个层面应该具有一个较为清晰和严格的逻辑边界。

4.编写Mybatis程序

（1.）导入pom.xml依赖

<!--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>5.1.47</version>
</dependency>

（2.）编写Mybatis核心配置文件

<?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>
    <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="11261221"/>
            </dataSource>
        </environment>
    </environments>
    <!--每一个Mapper.xml都需要在核心配置文件中注册-->
<mappers>
    <mapper resource="com/lyt/dao/UserMapper.xml"/>
</mappers>
</configuration>

（3.）编写Mybatis工具类

每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。使用任意的输入流（InputStream）实例。MyBatis 包含一个名叫 Resources 的工具类，它包含一些实用方法，使得从类路径或其它位置加载资源文件更加容易，从而定义一个输入流，把我们的核心资源文件放入。

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;

public class MybatisUtils {
     private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            String resource="mybatis-config.xml";
            InputStream inputStream= Resources.getResourceAsStream(resource);
            sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static SqlSession getSqlsession(){
        return sqlSessionFactory.openSession();
    }
}

（4.）创建一个实体类

package com.lyt.pojo;
//实体类
public class User {
    private  int id;
    private String name;
    private String pwd;

    //有参、无参构造

    //get、set方法
    
    //toString方法
}

（5.）编写我们dao层接口

import com.lyt.pojo.User;
import java.util.List;
import java.util.Map;

public interface UserDao {
    List<User> getUserLike(String value);
    List<User> getUserList();
    User getUserByid(int id);
    User getUserByid2(Map map);
    int addUser(User user);
    int updateUser(User user);
    int deleteUser(int id);
}

（6.）编写我们Mapper.xml文件

要注意namespace绑定我们UserDao，在我们mapper中写我们sql语句，id是我们UserDao接口中的方法

<?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">
<!--namespace绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.lyt.dao.UserDao" >

    <select id="getUserLike" parameterType="String" resultType="com.lyt.pojo.User">
        SELECT * FROM mybatis.user WHERE name LIKE "%" #{value} "%"
    </select>
    <select id="getUserList" resultType="com.lyt.pojo.User">
        select * from mybatis.user
    </select>
    <select id="getUserByid" resultType="com.lyt.pojo.User" parameterType="int">
        SELECT * FROM mybatis.user WHERE id=#{id}
    </select>
    <select id="getUserByid2" resultType="com.lyt.pojo.User" parameterType="map">
        SELECT * FROM mybatis.user WHERE id=#{id} AND name=#{name}
    </select>
    <insert id="addUser" parameterType="com.lyt.pojo.User">
        INSERT INTO user (id,name,pwd) VALUES (#{id},#{name},#{pwd})
    </insert>
    <update id="updateUser" parameterType="com.lyt.pojo.User" >
        UPDATE user SET name=#{name},pwd=#{pwd} WHERE id=#{id}
    </update>
    <delete id="deleteUser" parameterType="int">
        DELETE FROM user WHERE id=#{id}
    </delete>
</mapper>

（7.）编写测试类

在实际应用中，我们要通过service层调用我们的dao层，进而调用数据库。

要调用UserDao中的方法首先要获得SqlSession对象，通过我们写的Mybatis工具类，得到SqlSession对象后在调用它的getMapper方法得到我们UserDao对象，进而调用UserDao中对象。

package com.lyt.dao;

import com.lyt.pojo.User;
import com.lyt.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class UserDaoTest {
    //模糊查询别忘%String%
    @Test
    public void selectLike(){
        SqlSession sqlSession= MybatisUtils.getSqlsession();
        UserDao userDao= sqlSession.getMapper(UserDao.class);
        List<User> userList= userDao.getUserLike("李");
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }
    @Test
    public void test(){
       SqlSession sqlSession= MybatisUtils.getSqlsession();
       UserDao userDao= sqlSession.getMapper(UserDao.class);
       List<User> userList= userDao.getUserList();
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }
    @Test
    public void selectByid(){
        SqlSession sqlSession=MybatisUtils.getSqlsession();
        UserDao userDao=sqlSession.getMapper(UserDao.class);
        User user= userDao.getUserByid(2);
        System.out.println(user.toString());
        sqlSession.close();

    }
    @Test
    public void selectByid2(){
        SqlSession sqlSession=MybatisUtils.getSqlsession();
        UserDao userDao=sqlSession.getMapper(UserDao.class);
        Map<String,Object> map=new HashMap<String,Object>();
        map.put("id",3);
        map.put("name","王五");
        User user= userDao.getUserByid2(map);
        System.out.println(user.toString());
        sqlSession.close();
    }
    @Test
    public void addUser(){
        SqlSession sqlSession=MybatisUtils.getSqlsession();
        UserDao userDao= sqlSession.getMapper(UserDao.class);
        User user=new User(5,"com.lyt","123789");
        int res=userDao.addUser(user);
        if(res>0){
            System.out.println("插入成功");
        }
        sqlSession.commit();
        sqlSession.close();
    }
    @Test
    public void update(){
        SqlSession sqlSession= MybatisUtils.getSqlsession();
        UserDao userDao=sqlSession.getMapper(UserDao.class);
        User user=new User(5,"com.lyt","333333");
        userDao.updateUser(user);
        sqlSession.commit();
        sqlSession.close();
    }
    @Test
    public void delete(){
        SqlSession sqlSession=MybatisUtils.getSqlsession();
        UserDao userDao=sqlSession.getMapper(UserDao.class);
        userDao.deleteUser(5);
        sqlSession.commit();
        sqlSession.close();
    }


}

maven静态资源加载问题

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

5.总结

Mybatis简化了我们JDBC 代码和手动设置参数以及获取结果集的过程，并且将我们java与数据库sql语句分离。

SqlSessionFactory基本介绍（https://www.jianshu.com/p/0eb0904de2f3）：

SqlSessionFactory是MyBatis框架中的一个接口，主要负责MyBatis框架初始化操作及提供SqlSession对象（通过openSession获取SqlSession）。SqlSessionFactory对象的实例可以通过SqlSessionFactoryBuilder对象类获得，SqlSessionFactoryBuilder可以从XML配置文件或一个预先定制的Configuration的实例构建出SqlSessionFactory的实例。

//通过openSession方法获得sqlSession
public interface SqlSessionFactory {

  SqlSession openSession();
  
  SqlSession openSession(boolean autoCommit);//事务是手动提交还是自动提交
  SqlSession openSession(Connection connection);//其他方式拿到一个connection，不通过数据库连接池
  SqlSession openSession(TransactionIsolationLevel level);//当前操作数据库的事务隔离级别

  SqlSession openSession(ExecutorType execType);//当前操作数据库对象拿到的执行器类型
  SqlSession openSession(ExecutorType execType, boolean autoCommit);
  SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level);
  SqlSession openSession(ExecutorType execType, Connection connection);

  Configuration getConfiguration();

}

创建SqlSessionFactory基本执行流程

1. 调用 SqlSessionFactoryBuilder 对象的 build(inputStream) 方法；

2. SqlSessionFactoryBuilder 会根据输入流 inputStream 等信息创建XMLConfigBuilder 对象 ; 

3. SqlSessionFactoryBuilder 调用 XMLConfigBuilder 对象的 parse() 方法；

4. XMLConfigBuilder 对象返回 Configuration 对象；

5. SqlSessionFactoryBuilder创建一个DefaultSessionFactory 对象,并将Configuration对象作为参数传给DefaultSessionFactory对象；

6. SqlSessionFactoryBuilder 返回 DefaultSessionFactory 对象给 Client ，供 Client使用。
   Client可以使用DefaultSessionFactory对象创建需要的SqlSession.

上面初始化过程中设计到几个对象：

• SqlSessionFactoryBuilder ：SqlSessionFactory的构造器，用于创建SqlSessionFactory，采用了建造者设计模式。
• Configuration ：该对象是mybatis-config.xml文件中所有mybatis配置信息。
• SqlSessionFactory：SqlSession工厂类，以工厂形式创建SqlSession对象，采用了Factory工厂设计模式。
• XmlConfigParser ：负责将mybatis-config.xml配置文件解析成Configuration对象，共SqlSessonFactoryBuilder使用，创建SqlSessionFactory。

SqlSession

MyBatis的SqlSession与JDBC的Connection对比

SqlSession对象，该对象中包含了执行SQL语句的所有方法，类似于JDBC里面的Connection。这种“类似”体现在以下几个方面：

（1）在JDBC中，Connection不直接执行SQL方法，而是生成Statement或者PrepareStatement对象，利用Statement或者PrepareStatement来执行增删改查方法。
（2）在MyBatis中，SqlSession可以直接执行增删改查方法，例如：<T> T selectOne(String statement);int insert(String statement, Object parameter);等，也可以获取映射器Mapper：<T> T getMapper(Class<T> type);然后通过映射器来执行增删改查操作。

SqlSession与Executor

SqlSession只是一个前台客服，真正发挥作用的是Executor，对SqlSession方法的访问最终都会落到Executor的相应方法上去。Executor分成两大类：一类是CachingExecutor，另一类是普通的Executor。

（1）CachingExecutor有一个重要属性delegate，它保存的是某类普通的Executor，在构造函数时候传入。执行数据库update操作时，它直接调用delegate的update方法，执行query方法时先尝试从cache中取值，取不到再调用delegate的查询方法，并将查询结果存入cache中。

（2）普通Executor分三类：SimpleExecutor、ReuseExecutor和BatchExecutor。它们都继承于BaseExecutor，BatchExecutor专门用于执行批量sql操作，ReuseExecutor会重用Statement执行sql操作，SimpleExecutor只是简单执行sql。

SimpleExecutor是一种常规执行器，每次执行都会创建一个Statement，用完后关闭。
ReuseExecutor是可重用执行器，将Statement存入map中，操作map中的Statement而不会重复创建Statement。
BatchExecutor是批处理型执行器，doUpdate预处理存储过程或批处理操作，doQuery提交并执行过程。

总之，Executor最终是通过JDBC的java.sql.Statement来执行数据库操作。

执行流程：

调用 SqlSessionFactoryBuilder 对象的 build(inputStream) 方法对象,根据输入流 inputStream 等信息创建XMLConfigBuilder 对象,XMLConfigBuilder 对象返回 Configuration 对象;SqlSessionFactoryBuilder创建一个DefaultSessionFactory 对象,并将Configuration对象作为参数传给DefaultSessionFactory对象；SqlSessionFactoryBuilder 返回 DefaultSessionFactory 对象给 Client ，供 Client使用。Client可以使用DefaultSessionFactory对象通过调用openSession()方法得到需要的SqlSession。SqlSession通过getMapper得到相应的对象，我们通过调用该对象的方法从而在该方法的映射文件（xml）中调用对应的增删改查操作。