mybatis / ibatis-2 / 753

Committed 05 Jan 2026 01:30AM UTC coverage: 65.569% (+0.03%) from 65.537%

Build # 753

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #346 from hazendaz/master

Minor code cleanups

Run Details

1598 of 2797 branches covered (57.13%)

19 of 30 new or added lines in 9 files covered. (63.33%)

1 existing line in 1 file now uncovered.

5020 of 7656 relevant lines covered (65.57%)

0.66 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

42.82

/src/main/java/com/ibatis/common/jdbc/SimpleDataSource.java

/*
 * Copyright 2004-2026 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.ibatis.common.jdbc;

import com.ibatis.common.beans.ClassInfo;
import com.ibatis.common.logging.Log;
import com.ibatis.common.logging.LogFactory;
import com.ibatis.common.resources.Resources;

import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.sql.SQLWarning;
import java.sql.Savepoint;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.logging.Logger;

import javax.sql.DataSource;

/**
 * This is a simple, synchronous, thread-safe database connection pool.
 * <p>
 * REQUIRED PROPERTIES ------------------- JDBC.Driver JDBC.ConnectionURL JDBC.Username JDBC.Password
 * <p>
 * Pool.MaximumActiveConnections Pool.MaximumIdleConnections Pool.MaximumCheckoutTime Pool.TimeToWait Pool.PingQuery
 * Pool.PingEnabled Pool.PingConnectionsOlderThan Pool.PingConnectionsNotUsedFor Pool.QuietMode
 */
public class SimpleDataSource implements DataSource {

  /** The Constant log. */
  private static final Log log = LogFactory.getLog(SimpleDataSource.class);

  /** The Constant PROP_JDBC_DRIVER. */
  // Required Properties
  private static final String PROP_JDBC_DRIVER = "JDBC.Driver";

  /** The Constant PROP_JDBC_URL. */
  private static final String PROP_JDBC_URL = "JDBC.ConnectionURL";

  /** The Constant PROP_JDBC_USERNAME. */
  private static final String PROP_JDBC_USERNAME = "JDBC.Username";

  /** The Constant PROP_JDBC_PASSWORD. */
  private static final String PROP_JDBC_PASSWORD = "JDBC.Password";

  /** The Constant PROP_JDBC_DEFAULT_AUTOCOMMIT. */
  private static final String PROP_JDBC_DEFAULT_AUTOCOMMIT = "JDBC.DefaultAutoCommit";

  /** The Constant PROP_POOL_MAX_ACTIVE_CONN. */
  // Optional Properties
  private static final String PROP_POOL_MAX_ACTIVE_CONN = "Pool.MaximumActiveConnections";

  /** The Constant PROP_POOL_MAX_IDLE_CONN. */
  private static final String PROP_POOL_MAX_IDLE_CONN = "Pool.MaximumIdleConnections";

  /** The Constant PROP_POOL_MAX_CHECKOUT_TIME. */
  private static final String PROP_POOL_MAX_CHECKOUT_TIME = "Pool.MaximumCheckoutTime";

  /** The Constant PROP_POOL_TIME_TO_WAIT. */
  private static final String PROP_POOL_TIME_TO_WAIT = "Pool.TimeToWait";

  /** The Constant PROP_POOL_PING_QUERY. */
  private static final String PROP_POOL_PING_QUERY = "Pool.PingQuery";

  /** The Constant PROP_POOL_PING_CONN_OLDER_THAN. */
  private static final String PROP_POOL_PING_CONN_OLDER_THAN = "Pool.PingConnectionsOlderThan";

  /** The Constant PROP_POOL_PING_ENABLED. */
  private static final String PROP_POOL_PING_ENABLED = "Pool.PingEnabled";

  /** The Constant PROP_POOL_PING_CONN_NOT_USED_FOR. */
  private static final String PROP_POOL_PING_CONN_NOT_USED_FOR = "Pool.PingConnectionsNotUsedFor";

  /** The expected connection type code. */
  private int expectedConnectionTypeCode;

  /** The Constant ADD_DRIVER_PROPS_PREFIX. */
  // Additional Driver Properties prefix
  private static final String ADD_DRIVER_PROPS_PREFIX = "Driver.";

  /** The Constant ADD_DRIVER_PROPS_PREFIX_LENGTH. */
  private static final int ADD_DRIVER_PROPS_PREFIX_LENGTH = ADD_DRIVER_PROPS_PREFIX.length();

  /** The pool lock. */
  // ----- BEGIN: FIELDS LOCKED BY POOL_LOCK -----
  private final Object POOL_LOCK = new Object();

  /** The idle connections. */
  private List idleConnections = new ArrayList<>();

  /** The active connections. */
  private List activeConnections = new ArrayList<>();

  /** The request count. */
  private long requestCount = 0;

  /** The accumulated request time. */
  private long accumulatedRequestTime = 0;

  /** The accumulated checkout time. */
  private long accumulatedCheckoutTime = 0;

  /** The claimed overdue connection count. */
  private long claimedOverdueConnectionCount = 0;

  /** The accumulated checkout time of overdue connections. */
  private long accumulatedCheckoutTimeOfOverdueConnections = 0;

  /** The accumulated wait time. */
  private long accumulatedWaitTime = 0;

  /** The had to wait count. */
  private long hadToWaitCount = 0;

  /** The bad connection count. */
  private long badConnectionCount = 0;
  // ----- END: FIELDS LOCKED BY POOL_LOCK -----

  /** The jdbc driver. */
  // ----- BEGIN: PROPERTY FIELDS FOR CONFIGURATION -----
  private String jdbcDriver;

  /** The jdbc url. */
  private String jdbcUrl;

  /** The jdbc username. */
  private String jdbcUsername;

