Java.NIO编程一览笔录

java.nio.ByteBuffer byteBuffer = ByteBuffer.allocate(5);
//清空数据，切换写模式，准备写数据
byteBuffer.clear();
//byteBuffer.put((byte) 1);
//切换读模式，准备读数据
byteBuffer.flip();
while (byteBuffer.hasRemaining()) {
	byte b = byteBuffer.get();
	//操作数据
}

java.nio.ByteBuffer byteBuffer1 = ByteBuffer.allocate(10);

java.nio.ByteBuffer byteBuffer1 = ByteBuffer.allocateDirect(10);

byte[] bytes = new byte[]{1, 2, 3, 4, 5};
java.nio.ByteBuffer byteBuffer1 = ByteBuffer.wrap(bytes);

int bytesWritten = inChannel.write(buf);

byte aByte = buf.get();

int bytesRead = inChannel.read(buf); //read into buffer.

buf.put(127);

public static void main(String[] args) {
	java.nio.ByteBuffer byteBuffer1 = ByteBuffer.allocate(31);
	printBuffer(byteBuffer1, "byteBuffer1");

	/**
	 * byteBuffer1的remaining>1 （除以2）
	 */
	CharBuffer charBuffer = byteBuffer1.asCharBuffer();
	printBuffer(charBuffer, "charBuffer");
	charBuffer.put('a');
	if (byteBuffer1.hasArray())
		System.out.println("byteBuffer1 data=" + Arrays.toString(byteBuffer1.array()));

	/**
	 * byteBuffer1的remaining>1 （除以2）
	 */
	ShortBuffer shortBuffer = byteBuffer1.asShortBuffer();
	printBuffer(shortBuffer, "shortBuffer");
	shortBuffer.put((short) 3);
	if (byteBuffer1.hasArray())
		System.out.println("byteBuffer1 data=" + Arrays.toString(byteBuffer1.array()));

	/**
	 * byteBuffer1的remaining>2 （除以4）
	 */
	IntBuffer intBuffer = byteBuffer1.asIntBuffer();
	printBuffer(intBuffer, "intBuffer");
	intBuffer.put(4);
	if (byteBuffer1.hasArray())
		System.out.println("byteBuffer1 data=" + Arrays.toString(byteBuffer1.array()));

	/**
	 * byteBuffer1的remaining>3 （除以8）
	 */
	LongBuffer longBuffer = byteBuffer1.asLongBuffer();
	printBuffer(longBuffer, "longBuffer");
	longBuffer.put(120);
	if (byteBuffer1.hasArray())
		System.out.println("byteBuffer1 data=" + Arrays.toString(byteBuffer1.array()));

	/**
	 * byteBuffer1的remaining>2 （除以4）
	 */
	FloatBuffer floatBuffer = byteBuffer1.asFloatBuffer();
	printBuffer(floatBuffer, "floatBuffer");
	floatBuffer.put(9f);
	if (byteBuffer1.hasArray())
		System.out.println("byteBuffer1 data=" + Arrays.toString(byteBuffer1.array()));

	/**
	 * byteBuffer1的remaining>3 （除以8）
	 */
	DoubleBuffer doubleBuffer = byteBuffer1.asDoubleBuffer();
	printBuffer(doubleBuffer, "doubleBuffer");
	doubleBuffer.put(1);
	if (byteBuffer1.hasArray())
		System.out.println("byteBuffer1 data=" + Arrays.toString(byteBuffer1.array()));
}

private static void printBuffer(Buffer buffer, String name) {
	System.out.println((name != null && !name.isEmpty() ? name + " " : "") + "position=" 
			+ buffer.position() + ",limit=" + buffer.limit()
			+ ",remaining=" + buffer.remaining() + ",capacity=" + buffer.capacity());
}

