Java AsynchronousSocketChannel类代码示例

import java.nio.channels.AsynchronousSocketChannel; //导入依赖的package包/类
public AioServerConnection(AsynchronousSocketChannel channel) {
    this.channel = channel;
    this.reader = new MsgReader(channel) {
        @Override
        protected void onMsg(Msg msg) {
            Command command = MsgConverter.convert(msg);
            Reply reply = commandHandler.handle(command);
            writer.write(reply.toMsg());
        }
    };
    this.writer = new MsgWriter(channel) {
        @Override
        protected void onWriteDone() {
            super.onWriteDone();
            processCommand();
        }
    };
}
 

import java.nio.channels.AsynchronousSocketChannel; //导入依赖的package包/类
/**
 *@description 接收客户端请求成功之后回调
 *@time 创建时间:2017年7月20日上午11:05:16
 *@param channel
 *@param serverHandler
 *@author dzn
 */
@Override
public void completed(AsynchronousSocketChannel channel,
        AsyncTimeServerHandler serverHandler) {
    
    System.out.println("成功接收到客户端连接 : " + channel.toString());
    
    //继续注册一个接收请求的处理类
    serverHandler.asynchronousServerSocketChannel.accept(serverHandler, this);
    
    //创建一个数据缓冲区
    ByteBuffer bb = ByteBuffer.allocate(1024);
    
    //去读取客户端发送的数据，并注册一个数据处理类
    channel.read(bb, bb, new ReadCompletionHandler(channel));
}
 

import java.nio.channels.AsynchronousSocketChannel; //导入依赖的package包/类
@SuppressWarnings({"unchecked", "rawtypes"})
public MySQLConnection make(MySQLDataSource pool, ResponseHandler handler,
                            String schema) throws IOException {

    DBHostConfig dsc = pool.getConfig();
    NetworkChannel channel = openSocketChannel(DbleServer.getInstance().isAIO());

    MySQLConnection c = new MySQLConnection(channel, pool.isReadNode());
    c.setSocketParams(false);
    c.setHost(dsc.getIp());
    c.setPort(dsc.getPort());
    c.setUser(dsc.getUser());
    c.setPassword(dsc.getPassword());
    c.setSchema(schema);
    c.setHandler(new MySQLConnectionAuthenticator(c, handler));
    c.setPool(pool);
    c.setIdleTimeout(pool.getConfig().getIdleTimeout());
    if (channel instanceof AsynchronousSocketChannel) {
        ((AsynchronousSocketChannel) channel).connect(
                new InetSocketAddress(dsc.getIp(), dsc.getPort()), c,
                (CompletionHandler) DbleServer.getInstance().getConnector());
    } else {
        ((NIOConnector) DbleServer.getInstance().getConnector()).postConnect(c);
    }
    return c;
}
 

import java.nio.channels.AsynchronousSocketChannel; //导入依赖的package包/类
/**
   * Creates a new client and adds it to the list of connections.
   * Sets the clients handler to the initial state of NameReader
   *
   * @param channel the newly accepted channel
   */
private void handleNewConnection(AsynchronousSocketChannel channel) {
	try {
		channel.setOption(StandardSocketOptions.TCP_NODELAY, true);
	} catch (IOException e) {
		// ignore
		//
		e.printStackTrace();
	}

	//new dealer and channel
	AioServerDataDealer dealer = null;
	
	dealer = aioDataDealerFactory.getAioServerDataDealer();
	
	int channelId = getChannelId();
	AioServerChannel aioChannel = new AioServerChannel(channelId, channel, dealer, this);
	connections.put(channelId, aioChannel);
	
	//start channel
	aioChannel.run(null);
}
 

import java.nio.channels.AsynchronousSocketChannel; //导入依赖的package包/类
/**
 * @param asynchronousSocketChannel the asynchronousSocketChannel to set
 */
public void setAsynchronousSocketChannel(AsynchronousSocketChannel asynchronousSocketChannel)
{
	this.asynchronousSocketChannel = asynchronousSocketChannel;

	if (asynchronousSocketChannel != null)
	{
		try
		{
			Node clientNode = createClientNode(asynchronousSocketChannel);
			setClientNode(clientNode);
		} catch (IOException e)
		{
			log.info(e.toString(), e);
			assignAnUnknownClientNode();
		}
	} else
	{
		assignAnUnknownClientNode();
	}
}
 

