Mybatis_数据源与连接池详解

小灰灰 2024-04-01 13:03 96阅读 0赞

## 1、前言 ##

> 对于ORM框架而言，数据源的组织是一个非常重要的一部分，这直接影响到框架的性能问题。本文将通过对MyBatis框架的数据源结构进行详尽的分析，并且深入解析MyBatis的连接池。  
> 本文首先会讲述MyBatis的数据源的分类，然后会介绍数据源是如何加载和使用的。紧接着将分类介绍UNPOOLED、POOLED和JNDI类型的数据源组织；期间我们会重点讲解POOLED类型的数据源和其实现的连接池原理。

> 以下是本章的组织结构：  
> 1）MyBatis数据源DataSource分类  
> 2）数据源DataSource的创建过程  
> 3）DataSource什么时候创建Connection对象  
> 4）不使用连接池的UnpooledDataSource  
> 5）为什么要使用连接池？  
> 6） 使用了连接池的PooledDataSource

## 2、MyBatis数据源DataSource分类 ##

> 1）、数据源DataSource的创建过程  
> 2）、 DataSource什么时候创建Connection对象  
> 3）、不使用连接池的UnpooledDataSource  
> 4）、为什么要使用连接池？  
> 5）、使用了连接池的PooledDataSource

![在这里插入图片描述][a11ab1cac8fe48a68c277be69e019405.gif]

> 相应地，MyBatis内部分别定义了实现了java.sql.DataSource接口的UnpooledDataSource，PooledDataSource类来表示UNPOOLED、POOLED类型的数据源。 如下图所示：

![在这里插入图片描述][894bd3bb7e804e8d8de917b2f7d1ab13.png]

> 对于JNDI类型的数据源DataSource，则是通过JNDI上下文中取值

## 3、数据源DataSource的创建过程 ##

> MyBatis数据源DataSource对象的创建发生在MyBatis初始化的过程中。下面让我们一步步地了解MyBatis是如何创建数据源DataSource的。  
> 在mybatis的XML配置文件中，使用元素来配置数据源：

> 1） MyBatis在初始化时，解析此文件，根据的type属性来创建相应类型的的数据源DataSource，即：  
> type=”POOLED” ：MyBatis会创建PooledDataSource实例  
> type=”UNPOOLED” ：MyBatis会创建UnpooledDataSource实例  
> type=”JNDI” ：MyBatis会从JNDI服务上查找DataSource实例，然后返回使用

> 2） 顺便说一下，MyBatis是通过工厂模式来创建数据源DataSource对象的，MyBatis定义了抽象的工厂接口:org.apache.ibatis.datasource.DataSourceFactory,通过其getDataSource()方法返回数据源DataSource：  
> 定义如下：

public interface DataSourceFactory {
        
        void setProperties(Properties props);
        //生产DataSource
        DataSource getDataSource();
    }

> 上述三种不同类型的type，则有对应的以下dataSource工厂：  
> POOLED PooledDataSourceFactory  
> UNPOOLED UnpooledDataSourceFactory  
> JNDI JndiDataSourceFactory  
> 其类图如下所示：

![请添加图片描述][6194ae6913ad487ead6265ba2ffcd83a.png]

> 3） MyBatis创建了DataSource实例后，会将其放到Configuration对象内的Environment对象中， 供以后使用。

## 3、DataSource什么时候创建Connection对象 ##

> 当我们需要创建SqlSession对象并需要执行SQL语句时，这时候MyBatis才会去调用dataSource对象来创建java.sql.Connection对象。也就是说，java.sql.Connection对象的创建一直延迟到执行SQL语句的时候。  
> 比如，我们有如下方法执行一个简单的SQL语句：

String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession sqlSession = sqlSessionFactory.openSession();
    sqlSession.selectList("SELECT * FROM STUDENTS");

> 前4句都不会导致java.sql.Connection对象的创建，只有当第5句sqlSession.selectList(“SELECT \* FROM STUDENTS”)，才会触发MyBatis在底层执行下面这个方法来创建java.sql.Connection对象：