public static void main(String[] args) {
	String string = "abcde";
	java.nio.ByteBuffer byteBuffer1 = ByteBuffer.allocate(10);
	System.out.println(byteBuffer1.order());
	byteBuffer1.rewind();//位置设置为 0 并丢弃标记
	byteBuffer1.order(ByteOrder.BIG_ENDIAN);
	byteBuffer1.asCharBuffer().put(string);
	System.out.println("byteBuffer1 data=" + Arrays.toString(byteBuffer1.array()));
	byteBuffer1.rewind();//位置设置为 0 并丢弃标记
	byteBuffer1.order(ByteOrder.LITTLE_ENDIAN);
	byteBuffer1.asCharBuffer().put(string);
	System.out.println("byteBuffer1 data=" + Arrays.toString(byteBuffer1.array()));
	/**
	 * 无效用法1，只更改order，不重新填充数据，存储是不会改变的，只有下次才生效
	 */
	byteBuffer1.rewind();//位置设置为 0 并丢弃标记
	byteBuffer1.order(ByteOrder.LITTLE_ENDIAN);
	System.out.println("byteBuffer1 data=" + Arrays.toString(byteBuffer1.array()));
	/**
	 * 无效用法2，填充完数据再改order，存储是不会改变的，只有下次才生效
	 */
	byteBuffer1.rewind();//位置设置为 0 并丢弃标记
	byteBuffer1.asCharBuffer().put(string);
	byteBuffer1.order(ByteOrder.LITTLE_ENDIAN);
	System.out.println("byteBuffer1 data=" + Arrays.toString(byteBuffer1.array()));
}

	/**
	 * 转化byte数组
	 *
	 * @param byteBuffer
	 * @return
	 */
	public static byte[] readToBytes(ByteBuffer byteBuffer) {
		byteBuffer.flip();
		// Retrieve bytes between the position and limit
		// (see Putting Bytes into a ByteBuffer)
		byte[] bytes = new byte[byteBuffer.remaining()];
		// transfer bytes from this buffer into the given destination array
		byteBuffer.get(bytes, 0, bytes.length);
		byteBuffer.clear();
		return bytes;
	}

java.nio.channels.FileChannel channel = null;
FileInputStream fis = null;
try {
	fis = new FileInputStream(path);
	channel = fis.getChannel();
	
} finally {
	if (channel != null)
		channel.close();
	if (fis != null)
		fis.close();
}

public static void main(String[] args) throws IOException {
	final String path = "file.txt";
	write(path);//写文件
	write2(path);//特定位置读写
	read(path);//读文件
	System.out.println();
	truncate(path);//文件截取
	read(path);//读文件
}
/**
 * FileChannel 读文件
 */
private static void read(String path) throws IOException {
	java.nio.channels.FileChannel channel = null;
	FileInputStream fis = null;
	try {
		fis = new FileInputStream(path);
		channel = fis.getChannel();
		ByteBuffer buffer1 = ByteBuffer.allocate(1024);
		// 从入channel读取数据到buffer
		buffer1.rewind();
		while (channel.read(buffer1) > 0) {
			//读取buffer
			buffer1.flip();
			Charset charset = Charset.defaultCharset();
			CharBuffer charBuffer = charset.decode(buffer1);
			System.out.print(charBuffer);
		}
	} finally {
		if (channel != null)
			channel.close();
		if (fis != null)
			fis.close();
	}
}
/**
 * FileChannel 写文件
 */
private static void write(String path) throws IOException {
	ByteBuffer buffer = ByteBuffer.wrap("赵客缦胡缨，吴钩霜雪明。银鞍照白马，飒沓如流星。n".getBytes());
	java.nio.channels.FileChannel channel = null;
	FileOutputStream fos = null;
	try {
		fos = new FileOutputStream(path);
		channel = fos.getChannel();
		//强制刷出到内存
		channel.force(true);
		// 从buffer读取数据写入channel
		buffer.rewind();
		channel.write(buffer);
	} finally {
		if (channel != null)
			channel.close();
		if (fos != null)
			fos.close();
	}
}
/**
 * FileChannel 特定位置读写
 */
private static void write2(String path) throws IOException {
	ByteBuffer buffer = ByteBuffer.wrap("十步杀一人，千里不留行。事了拂衣去，深藏身与名。n".getBytes());
	java.nio.channels.FileChannel channel = null;
	RandomAccessFile file = null;
	try {
		file = new RandomAccessFile(path, "rw");
		channel = file.getChannel();
		channel.position(channel.size()); //定位到文件末尾  
		//强制刷出到内存
		channel.force(true);
		// 从buffer读取数据写入channel
		buffer.rewind();
		channel.write(buffer);
	} finally {
		if (channel != null)
			channel.close();
		if (file != null) {
			file.close();// 关闭流
		}
	}
}
/**
 * FileChannel 文件截取
 */
