zoukankan      html  css  js  c++  java

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

        对于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：

    定义如下：

    [java] view plain copy
     
    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语句：

    [java] view plain copy
     
    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对象：
    [java] view plain copy
     
    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。

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

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

    [java] view plain copy
     
    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语句各消耗多长时间。代码如下：

    [java] view plain copy
     
    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: " + 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: " + afterTimeOffset);  
    22.     System.out.println("Create Costs: " + (afterTimeOffset - beforeTimeOffset) + " ms");  
    23.   
    24.     st = con.prepareStatement(sql);  
    25.     //设置参数  
    26.     st.setInt(1, 101);  
    27.     st.setInt(2, 0);  
    28.     //查询，得出结果集  
    29.     rs = st.executeQuery();  
    30.     executeTimeOffset = new Date().getTime();  
    31.     System.out.println("Exec Costs: " + (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容器内的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连接池的大致结构如下所示：

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

    下面让我们看一下PooledDataSource 的getConnection()方法获取Connection对象的实现：
    [java] view plain copy
     
    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步

    [java] view plain copy
     
    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连接，释放资源。如下所示：
    [java] view plain copy
     
    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(1, 101);  
    15.         st.setInt(2, 0);  
    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，然后将上面的代码改写：
    [java] view plain copy
     
    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. }  

    [java] view plain copy
     
    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(1, 101);  
    27.             st.setInt(2, 0);  
    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的代理：

    其部分定义如下：

    [java] view plain copy
     
    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对象也是根据这个它来生成的代理对象：
    [java] view plain copy
     
    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()方法定义：
    [java] view plain copy
     
    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的关键代码：
    [java] view plain copy
     
    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. }  
  • 相关阅读:
    Linux 操作系统读写寄存器
    mysql_mysql基本使用
    logcat日志文件分析
    pytest_用例运行级别_class级
    pytest_用例运行级别_函数级
    pytest_用例运行级别_模块级
    python生成接口自动化测试报告模版
    python中nonlocal 的作用域
    python中global的作用域
    python装饰器参数那些事_接受参数的装饰器
  • 原文地址：https://www.cnblogs.com/firstdream/p/8666845.html
Copyright © 2011-2022 走看看