  /** The jdbc password. */
  private String jdbcPassword;

  /** The jdbc default auto commit. */
  private boolean jdbcDefaultAutoCommit;

  /** The driver props. */
  private Properties driverProps;

  /** The use driver props. */
  private boolean useDriverProps;

  /** The pool maximum active connections. */
  private int poolMaximumActiveConnections;

  /** The pool maximum idle connections. */
  private int poolMaximumIdleConnections;

  /** The pool maximum checkout time. */
  private int poolMaximumCheckoutTime;

  /** The pool time to wait. */
  private int poolTimeToWait;

  /** The pool ping query. */
  private String poolPingQuery;

  /** The pool ping enabled. */
  private boolean poolPingEnabled;

  /** The pool ping connections older than. */
  private int poolPingConnectionsOlderThan;

  /** The pool ping connections not used for. */
  private int poolPingConnectionsNotUsedFor;

  // ----- END: PROPERTY FIELDS FOR CONFIGURATION -----

  /**
   * Constructor to allow passing in a map of properties for configuration.
   *
   * @param props
   *          - the configuration parameters
   */
  public SimpleDataSource(Map props) {
    initialize(props);
  }

  /**
   * Initialize.
   *
   * @param props
   *          the props
   */
  private void initialize(Map props) {
    try {
      String prop_pool_ping_query = null;

      if (props == null) {
        throw new RuntimeException("SimpleDataSource: The properties map passed to the initializer was null.");
      }

      if (!props.containsKey(PROP_JDBC_DRIVER) || !props.containsKey(PROP_JDBC_URL)
          || !props.containsKey(PROP_JDBC_USERNAME) || !props.containsKey(PROP_JDBC_PASSWORD)) {
        throw new RuntimeException("SimpleDataSource: Some properties were not set.");
      }
      jdbcDriver = (String) props.get(PROP_JDBC_DRIVER);
      jdbcUrl = (String) props.get(PROP_JDBC_URL);
      jdbcUsername = (String) props.get(PROP_JDBC_USERNAME);
      jdbcPassword = (String) props.get(PROP_JDBC_PASSWORD);

      poolMaximumActiveConnections = props.containsKey(PROP_POOL_MAX_ACTIVE_CONN)
          ? Integer.parseInt((String) props.get(PROP_POOL_MAX_ACTIVE_CONN)) : 10;

      poolMaximumIdleConnections = props.containsKey(PROP_POOL_MAX_IDLE_CONN)
          ? Integer.parseInt((String) props.get(PROP_POOL_MAX_IDLE_CONN)) : 5;

      poolMaximumCheckoutTime = props.containsKey(PROP_POOL_MAX_CHECKOUT_TIME)
          ? Integer.parseInt((String) props.get(PROP_POOL_MAX_CHECKOUT_TIME)) : 20000;

      poolTimeToWait = props.containsKey(PROP_POOL_TIME_TO_WAIT)
          ? Integer.parseInt((String) props.get(PROP_POOL_TIME_TO_WAIT)) : 20000;

      poolPingEnabled = props.containsKey(PROP_POOL_PING_ENABLED)
          && Boolean.parseBoolean((String) props.get(PROP_POOL_PING_ENABLED));

      prop_pool_ping_query = (String) props.get(PROP_POOL_PING_QUERY);
      poolPingQuery = props.containsKey(PROP_POOL_PING_QUERY) ? prop_pool_ping_query : "NO PING QUERY SET";

      poolPingConnectionsOlderThan = props.containsKey(PROP_POOL_PING_CONN_OLDER_THAN)
          ? Integer.parseInt((String) props.get(PROP_POOL_PING_CONN_OLDER_THAN)) : 0;

      poolPingConnectionsNotUsedFor = props.containsKey(PROP_POOL_PING_CONN_NOT_USED_FOR)
          ? Integer.parseInt((String) props.get(PROP_POOL_PING_CONN_NOT_USED_FOR)) : 0;

      jdbcDefaultAutoCommit = props.containsKey(PROP_JDBC_DEFAULT_AUTOCOMMIT)
          && Boolean.parseBoolean((String) props.get(PROP_JDBC_DEFAULT_AUTOCOMMIT));

      useDriverProps = false;
      Iterator propIter = props.keySet().iterator();
      driverProps = new Properties();
      driverProps.put("user", jdbcUsername);
      driverProps.put("password", jdbcPassword);
      while (propIter.hasNext()) {
        String name = (String) propIter.next();
        String value = (String) props.get(name);
        if (name.startsWith(ADD_DRIVER_PROPS_PREFIX)) {
          driverProps.put(name.substring(ADD_DRIVER_PROPS_PREFIX_LENGTH), value);
          useDriverProps = true;
        }
      }

      expectedConnectionTypeCode = assembleConnectionTypeCode(jdbcUrl, jdbcUsername, jdbcPassword);

      Resources.instantiate(jdbcDriver);

      if (poolPingEnabled && (!props.containsKey(PROP_POOL_PING_QUERY) || prop_pool_ping_query.trim().length() == 0)) {
        throw new RuntimeException("SimpleDataSource: property '" + PROP_POOL_PING_ENABLED + "' is true, but property '"
            + PROP_POOL_PING_QUERY + "' is not set correctly.");
      }

    } catch (Exception e) {
      log.error("SimpleDataSource: Error while loading properties. Cause: " + e.toString(), e);
      throw new RuntimeException("SimpleDataSource: Error while loading properties. Cause: " + e, e);
    }
  }

  /**
   * Assemble connection type code.
   *
   * @param url
   *          the url
   * @param username
   *          the username
   * @param password
   *          the password
   *
   * @return the int
   */
  private int assembleConnectionTypeCode(String url, String username, String password) {
    return ("" + url + username + password).hashCode();
  }