private static void truncate(String path) throws IOException {
	java.nio.channels.FileChannel channel = null;
	RandomAccessFile file = null;
	try {
		file = new RandomAccessFile(path, "rw");
		channel = file.getChannel();
		/** 
		 * 截取文件前36byte 
		 */
		channel.truncate(36);
	} finally {
		if (channel != null)
			channel.close();
		if (file != null) {
			file.close();// 关闭流
		}
	}
}

ServerSocketChannel channel= ServerSocketChannel.open();

//关闭 ServerSocketChannel
if (channel != null) {
	channel.close();
}

channel.bind(new InetSocketAddress("127.0.0.1", 9595));

while (true) {
	// 监听新进来的连接
	java.nio.channels.SocketChannel socketChannel = channel.accept();
	//do something with socketChannel...
}

// 设置非阻塞模式，read的时候就不再阻塞
channel.configureBlocking(false);

while (true) {
	// 监听新进来的连接
	java.nio.channels.SocketChannel socketChannel = channel.accept();
	if (socketChannel == null) {
		// System.out.println("没有客户端连接");
		TimeUnit.SECONDS.sleep(1);
		continue;
	}
	//do something with socketChannel...
}

// 打开SocketChannel
SocketChannel channel = SocketChannel.open();
// 设置非阻塞模式，read的时候就不再阻塞
channel.configureBlocking(false);
// tcp连接网络
channel.connect(new InetSocketAddress("127.0.0.1", 9595));
if (channel.finishConnect()) {// 连接服务器成功
	//do something 
}

package io.flysium.nio.c2_channel.socket;

import io.flysium.nio.ByteBufferUtils;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.util.concurrent.TimeUnit;

/**
 * ServerSocketChannel示例
 *
 * @author Sven Augustus
 */
public class ServerSocketChannelTest {

	public static void main(String[] args) throws IOException, 
InterruptedException, ClassNotFoundException {
		java.nio.channels.ServerSocketChannel channel = null;
		try {
			// 打开 ServerSocketChannel
			channel = ServerSocketChannel.open();
			// 设置非阻塞模式，read的时候就不再阻塞
			channel.configureBlocking(false);
			// 将 ServerSocket 绑定到特定地址（IP 地址和端口号）
			channel.bind(new InetSocketAddress("127.0.0.1", 9595));

			while (true) {
				// 监听新进来的连接
				java.nio.channels.SocketChannel socketChannel = channel.accept();
				if (socketChannel == null) {
					// System.out.println("没有客户端连接");
					TimeUnit.SECONDS.sleep(1);
					continue;
				}
				System.out.println("准备读：");
				// 读取客户端发送的数据
				ByteBuffer buffer = ByteBuffer.allocate(1024);
				buffer.clear();
				socketChannel.read(buffer);
				buffer.flip();// 读取buffer
				Object object = ByteBufferUtils.readObject(buffer);
				System.out.println(object);
				// 往客户端写数据
				String serializable = "您好，客户端" + socketChannel.getRemoteAddress();
				System.out.println("准备写：" + serializable);
				ByteBuffer byteBuffer = ByteBufferUtils.writeObject(serializable);
				socketChannel.write(byteBuffer);
			}
		} finally {
			//关闭 ServerSocketChannel
			if (channel != null) {
				channel.close();
			}
		}
	}


}

package io.flysium.nio.c2_channel.socket;

import io.flysium.nio.ByteBufferUtils;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

/**
 * SocketChannel示例
 *
 * @author Sven Augustus
 */
@SuppressWarnings("unused")
public class SocketChannelTest {

