Java ConnectionEventListener.connectionErrorOccurred方法代码示例

import javax.sql.ConnectionEventListener; //导入方法依赖的package包/类
/**
 * Used to fire a connection error event to all listeners.
 */
void fireConnectionFatalError(SQLException e)
{
	ConnectionEvent evt = null;
	// Copy the listener list so the listener can remove itself during this
	// method call
	ConnectionEventListener[] local = listeners.toArray(new ConnectionEventListener[listeners.size()]);
	for (ConnectionEventListener listener : local)
	{
		if (evt == null)
		{
			evt = createConnectionEvent(e);
		}
		listener.connectionErrorOccurred(evt);
	}
}
 

import javax.sql.ConnectionEventListener; //导入方法依赖的package包/类
/**
 * Notifies all registered ConnectionEventListeners of ConnectionEvents.
 * Instantiates a new ConnectionEvent which wraps sqlException and invokes
 * either connectionClose or connectionErrorOccurred on listener as
 * appropriate.
 * 
 * @param eventType
 *            value indicating whether connectionClosed or
 *            connectionErrorOccurred called
 * @param sqlException
 *            the exception being thrown
 */
protected synchronized void callConnectionEventListeners(int eventType, SQLException sqlException) {

    if (this.connectionEventListeners == null) {

        return;
    }

    Iterator<Map.Entry<ConnectionEventListener, ConnectionEventListener>> iterator = this.connectionEventListeners.entrySet().iterator();

    ConnectionEvent connectionevent = new ConnectionEvent(this, sqlException);

    while (iterator.hasNext()) {

        ConnectionEventListener connectioneventlistener = iterator.next().getValue();

        if (eventType == CONNECTION_CLOSED_EVENT) {
            connectioneventlistener.connectionClosed(connectionevent);
        } else if (eventType == CONNECTION_ERROR_EVENT) {
            connectioneventlistener.connectionErrorOccurred(connectionevent);
        }
    }
}
 

import javax.sql.ConnectionEventListener; //导入方法依赖的package包/类
/**
 * Fire all the {@code ConnectionEventListener}s registered. Callers must
 * synchronize on {@code this} to prevent others from modifying the list of
 * listeners.
 *
 * @param exception the exception that caused the event, or {@code null} if
 * it is a close event
 */
private void fireConnectionEventListeners(SqlException exception) {
    if (!listeners_.isEmpty()) {
        final ConnectionEvent event = (exception == null) ?
            new ConnectionEvent(this) :
            new ConnectionEvent(this, exception.getSQLException(
                physicalConnection_ != null ? physicalConnection_
                    .agent_ : null /* GemStoneAddition */));
        eventIterators++;
        try {
            for (Iterator it = listeners_.iterator(); it.hasNext(); ) {
                final ConnectionEventListener listener =
                    (ConnectionEventListener) it.next();
                if (exception == null) {
                    listener.connectionClosed(event);
                } else {
                    listener.connectionErrorOccurred(event);
                }
            }
        } finally {
            eventIterators--;
        }
    }
}
 

import javax.sql.ConnectionEventListener; //导入方法依赖的package包/类
/**
 * Fire all the {@code ConnectionEventListener}s registered. Callers must
 * synchronize on {@code this} to prevent others from modifying the list of
 * listeners.
 *
 * @param exception the exception that caused the event, or {@code null} if
 * it is a close event
 */
private void fireConnectionEventListeners(SQLException exception) {
    if (eventListener != null && !eventListener.isEmpty()) {
        ConnectionEvent event = new ConnectionEvent(this, exception);
        eventIterators++;
        try {
            for (Iterator it = eventListener.iterator(); it.hasNext();) {
                ConnectionEventListener l =
                        (ConnectionEventListener) it.next();
                if (exception == null) {
                    l.connectionClosed(event);
                } else {
                    l.connectionErrorOccurred(event);
                }
            }
        } finally {
            eventIterators--;
        }
    }
}
 

import javax.sql.ConnectionEventListener; //导入方法依赖的package包/类
/**
 * Notifies all registered ConnectionEventListeners of ConnectionEvents.
 * Instantiates a new ConnectionEvent which wraps sqlException and invokes
 * either connectionClose or connectionErrorOccurred on listener as
 * appropriate.
 * 
 * @param eventType
 *            value indicating whether connectionClosed or
 *            connectionErrorOccurred called
 * @param sqlException
 *            the exception being thrown
 */
protected synchronized void callConnectionEventListeners(int eventType,
		SQLException sqlException) {

	if (this.connectionEventListeners == null) {

		return;
	}

	Iterator<Map.Entry<ConnectionEventListener, ConnectionEventListener>> iterator = this.connectionEventListeners.entrySet().iterator();
	
	ConnectionEvent connectionevent = new ConnectionEvent(this,
			sqlException);

	while (iterator.hasNext()) {

		ConnectionEventListener connectioneventlistener = iterator.next().getValue();

		if (eventType == CONNECTION_CLOSED_EVENT) {
			connectioneventlistener.connectionClosed(connectionevent);
		} else if (eventType == CONNECTION_ERROR_EVENT) {
			connectioneventlistener
					.connectionErrorOccurred(connectionevent);
		}
	}
}
 

import javax.sql.ConnectionEventListener; //导入方法依赖的package包/类
/**
 * Notify listeners, if there is any, about the connection status.
 * If e is null, the connection is properly closed.
 * @param e
 */
protected synchronized void notifyListener(SQLException e){
	if(listeners != null && !listeners.isEmpty()){
		Iterator<ConnectionEventListener> iter = listeners.iterator();
		while(iter.hasNext()){
			ConnectionEventListener listener = iter.next();
			if(e == null){
				//no exception
				listener.connectionClosed(new ConnectionEvent(this));
			}else{
				//exception occurred
				listener.connectionErrorOccurred(new ConnectionEvent(this, e));	
			}
		}
	}	
}
 

import javax.sql.ConnectionEventListener; //导入方法依赖的package包/类
/**
 * Fire all the {@code ConnectionEventListener}s registered. Callers must
 * synchronize on {@code this} to prevent others from modifying the list of
 * listeners.
 *
 * @param exception the exception that caused the event, or {@code null} if
 * it is a close event
 */
private void fireConnectionEventListeners(SqlException exception) {
    if (!listeners_.isEmpty()) {
        final ConnectionEvent event = (exception == null) ?
            new ConnectionEvent(this) :
            new ConnectionEvent(this, exception.getSQLException());
        eventIterators++;
        try {
            for (Iterator it = listeners_.iterator(); it.hasNext(); ) {
                final ConnectionEventListener listener =
                    (ConnectionEventListener) it.next();
                if (exception == null) {
                    listener.connectionClosed(event);
                } else {
                    listener.connectionErrorOccurred(event);
                }
            }
        } finally {
            eventIterators--;
        }
    }
}
 

import javax.sql.ConnectionEventListener; //导入方法依赖的package包/类
/**
 * Fire all the {@code ConnectionEventListener}s registered. Callers must
 * synchronize on {@code this} to prevent others from modifying the list of
 * listeners.
 *
 * @param exception the exception that caused the event, or {@code null} if
 * it is a close event
 */
private void fireConnectionEventListeners(SQLException exception) {
    if (eventListener != null && !eventListener.isEmpty()) {
        ConnectionEvent event = new ConnectionEvent(this, exception);
        eventIterators++;
        try {
            for (Object anEventListener : eventListener) {
                ConnectionEventListener l =
                        (ConnectionEventListener) anEventListener;
                if (exception == null) {
                    l.connectionClosed(event);
                } else {
                    l.connectionErrorOccurred(event);
                }
            }
        } finally {
            eventIterators--;
        }
    }
}
 

import javax.sql.ConnectionEventListener; //导入方法依赖的package包/类
protected void fireSqlExceptionEvent(SQLException e) {

        ConnectionEvent event = new ConnectionEvent(this.pooledConnection, e);

        for (Iterator iterator = connectionListeners.iterator();
                iterator.hasNext(); ) {
            ConnectionEventListener connectionEventListener =
                (ConnectionEventListener) iterator.next();

            connectionEventListener.connectionErrorOccurred(event);
        }
    }
 