  /**
   * @see javax.sql.DataSource#getConnection()
   */
  @Override
  public Connection getConnection() throws SQLException {
    return popConnection(jdbcUsername, jdbcPassword).getProxyConnection();
  }

  /**
   * @see javax.sql.DataSource#getConnection(java.lang.String, java.lang.String)
   */
  @Override
  public Connection getConnection(String username, String password) throws SQLException {
    return popConnection(username, password).getProxyConnection();
  }

  /**
   * @see javax.sql.DataSource#setLoginTimeout(int)
   */
  @Override
  public void setLoginTimeout(int loginTimeout) throws SQLException {
    DriverManager.setLoginTimeout(loginTimeout);
  }

  /**
   * @see javax.sql.DataSource#getLoginTimeout()
   */
  @Override
  public int getLoginTimeout() throws SQLException {
    return DriverManager.getLoginTimeout();
  }

  /**
   * @see javax.sql.DataSource#setLogWriter(java.io.PrintWriter)
   */
  @Override
  public void setLogWriter(PrintWriter logWriter) throws SQLException {
    DriverManager.setLogWriter(logWriter);
  }

  /**
   * @see javax.sql.DataSource#getLogWriter()
   */
  @Override
  public PrintWriter getLogWriter() throws SQLException {
    return DriverManager.getLogWriter();
  }

  /**
   * If a connection has not been used in this many milliseconds, ping the database to make sure the connection is still
   * good.
   *
   * @return the number of milliseconds of inactivity that will trigger a ping
   */
  public int getPoolPingConnectionsNotUsedFor() {
    return poolPingConnectionsNotUsedFor;
  }

  /**
   * Getter for the name of the JDBC driver class used.
   *
   * @return The name of the class
   */
  public String getJdbcDriver() {
    return jdbcDriver;
  }

  /**
   * Getter of the JDBC URL used.
   *
   * @return The JDBC URL
   */
  public String getJdbcUrl() {
    return jdbcUrl;
  }

  /**
   * Getter for the JDBC user name used.
   *
   * @return The user name
   */
  public String getJdbcUsername() {
    return jdbcUsername;
  }

  /**
   * Getter for the JDBC password used.
   *
   * @return The password
   */
  public String getJdbcPassword() {
    return jdbcPassword;
  }

  /**
   * Getter for the maximum number of active connections.
   *
   * @return The maximum number of active connections
   */
  public int getPoolMaximumActiveConnections() {
    return poolMaximumActiveConnections;
  }

  /**
   * Getter for the maximum number of idle connections.
   *
   * @return The maximum number of idle connections
   */
  public int getPoolMaximumIdleConnections() {
    return poolMaximumIdleConnections;
  }

  /**
   * Getter for the maximum time a connection can be used before it *may* be given away again.
   *
   * @return The maximum time
   */
  public int getPoolMaximumCheckoutTime() {
    return poolMaximumCheckoutTime;
  }

  /**
   * Getter for the time to wait before retrying to get a connection.
   *
   * @return The time to wait
   */
  public int getPoolTimeToWait() {
    return poolTimeToWait;
  }

  /**
   * Getter for the query to be used to check a connection.
   *
   * @return The query
   */
  public String getPoolPingQuery() {
    return poolPingQuery;
  }

  /**
   * Getter to tell if we should use the ping query.
   *
   * @return True if we need to check a connection before using it
   */
  public boolean isPoolPingEnabled() {
    return poolPingEnabled;
  }

  /**
   * Getter for the age of connections that should be pinged before using.
   *
   * @return The age
   */
  public int getPoolPingConnectionsOlderThan() {
    return poolPingConnectionsOlderThan;
  }

  /**
   * Gets the expected connection type code.
   *
   * @return the expected connection type code
   */
  private int getExpectedConnectionTypeCode() {
    return expectedConnectionTypeCode;
  }

  /**
   * Getter for the number of connection requests made.
   *
   * @return The number of connection requests made
   */
  public long getRequestCount() {
    synchronized (POOL_LOCK) {
      return requestCount;
    }
  }

  /**
   * Getter for the average time required to get a connection to the database.
   *
   * @return The average time
   */
  public long getAverageRequestTime() {
    synchronized (POOL_LOCK) {
      return requestCount == 0 ? 0 : accumulatedRequestTime / requestCount;
    }
  }

  /**
   * Getter for the average time spent waiting for connections that were in use.
   *
   * @return The average time
   */
  public long getAverageWaitTime() {
    synchronized (POOL_LOCK) {
      return hadToWaitCount == 0 ? 0 : accumulatedWaitTime / hadToWaitCount;
    }
  }

  /**
   * Getter for the number of requests that had to wait for connections that were in use.
   *
   * @return The number of requests that had to wait
   */
  public long getHadToWaitCount() {
    synchronized (POOL_LOCK) {
      return hadToWaitCount;
    }
  }

  /**
   * Getter for the number of invalid connections that were found in the pool.
   *
   * @return The number of invalid connections
   */
  public long getBadConnectionCount() {
    synchronized (POOL_LOCK) {
      return badConnectionCount;
    }
  }

  /**
   * Getter for the number of connections that were claimed before they were returned.
   *
   * @return The number of connections
   */
  public long getClaimedOverdueConnectionCount() {
    synchronized (POOL_LOCK) {
      return claimedOverdueConnectionCount;
    }
  }

  /**
   * Getter for the average age of overdue connections.
   *
   * @return The average age
   */
  public long getAverageOverdueCheckoutTime() {
    synchronized (POOL_LOCK) {
      return claimedOverdueConnectionCount == 0 ? 0
          : accumulatedCheckoutTimeOfOverdueConnections / claimedOverdueConnectionCount;
    }
  }

