《深入理解mybatis原理(九)》 Mybatis数据源与连接池

转载 2016年06月01日 12:44:59

    对于ORM框架而言,数据源的组织是一个非常重要的一部分,这直接影响到框架的性能问题。本文将通过对MyBatis框架的数据源结构进行详尽的分析,并且深入解析MyBatis的连接池。

    本文首先会讲述MyBatis的数据源的分类,然后会介绍数据源是如何加载和使用的。紧接着将分类介绍UNPOOLED、POOLED和JNDI类型的数据源组织;期间我们会重点讲解POOLED类型的数据源和其实现的连接池原理。

以下是本章的组织结构:


  • 一、MyBatis数据源DataSource分类
  • 二、数据源DataSource的创建过程
  • 三、 DataSource什么时候创建Connection对象
  • 四、不使用连接池的UnpooledDataSource
  • 五、为什么要使用连接池?
  • 六、使用了连接池的PooledDataSource


一、MyBatis数据源DataSource分类

MyBatis数据源实现是在以下四个包中:

MyBatis把数据源DataSource分为三种:

        ž UNPOOLED    不使用连接池的数据源

        ž POOLED      使用连接池的数据源

        ž JNDI            使用JNDI实现的数据源

即:

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

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


二、数据源DataSource的创建过程

 MyBatis数据源DataSource对象的创建发生在MyBatis初始化的过程中。下面让我们一步步地了解MyBatis是如何创建数据源DataSource的。

在mybatis的XML配置文件中,使用<dataSource>元素来配置数据源:

1.  MyBatis在初始化时,解析此文件,根据<dataSource>的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:

定义如下:

  1. public interface DataSourceFactory {  
  2.   
  3.   void setProperties(Properties props);  
  4.   //生产DataSource  
  5.   DataSource getDataSource();  
  6. }  

上述三种不同类型的type,则有对应的以下dataSource工厂:

  • POOLED        PooledDataSourceFactory
  • UNPOOLED     UnpooledDataSourceFactory
  • JNDI          JndiDataSourceFactory

   其类图如下所示:


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

三、 DataSource什么时候创建Connection对象

当我们需要创建SqlSession对象并需要执行SQL语句时,这时候MyBatis才会去调用dataSource对象来创建java.sql.Connection对象。也就是说,java.sql.Connection对象的创建一直延迟到执行SQL语句的时候。

比如,我们有如下方法执行一个简单的SQL语句:

  1. String resource = "mybatis-config.xml";  
  2. InputStream inputStream = Resources.getResourceAsStream(resource);  
  3. SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
  4. SqlSession sqlSession = sqlSessionFactory.openSession();  
  5. sqlSession.selectList("SELECT * FROM STUDENTS");  
前4句都不会导致java.sql.Connection对象的创建,只有当第5句sqlSession.selectList("SELECT * FROM STUDENTS"),才会触发MyBatis在底层执行下面这个方法来创建java.sql.Connection对象:

  1. protected void openConnection() throws SQLException {  
  2.     if (log.isDebugEnabled()) {  
  3.       log.debug("Opening JDBC Connection");  
  4.     }  
  5.     connection = dataSource.getConnection();  
  6.     if (level != null) {  
  7.       connection.setTransactionIsolation(level.getLevel());  
  8.     }  
  9.     setDesiredAutoCommit(autoCommmit);  
  10.   }  

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

四、不使用连接池的UnpooledDataSource


当 <dataSource>的type属性被配置成了”UNPOOLED”,MyBatis首先会实例化一个UnpooledDataSourceFactory工厂实例,然后通过.getDataSource()方法返回一个UnpooledDataSource实例对象引用,我们假定为dataSource。

使用UnpooledDataSourcegetConnection(),每调用一次就会产生一个新的Connection实例对象。

