终结篇:MyBatis原理深入解析(二)

dongxurr 2020-02-29

8 MyBatis数据源与连接池#

8.1 MyBatis数据源DataSource分类##

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

MyBatis数据源实现包

MyBatis把数据源DataSource分为三种:

UNPOOLED 不使用连接池的数据源

POOLED 使用连接池的数据源

JNDI 使用JNDI实现的数据源

即:

MyBatis三种数据源

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

MyBatis DataSource实现UML图

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

8.2 数据源DataSource的创建过程##

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

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

<dataSource>元素配置数据源

  1. MyBatis在初始化时,解析此文件,根据的type属性来创建相应类型的的数据源DataSource,即:

type=”POOLED” :MyBatis会创建PooledDataSource实例

type=”UNPOOLED” :MyBatis会创建UnpooledDataSource实例

type=”JNDI” :MyBatis会从JNDI服务上查找DataSource实例,然后返回使用

  1. 顺便说一下,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

其类图如下所示:

DataSource工厂UML类图

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

8.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);  }  

8.4 不使用连接池的UnpooledDataSource##

<dataSource>的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会做以下事情:

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

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

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

  4. 返回Connection对象

上述的序列图如下所示:

UnPooledDataSource序列图

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

8.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分钟!!!如果对高用户群体使用这样的系统,简直就是开玩笑!

  1. 问题分析:

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

  1. 解决方案:

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

8.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连接池的大致结构如下所示:

PoolState连接池结构图

  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. 线程等待,循环至第1步

/*    * 传递一个用户名和密码,从连接池中返回可用的PooledConnection    */  private PooledConnection popConnection(String username, String password) throws SQLException  {        boolean countedWait = false;        PooledConnection conn = null;        long t = System.currentTimeMillis();        int localBadConnectionCount = 0;         while (conn == null)        {            synchronized (state)            {                if (state.idleConnections.size() > 0)                {                    // 连接池中有空闲连接,取出第一个                    conn = state.idleConnections.remove(0);                    if (log.isDebugEnabled())                    {                        log.debug("Checked out connection " + conn.getRealHashCode() + " from pool.");                    }                }                else                {                    // 连接池中没有空闲连接,则取当前正在使用的连接数小于最大限定值,                    if (state.activeConnections.size() < poolMaximumActiveConnections)                    {                        // 创建一个新的connection对象                        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                    {                        // Cannot create new connection 当活动连接池已满,不能创建时,取出活动连接池的第一个,即最先进入连接池的PooledConnection对象                        // 计算它的校验时间,如果校验时间大于连接池规定的最大校验时间,则认为它已经过期了,利用这个PoolConnection内部的realConnection重新生成一个PooledConnection                        //                        PooledConnection oldestActiveConnection = state.activeConnections.get(0);                        long longestCheckoutTime = oldestActiveConnection.getCheckoutTime();                        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.

相关推荐