导语

缓冲器的设计的是新IO模型中最基础的一部分。因为新IO模型中要求所有的IO操作都需要进行缓冲。在新的IO模型中，不再向输出流写入数据和从数据流中读取数据了，而是要从缓冲区中读写数据。缓冲区可是是数组，也可以是与硬件或内存直接连接。

从编程的角度来看，流和通道之间的关键区别子在于流是基于字节的，而通道是基于块的。流设计为按顺序一字节接一字节地传输数据。出于性能的考虑，可以传送字节数组。不过，基本的概念都是一次传输一个字节的数据。与之不同的是，通道会传输缓冲区中的数据块。

基本概念

缓冲区可以看作是固定大小的元素列表，这些元素为特定类型，一般是基本数据类型。除boolean外，java中所有基本数据类型都有特定的Buffer子类：ByteBuffer,CharBuffer,ShortBuffer,IntBuffer,LongBuffer,FloatBuffer和DoubleBuffer。每个子类中的方法都有相应类型的返回值和参数列表。例如：DoubleBuffer类有设置和获取double的方法。不管缓冲区具体是什么类型，他们都有四个关键部分。

position

缓冲区中见读取或写入的位置，读取和写入时都从这个位置开始，其初始值为0，最大等于缓冲区的大小。可以用下面两个方法来获取和设置该值：

public final int position（）

public final Buffer position（int newPosition）

capacity

缓冲区可以保存的元素最大数目。容量值在创建缓冲区时设置，此后不能改变，可以用下面的方式读取：

public final int capacity()

limit

缓冲区中可访问的末尾位置，读或写时只能到limit的前一个位置，其初始值等于capacity。通过下面两个方法来控制：

public final int limit()

public final Buffer limit(int newLimit)

mark

在对缓冲区进行读写的时候用户可以通过mark进行标记。调用mark()时，mark的值等于position的值。调用reset()可以将position的值设置为mark值。

public final Buffer mark()

public final Buffer reset()

对缓冲区的操作还有其他几个方法。clear()方法将位置设置为0，将限度设置为容量，从而将缓冲区"清空"。这样就可以重新填充缓冲区了。rewind()的方法将位置设置为0，这样就可以重新读取缓冲区了。flip()方法将限度设置为当前位置，位置设置为0。

创建缓冲区

分配

通过allocate()方法创建一个固定大小的缓冲区。该方法创建的缓冲区是基于Java数组实现的。

ByteBuffer buffer = ByteBuffer.allocate(100);

直接分配

ByteBuffer类(其他类没有)有另外一个方法是 allocateDirect()方法，这个方法不为缓冲区创建Java数组。JVM会对以太网卡，核心内存或其他位置上的缓冲区使用直接内存访问，这样可以提升IO操作的性能。不过在API角度来说，两者在使用上是没有区别的。创建直接缓冲区的代价比间接缓冲区要高，除非必须要使用直接缓冲区则去创建它。

包装

如果有了要输出的数据数组，则可以用缓冲区进行包装。例如：

byte[] data = "Some data".getBytes("UTF-8");

ByteBuffer buffer = ByteBuffer.wrap(data);

在这里，缓冲区直接将该数组作为后备数组，即该数组已经变为缓冲区了。所以对该数组的操作将直接反应到缓冲区，反之亦然。

填充和排空

缓冲区是为顺序访问而设计的。没有缓冲区都有一个当前位置，由position来标识。从缓冲区读取或写入一个元素时，position都将增1。例如：假设你想分配一个容量为12的CharBuffer，并在其中放置5个字符：

CharBuffer buffer = CharBuffer.allocate(12);

buffer.put('H');

buffer.put('e');

buffer.put('l');

buffer.put('l');

buffer.put('o');

缓冲区现在的位置为5。这称为填充缓冲区。如果现在试图使用get()从缓冲区获取数据，则会得到null字符。要想读取之前写入的数据需要调用flip()将缓冲区回绕。当然还有两个扩展方法可以指定位置来读或写。

public abstract byte get(int index)

public abstract ByteBuffer put(int index, byte b)

批量方法

即使使用缓冲区，操作数据块通常比一次填写一个元素要快。不同的缓冲区都有一些批量方法来填充或排空相应的数组。例如:

public ByteBuffer get(byte[] dst, int offset, int length);

public ByteBuffer get(byte[] dst)

public ByteBuffer put(byte[] array, int offset, int length)

public ByteBuffer put(byte[] array)

复制缓冲区