UnPooledDataSource的getConnection()方法实现如下:

  1. /* 
  2. UnpooledDataSource的getConnection()实现 
  3. */  
  4. public Connection getConnection() throws SQLException  
  5. {  
  6.     return doGetConnection(username, password);  
  7. }  
  8.   
  9. private Connection doGetConnection(String username, String password) throws SQLException  
  10. {  
  11.     //封装username和password成properties  
  12.     Properties props = new Properties();  
  13.     if (driverProperties != null)  
  14.     {  
  15.         props.putAll(driverProperties);  
  16.     }  
  17.     if (username != null)  
  18.     {  
  19.         props.setProperty("user", username);  
  20.     }  
  21.     if (password != null)  
  22.     {  
  23.         props.setProperty("password", password);  
  24.     }  
  25.     return doGetConnection(props);  
  26. }  
  27.   
  28. /* 
  29.  *  获取数据连接 
  30.  */  
  31. private Connection doGetConnection(Properties properties) throws SQLException  
  32. {  
  33.     //1.初始化驱动  
  34.     initializeDriver();  
  35.     //2.从DriverManager中获取连接,获取新的Connection对象  
  36.     Connection connection = DriverManager.getConnection(url, properties);  
  37.     //3.配置connection属性  
  38.     configureConnection(connection);  
  39.     return connection;  
  40. }  

如上代码所示,UnpooledDataSource会做以下事情:

1.  初始化驱动:   判断driver驱动是否已经加载到内存中,如果还没有加载,则会动态地加载driver类,并实例化一个Driver对象,使用DriverManager.registerDriver()方法将其注册到内存中,以供后续使用。

2.  创建Connection对象:    使用DriverManager.getConnection()方法创建连接。

3.  配置Connection对象:   设置是否自动提交autoCommit和隔离级别isolationLevel。

4.  返回Connection对象。

 

上述的序列图如下所示:


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

五、为什么要使用连接池?


1. 创建一个java.sql.Connection实例对象的代价

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

  1. public static void main(String[] args) throws Exception  
  2. {  
  3.   
  4.     String sql = "select * from hr.employees where employee_id < ? and employee_id >= ?";  
  5.     PreparedStatement st = null;  
  6.     ResultSet rs = null;  
  7.   
  8.     long beforeTimeOffset = -1L; //创建Connection对象前时间  
  9.     long afterTimeOffset = -1L; //创建Connection对象后时间  
  10.     long executeTimeOffset = -1L; //创建Connection对象后时间  
  11.   
  12.     Connection con = null;  
  13.     Class.forName("oracle.jdbc.driver.OracleDriver");  
  14.   
  15.     beforeTimeOffset = new Date().getTime();  
  16.     System.out.println("before:\t" + beforeTimeOffset);  
  17.   
  18.     con = DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:xe""louluan""123456");  
  19.   
  20.     afterTimeOffset = new Date().getTime();  
  21.     System.out.println("after:\t\t" + afterTimeOffset);  
  22.     System.out.println("Create Costs:\t\t" + (afterTimeOffset - beforeTimeOffset) + " ms");  
  23.   
  24.     st = con.prepareStatement(sql);  
  25.     //设置参数  
  26.     st.setInt(1101);  
  27.     st.setInt(20);  
  28.     //查询,得出结果集  
  29.     rs = st.executeQuery();  
  30.     executeTimeOffset = new Date().getTime();  
  31.     System.out.println("Exec Costs:\t\t" + (executeTimeOffset - afterTimeOffset) + " ms");  
  32.   
  33. }  

上述程序在我笔记本上的执行结果为:

从此结果可以清楚地看出,创建一个Connection对象,用了250 毫秒;而执行SQL的时间用了170毫秒

创建一个Connection对象用了250毫秒!这个时间对计算机来说可以说是一个非常奢侈的!

这仅仅是一个Connection对象就有这么大的代价,设想一下另外一种情况:如果我们在Web应用程序中,为用户的每一个请求就操作一次数据库,当有10000个在线用户并发操作的话,对计算机而言,仅仅创建Connection对象不包括做业务的时间就要损耗10000×250ms= 250 0000 ms = 2500 s = 41.6667 min,竟然要41分钟!!!如果对高用户群体使用这样的系统,简直就是开玩笑!