	public static void main(String[] args) throws IOException, 
InterruptedException, ClassNotFoundException {
		java.nio.channels.SocketChannel channel = null;
		try {
			// 打开SocketChannel
			channel = SocketChannel.open();
			// 设置非阻塞模式，read的时候就不再阻塞
			channel.configureBlocking(false);
			// tcp连接网络
			channel.connect(new InetSocketAddress("127.0.0.1", 9595));
			if (channel.finishConnect()) {// 连接服务器成功
				/**
				 * 往服务端写数据
				 */
				String serializable = "您好，ServerSocketChannel。";
				System.out.println("准备写：" + serializable);
				ByteBuffer byteBuffer = ByteBufferUtils.writeObject(serializable);
				channel.write(byteBuffer);
				System.out.println("准备读：");
				// 读取服务端发送的数据
				ByteBuffer buffer = ByteBuffer.allocate(1024);
				buffer.clear();
				int numBytesRead = -1;
				while ((numBytesRead = channel.read(buffer)) != -1) {
					if (numBytesRead == 0) {// 如果没有数据，则稍微等待一下
						try {
							Thread.sleep(1);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						continue;
					}
					buffer.flip();// 读取buffer
					Object object = ByteBufferUtils.readObject(buffer);
					System.out.println(object);
        			buffer.clear(); // 复位，清空
				}
			} else {
				System.out.println("连接失败，服务器拒绝服务");
				return;
			}
		} finally {
			// 关闭SocketChannel
			if (channel != null) {
				channel.close();
			}
		}
	}

}

DatagramChannel channel= DatagramChannel.open();

//关闭DatagramChannel
if (channel!= null) {
	channel.close();
}

ByteBuffer byteBuffer = ByteBuffer.allocate(size);
byteBuffer.clear();
SocketAddress address = channel.receive(byteBuffer);//receive data

while (true) {
	ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
	byteBuffer.clear();
	SocketAddress socketAddress = channel.receive(byteBuffer);
	if (socketAddress == null) {
		// System.out.println("没有客户端连接");
		TimeUnit.MILLISECONDS.sleep(1);
		continue;
	}
	//do something with DatagramChannel...
}

ByteBuffer byteBuffer = ByteBuffer.wrap(new String("i 'm client").getBytes());
int bytesSent = channel.send(byteBuffer, new InetSocketAddress("127.0.0.1", 9898));

Serializable serializable = "您好，DatagramChannel。";
ByteBuffer byteBuffer = ByteBufferUtils.writeObject(serializable);
// 发送数据，以下为简单模拟非阻塞模式重发3次机制
final int TIMES = 3;
int bytesSent  = 0;
int sendTime = 1;
while (bytesSent  == 0 && sendTime <= TIMES) {
	bytesSent  = datagramChannel.send(byteBuffer, new InetSocketAddress("127.0.0.1", 9898));
	sendTime++;
}

int bytesRead = channel.read(buf);
int bytesWritten = channel.write(but);

package io.flysium.nio.c2_channel.socket;

import io.flysium.nio.ByteBufferUtils;

import java.io.IOException;
import java.io.Serializable;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
import java.util.concurrent.TimeUnit;

/**
 * 网络UDP通道（DatagramChannel）测试 --作为服务端
 *
 * @author Sven Augustus
 */
public class DatagramChannelServerTest {

	public static void main(String[] args) throws IOException, 
ClassNotFoundException, InterruptedException {
		DatagramChannel channel = null;
		try {
			//打开DatagramChannel
			channel = DatagramChannel.open();
			//非阻塞模式
			channel.configureBlocking(false);
			//将 UDP 绑定到特定地址（IP 地址和端口号），作为服务端监听端口
			channel.bind(new InetSocketAddress("127.0.0.1", 9898));

			ByteBuffer buffer = ByteBuffer.allocate(1024);
			while (true) {
				buffer.clear();
				SocketAddress socketAddress = channel.receive(buffer);
				if (socketAddress == null) {
					// System.out.println("没有客户端连接");
					TimeUnit.MILLISECONDS.sleep(1);
					continue;
				}
				System.out.println("准备读："+ socketAddress);
				buffer.flip();//切换读模式
				Serializable object = ByteBufferUtils.readObject(buffer);
				System.out.println(object);
				// 往客户端写数据
				String serializable = "您好，客户端" + socketAddress.toString();
				System.out.println("准备写：" + serializable);
				ByteBuffer byteBuffer = 
                                           ByteBufferUtils.writeObject(serializable);
				channel.send(byteBuffer,socketAddress);
			}
		} finally {
			//关闭DatagramChannel
			if (channel != null) {
				channel.close();
			}
		}

	}

}

package io.flysium.nio.c2_channel.socket;

import io.flysium.nio.ByteBufferUtils;

import java.io.IOException;
import java.io.Serializable;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
import java.util.concurrent.TimeUnit;

/**
 * 网络UDP通道（DatagramChannel）测试 --作为客户端，发送数据
 *
 * @author Sven Augustus
 */
public class DatagramChannelClientTest {

