MyBatis连接池的实现原理分析

小灰灰 2023-07-19 05:56 16阅读 0赞

### MyBatis的连接池 ###

*  1. 连接池技术
 *  2. MyBatis连接池的分类
 *  3. MyBatis连接池的实现原理分析
 *   *  1.MyBatis连接池的实现原理分析（图解）

# 1. 连接池技术 #

1.  连接池是什么：存储连接的容器
2.  解决了什么问题 ：如果没有连接池，那么每次都执行SQL语句都会创建connection连接，会浪费时间。影响 程序的性能。
3.  提前创建一些连接，存储到连接池中，使用的时候从连接池中获取连接即可。
4.  常用的连接池  
    1. C3P0连接池  
    2. DBCP连接池  
    3. Druid连接池（阿里）
5.  连接池有**归还**的操作，已经对close方法进行了增强，原来是销毁，现在是归还操作。

# 2. MyBatis连接池的分类 #

1.  MyBatis内置了连接池技术，dataSource标签的type属性有3个取值  
    ![在这里插入图片描述][20200329234426222.png]
2.  POOLED使用连接池
3.  UNPOOLED 不使用连接池(这个了解即可，一般是不使用的)
4.  JNDI 使用JNDI实现连接池（麻烦，不推荐使用）

# 3. MyBatis连接池的实现原理分析 #

1.  在解析配置文件的时候，创建dataSource对象，存入到Environment对象中。
2.  当执行SQL语句的时候，准备从dataSource对象中获取链接。
3.  PooledDataSource源码中的2个方法用来获取连接和归还连接  
    **（1）、popConnection方法用来获取链接**

> 1.  先判断空闲的连接池中是否存在连接，如果存在，则获取一个连接使用。
> 2.  查看活动状态的PooledConnection池activeConnections是否已满；如果没有满，则 创建一个新的 PooledConnection对象，然后放到activeConnections池中，然后返回此PooledConnection对 象。
> 3.  看最先进入activeConnections池中的PooledConnection对象是否已经过期：如果已 经过期，从 activeConnections池中移除此对象，然后创建一个新的PooledConnection对象，添加 到activeConnections中，然后将此对象返回。

**（2）、 pushConnection方法用来归还链接**

两个方法的源码如下(参考)：

