MyBatis的原理

摘要：不是线程安全的，所以在使用的时候一定要保证他是局部变量。他对应的类图如下有几种常见的实现是默认的非线程安全的实现是中对的线程安全实现，在内部是使用的的形式来保证线程安全的是的核心。是线程安全的，可以被多个或映射器所共享使用。

SqlSessionFactory

每一个MyBatis应用都是以一个SqlSessionFactory的实例为核心构建的。SqlSessionFactory的核心作用是什么？

从类的名称上可以看出来，SqlSessionFactory是产生SqlSession的工厂。SqlSessionFactory是通过SqlSessionFactoryBuilder这个构建器来构建的。

SqlSessionFactory是一个接口，其中定义了获取SqlSession的方法。

public interface SqlSessionFactory {
    //获取一个SqlSession
    SqlSession openSession();
    //获取一个SqlSession,参数设置事务是否自动提交
    SqlSession openSession(boolean var1);
    //通过指定Connection中的参数获取
    SqlSession openSession(Connection var1);
    //获取SqlSession,设置事务的隔离级别，NONE(0)，READ_COMMITTED(2),READ_UNCOMMITTED(1),REPEATABLE_READ(4),SERIALIZABLE(8);
    SqlSession openSession(TransactionIsolationLevel var1);
    //获取SqlSession，同时制定执行的类别，支持三种SIMPLE(这种模式下，将为每个语句创建一个PreparedStatement),REUSE(这个模式下重复使用preparedStatment),BATCH(批量更新，insert时候，如果没有提交，无法获取自增id);
    SqlSession openSession(ExecutorType var1);
    SqlSession openSession(ExecutorType var1, boolean var2);
    SqlSession openSession(ExecutorType var1, TransactionIsolationLevel var2);
    SqlSession openSession(ExecutorType var1, Connection var2);
    //获取所有的配置项
    Configuration getConfiguration();
}

SqlSessionFactory包含两个实现：DefaultSqlSessionFactory和SqlSessionManager
SqlSessionFactory的实例如何创建呢？
1、通常我们是在只有MyBatis的项目中是使用下面的代码段来创建的：

String resource = "org/mybatis/example/mybatis-config.xml";
//读取mybatis配置的问题
InputStream inputStream = Resources.getResourceAsStream(resource);
//通过SqlSessionFactoryBuilder的build方式创建
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

2、在Spring boot和MyBatis结合的项目中我会使用下面的代码段来创建：

MyBatis-Spring-Boot-Starter依赖将会提供如下

自动检测现有的DataSource

将创建并注册SqlSessionFactory的实例，该实例使用SqlSessionFactoryBean将该DataSource作为输入进行传递

将创建并注册从SqlSessionFactory中获取的SqlSessionTemplate的实例。

自动扫描您的mappers，将它们链接到SqlSessionTemplate并将其注册到Spring上下文，以便将它们注入到您的bean中。

就是说，使用了该Starter之后，只需要定义一个DataSource即可（application.properties中可配置），它会自动创建使用该DataSource的SqlSessionFactory Bean以及SqlSessionTemplate。会自动扫描你的Mappers，连接到SqlSessionTemplate，并注册到Spring上下文中.

@Bean
public SqlSessionFactory sqlSessionFactory(@Qualifier("druidDataSource") DataSource druidDataSource) throws Exception {
    //先创建一个SqlSessionFactoryBean
    SqlSessionFactoryBean fb = new SqlSessionFactoryBean();
    //在这个bean里设置需要的参数
    fb.setDataSource(this.dynamicDataSource(druidDataSource));
    fb.setTypeAliasesPackage(env.getProperty("mybatis.type-aliases-package"));
    fb.setTypeHandlersPackage(env.getProperty("mybatis.type-handlers-package"));
    fb.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(env.getProperty("mybatis.mapperLocations")));
    //通过这个方法获取一个SqlSessionFactory
    return fb.getObject();
}

在代码里一直向下查找的时候就会发现：这个过程其实和上面的过程一样。
SqlSessionFactoryBean会将一系列的属性封装成一个Configuration对象，然后调用
this.sqlSessionFactoryBuilder.build(configuration) 来创建。而在sqlSessionFactoryBuilder里主要就是解析资源的内容，然后进行创建。

在这里有分别使用了两个设计模式：

工厂模式

SqlSessionFactory就是一个工厂模式——简单工厂模式的变形实现。
通过SqlSessionFactory中重载的不同openSession()方法来获取不同类型的实例。

建造者模式（build模式）

SqlSessionFactoryBuilder创建SqlSessionFactory就是建造者模式的实现。在创建的过程中需要解析很多的文件，生成对象，进行缓存等操作，所以一个方法是很难直接写完，所以其中应用了大量的build模式：

protected SqlSessionFactory buildSqlSessionFactory() throws IOException {
    XMLConfigBuilder xmlConfigBuilder = null;
    Configuration configuration;
    if (this.configuration != null) {
       ......
    } else if (this.configLocation != null) {
        xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), (String)null, this.configurationProperties);
        configuration = xmlConfigBuilder.getConfiguration();
    } else {
        ......
    }
    ......

    if (xmlConfigBuilder != null) {
        try {
            //builder解析
            xmlConfigBuilder.parse();
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Parsed configuration file: "" + this.configLocation + """);
            }
        } catch (Exception var22) {
            throw new NestedIOException("Failed to parse config resource: " + this.configLocation, var22);
        } finally {
            ErrorContext.instance().reset();
        }
    }
    ......
    if (!ObjectUtils.isEmpty(this.mapperLocations)) {
        Resource[] var29 = this.mapperLocations;
        var27 = var29.length;

        for(var5 = 0; var5 < var27; ++var5) {
            Resource mapperLocation = var29[var5];
            if (mapperLocation != null) {
                try {
                    //Mapper文件build
                    XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(), configuration, mapperLocation.toString(), configuration.getSqlFragments());
                    xmlMapperBuilder.parse();
                } catch (Exception var20) {
                    
                } finally {
                    //单例模式
                    ErrorContext.instance().reset();
                }
            }
        }
    } 
    //build一个对象返回
    return this.sqlSessionFactoryBuilder.build(configuration);
}

SqlSession

SqlSessionFactory创建完成之后，就可以通过SqlSessionFactory对象来获取一个SqlSession实例.SqlSession是一次与数据库的会话.在他的接口中定义了一些列的CRUD和事务的操作接口。SqlSession是暴露给用户使用的API,一个SqlSession对应着一次数据库会话。SqlSession不是线程安全的，所以在使用的时候一定要保证他是局部变量。
他对应的类图如下：

SqlSession有几种常见的实现：DefaultSqkSession是默认的非线程安全的实现,SqlSessionManager是Mybatis中对SqlSession的线程安全实现，在内部是使用的private ThreadLocal localSqlSession = new ThreadLocal();的形式来保证线程安全的,SqlSessionTemplate是MyBatis-Spring 的核心。作为 SqlSession 的一个实现，这意味着可以使用它无缝代替你代码中已经在使用的 SqlSession。SqlSessionTemplate 是线程安全的，可以被多个 DAO 或映射器所共享使用。

因为SqlSessionTemplate是线程安全的，所以当SqlSessionTemplate是单例的时候，多线程调用SqlSessionTemplate仍然使用的是同一个SqlSession,接下来看一下SqlSessionTemplate是如何保证线程安全的呢？

首先我们看一下SqlSessionTemplate的创建过程：

/**
 * 构造函数1，需要传入参数SqlSessionFactory
 */
public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
    this(sqlSessionFactory, sqlSessionFactory.getConfiguration().getDefaultExecutorType());
}

public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType) {
    this(sqlSessionFactory, executorType, new MyBatisExceptionTranslator(sqlSessionFactory.getConfiguration().getEnvironment().getDataSource(), true));
}

public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {
    Assert.notNull(sqlSessionFactory, "Property "sqlSessionFactory" is required");
    Assert.notNull(executorType, "Property "executorType" is required");
    this.sqlSessionFactory = sqlSessionFactory;
    this.executorType = executorType;
    this.exceptionTranslator = exceptionTranslator;
    //创建代理类的实例，该代理类实现了SqlSession接口，这里使用的是基于JDK的动态代理，SqlSessionInterceptor也是实现了InvocationHandler接口，最后代理对象的操作都会经过invoke执行
    //class SqlSessionInterceptor implements InvocationHandler
    this.sqlSessionProxy = (SqlSession)Proxy.newProxyInstance(SqlSessionFactory.class.getClassLoader(), new Class[]{SqlSession.class}, new SqlSessionTemplate.SqlSessionInterceptor());
}

invoke的实现是实现线程安全的核心：

private class SqlSessionInterceptor implements InvocationHandler {
    private SqlSessionInterceptor() {
    }
  
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
     //获取真实的SqlSession，这个是真实使用的，是MyBatis生成的DefaultSqlSession,获取是线程安全实现的核心
        SqlSession sqlSession = SqlSessionUtils.getSqlSession(SqlSessionTemplate.this.sqlSessionFactory, SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);

        Object unwrapped;
        try {
            //执行操作
            Object result = method.invoke(sqlSession, args);
            //如果不是事务类型的，那么设置为自动提交
            if (!SqlSessionUtils.isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
                sqlSession.commit(true);
            }
            //执行结果包装
            unwrapped = result;
        } catch (Throwable var11) {
            unwrapped = ExceptionUtil.unwrapThrowable(var11);
            if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
                SqlSessionUtils.closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
                sqlSession = null;
                Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException)unwrapped);
                if (translated != null) {
                    unwrapped = translated;
                }
            }

            throw (Throwable)unwrapped;
        } finally {
            if (sqlSession != null) {
                SqlSessionUtils.closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
            }

        }
        //返回执行结果
        return unwrapped;
    }
}

接着看getSqlSession()的代码：

public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {
    Assert.notNull(sessionFactory, "No SqlSessionFactory specified");
    Assert.notNull(executorType, "No ExecutorType specified");
    //SqlSessionHolder是对SqlSession的一个功能包装，TransactionSynchronizationManager是一个事务同步管理器，维护当前线程事务资源，信息以及TxSync集合，getResource会从 ThreadLocal> resources 中获取当前线程SqlSessionHolder实例
    SqlSessionHolder holder = (SqlSessionHolder)TransactionSynchronizationManager.getResource(sessionFactory);
    SqlSession session = sessionHolder(executorType, holder);
    if (session != null) {
        return session;
    } else {
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("Creating a new SqlSession");
        }
        //如果没有获取成功，那么开启一个SqlSession
        session = sessionFactory.openSession(executorType);
        //注册SessionHolder
        registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);
        return session;
    }
}

registerSessionHolder()实现？

好难啊～～～～～