经常需要建立缓冲区的副本，从而将相同的信息分发到两个或多个通道。6中特定类型缓冲区类提供了duplicate()方法来完成这项工作：

public abstract ByteBuffer duplicate()

public abstract IntBuffer duplicate()

public abstract ShortBuffer duplicate()

public abstract FloatBuffer duplicate()

public abstract CharBuffer duplicate()

public abstract DoubleBuffre duplicate()

返回值是对原来缓冲区的复制，但不复制简介缓冲区(建立缓冲区时创建的用于存储数据的数组)。修改通过复制得到的缓冲区中的数据会直接反应到另一个缓冲区。这个方法主要用于只是读取缓冲区中的数据。虽然多个缓冲区共享数据，但是每个缓冲区都有独立的标记，限度和位置。希望多个通道大致并行地传输相同的数据时，这个方法特别有用。下面是改版后的单文件传输服务器：

import java.io.IOException;

import java.net.InetSocketAddress;

import java.net.URLConnection;

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.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.util.Iterator;

import java.util.Set;

public class NonblockingSingleFileHTTPServer {

	private ByteBuffer contentBuffer;

	private final byte[] header;

	private final byte[] discard;

	private int port;

	public NonblockingSingleFileHTTPServer(int _port, byte[] data,

			String encoding, String contentType) {

		port = _port;

		String respHeader = "HTTP/1.1 200 OK\r\n"

                + "Server: OneFile\r\n"

                + "Content-length: "+ data.length +"\r\n"

                + "Content-Type: " + contentType + ";charset=" + encoding + "\r\n\r\n";

		header = respHeader.getBytes();

		contentBuffer = ByteBuffer.allocate(header.length + data.length);

		contentBuffer.put(header);

		contentBuffer.put(data);

		contentBuffer.position(0);

		discard = new byte[4096];

	}

	private void start() {

		Selector selector;

		try {

			ServerSocketChannel server = ServerSocketChannel.open();

			server.configureBlocking(false);

			server.bind(new InetSocketAddress(port));

			selector = Selector.open();

			server.register(selector, SelectionKey.OP_ACCEPT);

		} catch (IOException e) {

			e.printStackTrace();

			return;

		}

		while (true) {

			try {

				selector.select();

			} catch (IOException e) {

				e.printStackTrace();

				break;

			}

			Set<SelectionKey> readykeys = selector.selectedKeys();

			Iterator<SelectionKey> iterator = readykeys.iterator();

			ByteBuffer buffer = ByteBuffer.wrap(discard);

			while (iterator.hasNext()) {

				SelectionKey key = iterator.next();

				iterator.remove();

				try {

					if (key.isAcceptable()) {

						ServerSocketChannel server = (ServerSocketChannel) key.channel();

						SocketChannel client = server.accept();

						client.configureBlocking(false);

						SelectionKey key2 = client.register(selector, SelectionKey.OP_READ|SelectionKey.OP_WRITE);

						key2.attach(contentBuffer.duplicate());

					} else if (key.isReadable()) {

						SocketChannel client = (SocketChannel) key.channel();

						buffer.clear();

						client.read(buffer);

					} else if (key.isWritable()) {

						SocketChannel client = (SocketChannel) key.channel();

						ByteBuffer duplication = (ByteBuffer) key.attachment();

						if (duplication.hasRemaining())

							client.write(duplication);

						else {

							client.close();

							key.cancel();

						}

					}

				} catch (IOException e) {

					if (key.isAcceptable())

						e.printStackTrace();

					else {

						key.cancel();

						try {

							key.channel().close();

						} catch (IOException e1) {}

					}

				}

			}

		}

	}

	public static void main(String[] args) {

		int port;

		String encoding = "utf-8";

		if (args.length == 0) {

			System.out.println("Usage: java NonblockingSingleFileHTTPServer file port encoding");

			return;

		}

		if (args.length > 2)

			encoding = args[2];

		try {

			port = Integer.parseInt(args[1]);

		} catch (NumberFormatException e) {

			port = 80;

		}

		Path path = Paths.get(args[0]).toAbsolutePath();

		String contentType = URLConnection.getFileNameMap().getContentTypeFor(path.toString());

		try {

			byte[] data = Files.readAllBytes(path);

			NonblockingSingleFileHTTPServer server = new NonblockingSingleFileHTTPServer(port, data, encoding, contentType);

			server.start();

		} catch (IOException e) {

			e.printStackTrace();

		}

	}

}