2，用NIO实现非阻塞的EchoServer和EchoClient

在非阻塞模式下，EchoServer只需要启动一个主线程，就能同时处理3件事：

1，接收客户的连接

2，接收客户发送的数据

3，接收客户发回响应的数据

 

package com.test.socket.nio.nonblocking;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.Iterator;
import java.util.Set;

/**
 * 使用非阻塞模式的SocketChannel,ServerSocketChannel.
 */
public class EchoServer {
	private Selector selector = null;
	private ServerSocketChannel serverSocketChannel = null;
	private int port = 8000;
	private Charset charset = Charset.forName("GBK");
	
	public EchoServer() throws IOException {
		//创建一个selector对象 
		selector = Selector.open();
		serverSocketChannel = ServerSocketChannel.open();
		serverSocketChannel.socket().setReuseAddress(true);
		//使serverSocketChannel工作于非阻塞模式
		serverSocketChannel.configureBlocking(false);
		serverSocketChannel.socket().bind(new InetSocketAddress(port));
		System.out.println("服务器启动...");
	}
	
	public void service() throws IOException{
		serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
		while(selector.select()>0){
			Set readyKeys = selector.selectedKeys();
			Iterator it = readyKeys.iterator();
			while(it.hasNext()){
				SelectionKey key = null;
				try{
					key = (SelectionKey)it.next();
					it.remove();
					if(key.isAcceptable()){
						ServerSocketChannel ssc = (ServerSocketChannel)key.channel();
						SocketChannel socketChannel = (SocketChannel)ssc.accept();
						System.out.println("接收到客户连接，来自："+ socketChannel.socket().getInetAddress() + ":"
								+ socketChannel.socket().getPort());
						socketChannel.configureBlocking(false);
						ByteBuffer buffer = ByteBuffer.allocate(1024);
						socketChannel.register(selector, SelectionKey.OP_READ|SelectionKey.OP_WRITE, buffer);
					}
					if(key.isReadable()){
						receive(key);
					}
					if(key.isWritable()){
						send(key);
					}
				}catch (IOException e) {
					e.printStackTrace();
					try{
						if(key!=null){
							key.cancel();
							key.channel().close();
						}
					}catch (Exception ex) {
						ex.printStackTrace();
					}
				}
			}
		}
	}
	public void send(SelectionKey key)throws IOException{
		ByteBuffer buffer = (ByteBuffer)key.attachment();
		SocketChannel socketChannel = (SocketChannel) key.channel();
		buffer.flip();//把极限设为位置，把位置设为0
		String data = decode(buffer);
		if(data.indexOf("\r\n") == -1){
			return;
		}
		String outputData = data.substring(0,data.indexOf("\n")+1);
		System.out.print(outputData);
		ByteBuffer outputBuffer = encode("echo:"+outputData);
		while(outputBuffer.hasRemaining()){
			socketChannel.write(outputBuffer);
		}
		ByteBuffer temp = encode(outputData);
		buffer.position(temp.limit());
		buffer.compact();//删除已经处理的字符串
		if(outputData.equals("bye\r\n")){
			key.cancel();
			socketChannel.close();
			System.out.println("关闭与客户端的连接");
		}
	}
	public void receive(SelectionKey key)throws IOException{
		ByteBuffer buffer = (ByteBuffer) key.attachment();
		SocketChannel socketChannel = (SocketChannel) key.channel();
		ByteBuffer readBuff = ByteBuffer.allocate(32);
		socketChannel.read(readBuff);
		readBuff.flip();
		
		buffer.limit(buffer.capacity());
		buffer.put(readBuff);
	}
	public String decode(ByteBuffer buffer){
		CharBuffer charBuffer = charset.decode(buffer);
		return charBuffer.toString();
	}
	public ByteBuffer encode(String str){
		return charset.encode(str);
	}
	public static void main(String[] args) throws IOException {
		new EchoServer().service();
	}
}

 

非阻塞的EchoClient：利用非阻塞模式来实现异步通信

package com.test.socket.nio.nonblocking;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.Iterator;
import java.util.Set;

public class EchoClient {
	private SocketChannel socketChannel = null;
	private ByteBuffer sendBuffer = ByteBuffer.allocate(1024);
	private ByteBuffer receiveBuffer = ByteBuffer.allocate(1024);
	private Charset charset = Charset.forName("GBK");
	private Selector selector;
	
	public EchoClient() throws IOException {
		socketChannel = SocketChannel.open();
		InetAddress ia = InetAddress.getLocalHost();
		InetSocketAddress isa = new InetSocketAddress(ia,8000);
		socketChannel.connect(isa);
		socketChannel.configureBlocking(false);
		System.out.println("与服务器的连接建立成功");
		selector = Selector.open();
	}
	
	public static void main(String[] args) throws IOException {
		final EchoClient client = new EchoClient();
		Thread receiver = new Thread(){
			public void run(){
				client.receiveFromUser();
			}
		};
		receiver.start();
		client.talk();
	}
	
	public void receiveFromUser(){
		try{
			BufferedReader localReader = new BufferedReader(new InputStreamReader(System.in));
			String msg = null;
			while((msg = localReader.readLine())!=null){
				synchronized (sendBuffer) {
					sendBuffer.put(encode(msg+"\r\n"));
				}
				if(msg.equals("bye"))
					break;
			}
		}catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public void talk()throws IOException{
		try{
			socketChannel.register(selector, SelectionKey.OP_READ|SelectionKey.OP_WRITE);
			while(selector.select()>0){
				Set readyKeys = selector.selectedKeys();
				Iterator it = readyKeys.iterator();
				while(it.hasNext()){
					SelectionKey key = null;
					try{
						key = (SelectionKey)it.next();
						it.remove();
						if(key.isReadable()){
							receive(key);
						}
						if(key.isWritable()){
							send(key);
						}
					}catch (IOException e) {
						e.printStackTrace();
						try{
							if(key!=null){
								key.cancel();
								key.channel().close();
							}
						}catch (Exception ex) {
							ex.printStackTrace();
						}
					}
				}
			}
		}catch (IOException e) {
			e.printStackTrace();
		}finally{
			try{
				socketChannel.close();
			}catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	public void send(SelectionKey key)throws IOException{
		SocketChannel socketChannel = (SocketChannel) key.channel();
		synchronized (sendBuffer) {
			sendBuffer.flip();
			socketChannel.write(sendBuffer);
			sendBuffer.compact();
		}
	}
	public void receive(SelectionKey key)throws IOException{
		//接收EchoServer发送的数据，把它放到receiveBuffer中 
		//如果receiverBuffer中有一行数据，就打印这行数据，然后把它从receiverBuffer中删除
		SocketChannel socketChannel = (SocketChannel) key.channel();
		socketChannel.read(receiveBuffer);
		receiveBuffer.flip();
		String receiveData = decode(receiveBuffer);
		if(receiveData.indexOf("\n") == -1){
			return;
		}
		String outputData = receiveData.substring(0,receiveData.indexOf("\n")+1);
		System.out.println(outputData);
		if(outputData.equals("echo:bye\r\n")){
			key.cancel();
			socketChannel.close();
			System.out.println("关闭与服务器的连接");
			selector.close();
			System.exit(0);
		}
		ByteBuffer temp = encode(outputData);
		receiveBuffer.position(temp.limit());
		receiveBuffer.compact();
	}
	public String decode(ByteBuffer buffer){
		CharBuffer charBuffer = charset.decode(buffer);
		return charBuffer.toString();
	}
	public ByteBuffer encode(String str){
		return charset.encode(str);
	}
}