2. 问题分析:

 

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

 

3.解决方案:

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

六、使用了连接池的PooledDataSource

同样地,我们也是使用PooledDataSource的getConnection()方法来返回Connection对象。现在让我们看一下它的基本原理:

 PooledDataSource将java.sql.Connection对象包裹成PooledConnection对象放到了PoolState类型的容器中维护。 MyBatis将连接池中的PooledConnection分为两种状态: 空闲状态(idle)和活动状态(active),这两种状态的PooledConnection对象分别被存储到PoolState容器内的idleConnectionsactiveConnections两个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连接池的大致结构如下所示:

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

 

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

  1. public Connection getConnection() throws SQLException {  
  2.    return popConnection(dataSource.getUsername(), dataSource.getPassword()).getProxyConnection();  
  3.  }  
  4.   
  5.  public Connection getConnection(String username, String password) throws SQLException {  
  6.    return popConnection(username, password).getProxyConnection();  
  7.  }  

上述的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步

  1. /* 
  2.  * 传递一个用户名和密码,从连接池中返回可用的PooledConnection 
  3.  */  
  4. private PooledConnection popConnection(String username, String password) throws SQLException  
  5. {  
  6.     boolean countedWait = false;  
  7.     PooledConnection conn = null;  
  8.     long t = System.currentTimeMillis();  
  9.     int localBadConnectionCount = 0;  
  10.   
  11.     while (conn == null)  
  12.     {  
  13.         synchronized (state)  
  14.         {  
  15.             if (state.idleConnections.size() > 0)  
  16.             {  
  17.                 // 连接池中有空闲连接,取出第一个  
  18.                 conn = state.idleConnections.remove(0);  
  19.                 if (log.isDebugEnabled())  
  20.                 {  
  21.                     log.debug("Checked out connection " + conn.getRealHashCode() + " from pool.");  
  22.                 }  
  23.             }  
  24.             else  
  25.             {  
  26.                 // 连接池中没有空闲连接,则取当前正在使用的连接数小于最大限定值,  
  27.                 if (state.activeConnections.size() < poolMaximumActiveConnections)  
  28.                 {  
  29.                     // 创建一个新的connection对象  
  30.                     conn = new PooledConnection(dataSource.getConnection(), this);  
  31.                     @SuppressWarnings("unused")  
  32.                     //used in logging, if enabled  
  33.                     Connection realConn = conn.getRealConnection();  
  34.                     if (log.isDebugEnabled())  
  35.                     {  
  36.                         log.debug("Created connection " + conn.getRealHashCode() + ".");  
  37.                     }  
  38.                 }  
  39.                 else  
  40.                 {  
  41.                     // Cannot create new connection 当活动连接池已满,不能创建时,取出活动连接池的第一个,即最先进入连接池的PooledConnection对象  
  42.                     // 计算它的校验时间,如果校验时间大于连接池规定的最大校验时间,则认为它已经过期了,利用这个PoolConnection内部的realConnection重新生成一个PooledConnection  
  43.                     //  
  44.                     PooledConnection oldestActiveConnection = state.activeConnections.get(0);  
  45.                     long longestCheckoutTime = oldestActiveConnection.getCheckoutTime();  
  46.                     if (longestCheckoutTime > poolMaximumCheckoutTime)  
  47.                     {  
  48.                         // Can claim overdue connection  
  49.                         state.claimedOverdueConnectionCount++;  
  50.                         state.accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime;  
  51.                         state.accumulatedCheckoutTime += longestCheckoutTime;  
  52.                         state.activeConnections.remove(oldestActiveConnection);  
  53.                         if (!oldestActiveConnection.getRealConnection().getAutoCommit())  
  54.                         {  
  55.                             oldestActiveConnection.getRealConnection().rollback();  
  56.                         }  
  57.                         conn = new PooledConnection(oldestActiveConnection.getRealConnection(), this);  
  58.                         oldestActiveConnection.invalidate();  
  59.                         if (log.isDebugEnabled())  
  60.                         {  
  61.                             log.debug("Claimed overdue connection " + conn.getRealHashCode() + ".");  
  62.                         }  
  63.                     }  
  64.                     else  
  65.                     {  
  66.   
  67.                         //如果不能释放,则必须等待有  
  68.                         // Must wait  
  69.                         try  
  70.                         {  
  71.                             if (!countedWait)  
  72.                             {  
  73.                                 state.hadToWaitCount++;  
  74.                                 countedWait = true;  
  75.                             }  
  76.                             if (log.isDebugEnabled())  
  77.                             {  
  78.                                 log.debug("Waiting as long as " + poolTimeToWait + " milliseconds for connection.");  
  79.                             }  
  80.                             long wt = System.currentTimeMillis();  
  81.                             state.wait(poolTimeToWait);  
  82.                             state.accumulatedWaitTime += System.currentTimeMillis() - wt;  
  83.                         }  
  84.                         catch (InterruptedException e)  
  85.                         {  
  86.                             break;  
  87.                         }  
  88.                     }  
  89.                 }  
  90.             }  
  91.   
  92.             //如果获取PooledConnection成功,则更新其信息  
  93.   
  94.             if (conn != null)  
  95.             {  
  96.                 if (conn.isValid())  
  97.                 {  
  98.                     if (!conn.getRealConnection().getAutoCommit())  
  99.                     {  
  100.                         conn.getRealConnection().rollback();  
  101.                     }  
  102.                     conn.setConnectionTypeCode(assembleConnectionTypeCode(dataSource.getUrl(), username, password));  
  103.                     conn.setCheckoutTimestamp(System.currentTimeMillis());  
  104.                     conn.setLastUsedTimestamp(System.currentTimeMillis());  
  105.                     state.activeConnections.add(conn);  
  106.                     state.requestCount++;  
  107.                     state.accumulatedRequestTime += System.currentTimeMillis() - t;  
  108.                 }  
  109.                 else  
  110.                 {  
  111.                     if (log.isDebugEnabled())  
  112.                     {  
  113.                         log.debug("A bad connection (" + conn.getRealHashCode() + ") was returned from the pool, getting another connection.");  
  114.                     }  
  115.                     state.badConnectionCount++;  
  116.                     localBadConnectionCount++;  
  117.                     conn = null;  
  118.                     if (localBadConnectionCount > (poolMaximumIdleConnections + 3))  
  119.                     {  
  120.                         if (log.isDebugEnabled())  
  121.                         {  
  122.                             log.debug("PooledDataSource: Could not get a good connection to the database.");  
  123.                         }  
  124.                         throw new SQLException("PooledDataSource: Could not get a good connection to the database.");  
  125.                     }  
  126.                 }  
  127.             }  
  128.         }  
  129.   
  130.     }  
  131.   
  132.     if (conn == null)  
  133.     {  
  134.         if (log.isDebugEnabled())  
  135.         {  
  136.             log.debug("PooledDataSource: Unknown severe error condition.  The connection pool returned a null connection.");  
  137.         }  
  138.         throw new SQLException("PooledDataSource: Unknown severe error condition.  The connection pool returned a null connection.");  
  139.     }  
  140.   
  141.     return conn;  
  142. }  

