Mybatis数据源类型和连接池实现原理源码分析

最新推荐文章于 2024-02-18 18:30:15 发布
最新推荐文章于 2024-02-18 18:30:15 发布
阅读量616 收藏
点赞数 2
CC 4.0 BY-SA版权
分类专栏： mybatis 文章标签： Mybatis数据源 Mybatis连接池 Mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/smile_from_2015/article/details/102558721
本文深入探讨MyBatis中三种数据源类型：UNPOOLED、POOLED和JNDI的实现机制，详细分析了各自在数据库连接管理上的特点与优势。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Mybatis中的dataSource使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源，有三种内建的数据源类型：

  • UNPOOLED：这个数据源的实现只是每次被请求时打开和关闭连接。虽然有点慢，但对于在数据库连接可用性方面没有太高要求的简单应用程序来说，是一个很好的选择。 不同的数据库在性能方面的表现也是不一样的，对于某些数据库来说，使用连接池并不重要，这个配置就很适合这种情形。
  • POOLED：这个数据源的实现利用“池”的概念将 JDBC 连接对象组织起来，避免了创建新的连接实例时所必需的初始化和认证时间。 这是一种使得并发 Web 应用快速响应请求的流行处理方式。
  • JNDI：这个数据源的实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的引用。如，我们常在wildfly的standalone.xml 文件中集中配置 JNDI 数据源。

DataSourceL类图
接下来，我们分别看下三种数据源的实现方式。

UnpooledDataSource 数据源创建过程

上文提到，Mybatis 中的 dataSource 使用标准的 JDBC 数据源接口，因此 UnpooledDataSource 是实现了 DataSource 接口的，并重写了 DataSource 中的 getConnection 方法。
看下 UnpooledDataSource 中 getConnection 方法实现：

public Connection getConnection() throws SQLException {
    //调用 doGetConnection 获取连接
    return doGetConnection(username, password);
}

private Connection doGetConnection(String username, String password) throws SQLException {
    Properties props = new Properties();
    //获取数据库驱动配置
    if (driverProperties != null) {
        props.putAll(driverProperties);
    }
    if (username != null) {
        props.setProperty("user", username);
    }
    if (password != null) {
        props.setProperty("password", password);
    }
    return doGetConnection(props);
}

private Connection doGetConnection(Properties properties) throws SQLException {
    //初始化数据库驱动
    initializeDriver();
    //通过驱动代理类 DriverProxy 对象创建 connection
    Connection connection = DriverManager.getConnection(url, properties);
    //配置是否自动提交和事务隔离级别
    configureConnection(connection);
    return connection;
}

UnpooledDataSource 的创建连接过程相对还是简单的。通过以下几步：

  1. 获取数据库驱动配置。
  2. 初始化数据库驱动。
  3. 通过 DriverManager 获取连接。
  4. 配置连接是否自动提交和事务隔离级别。

PooledDataSource 数据源创建过程

从 PooledDataSource 的代码中可以看出， PooledDataSource 同样继承 DataSource 接口，同时保存了一个 UnpooledDataSource 类的引用，还有一个 PoolState 对象用于保存空闲连接和活跃连接。我们看下获取连接代码：

public Connection getConnection() throws SQLException {
    //获取真实连接的代理连接 proxyConnection
    return popConnection(dataSource.getUsername(), dataSource.getPassword()).getProxyConnection();
}

private PooledConnection popConnection(String username, String password) throws SQLException {
    boolean countedWait = false;
    //PooledConnection 是 Connection 真实连接的代理类，用于关闭时特殊处理，下面会分析如何处理关闭情形
    PooledConnection conn = null;
    long t = System.currentTimeMillis();
    int localBadConnectionCount = 0;

    while (conn == null) {
        //state 是 连接池状态，防止多线程操作，所以加锁
        synchronized (state) {
            //当空闲池中存在连接时，则从空闲池中取出连接，取列表的一个连接
            if (state.idleConnections.size() > 0) {
                // Pool has available connection
                conn = state.idleConnections.remove(0);
                if (log.isDebugEnabled()) {
                    log.debug("Checked out connection " + conn.getRealHashCode() + " from pool.");
                }
            } else {
                // 当活跃连接池数量小于最大活跃连接池数时，创建新的连接
                if (state.activeConnections.size() < poolMaximumActiveConnections) {
                    // Can create new connection
      //这里是用 UnpooledDataSource 对象来创建连接
                    conn = new PooledConnection(dataSource.getConnection(), this);
                    @SuppressWarnings("unused")
                    //used in logging, if enabled
                            Connection realConn = conn.getRealConnection();
                    if (log.isDebugEnabled()) {
                        log.debug("Created connection " + conn.getRealHashCode() + ".");
                    }
                } else {
                    // 当活跃连接池数量等于最大活跃连接池数时，从活跃连接池的列表取第一个连接
                    PooledConnection oldestActiveConnection = state.activeConnections.get(0);
                    long longestCheckoutTime = oldestActiveConnection.getCheckoutTime();
                    //当池中连接被检出时间大于配置时间（单位毫秒），则重新new一个新连接，并将原连接置为不可用
                    if (longestCheckoutTime > poolMaximumCheckoutTime) {
                        // Can claim overdue connection
                        state.claimedOverdueConnectionCount++;
                        state.accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime;
                        state.accumulatedCheckoutTime += longestCheckoutTime;
                        state.activeConnections.remove(oldestActiveConnection);
                        if (!oldestActiveConnection.getRealConnection().getAutoCommit()) {
                            oldestActiveConnection.getRealConnection().rollback();
                        }
                        conn = new PooledConnection(oldestActiveConnection.getRealConnection(), this);
                        oldestActiveConnection.invalidate();
                        if (log.isDebugEnabled()) {
                            log.debug("Claimed overdue connection " + conn.getRealHashCode() + ".");
                        }
                    } else {
                        //活跃连接池已满，线程等待
                        // Must wait
                        try {
                            if (!countedWait) {
                                state.hadToWaitCount++;
                                countedWait = true;
                            }
                            if (log.isDebugEnabled()) {
                                log.debug("Waiting as long as " + poolTimeToWait + " milliseconds for connection.");
                            }
                            long wt = System.currentTimeMillis();
                            state.wait(poolTimeToWait);
                            state.accumulatedWaitTime += System.currentTimeMillis() - wt;
                        } catch (InterruptedException e) {
                            break;
                        }
                    }
                }
            }
            if (conn != null) {
                if (conn.isValid()) {
                    if (!conn.getRealConnection().getAutoCommit()) {
                        conn.getRealConnection().rollback();
                    }
                    //设置连接类型编码，取url+username+password 三者拼接字符串的hashcode
                    conn.setConnectionTypeCode(assembleConnectionTypeCode(dataSource.getUrl(), username, password));
                    conn.setCheckoutTimestamp(System.currentTimeMillis());
                    conn.setLastUsedTimestamp(System.currentTimeMillis());
                    //将连接加入到活跃连接池列表
                    state.activeConnections.add(conn);
                    state.requestCount++;
                    state.accumulatedRequestTime += System.currentTimeMillis() - t;
                } else {
                    //无法获取有效连接
                    if (log.isDebugEnabled()) {
                        log.debug("A bad connection (" + conn.getRealHashCode() + ") was returned from the pool, getting another connection.");
                    }
                    state.badConnectionCount++;
                    localBadConnectionCount++;
                    conn = null;
                    if (localBadConnectionCount > (poolMaximumIdleConnections + 3)) {
                        if (log.isDebugEnabled()) {
                            log.debug("PooledDataSource: Could not get a good connection to the database.");
                        }
                        throw new SQLException("PooledDataSource: Could not get a good connection to the database.");
                    }
                }
            }
        }

    }

    if (conn == null) {
        if (log.isDebugEnabled()) {
            log.debug("PooledDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
        }
        throw new SQLException("PooledDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
    }

    return conn;
}

PooledDataSource 的获取连接过程相对复杂一点，可以先看下流程图，简单描述了下上述代码的逻辑过程：
popConnection方法流程图
接下来再通过文字描述下上述步骤：

  1. 首先检查 PoolState 中的空闲连接池 idleConnections 中是否有可用连接。如果有，则直接从空闲连接池中取出一个连接使用。
  2. 如果空闲连接池 idleConnections 中没有可用连接，那么继续检查 PoolState 中的活跃连接池 activeConnections 是否小于最大活跃连接池数。如果小于，则新建一个连接，新建连接是通过 dataSource.getConnection() 建立的，而 dataSource 是 UnpooledDataSource 对象，所以 PooledDataSource 中新建连接是通过 UnpooledDataSource 对象建立的，通过对象关联避免了重复代码。
  3. 如果 PoolState 中的活跃连接池 activeConnections 不小于最大活跃连接池数，则从活跃连接池 activeConnections 中取出第一个连接，并检查是否超过连接池最大检出时间 poolMaximumCheckoutTime。如果未超过，则移除第一个活跃连接（最老的活跃连接），并新建一个连接。否则，继续等待获取连接，直到超过最大检出时间 poolMaximumCheckoutTime。
  4. if (conn != null) 如果连接不为空且可获得，则将获取的连接添加到活跃连接池中。否则，当重试超过一定次数的坏连接后，抛出 SQLException 异常。

接下来，谈另一话题。正常我们执行 SQL 语句，都会在执行前打开连接，执行结束后关闭连接。在 UnpooledDataSource 中确实是关闭了真实连接，那 PooledDataSource 是如何关闭的呢？ 刚才说过，PooledDataSource 中 getConnection 返回的是代理连接 proxyConnection，重点就在这个代理类中，它通过代理真实连接对象，并对真实连接对象的调用方法进行了增强。代理类 PooledConnection 使用的是 JDK 动态代理，即实现了 InvocationHandler 接口，并重写了 invoke 方法，我们来看下代理类中是如何处理 PooledDataSource 数据源的关闭操作的。

private static final String CLOSE = "close";

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    String methodName = method.getName();
    //关键点，当真实连接调用的方法是 close 时，这里是将该连接从活跃连接池移除，并放到空闲连接池中
    if (CLOSE.hashCode() == methodName.hashCode() && CLOSE.equals(methodName)) {
        dataSource.pushConnection(this);
        return null;
    } else {
        try {
            if (!Object.class.equals(method.getDeclaringClass())) {
                // issue #579 toString() should never fail
                // throw an SQLException instead of a Runtime
                checkConnection();
            }
            return method.invoke(realConnection, args);
        } catch (Throwable t) {
            throw ExceptionUtil.unwrapThrowable(t);
        }
    }
}

protected void pushConnection(PooledConnection conn) throws SQLException {
    synchronized (state) {
        //将连接从活跃连接池移除
        state.activeConnections.remove(conn);
        if (conn.isValid()) {
            //当空闲连接池未达到最大空闲连接池数限制，则将真实连接加入空闲连接池
            if (state.idleConnections.size() < poolMaximumIdleConnections && conn.getConnectionTypeCode() == expectedConnectionTypeCode) {
                state.accumulatedCheckoutTime += conn.getCheckoutTime();
                //检查该连接是否提交，如果未提交，则执行回滚
                if (!conn.getRealConnection().getAutoCommit()) {
                    conn.getRealConnection().rollback();
                }
                //获取真实连接
                PooledConnection newConn = new PooledConnection(conn.getRealConnection(), this);
                //添加到空间连接池中
                state.idleConnections.add(newConn);
                newConn.setCreatedTimestamp(conn.getCreatedTimestamp());
                newConn.setLastUsedTimestamp(conn.getLastUsedTimestamp());
                conn.invalidate();
                if (log.isDebugEnabled()) {
                    log.debug("Returned connection " + newConn.getRealHashCode() + " to pool.");
                }
                state.notifyAll();
            } else {
                //当空闲连接池数超过最大空闲连接池数限制，则将该真实连接关闭
                state.accumulatedCheckoutTime += conn.getCheckoutTime();
                if (!conn.getRealConnection().getAutoCommit()) {
                    conn.getRealConnection().rollback();
                }
                conn.getRealConnection().close();
                if (log.isDebugEnabled()) {
                    log.debug("Closed connection " + conn.getRealHashCode() + ".");
                }
                conn.invalidate();
            }
        } else {
            if (log.isDebugEnabled()) {
                log.debug("A bad connection (" + conn.getRealHashCode() + ") attempted to return to the pool, discarding connection.");
            }
            state.badConnectionCount++;
        }
    }
}

从 PooledConnection 代理类中，我们看到了，代理类对连接的 close 方法做了特殊处理：

  1. 当空闲连接池未达到最大空闲连接池数限制，则将真实连接加入空闲连接池。
  2. 当空闲连接池数超过最大空闲连接池数限制，则将该真实连接关闭。
    这样保证了 PooledDataSource 数据源中的连接复用，也是 Mybatis 中连接池的实现机制。

JNDI 数据源创建过程

Mybatis 创建 JNDI 数据源的方式只用到了一个工厂类 JndiDataSourceFactory ，JNDI 数据源创建方式和上面 UNPOOL 和 POOL 方式不同，JNDI 主要是通过启动上下文 InitialContext 和 JNDI 配置文件来完成。InitialContext 是执行命名操作的启动上下文，可以查找到配置文件中的 JNDI 配置：

public void setProperties(Properties properties) {
    try {
        InitialContext initCtx = null;
        //获取 JNDI 配置信息
        Properties env = getEnvProperties(properties);
        //初始化启动上下文
        if (env == null) {
            initCtx = new InitialContext();
        } else {
            initCtx = new InitialContext(env);
        }
        // 从配置文件中获取 dataSource
        if (properties.containsKey(INITIAL_CONTEXT)
                && properties.containsKey(DATA_SOURCE)) {
            Context ctx = (Context) initCtx.lookup(properties.getProperty(INITIAL_CONTEXT));
            dataSource = (DataSource) ctx.lookup(properties.getProperty(DATA_SOURCE));
        } else if (properties.containsKey(DATA_SOURCE)) {
            dataSource = (DataSource) initCtx.lookup(properties.getProperty(DATA_SOURCE));
        }
    } catch (NamingException e) {
        throw new DataSourceException("There was an error configuring JndiDataSourceTransactionPool. Cause: " + e, e);
    }

JNDI 获取数据源主要分三个步骤：

  1. 首先获取 JNDI 配置信息。
  2. 初始化启动上下文 initCtx。
  3. 上下文调用 lookup 方法获取数据源 dataSource。

Mybatis 中的数据源类型和连接池实现原理就先介绍到这里，以备复习及其他小伙伴学习。

Java 领域 MyBatis 与数据库连接池的搭配使用
Java技术栈实战开发的博客
04-09 1079
本文旨在全面解析Java生态中MyBatis持久层框架与数据库连接池技术的集成原理和实践方案。MyBatis框架的核心工作机制主流数据库连接池的实现原理两者之间的协同工作模式性能优化策略和最佳实践实际项目中的应用案例本文覆盖的技术范围包括MyBatis 3.x版本与主流连接池（Druid、HikariCP等）的集成，以及在Spring/Spring Boot环境下的配置方式。首先介绍MyBatis和连接池的基础概念然后分析两者的核心原理和集成机制接着通过源码和实例展示具体实现。
Mybatis 数据源和数据库连接池源码解析（DataSource）
weixin_40226974的博客
02-01 385
欢迎关注个人公众号：Java技术大杂烩，每天10点精美文章准时奉上 本文将从以下几个方面介绍 相关文章 前言 类图 工厂类实现 数据库连接实现 连接池的实现 从连接池中获取连接(流程图) 把连接放入到连接池中(流程图) 相关文章 Mybatis 解析配置文件的源码解析 Mybatis 类型转换源码分析 前言 在使用 Mybatis 的时候，数据库的连接一般都会使用第三方的数据源组件，如 ...
mybaits源码分析（四） mybaits数据源详解
shuixiou1的博客
02-03 677
mybaits源码分析（四） 数据源 前言：对于ORM框架，数据源都是不可或少的组件，虽然mybaits框架整合spring时，可以由外部指定数据源对象，构建到SqlSessionFactoryBean中，但是对于mybaits自身对数据源的实现原理还是值得探究的，本文将通过对MyBatis框架的数据源结构进行详尽的分析，并且深入解析MyBatis的连接池。 本文内容初步分为下面几个部分 mybaits数据源的概述 mybaits数据源的构建和使用 ...
MyBaits 支持哪些数据源类型？
Leon_Jinhai_Sun的博客
12-16 692
UNPOOLED：不带连接池的数据源。 POOLED ： 带连接池的数据源， 在PooledDataSource 中维护PooledConnection。 PooledDataSource 的getConnection()方法流程图： JNDI：使用容器的数据源，比如Tomcat 配置了C3P0。 自定义数据源：实现DataSourceFactory 接口，返回一个DataSource。 当MyBatis 集成到Spring 中的时候，使用Spring 的数据源。 ...
MyBatis数据源
web开发
07-18 285
dataSource 元素使用基本的 JDBC 数据源接口来配置 JDBC 连接对象的资源。 有三种内建的数据源类型（type）： 1、UNPOOLED – 这个数据源的实现是每次被请求时简单打开和关闭连接。它有一点慢,这是对简单应用程序的一个很好的选择,因为它不需要及时的可用连接。不同的数据库对这个的表现也是不一样的,所以对某些数据库来说配置数据源并不重要,这个配置也是闲置的。UNPOOLE...
MyBatis——MyBatis数据源与连接池
庄小焱
08-30 1532
博文主要介绍MyBatis数据源与连接池，更好的理解MyBatis数据源与连接池。
MyBatis数据源DataSource分类
qq_36074180的博客
06-30 3856
MyBatis内部分别定义了实现了java.sql.DataSource接口的UnpooledDataSource，PooledDataSource类来表示UNPOOLED、POOLED类型的数据源。 JNDI类型的数据源DataSource，则是通过JNDI上下文中取值。 数据源DataSource的创建过程 2  MyBatis是通过工厂模式来
MyBatis内置DataSource的连接池实现原理
Night Field' Blog
12-12 1080
前言 MyBatis是一个流行的ORM框架，它简单易用，支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。 作为一款优秀的持久层框架，连接池是必不可少的。本文将分析MyBatis内置的数据源是如何实现连接池功能的(源码基于MyBatis3.4.5)。 JDBC对数据库的操作 回忆一下，我们用原生的JDBC来操作数据库的一般流程： public class JDBCExample { // JDBC driver name and dat
Mybatis源码解析之数据库连接和连接池
翻身已碰头的博客
03-13 1319
Mybatis源码解析之核心类分析 Mybatis源码解析之初始化分析 Mybatis源码解析之执行流程解析 一、数据库连接的获取 Mybatis作为ORM框架，在上一篇博客中可以了解到在sql执行流程中会在BaseExecutor#getConnection(Log)中去获取数据库连接。 1. BaseExecutor#getConnection(Log) protected Connectio...
mybatis datasource种类
最新发布
农夫三拳
02-18 218
mybatis 内置了三种数据源，分别是Pooled，Unpooled和JNDI，其中Pooled数据源是具有连接池的。开发场景下，通常使用以下几种数据源。Druid：兼顾了性能和监控，综合。C3P0：性能稍好，常用。Hikari：性能快。
mybatis内置数据源
11-15 466
在jdbc中，我们可以通过DriverManager的getConnection方法来获取数据库连接，但是这种方式会去查找相应的驱动，然后与数据库地址建立真实的连接，因此比较耗时。如果在应用中存在大量的连接数据库操作，那么这种方式的效率将会非常低下。为了解决这个问题，数据源的技术应运而生，所谓...
【mybatis】mybatis数据源源码剖析（JNDI、POOLED、UNPOOLED）
经常犯错的Zack
06-07 404
http://blog.youkuaiyun.com/reliveit/article/details/47325189
深入Mybatis数据源
善守者
12-29 984
其中封装了真正的 java.sql.Connection 对象以及相关的代理对象，这里的代理对象就是通过JDK 动态代理产生的。下面来看 PooledConnection 中的核心字段。
MyBatis之数据源
m0_37039331的博客
06-18 2368
DataSourceFactory是数据源工厂，两个子类是PooledDataSourceFactory和UnpooledDataSourceFactory，唯一的区别是，PooledDataSourceFactory的构造函数初始化的是PooledDataSource。 PooledDataSource和UnpooledDataSource都是DataSource的实现类。 PooledData...
mybatis获取mysql源数据类型_mybatis源码解读(三)——数据源的配置
weixin_33685133的博客
01-26 610
在mybatis-configuration.xml 文件中，我们进行了如下的配置：其中 是对事务的配置，下篇博客我们会详细介绍。本篇博客我们介绍 对于数据源的配置。1、解析environments 标签在 XMLConfigBuilder.java 的parseConfiguration(XNode root) 中：进入environmentsElement(root.evalNo...
Mybatis数据源
weixin_51992178的博客
09-18 1628
因此，JDBC为我们定义了一个数据源的标准，也就是`DataSource`接口，告诉数据源数据库的连接信息，并将所有的连接全部交给数据源进行集中管理，当需要一个`Connection`对象时，可以向数据源申请，数据源会根据内部机制，合理地分配连接对象给我们。我们的数据源配置信息，存放在了`Transaction`对象中，那么现在我们只需要知道执行器到底是如何执行SQL语句的，我们就知道到底如何创建`Connection`对象了，就需要获取数据库的链接信息了，打开datasource。
MyBatis探究-----配置数据源的几种方式
anqi771129的博客
03-24 880
1.在核心配置文件mybatis-config.xml中配置数据库连接信息 mysql的j驱动jar包是mysql-connector-java-6.0.6.jar mysql版本5.7 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC...
一起认识Mybatis-数据源
qq_38677263的博客
08-13 940
Mybatis(二) —数据源DataSource 使用过数据库连接的读者对数据源都不会陌生，我们是通过数据源去拿到数据库连接的，本文主要从两个方面去介绍Mybatis中数据源这个模块： 1.数据源的创建。 2.数据库连接池技术。 数据源的创建 数据源对象是比较复杂的对象，其创建过程相对比较复杂，对于 MyBatis 创建一个数据源，主要有一下三个难点： 1.我们常见的数据源组件（C3P0,druid,DBCP等）都实现了javax.sql.DataSource 接口。 2.Mybatis要能集成第三方的数
MyBatis
qq_37020594的博客
11-04 1863
MyBatis 1.Mybatis框架基础 1.1.Mybatis框架技术   Mybatis是一个数据持久层（ORM）框架。在实体类和SQL语句之间建立映射关系，是一种半自动化的ORM实现。   Mybatis支持定制化SQL、存储过程以及高级映射，避免了几乎所有的JDBC和手动设置参数以及获取结果集。   ORM（Object Relational Mapping）对象关系映射，就是通过使用描...
Spring Boot + Mybatis: 整合Druid实现多数据源配置实例
本文将详细介绍如何在Spring Boot项目中整合Mybatis框架并利用Druid实现多数据源的配置。首先，我们先了解多数据源应用场景，尤其是在处理大规模数据时，为了优化性能和负载均衡，通常会配置主从库，例如将频繁访问...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值