	public static void main(String[] args) throws IOException, ClassNotFoundException {
		java.nio.channels.DatagramChannel channel = null;
		try {
			//打开DatagramChannel
			channel = DatagramChannel.open();
			//非阻塞模式
			channel.configureBlocking(false);
			// 发送数据将不用提供目的地址而且接收时的源地址也是已知的（这点类似SocketChannel），
			// 那么此时可以使用常规的read()和write()方法
			channel.connect(new InetSocketAddress("127.0.0.1", 9898));

			Serializable serializable = "您好，DatagramChannel。";
			System.out.println("准备写：" + serializable);
			ByteBuffer byteBuffer = ByteBufferUtils.writeObject(serializable);
			// 发送数据，以下为简单模拟非阻塞模式重发3次机制
			final int TIMES = 3;
			int bytesSent = 0;
			int sendTime = 1;
			while (bytesSent == 0 && sendTime <= TIMES) {
//bytesSent = datagramChannel.send(byteBuffer, new InetSocketAddress("127.0.0.1", 9898));
				bytesSent = channel.write(byteBuffer);
				sendTime++;
			}
			if (bytesSent > 0) {
				System.out.println("发送成功。");
			} else {
				System.out.println("发送失败。");
			}
			byteBuffer.clear();

			// 读取服务端发送的数据
			ByteBuffer buffer = ByteBuffer.allocate(1024);
			buffer.clear();
			int numBytesRead = -1;
			while ((numBytesRead = channel.read(buffer)) != -1) {
				if (numBytesRead == 0) {// 如果没有数据，则稍微等待一下
					try {
						TimeUnit.MILLISECONDS.sleep(1);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					continue;
				}
				buffer.flip();// 读取buffer
				Object object = ByteBufferUtils.readObject(buffer);
				System.out.println(object);
				buffer.clear(); // 复位，清空
			}
		} finally {
			//关闭DatagramChannel
			if (channel != null) {
				channel.close();
			}
		}

	}

}

Pipe pipe = Pipe.open();

Pipe.SinkChannel sinkChannel = pipe.sink();

Pipe.SourceChannel sourceChannel = pipe.source();

package io.flysium.nio.c2_channel.pipe;

import io.flysium.nio.ByteBufferUtils;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.Serializable;
import java.nio.ByteBuffer;
import java.nio.channels.Pipe;

/**
 * 管道测试
 * @author Sven Augustus
 */
public class PipeTest {

	static class Input implements Runnable {

		private final Pipe pipe;

		public Input(Pipe pipe) {
			this.pipe = pipe;
		}

		@Override
		public void run() {
			try {
				Pipe.SourceChannel sourceChannel = pipe.source();

				System.out.println("管道读取准备。");
				ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
				int bytesRead = sourceChannel.read(byteBuffer);
				byteBuffer.flip();//切换读模式
				Serializable serializable = 
                                           ByteBufferUtils.readObject(byteBuffer);
				System.out.println("管道读取结果：" + serializable);
			} catch (IOException e) {
				e.printStackTrace();
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
		}
	}

	static class Output implements Runnable {
		private final Pipe pipe;

		public Output(Pipe pipe) {
			this.pipe = pipe;
		}

