原文链接 https://blog.csdn.net/NongYeting/article/details/106408985 https://tech.meituan.com/2018/01/19/mybatis-cache.html https://juejin.cn/post/6844903665094901767

在springboot下的配置

MyBatis 一级缓存（MyBaits 称其为 Local Cache）无法关闭，但是有两种级别可选：

A.session

在同一个 sqlSession 内，对同样的查询将不再查询数据库，直接从缓存中获取。

  1. mybatis:
  2. configuration:
  3. cache-enabled: false  #禁用二级缓存
  4.     local-cache-scope: session  #一级缓存指定为session级别

B.statement

每次查询结束都会清掉一级缓存，实际效果就是禁用了一级缓存；

  1. mybatis:
  2.   configuration:
  3.     cache-enabled: false #禁用二级缓存
  4.     local-cache-scope: statement #一级缓存指定为statement级别
  1. public abstract class BaseExecutor implements Executor {  
  2.     ...
  3.     ...
  4.     ...
  5.     ...
  7.   @SuppressWarnings("unchecked")
  8.   @Override
  9.   public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
  10.     ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
  11.     if (closed) {
  12.       throw new ExecutorException("Executor was closed.");
  13.     }
  14.     if (queryStack == 0 && ms.isFlushCacheRequired()) {
  15.       clearLocalCache();
  16.     }
  17.     List<E> list;
  18.     try {
  19.       queryStack++;
  20.       list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
  21.       if (list != null) {
  22.         handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
  23.       } else {
  24.         list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
  25.       }
  26.     } finally {
  27.       queryStack--;
  28.     }
  30.     if (queryStack == 0) {
  31.       for (DeferredLoad deferredLoad : deferredLoads) {
  32.         deferredLoad.load();
  33.       }
  34.       // issue #601
  35.       deferredLoads.clear();
  37.       //-------
  38.       //LocalCacheScope.STATEMENT 每次都会清空缓存间接等于无缓存
  39.       //-------
  40.       if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
  41.         // issue #482
  42.         clearLocalCache();
  43.       }
  44.     }
  45.     return list;
  46.   }
  47.     ...
  48.     ...
  49.     ...
  50.     ...
  51. }

MyBatis一、二级缓存的基本概念

  1. MyBatis的二级缓存相对于一级缓存来说，实现了SqlSession之间缓存数据的共享，同时粒度更加的细，能够到namespace级别，通过Cache接口实现类不同的组合，对Cache的可控性也更强。
  2. MyBatis在多表查询时，极大可能会出现脏数据，有设计上的缺陷，安全使用二级缓存的条件比较苛刻。
  3. 在分布式环境下，由于默认的MyBatis Cache实现都是基于本地的，分布式环境下必然会出现读取到脏数据，需要使用集中式缓存将MyBatis的Cache接口实现，有一定的开发成本，直接使用Redis、Memcached等分布式缓存可能成本更低，安全性也更高。

最终建议MyBatis缓存特性在生产环境中进行关闭（单体服务例外）单纯作为一个ORM框架使用可能更为合适。

LocalCacheScope类

  1. package org.apache.ibatis.session;
  3. /**
  4. * @author Eduardo Macarron
  5. */
  6. public enum LocalCacheScope {
  7.     SESSION,STATEMENT
  8. }

