All Downloads are FREE. Search and download functionalities are using the official Maven repository.

src.com.ibm.as400.access.ConnectionPool Maven / Gradle / Ivy

There is a newer version: 11.1
Show newest version
///////////////////////////////////////////////////////////////////////////////
//                                                                             
// JTOpen (IBM Toolbox for Java - OSS version)                              
//                                                                             
// Filename: ConnectionPool.java
//                                                                             
// The source code contained herein is licensed under the IBM Public License   
// Version 1.0, which has been approved by the Open Source Initiative.         
// Copyright (C) 1997-2003 International Business Machines Corporation and     
// others. All rights reserved.                                                
//                                                                             
///////////////////////////////////////////////////////////////////////////////

package com.ibm.as400.access;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.beans.PropertyVetoException;
import java.io.Serializable;
import java.io.IOException;
import java.io.ObjectInputStream;

/**
*  Represents a pool of connections to the system.
*
*  

ConnectionPool objects generate the following events: *

    *
  • {@link ConnectionPoolEvent ConnectionPoolEvent} - The events fired are: *
      *
    • {@link ConnectionPoolEvent#CONNECTION_CREATED CONNECTION_CREATED}
    • *
    • {@link ConnectionPoolEvent#CONNECTION_EXPIRED CONNECTION_EXPIRED}
    • *
    • {@link ConnectionPoolEvent#CONNECTION_POOL_CLOSED CONNECTION_POOL_CLOSED}
    • *
    • {@link ConnectionPoolEvent#CONNECTION_RELEASED CONNECTION_RELEASED}
    • *
    • {@link ConnectionPoolEvent#CONNECTION_RETURNED CONNECTION_RETURNED}
    • *
    • {@link ConnectionPoolEvent#MAINTENANCE_THREAD_RUN MAINTENANCE_THREAD_RUN}
    • *
    *
  • *
  • PropertyChangeEvent
  • *
**/ public abstract class ConnectionPool implements Serializable { static final long serialVersionUID = 4L; /** Indicates that the CCSID used for new connections is the same as the system default CCSID. **/ static final int CCSID_DEFAULT = ConnectionPoolProperties.CCSID_DEFAULT; ConnectionPoolProperties properties_ = new ConnectionPoolProperties(); private boolean inUse_ = false; private boolean isRunMaintenance_ = true; //@A4D private boolean useThreads_ = true; transient PoolMaintenance maintenance_; // Maintenance thread. transient PropertyChangeSupport changes_; transient ConnectionPoolEventSupport poolListeners_; // Manage the ConnectionPoolEvent listeners. public ConnectionPool() { //@CRS properties_ = new ConnectionPoolProperties(); //@CRS initializeTransient(); } /** * Adds a ConnectionPoolListener. * @param listener The ConnectionPoolListener. * @see #removeConnectionPoolListener **/ public void addConnectionPoolListener(ConnectionPoolListener listener) { synchronized(this) { if (poolListeners_ == null) poolListeners_ = new ConnectionPoolEventSupport(); } poolListeners_.addConnectionPoolListener(listener); } /** * Adds a PropertyChangeListener. * @param listener The PropertyChangeListener. * @see #removePropertyChangeListener **/ public void addPropertyChangeListener(PropertyChangeListener listener) { if (listener == null) throw new NullPointerException("listener"); synchronized(this) { if (changes_ == null) changes_ = new PropertyChangeSupport(this); changes_.addPropertyChangeListener(listener); properties_.addPropertyChangeListener(listener); } } /** * Removes any connections that have exceeded the maximum inactivity time, replaces any * connections that have aged past maximum usage or maximum lifetime, and removes any * connections that have been in use too long. **/ abstract void cleanupConnections(); /** * Closes the connection pool. * @exception ConnectionPoolException If a pool error occurs. **/ public abstract void close() throws ConnectionPoolException; /** * Closes the connection pool if not explicitly closed by the caller. * @exception Throwable If an error occurs. **/ protected void finalize() throws Throwable { // Terminate the maintenance thread, if it's still alive. if (maintenance_ != null && maintenance_.isAlive()) { maintenance_.shutdown(); } super.finalize(); } /** * Returns the CCSID that is used when creating connections. * The default value is the system default CCSID as determined by the AS400 class. * @return The CCSID, or {@link #CCSID_DEFAULT CCSID_DEFAULT} if the system default CCSID is used. **/ int getCCSID() { return properties_.getCCSID(); } /** * Returns the time interval for how often the maintenance daemon is run. * The default value is 300000 milliseconds (5 minutes). * @return Number of milliseconds. **/ public long getCleanupInterval() { return properties_.getCleanupInterval(); } /** * Returns the maximum number of connections. * The default value is -1 indicating no limit to the number of connections. * @return Maximum number of connections. **/ public int getMaxConnections() { return properties_.getMaxConnections(); } /** * Returns the maximum amount of inactive time before an available connection is closed. * The maintenance daemon closes the connection if the threshold is reached. * The default value is 60 minutes. A value of -1 indicates that there is no limit. * @return Number of milliseconds. **/ public long getMaxInactivity() { return properties_.getMaxInactivity(); } /** * Returns the maximum life for an available connection. * The maintenance daemon closes the available connection if the threshold is reached. * The default value is a 24 hour limit. A value of -1 indicates that there is no limit. * @return Number of milliseconds. **/ public long getMaxLifetime() { return properties_.getMaxLifetime(); } /** * Returns the maximum number of times a connection can be used before it is replaced in the pool. * The default value is -1. A value of -1 indicates that there is no limit. * @return Maximum usage count. **/ public int getMaxUseCount() { return properties_.getMaxUseCount(); } /** * Returns the maximum amount of time a connection can be in use before it is closed and returned to the pool. * The default value is -1 indicating that there is no limit. * @return Number of milliseconds. **/ public long getMaxUseTime() { return properties_.getMaxUseTime(); } /** * Returns the connection pool properties used by the maintenance daemon. * @return The ConnectionPoolProperties object. **/ //@CRS ConnectionPoolProperties getProperties() //@CRS { //@CRS return properties_; //@CRS } /** * Initializes the transient data. **/ private void initializeTransient() { //@CRS changes_ = new PropertyChangeSupport(this); //@CRS poolListeners_ = new ConnectionPoolEventSupport(); // addPropertyChangeListener(new PropertyChangeListener() //@A2A // { // public void propertyChange(PropertyChangeEvent event) // { // String property = event.getPropertyName(); // if (property.equals("cleanupInterval")) // { // runMaintenance(false); // } // else if (property.equals("maxConnections")) // { // boolean reduced = false; // Integer newValue = (Integer)event.getNewValue(); // Integer oldValue = (Integer)event.getOldValue(); // if (oldValue.intValue() == -1 || oldValue.intValue() > newValue.intValue()) //@A2C // reduced = true; // runMaintenance(reduced); // } // else if (property.equals("runMaintenance")) // { // Boolean newValue = (Boolean)event.getNewValue(); // if (!newValue.booleanValue() && maintenance_ != null && maintenance_.isRunning()) // maintenance_.setRunning(false); // if (newValue.booleanValue() && maintenance_ != null && !maintenance_.isRunning()) //@A3A // maintenance_.setRunning(true); //@A3A // } // } // }); } /** * Indicates whether the pool is in use. * Used for checking state conditions. The default is false. * @return true if the pool is in use; false otherwise. **/ synchronized boolean isInUse() { return inUse_; } /** * Indicates whether connections are pretested before they are allocated to requesters. * Pretesting verifies that the connection is still valid. * By default, connections are not pretested. *

Note: The pretestConnections property is not fully effective until IBM i 7.1. * @return true if connections are pretested before being allocated; false otherwise. * @see AS400#isConnectionAlive **/ public boolean isPretestConnections() { return properties_.isPretestConnections(); } /** * Indicates whether the maintenance thread is used to cleanup expired connections. * The default is true. * @return true if expired connection are cleaned up by the maintenance thread; false otherwise. **/ public boolean isRunMaintenance() { return isRunMaintenance_; } /** * Indicates whether threads are used in communication with the host servers and for running * maintenance. This property affects AS400ConnectionPool and not AS400JDBCConnectionPool * which is written to the JDBC specification. * The default value is true. * @return true if threads are used; false otherwise. **/ public boolean isThreadUsed() { //@A4D return useThreads_; return properties_.isThreadUsed(); //@A4A } /** * Deserializes and initializes transient data. * @exception IOException If a file I/O error occurs. * @exception ClassNotFoundException If a file error occurs. **/ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { in.defaultReadObject(); initializeTransient(); } /** * Removes a PropertyChangeListener. * @param listener The PropertyChangeListener. * @see #addPropertyChangeListener **/ public void removePropertyChangeListener(PropertyChangeListener listener) { if (listener == null) throw new NullPointerException("listener"); if (changes_ != null) changes_.removePropertyChangeListener(listener); properties_.removePropertyChangeListener(listener); } /** * Removes a ConnectionPoolListener. * @param listener The ConnectionPoolListener. * @see #addConnectionPoolListener **/ public void removeConnectionPoolListener(ConnectionPoolListener listener) { if (poolListeners_ != null) poolListeners_.removeConnectionPoolListener(listener); } //@A2A /** * Run cleanupConnections(). * @param reduced true if need to check current num connections; false otherwise. **/ abstract void runMaintenance(boolean reduced); /** * Sets the CCSID to use when creating connections. * The default value is the system default CCSID as determined by the AS400 class. * @param ccsid The CCSID to use for connections in the pool, or {@link #CCSID_DEFAULT CCSID_DEFAULT} to indicate that the system default CCSID should be used. **/ void setCCSID(int ccsid) { properties_.setCCSID(ccsid); } /** * Sets the time interval for how often the maintenance daemon is run. * The default value is 300000 milliseconds or 5 minutes. * @param cleanupInterval The number of milliseconds. **/ public void setCleanupInterval(long cleanupInterval) { properties_.setCleanupInterval(cleanupInterval); runMaintenance(false); //@CRS if (getCleanupInterval() == 0) if (cleanupInterval == 0) setRunMaintenance(false); } /** * Sets whether the pool is in use. * Used for setting state conditions. * @param inUse true if the pool is in use; false otherwise. **/ synchronized void setInUse(boolean inUse) { inUse_ = inUse; } /** * Sets the maximum number of connections. * The default value is -1 indicating no limit to the number of connections. * @param maxConnections Maximum number of connections. **/ public void setMaxConnections(int maxConnections) { int oldValue = getMaxConnections(); properties_.setMaxConnections(maxConnections); boolean reduced = (oldValue == -1 || oldValue > maxConnections); runMaintenance(reduced); } /** * Sets the maximum amount of inactive time before an available connection is closed. * The maintenance daemon closes the connection if the threshold is reached. * The default value is 60 minutes. A value of -1 indicates that there is no limit. * @param maxInactivity Number of milliseconds. **/ public void setMaxInactivity(long maxInactivity) { properties_.setMaxInactivity(maxInactivity); } /** * Sets the maximum life for an available connection. * The maintenance daemon closes the available connection if the threshold is reached. * The default value is a 24 hour limit. A value of -1 indicates that there is no limit. * @param maxLifetime Number of milliseconds. **/ public void setMaxLifetime(long maxLifetime) { properties_.setMaxLifetime(maxLifetime); } /** * Sets the maximum number of times a connection can be used before it is replaced in the pool. * The default value is -1. A value of -1 indicates that there is no limit. * @param maxUseCount Maximum usage count. **/ public void setMaxUseCount(int maxUseCount) { properties_.setMaxUseCount(maxUseCount); } /** * Sets the maximum amount of time a connection can be in use before it is closed and returned to the pool. * The default value is -1 indicating that there is no limit. * @param maxUseTime Number of milliseconds. **/ public void setMaxUseTime(long maxUseTime) { properties_.setMaxUseTime(maxUseTime); } /** * Sets whether connections are pretested before they are allocated to requesters. * Pretesting verifies that the connection is still valid. * By default, connections are not pretested. *

Note: The pretestConnections property is not fully effective until IBM i 7.1. * @param pretest If connections are pretested before being allocated. * @see AS400#isConnectionAlive **/ public void setPretestConnections(boolean pretest) { properties_.setPretestConnections(pretest); } /** * Sets whether the Toolbox does periodic maintenance on the connection pool to clean up * expired connections. If setThreadUsed is true, the Toolbox starts an extra thread to * perform maintenance. If setThreadUsed is false, the Toolbox will perform maintenance * on the user's thread when it uses the connection pool. * This method and {@link #setThreadUsed setThreadUsed} can be set * in interchangeable order. * The default value is true. * @param cleanup If expired connections are cleaned up by the maintenance daemon. **/ public void setRunMaintenance(boolean cleanup) { String property = "runMaintenance"; // Boolean oldValue = new Boolean(isRunMaintenance_); // Boolean newValue = new Boolean(cleanup); boolean oldValue = isRunMaintenance_; isRunMaintenance_ = cleanup; if (changes_ != null) changes_.firePropertyChange(property, new Boolean(oldValue), new Boolean(cleanup)); if (maintenance_ != null) { //@CRS: We don't care if maintenance is currently running or not, // we just want to tell it to either run or not, from now on. maintenance_.setRunning(cleanup); } } /** * Sets whether the IBM Toolbox for Java uses additional threads. * The Toolbox creates additional threads for various purposes, including: *

    *
  • for communication with the host servers; and
  • *
  • for running pool maintenance.
  • *
* Letting the IBM Toolbox for Java use additional threads will be beneficial * to performance, but turning threads off may be necessary if your application needs to be compliant * with the Enterprise Java Beans specification. The threadUsed property cannot be changed once * the pool is in use. This property affects AS400ConnectionPool and not AS400JDBCConnectionPool, * which is written to the JDBC specification. This method and * {@link #setRunMaintenance setRunMaintenance} can be called * in interchangeable order. * The default value is true. * @param useThreads true to use additional threads; false otherwise. **/ public void setThreadUsed(boolean useThreads) { //@A4D Moved code to ConnectionPoolProperties //@A4D String property = "threadUsed"; //@A4D if (isInUse()) //@A4D throw new ExtendedIllegalStateException(property, ExtendedIllegalStateException.PROPERTY_NOT_CHANGED); //@A4D Boolean oldValue = new Boolean(isThreadUsed()); //@A4D Boolean newValue = new Boolean(useThreads); //@A4D useThreads_ = useThreads; //@A4D changes_.firePropertyChange(property, oldValue, newValue); properties_.setThreadUsed(useThreads, isInUse()); //@A4A } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy