原来的 I/O 以流的方式处理数据，而 NIO 以块的方式处理数据。 面向流 的 I/O 系统一次一个字节地处
理数据。一个输入流产生一个字节的数据，一个输出流消费一个字节的数据。为流式数据创建过滤器非常容易。链接几个过滤器，以便每个过滤器只负责单个复杂处理机制的一部分，这样也是相对简单的。不利的一面是，面向流的 I/O 通常相当慢。 一个 面向块 的 I/O 系统以块的形式处理数据。每一个操作都在一步中产生或者消费一个数据块。按块处理数据比按(流式的)字节处理数据要快得多。但是面向块的 I/O 缺少一些面向流的I/O 所具有的优雅性和简单性。
NIO主要原理和适用。
NIO 有一个主要的类Selector,这个类似一个观察者，只要我们把需要探知的socketchannel告诉Selector,我们接着做别的事情，当有事件发生时，他会通知我们，传回一组SelectionKey,我们读取这些Key,就会获得我们刚刚注册过的socketchannel,然后，我们从这个Channel中读取数据，放心，包准能够读到，接着我们可以处理这些数据。
Selector内部原理实际是在做一个对所注册的channel的轮询访问，不断的轮询(目前就这一个算法)，一旦轮询到一个channel有所注册的事情发生，比如数据来了，他就会站起来报告，交出一把钥匙，让我们通过这把钥匙来读取这个channel的内容。
服务器端:
package cn.com.testnio.base;
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.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
/**
* NIO是面向缓冲区的
* User: lihaoquan
*/
public class Server {
private Selector selector;
/**
* 值得注意的是 Buffer 及其子类都不是线程安全的。
*/
private ByteBuffer readBuffer = ByteBuffer.allocate(1024);//设置缓冲区大小
/**
* ConcurrentHashMap是支持并发的,所以这里不使用HashMap
*/
private Map<SocketChannel,byte[]> clientMessage
= new ConcurrentHashMap<SocketChannel,byte[]>();
/**
* 启动开关
* @throws IOException
*/
public void start() throws IOException {
//通过静态工厂生产服务端的channel
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
//设置非阻塞方式
serverSocketChannel.configureBlocking(false);
//绑定IP
serverSocketChannel.socket().bind(new InetSocketAddress(8080));
//创建选择器
selector = Selector.open();
//注册监听事件
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
while (!Thread.currentThread().isInterrupted()) {
selector.select();
Set<SelectionKey> keys = selector.selectedKeys();
Iterator<SelectionKey> keyIterator = keys.iterator();
while (keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();
if(!key.isValid()) {
continue;
}
if(key.isAcceptable()) {
accept(key);
}else if(key.isReadable()) {
read(key);
}
//去除本次keyIterator.next()的对象,但不会对下次遍历有影响
keyIterator.remove();
}
}
}
/**
* 读入
* @param key
* @throws IOException
*/
public void read(SelectionKey key) throws IOException{
SocketChannel socketChannel = (SocketChannel) key.channel();
this.readBuffer.clear();
int numRead;
try {
/**
* 获取客户点的read操作读入数据块数量
*/
numRead = socketChannel.read(readBuffer);
}catch (Exception e) {
e.printStackTrace();
key.cancel();
socketChannel.close();
clientMessage.remove(socketChannel);
return;
}
byte[] bytes = clientMessage.get(socketChannel);
if(bytes == null) {
bytes = new byte[0];
}
if(numRead > 0) {
byte[] newBytes =new byte[bytes.length+numRead];
System.arraycopy(bytes,0,newBytes,0,bytes.length);
System.arraycopy(readBuffer.array(), 0, newBytes, bytes.length, numRead);
clientMessage.put(socketChannel, newBytes);
System.out.println("message>>>"+new String(newBytes));
}else {
String message = new String(bytes);
System.out.println("data>>>"+message);
}
}
/**
* 接收
* @param key
* @throws IOException
*/
public void accept(SelectionKey key) throws IOException {
ServerSocketChannel serverSocketChannel
= (ServerSocketChannel) key.channel();
SocketChannel clientChannel = serverSocketChannel.accept();
clientChannel.configureBlocking(false);
clientChannel.register(selector,SelectionKey.OP_READ);
System.out.println("已成功连接新的客户端......");
}
public static void main(String[] args) throws Exception{
new Server().start();
}
}
客户端
package cn.com.testnio.base;
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.SocketChannel;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;
/**
* User: lihaoquan
*/
public class Client {
/**
* 启动开关
* @throws IOException
*/
public void start() throws IOException {
//通过静态工厂生产客户端的channnel
SocketChannel socketChannel = SocketChannel.open();
//设置客户端请求为非阻塞方式
socketChannel.configureBlocking(false);
//绑定IP
socketChannel.connect(new InetSocketAddress(8080));
//创建选择器
Selector selector = Selector.open();
//注册监听事件
socketChannel.register(selector, SelectionKey.OP_CONNECT);
//键盘输入
Scanner scanner = new Scanner(System.in);
while (true) {
selector.select();
Set<SelectionKey> keys = selector.selectedKeys();
Iterator<SelectionKey> keyIterator = keys.iterator();
while (keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();
//去除本次keyIterator.next()的对象,但不会对下次遍历有影响
keyIterator.remove();
if(key.isConnectable()) {
socketChannel.finishConnect();
socketChannel.register(selector,SelectionKey.OP_WRITE);
System.out.println("客户端已经连上服务器端!!");
break;
}else if(key.isWritable()) {
System.out.println("请输入信息!!");
String message = scanner.nextLine();
ByteBuffer writeBuffer = ByteBuffer.wrap(message.getBytes());
socketChannel.write(writeBuffer);
}
}
}
}
public static void main(String[] args) throws Exception{
new Client().start();
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