Configuration类

  1. package org.apache.ibatis.session;
  3. import java.util.Arrays;
  4. import java.util.Collection;
  5. import java.util.HashMap;
  6. import java.util.HashSet;
  7. import java.util.Iterator;
  8. import java.util.LinkedList;
  9. import java.util.List;
  10. import java.util.Map;
  11. import java.util.Properties;
  12. import java.util.Set;
  13. import java.util.function.BiFunction;
  14. /**
  15.  * @author Clinton Begin
  16.  */
  17. public class Configuration {
  19.   protected Environment environment;
  21.   protected boolean safeRowBoundsEnabled;
  22.   protected boolean safeResultHandlerEnabled = true;
  23.   protected boolean mapUnderscoreToCamelCase;
  24.   protected boolean aggressiveLazyLoading;
  25.   protected boolean multipleResultSetsEnabled = true;
  26.   protected boolean useGeneratedKeys;
  27.   protected boolean useColumnLabel = true;
  28.   protected boolean cacheEnabled = true;
  29.   protected boolean callSettersOnNulls;
  30.   protected boolean useActualParamName = true;
  31.   protected boolean returnInstanceForEmptyRow;
  32.   protected boolean shrinkWhitespacesInSql;
  33.   protected boolean nullableOnForEach;
  34.   protected boolean argNameBasedConstructorAutoMapping;
  36.   protected String logPrefix;
  37.   protected Class<? extends Log> logImpl;
  38.   protected Class<? extends VFS> vfsImpl;
  39.   protected Class<?> defaultSqlProviderType;
  40.   protected LocalCacheScope localCacheScope = LocalCacheScope.SESSION;
  41.   protected JdbcType jdbcTypeForNull = JdbcType.OTHER;
  42.   protected Set<String> lazyLoadTriggerMethods = new HashSet<>(Arrays.asList("equals", "clone", "hashCode", "toString"));
  43.   protected Integer defaultStatementTimeout;
  44.   protected Integer defaultFetchSize;
  45.   protected ResultSetType defaultResultSetType;
  46.   protected ExecutorType defaultExecutorType = ExecutorType.SIMPLE;
  47.   protected AutoMappingBehavior autoMappingBehavior = AutoMappingBehavior.PARTIAL;
  48.   protected AutoMappingUnknownColumnBehavior autoMappingUnknownColumnBehavior = AutoMappingUnknownColumnBehavior.NONE;
  50.   protected Properties variables = new Properties();
  51.   protected ReflectorFactory reflectorFactory = new DefaultReflectorFactory();
  52.   protected ObjectFactory objectFactory = new DefaultObjectFactory();
  53.   protected ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory();
  55.   protected boolean lazyLoadingEnabled = false;
  56.   protected ProxyFactory proxyFactory = new JavassistProxyFactory(); // #224 Using internal Javassist instead of OGNL
  58.   protected String databaseId;
  59.   /**
  60.    * Configuration factory class.
  61.    * Used to create Configuration for loading deserialized unread properties.
  62.    *
  63.    * @see <a href='https://github.com/mybatis/old-google-code-issues/issues/300'>Issue 300 (google code)</a>
  64.    */
  65.   protected Class<?> configurationFactory;
  67.   protected final MapperRegistry mapperRegistry = new MapperRegistry(this);
  68.   protected final InterceptorChain interceptorChain = new InterceptorChain();
  69.   protected final TypeHandlerRegistry typeHandlerRegistry = new TypeHandlerRegistry(this);
  70.   protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();
  71.   protected final LanguageDriverRegistry languageRegistry = new LanguageDriverRegistry();
  73.   protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection")
  74.       .conflictMessageProducer((savedValue, targetValue) ->
  75.           ". please check " + savedValue.getResource() + " and " + targetValue.getResource());
  76.   protected final Map<String, Cache> caches = new StrictMap<>("Caches collection");
  77.   protected final Map<String, ResultMap> resultMaps = new StrictMap<>("Result Maps collection");
  78.   protected final Map<String, ParameterMap> parameterMaps = new StrictMap<>("Parameter Maps collection");
  79.   protected final Map<String, KeyGenerator> keyGenerators = new StrictMap<>("Key Generators collection");
  81.   protected final Set<String> loadedResources = new HashSet<>();
  82.   protected final Map<String, XNode> sqlFragments = new StrictMap<>("XML fragments parsed from previous mappers");
  84.   protected final Collection<XMLStatementBuilder> incompleteStatements = new LinkedList<>();
  85.   protected final Collection<CacheRefResolver> incompleteCacheRefs = new LinkedList<>();
  86.   protected final Collection<ResultMapResolver> incompleteResultMaps = new LinkedList<>();
  87.   protected final Collection<MethodResolver> incompleteMethods = new LinkedList<>();
  89.   /*
  90.    * A map holds cache-ref relationship. The key is the namespace that
  91.    * references a cache bound to another namespace and the value is the
  92.    * namespace which the actual cache is bound to.
  93.    */
  94.   protected final Map<String, String> cacheRefMap = new HashMap<>();
  96.   public Configuration(Environment environment) {
  97.     this();
  98.     this.environment = environment;
  99.   }
  101.   public Configuration() {
  102.     typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
  103.     typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);
  105.     typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
  106.     typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
  107.     typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);
  109.     typeAliasRegistry.registerAlias("PERPETUAL", PerpetualCache.class);
  110.     typeAliasRegistry.registerAlias("FIFO", FifoCache.class);
  111.     typeAliasRegistry.registerAlias("LRU", LruCache.class);
  112.     typeAliasRegistry.registerAlias("SOFT", SoftCache.class);
  113.     typeAliasRegistry.registerAlias("WEAK", WeakCache.class);
  115.     typeAliasRegistry.registerAlias("DB_VENDOR", VendorDatabaseIdProvider.class);
  117.     typeAliasRegistry.registerAlias("XML", XMLLanguageDriver.class);
  118.     typeAliasRegistry.registerAlias("RAW", RawLanguageDriver.class);
  120.     typeAliasRegistry.registerAlias("SLF4J", Slf4jImpl.class);
  121.     typeAliasRegistry.registerAlias("COMMONS_LOGGING", JakartaCommonsLoggingImpl.class);
  122.     typeAliasRegistry.registerAlias("LOG4J", Log4jImpl.class);
  123.     typeAliasRegistry.registerAlias("LOG4J2", Log4j2Impl.class);
  124.     typeAliasRegistry.registerAlias("JDK_LOGGING", Jdk14LoggingImpl.class);
  125.     typeAliasRegistry.registerAlias("STDOUT_LOGGING", StdOutImpl.class);
  126.     typeAliasRegistry.registerAlias("NO_LOGGING", NoLoggingImpl.class);
  128.     typeAliasRegistry.registerAlias("CGLIB", CglibProxyFactory.class);
  129.     typeAliasRegistry.registerAlias("JAVASSIST", JavassistProxyFactory.class);
  131.     languageRegistry.setDefaultDriverClass(XMLLanguageDriver.class);
  132.     languageRegistry.register(RawLanguageDriver.class);
  133.   }

