java nio入门学习，javanio入门

java nio入门学习，javanio入门

原本想直接扔代码,但是想想还是算了吧,毕竟如果直接扔的话,如果其他人看的话,可能会看不懂

首先,java io和java nio的区别, java io是面向流的,阻塞的, 而java nio 是在jdk1.4发布的,一种面向缓存的(ByteBuffer) ,非阻塞的,并且有selector,传输过程.

java io和java nio相比,java io适合连接少,并且一次传输大量数据的情况.而java nio适合网络情况,比如网络中的高并发,所以java nio是高并发的情况,但是同样的也优缺点.java io的缺点是,不是和高并发,并且阻塞.而java nio的缺点是最资源损耗大

介绍下,java nio中的重要的几个部分.

Channel:类似于流,在javanio中有很多的channel负责不同的工作

ByteBuffer 缓冲区

selector:通过轮询管理注册在这上边的Channel,selectionkey是channel注册到selector并添加事件返回对象,当有事件时,通过selectionKey找到处理改事件的channel

好的上代码

NioServer

package spring.controller;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
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;

public class NioServer {
	 /*标识数字*/ 
    private  int flag = 0;  
    /*缓冲区大小*/ 
    private  int BLOCK = 4096;  
    /*接受数据缓冲区*/ 
    private  ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK);  
    /*发送数据缓冲区*/ 
    private  ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK);  
    private  Selector selector;  
    private ServerSocketChannel ssc = null;
	
    public NioServer(int port) throws Exception {
    	//创建服务器通道
    	ssc = ServerSocketChannel.open();
    	//将改通道设置为非阻塞的
    	ssc.configureBlocking(false);
    	//创建selector
    	selector = Selector.open();
    	//创建与通道相关的服务器套接字
    	ServerSocket ss = ssc.socket();
    	//绑定端口
    	ss.bind(new InetSocketAddress(port));
    	
    	//将channel注册到selector,同时给该channel注册SelectionKey.OP_ACCEPT事件
    	//请注意对 register() 的调用的返回值。 SelectionKey 代表这个通道在此 Selector 上的这个注册。
    	//当某个 Selector 通知您某个传入事件时，它是通过提供对应于该事件的 SelectionKey 来进行的。SelectionKey 还可以用于取消通道的注册。
    	SelectionKey key = ssc.register(selector, SelectionKey.OP_ACCEPT);
    }
    
    //监听
    private void listen() throws IOException {
    	//死循环selector
    	while(true) {
    		//当有事件到达时,选择一组准备进行io通信的chanel的key;否则该方法一直阻塞
    		selector.select();
    		//返回此选择器的已选择key集
    		Set<SelectionKey> selectionKeys = selector.selectedKeys();
    		Iterator<SelectionKey> iterator = selectionKeys.iterator();
    		while(iterator.hasNext()) {
    			SelectionKey selectionKey = iterator.next();
    			//删除key,以防止重复处理
    			iterator.remove();
    			handlerKey(selectionKey);
    		}
    	}
    }
    
    //处理请求
	private void handlerKey(SelectionKey selectionKey) throws IOException {
		//接收请求
		ServerSocketChannel server = null;
		SocketChannel client = null;
		String receiveText;
		String sendText;
		int count = 0;
		
		//测试此键的通道是否已准备好,接收新的套接字连接
		if(selectionKey.isAcceptable()) {
			//返回创建此key创建的的通道
			server = (ServerSocketChannel) selectionKey.channel();
			//用于测试这个server跟构造方法中的ssc是否相同,答案就是true
			//System.out.println(server.equals(ssc));
			//获得与客户端的连接通道
			client = server.accept();
			//配置为非阻塞
			client.configureBlocking(false);
			System.out.println("成功连接到客户端");
			//在和客户端连接成功之后,为了可以接收到客户端的信息,给通道配置读写的权限(相当于给了channel,读写的监听)
			client.register(selector, SelectionKey.OP_READ|SelectionKey.OP_WRITE);
		} else if(selectionKey.isReadable()) {
			//返回创建此key创建的的通道。  
            client = (SocketChannel) selectionKey.channel();  
            //将缓冲区清空以备下次读取  
            receivebuffer.clear();  
            //读取服务器发送来的数据到缓冲区中  
            count = client.read(receivebuffer);   
            if (count > 0) {  
                receiveText = new String( receivebuffer.array(),0,count);  
                System.out.println("服务器端接受客户端数据--:"+receiveText);  
            }  
		} else if (selectionKey.isWritable()) {  
			//因为在通道中添加了写的监听,相当于监听的是server本身有"写"这个操作,所以此key的isWritable是一直为true,它不像isReadable,监听的是对面
			//是不是"写"的操作,如果对面有"写"的操作,我们这边"读"才为true,总结就是无论那一端,只要设置"写"权限,通道key的isWritable就是为true的
            //将缓冲区清空以备下次写入  
            sendbuffer.clear();  
          //返回创建此key创建的的通道  
            client = (SocketChannel) selectionKey.channel();  
            sendText="message from server--" + flag++;  
            //向缓冲区中输入数据  
            sendbuffer.put(sendText.getBytes());  
             //将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位  
            sendbuffer.flip();  
            //输出到通道  
            client.write(sendbuffer); 
            client.close();
            System.out.println("服务器端向客户端发送数据--："+sendText);  
        }  
	}

	public static void main(String[] args) throws Exception {
		new NioServer(9981).listen();
	}
}