import javax.sql.ConnectionEventListener; //导入方法依赖的package包/类
void connectionErrorOccurred(SQLException sqlException)
{
	ConnectionEvent event = new ConnectionEvent(this, sqlException);
	for (ConnectionEventListener listener : connectionEventListeners)
	{
		listener.connectionErrorOccurred(event);
	}
}
 

import javax.sql.ConnectionEventListener; //导入方法依赖的package包/类
public void connectionErrorOccurred(ConnectionEvent event) {
	for (Iterator<ConnectionEventListener> itr = this.listeners.iterator(); itr.hasNext();) {
		ConnectionEventListener listener = itr.next();
		try {
			listener.connectionErrorOccurred(new ConnectionEvent(this, event.getSQLException()));
		} catch (RuntimeException rex) {
			logger.warn(rex.getMessage(), rex);
		}
	} // end-for (Iterator<ConnectionEventListener> itr = this.listeners.iterator(); itr.hasNext();)

	this.firePhysicalConnectionClosed(event); // removeConnectionEventListener
}
 

import javax.sql.ConnectionEventListener; //导入方法依赖的package包/类
private void fireConnectionErrorOccurred() {
	Iterator<ConnectionEventListener> itr = this.listeners.iterator();
	while (itr.hasNext()) {
		ConnectionEventListener listener = itr.next();
		try {
			listener.connectionErrorOccurred(new ConnectionEvent(this));
		} catch (Exception ex) {
			logger.debug(ex.getMessage(), ex);
		}
	}
}
 

import javax.sql.ConnectionEventListener; //导入方法依赖的package包/类
private SQLException handleException(SQLException e) throws SQLException {
  ConnectionEvent event = new ConnectionEvent(this, e);
  if (this.connectionEventListeners != null) {
    for (ConnectionEventListener eventListener : this.connectionEventListeners) {
      eventListener.connectionErrorOccurred(event);
    }
  }
  throw e;
}
 

import javax.sql.ConnectionEventListener; //导入方法依赖的package包/类
protected void notifyConnectionErrorOccurred(final SQLException e) {
    final ConnectionEvent event = new ConnectionEvent(this, e);
    final List<ConnectionEventListener> copy = new ArrayList<>(
            listeners);
    for (final ConnectionEventListener listener : copy) {
        listener.connectionErrorOccurred(event);
    }
}
 

import javax.sql.ConnectionEventListener; //导入方法依赖的package包/类
public void handleConnectionException(DruidPooledConnection pooledConnection, Throwable t) throws SQLException {
    final DruidConnectionHolder holder = pooledConnection.getConnectionHolder();

    errorCount.incrementAndGet();
    lastError = t;
    lastErrorTimeMillis = System.currentTimeMillis();

    if (t instanceof SQLException) {
        SQLException sqlEx = (SQLException) t;

        // broadcastConnectionError
        ConnectionEvent event = new ConnectionEvent(pooledConnection, sqlEx);
        for (ConnectionEventListener eventListener : holder.getConnectionEventListeners()) {
            eventListener.connectionErrorOccurred(event);
        }

        // exceptionSorter.isExceptionFatal
        if (exceptionSorter != null && exceptionSorter.isExceptionFatal(sqlEx)) {
            if (pooledConnection.isTraceEnable()) {
                synchronized (activeConnections) {
                    if (pooledConnection.isTraceEnable()) {
                        activeConnections.remove(pooledConnection);
                        pooledConnection.setTraceEnable(false);
                    }
                }
            }

            boolean requireDiscard = false;
            synchronized (pooledConnection) {
                if ((!pooledConnection.isClosed()) || !pooledConnection.isDisable()) {
                    holder.setDiscard(true);
                    pooledConnection.disable(t);
                    requireDiscard = true;
                }
            }

            if (requireDiscard) {
                this.discardConnection(holder.getConnection());
                holder.setDiscard(true);
            }

            LOG.error("discard connection", sqlEx);
        }

        throw sqlEx;
    } else {
        throw new SQLException("Error", t);
    }
}