UnpooledDataSourceFactory 非池化类

package org.apache.ibatis.datasource.unpooled;
image.png

  1. package org.apache.ibatis.datasource.unpooled;
  3. /**
  4.  * @author Clinton Begin
  5.  */
  6. public class UnpooledDataSourceFactory implements DataSourceFactory {
  8.   private static final String DRIVER_PROPERTY_PREFIX = "driver.";
  9.   private static final int DRIVER_PROPERTY_PREFIX_LENGTH = DRIVER_PROPERTY_PREFIX.length();
  11.   protected DataSource dataSource;
  13.   public UnpooledDataSourceFactory() {
  14.     this.dataSource = new UnpooledDataSource();
  15.   }
  17.   @Override
  18.   public void setProperties(Properties properties) {
  19.     Properties driverProperties = new Properties();
  20.     MetaObject metaDataSource = SystemMetaObject.forObject(dataSource);
  21.     for (Object key : properties.keySet()) {
  22.       String propertyName = (String) key;
  23.       if (propertyName.startsWith(DRIVER_PROPERTY_PREFIX)) {
  24.         String value = properties.getProperty(propertyName);
  25.         driverProperties.setProperty(propertyName.substring(DRIVER_PROPERTY_PREFIX_LENGTH), value);
  26.       } else if (metaDataSource.hasSetter(propertyName)) {
  27.         String value = (String) properties.get(propertyName);
  28.         Object convertedValue = convertValue(metaDataSource, propertyName, value);
  29.         metaDataSource.setValue(propertyName, convertedValue);
  30.       } else {
  31.         throw new DataSourceException("Unknown DataSource property: " + propertyName);
  32.       }
  33.     }
  34.     if (driverProperties.size() > 0) {
  35.       metaDataSource.setValue("driverProperties", driverProperties);
  36.     }
  37.   }
  39.   @Override
  40.   public DataSource getDataSource() {
  41.     return dataSource;
  42.   }
  44.   private Object convertValue(MetaObject metaDataSource, String propertyName, String value) {
  45.     Object convertedValue = value;
  46.     Class<?> targetType = metaDataSource.getSetterType(propertyName);
  47.     if (targetType == Integer.class || targetType == int.class) {
  48.       convertedValue = Integer.valueOf(value);
  49.     } else if (targetType == Long.class || targetType == long.class) {
  50.       convertedValue = Long.valueOf(value);
  51.     } else if (targetType == Boolean.class || targetType == boolean.class) {
  52.       convertedValue = Boolean.valueOf(value);
  53.     }
  54.     return convertedValue;
  55.   }
  57. }