对应的处理流程图如下所示:

如上所示,对于PooledDataSource的getConnection()方法内,先是调用类PooledDataSource的popConnection()方法返回了一个PooledConnection对象,然后调用了PooledConnection的getProxyConnection()来返回Connection对象。

6.2java.sql.Connection对象的回收

       当我们的程序中使用完Connection对象时,如果不使用数据库连接池,我们一般会调用 connection.close()方法,关闭connection连接,释放资源。如下所示:

  1. private void test() throws ClassNotFoundException, SQLException  
  2. {  
  3.     String sql = "select * from hr.employees where employee_id < ? and employee_id >= ?";  
  4.     PreparedStatement st = null;  
  5.     ResultSet rs = null;  
  6.   
  7.     Connection con = null;  
  8.     Class.forName("oracle.jdbc.driver.OracleDriver");  
  9.     try  
  10.     {  
  11.         con = DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:xe""louluan""123456");  
  12.         st = con.prepareStatement(sql);  
  13.         //设置参数  
  14.         st.setInt(1101);  
  15.         st.setInt(20);  
  16.         //查询,得出结果集  
  17.         rs = st.executeQuery();  
  18.         //取数据,省略  
  19.         //关闭,释放资源  
  20.         con.close();  
  21.     }  
  22.     catch (SQLException e)  
  23.     {  
  24.         con.close();  
  25.         e.printStackTrace();  
  26.     }  
  27. }  