protected void pushConnection(PooledConnection conn) throws SQLException { 
    
        synchronized (state) { 
          state.activeConnections.remove(conn);
          if (conn.isValid()) { 
            if (state.idleConnections.size() < poolMaximumIdleConnections && conn.getConnectionTypeCode() == expectedConnectionTypeCode) { 
              state.accumulatedCheckoutTime += conn.getCheckoutTime();
              if (!conn.getRealConnection().getAutoCommit()) { 
                conn.getRealConnection().rollback();
              }
              PooledConnection newConn = new PooledConnection(conn.getRealConnection(), this);
              state.idleConnections.add(newConn);
              newConn.setCreatedTimestamp(conn.getCreatedTimestamp());
              newConn.setLastUsedTimestamp(conn.getLastUsedTimestamp());
              conn.invalidate();
              if (log.isDebugEnabled()) { 
                log.debug("Returned connection " + newConn.getRealHashCode() + " to pool.");
              }
              state.notifyAll();
            } else { 
              state.accumulatedCheckoutTime += conn.getCheckoutTime();
              if (!conn.getRealConnection().getAutoCommit()) { 
                conn.getRealConnection().rollback();
              }
              conn.getRealConnection().close();
              if (log.isDebugEnabled()) { 
                log.debug("Closed connection " + conn.getRealHashCode() + ".");
              }
              conn.invalidate();
            }
          } else { 
            if (log.isDebugEnabled()) { 
              log.debug("A bad connection (" + conn.getRealHashCode() + ") attempted to return to the pool, discarding connection.");
            }
            state.badConnectionCount++;
          }
        }
      }
    
      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.isEmpty()) { 
              // Pool has available connection
              conn = state.idleConnections.remove(0);
              if (log.isDebugEnabled()) { 
                log.debug("Checked out connection " + conn.getRealHashCode() + " from pool.");
              }
            } else { 
              // Pool does not have available connection
              if (state.activeConnections.size() < poolMaximumActiveConnections) { 
                // Can create new connection
                conn = new PooledConnection(dataSource.getConnection(), this);
                if (log.isDebugEnabled()) { 
                  log.debug("Created connection " + conn.getRealHashCode() + ".");
                }
              } else { 
                // Cannot create new connection
                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()) { 
                    try { 
                      oldestActiveConnection.getRealConnection().rollback();
                    } catch (SQLException e) { 
                      /* Just log a message for debug and continue to execute the following statement like nothing happend. Wrap the bad connection with a new PooledConnection, this will help to not intterupt current executing thread and give current thread a chance to join the next competion for another valid/good database connection. At the end of this loop, bad {@link @conn} will be set as null. */
                      log.debug("Bad connection. Could not roll back");
                    }  
                  }
                  conn = new PooledConnection(oldestActiveConnection.getRealConnection(), this);
                  conn.setCreatedTimestamp(oldestActiveConnection.getCreatedTimestamp());
                  conn.setLastUsedTimestamp(oldestActiveConnection.getLastUsedTimestamp());
                  oldestActiveConnection.invalidate();
                  if (log.isDebugEnabled()) { 
                    log.debug("Claimed overdue connection " + conn.getRealHashCode() + ".");
                  }
                } else { 
                  // Must wait
                  try { 
                    if (!countedWait) { 
                      state.hadToWaitCount++;
                      countedWait = true;
                    }
                    if (log.isDebugEnabled()) { 
                      log.debug("Waiting as long as " + poolTimeToWait + " milliseconds for connection.");
                    }
                    long wt = System.currentTimeMillis();
                    state.wait(poolTimeToWait);
                    state.accumulatedWaitTime += System.currentTimeMillis() - wt;
                  } catch (InterruptedException e) { 
                    break;
                  }
                }
              }
            }
            if (conn != null) { 
              // ping to server and check the connection is valid or not
              if (conn.isValid()) { 
                if (!conn.getRealConnection().getAutoCommit()) { 
                  conn.getRealConnection().rollback();
                }
                conn.setConnectionTypeCode(assembleConnectionTypeCode(dataSource.getUrl(), username, password));
                conn.setCheckoutTimestamp(System.currentTimeMillis());
                conn.setLastUsedTimestamp(System.currentTimeMillis());
                state.activeConnections.add(conn);
                state.requestCount++;
                state.accumulatedRequestTime += System.currentTimeMillis() - t;
              } else { 
                if (log.isDebugEnabled()) { 
                  log.debug("A bad connection (" + conn.getRealHashCode() + ") was returned from the pool, getting another connection.");
                }
                state.badConnectionCount++;
                localBadConnectionCount++;
                conn = null;
                if (localBadConnectionCount > (poolMaximumIdleConnections + poolMaximumLocalBadConnectionTolerance)) { 
                  if (log.isDebugEnabled()) { 
                    log.debug("PooledDataSource: Could not get a good connection to the database.");
                  }
                  throw new SQLException("PooledDataSource: Could not get a good connection to the database.");
                }
              }
            }
          }
    
        }
    
        if (conn == null) { 
          if (log.isDebugEnabled()) { 
            log.debug("PooledDataSource: Unknown severe error condition. The connection pool returned a null connection.");
          }
          throw new SQLException("PooledDataSource: Unknown severe error condition. The connection pool returned a null connection.");
        }
    
        return conn;
      }

## 1.MyBatis连接池的实现原理分析（图解） ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTIyMTEz_size_16_color_FFFFFF_t_70]  
源码中规定的活动连接池中的最大连接数是10：

protected int poolMaximumActiveConnections = 10;

[20200329234426222.png]: /images/20230528/ad1a56972e0f477d8bf9895c8c237039.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTIyMTEz_size_16_color_FFFFFF_t_70]: /images/20230528/850b6f6b1ba74ba5be3fa112baac7264.png