PooledDataSourceFactory\PooledDataSource 线程池

package org.apache.ibatis.datasource.pooled;

参数说明

  1. poolMaximumActiveConnections ： 最大活跃数，默认值：10
  2. poolMaximumIdleConnections ：最大空闲连接数，默认值：5
  3. poolMaximumCheckoutTime :获取连接超时等待最大（checked out）时间，默认值：20000 毫秒
  4. poolTimeToWait ： 单次获取连接 最大等待时间 默认：20000 毫秒
  5. poolMaximumLocalBadConnectionTolerance 获取连接重试次数 默认：3
  6. poolPingQuery 用于检测连接是否断开的测试语句，默认值：”NO PING QUERY SET”，一般设置为”select 1”
  7. poolPingEnabled 是否通过执行poolPingQuery 语句做检测，默认值：false，必须为true才生效
  8. poolPingConnectionsNotUsedFor 连接检测间隔时间 ，默认0。必须大0才生效

这3个参数是一起使用poolPingQuery、poolPingEnabled、poolPingConnectionsNotUsedFor

  2. package org.apache.ibatis.datasource.pooled;
  5. /**
  6.  * @author Clinton Begin
  7.  */
  8. public class PooledDataSourceFactory extends UnpooledDataSourceFactory {
  10.   public PooledDataSourceFactory() {
  11.     this.dataSource = new PooledDataSource();
  12.   }
  14. }
  18. /**
  19.  * This is a simple, synchronous, thread-safe database connection pool.
  20.  *
  21.  * @author Clinton Begin
  22.  */
  23. public class PooledDataSource implements DataSource {
  25.   private static final Log log = LogFactory.getLog(PooledDataSource.class);
  27.   private final PoolState state = new PoolState(this);
  29.   private final UnpooledDataSource dataSource;
  31.   // OPTIONAL CONFIGURATION FIELDS
  32.   protected int poolMaximumActiveConnections = 10;
  33.   protected int poolMaximumIdleConnections = 5;
  34.   protected int poolMaximumCheckoutTime = 20000;
  35.   protected int poolTimeToWait = 20000;
  36.   protected int poolMaximumLocalBadConnectionTolerance = 3;
  37.   protected String poolPingQuery = "NO PING QUERY SET";
  38.   protected boolean poolPingEnabled;
  39.   protected int poolPingConnectionsNotUsedFor;
  41.   private int expectedConnectionTypeCode;
  43.   public PooledDataSource() {
  44.     dataSource = new UnpooledDataSource();
  45.   }
  47.   public PooledDataSource(UnpooledDataSource dataSource) {
  48.     this.dataSource = dataSource;
  49.   }
  51.   public PooledDataSource(String driver, String url, String username, String password) {
  52.     dataSource = new UnpooledDataSource(driver, url, username, password);
  53.     expectedConnectionTypeCode = assembleConnectionTypeCode(dataSource.getUrl(), dataSource.getUsername(), dataSource.getPassword());
  54.   }
  56.   public PooledDataSource(String driver, String url, Properties driverProperties) {
  57.     dataSource = new UnpooledDataSource(driver, url, driverProperties);
  58.     expectedConnectionTypeCode = assembleConnectionTypeCode(dataSource.getUrl(), dataSource.getUsername(), dataSource.getPassword());
  59.   }
  61.   public PooledDataSource(ClassLoader driverClassLoader, String driver, String url, String username, String password) {
  62.     dataSource = new UnpooledDataSource(driverClassLoader, driver, url, username, password);
  63.     expectedConnectionTypeCode = assembleConnectionTypeCode(dataSource.getUrl(), dataSource.getUsername(), dataSource.getPassword());
  64.   }
  66.   public PooledDataSource(ClassLoader driverClassLoader, String driver, String url, Properties driverProperties) {
  67.     dataSource = new UnpooledDataSource(driverClassLoader, driver, url, driverProperties);
  68.     expectedConnectionTypeCode = assembleConnectionTypeCode(dataSource.getUrl(), dataSource.getUsername(), dataSource.getPassword());
  69.   }
  71.   ...
  72.   ...
  73.   ...
  74. }

