Java ConnectionEventListener.connectionClosed方法代码示例

import javax.resource.spi.ConnectionEventListener; //导入方法依赖的package包/类
void connectionClosed(WrappedConnection wc) {
	
	synchronized (this.handles) {
		handles.remove(wc);
	}
	
	ConnectionEvent ce = new ConnectionEvent(this, ConnectionEvent.CONNECTION_CLOSED);
	ce.setConnectionHandle(wc);
	
	ArrayList<ConnectionEventListener> copy = null;
	synchronized (this.listeners) {
		copy = new ArrayList<ConnectionEventListener>(this.listeners);
	}
	
	for(ConnectionEventListener l: copy) {
		l.connectionClosed(ce);
	}
}
 

import javax.resource.spi.ConnectionEventListener; //导入方法依赖的package包/类
protected void sendConnectionEvent(ConnectionEvent connEvent) {
for (int i = listeners.size() - 1; i >= 0; i--) {
    ConnectionEventListener listener =
	(ConnectionEventListener) listeners.get(i);
    if (connEvent.getId() == ConnectionEvent.CONNECTION_CLOSED) {
	listener.connectionClosed(connEvent);
    } else if (connEvent.getId() ==
	       ConnectionEvent.CONNECTION_ERROR_OCCURRED) {
	listener.connectionErrorOccurred(connEvent);
    } else if (connEvent.getId() ==
	       ConnectionEvent.LOCAL_TRANSACTION_STARTED) {
	listener.localTransactionStarted(connEvent);
    } else if (connEvent.getId() ==
	       ConnectionEvent.LOCAL_TRANSACTION_COMMITTED) {
	listener.localTransactionCommitted(connEvent);
    } else if (connEvent.getId() ==
	       ConnectionEvent.LOCAL_TRANSACTION_ROLLEDBACK) {
	listener.localTransactionRolledback(connEvent);
    }
}
   }
 

import javax.resource.spi.ConnectionEventListener; //导入方法依赖的package包/类
protected void sendConnectionEvent(ConnectionEvent connEvent) {
    for (int i = listeners.size() - 1; i >= 0; i--) {
        ConnectionEventListener listener =
            listeners.get(i);
        if (connEvent.getId() == ConnectionEvent.CONNECTION_CLOSED) {
            listener.connectionClosed(connEvent);
        } else if (connEvent.getId() ==
                   ConnectionEvent.CONNECTION_ERROR_OCCURRED) {
            listener.connectionErrorOccurred(connEvent);
        } else if (connEvent.getId() ==
                   ConnectionEvent.LOCAL_TRANSACTION_STARTED) {
            listener.localTransactionStarted(connEvent);
        } else if (connEvent.getId() ==
                   ConnectionEvent.LOCAL_TRANSACTION_COMMITTED) {
            listener.localTransactionCommitted(connEvent);
        } else if (connEvent.getId() ==
                   ConnectionEvent.LOCAL_TRANSACTION_ROLLEDBACK) {
            listener.localTransactionRolledback(connEvent);
        }
    }
}
 

import javax.resource.spi.ConnectionEventListener; //导入方法依赖的package包/类
public void fireConnectionEvent(int event) {
	ConnectionEvent connnectionEvent = new ConnectionEvent(this, event);
	connnectionEvent.setConnectionHandle(this.remoteConnection);
	for (ConnectionEventListener listener : this.listeners) {
		switch (event) {
		case LOCAL_TRANSACTION_STARTED:
			listener.localTransactionStarted(connnectionEvent);
			break;
		case LOCAL_TRANSACTION_COMMITTED:
			listener.localTransactionCommitted(connnectionEvent);
			break;
		case LOCAL_TRANSACTION_ROLLEDBACK:
			listener.localTransactionRolledback(connnectionEvent);
			break;
		case CONNECTION_CLOSED:
			listener.connectionClosed(connnectionEvent);
			break;
		default:
			throw new IllegalArgumentException("Unknown event: " + event);
		}
	}
}
 

import javax.resource.spi.ConnectionEventListener; //导入方法依赖的package包/类
public void connectionClosed(CI handle) {
    ConnectionEvent event = new ConnectionEvent(this, ConnectionEvent.CONNECTION_CLOSED);
    event.setConnectionHandle(handle);
    // count down in case sending the event results in a handle getting removed.
    if (listeners != null) {
        for (ConnectionEventListener listener : reverse(listeners)) {
            listener.connectionClosed(event);
        }
    }
    if (listener != null) {
        listener.connectionClosed(event);
    }
}
 

import javax.resource.spi.ConnectionEventListener; //导入方法依赖的package包/类
/**
 * Close handle
 *
 * @param handle
 *          The handle
 */
void closeHandle(RabbitmqConnection handle) {
  ConnectionEvent event = new ConnectionEvent(this,
      ConnectionEvent.CONNECTION_CLOSED);
  event.setConnectionHandle(handle);
  for (ConnectionEventListener cel : listeners) {
    cel.connectionClosed(event);
  }

}
 

import javax.resource.spi.ConnectionEventListener; //导入方法依赖的package包/类
public void close(TransactionAssistant handle) {
    ConnectionEvent event = new ConnectionEvent(this, ConnectionEvent.CONNECTION_CLOSED);
    event.setConnectionHandle(handle);
    for(ConnectionEventListener l : listeners){
        l.connectionClosed(event);
    }
}
 

import javax.resource.spi.ConnectionEventListener; //导入方法依赖的package包/类
/**
 * Send an event.
 *
 * @param event The event to send.
 */
