Java IoSession类代码示例

import org.apache.mina.common.IoSession; //导入依赖的package包/类
static MinaChannel getOrAddChannel(IoSession session, URL url, ChannelHandler handler) {
    if (session == null) {
        return null;
    }
    MinaChannel ret = (MinaChannel) session.getAttribute(CHANNEL_KEY);
    if (ret == null) {
        ret = new MinaChannel(session, url, handler);
        if (session.isConnected()) {
            MinaChannel old = (MinaChannel) session.setAttribute(CHANNEL_KEY, ret);
            if (old != null) {
                session.setAttribute(CHANNEL_KEY, old);
                ret = old;
            }
        }
    }
    return ret;
}
 

import org.apache.mina.common.IoSession; //导入依赖的package包/类
public void messageReceived(IoSession session, Object message) throws Exception {
  if (message instanceof List) {
    @SuppressWarnings("unchecked")
    List<ResponseWrapper> responses = (List<ResponseWrapper>) message;
    if (isDebugEnabled) {
      // for performance trace
      LOGGER.debug("receive response list from server: " + session.getRemoteAddress() + ",list size is:" + responses.size());
    }
    client.putResponses(responses);
  } else if (message instanceof ResponseWrapper) {
    ResponseWrapper response = (ResponseWrapper) message;
    if (isDebugEnabled) {
      // for performance trace
      LOGGER.debug("receive response list from server: " + session.getRemoteAddress() + ",request is:" + response.getRequestId());
    }
    client.putResponse(response);
  } else {
    LOGGER.error("receive message error,only support List || ResponseWrapper");
    throw new Exception("receive message error,only support List || ResponseWrapper");
  }
}
 

import org.apache.mina.common.IoSession; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void handleRequest(final IoSession session, final Object message) {
  try {
    threadpool.execute(new HandlerRunnable(session, message, threadpool));
  } catch (RejectedExecutionException exception) {
    LOGGER.error("server threadpool full,threadpool maxsize is:" + ((ThreadPoolExecutor) threadpool).getMaximumPoolSize());
    if (message instanceof List) {
      List<RequestWrapper> requests = (List<RequestWrapper>) message;
      for (final RequestWrapper request : requests) {
        sendErrorResponse(session, request);
      }
    } else {
      sendErrorResponse(session, (RequestWrapper) message);
    }
  }
}
 

import org.apache.mina.common.IoSession; //导入依赖的package包/类
@Override
public void encode(final IoSession session, final Object message, final ProtocolEncoderOutput out) throws Exception {
    final MapleClient client = (MapleClient) session.getAttribute(MapleClient.CLIENT_KEY);

    if (client != null) {
        final byte[] input = ((MaplePacket) message).getBytes();
        final byte[] unencrypted = new byte[input.length];
        System.arraycopy(input, 0, unencrypted, 0, input.length);

        final byte[] ret = new byte[unencrypted.length + 4];

        final byte[] header = client.getSendCrypto().getPacketHeader(unencrypted.length);
        synchronized(client.getSendCrypto()){
            MapleCustomEncryption.encryptData(unencrypted);
            client.getSendCrypto().crypt(unencrypted);

            System.arraycopy(header, 0, ret, 0, 4);
            System.arraycopy(unencrypted, 0, ret, 4, unencrypted.length);

            final ByteBuffer out_buffer = ByteBuffer.wrap(ret);
            out.write(out_buffer);
        }
    } else { // no client object created yet, send unencrypted (hello)
            out.write(ByteBuffer.wrap(((MaplePacket) message).getBytes()));
    }
}
 

import org.apache.mina.common.IoSession; //导入依赖的package包/类
public void encode(IoSession session, Object message,
		ProtocolEncoderOutput out) throws Exception {
	if(!(message instanceof byte[])){
		throw new Exception("must send byte[]");
	}
	byte[] payload=(byte[]) message;
	ByteBuffer buf = ByteBuffer.allocate(payload.length, false);
       buf.put(payload);
       buf.flip();
       out.write(buf);
       if (isDebugEnabled)
       	LOGGER.debug(TairUtil.toHex(payload));
}
 