数据库连接池维护操作

核心两个方法：

pushConnection

这个方法简单一看就明白了。

  1. protected void pushConnection(PooledConnection conn) throws SQLException {
  3.   synchronized (state) {
  4.     state.activeConnections.remove(conn);
  5.     if (conn.isValid()) {
  6.       if (state.idleConnections.size() < poolMaximumIdleConnections && conn.getConnectionTypeCode() == expectedConnectionTypeCode) {
  7.         state.accumulatedCheckoutTime += conn.getCheckoutTime();
  8.         if (!conn.getRealConnection().getAutoCommit()) {
  9.           conn.getRealConnection().rollback();
  10.         }
  11.         PooledConnection newConn = new PooledConnection(conn.getRealConnection(), this);
  12.         state.idleConnections.add(newConn);
  13.         newConn.setCreatedTimestamp(conn.getCreatedTimestamp());
  14.         newConn.setLastUsedTimestamp(conn.getLastUsedTimestamp());
  15.         conn.invalidate();
  16.         if (log.isDebugEnabled()) {
  17.           log.debug("Returned connection " + newConn.getRealHashCode() + " to pool.");
  18.         }
  20.         // 线程唤醒
  21.         state.notifyAll();
  22.       } else {
  23.         state.accumulatedCheckoutTime += conn.getCheckoutTime();
  24.         if (!conn.getRealConnection().getAutoCommit()) {
  25.           conn.getRealConnection().rollback();
  26.         }
  27.         conn.getRealConnection().close();
  28.         if (log.isDebugEnabled()) {
  29.           log.debug("Closed connection " + conn.getRealHashCode() + ".");
  30.         }
  31.         conn.invalidate();
  32.       }
  33.     } else {
  34.       if (log.isDebugEnabled()) {
  35.         log.debug("A bad connection (" + conn.getRealHashCode() + ") attempted to return to the pool, discarding connection.");
  36.       }
  37.       state.badConnectionCount++;
  38.     }
  39.   }
  40. }

popConnection

