Java SocketChannel类代码示例

import java.nio.channels.SocketChannel; //导入依赖的package包/类
public Client(Selector selector, SocketChannel clientChannel, CloseListener<Client> closeListener) throws ClosedChannelException {
    id = nextId++;
    this.clientChannel = clientChannel;
    router = new Router(this, selector);
    pendingIdBuffer = createIntBuffer(id);

    SelectionHandler selectionHandler = (selectionKey) -> {
        if (selectionKey.isValid() && selectionKey.isWritable()) {
            processSend();
        }
        if (selectionKey.isValid() && selectionKey.isReadable()) {
            processReceive();
        }
        if (selectionKey.isValid()) {
            updateInterests();
        }
    };
    // on start, we are interested only in writing (we must first send the client id)
    interests = SelectionKey.OP_WRITE;
    selectionKey = clientChannel.register(selector, interests, selectionHandler);

    this.closeListener = closeListener;
}
 

import java.nio.channels.SocketChannel; //导入依赖的package包/类
@Override
protected FrameBuffer createFrameBuffer(TNonblockingTransport trans, SelectionKey selectionKey,
                                        AbstractSelectThread selectThread) {
    TrackingFrameBuffer frameBuffer = new TrackingFrameBuffer(trans, selectionKey, selectThread);
    if (trans instanceof TNonblockingSocket) {
        try {
            SocketChannel socketChannel = ((TNonblockingSocket) trans).getSocketChannel();
            InetAddress addr = ((InetSocketAddress) socketChannel.getRemoteAddress()).getAddress();
            clientAddresses.put(frameBuffer.getInputFramedTransport(), addr);
        } catch (IOException e) {
            log.warn("Exception while tracking client address", e);
            clientAddresses.remove(frameBuffer.getInputFramedTransport());
        }
    } else {
        log.warn("Unknown TNonblockingTransport instance: {}", trans.getClass().getName());
        clientAddresses.remove(frameBuffer.getInputFramedTransport());
    }
    return frameBuffer;
}
 

import java.nio.channels.SocketChannel; //导入依赖的package包/类
protected NioTcpMessageChannel(NioTcpMessageProcessor nioTcpMessageProcessor,
		SocketChannel socketChannel) throws IOException {
	super(nioTcpMessageProcessor.getSIPStack());
	super.myClientInputStream = socketChannel.socket().getInputStream();
	try {
		this.peerAddress = socketChannel.socket().getInetAddress();
		this.peerPort = socketChannel.socket().getPort();
		this.socketChannel = socketChannel;
		super.mySock = socketChannel.socket();
		// messages that we write out to him.
		nioParser = new NioPipelineParser(sipStack, this,
				this.sipStack.getMaxMessageSize());
		this.peerProtocol = nioTcpMessageProcessor.transport;
		lastActivityTimeStamp = System.currentTimeMillis();
		super.key = MessageChannel.getKey(peerAddress, peerPort, nioTcpMessageProcessor.transport);

           myAddress = nioTcpMessageProcessor.getIpAddress().getHostAddress();
           myPort = nioTcpMessageProcessor.getPort();

	} finally {
		if (logger.isLoggingEnabled(LogWriter.TRACE_DEBUG)) {
			logger.logDebug("Done creating NioTcpMessageChannel " + this + " socketChannel = " +socketChannel);
		}
	}

}
 

import java.nio.channels.SocketChannel; //导入依赖的package包/类
private void getData(ByteBuffer input, SocketChannel channel) {
	int id = input.getInt();
	byte[] entity = data.get(id);

	ByteBuffer outputBuffer = TCPServer.prepareEmptyBuffer();
	int entityOffset = 0;

	while ((entity.length - entityOffset) > TCPServer.MAX_MESSAGE_BYTES) {
		outputBuffer.rewind();
		outputBuffer.put(entity, entityOffset, TCPServer.MAX_MESSAGE_BYTES);
		TCPServer.sendMessage(channel, outputBuffer);
		entityOffset += TCPServer.MAX_MESSAGE_BYTES;
	}
	outputBuffer.rewind();
	outputBuffer.put(entity, entityOffset, entity.length - entityOffset);
	outputBuffer.limit(entity.length - entityOffset);
	TCPServer.sendMessage(channel, outputBuffer);
}
 

