SqlSession的初始化过程

这篇具有很好参考价值的文章主要介绍了SqlSession的初始化过程。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

demo示例

public class Test {
    private SqlSessionFactory sqlSessionFactory;

    @Before
    public void init() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        inputStream.close();
    }

    @Test
    public void testSelectAll() {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper newsMapper = sqlSession.getMapper(UserMapper.class);
        List<UserInfo> newsList = newsMapper.selectAll();
        for (UserInfo news : newsList) {
            System.out.println(news.getUserName());
        }
        sqlSession.close();
    }
}

mybatis-config.xml

<?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>
    <properties resource="db.properties"/>
    <environments default="myEnv">
        <environment id="env01">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver-class-name}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

db.properties

driver-class-name=com.mysql.jdbc.Driver
username=root
password=root
url=jdbc:mysql://192.168.127.147:3306

SqlSessionFactory构建

首先来看SqlSessionFactory的构建过程,调用重载方法解析配置文件内容,将配置信息装载到Configuration对象中。

public SqlSessionFactory build(InputStream inputStream) {
    return build(inputStream, null, null);
}

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
        // 解析全局配置文件
        XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
        
        // parser.parse()得到Configuration配置对象
        return build(parser.parse());
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
        ErrorContext.instance().reset();
        try {
            inputStream.close();
        } catch (IOException e) {
            // Intentionally ignore. Prefer previous error.
        }
    }
}
// 构建SqlSessionFactory
public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
}

得到最终的SqlSessionFactory

public class DefaultSqlSessionFactory implements SqlSessionFactory {

    private final Configuration configuration;
    public DefaultSqlSessionFactory(Configuration configuration) {
        this.configuration = configuration;
    }
}

SqlSession

接下来我们继续分析通过DefaultSqlSessionFactory工厂方法获得SqlSession的逻辑

public SqlSession openSession() {
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
}

// 从数据源获取SqlSession
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
        // 通过环境变量获取数据源等
        final Environment environment = configuration.getEnvironment();
        // 1.创建事务工厂
        final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);

        // 2.创建mybatis事务对象
        tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);

        // 3.新建执行器
        final Executor executor = configuration.newExecutor(tx, execType);
        // 4.将执行器封装到SqlSession中
        return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
        closeTransaction(tx); // may have fetched a connection so lets call close()
        throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
        ErrorContext.instance().reset();
    }
}

这之中做了几件事情:

  1. 创建事务工厂
  2. 创建mybatis事务对象
  3. 新建执行器
  4. 将执行器封装到SqlSession中

对于获得事务工厂,事务工厂在解析配置文件时就已经确定,并保存在了Environment对象中

创建事务对象-Transaction

private TransactionFactory getTransactionFactoryFromEnvironment(Environment environment) {
if (environment == null || environment.getTransactionFactory() == null) {
    return new ManagedTransactionFactory();
}
return environment.getTransactionFactory();
}

// 环境变量属性
public final class Environment {
    private final String id;
    private final TransactionFactory transactionFactory;
    private final DataSource dataSource;
}

针对于JdbcTransactionFactory获取事务,就是简单的工厂模式

public class JdbcTransactionFactory implements TransactionFactory {
  @Override
  public Transaction newTransaction(Connection conn) {
    return new JdbcTransaction(conn);
  }
  @Override
  public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) {
    return new JdbcTransaction(ds, level, autoCommit);
  }
}

我们继续看看JdbcTransaction的封装信息

public class JdbcTransaction implements Transaction {

  protected Connection connection;
  protected DataSource dataSource;
  protected TransactionIsolationLevel level;
  protected boolean autoCommit;

  public JdbcTransaction(DataSource ds, TransactionIsolationLevel desiredLevel, boolean desiredAutoCommit) {
    dataSource = ds;
    level = desiredLevel;
    autoCommit = desiredAutoCommit;
  }
}

创建执行器-Executor

接下来继续看如何调用Configuration#newExecutor()方法创建的执行器Executor

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    // 默认使用SimpleExecutor
    executorType = executorType == null ? defaultExecutorType : executorType;
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor executor;
    
    if (ExecutorType.BATCH == executorType) {
        executor = new BatchExecutor(this, transaction);
    } else if (ExecutorType.REUSE == executorType) {
        executor = new ReuseExecutor(this, transaction);
    } else {
        executor = new SimpleExecutor(this, transaction);
    }
    // 开启缓存的情况下,进行装饰代理
    if (cacheEnabled) {
        executor = new CachingExecutor(executor);
    }
    
    // 织入外部插件
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
}

插件也是相对简单的实现

拦截器增强

