import org.apache.mina.core.future.ReadFuture; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public final ReadFuture read() {
    if (!getConfig().isUseReadOperation()) {
        throw new IllegalStateException("useReadOperation is not enabled.");
    }

    Queue<ReadFuture> readyReadFutures = getReadyReadFutures();
    ReadFuture future;
    synchronized (readyReadFutures) {
        future = readyReadFutures.poll();
        if (future != null) {
            if (future.isClosed()) {
                // Let other readers get notified.
                readyReadFutures.offer(future);
            }
        } else {
            future = new DefaultReadFuture(this);
            getWaitingReadFutures().offer(future);
        }
    }

    return future;
}
 

import org.apache.mina.core.future.ReadFuture; //导入依赖的package包/类
protected byte[] recvResponse(ReadFuture readFuture, int timeout) throws Exception  {
	// 读取等待超时
	boolean b = readFuture.awaitUninterruptibly(timeout);
	if (!b)
		throw new Exception("接收远程Tcp服务器数据超时");
	if (!readFuture.isRead()) {
		if (readFuture.getException() != null)
			throw new Exception("接收远程Tcp服务器数据异常", readFuture.getException());
		throw new Exception("接收远程Tcp服务器数据异常");
	}
	
	Object ret = readFuture.getMessage();
	if (logger.isInfoEnabled())
		logger.info("TcpConnector RECEIVED:\r\n" + new String((byte[])ret));
	return (byte[]) ret;
}
 

import org.apache.mina.core.future.ReadFuture; //导入依赖的package包/类
@Override
protected <T extends Reply> T writeAndRead(Command command) throws IOException {
    Msg cmd = command.toMsg();
    WriteFuture wf = session.write(cmd);
    wf.awaitUninterruptibly();

    ReadFuture readFuture = session.read();
    readFuture.awaitUninterruptibly();
    Msg msg = (Msg) readFuture.getMessage();

    Reply reply = MsgConverter.convertReply(msg);

    return (T) reply;
}
 

import org.apache.mina.core.future.ReadFuture; //导入依赖的package包/类
/**
 * TODO Add method documentation
 */
public final void offerClosedReadFuture() {
    Queue<ReadFuture> readyReadFutures = getReadyReadFutures();
    synchronized (readyReadFutures) {
        newReadFuture().setClosed();
    }
}
 

import org.apache.mina.core.future.ReadFuture; //导入依赖的package包/类
/**
 * TODO Add method documentation
 */
private ReadFuture newReadFuture() {
    Queue<ReadFuture> readyReadFutures = getReadyReadFutures();
    Queue<ReadFuture> waitingReadFutures = getWaitingReadFutures();
    ReadFuture future;
    synchronized (readyReadFutures) {
        future = waitingReadFutures.poll();
        if (future == null) {
            future = new DefaultReadFuture(this);
            readyReadFutures.offer(future);
        }
    }
    return future;
}
 

import org.apache.mina.core.future.ReadFuture; //导入依赖的package包/类
/**
 * TODO Add method documentation
 */
private Queue<ReadFuture> getReadyReadFutures() {
    Queue<ReadFuture> readyReadFutures = (Queue<ReadFuture>) getAttribute(READY_READ_FUTURES_KEY);
    if (readyReadFutures == null) {
        readyReadFutures = new ConcurrentLinkedQueue<ReadFuture>();

        Queue<ReadFuture> oldReadyReadFutures = (Queue<ReadFuture>) setAttributeIfAbsent(READY_READ_FUTURES_KEY,
                readyReadFutures);
        if (oldReadyReadFutures != null) {
            readyReadFutures = oldReadyReadFutures;
        }
    }
    return readyReadFutures;
}
 

import org.apache.mina.core.future.ReadFuture; //导入依赖的package包/类
/**
 * TODO Add method documentation
 */
private Queue<ReadFuture> getWaitingReadFutures() {
    Queue<ReadFuture> waitingReadyReadFutures = (Queue<ReadFuture>) getAttribute(WAITING_READ_FUTURES_KEY);
    if (waitingReadyReadFutures == null) {
        waitingReadyReadFutures = new ConcurrentLinkedQueue<ReadFuture>();

        Queue<ReadFuture> oldWaitingReadyReadFutures = (Queue<ReadFuture>) setAttributeIfAbsent(
                WAITING_READ_FUTURES_KEY, waitingReadyReadFutures);
        if (oldWaitingReadyReadFutures != null) {
            waitingReadyReadFutures = oldWaitingReadyReadFutures;
        }
    }
    return waitingReadyReadFutures;
}
 