  /**
   * Getter for the average age of a connection checkout.
   *
   * @return The average age
   */
  public long getAverageCheckoutTime() {
    synchronized (POOL_LOCK) {
      return requestCount == 0 ? 0 : accumulatedCheckoutTime / requestCount;
    }
  }

  /**
   * Returns the status of the connection pool.
   *
   * @return The status
   */
  public String getStatus() {
    StringBuilder builder = new StringBuilder();

    builder.append("\n===============================================================");
    builder.append("\n jdbcDriver                     ").append(jdbcDriver);
    builder.append("\n jdbcUrl                        ").append(jdbcUrl);
    builder.append("\n jdbcUsername                   ").append(jdbcUsername);
    builder.append("\n jdbcPassword                   ").append(jdbcPassword == null ? "NULL" : "************");
    builder.append("\n poolMaxActiveConnections       ").append(poolMaximumActiveConnections);
    builder.append("\n poolMaxIdleConnections         ").append(poolMaximumIdleConnections);
    builder.append("\n poolMaxCheckoutTime            " + poolMaximumCheckoutTime);
    builder.append("\n poolTimeToWait                 " + poolTimeToWait);
    builder.append("\n poolPingEnabled                " + poolPingEnabled);
    builder.append("\n poolPingQuery                  " + poolPingQuery);
    builder.append("\n poolPingConnectionsOlderThan   " + poolPingConnectionsOlderThan);
    builder.append("\n poolPingConnectionsNotUsedFor  " + poolPingConnectionsNotUsedFor);
    builder.append("\n --------------------------------------------------------------");
    builder.append("\n activeConnections              " + activeConnections.size());
    builder.append("\n idleConnections                " + idleConnections.size());
    builder.append("\n requestCount                   " + getRequestCount());
    builder.append("\n averageRequestTime             " + getAverageRequestTime());
    builder.append("\n averageCheckoutTime            " + getAverageCheckoutTime());
    builder.append("\n claimedOverdue                 " + getClaimedOverdueConnectionCount());
    builder.append("\n averageOverdueCheckoutTime     " + getAverageOverdueCheckoutTime());
    builder.append("\n hadToWait                      " + getHadToWaitCount());
    builder.append("\n averageWaitTime                " + getAverageWaitTime());
    builder.append("\n badConnectionCount             " + getBadConnectionCount());
    builder.append("\n===============================================================");
    return builder.toString();
  }

  /**
   * Closes all of the connections in the pool.
   */
  public void forceCloseAll() {
    synchronized (POOL_LOCK) {
      for (int i = activeConnections.size(); i > 0; i--) {
        try {
          SimplePooledConnection conn = (SimplePooledConnection) activeConnections.remove(i - 1);
          conn.invalidate();

          Connection realConn = conn.getRealConnection();
          if (!realConn.getAutoCommit()) {
            realConn.rollback();
          }
          realConn.close();
        } catch (Exception e) {
          // ignore
        }
      }
      for (int i = idleConnections.size(); i > 0; i--) {
        try {
          SimplePooledConnection conn = (SimplePooledConnection) idleConnections.remove(i - 1);
          conn.invalidate();

          Connection realConn = conn.getRealConnection();
          if (!realConn.getAutoCommit()) {
            realConn.rollback();
          }
          realConn.close();
        } catch (Exception e) {
          // ignore
        }
      }
    }
    if (log.isDebugEnabled()) {
      log.debug("SimpleDataSource forcefully closed/removed all connections.");
    }
  }

  /**
   * Push connection.
   *
   * @param conn
   *          the conn
   *
   * @throws SQLException
   *           the SQL exception
   */
  private void pushConnection(SimplePooledConnection conn) throws SQLException {

    synchronized (POOL_LOCK) {
      activeConnections.remove(conn);
      if (conn.isValid()) {
        if (idleConnections.size() < poolMaximumIdleConnections
            && conn.getConnectionTypeCode() == getExpectedConnectionTypeCode()) {
          accumulatedCheckoutTime += conn.getCheckoutTime();
          if (!conn.getRealConnection().getAutoCommit()) {
            conn.getRealConnection().rollback();
          }
          SimplePooledConnection newConn = new SimplePooledConnection(conn.getRealConnection(), this);
          idleConnections.add(newConn);
          newConn.setCreatedTimestamp(conn.getCreatedTimestamp());
          newConn.setLastUsedTimestamp(conn.getLastUsedTimestamp());
          conn.invalidate();
          if (log.isDebugEnabled()) {
            log.debug("Returned connection " + newConn.getRealHashCode() + " to pool.");
          }
          POOL_LOCK.notifyAll();
        } else {
          accumulatedCheckoutTime += conn.getCheckoutTime();
          if (!conn.getRealConnection().getAutoCommit()) {
            conn.getRealConnection().rollback();
          }
          conn.getRealConnection().close();
          if (log.isDebugEnabled()) {
            log.debug("Closed connection " + conn.getRealHashCode() + ".");
          }
          conn.invalidate();
        }
      } else {
        if (log.isDebugEnabled()) {
          log.debug("A bad connection (" + conn.getRealHashCode()
              + ") attempted to return to the pool, discarding connection.");
        }
        badConnectionCount++;
      }
    }
  }

