从源码理解 Spring 如何管理数据库连接

向右看齐 2022-02-09 08:07 448阅读 0赞

# 1 - 引言 #

在了解 Spring 中数据库连接池的实现机制时，看到一些新知识，但是单纯的文字或实验描述并不能让我深入了解这些知识。

> Spring DAO 对所有支持的数据访问技术框架都使用模板化技术进行了薄层的封装。只要您的程序都使用 Spring DAO 模板（如 JdbcTemplate、HibernateTemplate 等）进行数据访问，一定不会存在数据连接泄漏的问题 ―― 这是 Spring 给予我们郑重的承诺！因此，我们无需关注数据连接（Connection）及其衍生品（Hibernate 的 Session 等）的获取和释放的操作，模板类已经通过其内部流程替我们完成了，且对开发者是透明的。  
> 当 Spring 事务方法运行时，就产生一个事务上下文，该上下文在本事务执行线程中针对同一个数据源绑定了一个唯一的数据连接（或其衍生品），所有被该事务上下文传播的方法都共享这个数据连接。这个数据连接从数据源获取及返回给数据源都在 Spring 掌控之中，不会发生问题。如果在需要数据连接时，能够获取这个被 Spring 管控的数据连接，则使用者可以放心使用，无需关注连接释放的问题。1

偶然看到上面关于Spring中数据库连接的一段描述，字面上挺好理解的。但背下来只能拿来撑场面，没什么意思，还是需要自己亲自查看一番，知其然还要知其所以然。

这次我们不考虑 MyBatis 或者 Hibernate 之类的持久层框架怎么使用数据库连接池，研究下 Spring 自己是怎么管理数据库连接的。

--------------------

# 2 - Spring 的 DAO 工具类 #

#### 2.1 JdbcTemplate ####

在 Spring 下做持久层操作，不使用持久层框架的情况下一般会选择使用 JdbcTemplate 这种模版类，它底层封装了 JDBC，避免了直接书写 JDBC 的麻烦，也一定程度上帮助管理数据库连接，使程序员更加专注于业务查询。使用方法是将其配置为 bean 之后进行注入，比如下面这样：

那么我们首先考察一下 JdbcTemplate 的核心方法 `execute()`，它是执行查询的关键，这个方法有众多的重载形式，这里截取其中一个。留意到在 `execute()` 内部获取和释放连接的关键代码如下：

public <T> T execute(ConnectionCallback<T> action){ 
    		...
            Connection con = DataSourceUtils.getConnection(this.getDataSource());
    		...
            try { 
                ...
            } catch (SQLException var8) { 
                DataSourceUtils.releaseConnection(con, this.getDataSource());
                ...
            } finally { 
                DataSourceUtils.releaseConnection(con, this.getDataSource());
            }
            return var4;
        }

#### 2.2 DataSourceUtils 获取 Connection ####

在上一节代码可以看到 DataSourceUtils 的身影，它负责管理连接的获取和释放，看来这就是我们应该研究的对象了。关于 DataSourceUtils 这个类，查询 Spring 4.3 的文档获得这样的解释：

> Helper class that provides static methods for obtaining JDBC Connections from a DataSource. Includes special support for Spring-managed transactional Connections, e.g. managed by DataSourceTransactionManager or JtaTransactionManager. 2

翻译过来就是提供一些静态方法从数据源获取 JDBC 连接，同时提供对 Spring 管理的（加入了）事务的（数据库）连接的一些支持。这里我们看到了事务与连接这两个概念发生了关联，正和我们前面提到的事务上下文会绑定一条数据库连接。

我们需要研究怎么获取数据库连接就绕不开 `DataSourceUtils.getConnection()` 这个方法，官方文档解释：

> Obtain a Connection from the given DataSource. Translates SQLExceptions into the Spring hierarchy of unchecked generic data access exceptions, simplifying calling code and making any exception that is thrown more meaningful.  
> Is aware of a corresponding Connection bound to the current thread, for example when using DataSourceTransactionManager. Will bind a Connection to the thread if transaction synchronization is active, e.g. when running within a JTA transaction). 2

大意是从给定的数据源获取连接，做一些异常处理，如果当前事务是活跃的，会将一条连接绑定到当前的线程。那么线程和连接的绑定是怎么做的呢？我们还是看一下源代码吧。