protected void sendEvent(final ConnectionEvent event) {
   if (logger.isTraceEnabled()) {
      ActiveMQRALogger.LOGGER.trace("sendEvent(" + event + ")");
   }

   int type = event.getId();

   // convert to an array to avoid concurrent modification exceptions
   ConnectionEventListener[] list = eventListeners.toArray(new ConnectionEventListener[eventListeners.size()]);

   for (ConnectionEventListener l : list) {
      switch (type) {
         case ConnectionEvent.CONNECTION_CLOSED:
            l.connectionClosed(event);
            break;

         case ConnectionEvent.LOCAL_TRANSACTION_STARTED:
            l.localTransactionStarted(event);
            break;

         case ConnectionEvent.LOCAL_TRANSACTION_COMMITTED:
            l.localTransactionCommitted(event);
            break;

         case ConnectionEvent.LOCAL_TRANSACTION_ROLLEDBACK:
            l.localTransactionRolledback(event);
            break;

         case ConnectionEvent.CONNECTION_ERROR_OCCURRED:
            l.connectionErrorOccurred(event);
            break;

         default:
            throw new IllegalArgumentException("Illegal eventType: " + type);
      }
   }
}
 

import javax.resource.spi.ConnectionEventListener; //导入方法依赖的package包/类
void sendEvent(ConnectionEvent ce)
{
	Vector list = (Vector) m_listeners.clone();
	int size = list.size();
	for (int i = 0; i < size; i++)
	{
		ConnectionEventListener l =
				(ConnectionEventListener) list.elementAt(i);
		switch (ce.getId())
		{
			case ConnectionEvent.CONNECTION_CLOSED:
				l.connectionClosed(ce);
				break;
			case ConnectionEvent.LOCAL_TRANSACTION_STARTED:
				l.localTransactionStarted(ce);
				break;
			case ConnectionEvent.LOCAL_TRANSACTION_COMMITTED:
				l.localTransactionCommitted(ce);
				break;
			case ConnectionEvent.LOCAL_TRANSACTION_ROLLEDBACK:
				l.localTransactionRolledback(ce);
				break;
			case ConnectionEvent.CONNECTION_ERROR_OCCURRED:
				l.connectionErrorOccurred(ce);
				break;
			default:
				throw new IllegalArgumentException("Illegal eventType: " + ce.getId());
		}
	}
}
 

import javax.resource.spi.ConnectionEventListener; //导入方法依赖的package包/类
/**
 * Close handle
 *
 * @param handle
 *          The handle
 */
void closeHandle(VertxConnectionImpl handle) {
  ConnectionEvent event = new ConnectionEvent(this,
      ConnectionEvent.CONNECTION_CLOSED);
  event.setConnectionHandle(handle);
  for (ConnectionEventListener cel : listeners) {
    cel.connectionClosed(event);
  }
}
 

import javax.resource.spi.ConnectionEventListener; //导入方法依赖的package包/类
/**
 *
 * @param handle
 */
public void closeHandle(BeanstalkdConnectionImpl handle) {
    try {
        ConnectionEvent event = new ConnectionEvent(this, ConnectionEvent.CONNECTION_CLOSED);
        event.setConnectionHandle(handle);
        for (ConnectionEventListener cel : listeners) {
            cel.connectionClosed(event);
        }
    } catch (Exception ex) {
        System.out.println(ex.getMessage());
        ex.printStackTrace(System.err);
        LOG.error("Error while closing connection", ex);
    }
}
 

import javax.resource.spi.ConnectionEventListener; //导入方法依赖的package包/类
/**
 * Close handle
 *
 * @param handle The handle
 */
void closeHandle(UnifiedSecurityConnection handle)
{
   connectionSet.remove(handle);

   ConnectionEvent event = new ConnectionEvent(this, ConnectionEvent.CONNECTION_CLOSED);
   event.setConnectionHandle(handle);

   List<ConnectionEventListener> copy = new ArrayList<ConnectionEventListener>(listeners);
   for (ConnectionEventListener cel : copy)
   {
      cel.connectionClosed(event);
   }

}
 

import javax.resource.spi.ConnectionEventListener; //导入方法依赖的package包/类
/**
 * Close handle
 *
 * @param handle The handle
 */
void closeHandle(WorkConnection handle)
{
   ConnectionEvent event = new ConnectionEvent(this, ConnectionEvent.CONNECTION_CLOSED);
   event.setConnectionHandle(handle);
   for (ConnectionEventListener cel : listeners)
   {
      cel.connectionClosed(event);
   }

}
 

import javax.resource.spi.ConnectionEventListener; //导入方法依赖的package包/类
/**
 * Close handle
 *
 * @param handle The handle
 */
void closeHandle(LazyConnection handle)
{
   ConnectionEvent event = new ConnectionEvent(this, ConnectionEvent.CONNECTION_CLOSED);
   event.setConnectionHandle(handle);
   for (ConnectionEventListener cel : listeners)
   {
      cel.connectionClosed(event);
   }
}
 

import javax.resource.spi.ConnectionEventListener; //导入方法依赖的package包/类
/**
 * Close handle
 */
void closeHandle()
{
   ConnectionEvent closeEvent = new ConnectionEvent(this, ConnectionEvent.CONNECTION_CLOSED);
   closeEvent.setConnectionHandle(connection);

   List<ConnectionEventListener> copy = new ArrayList<ConnectionEventListener>(listeners);
   for (ConnectionEventListener cel : copy)
   {
      cel.connectionClosed(closeEvent);
   }
}