  /**
   * Pop connection.
   *
   * @param username
   *          the username
   * @param password
   *          the password
   *
   * @return the simple pooled connection
   *
   * @throws SQLException
   *           the SQL exception
   */
  private SimplePooledConnection popConnection(String username, String password) throws SQLException {
    boolean countedWait = false;
    SimplePooledConnection conn = null;
    long t = System.currentTimeMillis();
    int localBadConnectionCount = 0;

    while (conn == null) {
      synchronized (POOL_LOCK) {
        if (!idleConnections.isEmpty()) {
          // Pool has available connection
          conn = (SimplePooledConnection) idleConnections.remove(0);
          if (log.isDebugEnabled()) {
            log.debug("Checked out connection " + conn.getRealHashCode() + " from pool.");
          }
        } else {
          // Pool does not have available connection
          if (activeConnections.size() < poolMaximumActiveConnections) {
            // Can create new connection
            if (useDriverProps) {
              conn = new SimplePooledConnection(DriverManager.getConnection(jdbcUrl, driverProps), this);
            } else {
              conn = new SimplePooledConnection(DriverManager.getConnection(jdbcUrl, jdbcUsername, jdbcPassword), this);
            }
            Connection realConn = conn.getRealConnection();
            if (realConn.getAutoCommit() != jdbcDefaultAutoCommit) {
              realConn.setAutoCommit(jdbcDefaultAutoCommit);
            }
            if (log.isDebugEnabled()) {
              log.debug("Created connection " + conn.getRealHashCode() + ".");
            }
          } else {
            // Cannot create new connection
            SimplePooledConnection oldestActiveConnection = (SimplePooledConnection) activeConnections.get(0);
            long longestCheckoutTime = oldestActiveConnection.getCheckoutTime();
            if (longestCheckoutTime > poolMaximumCheckoutTime) {
              // Can claim overdue connection
              claimedOverdueConnectionCount++;
              accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime;
              accumulatedCheckoutTime += longestCheckoutTime;
              activeConnections.remove(oldestActiveConnection);
              if (!oldestActiveConnection.getRealConnection().getAutoCommit()) {
                oldestActiveConnection.getRealConnection().rollback();
              }
              conn = new SimplePooledConnection(oldestActiveConnection.getRealConnection(), this);
              oldestActiveConnection.invalidate();
              if (log.isDebugEnabled()) {
                log.debug("Claimed overdue connection " + conn.getRealHashCode() + ".");
              }
            } else {
              // Must wait
              try {
                if (!countedWait) {
                  hadToWaitCount++;
                  countedWait = true;
                }
                if (log.isDebugEnabled()) {
                  log.debug("Waiting as long as " + poolTimeToWait + " milliseconds for connection.");
                }
                long wt = System.currentTimeMillis();
                POOL_LOCK.wait(poolTimeToWait);
                accumulatedWaitTime += System.currentTimeMillis() - wt;
              } catch (InterruptedException e) {
                break;
              }
            }
          }
        }
        if (conn != null) {
          if (conn.isValid()) {
            if (!conn.getRealConnection().getAutoCommit()) {
              conn.getRealConnection().rollback();
            }
            conn.setConnectionTypeCode(assembleConnectionTypeCode(jdbcUrl, username, password));
            conn.setCheckoutTimestamp(System.currentTimeMillis());
            conn.setLastUsedTimestamp(System.currentTimeMillis());
            activeConnections.add(conn);
            requestCount++;
            accumulatedRequestTime += System.currentTimeMillis() - t;
          } else {
            if (log.isDebugEnabled()) {
              log.debug("A bad connection (" + conn.getRealHashCode()
                  + ") was returned from the pool, getting another connection.");
            }
            badConnectionCount++;
            localBadConnectionCount++;
            conn = null;
            if (localBadConnectionCount > poolMaximumIdleConnections + 3) {
              if (log.isDebugEnabled()) {
                log.debug("SimpleDataSource: Could not get a good connection to the database.");
              }
              throw new SQLException("SimpleDataSource: Could not get a good connection to the database.");
            }
          }
        }
      }

    }

    if (conn == null) {
      if (log.isDebugEnabled()) {
        log.debug("SimpleDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
      }
      throw new SQLException(
          "SimpleDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
    }

    return conn;
  }

  /**
   * Method to check to see if a connection is still usable.
   *
   * @param conn
   *          - the connection to check
   *
   * @return True if the connection is still usable
   */
  private boolean pingConnection(SimplePooledConnection conn) {
    boolean result = true;

    try {
      result = !conn.getRealConnection().isClosed();
    } catch (SQLException e) {
      if (log.isDebugEnabled()) {
        log.debug("Connection " + conn.getRealHashCode() + " is BAD: " + e.getMessage());
      }
      result = false;
    }

    if (result && poolPingEnabled) {
      if (poolPingConnectionsOlderThan > 0 && conn.getAge() > poolPingConnectionsOlderThan
          || poolPingConnectionsNotUsedFor > 0 && conn.getTimeElapsedSinceLastUse() > poolPingConnectionsNotUsedFor) {

        try {
          if (log.isDebugEnabled()) {
            log.debug("Testing connection " + conn.getRealHashCode() + " ...");
          }
          Connection realConn = conn.getRealConnection();
          Statement statement = realConn.createStatement();
          ResultSet rs = statement.executeQuery(poolPingQuery);
          rs.close();
          statement.close();
          if (!realConn.getAutoCommit()) {
            realConn.rollback();
          }
          result = true;
          if (log.isDebugEnabled()) {
            log.debug("Connection " + conn.getRealHashCode() + " is GOOD!");
          }
        } catch (Exception e) {
          log.warn("Execution of ping query '" + poolPingQuery + "' failed: " + e.getMessage());
          try {
            conn.getRealConnection().close();
          } catch (Exception e2) {
            // ignore
          }
          result = false;
          if (log.isDebugEnabled()) {
            log.debug("Connection " + conn.getRealHashCode() + " is BAD: " + e.getMessage());
          }
        }
      }
    }
    return result;
  }

  /**
   * Unwraps a pooled connection to get to the 'real' connection.
   *
   * @param conn
   *          - the pooled connection to unwrap
   *
   * @return The 'real' connection
   */
  public static Connection unwrapConnection(Connection conn) {
    if (conn instanceof SimplePooledConnection) {
      return ((SimplePooledConnection) conn).getRealConnection();
    }
    return conn;
  }

  @Override
  protected void finalize() throws Throwable {
    forceCloseAll();
  }

  /**
   * --------------------------------------------------------------------------------------- SimplePooledConnection
   * ---------------------------------------------------------------------------------------.
   */
  public static class SimplePooledConnection implements InvocationHandler {

    /** The Constant CLOSE. */
    private static final String CLOSE = "close";

    /** The Constant IFACES. */
    private static final Class[] IFACES = { Connection.class };

    /** The hash code. */
    private int hashCode = 0;

    /** The data source. */
    private SimpleDataSource dataSource;

    /** The real connection. */
    private Connection realConnection;

    /** The proxy connection. */
    private Connection proxyConnection;

    /** The checkout timestamp. */
    private long checkoutTimestamp;

    /** The created timestamp. */
    private long createdTimestamp;

    /** The last used timestamp. */
    private long lastUsedTimestamp;

    /** The connection type code. */
    private int connectionTypeCode;

    /** The valid. */
    private boolean valid;

    /**
     * Constructor for SimplePooledConnection that uses the Connection and SimpleDataSource passed in.
     *
     * @param connection
     *          - the connection that is to be presented as a pooled connection
     * @param dataSource
     *          - the dataSource that the connection is from
     */
    public SimplePooledConnection(Connection connection, SimpleDataSource dataSource) {
      this.hashCode = connection.hashCode();
      this.realConnection = connection;
      this.dataSource = dataSource;
      this.createdTimestamp = System.currentTimeMillis();
      this.lastUsedTimestamp = System.currentTimeMillis();
      this.valid = true;

      proxyConnection = (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(), IFACES, this);
    }

    /**
     * Invalidates the connection.
     */
    public void invalidate() {
      valid = false;
    }

    /**
     * Method to see if the connection is usable.
     *
     * @return True if the connection is usable
     */
    public boolean isValid() {
      return valid && realConnection != null && dataSource.pingConnection(this);
    }

    /**
     * Getter for the *real* connection that this wraps.
     *
     * @return The connection
     */
    public Connection getRealConnection() {
      return realConnection;
    }

    /**
     * Getter for the proxy for the connection.
     *
     * @return The proxy
     */
    public Connection getProxyConnection() {
      return proxyConnection;
    }

    /**
     * Gets the hashcode of the real connection (or 0 if it is null).
     *
     * @return The hashcode of the real connection (or 0 if it is null)
     */
    public int getRealHashCode() {
      if (realConnection == null) {
        return 0;
      }
      return realConnection.hashCode();
    }

    /**
     * Getter for the connection type (based on url + user + password).
     *
     * @return The connection type
     */
    public int getConnectionTypeCode() {
      return connectionTypeCode;
    }

    /**
     * Setter for the connection type.
     *
     * @param connectionTypeCode
     *          - the connection type
     */
    public void setConnectionTypeCode(int connectionTypeCode) {
      this.connectionTypeCode = connectionTypeCode;
    }

    /**
     * Getter for the time that the connection was created.
     *
     * @return The creation timestamp
     */
    public long getCreatedTimestamp() {
      return createdTimestamp;
    }

    /**
     * Setter for the time that the connection was created.
     *
     * @param createdTimestamp
     *          - the timestamp
     */
    public void setCreatedTimestamp(long createdTimestamp) {
      this.createdTimestamp = createdTimestamp;
    }

    /**
     * Getter for the time that the connection was last used.
     *
     * @return - the timestamp
     */
    public long getLastUsedTimestamp() {
      return lastUsedTimestamp;
    }

    /**
     * Setter for the time that the connection was last used.
     *
     * @param lastUsedTimestamp
     *          - the timestamp
     */
    public void setLastUsedTimestamp(long lastUsedTimestamp) {
      this.lastUsedTimestamp = lastUsedTimestamp;
    }

    /**
     * Getter for the time since this connection was last used.
     *
     * @return - the time since the last use
     */
    public long getTimeElapsedSinceLastUse() {
      return System.currentTimeMillis() - lastUsedTimestamp;
    }

    /**
     * Getter for the age of the connection.
     *
     * @return the age
     */
    public long getAge() {
      return System.currentTimeMillis() - createdTimestamp;
    }

    /**
     * Getter for the timestamp that this connection was checked out.
     *
     * @return the timestamp
     */
    public long getCheckoutTimestamp() {
      return checkoutTimestamp;
    }

    /**
     * Setter for the timestamp that this connection was checked out.
     *
     * @param timestamp
     *          the timestamp
     */
    public void setCheckoutTimestamp(long timestamp) {
      this.checkoutTimestamp = timestamp;
    }

    /**
     * Getter for the time that this connection has been checked out.
     *
     * @return the time
     */
    public long getCheckoutTime() {
      return System.currentTimeMillis() - checkoutTimestamp;
    }

    /**
     * Gets the valid connection.
     *
     * @return the valid connection
     */
    private Connection getValidConnection() {
      if (!valid) {
        throw new RuntimeException("Error accessing SimplePooledConnection. Connection is invalid.");
      }
      return realConnection;
    }

    @Override
    public int hashCode() {
      return hashCode;
    }

    /**
     * Allows comparing this connection to another
     *
     * @param obj
     *          - the other connection to test for equality
     *
     * @see java.lang.Object#equals(java.lang.Object)
     */
    @Override
    public boolean equals(Object obj) {
      if (obj instanceof SimplePooledConnection) {
        return realConnection.hashCode() == ((SimplePooledConnection) obj).realConnection.hashCode();
      }
      if (obj instanceof Connection) {
        return hashCode == obj.hashCode();
      }
      return false;
    }

    // **********************************
    // Implemented Connection Methods -- Now handled by proxy
    // **********************************

    /**
     * Required for InvocationHandler implementation.
     *
     * @param proxy
     *          - not used
     * @param method
     *          - the method to be executed
     * @param args
     *          - the parameters to be passed to the method
     *
     * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      String methodName = method.getName();
      if (CLOSE.hashCode() == methodName.hashCode() && CLOSE.equals(methodName)) {
        dataSource.pushConnection(this);
        return null;
      }
      try {
        return method.invoke(getValidConnection(), args);
      } catch (Throwable t) {
        throw ClassInfo.unwrapThrowable(t);
      }
    }

    /**
     * Creates the statement.
     *
     * @return the statement
     *
     * @throws SQLException
     *           the SQL exception
     */
    public Statement createStatement() throws SQLException {
      return getValidConnection().createStatement();
    }

    /**
     * Prepare statement.
     *
     * @param sql
     *          the sql
     *
     * @return the prepared statement
     *
     * @throws SQLException
     *           the SQL exception
     */
    public PreparedStatement prepareStatement(String sql) throws SQLException {
      return getValidConnection().prepareStatement(sql);
    }

    /**
     * Prepare call.
     *
     * @param sql
     *          the sql
     *
     * @return the callable statement
     *
     * @throws SQLException
     *           the SQL exception
     */
    public CallableStatement prepareCall(String sql) throws SQLException {
      return getValidConnection().prepareCall(sql);
    }

    /**
     * Native SQL.
     *
     * @param sql
     *          the sql
     *
     * @return the string
     *
     * @throws SQLException
     *           the SQL exception
     */
    public String nativeSQL(String sql) throws SQLException {
      return getValidConnection().nativeSQL(sql);
    }

    /**
     * Sets the auto commit.
     *
     * @param autoCommit
     *          the new auto commit
     *
     * @throws SQLException
     *           the SQL exception
     */
    public void setAutoCommit(boolean autoCommit) throws SQLException {
      getValidConnection().setAutoCommit(autoCommit);
    }

    /**
     * Gets the auto commit.
     *
     * @return the auto commit
     *
     * @throws SQLException
     *           the SQL exception
     */
    public boolean getAutoCommit() throws SQLException {
      return getValidConnection().getAutoCommit();
    }

    /**
     * Commit.
     *
     * @throws SQLException
     *           the SQL exception
     */
    public void commit() throws SQLException {
      getValidConnection().commit();
    }

    /**
     * Rollback.
     *
     * @throws SQLException
     *           the SQL exception
     */
    public void rollback() throws SQLException {
      getValidConnection().rollback();
    }

    /**
     * Close.
     *
     * @throws SQLException
     *           the SQL exception
     */
    public void close() throws SQLException {
      dataSource.pushConnection(this);
    }

    /**
     * Checks if is closed.
     *
     * @return true, if is closed
     *
     * @throws SQLException
     *           the SQL exception
     */
    public boolean isClosed() throws SQLException {
      return getValidConnection().isClosed();
    }

    /**
     * Gets the meta data.
     *
     * @return the meta data
     *
     * @throws SQLException
     *           the SQL exception
     */
    public DatabaseMetaData getMetaData() throws SQLException {
      return getValidConnection().getMetaData();
    }

    /**
     * Sets the read only.
     *
     * @param readOnly
     *          the new read only
     *
     * @throws SQLException
     *           the SQL exception
     */
    public void setReadOnly(boolean readOnly) throws SQLException {
      getValidConnection().setReadOnly(readOnly);
    }

    /**
     * Checks if is read only.
     *
     * @return true, if is read only
     *
     * @throws SQLException
     *           the SQL exception
     */
    public boolean isReadOnly() throws SQLException {
      return getValidConnection().isReadOnly();
    }

    /**
     * Sets the catalog.
     *
     * @param catalog
     *          the new catalog
     *
     * @throws SQLException
     *           the SQL exception
     */
    public void setCatalog(String catalog) throws SQLException {
      getValidConnection().setCatalog(catalog);
    }

    /**
     * Gets the catalog.
     *
     * @return the catalog
     *
     * @throws SQLException
     *           the SQL exception
     */
    public String getCatalog() throws SQLException {
      return getValidConnection().getCatalog();
    }

    /**
     * Sets the transaction isolation.
     *
     * @param level
     *          the new transaction isolation
     *
     * @throws SQLException
     *           the SQL exception
     */
    public void setTransactionIsolation(int level) throws SQLException {
      getValidConnection().setTransactionIsolation(level);
    }

    /**
     * Gets the transaction isolation.
     *
     * @return the transaction isolation
     *
     * @throws SQLException
     *           the SQL exception
     */
    public int getTransactionIsolation() throws SQLException {
      return getValidConnection().getTransactionIsolation();
    }

    /**
     * Gets the warnings.
     *
     * @return the warnings
     *
     * @throws SQLException
     *           the SQL exception
     */
    public SQLWarning getWarnings() throws SQLException {
      return getValidConnection().getWarnings();
    }

    /**
     * Clear warnings.
     *
     * @throws SQLException
     *           the SQL exception
     */
    public void clearWarnings() throws SQLException {
      getValidConnection().clearWarnings();
    }

    /**
     * Creates the statement.
     *
     * @param resultSetType
     *          the result set type
     * @param resultSetConcurrency
     *          the result set concurrency
     *
     * @return the statement
     *
     * @throws SQLException
     *           the SQL exception
     */
    public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
      return getValidConnection().createStatement(resultSetType, resultSetConcurrency);
    }

    /**
     * Prepare statement.
     *
     * @param sql
     *          the sql
     * @param resultSetType
     *          the result set type
     * @param resultSetConcurrency
     *          the result set concurrency
     *
     * @return the prepared statement
     *
     * @throws SQLException
     *           the SQL exception
     */
    public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency)
        throws SQLException {
      return getValidConnection().prepareCall(sql, resultSetType, resultSetConcurrency);
    }

    /**
     * Prepare call.
     *
     * @param sql
     *          the sql
     * @param resultSetType
     *          the result set type
     * @param resultSetConcurrency
     *          the result set concurrency
     *
     * @return the callable statement
     *
     * @throws SQLException
     *           the SQL exception
     */
    public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
      return getValidConnection().prepareCall(sql, resultSetType, resultSetConcurrency);
    }