public static Connection getConnection(DataSource dataSource) throws CannotGetJdbcConnectionException { 
            try { 
                return doGetConnection(dataSource); // 实际调用方法 doGetConnection
            } catch (SQLException var2) { 
                ...
            }
        }
    
        public static Connection doGetConnection(DataSource dataSource) throws SQLException { 
            Assert.notNull(dataSource, "No DataSource specified");
            // 从线程获取连接的缓存holder
            ConnectionHolder conHolder = (ConnectionHolder)TransactionSynchronizationManager.getResource(dataSource);
            if (conHolder == null ||  // 该线程第一次从数据源拿连接，缓存holder为null
            	!conHolder.hasConnection() && 
            	!conHolder.isSynchronizedWithTransaction()) {  
            	        	
                logger.debug("Fetching JDBC Connection from DataSource");
                Connection con = dataSource.getConnection();
                if (TransactionSynchronizationManager.isSynchronizationActive()) { 
                	// 如果事务管理器处于活跃状态，可以通过事务管理器绑定连接和当前线程
                    logger.debug("Registering transaction synchronization for JDBC Connection");
                    
                    // 将数据连接绑定holder
                    ConnectionHolder holderToUse = conHolder;
                    if (conHolder == null) { 
                        holderToUse = new ConnectionHolder(con);
                    } else { 
                        conHolder.setConnection(con);  
                    }
    
                    holderToUse.requested();
                    TransactionSynchronizationManager.registerSynchronization(new DataSourceUtils.ConnectionSynchronization(holderToUse, dataSource)); 
                    holderToUse.setSynchronizedWithTransaction(true);
                    if (holderToUse != conHolder) {  // 将holder绑定当前线程，重要！！！
                        TransactionSynchronizationManager.bindResource(dataSource, holderToUse);
                    }
                }
                // 注意到如果事务管理器不支持事务或当前没有事务，
                // con不会保存在缓存中，直接返回
                return con;
                
            } else {  // 缓存不为null的情况
                conHolder.requested();
                if (!conHolder.hasConnection()) {  //连接失效，重新获取新的连接并放入缓存 
                    logger.debug("Fetching resumed JDBC Connection from DataSource");
                    conHolder.setConnection(dataSource.getConnection());
                }
    
                return conHolder.getConnection();
            }
        }

我已经在上面的关键逻辑部分做了注释，下面简单总结几个关键的步骤：

1.  从线程拥有的资源中查找 ConnectionHolder 缓存。
2.  假如缓存 ConnectionHolder 存在，直接跳到步骤 6，反之，继续下面的步骤。
3.  从数据源中拿出一条数据库连接 Connection 。
4.  当前事务管理器是否可用，不可用就直接返回 Connection ，否则继续下面步骤。
5.  将 Connection 保存到 ConnectionHolder 中，再通过 TransactionSynchronizationManager 将 ConnectionHolder 保存到线程本地资源中，最后返回 Connection。退出方法。
6.  ConnectionHolder 存在并且Connection 还没失效，直接返回 Connection。若 Connection 已经失效，新建并保存。退出方法。

注意到步骤 4，如果当前事务管理器不活跃，比如当前没有事务，那么 Connection 不会保存到 ConnectionHolder 中，也没有绑定到线程。这代表着我们每一次返回的都是不同的连接。

#### 2.3 TransactionSynchronizationManager 与 ThreadLocal ####

有些同学可能对 TransactionSynchronizationManager 怎么把资源绑定线程/从线程获取资源不是很了解，这里简单介绍一下这个类。官方文档解释：

> Central delegate that manages resources and transaction synchronizations per thread. To be used by resource management code but not by typical application code.  
> Supports one resource per key without overwriting, that is, a resource needs to be removed before a new one can be set for the same key. Supports a list of transaction synchronizations if synchronization is active. 2

这个类的说明比较长，这里只截取了部分，感兴趣的同学可以直接查看文档。大意是帮助线程管理资源和事务。具体是怎么管理的呢？还是看一下源代码吧。

public abstract class TransactionSynchronizationManager { 
        // 主要成员变量，注意第一个 resources 变量，其他的先不看
        ...
        private static final ThreadLocal<Map<Object, Object>> resources = ...;
        private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations = ...;
        private static final ThreadLocal<String> currentTransactionName = ...;
        private static final ThreadLocal<Boolean> currentTransactionReadOnly = ...;
        private static final ThreadLocal<Integer> currentTransactionIsolationLevel = ...;
        private static final ThreadLocal<Boolean> actualTransactionActive = ...;
    	...
    }

如果熟悉多线程的同学应该早猜出来线程私有资源使用的是 ThreadLocal 变量。 ThreadLocal 本身有很多东西讲，但本文侧重点不是这个，这里简单介绍一下它的机制。

我们知道 Java 中的线程是 Thread 类，查看它的源代码，我们会发现下面这个成员变量：

/* ThreadLocal values pertaining to this thread. This map is maintained * by the ThreadLocal class. */
        ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocal.ThreadLocalMap 从名字上就知道是 ThreadLocal 的内部类，它的实现和 HashMap 很相似，但要注意这个 ThreadLocalMap 的 Key 恒为 ThreadLocal 类型。

每个线程都保存有这么一个哈希表，ThreadLocal 提供了`set()`、`get()`两个方法对当前线程的 ThreadLocalMap 进行键值对的插入和获取。