public class InterceptorChain {
    // 所有插件
    private final List<Interceptor> interceptors = new ArrayList<>();

    public Object pluginAll(Object target) {
        for (Interceptor interceptor : interceptors) {
            target = interceptor.plugin(target);
        }
        return target;
    }
    public void addInterceptor(Interceptor interceptor) {
        interceptors.add(interceptor);
    }
    public List<Interceptor> getInterceptors() {
        return Collections.unmodifiableList(interceptors);
    }
}
// 插入
public interface Interceptor {
    Object intercept(Invocation invocation) throws Throwable;
    // 默认方法的包装增强代理
    default Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }
}

InvocationHandler实现-Plugin

而Plugin类是实现了InvocationHandler的动态代理基础类,

public class Plugin implements InvocationHandler {
    // 被代理对象
    private final Object target;
    // 增强对象
    private final Interceptor interceptor;
    // 签名方法-需要拦截的方法
    private final Map<Class<?>, Set<Method>> signatureMap;

    // 构建InvocationHandler实现类对象
    private Plugin(Object target, Interceptor interceptor, Map<Class<?>, Set<Method>> signatureMap) {
        this.target = target;
        this.interceptor = interceptor;
        this.signatureMap = signatureMap;
    }

    // 实现InvocationHandler的invoke方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
            Set<Method> methods = signatureMap.get(method.getDeclaringClass());
            if (methods != null && methods.contains(method)) {
                // 执行插件方法
                return interceptor.intercept(new Invocation(target, method, args));
            }
            return method.invoke(target, args);
        } catch (Exception e) {
            throw ExceptionUtil.unwrapThrowable(e);
        }
    }


    // 针对对每个插件Interceptor,都会进行一次代理
    public static Object wrap(Object target, Interceptor interceptor) {
        // 获取需要拦截方法的Map
        Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
        Class<?> type = target.getClass();
        Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
        if (interfaces.length > 0) {
            // Plugin实现了InvocationHandler,执行时会调用invoke方法
            return Proxy.newProxyInstance(type.getClassLoader(),  
                                          interfaces, 
                                          new Plugin(target, interceptor, signatureMap));
        }
        return target;
    }

    private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) {
        // 插件必须带有@Intercepts注解
        Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);
        // issue #251
        if (interceptsAnnotation == null) {
            throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());
        }
        Signature[] sigs = interceptsAnnotation.value();
        Map<Class<?>, Set<Method>> signatureMap = new HashMap<>();
        // 解析当前插件拦截哪些类实现的方法
        for (Signature sig : sigs) {
            Set<Method> methods = MapUtil.computeIfAbsent(signatureMap, sig.type(), k -> new HashSet<>());
            try {
                Method method = sig.type().getMethod(sig.method(), sig.args());
                methods.add(method);
            } catch (NoSuchMethodException e) {
                throw new PluginException("Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + e, e);
            }
        }
        return signatureMap;
    }

    private static Class<?>[] getAllInterfaces(Class<?> type, Map<Class<?>, Set<Method>> signatureMap) {
        Set<Class<?>> interfaces = new HashSet<>();
        while (type != null) {
            // 该类是否需要被插件运用拦截
            for (Class<?> c : type.getInterfaces()) {
                if (signatureMap.containsKey(c)) {
                    interfaces.add(c);
                }
            }
            type = type.getSuperclass();
        }
        return interfaces.toArray(new Class<?>[0]);
    }

}

@Intercepts注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Intercepts {
    Signature[] value();
}

@Retention(RetentionPolicy.RUNTIME)
@Target({})
public @interface Signature {
    // 拦截何种类型
    Class<?> type();
	// 拦截的方法名称
    String method();
	// 方法参数签名
    Class<?>[] args();
}

继续看DefaultSqlSession的创建,保存了执行器,配置信息以及事务是否自动提交。

public class DefaultSqlSession implements SqlSession {

  private final Configuration configuration;
  private final Executor executor;

  private final boolean autoCommit;
  private boolean dirty;
  private List<Cursor<?>> cursorList;

  public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
    this.configuration = configuration;
    this.executor = executor;
    this.dirty = false;
    this.autoCommit = autoCommit;
  }
}

最终得到了一个构建好的DefaultSqlSession,其拥有了执行器。文章来源地址https://www.toymoban.com/news/detail-435670.html