import java.nio.channels.SocketChannel; //导入依赖的package包/类
private void start0() throws IOException {
    while (!closed) {

        processQueues();
        selector.select();

        if (selector.selectedKeys().isEmpty()) {
            processQueues();
        }

        for (Iterator<SelectionKey> i = selector.selectedKeys().iterator(); i.hasNext(); ) {
            SelectionKey key = i.next();
            i.remove();

            if (key.isConnectable()) {
                SocketChannel socketChannel = (SocketChannel) key.channel();
                socketChannel.finishConnect();
                LOG.info("SocketChannel connected.");
            }

            if (key.isReadable()) {
                this.socketChannelReader.readFromKey(key);
            }
        }
    }
}
 

import java.nio.channels.SocketChannel; //导入依赖的package包/类
private void handle(SelectionKey key) {
	SocketChannel channel = (SocketChannel) key.channel();
	if (key.isConnectable()) {
		try {
			if (channel.finishConnect()) {
				//connect finish
				this.logger.info("[Connecter] finish connect " + channel.getRemoteAddress().toString());
				IoWorker worker = this.workers.get(workersIndex);
				worker.dispatch(new JobBean(channel, this.chanToParam.get(channel)));
				workersIndex = (workersIndex + 1) % workers.size();
			}
		} catch (IOException e) {
			this.logger.info("[Connecter] finish connect error : " + e.toString());
			ClientParam clientParam = this.chanToParam.get(channel);
			if (clientParam.getOnConnectError() != null) {
				clientParam.getOnConnectError().onConnectError(e);
			}
			this.chanToParam.remove(channel);
			try {
				channel.close();
			} catch (IOException e1) {
				// already close
			}
		}
	}
}
 

import java.nio.channels.SocketChannel; //导入依赖的package包/类
/**
 * Expected to be used by the Poller to release resources on socket
 * close, errors etc.
 */
@Override
public void release(SocketChannel socket) {
    if (log.isDebugEnabled()) 
        log.debug("Iterating through our connections to release a socket channel:"+socket);
    boolean released = false;
    Iterator<java.util.Map.Entry<NioChannel, Processor<NioChannel>>> it = connections.entrySet().iterator();
    while (it.hasNext()) {
        java.util.Map.Entry<NioChannel, Processor<NioChannel>> entry = it.next();
        if (entry.getKey().getIOChannel()==socket) {
            it.remove();
            Processor<NioChannel> result = entry.getValue();
            result.recycle(true);
            unregister(result);
            released = true;
            break;
        }
    }
    if (log.isDebugEnabled()) 
        log.debug("Done iterating through our connections to release a socket channel:"+socket +" released:"+released);
}
 

import java.nio.channels.SocketChannel; //导入依赖的package包/类
void createOutgoingChannel(final short p_nodeID) throws NetworkException {
    try {
        m_outgoingChannel = SocketChannel.open();
        m_outgoingChannel.configureBlocking(false);
        m_outgoingChannel.socket().setSoTimeout(0);
        m_outgoingChannel.socket().setTcpNoDelay(true);
        m_outgoingChannel.socket().setReceiveBufferSize(32);
        m_outgoingChannel.socket().setSendBufferSize(m_bufferSize);
        int sendBufferSize = m_outgoingChannel.socket().getSendBufferSize();
        if (sendBufferSize < m_bufferSize) {
            // #if LOGGER >= WARN
            LOGGER.warn("Send buffer size could not be set properly. Check OS settings! Requested: %d, actual: %d", m_bufferSize, sendBufferSize);
            // #endif /* LOGGER >= WARN */
        }

        m_outgoingChannel.connect(m_nodeMap.getAddress(p_nodeID));
    } catch (final IOException ignored) {
        throw new NetworkException("Creating outgoing channel failed");
    }
}
 

import java.nio.channels.SocketChannel; //导入依赖的package包/类
@Override
public InetSocketAddress
getAddress()
{
	SocketChannel channel = ep.getSocketChannel();

	if ( channel != null ){

		Socket socket = channel.socket();

		if ( socket != null ){

			return((InetSocketAddress)socket.getLocalSocketAddress());
		}
	}

	return( null );
}
 

