From 260b81df66ebd45c8f00b0485593e28cd5348320 Mon Sep 17 00:00:00 2001 From: wenshao Date: Mon, 20 May 2013 17:15:28 +0800 Subject: [PATCH] refactor --- .../pool/DruidDataSourceStatLoggerImpl.java | 45 +- .../druid/pool/DruidDataSourceStatValue.java | 568 ++++++++++++++++-- .../alibaba/druid/stat/JdbcSqlStatValue.java | 339 +++++++++-- 3 files changed, 844 insertions(+), 108 deletions(-) diff --git a/src/main/java/com/alibaba/druid/pool/DruidDataSourceStatLoggerImpl.java b/src/main/java/com/alibaba/druid/pool/DruidDataSourceStatLoggerImpl.java index f60a6417bc..6f0663ef07 100644 --- a/src/main/java/com/alibaba/druid/pool/DruidDataSourceStatLoggerImpl.java +++ b/src/main/java/com/alibaba/druid/pool/DruidDataSourceStatLoggerImpl.java @@ -109,7 +109,7 @@ public class DruidDataSourceStatLoggerImpl implements DruidDataSourceStatLogger if (statValue.sqlList.size() > 0) { for (JdbcSqlStatValue sqlStat : statValue.sqlList) { Map sqlStatMap = new LinkedHashMap(); - sqlStatMap.put("sql", sqlStat.sql); + sqlStatMap.put("sql", sqlStat.getSql()); if (sqlStat.getExecuteCount() > 0) { sqlStatMap.put("executeCount", sqlStat.getExecuteCount()); @@ -121,36 +121,43 @@ public class DruidDataSourceStatLoggerImpl implements DruidDataSourceStatLogger rtrim(sqlStat.getExecuteAndResultHoldHistogram())); } - if (sqlStat.executeErrorCount > 0) { - sqlStatMap.put("executeErrorCount", sqlStat.executeErrorCount); + long executeErrorCount = sqlStat.getExecuteErrorCount(); + if (executeErrorCount > 0) { + sqlStatMap.put("executeErrorCount", executeErrorCount); } - if (sqlStat.runningCount > 0) { - sqlStatMap.put("runningCount", sqlStat.runningCount); - } - sqlStatMap.put("concurrentMax", sqlStat.concurrentMax); - if (sqlStat.fetchRowCount > 0) { - sqlStatMap.put("fetchRowCount", sqlStat.fetchRowCount); - sqlStatMap.put("fetchRowCount", sqlStat.fetchRowCountMax); + int runningCount = sqlStat.getRunningCount(); + if (runningCount > 0) { + sqlStatMap.put("runningCount", runningCount); + } + + int concurrentMax = sqlStat.getConcurrentMax(); + if (concurrentMax > 0) { + sqlStatMap.put("concurrentMax", concurrentMax); + } + + if (sqlStat.getFetchRowCount() > 0) { + sqlStatMap.put("fetchRowCount", sqlStat.getFetchRowCount()); + sqlStatMap.put("fetchRowCount", sqlStat.getFetchRowCountMax()); sqlStatMap.put("fetchRowHistogram", rtrim(sqlStat.getFetchRowHistogram())); } - if (sqlStat.updateCount > 0) { - sqlStatMap.put("updateCount", sqlStat.updateCount); - sqlStatMap.put("updateCountMax", sqlStat.updateCountMax); + if (sqlStat.getUpdateCount() > 0) { + sqlStatMap.put("updateCount", sqlStat.getUpdateCount()); + sqlStatMap.put("updateCountMax", sqlStat.getUpdateCountMax()); sqlStatMap.put("updateHistogram", rtrim(sqlStat.getUpdateHistogram())); } - if (sqlStat.inTransactionCount > 0) { - sqlStatMap.put("inTransactionCount", sqlStat.inTransactionCount); + if (sqlStat.getInTransactionCount() > 0) { + sqlStatMap.put("inTransactionCount", sqlStat.getInTransactionCount()); } - if (sqlStat.clobOpenCount > 0) { - sqlStatMap.put("clobOpenCount", sqlStat.clobOpenCount); + if (sqlStat.getClobOpenCount() > 0) { + sqlStatMap.put("clobOpenCount", sqlStat.getClobOpenCount()); } - if (sqlStat.blobOpenCount > 0) { - sqlStatMap.put("blobOpenCount", sqlStat.blobOpenCount); + if (sqlStat.getBlobOpenCount() > 0) { + sqlStatMap.put("blobOpenCount", sqlStat.getBlobOpenCount()); } sqlList.add(sqlStatMap); diff --git a/src/main/java/com/alibaba/druid/pool/DruidDataSourceStatValue.java b/src/main/java/com/alibaba/druid/pool/DruidDataSourceStatValue.java index 5f7f717962..58e092371e 100644 --- a/src/main/java/com/alibaba/druid/pool/DruidDataSourceStatValue.java +++ b/src/main/java/com/alibaba/druid/pool/DruidDataSourceStatValue.java @@ -22,61 +22,61 @@ import com.alibaba.druid.stat.JdbcSqlStatValue; public class DruidDataSourceStatValue { - public String name; - public String dbType; - public String driverClassName; - public String url; - public String userName; - public List filterClassNames; - public boolean removeAbandoned; + protected String name; + protected String dbType; + protected String driverClassName; + protected String url; + protected String userName; + protected List filterClassNames; + protected boolean removeAbandoned; - public int initialSize; - public int minIdle; - public int maxActive; - public int queryTimeout; - public int transactionQueryTimeout; - public int loginTimeout; - public String validConnectionCheckerClassName; - public String exceptionSorterClassName; - public boolean testOnBorrow; - public boolean testOnReturn; - public boolean testWhileIdle; - public boolean defaultAutoCommit; - public boolean defaultReadOnly; - public Integer defaultTransactionIsolation; + protected int initialSize; + protected int minIdle; + protected int maxActive; + protected int queryTimeout; + protected int transactionQueryTimeout; + protected int loginTimeout; + protected String validConnectionCheckerClassName; + protected String exceptionSorterClassName; + protected boolean testOnBorrow; + protected boolean testOnReturn; + protected boolean testWhileIdle; + protected boolean defaultAutoCommit; + protected boolean defaultReadOnly; + protected Integer defaultTransactionIsolation; - public int activeCount; - public int activePeak; - public long activePeakTime; + protected int activeCount; + protected int activePeak; + protected long activePeakTime; - public int poolingCount; - public int poolingPeak; - public long poolingPeakTime; + protected int poolingCount; + protected int poolingPeak; + protected long poolingPeakTime; - public long connectCount; - public long closeCount; - public long waitThreadCount; - public long notEmptyWaitCount; - public long notEmptyWaitNanos; + protected long connectCount; + protected long closeCount; + protected long waitThreadCount; + protected long notEmptyWaitCount; + protected long notEmptyWaitNanos; - public long logicConnectErrorCount; - public long physicalConnectCount; - public long physicalCloseCount; - public long physicalConnectErrorCount; - public long executeCount; - public long errorCount; - public long commitCount; - public long rollbackCount; - public long pstmtCacheHitCount; - public long pstmtCacheMissCount; - public long startTransactionCount; - public long[] transactionHistogram; - public long[] connectionHoldTimeHistogram; + protected long logicConnectErrorCount; + protected long physicalConnectCount; + protected long physicalCloseCount; + protected long physicalConnectErrorCount; + protected long executeCount; + protected long errorCount; + protected long commitCount; + protected long rollbackCount; + protected long pstmtCacheHitCount; + protected long pstmtCacheMissCount; + protected long startTransactionCount; + protected long[] transactionHistogram; + protected long[] connectionHoldTimeHistogram; - public long clobOpenCount; - public long blobOpenCount; + protected long clobOpenCount; + protected long blobOpenCount; - public List sqlList; + protected List sqlList; public Date getPoolingPeakTime() { if (poolingPeakTime <= 0) { @@ -97,4 +97,476 @@ public class DruidDataSourceStatValue { public long getNotEmptyWaitMillis() { return notEmptyWaitNanos / (1000 * 1000); } + + + public String getName() { + return name; + } + + + public void setName(String name) { + this.name = name; + } + + + public String getDbType() { + return dbType; + } + + + public void setDbType(String dbType) { + this.dbType = dbType; + } + + + public String getDriverClassName() { + return driverClassName; + } + + + public void setDriverClassName(String driverClassName) { + this.driverClassName = driverClassName; + } + + + public String getUrl() { + return url; + } + + + public void setUrl(String url) { + this.url = url; + } + + + public String getUserName() { + return userName; + } + + + public void setUserName(String userName) { + this.userName = userName; + } + + + public List getFilterClassNames() { + return filterClassNames; + } + + + public void setFilterClassNames(List filterClassNames) { + this.filterClassNames = filterClassNames; + } + + + public boolean isRemoveAbandoned() { + return removeAbandoned; + } + + + public void setRemoveAbandoned(boolean removeAbandoned) { + this.removeAbandoned = removeAbandoned; + } + + + public int getInitialSize() { + return initialSize; + } + + + public void setInitialSize(int initialSize) { + this.initialSize = initialSize; + } + + + public int getMinIdle() { + return minIdle; + } + + + public void setMinIdle(int minIdle) { + this.minIdle = minIdle; + } + + + public int getMaxActive() { + return maxActive; + } + + + public void setMaxActive(int maxActive) { + this.maxActive = maxActive; + } + + + public int getQueryTimeout() { + return queryTimeout; + } + + + public void setQueryTimeout(int queryTimeout) { + this.queryTimeout = queryTimeout; + } + + + public int getTransactionQueryTimeout() { + return transactionQueryTimeout; + } + + + public void setTransactionQueryTimeout(int transactionQueryTimeout) { + this.transactionQueryTimeout = transactionQueryTimeout; + } + + + public int getLoginTimeout() { + return loginTimeout; + } + + + public void setLoginTimeout(int loginTimeout) { + this.loginTimeout = loginTimeout; + } + + + public String getValidConnectionCheckerClassName() { + return validConnectionCheckerClassName; + } + + + public void setValidConnectionCheckerClassName(String validConnectionCheckerClassName) { + this.validConnectionCheckerClassName = validConnectionCheckerClassName; + } + + + public String getExceptionSorterClassName() { + return exceptionSorterClassName; + } + + + public void setExceptionSorterClassName(String exceptionSorterClassName) { + this.exceptionSorterClassName = exceptionSorterClassName; + } + + + public boolean isTestOnBorrow() { + return testOnBorrow; + } + + + public void setTestOnBorrow(boolean testOnBorrow) { + this.testOnBorrow = testOnBorrow; + } + + + public boolean isTestOnReturn() { + return testOnReturn; + } + + + public void setTestOnReturn(boolean testOnReturn) { + this.testOnReturn = testOnReturn; + } + + + public boolean isTestWhileIdle() { + return testWhileIdle; + } + + + public void setTestWhileIdle(boolean testWhileIdle) { + this.testWhileIdle = testWhileIdle; + } + + + public boolean isDefaultAutoCommit() { + return defaultAutoCommit; + } + + + public void setDefaultAutoCommit(boolean defaultAutoCommit) { + this.defaultAutoCommit = defaultAutoCommit; + } + + + public boolean isDefaultReadOnly() { + return defaultReadOnly; + } + + + public void setDefaultReadOnly(boolean defaultReadOnly) { + this.defaultReadOnly = defaultReadOnly; + } + + + public Integer getDefaultTransactionIsolation() { + return defaultTransactionIsolation; + } + + + public void setDefaultTransactionIsolation(Integer defaultTransactionIsolation) { + this.defaultTransactionIsolation = defaultTransactionIsolation; + } + + + public int getActiveCount() { + return activeCount; + } + + + public void setActiveCount(int activeCount) { + this.activeCount = activeCount; + } + + + public int getActivePeak() { + return activePeak; + } + + + public void setActivePeak(int activePeak) { + this.activePeak = activePeak; + } + + + public int getPoolingCount() { + return poolingCount; + } + + + public void setPoolingCount(int poolingCount) { + this.poolingCount = poolingCount; + } + + + public int getPoolingPeak() { + return poolingPeak; + } + + + public void setPoolingPeak(int poolingPeak) { + this.poolingPeak = poolingPeak; + } + + + public long getConnectCount() { + return connectCount; + } + + + public void setConnectCount(long connectCount) { + this.connectCount = connectCount; + } + + + public long getCloseCount() { + return closeCount; + } + + + public void setCloseCount(long closeCount) { + this.closeCount = closeCount; + } + + + public long getWaitThreadCount() { + return waitThreadCount; + } + + + public void setWaitThreadCount(long waitThreadCount) { + this.waitThreadCount = waitThreadCount; + } + + + public long getNotEmptyWaitCount() { + return notEmptyWaitCount; + } + + + public void setNotEmptyWaitCount(long notEmptyWaitCount) { + this.notEmptyWaitCount = notEmptyWaitCount; + } + + + public long getNotEmptyWaitNanos() { + return notEmptyWaitNanos; + } + + + public void setNotEmptyWaitNanos(long notEmptyWaitNanos) { + this.notEmptyWaitNanos = notEmptyWaitNanos; + } + + + public long getLogicConnectErrorCount() { + return logicConnectErrorCount; + } + + + public void setLogicConnectErrorCount(long logicConnectErrorCount) { + this.logicConnectErrorCount = logicConnectErrorCount; + } + + + public long getPhysicalConnectCount() { + return physicalConnectCount; + } + + + public void setPhysicalConnectCount(long physicalConnectCount) { + this.physicalConnectCount = physicalConnectCount; + } + + + public long getPhysicalCloseCount() { + return physicalCloseCount; + } + + + public void setPhysicalCloseCount(long physicalCloseCount) { + this.physicalCloseCount = physicalCloseCount; + } + + + public long getPhysicalConnectErrorCount() { + return physicalConnectErrorCount; + } + + + public void setPhysicalConnectErrorCount(long physicalConnectErrorCount) { + this.physicalConnectErrorCount = physicalConnectErrorCount; + } + + + public long getExecuteCount() { + return executeCount; + } + + + public void setExecuteCount(long executeCount) { + this.executeCount = executeCount; + } + + + public long getErrorCount() { + return errorCount; + } + + + public void setErrorCount(long errorCount) { + this.errorCount = errorCount; + } + + + public long getCommitCount() { + return commitCount; + } + + + public void setCommitCount(long commitCount) { + this.commitCount = commitCount; + } + + + public long getRollbackCount() { + return rollbackCount; + } + + + public void setRollbackCount(long rollbackCount) { + this.rollbackCount = rollbackCount; + } + + + public long getPstmtCacheHitCount() { + return pstmtCacheHitCount; + } + + + public void setPstmtCacheHitCount(long pstmtCacheHitCount) { + this.pstmtCacheHitCount = pstmtCacheHitCount; + } + + + public long getPstmtCacheMissCount() { + return pstmtCacheMissCount; + } + + + public void setPstmtCacheMissCount(long pstmtCacheMissCount) { + this.pstmtCacheMissCount = pstmtCacheMissCount; + } + + + public long getStartTransactionCount() { + return startTransactionCount; + } + + + public void setStartTransactionCount(long startTransactionCount) { + this.startTransactionCount = startTransactionCount; + } + + + public long[] getTransactionHistogram() { + return transactionHistogram; + } + + + public void setTransactionHistogram(long[] transactionHistogram) { + this.transactionHistogram = transactionHistogram; + } + + + public long[] getConnectionHoldTimeHistogram() { + return connectionHoldTimeHistogram; + } + + + public void setConnectionHoldTimeHistogram(long[] connectionHoldTimeHistogram) { + this.connectionHoldTimeHistogram = connectionHoldTimeHistogram; + } + + + public long getClobOpenCount() { + return clobOpenCount; + } + + + public void setClobOpenCount(long clobOpenCount) { + this.clobOpenCount = clobOpenCount; + } + + + public long getBlobOpenCount() { + return blobOpenCount; + } + + + public void setBlobOpenCount(long blobOpenCount) { + this.blobOpenCount = blobOpenCount; + } + + + public List getSqlList() { + return sqlList; + } + + + public void setSqlList(List sqlList) { + this.sqlList = sqlList; + } + + + public void setActivePeakTime(long activePeakTime) { + this.activePeakTime = activePeakTime; + } + + + public void setPoolingPeakTime(long poolingPeakTime) { + this.poolingPeakTime = poolingPeakTime; + } + + } diff --git a/src/main/java/com/alibaba/druid/stat/JdbcSqlStatValue.java b/src/main/java/com/alibaba/druid/stat/JdbcSqlStatValue.java index 751aafb0cf..a7e5cc2241 100644 --- a/src/main/java/com/alibaba/druid/stat/JdbcSqlStatValue.java +++ b/src/main/java/com/alibaba/druid/stat/JdbcSqlStatValue.java @@ -17,57 +17,57 @@ package com.alibaba.druid.stat; public class JdbcSqlStatValue { - public String sql; - public long id; - public String dataSource; - public long executeLastStartTime; + protected String sql; + protected long id; + protected String dataSource; + protected long executeLastStartTime; - public long executeBatchSizeTotal; - public int executeBatchSizeMax; + protected long executeBatchSizeTotal; + protected int executeBatchSizeMax; - public long executeSuccessCount; - public long executeSpanNanoTotal; - public long executeSpanNanoMax; - public int runningCount; - public int concurrentMax; - public long resultSetHoldTimeNano; - public long executeAndResultSetHoldTime; + protected long executeSuccessCount; + protected long executeSpanNanoTotal; + protected long executeSpanNanoMax; + protected int runningCount; + protected int concurrentMax; + protected long resultSetHoldTimeNano; + protected long executeAndResultSetHoldTime; - public String name; - public String file; - public String dbType; + protected String name; + protected String file; + protected String dbType; - public long executeNanoSpanMaxOccurTime; + protected long executeNanoSpanMaxOccurTime; - public long executeErrorCount; - public Throwable executeErrorLast; - public long executeErrorLastTime; + protected long executeErrorCount; + protected Throwable executeErrorLast; + protected long executeErrorLastTime; - public long updateCount; - public long updateCountMax; - public long fetchRowCount; - public long fetchRowCountMax; + protected long updateCount; + protected long updateCountMax; + protected long fetchRowCount; + protected long fetchRowCountMax; - public long inTransactionCount; + protected long inTransactionCount; - public String lastSlowParameters; + protected String lastSlowParameters; - public long clobOpenCount; - public long blobOpenCount; - public long readStringLength; - public long readBytesLength; + protected long clobOpenCount; + protected long blobOpenCount; + protected long readStringLength; + protected long readBytesLength; - public long inputStreamOpenCount; - public long readerOpenCount; + protected long inputStreamOpenCount; + protected long readerOpenCount; - public long histogram_0_1; - public long histogram_1_10; - public int histogram_10_100; - public int histogram_100_1000; - public int histogram_1000_10000; - public int histogram_10000_100000; - public int histogram_100000_1000000; - public int histogram_1000000_more; + protected long histogram_0_1; + protected long histogram_1_10; + protected int histogram_10_100; + protected int histogram_100_1000; + protected int histogram_1000_10000; + protected int histogram_10000_100000; + protected int histogram_100000_1000000; + protected int histogram_1000000_more; public long[] getExecuteHistogram() { return new long[] { histogram_0_1, // @@ -143,8 +143,265 @@ public class JdbcSqlStatValue { public long getExecuteMillisMax() { return executeSpanNanoMax / (1000 * 1000); } - + public long getExecuteMillisTotal() { return executeSpanNanoTotal / (1000 * 1000); } + + public String getSql() { + return sql; + } + + public void setSql(String sql) { + this.sql = sql; + } + + public long getId() { + return id; + } + + public void setId(long id) { + this.id = id; + } + + public String getDataSource() { + return dataSource; + } + + public void setDataSource(String dataSource) { + this.dataSource = dataSource; + } + + public long getExecuteLastStartTime() { + return executeLastStartTime; + } + + public void setExecuteLastStartTime(long executeLastStartTime) { + this.executeLastStartTime = executeLastStartTime; + } + + public long getExecuteBatchSizeTotal() { + return executeBatchSizeTotal; + } + + public void setExecuteBatchSizeTotal(long executeBatchSizeTotal) { + this.executeBatchSizeTotal = executeBatchSizeTotal; + } + + public int getExecuteBatchSizeMax() { + return executeBatchSizeMax; + } + + public void setExecuteBatchSizeMax(int executeBatchSizeMax) { + this.executeBatchSizeMax = executeBatchSizeMax; + } + + public long getExecuteSuccessCount() { + return executeSuccessCount; + } + + public void setExecuteSuccessCount(long executeSuccessCount) { + this.executeSuccessCount = executeSuccessCount; + } + + public long getExecuteSpanNanoTotal() { + return executeSpanNanoTotal; + } + + public void setExecuteSpanNanoTotal(long executeSpanNanoTotal) { + this.executeSpanNanoTotal = executeSpanNanoTotal; + } + + public long getExecuteSpanNanoMax() { + return executeSpanNanoMax; + } + + public void setExecuteSpanNanoMax(long executeSpanNanoMax) { + this.executeSpanNanoMax = executeSpanNanoMax; + } + + public int getRunningCount() { + return runningCount; + } + + public void setRunningCount(int runningCount) { + this.runningCount = runningCount; + } + + public int getConcurrentMax() { + return concurrentMax; + } + + public void setConcurrentMax(int concurrentMax) { + this.concurrentMax = concurrentMax; + } + + public long getResultSetHoldTimeNano() { + return resultSetHoldTimeNano; + } + + public void setResultSetHoldTimeNano(long resultSetHoldTimeNano) { + this.resultSetHoldTimeNano = resultSetHoldTimeNano; + } + + public long getExecuteAndResultSetHoldTime() { + return executeAndResultSetHoldTime; + } + + public void setExecuteAndResultSetHoldTime(long executeAndResultSetHoldTime) { + this.executeAndResultSetHoldTime = executeAndResultSetHoldTime; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getFile() { + return file; + } + + public void setFile(String file) { + this.file = file; + } + + public String getDbType() { + return dbType; + } + + public void setDbType(String dbType) { + this.dbType = dbType; + } + + public long getExecuteNanoSpanMaxOccurTime() { + return executeNanoSpanMaxOccurTime; + } + + public void setExecuteNanoSpanMaxOccurTime(long executeNanoSpanMaxOccurTime) { + this.executeNanoSpanMaxOccurTime = executeNanoSpanMaxOccurTime; + } + + public long getExecuteErrorCount() { + return executeErrorCount; + } + + public void setExecuteErrorCount(long executeErrorCount) { + this.executeErrorCount = executeErrorCount; + } + + public Throwable getExecuteErrorLast() { + return executeErrorLast; + } + + public void setExecuteErrorLast(Throwable executeErrorLast) { + this.executeErrorLast = executeErrorLast; + } + + public long getExecuteErrorLastTime() { + return executeErrorLastTime; + } + + public void setExecuteErrorLastTime(long executeErrorLastTime) { + this.executeErrorLastTime = executeErrorLastTime; + } + + public long getUpdateCount() { + return updateCount; + } + + public void setUpdateCount(long updateCount) { + this.updateCount = updateCount; + } + + public long getUpdateCountMax() { + return updateCountMax; + } + + public void setUpdateCountMax(long updateCountMax) { + this.updateCountMax = updateCountMax; + } + + public long getFetchRowCount() { + return fetchRowCount; + } + + public void setFetchRowCount(long fetchRowCount) { + this.fetchRowCount = fetchRowCount; + } + + public long getFetchRowCountMax() { + return fetchRowCountMax; + } + + public void setFetchRowCountMax(long fetchRowCountMax) { + this.fetchRowCountMax = fetchRowCountMax; + } + + public long getInTransactionCount() { + return inTransactionCount; + } + + public void setInTransactionCount(long inTransactionCount) { + this.inTransactionCount = inTransactionCount; + } + + public String getLastSlowParameters() { + return lastSlowParameters; + } + + public void setLastSlowParameters(String lastSlowParameters) { + this.lastSlowParameters = lastSlowParameters; + } + + public long getClobOpenCount() { + return clobOpenCount; + } + + public void setClobOpenCount(long clobOpenCount) { + this.clobOpenCount = clobOpenCount; + } + + public long getBlobOpenCount() { + return blobOpenCount; + } + + public void setBlobOpenCount(long blobOpenCount) { + this.blobOpenCount = blobOpenCount; + } + + public long getReadStringLength() { + return readStringLength; + } + + public void setReadStringLength(long readStringLength) { + this.readStringLength = readStringLength; + } + + public long getReadBytesLength() { + return readBytesLength; + } + + public void setReadBytesLength(long readBytesLength) { + this.readBytesLength = readBytesLength; + } + + public long getInputStreamOpenCount() { + return inputStreamOpenCount; + } + + public void setInputStreamOpenCount(long inputStreamOpenCount) { + this.inputStreamOpenCount = inputStreamOpenCount; + } + + public long getReaderOpenCount() { + return readerOpenCount; + } + + public void setReaderOpenCount(long readerOpenCount) { + this.readerOpenCount = readerOpenCount; + } + }