import org.apache.mina.core.future.ReadFuture; //导入依赖的package包/类
public void exceptionCaught(IoSession session, Throwable t){
	logger.error("TcpConnector exceptionCaught:" + session.getId(), t);
	ReadFuture future = getReadFuture(session);
	if (future != null)
		future.setException(new Exception(t));
    session.close(true);
}
 

import org.apache.mina.core.future.ReadFuture; //导入依赖的package包/类
public void sessionClosed(IoSession session) {
    logger.info("TcpConnector sessionClosed:" + session.getId() +" total " + session.getReadBytes() + " byte(s)");
    ReadFuture future = null;
	// 此处有可能远程主机已经关闭连接，但socket客户端未收到数据，故需要在此处抛出异常
	future = getReadFuture(session);
	if (future != null)
		future.setException(new Exception("远程服务器Tcp已关闭连接"));
}
 

import org.apache.mina.core.future.ReadFuture; //导入依赖的package包/类
public void messageReceived(IoSession session, Object message) {
    	// 日志放TcpConnector中，避免因为connector使用线程池而无法定位日志属于哪个接入线程
//    	if (logger.isInfoEnabled())
//			logger.info("TcpConnector RECEIVED:\r\n" + CommHelper.messageToString(cfg, message));
    	logger.debug("TcpConnector RECEIVED:" + session.getId());
    	ReadFuture future = getReadFuture(session);
    	if (future != null)
    		future.setRead(message);
    }
 

import org.apache.mina.core.future.ReadFuture; //导入依赖的package包/类
public void sessionIdle(IoSession session, IdleStatus status) {
super.sessionIdle(session, status);
  	ReadFuture future = getReadFuture(session);
if (future != null)
       future.setException(new Exception("远程服务器SOCKET通讯连接空闲：" + status));
      session.close(true);
  }
 

import org.apache.mina.core.future.ReadFuture; //导入依赖的package包/类
protected ReadFuture getReadFuture(IoSession s) {
	return handlers.get(s);
}
 

import org.apache.mina.core.future.ReadFuture; //导入依赖的package包/类
public void addReadFuture(IoSession s, ReadFuture f) {
	handlers.put(s, f);
}
 

import org.apache.mina.core.future.ReadFuture; //导入依赖的package包/类
@Override
public ReadFuture read() {
    return null;
}
 

import org.apache.mina.core.future.ReadFuture; //导入依赖的package包/类
@Override
public ReadFuture read() {
	throw new UnsupportedOperationException("Not supported yet.");
}
 

import org.apache.mina.core.future.ReadFuture; //导入依赖的package包/类
@Override
public ReadFuture read() {
    // TODO Auto-generated method stub
    return null;
}
 

import org.apache.mina.core.future.ReadFuture; //导入依赖的package包/类
/**
    * @see IoSession#read()
    */
   public ReadFuture read() {
return wrappedSession.read();
   }
 

import org.apache.mina.core.future.ReadFuture; //导入依赖的package包/类
/**
 * TODO This javadoc is wrong. The return tag should be short.
 * 
 * @return a {@link ReadFuture} which is notified when a new message is
 * received, the connection is closed or an exception is caught.  This
 * operation is especially useful when you implement a client application.
 * TODO : Describe here how we enable this feature.
 * However, please note that this operation is disabled by default and
 * throw {@link IllegalStateException} because all received events must be
 * queued somewhere to support this operation, possibly leading to memory
 * leak.  This means you have to keep calling {@link #read()} once you
 * enabled this operation.  To enable this operation, please call
 * {@link IoSessionConfig#setUseReadOperation(boolean)} with <tt>true</tt>.
 *
 * @throws IllegalStateException if
 * {@link IoSessionConfig#setUseReadOperation(boolean) useReadOperation}
 * option has not been enabled.
 */
ReadFuture read();