protected void openConnection() throws SQLException {
        
        if (log.isDebugEnabled()) {
        
          log.debug("Opening JDBC Connection");
        }
        connection = dataSource.getConnection();
        if (level != null) {
        
          connection.setTransactionIsolation(level.getLevel());
        }
        setDesiredAutoCommit(autoCommmit);
      }

> 而对于DataSource的UNPOOLED的类型的实现-UnpooledDataSource是怎样实现getConnection()方法的呢？请看下一节

## 4、不使用连接池的UnpooledDataSource ##

> 当 的type属性被配置成了”UNPOOLED”，MyBatis首先会实例化一个UnpooledDataSourceFactory工厂实例，然后通过.getDataSource()方法返回一个UnpooledDataSource实例对象引用，我们假定为dataSource。  
> 使用UnpooledDataSource的getConnection(),每调用一次就会产生一个新的Connection实例对象。  
> UnPooledDataSource的getConnection()方法实现如下：

/*
    UnpooledDataSource的getConnection()实现
    */
    public Connection getConnection() throws SQLException
    {
        
        return doGetConnection(username, password);
    }
     
    private Connection doGetConnection(String username, String password) throws SQLException
    {
        
        //封装username和password成properties
        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
    {
        
        //1.初始化驱动
        initializeDriver();
        //2.从DriverManager中获取连接，获取新的Connection对象
        Connection connection = DriverManager.getConnection(url, properties);
        //3.配置connection属性
        configureConnection(connection);
        return connection;
    }

> 如上代码所示，UnpooledDataSource会做以下事情：  
> 初始化驱动： 判断driver驱动是否已经加载到内存中，如果还没有加载，则会动态地加载driver类，并实例化一个Driver对象，使用DriverManager.registerDriver()方法将其注册到内存中，以供后续使用。  
> 创建Connection对象： 使用DriverManager.getConnection()方法创建连接。  
> 配置Connection对象： 设置是否自动提交autoCommit和隔离级别isolationLevel。  
> 返回Connection对象。

> 上述的序列图如下所示：

![在这里插入图片描述][da21eb24fe9d477fb506a3ae68d180ea.png]

> 总结：从上述的代码中可以看到，我们每调用一次getConnection()方法，都会通过DriverManager.getConnection()返回新的java.sql.Connection实例。

## 5、为什么要使用连接池？ ##

> 1） 创建一个java.sql.Connection实例对象的代价  
> 首先让我们来看一下创建一个java.sql.Connection对象的资源消耗。我们通过连接Oracle数据库，创建Connection对象，来看创建一个Connection对象、执行SQL语句各消耗多长时间。代码如下：

public static void main(String[] args) throws Exception
    {
        
     
        String sql = "select * from hr.employees where employee_id < ? and employee_id >= ?";
        PreparedStatement st = null;
        ResultSet rs = null;
     
        long beforeTimeOffset = -1L; //创建Connection对象前时间
        long afterTimeOffset = -1L; //创建Connection对象后时间
        long executeTimeOffset = -1L; //创建Connection对象后时间
     
        Connection con = null;
        Class.forName("oracle.jdbc.driver.OracleDriver");
     
        beforeTimeOffset = new Date().getTime();
        System.out.println("before:\t" + beforeTimeOffset);
     
        con = DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:xe", "louluan", "123456");
     
        afterTimeOffset = new Date().getTime();
        System.out.println("after:\t\t" + afterTimeOffset);
        System.out.println("Create Costs:\t\t" + (afterTimeOffset - beforeTimeOffset) + " ms");
     
        st = con.prepareStatement(sql);
        //设置参数
        st.setInt(1, 101);
        st.setInt(2, 0);
        //查询，得出结果集
        rs = st.executeQuery();
        executeTimeOffset = new Date().getTime();
        System.out.println("Exec Costs:\t\t" + (executeTimeOffset - afterTimeOffset) + " ms");
     
    }

> 上述程序在我笔记本上的执行结果为：  
> 从此结果可以清楚地看出，创建一个Connection对象，用了250 毫秒；而执行SQL的时间用了170毫秒。  
> 创建一个Connection对象用了250毫秒！这个时间对计算机来说可以说是一个非常奢侈的！  
> 这仅仅是一个Connection对象就有这么大的代价，设想一下另外一种情况：如果我们在Web应用程序中，为用户的每一个请求就操作一次数据库，当有10000个在线用户并发操作的话，对计算机而言，仅仅创建Connection对象不包括做业务的时间就要损耗10000×250ms= 250 0000 ms = 2500 s = 41.6667 min,竟然要41分钟！！！如果对高用户群体使用这样的系统，简直就是开玩笑！

> 问题分析：  
> 创建一个java.sql.Connection对象的代价是如此巨大，是因为创建一个Connection对象的过程，在底层就相当于和数据库建立的通信连接，在建立通信连接的过程，消耗了这么多的时间，而往往我们建立连接后（即创建Connection对象后），就执行一个简单的SQL语句，然后就要抛弃掉，这是一个非常大的资源浪费！

> 解决方案:  
> 对于需要频繁地跟数据库交互的应用程序，可以在创建了Connection对象，并操作完数据库后，可以不释放掉资源，而是将它放到内存中，当下次需要操作数据库时，可以直接从内存中取出Connection对象，不需要再创建了，这样就极大地节省了创建Connection对象的资源消耗。由于内存也是有限和宝贵的，这又对我们对内存中的Connection对象怎么有效地维护提出了很高的要求。我们将在内存中存放Connection对象的容器称之为 连接池（Connection Pool）。下面让我们来看一下MyBatis的线程池是怎样实现的。

## 6、使用了连接池的PooledDataSource ##

> 同样地，我们也是使用PooledDataSource的getConnection()方法来返回Connection对象。现在让我们看一下它的基本原理：  
> PooledDataSource将java.sql.Connection对象包裹成PooledConnection对象放到了PoolState类型的容器中维护。 MyBatis将连接池中的PooledConnection分为两种状态： 空闲状态（idle）和活动状态(active)，这两种状态的PooledConnection对象分别被存储到PoolState容器内的idleConnections和activeConnections两个List集合中：

> idleConnections:空闲(idle)状态PooledConnection对象被放置到此集合中，表示当前闲置的没有被使用的PooledConnection集合，调用PooledDataSource的getConnection()方法时，会优先从此集合中取PooledConnection对象。当用完一个java.sql.Connection对象时，MyBatis会将其包裹成PooledConnection对象放到此集合中。

> activeConnections:活动(active)状态的PooledConnection对象被放置到名为activeConnections的ArrayList中，表示当前正在被使用的PooledConnection集合，调用PooledDataSource的getConnection()方法时，会优先从idleConnections集合中取PooledConnection对象,如果没有，则看此集合是否已满，如果未满，PooledDataSource会创建出一个PooledConnection，添加到此集合中，并返回。

> PoolState连接池的大致结构如下所示：

![在这里插入图片描述][c0c859ccc6b940f1b8d1c511ae1e6673.png]

### 6.1获取java.sql.Connection对象的过程 ###

> 下面让我们看一下PooledDataSource 的getConnection()方法获取Connection对象的实现：

public Connection getConnection() throws SQLException {
        
        return popConnection(dataSource.getUsername(), dataSource.getPassword()).getProxyConnection();
      }
     
    public Connection getConnection(String username, String password) throws SQLException {
        
        return popConnection(username, password).getProxyConnection();
      }

> 上述的popConnection()方法，会从连接池中返回一个可用的PooledConnection对象，然后再调用getProxyConnection()方法最终返回Conection对象。（至于为什么会有getProxyConnection(),请关注下一节）  
> 现在让我们看一下popConnection()方法到底做了什么：  
> 1）先看是否有空闲(idle)状态下的PooledConnection对象，如果有，就直接返回一个可用的PooledConnection对象；否则进行第2步。  
> 2）查看活动状态的PooledConnection池activeConnections是否已满；如果没有满，则创建一个新的PooledConnection对象，然后放到activeConnections池中，然后返回此PooledConnection对象；否则进行第三步；  
> 3）看最先进入activeConnections池中的PooledConnection对象是否已经过期：如果已经过期，从activeConnections池中移除此对象，然后创建一个新的PooledConnection对象，添加到activeConnections中，然后将此对象返回；否则进行第4步。  
> 4）线程等待，循环2步

对应的处理流程图如下所示：  
![请添加图片描述][5ad999ddb24e4c96a80a6138cfc2e6d3.png]  
如上所示,对于PooledDataSource的getConnection()方法内，先是调用类PooledDataSource的popConnection()方法返回了一个PooledConnection对象，然后调用了PooledConnection的getProxyConnection()来返回Connection对象。

### 6.2、java.sql.Connection对象的回收 ###

> 当我们的程序中使用完Connection对象时，如果不使用数据库连接池，我们一般会调用 connection.close()方法，关闭connection连接，释放资源。如下所示：  
> 调用过close()方法的Connection对象所持有的资源会被全部释放掉，Connection对象也就不能再使用。  
> 那么，如果我们使用了连接池，我们在用完了Connection对象时，需要将它放在连接池中，该怎样做呢？  
> 可能大家第一个在脑海里闪现出来的想法就是：我在应该调用con.close()方法的时候，不调用close()方法，将其换成将Connection对象放到连接池容器中的代码！  
> 好，我们将上述的想法实现，首先定义一个简易连接池Pool，然后将上面的代码改写：  
> 上述的代码就是将我们使用过的Connection对象放到Pool连接池中，我们需要Connection对象的话，只需要使用Pool.getConnection()方法从里面取即可。  
> 是的,上述的代码完全可以实现此能力，不过有一个很不优雅的实现：就是我们需要手动地将Connection对象放到Pool连接池中，这是一个很傻的实现方式。这也和一般使用Connection对象的方式不一样：一般使用Connection的方式是使用完后，然后调用.close()方法释放资源。  
> 为了和一般的使用Conneciton对象的方式保持一致，我们希望当Connection使用完后，调用.close()方法，而实际上Connection资源并没有被释放，而实际上被添加到了连接池中。这样可以做到吗？答案是可以。上述的要求从另外一个角度来描述就是：能否提供一种机制，让我们知道Connection对象调用了什么方法，从而根据不同的方法自定义相应的处理机制。恰好代理机制就可以完成上述要求.  
> 怎样实现Connection对象调用了close()方法，而实际是将其添加到连接池中  
> 这是要使用代理模式，为真正的Connection对象创建一个代理对象，代理对象所有的方法都是调用相应的真正Connection对象的方法实现。当代理对象执行close()方法时，要特殊处理，不调用真正Connection对象的close()方法，而是将Connection对象添加到连接池中。  
> MyBatis的PooledDataSource的PoolState内部维护的对象是PooledConnection类型的对象，而PooledConnection则是对真正的数据库连接java.sql.Connection实例对象的包裹器。  
> PooledConnection对象内持有一个真正的数据库连接java.sql.Connection实例对象和一个java.sql.Connection的代理：

[a11ab1cac8fe48a68c277be69e019405.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/b34fb3d532804087bb23628b5679d9fd.gif
[894bd3bb7e804e8d8de917b2f7d1ab13.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/819a61444f15415daba316e358ce0ac7.png
[6194ae6913ad487ead6265ba2ffcd83a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/45bdc91048b840c790b1a855b1e7a782.png
[da21eb24fe9d477fb506a3ae68d180ea.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/3a5c4f052cce4a7b9ec145c7ca6e615f.png
[c0c859ccc6b940f1b8d1c511ae1e6673.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/e811771b7ee7400b98bdd8b59c231185.png
[5ad999ddb24e4c96a80a6138cfc2e6d3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/f2041c6b8d4a4e03adc2a434637f24ac.png