NioClient.java

package spring.controller;

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;

public class NioClient {
	//管道管理器
    private Selector selector;
    
    public NioClient init(String serverIp, int port) throws IOException{
        //获取socket通道
        SocketChannel channel = SocketChannel.open();
        
        channel.configureBlocking(false);
        //获得通道管理器
        selector=Selector.open();
        
        //客户端连接服务器，需要调用channel.finishConnect();才能实际完成连接。
        channel.connect(new InetSocketAddress(serverIp, port));
        //为该通道注册SelectionKey.OP_CONNECT事件
        channel.register(selector, SelectionKey.OP_CONNECT);
        return this;
    }
    
    public void listen() throws IOException{
        System.out.println("客户端启动");
        //轮询访问selector
        while(true){
            //选择注册过的io操作的事件(第一次为SelectionKey.OP_CONNECT)
            selector.select();
            Iterator<SelectionKey> ite = selector.selectedKeys().iterator();
            while(ite.hasNext()){
                SelectionKey key = ite.next();
                //删除已选的key，防止重复处理
                ite.remove();
                if(key.isConnectable()){
                    SocketChannel channel=(SocketChannel)key.channel();
                    
                    //如果正在连接，则完成连接
                    if(channel.isConnectionPending()){
                        channel.finishConnect();
                    }
                    
                    channel.configureBlocking(false);
                    //向服务器发送消息
                    channel.write(ByteBuffer.wrap(new String("send message to server.").getBytes()));
                    
                    //连接成功后，注册接收服务器消息的事件
                    channel.register(selector, SelectionKey.OP_READ|SelectionKey.OP_WRITE);
                    System.out.println("客户端连接成功");
                }else if(key.isReadable()){ //有可读数据事件。
                    SocketChannel channel = (SocketChannel)key.channel();
                    
                    ByteBuffer buffer = ByteBuffer.allocate(10);
                    channel.read(buffer);
                    byte[] data = buffer.array();
                    String message = new String(data);
                    
                    System.out.println("recevie message from server:, size:" + buffer.position() + " msg: " + message);
//                    ByteBuffer outbuffer = ByteBuffer.wrap(("client.".concat(msg)).getBytes());
//                    channel.write(outbuffer);
                }
            }
        }
    }
    
    public static void main(String[] args) throws IOException {
        new NioClient().init("127.0.0.1", 9981).listen();
    }
}