import java.nio.channels.SocketChannel; //导入依赖的package包/类
public SecureNioChannel(SocketChannel channel, SSLEngine engine, ApplicationBufferHandler bufHandler,
		NioSelectorPool pool) throws IOException {
	super(channel, bufHandler);
	this.sslEngine = engine;
	int appBufSize = sslEngine.getSession().getApplicationBufferSize();
	int netBufSize = sslEngine.getSession().getPacketBufferSize();
	// allocate network buffers - TODO, add in optional direct non-direct
	// buffers
	if (netInBuffer == null)
		netInBuffer = ByteBuffer.allocateDirect(netBufSize);
	if (netOutBuffer == null)
		netOutBuffer = ByteBuffer.allocateDirect(netBufSize);

	// selector pool for blocking operations
	this.pool = pool;

	// ensure that the application has a large enough read/write buffers
	// by doing this, we should not encounter any buffer overflow errors
	bufHandler.expand(bufHandler.getReadBuffer(), appBufSize);
	bufHandler.expand(bufHandler.getWriteBuffer(), appBufSize);
	reset();
}
 

import java.nio.channels.SocketChannel; //导入依赖的package包/类
@Override
public NonBlockingConnection startNewConnection() {
    try {
        SocketChannel socket = SocketChannel.open();
        NonBlockingConnection connection = new NonBlockingConnection(socket);

        // this connect is non-blocking and should always return false.
        boolean finished = ((SocketChannel) connection.getChannel()).connect(address);
        if (finished) {
            throw new IllegalStateException("async connect finished instantly?");
        }
        return connection;
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

import java.nio.channels.SocketChannel; //导入依赖的package包/类
public void run() {
    SocketChannel socketChannel = null;

    while (accept) {

        try {
            socketChannel = _serverChannel.accept();
            if (!accept) {
                break;
            }
            // socket.setSoTimeout(getTimeout());
        } catch (final IOException e) {
            if (accept) {
                logger.log(Level.WARNING, "ServerNIO died: "
                        + e.getMessage(), e);
            }
            break;
        }
        handleConnection(socketChannel);
    }
}
 

import java.nio.channels.SocketChannel; //导入依赖的package包/类
/**
 * testStartConnection
 */
@Test
public void testStartConnection() throws Exception {
    System.err.println("testStartConnection()");
    for (final HStoreCoordinator m : this.coordinators) {
        // Check that the messenger state is correct
        assert (m.isStarted());

        // Check that the messenger's listener thread is running
        assert (m.getListenerThread().isAlive());

        // Check that we can connect to the messenger's listening port
        int port = m.getLocalMessengerPort();
        SocketChannel channel = SocketChannel.open();
        channel.connect(new InetSocketAddress(port));
        assert (channel.isConnected());
    } // FOR
}
 

import java.nio.channels.SocketChannel; //导入依赖的package包/类
public Connection(SocketChannel channel, long lastContact) {
  this.channel = channel;
  this.lastContact = lastContact;
  this.data = null;
  this.dataLengthBuffer = ByteBuffer.allocate(4);
  this.unwrappedData = null;
  this.unwrappedDataLengthBuffer = ByteBuffer.allocate(4);
  this.socket = channel.socket();
  this.addr = socket.getInetAddress();
  if (addr == null) {
    this.hostAddress = "*Unknown*";
  } else {
    this.hostAddress = addr.getHostAddress();
  }
  this.remotePort = socket.getPort();
  this.responseQueue = new LinkedList<Call>();
  if (socketSendBufferSize != 0) {
    try {
      socket.setSendBufferSize(socketSendBufferSize);
    } catch (IOException e) {
      LOG.warn("Connection: unable to set socket send buffer size to " +
               socketSendBufferSize);
    }
  }
}
 

import java.nio.channels.SocketChannel; //导入依赖的package包/类
protected void removeSocket(SocketChannel channel) {
  	if (logger.isLoggingEnabled(LogWriter.TRACE_DEBUG)) {
	logger.logDebug("Trying to remove cached socketChannel without key"
			+ this + " socketChannel = " + channel);
}
  	LinkedList<String> keys = new LinkedList<String>();
  	synchronized(socketTable) {
  		Set<Entry<String, SocketChannel>> e = socketTable.entrySet();
  		for(Entry<String, SocketChannel> entry : e ) {
  			SocketChannel sc = entry.getValue();
  			if(sc.equals(channel)) {
  				keys.add(entry.getKey());
  			}
  		}
  		for(String key : keys) {
  			if (logger.isLoggingEnabled(LogWriter.TRACE_DEBUG)) {
  				logger.logDebug("Removing cached socketChannel without key"
  						+ this + " socketChannel = " + channel + " key = " + key);
  			}
  			removeSocket(key);
  		}
  	}
  }