这个方法稍微复杂一点，这里涉及到synchronized锁机制（死循环取连接）、连接超时、超过本地错误最大连接报错

  1. private PooledConnection popConnection(String username, String password) throws SQLException {
  2.   boolean countedWait = false;
  3.   PooledConnection conn = null;
  4.   long t = System.currentTimeMillis();
  5.   int localBadConnectionCount = 0;
  7.   // 重点看一下
  8.   while (conn == null) {
  10.     // 重点看一下
  11.     synchronized (state) {
  12.       if (!state.idleConnections.isEmpty()) {
  13.         // Pool has available connection
  14.         conn = state.idleConnections.remove(0);
  15.         if (log.isDebugEnabled()) {
  16.           log.debug("Checked out connection " + conn.getRealHashCode() + " from pool.");
  17.         }
  18.       } else {
  19.         // 未超过最大连接数，直接创建新的连接
  20.         // Pool does not have available connection
  21.         if (state.activeConnections.size() < poolMaximumActiveConnections) {
  22.           // Can create new connection
  23.           conn = new PooledConnection(dataSource.getConnection(), this);
  24.           if (log.isDebugEnabled()) {
  25.             log.debug("Created connection " + conn.getRealHashCode() + ".");
  26.           }
  27.         } else {
  28.           // 连接池取一个连接，check是否超过最大连接时间，未超过就取出来使用，超过继续else
  29.           // Cannot create new connection
  30.           PooledConnection oldestActiveConnection = state.activeConnections.get(0);
  31.           long longestCheckoutTime = oldestActiveConnection.getCheckoutTime();
  32.           if (longestCheckoutTime > poolMaximumCheckoutTime) {
  33.             // Can claim overdue connection
  34.             state.claimedOverdueConnectionCount++;
  35.             state.accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime;
  36.             state.accumulatedCheckoutTime += longestCheckoutTime;
  37.             state.activeConnections.remove(oldestActiveConnection);
  38.             if (!oldestActiveConnection.getRealConnection().getAutoCommit()) {
  39.               try {
  40.                 oldestActiveConnection.getRealConnection().rollback();
  41.               } catch (SQLException e) {
  42.                 /*
  43.                    Just log a message for debug and continue to execute the following
  44.                    statement like nothing happened.
  45.                    Wrap the bad connection with a new PooledConnection, this will help
  46.                    to not interrupt current executing thread and give current thread a
  47.                    chance to join the next competition for another valid/good database
  48.                    connection. At the end of this loop, bad {@link @conn} will be set as null.
  49.                  */
  50.                 log.debug("Bad connection. Could not roll back");
  51.               }
  52.             }
  53.             conn = new PooledConnection(oldestActiveConnection.getRealConnection(), this);
  54.             conn.setCreatedTimestamp(oldestActiveConnection.getCreatedTimestamp());
  55.             conn.setLastUsedTimestamp(oldestActiveConnection.getLastUsedTimestamp());
  56.             oldestActiveConnection.invalidate();
  57.             if (log.isDebugEnabled()) {
  58.               log.debug("Claimed overdue connection " + conn.getRealHashCode() + ".");
  59.             }
  60.           } else {
  61.             // 到这里说明mysql连接池已经打满已经达到最大数，必须等待等待其他线程唤醒，state.notifyAll(); 
  62.             // 如果超过最大时间还未唤醒就累计错误连接，如果超过最大错误连接数服务会报错
  63.             // Must wait
  64.             try {
  65.               if (!countedWait) {
  66.                 state.hadToWaitCount++;
  67.                 countedWait = true;
  68.               }
  69.               if (log.isDebugEnabled()) {
  70.                 log.debug("Waiting as long as " + poolTimeToWait + " milliseconds for connection.");
  71.               }
  72.               long wt = System.currentTimeMillis();
  73.               state.wait(poolTimeToWait);
  74.               state.accumulatedWaitTime += System.currentTimeMillis() - wt;
  75.             } catch (InterruptedException e) {
  76.               // set interrupt flag
  77.               Thread.currentThread().interrupt();
  78.               break;
  79.             }
  80.           }
  81.         }
  82.       }
  83.       if (conn != null) {
  84.         // ping to server and check the connection is valid or not
  85.         if (conn.isValid()) {
  86.           if (!conn.getRealConnection().getAutoCommit()) {
  87.             conn.getRealConnection().rollback();
  88.           }
  89.           conn.setConnectionTypeCode(assembleConnectionTypeCode(dataSource.getUrl(), username, password));
  90.           conn.setCheckoutTimestamp(System.currentTimeMillis());
  91.           conn.setLastUsedTimestamp(System.currentTimeMillis());
  92.           state.activeConnections.add(conn);
  93.           state.requestCount++;
  94.           state.accumulatedRequestTime += System.currentTimeMillis() - t;
  95.         } else {
  96.           if (log.isDebugEnabled()) {
  97.             log.debug("A bad connection (" + conn.getRealHashCode() + ") was returned from the pool, getting another connection.");
  98.           }
  99.           state.badConnectionCount++;
  100.           localBadConnectionCount++;
  101.           conn = null;
  103.           // 重点分析
  104.           if (localBadConnectionCount > (poolMaximumIdleConnections + poolMaximumLocalBadConnectionTolerance)) {
  105.             if (log.isDebugEnabled()) {
  106.               log.debug("PooledDataSource: Could not get a good connection to the database.");
  107.             }
  108.             throw new SQLException("PooledDataSource: Could not get a good connection to the database.");
  109.           }
  110.         }
  111.       }
  112.     }
  114.   }
  116.   if (conn == null) {
  117.     if (log.isDebugEnabled()) {
  118.       log.debug("PooledDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
  119.     }
  120.     throw new SQLException("PooledDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
  121.   }
  123.   return conn;
  124. }

PoolState 线程池状态类

  1. package org.apache.ibatis.datasource.pooled;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. /**
  7.  * @author Clinton Begin
  8.  */
  9. public class PoolState {
  11.   protected PooledDataSource dataSource;
  13.   protected final List<PooledConnection> idleConnections = new ArrayList<>();
  14.   protected final List<PooledConnection> activeConnections = new ArrayList<>();
  15.   protected long requestCount = 0;
  16.   protected long accumulatedRequestTime = 0;
  17.   protected long accumulatedCheckoutTime = 0;
  18.   protected long claimedOverdueConnectionCount = 0;
  19.   protected long accumulatedCheckoutTimeOfOverdueConnections = 0;
  20.   protected long accumulatedWaitTime = 0;
  21.   protected long hadToWaitCount = 0;
  22.   protected long badConnectionCount = 0;
  24.   public PoolState(PooledDataSource dataSource) {
  25.     this.dataSource = dataSource;
  26.   }
  28.   public synchronized long getRequestCount() {
  29.     return requestCount;
  30.   }
  32.   public synchronized long getAverageRequestTime() {
  33.     return requestCount == 0 ? 0 : accumulatedRequestTime / requestCount;
  34.   }
  36.   public synchronized long getAverageWaitTime() {
  37.     return hadToWaitCount == 0 ? 0 : accumulatedWaitTime / hadToWaitCount;
  39.   }
  41.   public synchronized long getHadToWaitCount() {
  42.     return hadToWaitCount;
  43.   }
  45.   public synchronized long getBadConnectionCount() {
  46.     return badConnectionCount;
  47.   }
  49.   public synchronized long getClaimedOverdueConnectionCount() {
  50.     return claimedOverdueConnectionCount;
  51.   }
  53.   public synchronized long getAverageOverdueCheckoutTime() {
  54.     return claimedOverdueConnectionCount == 0 ? 0 : accumulatedCheckoutTimeOfOverdueConnections / claimedOverdueConnectionCount;
  55.   }
  57.   public synchronized long getAverageCheckoutTime() {
  58.     return requestCount == 0 ? 0 : accumulatedCheckoutTime / requestCount;
  59.   }
  61.   public synchronized int getIdleConnectionCount() {
  62.     return idleConnections.size();
  63.   }
  65.   public synchronized int getActiveConnectionCount() {
  66.     return activeConnections.size();
  67.   }
  69.   @Override
  70.   public synchronized String toString() {
  71.     StringBuilder builder = new StringBuilder();
  72.     builder.append("\n===CONFIGURATION==============================================");
  73.     builder.append("\n jdbcDriver                     ").append(dataSource.getDriver());
  74.     builder.append("\n jdbcUrl                        ").append(dataSource.getUrl());
  75.     builder.append("\n jdbcUsername                   ").append(dataSource.getUsername());
  76.     builder.append("\n jdbcPassword                   ").append(dataSource.getPassword() == null ? "NULL" : "************");
  77.     builder.append("\n poolMaxActiveConnections       ").append(dataSource.poolMaximumActiveConnections);
  78.     builder.append("\n poolMaxIdleConnections         ").append(dataSource.poolMaximumIdleConnections);
  79.     builder.append("\n poolMaxCheckoutTime            ").append(dataSource.poolMaximumCheckoutTime);
  80.     builder.append("\n poolTimeToWait                 ").append(dataSource.poolTimeToWait);
  81.     builder.append("\n poolPingEnabled                ").append(dataSource.poolPingEnabled);
  82.     builder.append("\n poolPingQuery                  ").append(dataSource.poolPingQuery);
  83.     builder.append("\n poolPingConnectionsNotUsedFor  ").append(dataSource.poolPingConnectionsNotUsedFor);
  84.     builder.append("\n ---STATUS-----------------------------------------------------");
  85.     builder.append("\n activeConnections              ").append(getActiveConnectionCount());
  86.     builder.append("\n idleConnections                ").append(getIdleConnectionCount());
  87.     builder.append("\n requestCount                   ").append(getRequestCount());
  88.     builder.append("\n averageRequestTime             ").append(getAverageRequestTime());
  89.     builder.append("\n averageCheckoutTime            ").append(getAverageCheckoutTime());
  90.     builder.append("\n claimedOverdue                 ").append(getClaimedOverdueConnectionCount());
  91.     builder.append("\n averageOverdueCheckoutTime     ").append(getAverageOverdueCheckoutTime());
  92.     builder.append("\n hadToWait                      ").append(getHadToWaitCount());
  93.     builder.append("\n averageWaitTime                ").append(getAverageWaitTime());
  94.     builder.append("\n badConnectionCount             ").append(getBadConnectionCount());
  95.     builder.append("\n===============================================================");
  96.     return builder.toString();
  97.   }
  99. }