import java.nio.channels.AsynchronousSocketChannel; //导入依赖的package包/类
private void retry() {
    try {
        TimeUnit.SECONDS.sleep(1);
        if (null != this.channel && this.channel.isOpen()) {
            this.channel.close();
        }
        log.debug("连接:{}", this.socketAddress.toString());
        final AsynchronousSocketChannel asynchronousSocketChannel = AsynchronousSocketChannel.open(this.group);
        asynchronousSocketChannel.setOption(StandardSocketOptions.TCP_NODELAY, true);
        asynchronousSocketChannel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
        asynchronousSocketChannel.setOption(StandardSocketOptions.SO_KEEPALIVE, true);
        asynchronousSocketChannel.connect(this.socketAddress).get(5, TimeUnit.SECONDS);
        this.channel = new FastChannel(asynchronousSocketChannel, this.serializer, timeout);
    } catch (final Exception e) {
        retry();
    }
}
 

import java.nio.channels.AsynchronousSocketChannel; //导入依赖的package包/类
private CompletionHandler<AsynchronousSocketChannel, Integer> acceptCompletionHandler(
			int byteCount, AsynchronousServerSocketChannel socket) {
		return new CompletionHandler<AsynchronousSocketChannel, Integer>() {
			public void completed(
					AsynchronousSocketChannel ch,
					Integer acceptsToGo) {
				acceptsToGo = acceptsToGo-1;
//				System.out.println("server accepted, to go = " + acceptsToGo);
				writeStuffThreadAsync(socket, ch, byteCount, acceptsToGo);
				if (acceptsToGo > 0) {
					socket.accept(acceptsToGo, acceptCompletionHandler(byteCount, socket));
				}
			}
			public void failed(Throwable exc, Integer attachment) {
				exc.printStackTrace();
				try {
					socket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		};
	}
 

import java.nio.channels.AsynchronousSocketChannel; //导入依赖的package包/类
@Override
public void completed(AsynchronousSocketChannel socketChannel, AioServerSocket serverSocket) {
	try {
		//接续接收 accept 请求
		serverSocket.catchAccept();
		
		AioSocket socket = new AioSocket(serverSocket,socketChannel);
		
		//触发 Accept 事件
		EventTrigger.fireAcceptThread(socket.getSession());
		
		
	} catch (IOException e) {
		EventTrigger.fireExceptionThread(null, e);
	}
}
 

import java.nio.channels.AsynchronousSocketChannel; //导入依赖的package包/类
public static void main(String[] args) throws IOException, ExecutionException,
          InterruptedException, TimeoutException {
    //打开 AsychronousServerSocketChannel 并将其绑定到类似于 ServerSocketChannel 的地址
    //方法 bind() 将一个套接字地址作为其参数。找到空闲端口的便利方法是传递一个 null 地址，它会自动将套接字绑定到本地主机地址，并使用空闲的 临时 端口。
    AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open().bind(null);
    //告诉通道接受一个连接
    Future<AsynchronousSocketChannel> future = server.accept();

//    利用 Future 对象，当前线程可阻塞来等待结果：
    AsynchronousSocketChannel worker = future.get();
    //超时
    //AsynchronousSocketChannel worker = future.get(10, TimeUnit.SECONDS);
    //取消
//    if (!future.isDone()) {
//      future.cancel(true);//cancel() 方法可利用一个布尔标志来指出执行接受的线程是否可被中断
//    }
//
//// read a message from the client
    ByteBuffer readBuffer = ByteBuffer.allocate(1024);
    worker.read(readBuffer).get(10, TimeUnit.SECONDS);
    System.out.println("Message: " + new String(readBuffer.array()));
  }
 

import java.nio.channels.AsynchronousSocketChannel; //导入依赖的package包/类
public Nio2SSLSocket(AsynchronousSocketChannel sock, SSLContext sslc, boolean clientMode)
{
	super(sock);
	this.engine = sslc.createSSLEngine();
	this.engine.setUseClientMode(clientMode);
	String[] procols = { "TLSv1" };
	this.engine.setEnabledProtocols(procols);

	int packetBufferSize = engine.getSession().getPacketBufferSize();
	decodeBuf	= ByteBuffer.allocateDirect(packetBufferSize);
	readBuf = ByteBuffer.allocateDirect(packetBufferSize);
	
	for (int i = 0; i < 2; i++)
	{
		writeBufs[i] = ByteBuffer.allocateDirect(packetBufferSize);
		writeBufs[i].limit(0);
	}
	writeBufs[0].clear();
}
 

import java.nio.channels.AsynchronousSocketChannel; //导入依赖的package包/类
private void connect() throws BindException{
	String errorMessage = "";
	if (socketChannel == null || !socketChannel.isOpen() || closed) {
		try {
			socketChannel = AsynchronousSocketChannel.open();
			socketChannel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
			socketChannel.setOption(StandardSocketOptions.SO_KEEPALIVE, true);
			socketChannel.connect(new InetSocketAddress(ip, port)).get(timeout, TimeUnit.MILLISECONDS);
			closed = false;
			
			//when connect to the server, keep receiving data either server response or server call
			receive();
		} catch (Exception e) {
			log.error("Connection error: " + e.getMessage());
			errorMessage = e.getMessage();
		}
	}
	if (socketChannel == null) {
		throw new BindException(errorMessage);
	}
}
 

import java.nio.channels.AsynchronousSocketChannel; //导入依赖的package包/类
private void connect() throws BindException{
	String errorMessage = "";
	if (socketChannel == null || !socketChannel.isOpen() || closed) {
		try {
			socketChannel = AsynchronousSocketChannel.open();
			socketChannel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
			socketChannel.setOption(StandardSocketOptions.SO_KEEPALIVE, true);
			socketChannel.connect(new InetSocketAddress(ip, port)).get(timeout, TimeUnit.MILLISECONDS);
			closed = false;
			log.debug("Session start to " + socketChannel.getRemoteAddress());
			
			//when connect to the server, keep receiving data either server response or server call
			receive();
		} catch (Exception e) {
			log.error("Connection error: " + e.getMessage());
			errorMessage = e.getMessage();
		}
	}
	if (socketChannel == null) {
		throw new BindException(errorMessage);
	}
}
 

import java.nio.channels.AsynchronousSocketChannel; //导入依赖的package包/类
public MySQLConnection make(MySQLDataSource pool, ResponseHandler handler)
		throws IOException {

	DBHostConfig dsc = pool.getConfig();
	AsynchronousSocketChannel channel = openSocketChannel();
	MySQLConnection c = new MySQLConnection(channel, pool.isReadNode());

	c.setHost(dsc.getIp());
	c.setPort(dsc.getPort());
	c.setUser(dsc.getUser());
	c.setPassword(dsc.getPassword());
	// c.setSchema(dsc.getDatabase());
	c.setHandler(new MySQLConnectionAuthenticator(c, handler));
	c.setPool(pool);
	c.setIdleTimeout(pool.getConfig().getIdleTimeout());
	channel.connect(new InetSocketAddress(dsc.getIp(), dsc.getPort()), c,
			MycatServer.getInstance().getConnector());
	return c;
}
 

import java.nio.channels.AsynchronousSocketChannel; //导入依赖的package包/类
public SocketSession(AsynchronousSocketChannel channel, ByteBuffer buffer,
		CodecFactory codecFactory) throws IOException {
	this.channel = channel;
	this.remoteAddress = channel.getRemoteAddress();
	this.processor = new Processor(this);
	this.buffer = buffer;
	this.codec = codecFactory.getCodec();
	this.describe = "local:" + channel.getLocalAddress() + " remote:"
			+ remoteAddress + " hashCode/" + super.hashCode();
	this.hashCode = super.hashCode();
	attachment = new ConcurrentHashMap<Object, Object>(128);
	this.attachment.put(MSG_SURPLUS_LENGTH, -1);
	this.attachment.put(MSG_TMP, new byte[0]);
	this.remotePort = Integer.parseInt(this.toString().split(" ")[1]
			.split(":")[2]);
}
 

import java.nio.channels.AsynchronousSocketChannel; //导入依赖的package包/类
/**
 * Construct a new {@code Client}
 * @param channel that this client listens on
 * @throws IOException If an I/O error occurs
 */
AbstractClient(AsynchronousSocketChannel channel) {
	super();
	this.channel = channel;
	this.cipher = new Cryptographer();
	/*
	 * TODO This option was part of the ChatServer example by Oracle, but
	 * should be used with caution: "The socket option should only be
	 * enabled in cases where it is known that the coalescing impacts
	 * performance". We need to figure out whether it is required to set
	 * this option to true.
	 * 
	 * try {
	 * 	this.channel.setOption(StandardSocketOptions.TCP_NODELAY, true);
	 * } catch (IOException e) {
	 *	e.printStackTrace();
	 * }
	 * 
	 */
}