调用过close()方法的Connection对象所持有的资源会被全部释放掉,Connection对象也就不能再使用。

那么,如果我们使用了连接池,我们在用完了Connection对象时,需要将它放在连接池中,该怎样做呢?

可能大家第一个在脑海里闪现出来的想法就是:我在应该调用con.close()方法的时候,不调用close()f方法,将其换成将Connection对象放到连接池容器中的代码!

好,我们将上述的想法实现,首先定义一个简易连接池Pool,然后将上面的代码改写:

  1. package com.foo.jdbc;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.DriverManager;  
  5. import java.sql.SQLException;  
  6. import java.util.Vector;  
  7.   
  8. /** 
  9.  *  
  10.  * 一个线程安全的简易连接池实现,此连接池是单例的 
  11.  *  putConnection()将Connection添加到连接池中 
  12.  *  getConnection()返回一个Connection对象 
  13.  */  
  14. public class Pool {  
  15.   
  16.     private static Vector<Connection> pool = new Vector<Connection>();  
  17.       
  18.     private static int MAX_CONNECTION =100;  
  19.       
  20.     private static String DRIVER="oracle.jdbc.driver.OracleDriver";  
  21.     private static String URL = "jdbc:oracle:thin:@127.0.0.1:1521:xe";  
  22.     private static String USERNAME = "louluan";  
  23.     private static String PASSWROD = "123456";  
  24.       
  25.     static {  
  26.         try {  
  27.             Class.forName(DRIVER);  
  28.         } catch (ClassNotFoundException e) {  
  29.             e.printStackTrace();  
  30.         }  
  31.     }  
  32.       
  33.     /** 
  34.      * 将一个Connection对象放置到连接池中  
  35.      */  
  36.     public static  void putConnection(Connection connection){  
  37.           
  38.         synchronized(pool)  
  39.         {  
  40.             if(pool.size()<MAX_CONNECTION)  
  41.             {  
  42.                 pool.add(connection);         
  43.             }  
  44.         }  
  45.     }  
  46.       
  47.       
  48.     /** 
  49.      * 返回一个Connection对象,如果连接池内有元素,则pop出第一个元素; 
  50.      * 如果连接池Pool中没有元素,则创建一个connection对象,然后添加到pool中 
  51.      * @return Connection 
  52.      */  
  53.     public static Connection getConnection(){  
  54.         Connection connection = null;  
  55.         synchronized(pool)  
  56.         {  
  57.             if(pool.size()>0)  
  58.             {  
  59.                 connection = pool.get(0);  
  60.                 pool.remove(0);  
  61.             }  
  62.             else  
  63.             {  
  64.                 connection = createConnection();  
  65.                 pool.add(connection);  
  66.             }  
  67.         }  
  68.         return connection;  
  69.     }  
  70.       
  71.     /** 
  72.      * 创建一个新的Connection对象 
  73.      */  
  74.     private static Connection createConnection()  
  75.     {  
  76.         Connection connection = null;  
  77.         try {  
  78.             connection = DriverManager.getConnection(URL, USERNAME,PASSWROD);  
  79.         } catch (SQLException e) {  
  80.             e.printStackTrace();  
  81.         }  
  82.         return connection;  
  83.     }  
  84.       
  85. }  

  1. package com.foo.jdbc;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.DriverManager;  
  5. import java.sql.PreparedStatement;  
  6. import java.sql.ResultSet;  
  7. import java.sql.SQLException;  
  8. import java.util.Vector;  
  9.   
  10. public class PoolTest  
  11. {  
  12.   
  13.     private void test() throws ClassNotFoundException, SQLException  
  14.     {  
  15.         String sql = "select * from hr.employees where employee_id < ? and employee_id >= ?";  
  16.         PreparedStatement st = null;  
  17.         ResultSet rs = null;  
  18.   
  19.         Connection con = null;  
  20.         Class.forName("oracle.jdbc.driver.OracleDriver");  
  21.         try  
  22.         {  
  23.             con = DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:xe""louluan""123456");  
  24.             st = con.prepareStatement(sql);  
  25.             //设置参数  
  26.             st.setInt(1101);  
  27.             st.setInt(20);  
  28.             //查询,得出结果集  
  29.             rs = st.executeQuery();  
  30.             //取数据,省略  
  31.             //将不再使用的Connection对象放到连接池中,供以后使用  
  32.             Pool.putConnection(con);  
  33.         }  
  34.         catch (SQLException e)  
  35.         {  
  36.             e.printStackTrace();  
  37.         }  
  38.     }  
  39. }  
 