		@Override
		public void run() {
			try {
				Pipe.SinkChannel sinkChannel = pipe.sink();

				System.out.println("管道写出准备。");
				Serializable object = "您好啊，Pipe。";
				ByteBuffer byteBuffer = ByteBufferUtils.writeObject(object);
				while (byteBuffer.hasRemaining()) {
					sinkChannel.write(byteBuffer);
				}
				System.out.println("管道写出完成："+object);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) throws IOException {
		Pipe pipe = Pipe.open();
		new Thread(new Input(pipe)).start();
		new Thread(new Output(pipe)).start();
	}

}

Selector selector = Selector.open();

channel.configureBlocking(false);
SelectionKey key = channel.register(selector, Selectionkey.OP_READ);

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

Set selectedKeys = selector.selectedKeys();

Set selectedKeys = selector.selectedKeys();
Iterator keyIterator = selectedKeys.iterator();
while(keyIterator.hasNext()) {
    SelectionKey key = keyIterator.next();
    keyIterator.remove();
	if(key.isAcceptable()) {
        // 接收就绪，server channel成功接受到一个连接。
		//  a connection was accepted by a ServerSocketChannel.
    } else if (key.isConnectable()) {
        //连接就绪，channel成功连接另一个服务器。
		// a connection was established with a remote server.
    } else if (key.isReadable()) {
        //读就绪，channel通道中有数据可读。
		// a channel is ready for reading
    } else if (key.isWritable()) {
        //写就绪，channel通道等待写数据。
		// a channel is ready for writing
    }
}

package io.flysium.nio.c3_selector;

import io.flysium.nio.ByteBufferUtils;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * ServerSocketChannel示例，使用Selector模式
 *
 * @author Sven Augustus
 */
public class ServerSocketChannelTest2 {

	public static void main(String[] args) throws IOException, 
	InterruptedException, ClassNotFoundException {
		ServerSocketChannel channel = null;
		Selector selector = null;
		try {
			// 打开 ServerSocketChannel
			channel = ServerSocketChannel.open();
			// 设置非阻塞模式，read的时候就不再阻塞
			channel.configureBlocking(false);
			// 将 ServerSocket 绑定到特定地址（IP 地址和端口号）
			channel.bind(new InetSocketAddress("127.0.0.1", 9595));

			// 创建Selector选择器
			selector = Selector.open();
			// 注册事件，监听客户端连接请求
			channel.register(selector, SelectionKey.OP_ACCEPT);

			final int timeout = 1000;//超时timeout毫秒
			while (true) {
				if (selector.select(timeout) == 0) {//无论是否有事件发生，selector每隔timeout被唤醒一次
					continue;
				}
				Set selectedKeys = selector.selectedKeys();
				Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
				while (keyIterator.hasNext()) {
					SelectionKey key = keyIterator.next();
					keyIterator.remove();
					if (key.isAcceptable()) {// 接收就绪，server channel成功接受到一个连接。
						SocketChannel socketChannel = ((ServerSocketChannel) key.channel()).accept();
						socketChannel.configureBlocking(false);// 设置非阻塞模式
						// 注册读操作 , 以进行下一步的读操作
						socketChannel.register(key.selector(), SelectionKey.OP_READ);
					} else if (key.isConnectable()) {//连接就绪，channel成功连接另一个服务器。

					} else if (key.isReadable()) {//读就绪，channel通道中有数据可读。
						SocketChannel socketChannel = (SocketChannel) key.channel();
						//System.out.println("准备读：");
						// 读取客户端发送的数据
						ByteBuffer buffer = ByteBuffer.allocate(1024);
						buffer.clear();
						int readBytes = socketChannel.read(buffer);
						if (readBytes >= 0) {// 非阻塞，立刻读取缓冲区可用字节
							buffer.flip();// 读取buffer
							Object object = ByteBufferUtils.readObject(buffer);
							//System.out.println(object);
							//附加参数
							key.attach(object);
							// 切换写操作 , 以进行下一步的写操作
							key.interestOps(SelectionKey.OP_WRITE);
						} else if (readBytes < 0) { //客户端连接已经关闭，释放资源
							System.out.println("客户端" + socketChannel.socket().getInetAddress() 
							+ "端口" + socketChannel.socket().getPort() + "断开...");
							socketChannel.close();
						}
					} else if (key.isValid() && key.isWritable()) {//写就绪，channel通道等待写数据。
						SocketChannel socketChannel = (SocketChannel) key.channel();
						// 计算
						Integer integer = Integer.parseInt(String.valueOf(key.attachment()));
						String serializable = String.valueOf(integer * 2);
						// 往客户端写数据
						ByteBuffer byteBuffer = ByteBufferUtils.writeObject(serializable);
						socketChannel.write(byteBuffer);
						System.out.println("客户端服务器：" + integer + "，响应：" + serializable);
						// 切换读操作 , 以进行下一次的接口请求，即下一次读操作
						key.interestOps(SelectionKey.OP_READ);
					}
				}
			}
		} finally {
			//关闭 ServerSocketChannel
			if (channel != null) {
				channel.close();
			}
			if (selector != null) {
				selector.close();
			}
		}
	}


}

package io.flysium.nio.c3_selector;

import io.flysium.nio.ByteBufferUtils;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * SocketChannel示例，使用Selector模式
 *
 * @author Sven Augustus
 */
@SuppressWarnings("unused")
public class SocketChannelTest2 {