到了这里,关于SqlSession的初始化过程的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • K8S集群重新初始化--详细过程

    在引导k8s集群的过程时可能因为这个或那个的原因导致需要重新引导集群 。 下面整理了我在实际工作中初始化k8s集群的详细过程。 k8s环境部署总览 ip地址 类型 操作系统 服务配置 192.168.162.31 Master01 Centos7.6 2核CPU 2G内存 20G硬盘 192.168.162.41 node1 Centos7.6 2核CPU 2G内存 20G硬盘 192

    2024年02月02日
    浏览(49)
  • 第3章 创建项目并初始化业务数据(过程记录)

    公用的声明、依赖、插件 properties 声明 log4g :处理日志的框架(日志的具体实现) sel4g :简单日志门面(简单日志的接口) mongodb-spark :MongoDB和Spark的接口 casbah :MongoDB在scala上的Driver(最新的有MongoScalaDriver) redis、kafka、spark、scala jblas:java线性代数库(矩阵运算) depen

    2024年02月13日
    浏览(43)
  • bash的login shell与non-login shell,以及各自的初始化过程

    可能是以 - 开头的 或者以 --login 启动的bash 根据bash手册(man bash),不管是interactive或是non-interactive的login shell,首先读取/etc/profile文件,然后按顺序开始查找~/.bash_prifile、~/.bash_login、~/.prifile文件,仅读取第一个找到的文件。 当它退出时,会读取~/.bash_logout与/etc/bash.bash_log

    2024年04月08日
    浏览(37)
  • DevC++ easyx实现悬浮窗放入网格,与在函数分离过程中遇到的BUG下理解 函数的作用时域 以及 初始化与复位的关系。

    这次就着上上上篇的悬浮窗代码DevC++ easyx实现图片拖动,一种悬浮窗实现原理与完整代码-CSDN博客 继续实现效果。 基本背景是搓出来图片拖动了,然后想把图片暂存到另一块。再细说背景的背景就是之前提到Unity复刻瓦片地图,想着整合一个铅笔绘制功能,就是绘制瓦片和瓦

    2024年02月03日
    浏览(49)
  • Pytorch权重初始化/参数初始化

    refer: 【Pytorch】各网络层的默认初始化方法 https://blog.csdn.net/guofei_fly/article/details/105109883 其实Pytorch初始化方法就在各自的层的 def reset_parameters(self) - None: 方法中。 有人可能会问 为什么这个方法和Pytorch直接出来的权重初始值不一样 ?单步调试会发现其实这个方法运行了至少两

    2024年02月11日
    浏览(66)
  • Linux内存初始化-启动阶段的内存初始化

    本文代码基于ARM64平台, Linux kernel 5.15 在加载kernel 之前, kernel对于系统是有一定要求的,明确规定了boot阶段必须要把MMU关闭: 那么在进入kernel之后, 就必须有一个使能MMU, 建立映射的过程, 本文描述kernel启动阶段进行内存初始化相关的操作。 在初始化阶段,我们mapping二段

    2024年02月08日
    浏览(78)
  • 【温故而知新】JavaScript初始化/初始化加载

    在JavaScript中,对象、数组、函数、类等都可以通过不同的方式进行初始化。以下是几种常见的初始化方式: 对象初始化: 使用字面量方式: 使用构造函数方式: 数组初始化: 使用字面量方式: 使用构造函数方式: 函数初始化: 类初始化: 使用Array的of和from方法进行数组

    2024年01月24日
    浏览(78)
  • 深度学习参数初始化(二)Kaiming初始化 含代码

    目录 一、介绍 二、基础知识 三、Kaiming初始化的假设条件  四、Kaiming初始化的简单的公式推导 1.前向传播 2.反向传播 五、Pytorch实现 深度学习参数初始化系列: (一)Xavier初始化 含代码 (二)Kaiming初始化 含代码         Kaiming初始化论文地址:https://arxiv.org/abs/1502.01

    2024年02月04日
    浏览(78)
  • 【随机种子初始化】一个神经网络模型初始化的大坑

    半年前写了一个模型,取得了不错的效果(简称项目文件1),于是整理了一番代码,保存为了一个新的项目(简称项目文件2)。半年后的今天,我重新训练这个整理过的模型,即项目文件2,没有修改任何的超参数,并且保持完全一致的随机种子,但是始终无法完全复现出半

    2024年02月09日
    浏览(69)
  • 初始化磁盘选哪个格式 初始化磁盘分区形式选什么好

    在 初始化磁盘 之前,我们应该先明确什么时候需要初始化磁盘,通常是在电脑安装了SSD固态硬盘,计算机无法正常读取该固态硬盘时。或者需要腾空移动磁盘,以做它用时。那么初始化磁盘时,有哪些格式呢?如今主流的是NTFS格式。也有FAT 32格式,但读写性能会比较差。

    2024年02月09日
    浏览(49)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包