上述的代码就是将我们使用过的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的代理:

其部分定义如下:

  1. class PooledConnection implements InvocationHandler {  
  2.     
  3.   //......  
  4.   //所创建它的datasource引用  
  5.   private PooledDataSource dataSource;  
  6.   //真正的Connection对象  
  7.   private Connection realConnection;  
  8.   //代理自己的代理Connection  
  9.   private Connection proxyConnection;  
  10.     
  11.   //......  
  12. }  

PooledConenction实现了InvocationHandler接口,并且,proxyConnection对象也是根据这个它来生成的代理对象:

  1. public PooledConnection(Connection connection, PooledDataSource dataSource) {  
  2.     this.hashCode = connection.hashCode();  
  3.     this.realConnection = connection;  
  4.     this.dataSource = dataSource;  
  5.     this.createdTimestamp = System.currentTimeMillis();  
  6.     this.lastUsedTimestamp = System.currentTimeMillis();  
  7.     this.valid = true;  
  8.     this.proxyConnection = (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(), IFACES, this);  
  9.   }  

实际上,我们调用PooledDataSource的getConnection()方法返回的就是这个proxyConnection对象。

当我们调用此proxyConnection对象上的任何方法时,都会调用PooledConnection对象内invoke()方法。

让我们看一下PooledConnection类中的invoke()方法定义:

  1. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
  2.     String methodName = method.getName();  
  3.     //当调用关闭的时候,回收此Connection到PooledDataSource中  
  4.     if (CLOSE.hashCode() == methodName.hashCode() && CLOSE.equals(methodName)) {  
  5.       dataSource.pushConnection(this);  
  6.       return null;  
  7.     } else {  
  8.       try {  
  9.         if (!Object.class.equals(method.getDeclaringClass())) {  
  10.           checkConnection();  
  11.         }  
  12.         return method.invoke(realConnection, args);  
  13.       } catch (Throwable t) {  
  14.         throw ExceptionUtil.unwrapThrowable(t);  
  15.       }  
  16.     }  
  17.   }  

从上述代码可以看到,当我们使用了pooledDataSource.getConnection()返回的Connection对象的close()方法时,不会调用真正Connection的close()方法,而是将此Connection对象放到连接池中。

七、JNDI类型的数据源DataSource

对于JNDI类型的数据源DataSource的获取就比较简单,MyBatis定义了一个JndiDataSourceFactory工厂来创建通过JNDI形式生成的DataSource。