// ThreadLocal.set(T value)
    	public void set(T value) { 
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);  // getMap()其实就是返回传入线程参数的ThreadLocalMap
            if (map != null)
                map.set(this, value); // ThreadLocalMap插入键值对，注意将ThreadLocal自身作为key
            else
                createMap(t, value);
        }
        
    	// ThreadLocal.get()
    	public T get() { 
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);
            if (map != null) { 
                ThreadLocalMap.Entry e = map.getEntry(this); 
                if (e != null)
                    return (T)e.value;
            }
            return setInitialValue();
        }
    
    	// ThreadLocal.getMap(Thread t)
    	ThreadLocalMap getMap(Thread t) { 
            return t.threadLocals;
        }

再回来说一下 TransactionSynchronizationManager，它通过调用 resources 变量的 `set()` 方法，将 resources 自身作为 Key，Map<Object, Object> 作为 Value 放入线程的 ThreadLocalMap 中。之后就可以通过 `Map.put()` 方法将资源放入 resources，就间接把资源保存在线程中。源代码如下：

/* TransactionSynchronizationManager.bindResource() */
    	public static void bindResource(Object key, Object value) throws IllegalStateException { 
    		... 
            Map<Object, Object> map = (Map)resources.get(); // ThreadLocal.get()
            if (map == null) { 
                map = new HashMap();
                resources.set(map);
            }
    		
            Object oldValue = ((Map)map).put(actualKey, value); // 往resources插入键值对
            ...
        }

至于 TransactionSynchronizationManager 怎么获取资源相信大家也能猜到了，本质上就是 ThreadLocal 的 `get()` 方法，这里粘一点代码，大家自己体会一下。

private static Object doGetResource(Object actualKey) { 
            Map<Object, Object> map = (Map)resources.get();
            if (map == null) { 
                return null;
            } else { 
                Object value = map.get(actualKey); // 查找资源
                ...
                return value;
            }
        }

resources本身是个 HashMap，ThreadLocalMap 又是一个 HashMap，导致这一段看起来比较绕， 大家需要细细阅读和思考。总结起来，**resources 将自身作为 Key 保存在线程本地，它的 Value 是一个 HashMap，我们的资源（在本文是ConnectionHolder）实际保存在 resources 指向的 HashMap 里，key 是 DataSource 类型的**，相当于间接保存在线程。发张图帮助理解前面。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1h1X0pMMTk5Nw_size_16_color_FFFFFF_t_70]

#### 2.4 DataSourceUtils 释放 Connection ####

有了上面的基础，看这个就 so easy 了，直接上代码：

public static void doReleaseConnection(Connection con, DataSource dataSource) throws SQLException { 
            if (con != null) { 
                if (dataSource != null) { 
                    ConnectionHolder conHolder = (ConnectionHolder)TransactionSynchronizationManager.getResource(dataSource);
                    if (conHolder != null && connectionEquals(conHolder, con)) { 
                        conHolder.released();  // 释放，但是没有 conHolder = null
                        return;
                    }
                }
    			// 将连接放回数据源
                logger.debug("Returning JDBC Connection to DataSource");
                doCloseConnection(con, dataSource); 
            }
        }
    
        public static void doCloseConnection(Connection con, DataSource dataSource) throws SQLException { 
            if (!(dataSource instanceof SmartDataSource) || ((SmartDataSource)dataSource).shouldClose(con)) { 
                con.close();  // 直接关闭连接
            }
        }

注意到释放连接的时候，ConnectionHolder 没有手动指向 null，意味着什么？表示这个变量指向的实例不为 null，仍保存在内存中，只是它的一些状态发生改变，连接也不能用了。回到 2.2 的 `getConnection()`，你会发现我刻意跳过了一些内容：

if (conHolder == null ||
    	!conHolder.hasConnection() && !conHolder.isSynchronizedWithTransaction())

这句判断的后半部分就是连接释放后再次申请的情况（因为线程可能执行多个事务，每个事务都可能重新申请连接），conHolder 不为 null，但是它的连接已经释放并且上一次事务已经结束，我们可以重新使用这个对象，为它设置新的连接。具体可以看 ConnectionHolder 是释放连接是怎么处理的，这里就不多说了。

--------------------

# 3 - 补充 #

本文着重通过 DataSourceUtils 这个类来分析 Spring 如何使用数据源里的连接。就数据库连接池的使用而言，如果我们不使用持久层框架或者一些模版类，我们需要关注它们的连接泄漏问题，DataSourceUtils 就存在连接泄漏的风险，需要我们手动管理。

关于 Hibernate 的一些数据库连接池的理解可以参考： [java jdbc深入理解（connection与threadlocal与数据库连接池和事务实）][java jdbc_connection_threadlocal]

--------------------

1.  [(转载)数据库连接泄露的问题][Link 1] ↩︎
2.  [Spring 官方文档][Spring] ↩︎ ↩︎ ↩︎

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1h1X0pMMTk5Nw_size_16_color_FFFFFF_t_70]: /images/20220209/f3619756a2094485b8e8113b7fcd4f58.png
[java jdbc_connection_threadlocal]: https://www.cnblogs.com/panxuejun/p/5920845.html
[Link 1]: https://blog.csdn.net/u012089657/article/details/48897151
[Spring]: https://docs.spring.io/spring/docs/4.3.23.RELEASE/javadoc-api/