import javax.resource.spi.ConnectionEventListener; //导入依赖的package包/类
/**
 * Creates a new connection for the managed connection pool.
 * 
 * @return the managed connection from the EIS as ManagedConnection object.
 * @throws PoolException
 */
@Override
public Object getNewPoolConnection() throws PoolException {
  ManagedConnection manConn = null;
  try {
    manConn = connFactory.createManagedConnection(sub, connReqInfo);
  } catch (ResourceException rex) {
    rex.printStackTrace();
    throw new PoolException(
        LocalizedStrings.ManagedPoolCacheImpl_MANAGEDPOOLCACHEIMPLGETNEWCONNECTION_EXCEPTION_IN_CREATING_NEW_MANAGED_POOLEDCONNECTION
            .toLocalizedString(),
        rex);
  }
  manConn
      .addConnectionEventListener((javax.resource.spi.ConnectionEventListener) connEventListner);
  return manConn;
}
 

import javax.resource.spi.ConnectionEventListener; //导入依赖的package包/类
/**
 * Destroys the underline physical connection to EIS.
 * 
 * @param connectionObject connection Object.
 */
@Override
void destroyPooledConnection(Object connectionObject) {
  try {
    ((ManagedConnection) connectionObject)
        .removeConnectionEventListener((ConnectionEventListener) connEventListner);
    ((ManagedConnection) connectionObject).destroy();
    connectionObject = null;
  } catch (ResourceException rex) {
    if (logger.isTraceEnabled()) {
      logger.trace(
          "ManagedPoolcacheImpl::destroyPooledConnection:Exception in closing the connection.Ignoring it. The exeption is {}",
          rex.getMessage(), rex);
    }
  }
}
 

import javax.resource.spi.ConnectionEventListener; //导入依赖的package包/类
private void onError(Exception e) {

    this.localTran = null;

    synchronized (this.connections) {
      Iterator<GFConnectionImpl> connsItr = this.connections.iterator();
      while (connsItr.hasNext()) {
        GFConnectionImpl conn = connsItr.next();
        conn.invalidate();
        synchronized (this.listeners) {
          Iterator<ConnectionEventListener> itr = this.listeners.iterator();
          ConnectionEvent ce =
              new ConnectionEvent(this, ConnectionEvent.CONNECTION_ERROR_OCCURRED, e);
          ce.setConnectionHandle(conn);
          while (itr.hasNext()) {
            itr.next().connectionErrorOccurred(ce);
          }
        }
        connsItr.remove();
      }
    }

  }
 

import javax.resource.spi.ConnectionEventListener; //导入依赖的package包/类
public void onClose(GFConnectionImpl conn) throws ResourceException {
  conn.invalidate();
  this.connections.remove(conn);
  synchronized (this.listeners) {
    Iterator<ConnectionEventListener> itr = this.listeners.iterator();
    ConnectionEvent ce = new ConnectionEvent(this, ConnectionEvent.CONNECTION_CLOSED);
    ce.setConnectionHandle(conn);
    while (itr.hasNext()) {
      itr.next().connectionClosed(ce);
    }
  }
  if (this.connections.isEmpty()) {
    // safe to dissociate this managedconnection so that it can go to pool
    if (this.initDone && !this.cache.isClosed()) {
      this.localTran = new JCALocalTransaction(this.cache, this.gfTxMgr);
    } else {
      this.localTran = new JCALocalTransaction();
    }
  }

}
 

import javax.resource.spi.ConnectionEventListener; //导入依赖的package包/类
/**
 * Destroys the underline physical connection to EIS.
 * 
 * @param connectionObject connection Object.
 */
@Override
void destroyPooledConnection(Object connectionObject) {
  try {
    ((ManagedConnection) connectionObject)
        .removeConnectionEventListener((ConnectionEventListener) connEventListner);
    ((ManagedConnection) connectionObject).destroy();
    connectionObject = null;
  }
  catch (ResourceException rex) {
    LogWriterI18n writer = TransactionUtils.getLogWriterI18n();
    if (writer.finerEnabled())
        writer
            .finer(
                "ManagedPoolcacheImpl::destroyPooledConnection:Exception in closing the connection.Ignoring it. The exeption is "
                    + rex.toString(), rex);
  }
}
 

import javax.resource.spi.ConnectionEventListener; //导入依赖的package包/类
private void onError(Exception e)
{

  this.localTran = null;

  synchronized (this.connections) {
    Iterator<GFConnectionImpl> connsItr = this.connections.iterator();
    while (connsItr.hasNext()) {
      GFConnectionImpl conn = connsItr.next();
      conn.invalidate();
      synchronized (this.listeners) {
        Iterator<ConnectionEventListener> itr = this.listeners.iterator();
        ConnectionEvent ce = new ConnectionEvent(this,
            ConnectionEvent.CONNECTION_ERROR_OCCURRED, e);
        ce.setConnectionHandle(conn);
        while (itr.hasNext()) {
          itr.next().connectionErrorOccurred(ce);
        }
      }
      connsItr.remove();
    }
  }

}
 