下面让我们看一下JndiDataSourceFactory的关键代码:

  1. if (properties.containsKey(INITIAL_CONTEXT)  
  2.         && properties.containsKey(DATA_SOURCE))  
  3. {  
  4.     //从JNDI上下文中找到DataSource并返回  
  5.     Context ctx = (Context) initCtx.lookup(properties.getProperty(INITIAL_CONTEXT));  
  6.     dataSource = (DataSource) ctx.lookup(properties.getProperty(DATA_SOURCE));  
  7. }  
  8. else if (properties.containsKey(DATA_SOURCE))  
  9. {  
  10.     // //从JNDI上下文中找到DataSource并返回  
  11.     dataSource = (DataSource) initCtx.lookup(properties.getProperty(DATA_SOURCE));  
  12. }  



本文转载自:http://blog.csdn.net/luanlouis/article/details/37671851




《深入理解mybatis原理(二)》 Mybatis关联查询问题

版权声明:本文为博主原创文章,未经博主允许不得转载。 目录(?)[+] 嵌套语句查询 嵌套语句查询的原理N1问题 嵌套结果查询 mybatis 提供了高级的关联查询功能,可以很方便地将...
  • pfnie
  • pfnie
  • 2016年05月25日 14:06
  • 740

第一天:浪迹天涯网上商城(1.0版本)--项目介绍

1、浪迹天涯商城简介 浪迹天涯网上商城是一个综合性的B2C平台,类似京东商城、天猫商城。会员可以在商城浏览商品、下订单,以及参加各种活动。管理员、运营可以在平台后台管理系统中管理商品、订单、会员等。客...
  • pfnie
  • pfnie
  • 2017年11月04日 12:26
  • 92

《深入理解mybatis原理》 Mybatis数据源与连接池

对于ORM框架而言,数据源的组织是一个非常重要的一部分,这直接影响到框架的性能问题。本文将通过对MyBatis框架的数据源结构进行详尽的分析,并且深入解析MyBatis的连接池。     本文首先会...

《深入理解mybatis原理》 Mybatis数据源与连接池

对于ORM框架而言,数据源的组织是一个非常重要的一部分,这直接影响到框架的性能问题。本文将通过对MyBatis框架的数据源结构进行详尽的分析,并且深入解析MyBatis的连接池。     本文首...

《深入理解mybatis原理》 Mybatis数据源与连接池

对于ORM框架而言,数据源的组织是一个非常重要的一部分,这直接影响到框架的性能问题。本文将通过对MyBatis框架的数据源结构进行详尽的分析,并且深入解析MyBatis的连接池。     本文首...

《深入理解mybatis原理》 Mybatis数据源与连接池

对于ORM框架而言,数据源的组织是一个非常重要的一部分,这直接影响到框架的性能问题。本文将通过对MyBatis框架的数据源结构进行详尽的分析,并且深入解析MyBatis的连接池。     本文首先会...
  • QH_JAVA
  • QH_JAVA
  • 2016年05月18日 09:46
  • 649

《深入理解mybatis原理》 Mybatis数据源与连接池

对于ORM框架而言,数据源的组织是一个非常重要的一部分,这直接影响到框架的性能问题。本文将通过对MyBatis框架的数据源结构进行详尽的分析,并且深入解析MyBatis的连接池。     本文首...

《深入理解mybatis原理》 Mybatis数据源与连接池

对于ORM框架而言,数据源的组织是一个非常重要的一部分,这直接影响到框架的性能问题。本文将通过对MyBatis框架的数据源结构进行详尽的分析,并且深入解析MyBatis的连接池。     本文首先会...

《深入理解mybatis原理》 Mybatis数据源与连接池

对于ORM框架而言,数据源的组织是一个非常重要的一部分,这直接影响到框架的性能问题。本文将通过对MyBatis框架的数据源结构进行详尽的分析,并且深入解析MyBatis的连接池。     本文首先会...

mybatis知识点总结之数据源和连接池

参考博客; http://blog.csdn.NET/luanlouis/article/details/37671851对于ORM框架而言,数据源的组织是一个非常重要的一部分,这直接影响到框架的性能...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:《深入理解mybatis原理(九)》 Mybatis数据源与连接池
举报原因:
原因补充:

(最多只允许输入30个字)