import org.apache.mina.common.IoSession; //导入依赖的package包/类
@Override
public void exceptionCaught(final IoSession session, final Throwable cause) throws Exception {
    //cause.printStackTrace();
    /*
    MapleClient client = (MapleClient) session.getAttribute(MapleClient.CLIENT_KEY);
    log.error(MapleClient.getLogMessage(client, cause.getMessage()), cause);
    ChannelServer.getInstance(1).broadcastPacket(MaplePacketCreator.getChatText(30000, "Exception: " + cause.getClass().getName() + ": " + cause.getMessage()));
    for (int i = 0; i < cause.getStackTrace().length; ++i) {
        StackTraceElement ste = cause.getStackTrace()[i];
        ChannelServer.getInstance(1).broadcastPacket(MaplePacketCreator.getChatText(30000, ste.toString()));
        if (i > 2) {
            break;
        }
    }
    */
}
 

import org.apache.mina.common.IoSession; //导入依赖的package包/类
public Collection<Channel> getChannels() {
    Set<IoSession> sessions = acceptor.getManagedSessions(getBindAddress());
    Collection<Channel> channels = new HashSet<Channel>();
    for (IoSession session : sessions) {
        if (session.isConnected()) {
            channels.add(MinaChannel.getOrAddChannel(session, getUrl(), this));
        }
    }
    return channels;
}
 

import org.apache.mina.common.IoSession; //导入依赖的package包/类
public Channel getChannel(InetSocketAddress remoteAddress) {
    Set<IoSession> sessions = acceptor.getManagedSessions(getBindAddress());
    for (IoSession session : sessions) {
        if (session.getRemoteAddress().equals(remoteAddress)) {
            return MinaChannel.getOrAddChannel(session, getUrl(), this);
        }
    }
    return null;
}
 

import org.apache.mina.common.IoSession; //导入依赖的package包/类
private MinaChannel(IoSession session, URL url, ChannelHandler handler){
    super(url, handler);
    if (session == null) {
        throw new IllegalArgumentException("mina session == null");
    }
    this.session = session;
}
 

import org.apache.mina.common.IoSession; //导入依赖的package包/类
public void encode(IoSession session, Object msg, ProtocolEncoderOutput out) throws Exception {
    ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(1024);
    MinaChannel channel = MinaChannel.getOrAddChannel(session, url, handler);
    try {
    	codec.encode(channel, buffer, msg);
    } finally {
        MinaChannel.removeChannelIfDisconnectd(session);
    }
    out.write(ByteBuffer.wrap(buffer.toByteBuffer()));
    out.flush();
}
 

import org.apache.mina.common.IoSession; //导入依赖的package包/类
@Override
public void sessionOpened(IoSession session) throws Exception {
    MinaChannel channel = MinaChannel.getOrAddChannel(session, url, handler);
    try {
        handler.connected(channel);
    } finally {
        MinaChannel.removeChannelIfDisconnectd(session);
    }
}
 

import org.apache.mina.common.IoSession; //导入依赖的package包/类
@Override
public void sessionClosed(IoSession session) throws Exception {
    MinaChannel channel = MinaChannel.getOrAddChannel(session, url, handler);
    try {
        handler.disconnected(channel);
    } finally {
        MinaChannel.removeChannelIfDisconnectd(session);
    }
}
 

import org.apache.mina.common.IoSession; //导入依赖的package包/类
@Override
public void messageReceived(IoSession session, Object message) throws Exception {
    MinaChannel channel = MinaChannel.getOrAddChannel(session, url, handler);
    try {
        handler.received(channel, message);
    } finally {
        MinaChannel.removeChannelIfDisconnectd(session);
    }
}
 

import org.apache.mina.common.IoSession; //导入依赖的package包/类
@Override
public void messageSent(IoSession session, Object message) throws Exception {
    MinaChannel channel = MinaChannel.getOrAddChannel(session, url, handler);
    try {
        handler.sent(channel, message);
    } finally {
        MinaChannel.removeChannelIfDisconnectd(session);
    }
}
 

import org.apache.mina.common.IoSession; //导入依赖的package包/类
@Override
public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
    MinaChannel channel = MinaChannel.getOrAddChannel(session, url, handler);
    try {
        handler.caught(channel, cause);
    } finally {
        MinaChannel.removeChannelIfDisconnectd(session);
    }
}