import javax.resource.spi.ConnectionEventListener; //导入依赖的package包/类
public void onClose(GFConnectionImpl conn) throws ResourceException
{
  conn.invalidate();
  this.connections.remove(conn);
  synchronized (this.listeners) {
    Iterator<ConnectionEventListener> itr = this.listeners.iterator();
    ConnectionEvent ce = new ConnectionEvent(this,
        ConnectionEvent.CONNECTION_CLOSED);
    ce.setConnectionHandle(conn);
    while (itr.hasNext()) {
      itr.next().connectionClosed(ce);
    }
  }
  if (this.connections.isEmpty()) {
    // safe to dissociate this managedconnection so that it can go to pool
    if (this.initDone && !this.cache.isClosed()) {
      this.localTran = new JCALocalTransaction(this.cache, this.gfTxMgr);
    }
    else {
      this.localTran = new JCALocalTransaction();
    }
  }

}
 

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包/类
JEManagedConnection(Subject subject, JERequestInfo jeInfo)
    throws ResourceException {

    try {
        savedTransConfig = jeInfo.getTransactionConfig();
        this.env = new XAEnvironment(jeInfo.getJERootDir(),
                                     jeInfo.getEnvConfig());
    } catch (DatabaseException DE) {
        throw new ResourceException(DE.toString());
    }
      listeners = new ArrayList<ConnectionEventListener>();
    savedLT = null;
    rwDatabaseHandleCache = new HashMap<String,Database>();
    roDatabaseHandleCache = new HashMap<String,Database>();
    rwSecondaryDatabaseHandleCache = new HashMap<String,Database>();
    roSecondaryDatabaseHandleCache = new HashMap<String,Database>();
}
 

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包/类
/**
 * Default constructor
 * @param localTransaction Support local transaction
 * @param xaTransaction Support XA transaction
 * @param mcf The managed connection factory
 * @param cm The connection manager
 */
public LazyManagedConnection(boolean localTransaction, boolean xaTransaction,
                             LazyManagedConnectionFactory mcf, ConnectionManager cm)
{
   this.localTransaction = localTransaction;
   this.xaTransaction = xaTransaction;
   this.enlisted = false;
   this.mcf = mcf;
   this.cm = cm;
   this.logwriter = null;
   this.listeners = Collections.synchronizedList(new ArrayList<ConnectionEventListener>(1));
   this.connection = null;
   this.lazyLocalTransaction = null;
   this.lazyXAResource = null;

   if (localTransaction)
      this.lazyLocalTransaction = new LazyLocalTransaction(this);

   if (xaTransaction)
      this.lazyXAResource = new LazyXAResource(this);
}
 

import javax.resource.spi.ConnectionEventListener; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public void begin() throws ResourceException
{
   if (txBeginDuration > 0)
   {
      try
      {
         Thread.sleep(txBeginDuration);
      }
      catch (Exception e)
      {
         // Ignore
      }
   }

   ConnectionEvent ce = new ConnectionEvent(this, ConnectionEvent.LOCAL_TRANSACTION_STARTED);
   
   for (ConnectionEventListener cel : listeners)
   {
      cel.localTransactionStarted(ce);
   }
}
 

import javax.resource.spi.ConnectionEventListener; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public void commit() throws ResourceException
{
   if (txCommitDuration > 0)
   {
      try
      {
         Thread.sleep(txCommitDuration);
      }
      catch (Exception e)
      {
         // Ignore
      }
   }

   ConnectionEvent ce = new ConnectionEvent(this, ConnectionEvent.LOCAL_TRANSACTION_COMMITTED);
   
   for (ConnectionEventListener cel : listeners)
   {
      cel.localTransactionCommitted(ce);
   }
}
 

import javax.resource.spi.ConnectionEventListener; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public void rollback() throws ResourceException
{
   if (txCommitDuration > 0)
   {
      try
      {
         Thread.sleep(txCommitDuration);
      }
      catch (Exception e)
      {
         // Ignore
      }
   }

   ConnectionEvent ce = new ConnectionEvent(this, ConnectionEvent.LOCAL_TRANSACTION_ROLLEDBACK);
   
   for (ConnectionEventListener cel : listeners)
   {
      cel.localTransactionRolledback(ce);
   }
}
 

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包/类
protected void unfilteredConnectionError(Exception e) {
    ConnectionEvent event = new ConnectionEvent(this, ConnectionEvent.CONNECTION_ERROR_OCCURRED, e);
    if (listeners != null) {
        for (ConnectionEventListener listener : reverse(listeners)) {
            listener.connectionErrorOccurred(event);
        }
    }
    if (listener != null) {
        listener.connectionErrorOccurred(event);
    }
}
 

import javax.resource.spi.ConnectionEventListener; //导入依赖的package包/类
public void addConnectionEventListener(ConnectionEventListener connectionEventListener) {
    if (listener == null) {
        listener = connectionEventListener;
    } else {
        if (listeners == null) {
            listeners = new ArrayDeque<>();
        }
        listeners.add(connectionEventListener);
    }
}
 

import javax.resource.spi.ConnectionEventListener; //导入依赖的package包/类
public void removeConnectionEventListener(ConnectionEventListener connectionEventListener) {
    if (listener == connectionEventListener) {
        listener = null;
        if (listeners != null) {
            listener = listeners.removeFirst();
        }
    } else if (listeners != null) {
        listeners.remove(connectionEventListener);
    }
}