    /**
     * Gets the type map.
     *
     * @return the type map
     *
     * @throws SQLException
     *           the SQL exception
     */
    public Map getTypeMap() throws SQLException {
      return getValidConnection().getTypeMap();
    }

    /**
     * Sets the type map.
     *
     * @param map
     *          the new type map
     *
     * @throws SQLException
     *           the SQL exception
     */
    public void setTypeMap(Map map) throws SQLException {
      getValidConnection().setTypeMap(map);
    }

    // **********************************
    // JDK 1.4 JDBC 3.0 Methods below
    // **********************************

    /**
     * Sets the holdability.
     *
     * @param holdability
     *          the new holdability
     *
     * @throws SQLException
     *           the SQL exception
     */
    public void setHoldability(int holdability) throws SQLException {
      getValidConnection().setHoldability(holdability);
    }

    /**
     * Gets the holdability.
     *
     * @return the holdability
     *
     * @throws SQLException
     *           the SQL exception
     */
    public int getHoldability() throws SQLException {
      return getValidConnection().getHoldability();
    }

    /**
     * Sets the savepoint.
     *
     * @return the savepoint
     *
     * @throws SQLException
     *           the SQL exception
     */
    public Savepoint setSavepoint() throws SQLException {
      return getValidConnection().setSavepoint();
    }