	public static void main(String[] args) throws IOException,
	InterruptedException, ClassNotFoundException {
		new Thread(new ClientRunnable("A")).start();
		new Thread(new ClientRunnable("B")).start();
		new Thread(new ClientRunnable("C")).start();
		new Thread(new ClientRunnable("D")).start();
	}

	private static class ClientRunnable implements Runnable {

		private final String name;

		private ClientRunnable(String name) {
			this.name = name;
		}

		@Override
		public void run() {
			SocketChannel channel = null;
			Selector selector = null;
			try {
				// 打开SocketChannel
				channel = SocketChannel.open();
				// 设置非阻塞模式，read的时候就不再阻塞
				channel.configureBlocking(false);
				// tcp连接网络
				channel.connect(new InetSocketAddress("127.0.0.1", 9595));

				// 创建Selector选择器
				selector = Selector.open();
				// 注册事件，监听读/写操作
				channel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);

				final int timeout = 1000;//超时timeout毫秒
				if (channel.finishConnect()) {// 连接服务器成功
					while (true) {
						if (selector.select(timeout) == 0) {
							continue;
						}
						Set selectedKeys = selector.selectedKeys();
						Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
						while (keyIterator.hasNext()) {
							SelectionKey key = keyIterator.next();
							keyIterator.remove();
							if (key.isValid() && key.isWritable()) {//写就绪，channel通道等待写数据。
								TimeUnit.SECONDS.sleep(3);
								SocketChannel socketChannel = (SocketChannel) key.channel();
								// 往服务端写数据
								String serializable = String.valueOf(new Random().nextInt(1000));
								//System.out.println("准备写：" + serializable);
								ByteBuffer byteBuffer = ByteBufferUtils.writeObject(serializable);
								socketChannel.write(byteBuffer);
								//附加参数
								key.attach(serializable);
								// 切换读操作 , 以进行下一次的接口请求，即下一次读操作
								key.interestOps(SelectionKey.OP_READ);
							} else if (key.isReadable()) {//读就绪，channel通道中有数据可读。
								SocketChannel socketChannel = (SocketChannel) key.channel();
								//System.out.println("准备读：");
								// 读取服务端发送的数据
								ByteBuffer buffer = ByteBuffer.allocate(1024);
								buffer.clear();
								int readBytes = socketChannel.read(buffer);
								if (readBytes >= 0) {// 非阻塞，立刻读取缓冲区可用字节
									buffer.flip();// 读取buffer
									Object object = ByteBufferUtils.readObject(buffer);
									//System.out.println(object);
									buffer.clear(); // 复位，清空
									Integer integer = Integer.parseInt(String.valueOf(key.attachment()));
									System.out.println("线程-" + name 
+ "，请求服务器：" + integer + "，响应：" + object);
									// 切换写操作 , 以进行下一步的写操作，即接口请求
									key.interestOps(SelectionKey.OP_WRITE);
								} else if (readBytes < 0) { //客户端连接已经关闭，释放资源
									System.out.println("服务端断开...");
								}
							}
						}
					}
				} else {
					System.out.println("连接失败，服务器拒绝服务");
					return;
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (ClosedChannelException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			} finally {
				// 关闭SocketChannel
				if (channel != null) {
					try {
						channel.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			}
		}
	}

}

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body   = ByteBuffer.allocate(1024);
ByteBuffer[] bufferArray = { header, body };
channel.read(bufferArray);

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body   = ByteBuffer.allocate(1024);
//write data into buffers
ByteBuffer[] bufferArray = { header, body };
channel.write(bufferArray);