对SqlSessionFactory的浅显理解

最新推荐文章于 2024-07-17 10:40:11 发布
最新推荐文章于 2024-07-17 10:40:11 发布
阅读量570 收藏
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Aresxiaohe/article/details/106257673
版权

在学习Mybatis的时，看到了SqlSessionFactory，然后就结合源码和网上大佬的总结大致了解了一下流程。

String resource = "/mybatis-config.xml";

InputStream inputStream = Resources.class.getResourceAsStream(resource);

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

在刚开始学习Mybatis的时候，想必大家对上面这个几行东西都很熟悉，所以就来探究学习一下其内部流程。

SqlSessionFactory源码

public interface SqlSessionFactory {

    SqlSession openSession();

    SqlSession openSession(boolean var1);

     SqlSession openSession(Connection var1);

    SqlSession openSession(TransactionIsolationLevel var1);

    SqlSession openSession(ExecutorType var1);

    SqlSession openSession(ExecutorType var1, boolean var2);

    SqlSession openSession(ExecutorType var1, TransactionIsolationLevel var2);

    SqlSession openSession(ExecutorType var1, Connection var2);

    Configuration getConfiguration();

}

SqlSessionFactoryBuilder()

先看一下几种不同的build方法

1、

public SqlSessionFactory build(Reader reader, String environment, Properties properties) {

    SqlSessionFactory var5;

    try {

        XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);

        var5 = this.build(parser.parse());

    } catch (Exception var14) {

        throw ExceptionFactory.wrapException("Error building SqlSession.", var14);

    } finally {

        ErrorContext.instance().reset();

        try {

            reader.close();

        } catch (IOException var13) {

        }

    }

    return var5;

}

 

2、

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {

    SqlSessionFactory var5;

    try {

        XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);

        var5 = this.build(parser.parse());

    } catch (Exception var14) {

        throw ExceptionFactory.wrapException("Error building SqlSession.", var14);

    } finally {

        ErrorContext.instance().reset();

        try {

            inputStream.close();

        } catch (IOException var13) {

        }

    }

    return var5;

}

 

3、

public SqlSessionFactory build(Configuration config) {

    return new DefaultSqlSessionFactory(config);

}

 

从源码种可以看出，主要通过上面这三种方法。1、字符流。2、字节流。3、Configuration类实例作为入参。

通过上面源码不难看出，不管是字符流还是字节流最后都是指向了第三种方法。

 

那么SqlSessionFactory的基本构建流程其实也就比较明了了。

配置文件--->SqlSessionFactorybuild-->XMLConfigBuilder-->Configuration-->DefaultSqlSessionFactory

其实也就是SqlSessionFactorybuild读取配置文件后，先通过XMLConfigBuilder生产出Configuration类实例对象。

XMLConfigBuilder源码

public XMLConfigBuilder(InputStream inputStream, String environment, Properties props) {

    this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment, props);

}

private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {

    super(new Configuration());

    ErrorContext.instance().resource("SQL Mapper Configuration");

    this.configuration.setVariables(props);

    this.parsed = false;

    this.environment = environment;

    this.parser = parser;

}

public Configuration parse() {

    if (this.parsed) {

        throw new BuilderException("Each XMLConfigBuilder can only be used once.");

    } else {

        this.parsed = true;

        this.parseConfiguration(this.parser.evalNode("/configuration"));

        return this.configuration;

    }

}

private void parseConfiguration(XNode root) {

    try {

        this.propertiesElement(root.evalNode("properties"));

        this.typeAliasesElement(root.evalNode("typeAliases"));

        this.pluginElement(root.evalNode("plugins"));

        this.objectFactoryElement(root.evalNode("objectFactory"));

        this.objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));

        this.settingsElement(root.evalNode("settings"));

        this.environmentsElement(root.evalNode("environments"));

        this.databaseIdProviderElement(root.evalNode("databaseIdProvider"));

        this.typeHandlerElement(root.evalNode("typeHandlers"));

        this.mapperElement(root.evalNode("mappers"));

    } catch (Exception var3) {

        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + var3, var3);

    }

}

 

DefaultSqlSessionFactory源码

//

// Source code recreated from a .class file by IntelliJ IDEA

// (powered by Fernflower decompiler)

//

package org.apache.ibatis.session.defaults;

import java.sql.Connection;

import java.sql.SQLException;

import org.apache.ibatis.exceptions.ExceptionFactory;

import org.apache.ibatis.executor.ErrorContext;

import org.apache.ibatis.executor.Executor;

import org.apache.ibatis.mapping.Environment;

import org.apache.ibatis.session.Configuration;

import org.apache.ibatis.session.ExecutorType;

import org.apache.ibatis.session.SqlSession;

import org.apache.ibatis.session.SqlSessionFactory;

import org.apache.ibatis.session.TransactionIsolationLevel;

import org.apache.ibatis.transaction.Transaction;

import org.apache.ibatis.transaction.TransactionFactory;

import org.apache.ibatis.transaction.managed.ManagedTransactionFactory;

public class DefaultSqlSessionFactory implements SqlSessionFactory {

    private final Configuration configuration;

    public DefaultSqlSessionFactory(Configuration configuration) {

        this.configuration = configuration;

    }

    public SqlSession openSession() {

        return this.openSessionFromDataSource(this.configuration.getDefaultExecutorType(), (TransactionIsolationLevel)null, false);

    }

    public SqlSession openSession(boolean autoCommit) {

        return this.openSessionFromDataSource(this.configuration.getDefaultExecutorType(), (TransactionIsolationLevel)null, autoCommit);

    }

 

    public SqlSession openSession(ExecutorType execType) {

        return this.openSessionFromDataSource(execType, (TransactionIsolationLevel)null, false);

    }

    public SqlSession openSession(TransactionIsolationLevel level) {

        return this.openSessionFromDataSource(this.configuration.getDefaultExecutorType(), level, false);

    }

    public SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level) {

        return this.openSessionFromDataSource(execType, level, false);

    }

    public SqlSession openSession(ExecutorType execType, boolean autoCommit) {

        return this.openSessionFromDataSource(execType, (TransactionIsolationLevel)null, autoCommit);

    }

    public SqlSession openSession(Connection connection) {

        return this.openSessionFromConnection(this.configuration.getDefaultExecutorType(), connection);

    }

    public SqlSession openSession(ExecutorType execType, Connection connection) {

        return this.openSessionFromConnection(execType, connection);

    }

    public Configuration getConfiguration() {

        return this.configuration;

    }

    private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {

        Transaction tx = null;

        DefaultSqlSession var8;

        try {

            Environment environment = this.configuration.getEnvironment();

            TransactionFactory transactionFactory = this.getTransactionFactoryFromEnvironment(environment);

            tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);

            Executor executor = this.configuration.newExecutor(tx, execType);

            var8 = new DefaultSqlSession(this.configuration, executor, autoCommit);

        } catch (Exception var12) {

            this.closeTransaction(tx);

            throw ExceptionFactory.wrapException("Error opening session.  Cause: " + var12, var12);

        } finally {

            ErrorContext.instance().reset();

        }

        return var8;

    }

    private SqlSession openSessionFromConnection(ExecutorType execType, Connection connection) {

        DefaultSqlSession var8;

        try {

            boolean autoCommit;

            try {

                autoCommit = connection.getAutoCommit();

            } catch (SQLException var13) {

                autoCommit = true;

            }

            Environment environment = this.configuration.getEnvironment();

            TransactionFactory transactionFactory = this.getTransactionFactoryFromEnvironment(environment);

            Transaction tx = transactionFactory.newTransaction(connection);

            Executor executor = this.configuration.newExecutor(tx, execType);

            var8 = new DefaultSqlSession(this.configuration, executor, autoCommit);

        } catch (Exception var14) {

            throw ExceptionFactory.wrapException("Error opening session.  Cause: " + var14, var14);

        } finally {

            ErrorContext.instance().reset();

        }

        return var8;

    }

    private TransactionFactory getTransactionFactoryFromEnvironment(Environment environment) {

        return (TransactionFactory)(environment != null && environment.getTransactionFactory() != null ? environment.getTransactionFactory() : new ManagedTransactionFactory());

    }

    private void closeTransaction(Transaction tx) {

        if (tx != null) {

            try {

                tx.close();

            } catch (SQLException var3) {

            }

        }

    }

}

 

DefaultSqlSessionFactory只有一个属性Configuration和一个构造方法。

从源码看出DefaultSqlSessionFactory最后还是调用openSessionFromDataSource或者openSessionFromConnection的。

openSessionFromDataSource

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {

    Transaction tx = null;

    DefaultSqlSession var8;

    try {

        Environment environment = this.configuration.getEnvironment();

        TransactionFactory transactionFactory = this.getTransactionFactoryFromEnvironment(environment);

        tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);

        Executor executor = this.configuration.newExecutor(tx, execType);

        var8 = new DefaultSqlSession(this.configuration,configuration, autoCommit);

    } catch (Exception var12) {

        this.closeTransaction(tx);

        throw ExceptionFactory.wrapException("Error opening session.  Cause: " + var12, var12);

    } finally {

        ErrorContext.instance().reset();

    }

    return var8;

}

 

此方法执行的大致流程

1、先用configuration的environment对象去构造一个工厂transactionFactory。

2、然后再用transactionFactory工厂得到一个新对象Transaction，

3、再用新对象tx和execType去构建另一个对象executor。

4、最后configuration、configuration、autoCommit一起构造DefaultSqlSessionFactory。

openSessionFromConnection

private SqlSession openSessionFromConnection(ExecutorType execType, Connection connection) {

        DefaultSqlSession var8;

        try {

            boolean autoCommit;

            try {

                autoCommit = connection.getAutoCommit();

            } catch (SQLException var13) {

                autoCommit = true;

            }

            Environment environment = this.configuration.getEnvironment();

            TransactionFactory transactionFactory = this.getTransactionFactoryFromEnvironment(environment);

            Transaction tx = transactionFactory.newTransaction(connection);

            Executor executor = this.configuration.newExecutor(tx, execType);

            var8 = new DefaultSqlSession(this.configuration, executor, autoCommit);

        } catch (Exception var14) {

            throw ExceptionFactory.wrapException("Error opening session.  Cause: " + var14, var14);

        } finally {

            ErrorContext.instance().reset();

        }

        return var8;

    }

 

这个和上谜案的大致一致，不一样的就是

1、此方法首先从connection中获取到autoCommit。

2、在用transactionFactory工厂得到一个新对象Transaction时用connection作为参数。

 

Ares小何
关注
Java常用框架面试题
qq_26761587的博客
05-09 4840
主题 链接 Java基础知识 面试题 Java集合框架 面试题 Java并发编程 面试题 Redis 面试题 文章目录
我懵了，居然还有学校还在教 Java 的 Swing
weixin_45987961的博客
11-09 823
昨天，有个读者私信我说，“老师正在教 Swing，这个知识点还需要学习吗？” 说句实在话，刚看到这个问题的时候，我是想骂娘的！不是骂读者啊，你懂得，骂学校，骂老师。但我硬是掐着自己的大腿忍住了，很客气地回复了一句“对，甚至可以不学”。 有点点到为止的味道。 我之所以这么委婉，是希望读者不要对学校的老师心存偏见，影响了后面的学习进度。但我内心其实是非常愤怒的，都什么时候了，Java 中的 Swing 早被淘汰了，哪个项目还会用这玩意编写客户端界面呢！ 学 Swing、AWT 这些图形化组件纯属浪费.
SqlSessionFactory的理解
m0_65712857的博客
01-15 132
SqlSessionFactory的理解
MyBatis常用对象SqlSessionFactory和SqlSession介绍和运用
热门推荐
DemoTransfer
06-23 22万+
前言:学习框架一个比较好的路径阅读源码.本文介绍的SqlSessionFactory和SqlSession.可以通过了解SqlSessionFactory接口和SqlSession接口以及两个的实现类入手,去看源码了解实现过程.最好能把项目下载到本地,慢慢分析实现过程.Myabtis官网：http://www.mybatis.org/ github地址：https://github.com/myb
Java 在切面中为SqlSessionFactory调用.openSession()产生的非Bean的SqlSession对象 添加监听器，以监听它调用的insert、update操作。
最新发布
u012632105的博客
07-17 224
在Java中，为非Spring管理的Bean（如由的方法产生的SqlSession对象）添加监听器，需要采用一种间接的方法，因为Spring AOP默认只代理Spring容器管理的Bean。为了监听SqlSession对象的insert和update操作，我们可以创建一个代理，该代理负责生成代理的SqlSession对象。然后，我们可以在这个代理SqlSession上应用AOP来实现所需的监听功能。
SqlSessionFactory
Nana_Oyang的博客
03-03 2840
SqlSessionFactory
基于Maven的mybatis框架搭建（均实践）
little 小样
08-30 267
基于Maven的mybatis框架搭建以及各类知识点
ssm面试题
pengyuyan___的博客
11-27 1767
ssm面试题提问 一、什么是Mybatis （1）Mybatis是一个半ORM（对象关系映射）框架，它内部封装了JDBC，开发时只需要关注SQL语句本身，不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。程序员直接编写原生态sql，可以严格控制sql执行性能，灵活度高。 （2）MyBatis 可以使用 XML 或注解来配置和映射原生信息，将 POJO映射成数据库中的记录，避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。 （3）通过xml 文件或注解的方式将要执行的各种
Java高频面试题（四）
ditto77的博客
10-30 1154
Java高频面试题四六、 框架部分6.1、什么是框架?6.2 、MVC模式6.3、 MVC框架6.4、 简单讲一下struts2的执行流程？6.5、 Struts2中的拦截器，你都用它干什么？6.6 、SpringMVC的执行流程？2.2.6.1MVC的各个部分技术实现?6.7、 struts2和springMVC有什么不同？6.8、 Spring中的两大核心？6.8.1、Spring是什么？6....
SqlSessionFactory介绍
zly的博客
12-22 6644
SqlSessionFactory是MyBatis的关键对象，它是单个数据库映射关系经过编译后的内存镜像。 SqlSessionFactory对象的实例可以通过SqlSessionFactoryBuilder对象来获得，而SqlSessionFactoryBuildr则可以从XML配置文件或一个预先定制的Configuration的实例构建出SqlSessionFactory的实例。 每一个MyB...
什么是SqlSessionFactory
weixin_66107850的博客
11-15 1564
SqlSession是Mybatis最重要的构建之一，可以简单的任务Mybatis一系列的配置目的是生成类似JDBC生成的Connection对象的SqlSession，这样才能和数据库开启“沟通的桥梁”，通过SqlSession可以实现增删改查（当然现在更加推荐是使用Mapper接口的形式），那么它是如何执行实现的呢？SqlSessionFactory是MyBatis框架中十分重要的对象，它是单个数据库映射关系经过编译后的内存镜像，其主要作用是创建SqlSession。
MyBatis核心组件之SqlSessionFactory
qq_36525300的博客
05-13 1089
MyBatis的核心组件 MyBatis的核心组件分为4个部分： SqlSessionFactoryBuilder（构造器）：它会根据配置或者代码来生成SqlSessionFactory，采用的是分布构建的Builder模式。 SqlSessionFactory（工厂接口）：依靠它来生成SqlSession，使用的是工厂模式。 SqlSession（会话）：一个既可以发送SQL执行返回结果，也可...
sqlSessionFactory
10-07
SqlSessionFactory是MyBatis框架的核心对象之一。它是一个单例的数据库映射关系经过编译后的内存镜像。通过SqlSessionFactory对象，可以创建SqlSession对象，用于执行SQL语句和操作数据库。 要创建SqlSessionFactory对象，可以通过SqlSessionFactoryBuilder对象来构建。SqlSessionFactoryBuilder可以从XML配置文件或一个预先定制的Configuration对象构建SqlSessionFactory的实例。 每个MyBatis应用程序都以一个SqlSessionFactory对象的实例为核心。SqlSessionFactory是线程安全的，一旦被创建，应该在应用程序的整个生命周期内存在。因此，在应用程序运行期间，不要重复创建多次SqlSessionFactory对象，推荐使用单例模式。 以下是SqlSessionFactory接口的一些方法： - openSession()：使用默认设置创建一个SqlSession对象。 - openSession(boolean autoCommit)：根据指定的参数创建一个SqlSession对象。 - openSession(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)：根据给定的执行器类型和数据库连接创建一个SqlSession对象。 - getConfiguration()：获取配置对象Configuration。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值