    /**
     * Sets the savepoint.
     *
     * @param name
     *          the name
     *
     * @return the savepoint
     *
     * @throws SQLException
     *           the SQL exception
     */
    public Savepoint setSavepoint(String name) throws SQLException {
      return getValidConnection().setSavepoint(name);
    }

    /**
     * Rollback.
     *
     * @param savepoint
     *          the savepoint
     *
     * @throws SQLException
     *           the SQL exception
     */
    public void rollback(Savepoint savepoint) throws SQLException {
      getValidConnection().rollback(savepoint);
    }

    /**
     * Release savepoint.
     *
     * @param savepoint
     *          the savepoint
     *
     * @throws SQLException
     *           the SQL exception
     */
    public void releaseSavepoint(Savepoint savepoint) throws SQLException {
      getValidConnection().releaseSavepoint(savepoint);
    }

    /**
     * Creates the statement.
     *
     * @param resultSetType
     *          the result set type
     * @param resultSetConcurrency
     *          the result set concurrency
     * @param resultSetHoldability
     *          the result set holdability
     *
     * @return the statement
     *
     * @throws SQLException
     *           the SQL exception
     */
    public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
        throws SQLException {
      return getValidConnection().createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);
    }

    /**
     * Prepare statement.
     *
     * @param sql
     *          the sql
     * @param resultSetType
     *          the result set type
     * @param resultSetConcurrency
     *          the result set concurrency
     * @param resultSetHoldability
     *          the result set holdability
     *
     * @return the prepared statement
     *
     * @throws SQLException
     *           the SQL exception
     */
    public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency,
        int resultSetHoldability) throws SQLException {
      return getValidConnection().prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
    }

    /**
     * Prepare call.
     *
     * @param sql
     *          the sql
     * @param resultSetType
     *          the result set type
     * @param resultSetConcurrency
     *          the result set concurrency
     * @param resultSetHoldability
     *          the result set holdability
     *
     * @return the callable statement
     *
     * @throws SQLException
     *           the SQL exception
     */
    public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency,
        int resultSetHoldability) throws SQLException {
      return getValidConnection().prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
    }

    /**
     * Prepare statement.
     *
     * @param sql
     *          the sql
     * @param autoGeneratedKeys
     *          the auto generated keys
     *
     * @return the prepared statement
     *
     * @throws SQLException
     *           the SQL exception
     */
    public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
      return getValidConnection().prepareStatement(sql, autoGeneratedKeys);
    }

    /**
     * Prepare statement.
     *
     * @param sql
     *          the sql
     * @param columnIndexes
     *          the column indexes
     *
     * @return the prepared statement
     *
     * @throws SQLException
     *           the SQL exception
     */
    public PreparedStatement prepareStatement(String sql, int columnIndexes[]) throws SQLException {
      return getValidConnection().prepareStatement(sql, columnIndexes);
    }

    /**
     * Prepare statement.
     *
     * @param sql
     *          the sql
     * @param columnNames
     *          the column names
     *
     * @return the prepared statement
     *
     * @throws SQLException
     *           the SQL exception
     */
    public PreparedStatement prepareStatement(String sql, String columnNames[]) throws SQLException {
      return getValidConnection().prepareStatement(sql, columnNames);
    }

  }

  @Override
  public Logger getParentLogger() throws SQLFeatureNotSupportedException {
    // TODO Auto-generated method stub
    return null;
  }

  @Override
  public <T> T unwrap(Class<T> iface) throws SQLException {
    // TODO Auto-generated method stub
    return null;
  }

  @Override
  public boolean isWrapperFor(Class<?> iface) throws SQLException {
    // TODO Auto-generated method stub
    return false;
  }
}

mybatis / ibatis-2 / 753

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous