001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 018 package org.apache.commons.pool.impl; 019 020 import org.apache.commons.pool.ObjectPool; 021 import org.apache.commons.pool.ObjectPoolFactory; 022 import org.apache.commons.pool.PoolableObjectFactory; 023 024 /** 025 * A factory for creating {@link GenericObjectPool} instances. 026 * 027 * @param <T> the type of objects held in this pool 028 * 029 * @see GenericObjectPool 030 * @see ObjectPoolFactory 031 * 032 * @author Rodney Waldhoff 033 * @version $Revision: 1222396 $ $Date: 2011-12-22 14:02:25 -0500 (Thu, 22 Dec 2011) $ 034 * @since Pool 1.0 035 */ 036 public class GenericObjectPoolFactory<T> implements ObjectPoolFactory<T> { 037 /** 038 * Create a new GenericObjectPoolFactory. 039 * 040 * @param factory the PoolableObjectFactory used by created pools. 041 * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory) 042 */ 043 public GenericObjectPoolFactory(PoolableObjectFactory<T> factory) { 044 this(factory,GenericObjectPool.DEFAULT_MAX_ACTIVE,GenericObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION,GenericObjectPool.DEFAULT_MAX_WAIT,GenericObjectPool.DEFAULT_MAX_IDLE,GenericObjectPool.DEFAULT_MIN_IDLE,GenericObjectPool.DEFAULT_TEST_ON_BORROW,GenericObjectPool.DEFAULT_TEST_ON_RETURN,GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,GenericObjectPool.DEFAULT_TEST_WHILE_IDLE); 045 } 046 047 /** 048 * Create a new GenericObjectPoolFactory. 049 * 050 * @param factory the PoolableObjectFactory used by created pools. 051 * @param config a non-<code>null</code> GenericObjectPool.Config describing the configuration. 052 * @throws NullPointerException when config is <code>null</code>. 053 * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, GenericObjectPool.Config) 054 */ 055 public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, GenericObjectPool.Config config) throws NullPointerException { 056 this(factory,config.maxActive,config.whenExhaustedAction,config.maxWait,config.maxIdle,config.minIdle,config.testOnBorrow,config.testOnReturn,config.timeBetweenEvictionRunsMillis,config.numTestsPerEvictionRun,config.minEvictableIdleTimeMillis,config.testWhileIdle,config.softMinEvictableIdleTimeMillis, config.lifo); 057 } 058 059 /** 060 * Create a new GenericObjectPoolFactory. 061 * 062 * @param factory the PoolableObjectFactory used by created pools. 063 * @param maxActive maximum number of objects that can be borrowed from created pools at one time. 064 * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int) 065 */ 066 public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, int maxActive) { 067 this(factory,maxActive,GenericObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION,GenericObjectPool.DEFAULT_MAX_WAIT,GenericObjectPool.DEFAULT_MAX_IDLE,GenericObjectPool.DEFAULT_MIN_IDLE,GenericObjectPool.DEFAULT_TEST_ON_BORROW,GenericObjectPool.DEFAULT_TEST_ON_RETURN,GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,GenericObjectPool.DEFAULT_TEST_WHILE_IDLE); 068 } 069 070 /** 071 * Create a new GenericObjectPoolFactory. 072 * 073 * @param factory the PoolableObjectFactory used by created pools. 074 * @param maxActive maximum number of objects that can be borrowed from created pools at one time. 075 * @param whenExhaustedAction the action to take when the pool is exhausted. 076 * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted. 077 * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long) 078 */ 079 public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, int maxActive, byte whenExhaustedAction, long maxWait) { 080 this(factory,maxActive,whenExhaustedAction,maxWait,GenericObjectPool.DEFAULT_MAX_IDLE,GenericObjectPool.DEFAULT_MIN_IDLE,GenericObjectPool.DEFAULT_TEST_ON_BORROW,GenericObjectPool.DEFAULT_TEST_ON_RETURN,GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,GenericObjectPool.DEFAULT_TEST_WHILE_IDLE); 081 } 082 083 /** 084 * Create a new GenericObjectPoolFactory. 085 * 086 * @param factory the PoolableObjectFactory used by created pools. 087 * @param maxActive maximum number of objects that can be borrowed from created pools at one time. 088 * @param whenExhaustedAction the action to take when the pool is exhausted. 089 * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted. 090 * @param testOnBorrow whether to validate objects before they are returned by the borrowObject. 091 * @param testOnReturn whether to validate objects after they are returned to the returnObject. 092 * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, boolean, boolean) 093 */ 094 public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, int maxActive, byte whenExhaustedAction, long maxWait, boolean testOnBorrow, boolean testOnReturn) { 095 this(factory,maxActive,whenExhaustedAction,maxWait,GenericObjectPool.DEFAULT_MAX_IDLE,GenericObjectPool.DEFAULT_MIN_IDLE,testOnBorrow,testOnReturn,GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,GenericObjectPool.DEFAULT_TEST_WHILE_IDLE); 096 } 097 098 /** 099 * Create a new GenericObjectPoolFactory. 100 * 101 * @param factory the PoolableObjectFactory used by created pools. 102 * @param maxActive maximum number of objects that can be borrowed from created pools at one time. 103 * @param whenExhaustedAction the action to take when the pool is exhausted. 104 * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted. 105 * @param maxIdle the maximum number of idle objects in my pool. 106 * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, int) 107 */ 108 public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle) { 109 this(factory,maxActive,whenExhaustedAction,maxWait,maxIdle,GenericObjectPool.DEFAULT_MIN_IDLE,GenericObjectPool.DEFAULT_TEST_ON_BORROW,GenericObjectPool.DEFAULT_TEST_ON_RETURN,GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,GenericObjectPool.DEFAULT_TEST_WHILE_IDLE); 110 } 111 112 /** 113 * Create a new GenericObjectPoolFactory. 114 * 115 * @param factory the PoolableObjectFactory used by created pools. 116 * @param maxActive maximum number of objects that can be borrowed from created pools at one time. 117 * @param whenExhaustedAction the action to take when the pool is exhausted. 118 * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted. 119 * @param maxIdle the maximum number of idle objects in my pool. 120 * @param testOnBorrow whether to validate objects before they are returned by the borrowObject. 121 * @param testOnReturn whether to validate objects after they are returned to the returnObject. 122 * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, int, boolean, boolean) 123 */ 124 public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, boolean testOnBorrow, boolean testOnReturn) { 125 this(factory,maxActive,whenExhaustedAction,maxWait,maxIdle,GenericObjectPool.DEFAULT_MIN_IDLE,testOnBorrow,testOnReturn,GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS,GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN,GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS,GenericObjectPool.DEFAULT_TEST_WHILE_IDLE); 126 } 127 128 /** 129 * Create a new GenericObjectPoolFactory. 130 * 131 * @param factory the PoolableObjectFactory used by created pools. 132 * @param maxActive maximum number of objects that can be borrowed from created pools at one time. 133 * @param whenExhaustedAction the action to take when the pool is exhausted. 134 * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted. 135 * @param maxIdle the maximum number of idle objects in my pool. 136 * @param testOnBorrow whether to validate objects before they are returned by the borrowObject. 137 * @param testOnReturn whether to validate objects after they are returned to the returnObject. 138 * @param timeBetweenEvictionRunsMillis the number of milliseconds to sleep between examining idle objects for eviction. 139 * @param numTestsPerEvictionRun the number of idle objects to examine per run within the idle object eviction thread. 140 * @param minEvictableIdleTimeMillis the minimum number of milliseconds an object can sit idle in the pool before it is eligible for eviction. 141 * @param testWhileIdle whether or not to validate objects in the idle object eviction thread. 142 * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, int, boolean, boolean, long, int, long, boolean) 143 */ 144 public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle) { 145 this(factory,maxActive,whenExhaustedAction,maxWait,maxIdle,GenericObjectPool.DEFAULT_MIN_IDLE,testOnBorrow,testOnReturn,timeBetweenEvictionRunsMillis,numTestsPerEvictionRun,minEvictableIdleTimeMillis,testWhileIdle, GenericObjectPool.DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS); 146 } 147 148 /** 149 * Create a new GenericObjectPoolFactory. 150 * 151 * @param factory the PoolableObjectFactory used by created pools. 152 * @param maxActive maximum number of objects that can be borrowed from created pools at one time. 153 * @param whenExhaustedAction the action to take when the pool is exhausted. 154 * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted. 155 * @param maxIdle the maximum number of idle objects in my pool. 156 * @param minIdle the minimum number of idle objects in my pool. 157 * @param testOnBorrow whether to validate objects before they are returned by the borrowObject. 158 * @param testOnReturn whether to validate objects after they are returned to the returnObject. 159 * @param timeBetweenEvictionRunsMillis the number of milliseconds to sleep between examining idle objects for eviction. 160 * @param numTestsPerEvictionRun the number of idle objects to examine per run within the idle object eviction thread. 161 * @param minEvictableIdleTimeMillis the minimum number of milliseconds an object can sit idle in the pool before it is eligible for eviction. 162 * @param testWhileIdle whether or not to validate objects in the idle object eviction thread. 163 * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, int, int, boolean, boolean, long, int, long, boolean) 164 */ 165 public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, int minIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle) { 166 this(factory,maxActive,whenExhaustedAction,maxWait,maxIdle,minIdle,testOnBorrow,testOnReturn,timeBetweenEvictionRunsMillis,numTestsPerEvictionRun,minEvictableIdleTimeMillis,testWhileIdle, GenericObjectPool.DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS); 167 } 168 169 /** 170 * Create a new GenericObjectPoolFactory. 171 * 172 * @param factory the PoolableObjectFactory used by created pools. 173 * @param maxActive maximum number of objects that can be borrowed from created pools at one time. 174 * @param whenExhaustedAction the action to take when the pool is exhausted. 175 * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted. 176 * @param maxIdle the maximum number of idle objects in my pool. 177 * @param minIdle the minimum number of idle objects in my pool. 178 * @param testOnBorrow whether to validate objects before they are returned by the borrowObject. 179 * @param testOnReturn whether to validate objects after they are returned to the returnObject. 180 * @param timeBetweenEvictionRunsMillis the number of milliseconds to sleep between examining idle objects for eviction. 181 * @param numTestsPerEvictionRun the number of idle objects to examine per run within the idle object eviction thread. 182 * @param minEvictableIdleTimeMillis the minimum number of milliseconds an object can sit idle in the pool before it is eligible for eviction. 183 * @param testWhileIdle whether or not to validate objects in the idle object eviction thread. 184 * @param softMinEvictableIdleTimeMillis the minimum number of milliseconds an object can sit idle in the pool before it is eligible for eviction with the extra condition that at least "minIdle" amount of object remain in the pool. 185 * @since Pool 1.3 186 * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, int, int, boolean, boolean, long, int, long, boolean, long) 187 */ 188 public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, int minIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle, long softMinEvictableIdleTimeMillis) { 189 this(factory,maxActive,whenExhaustedAction,maxWait,maxIdle,minIdle,testOnBorrow,testOnReturn,timeBetweenEvictionRunsMillis,numTestsPerEvictionRun,minEvictableIdleTimeMillis,testWhileIdle,softMinEvictableIdleTimeMillis, GenericObjectPool.DEFAULT_LIFO); 190 } 191 192 /** 193 * Create a new GenericObjectPoolFactory. 194 * 195 * @param factory the PoolableObjectFactory used by created pools. 196 * @param maxActive maximum number of objects that can be borrowed from created pools at one time. 197 * @param whenExhaustedAction the action to take when the pool is exhausted. 198 * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted. 199 * @param maxIdle the maximum number of idle objects in my pool. 200 * @param minIdle the minimum number of idle objects in my pool. 201 * @param testOnBorrow whether to validate objects before they are returned by the borrowObject. 202 * @param testOnReturn whether to validate objects after they are returned to the returnObject. 203 * @param timeBetweenEvictionRunsMillis the number of milliseconds to sleep between examining idle objects for eviction. 204 * @param numTestsPerEvictionRun the number of idle objects to examine per run within the idle object eviction thread. 205 * @param minEvictableIdleTimeMillis the minimum number of milliseconds an object can sit idle in the pool before it is eligible for eviction. 206 * @param testWhileIdle whether or not to validate objects in the idle object eviction thread. 207 * @param softMinEvictableIdleTimeMillis the minimum number of milliseconds an object can sit idle in the pool before it is eligible for eviction with the extra condition that at least "minIdle" amount of object remain in the pool. 208 * @param lifo whether or not objects are returned in last-in-first-out order from the idle object pool. 209 * @since Pool 1.4 210 * @see GenericObjectPool#GenericObjectPool(PoolableObjectFactory, int, byte, long, int, int, boolean, boolean, long, int, long, boolean, long, boolean) 211 */ 212 public GenericObjectPoolFactory(PoolableObjectFactory<T> factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, int minIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle, long softMinEvictableIdleTimeMillis, boolean lifo) { 213 _maxIdle = maxIdle; 214 _minIdle = minIdle; 215 _maxActive = maxActive; 216 _maxWait = maxWait; 217 _whenExhaustedAction = whenExhaustedAction; 218 _testOnBorrow = testOnBorrow; 219 _testOnReturn = testOnReturn; 220 _testWhileIdle = testWhileIdle; 221 _timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis; 222 _numTestsPerEvictionRun = numTestsPerEvictionRun; 223 _minEvictableIdleTimeMillis = minEvictableIdleTimeMillis; 224 _softMinEvictableIdleTimeMillis = softMinEvictableIdleTimeMillis; 225 _lifo = lifo; 226 _factory = factory; 227 } 228 229 /** 230 * {@inheritDoc} 231 */ 232 public ObjectPool<T> createPool() { 233 return new GenericObjectPool<T>(_factory,_maxActive,_whenExhaustedAction,_maxWait,_maxIdle,_minIdle,_testOnBorrow,_testOnReturn,_timeBetweenEvictionRunsMillis,_numTestsPerEvictionRun,_minEvictableIdleTimeMillis,_testWhileIdle,_softMinEvictableIdleTimeMillis,_lifo); 234 } 235 236 237 /** 238 * @return the {@link GenericObjectPool#getMaxIdle() maxIdle} setting for pools created by this factory. 239 * @since 1.5.5 240 */ 241 public int getMaxIdle() { 242 return _maxIdle; 243 } 244 245 /** 246 * @return the {@link GenericObjectPool#getMinIdle() minIdle} setting for pools created by this factory. 247 * @since 1.5.5 248 */ 249 public int getMinIdle() { 250 return _minIdle; 251 } 252 253 /** 254 * @return the {@link GenericObjectPool#getMaxActive() maxActive} setting for pools created by this factory. 255 * @since 1.5.5 256 */ 257 public int getMaxActive() { 258 return _maxActive; 259 } 260 261 /** 262 * @return the {@link GenericObjectPool#getMaxWait() maxWait} setting for pools created by this factory. 263 * @since 1.5.5 264 */ 265 public long getMaxWait() { 266 return _maxWait; 267 } 268 269 /** 270 * @return the {@link GenericObjectPool#getWhenExhaustedAction() whenExhaustedAction} setting for pools 271 * created by this factory. 272 * @since 1.5.5 273 */ 274 public byte getWhenExhaustedAction() { 275 return _whenExhaustedAction; 276 } 277 278 /** 279 * @return the {@link GenericObjectPool#getTestOnBorrow() testOnBorrow} setting for pools 280 * created by this factory. 281 * @since 1.5.5 282 */ 283 public boolean getTestOnBorrow() { 284 return _testOnBorrow; 285 } 286 287 /** 288 * @return the {@link GenericObjectPool#getTestOnReturn() testOnReturn} setting for pools 289 * created by this factory. 290 * @since 1.5.5 291 */ 292 public boolean getTestOnReturn() { 293 return _testOnReturn; 294 } 295 296 /** 297 * @return the {@link GenericObjectPool#getTestWhileIdle() testWhileIdle} setting for pools 298 * created by this factory. 299 * @since 1.5.5 300 */ 301 public boolean getTestWhileIdle() { 302 return _testWhileIdle; 303 } 304 305 /** 306 * @return the {@link GenericObjectPool#getTimeBetweenEvictionRunsMillis() timeBetweenEvictionRunsMillis} 307 * setting for pools created by this factory. 308 * @since 1.5.5 309 */ 310 public long getTimeBetweenEvictionRunsMillis() { 311 return _timeBetweenEvictionRunsMillis; 312 } 313 314 /** 315 * @return the {@link GenericObjectPool#getNumTestsPerEvictionRun() numTestsPerEvictionRun} 316 * setting for pools created by this factory. 317 * @since 1.5.5 318 */ 319 public int getNumTestsPerEvictionRun() { 320 return _numTestsPerEvictionRun; 321 } 322 323 /** 324 * @return the {@link GenericObjectPool#getMinEvictableIdleTimeMillis() minEvictableIdleTimeMillis} 325 * setting for pools created by this factory. 326 * @since 1.5.5 327 */ 328 public long getMinEvictableIdleTimeMillis() { 329 return _minEvictableIdleTimeMillis; 330 } 331 332 /** 333 * @return the {@link GenericObjectPool#getSoftMinEvictableIdleTimeMillis() softMinEvicatableIdleTimeMillis} 334 * setting for pools created by this factory. 335 * @since 1.5.5 336 */ 337 public long getSoftMinEvictableIdleTimeMillis() { 338 return _softMinEvictableIdleTimeMillis; 339 } 340 341 /** 342 * @return the {@link GenericObjectPool#getLifo() lifo} setting for pools created by this factory. 343 * @since 1.5.5 344 */ 345 public boolean getLifo() { 346 return _lifo; 347 } 348 349 /** 350 * @return the {@link PoolableObjectFactory} used by pools created by this factory 351 */ 352 public PoolableObjectFactory<T> getFactory() { 353 return _factory; 354 } 355 356 /** 357 * The {@link GenericObjectPool#getMaxIdle() maxIdle} setting for pools created by this factory. 358 * @deprecated to be removed in pool 2.0. Use {@link #getMaxIdle()}. 359 */ 360 @Deprecated 361 protected int _maxIdle = GenericObjectPool.DEFAULT_MAX_IDLE; 362 363 /** 364 * The {@link GenericObjectPool#getMinIdle() minIdle} setting for pools created by this factory. 365 * @deprecated to be removed in pool 2.0. Use {@link #getMinIdle()}. 366 */ 367 @Deprecated 368 protected int _minIdle = GenericObjectPool.DEFAULT_MIN_IDLE; 369 370 /** 371 * The {@link GenericObjectPool#getMaxActive() maxActive} setting for pools created by this factory. 372 * @deprecated to be removed in pool 2.0. Use {@link #getMaxActive()}. 373 */ 374 @Deprecated 375 protected int _maxActive = GenericObjectPool.DEFAULT_MAX_ACTIVE; 376 377 /** 378 * The {@link GenericObjectPool#getMaxWait() maxWait} setting for pools created by this factory. 379 * @deprecated to be removed in pool 2.0. Use {@link #getMaxWait()}. 380 */ 381 @Deprecated 382 protected long _maxWait = GenericObjectPool.DEFAULT_MAX_WAIT; 383 384 /** 385 * The {@link GenericObjectPool#getWhenExhaustedAction() whenExhaustedAction} setting for pools 386 * created by this factory. 387 * @deprecated to be removed in pool 2.0. Use {@link #getWhenExhaustedAction()}. 388 */ 389 @Deprecated 390 protected byte _whenExhaustedAction = GenericObjectPool.DEFAULT_WHEN_EXHAUSTED_ACTION; 391 392 /** 393 * The {@link GenericObjectPool#getTestOnBorrow() testOnBorrow} setting for pools created by this factory. 394 * @deprecated to be removed in pool 2.0. Use {@link #getTestOnBorrow()}. 395 */ 396 @Deprecated 397 protected boolean _testOnBorrow = GenericObjectPool.DEFAULT_TEST_ON_BORROW; 398 399 /** 400 * The {@link GenericObjectPool#getTestOnReturn() testOnReturn} setting for pools created by this factory. 401 * @deprecated to be removed in pool 2.0. Use {@link #getTestOnReturn()}. 402 */ 403 @Deprecated 404 protected boolean _testOnReturn = GenericObjectPool.DEFAULT_TEST_ON_RETURN; 405 406 /** 407 * The {@link GenericObjectPool#getTestWhileIdle() testWhileIdle} setting for pools created by this factory. 408 * @deprecated to be removed in pool 2.0. Use {@link #getTestWhileIdle()}. 409 */ 410 @Deprecated 411 protected boolean _testWhileIdle = GenericObjectPool.DEFAULT_TEST_WHILE_IDLE; 412 413 /** 414 * The {@link GenericObjectPool#getTimeBetweenEvictionRunsMillis() timeBetweenEvictionRunsMillis} 415 * setting for pools created by this factory. 416 * @deprecated to be removed in pool 2.0. Use {@link #getTimeBetweenEvictionRunsMillis()}. 417 */ 418 @Deprecated 419 protected long _timeBetweenEvictionRunsMillis = GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS; 420 421 /** 422 * The {@link GenericObjectPool#getNumTestsPerEvictionRun() numTestsPerEvictionRun} setting 423 * for pools created by this factory. 424 * @deprecated to be removed in pool 2.0. Use {@link #getNumTestsPerEvictionRun()}. 425 */ 426 @Deprecated 427 protected int _numTestsPerEvictionRun = GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN; 428 429 /** 430 * The {@link GenericObjectPool#getMinEvictableIdleTimeMillis() minEvictableIdleTimeMillis} 431 * setting for pools created by this factory. 432 * @deprecated to be removed in pool 2.0. Use {@link #getMinEvictableIdleTimeMillis()}. 433 */ 434 @Deprecated 435 protected long _minEvictableIdleTimeMillis = GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS; 436 437 /** 438 * The {@link GenericObjectPool#getSoftMinEvictableIdleTimeMillis() softMinEvictableIdleTimeMillis} 439 * setting for pools created by this factory. 440 * @deprecated to be removed in pool 2.0. Use {@link #getSoftMinEvictableIdleTimeMillis()}. 441 */ 442 @Deprecated 443 protected long _softMinEvictableIdleTimeMillis = GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS; 444 445 /** 446 * The {@link GenericObjectPool#getLifo() lifo} setting for pools created by this factory. 447 * @deprecated to be removed in pool 2.0. Use {@link #getLifo()}. 448 */ 449 @Deprecated 450 protected boolean _lifo = GenericObjectPool.DEFAULT_LIFO; 451 452 /** 453 * The {@link PoolableObjectFactory} used by pools created by this factory. 454 * @deprecated to be removed in pool 2.0. Use {@link #getFactory()}. 455 */ 456 @Deprecated 457 protected PoolableObjectFactory<T> _factory = null; 458 459 }