Java SelectionKey.attach方法代码示例

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
private void closeCurrentConnection(SelectionKey key, Throwable e) {
  if (key != null) {
    Connection c = (Connection)key.attachment();
    if (c != null) {
      if (LOG.isDebugEnabled()) {
        LOG.debug(getName() + ": disconnecting client " + c.getHostAddress() +
            (e != null ? " on error " + e.getMessage() : ""));
      }
      closeConnection(c);
      key.attach(null);
    }
  }
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
private void doAccept(SelectionKey sk){
    ServerSocketChannel server=(ServerSocketChannel)sk.channel();
    SocketChannel clientChannel;
    try {
        //获取客户端的channel
        clientChannel = server.accept();
        clientChannel.configureBlocking(false);

        //register the channel for reading
        SelectionKey clientKey=clientChannel.register(selector,SelectionKey.OP_READ);
        //Allocate an EchoClient instance and attach it to this selection key.
        EchoClient echoClient=new EchoClient();
        clientKey.attach(echoClient);

        InetAddress clientAddress=clientChannel.socket().getInetAddress();
        System.out.println("Accepted connetion from "+clientAddress.getHostAddress()+".");
    }catch (Exception e){
        System.out.println("Failed to accept new client");
        e.printStackTrace();
    }
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
/**
 * out node try to connect
 *
 * @param node
 */
public void openConnection(Node node) {

    SocketChannel channel = null;
    try {
        channel = SocketChannel.open();
        channel.configureBlocking(false);
        channel.socket().setReuseAddress(true);
        InetSocketAddress socketAddress = new InetSocketAddress(node.getIp(), node.getPort());
        channel.connect(socketAddress);
        PendingConnect data = new PendingConnect(channel, node);
        SelectionKey key = channel.register(selector, SelectionKey.OP_CONNECT);
        key.attach(data);
        selector.wakeup();
    } catch (IOException e) {
        e.printStackTrace();
        if (channel != null) {
            try {
                channel.close();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
        node.destroy();
    }
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
/**
 * Unregister a channel. The connections streams are not drained before finishing.
 * @param c
 */
void unregisterChannel (Connection c) {
    VoltPort port = (VoltPort)c;
    assert(c != null);
    SelectionKey selectionKey = port.getKey();

    acquireRegistrationLock();
    try {
        synchronized (m_ports) {
            if (!m_ports.contains(port)) {
                return;
            }
        }
        port.unregistering();
        selectionKey.cancel();
        selectionKey.attach(null);
        synchronized (m_ports) {
            m_ports.remove(port);
        }
    } finally {
        releaseRegistrationLock();
    }
    port.unregistered();
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
private final void acceptConnection(SelectionKey key, MMOConnection<T> con)
{
	final ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
	SocketChannel sc;
	
	try
	{
		while ((sc = ssc.accept()) != null)
		{
			if ((_acceptFilter == null) || _acceptFilter.accept(sc))
			{
				sc.configureBlocking(false);
				final SelectionKey clientKey = sc.register(_selector, SelectionKey.OP_READ);
				con = new MMOConnection<>(this, sc.socket(), clientKey, TCP_NODELAY);
				con.setClient(_clientFactory.create(con));
				clientKey.attach(con);
			}
			else
			{
				sc.socket().close();
			}
		}
	}
	catch (IOException e)
	{
		e.printStackTrace();
	}
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
public void remove(final KeyAttachment key, final int ops) {
    Runnable r = new Runnable() {
        @Override
        public void run() {
            if ( key == null ) return;
            NioChannel nch = key.getChannel();
            if ( nch == null ) return;
            SocketChannel ch = nch.getIOChannel();
            if ( ch == null ) return;
            SelectionKey sk = ch.keyFor(selector);
            try {
                if (sk == null) {
                    if (SelectionKey.OP_WRITE==(ops&SelectionKey.OP_WRITE)) countDown(key.getWriteLatch());
                    if (SelectionKey.OP_READ==(ops&SelectionKey.OP_READ))countDown(key.getReadLatch());
                } else {
                    if (sk.isValid()) {
                        sk.interestOps(sk.interestOps() & (~ops));
                        if (SelectionKey.OP_WRITE==(ops&SelectionKey.OP_WRITE)) countDown(key.getWriteLatch());
                        if (SelectionKey.OP_READ==(ops&SelectionKey.OP_READ))countDown(key.getReadLatch());
                        if (sk.interestOps()==0) {
                            sk.cancel();
                            sk.attach(null);
                        }
                    }else {
                        sk.cancel();
                        sk.attach(null);
                    }
                }
            }catch (CancelledKeyException cx) {
                if (sk!=null) {
                    sk.cancel();
                    sk.attach(null);
                }
            }
        }
    };
    events.offer(r);
    wakeup();
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
private void clearDeferredRegistrations() {
    synchronized (deferredRegistrations) {
        int deferredListSize = deferredRegistrations.size();
        if (orb.transportDebugFlag) {
            dprint(".clearDeferredRegistrations:deferred list size == " + deferredListSize);
        }
        for (int i = 0; i < deferredListSize; i++) {
            EventHandler eventHandler =
                (EventHandler)deferredRegistrations.get(i);
            if (orb.transportDebugFlag) {
                dprint(".clearDeferredRegistrations: " + eventHandler);
            }
            SelectableChannel channel = eventHandler.getChannel();
            SelectionKey selectionKey = null;

            try {
                if (orb.transportDebugFlag) {
                    dprint(".clearDeferredRegistrations:close channel == "
                            + channel);
                    dprint(".clearDeferredRegistrations:close channel class == "
                            + channel.getClass().getName());
                }
                channel.close();
                selectionKey = eventHandler.getSelectionKey();
                if (selectionKey != null) {
                    selectionKey.cancel();
                    selectionKey.attach(null);
                }
            } catch (IOException ioEx) {
                if (orb.transportDebugFlag) {
                    dprint(".clearDeferredRegistrations: ", ioEx);
                }
            }
        }
        deferredRegistrations.clear();
    }
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
@Override
public void register(TCPClientSocket clientSocket, boolean writable) throws IOException {

    int interestOps = SelectionKey.OP_READ;
    if (writable) {
        interestOps |= SelectionKey.OP_WRITE;
    }

    SelectionKey key = clientSocket.getChannel().register(selector, interestOps);
    key.attach(clientSocket);
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
private void clearSelectionKey() {
    try {
        SelectionKey key = this.processKey;
        if (key != null && key.isValid()) {
            key.attach(null);
            key.cancel();
        }
    } catch (Exception e) {
        AbstractConnection.LOGGER.info("clear selector keys err:" + e);
    }
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
public void cancel(SelectionKey sk, KeyAttachment key, int ops){
    if (sk!=null) {
        sk.cancel();
        sk.attach(null);
        if (SelectionKey.OP_WRITE==(ops&SelectionKey.OP_WRITE)) countDown(key.getWriteLatch());
        if (SelectionKey.OP_READ==(ops&SelectionKey.OP_READ))countDown(key.getReadLatch());
    }
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
private void addInNode(SelectionKey key) {
    SocketChannel socketChannel = null;
    Node node = null;
    try {
        socketChannel = serverSocketChannel.accept();
        InetSocketAddress socketAddress = (InetSocketAddress) socketChannel.getRemoteAddress();
        if (!allowConnection(socketAddress)) {
            socketChannel.close();
            return;
        }
        socketChannel.configureBlocking(false);
        SelectionKey newKey = socketChannel.register(selector, SelectionKey.OP_READ);

        node = new Node(network, Node.IN, socketAddress);
        nodesManager.addNodeToGroup(NetworkConstant.NETWORK_NODE_IN_GROUP, node);
        ConnectionHandler handler = new ConnectionHandler(node, socketChannel, newKey);
        node.setWriteTarget(handler);
        newKey.attach(handler);
        node.connectionOpened();
    } catch (Exception e) {
        if (socketChannel != null) {
            Log.warn("in node Failed to connect" + node.getIp());
            try {
                socketChannel.close();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
        if (node != null) {
            node.destroy();
        }
    }
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
private final void closeConnectionImpl(SelectionKey key, MMOConnection<T> con)
{
	try
	{
		// notify connection
		con.getClient().onDisconnection();
	}
	finally
	{
		try
		{
			// close socket and the SocketChannel
			con.close();
		}
		catch (IOException e)
		{
			// ignore, we are closing anyway
		}
		finally
		{
			con.releaseBuffers();
			// clear attachment
			key.attach(null);
			// cancel key
			key.cancel();
		}
	}
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
private void clearSelectionKey(SelectionKey key) {
    if (key.isValid()) {
        key.attach(null);
        key.cancel();
    }
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
private void clearSelectionKey(SelectionKey key) {
	if (key.isValid()) {
		key.attach(null);
		key.cancel();
	}
}
 

import java.nio.channels.SelectionKey; //导入方法依赖的package包/类
protected boolean processKey(SelectionKey sk, KeyAttachment attachment) {
    boolean result = true;
    try {
        if ( close ) {
            cancelledKey(sk, SocketStatus.STOP, attachment.comet);
        } else if ( sk.isValid() && attachment != null ) {
            attachment.access();//make sure we don't time out valid sockets
            sk.attach(attachment);//cant remember why this is here
            NioChannel channel = attachment.getChannel();
            if (sk.isReadable() || sk.isWritable() ) {
                if ( attachment.getSendfileData() != null ) {
                    processSendfile(sk,attachment, false);
                } else {
                    if ( isWorkerAvailable() ) {
                        unreg(sk, attachment, sk.readyOps());
                        boolean closeSocket = false;
                        // Read goes before write
                        if (sk.isReadable()) {
                            if (!processSocket(channel, SocketStatus.OPEN_READ, true)) {
                                closeSocket = true;
                            }
                        }
                        if (!closeSocket && sk.isWritable()) {
                            if (!processSocket(channel, SocketStatus.OPEN_WRITE, true)) {
                                closeSocket = true;
                            }
                        }
                        if (closeSocket) {
                            cancelledKey(sk,SocketStatus.DISCONNECT,false);
                        }
                    } else {
                        result = false;
                    }
                }
            }
        } else {
            //invalid key
            cancelledKey(sk, SocketStatus.ERROR,false);
        }
    } catch ( CancelledKeyException ckx ) {
        cancelledKey(sk, SocketStatus.ERROR,false);
    } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
        log.error("",t);
    }
    return result;
}