java nio之数据读写时无限循环分析与解决

    写这片文章是因为自己昨天刚解决了一个十个月前碰到的问题！当时苦于网上高手无人回答，也苦于自己当时没有时间去钻研为什么

！

   问题是:通过网上实例以及java网络编程这本书写java nio简单的测试服务器时发现，都是注册读写事件后然后分别处理相应的事件

就行了，这样本没错，可对于后续对注册事件的操作，再也没有看到与之相关实例与说明。然而，就这样完事以后，服务器端要么是

无限读事件与写事件有效，要么是客户端接收的数据是重复的好几条，在高并发时甚至上百上千。

   一般网络通讯程序是，客户端请求，然后服务端回复响应，即key.isReadable()时，服务器端接收请求，key.isWriteable()时，服

务端返回响应！一般我们在处理完接收后，我们就注册写事件，然后有写事件时处理写事件，正常网上的实例都是这样写的，可是这

样的话，客户端第二次以后发送时，服务器端再也没有进入到读事件中，还写事件回复的数据也很怪异，返回很多重复的数据。

再改进一点的是，写事件完事以后，又注册一个读事件，这样又可以读了，然后读了以后再注册写，这样反复重复，的确，能很好的

解决问题了。可是是因为什么原因呢？当时我是这样解决的，凑合用着，但是不知道为什么！

    昨天偶尔想起这个问题，然后查看mina源码时，发现其只注册过读事件，而对写事件并没有注册过，只是发现有一些

key.interestOps(SelectionKey.OP_WRITE)的操作，不是很明白，后来查看帮忙文档，知道这是管道当前感兴趣的事件时突然有些明

白了，后来又查看jdk源码，发现，每当重复注册时，都会检测事件是否已经注册过，如果已经注册过的事件，会把当前感兴趣的事

件切换成现在感兴趣的事件，这样所有的都明白了。

    即：管道注册事件，可以有四种事件，它可以注册所有的事件，但是管道每次只能对一种事件有效，即注册读事件时，此时只对读事

件有效，注册写事件时，此时只对写事件有效，这样上面的笨方法来回注册刚好达到这种效果，多的只是每次注册时的一次判断是否

已经注册过。当然我们也有更好的方法，那就是通过key.interestOps方法来切换当前感兴趣的事件，这样就可以避免每次注册时都

需要判断了。

    以上把问题与解决方法说明，现在附一下网上经常看到的服务器端实例！只是做了一些简单的修改。另外客户端网上很多也用非阻塞

实现的，我感觉没有必要，因为非阻塞只是为了解决高并发的问题。下面附上的客户端是我用socket写的一个简单实例！

 

 

//服务器
package com.netease.nio;

import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.channels.Selector;
import java.nio.channels.SelectionKey;

import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.CharBuffer;

import java.util.Iterator;

import java.io.IOException;

//基于非阻塞的服务器实现
public class NioServer {
 
 private static int DEFAULT_PORT = 512;
 private static int DEFAULT_BUFFERSIZE = 1023;
 private static String DEFAULT_CHARSET = "UTF-8";
 
 private ServerSocketChannel ss;
 private Selector selector;
 
 private ByteBuffer buffer;
 private Charset charset;
 private CharsetDecoder decoder;
 private int port;
 public NioServer() throws IOException{
  
  this.port = DEFAULT_PORT;
  this.ss = null;
  this.selector = Selector.open();
  this.buffer = ByteBuffer.allocate(DEFAULT_BUFFERSIZE);
  this.charset = Charset.forName(DEFAULT_CHARSET);
  this.decoder = this.charset.newDecoder();
  
 }
 
 //处理key
 public void handlerKey(SelectionKey key) throws IOException{
  
  if(key.isAcceptable()){
   
   System.out.println("one client coming");
   //取出对应的服务器通道
   ServerSocketChannel server = (ServerSocketChannel)key.channel();
   //对应socketchannel
   SocketChannel channel = server.accept();
   channel.configureBlocking(false);
   //可读
   channel.register(selector, SelectionKey.OP_READ);
  }else if(key.isReadable()){
   
    SocketChannel channel = (SocketChannel) key.channel();
   
             int count = channel.read(this.buffer);
             System.out.println("开始read");
             if (count > 0)
              {
              //把极限设为位置，把位置设为0，这样读取buffer时，刚好读取其已经读取多少内容的buffer
              this.buffer.flip();
              
               CharBuffer charBuffer = decoder.decode(this.buffer);
               String message = charBuffer.toString();
               //服务端接收客户端来的数据
               System.out.println("server:" + message);
            //   NioSession data = new NioSession(message);
              
             //切换为写事件
               key.interestOps(SelectionKey.OP_WRITE);
      //        channel.register(selector, SelectionKey.OP_WRITE);
               key.attach(message);
              
             }
             else
             { //客户已经断开
                 channel.close();
             }
             //把极限设为容量，再把位置设为0。
      //       this.buffer.clear();//清空缓冲区,为下一次接收数据做准备
            
             //极限不变，再把位置设为0，这样跟初始化时buffer是一样的
             this.buffer.rewind();
  }else if(key.isWritable() && key.isValid()){
   
   SocketChannel channel = (SocketChannel) key.channel();
  // NioSession handle = (NioSession) key.attachment();//取出处理者
   String message = "re:"+((String)key.attachment());
  // handle.setGreeting(message);
            ByteBuffer block = ByteBuffer.wrap(message.getBytes());
            channel.write(block);
          //切换为读事件
            key.interestOps(SelectionKey.OP_READ);
            //此时重新注册一个读事件时，当调用此方法时，register当检测读事件已经存在时，
    //        channel.register(selector,SelectionKey.OP_READ);
  }
 }
 
 public void listen() throws IOException
    { //服务器开始监听端口，提供服务
       ServerSocket socket;
       ss = ServerSocketChannel.open(); // 打开通道
       socket = ss.socket();   //得到与通到相关的socket对象
       socket.bind(new InetSocketAddress(port));   //将scoket榜定在制定的端口上
       //配置通到使用非阻塞模式，在非阻塞模式下，可以编写多道程序同时避免使用复杂的多线程
       ss.configureBlocking(false);   
       ss.register(selector, SelectionKey.OP_ACCEPT);
       try
        {
           while(true)
            {//     与通常的程序不同，这里使用channel.accpet()接受客户端连接请求，而不是在socket对象上调用accept(),

这里在调用accept()方法时如果通道配置为非阻塞模式,那么accept()方法立即返回null，并不阻塞
               this.selector.select();
               Iterator iter = this.selector.selectedKeys().iterator();
               while(iter.hasNext())
                {
                   SelectionKey key = (SelectionKey)iter.next();
                   iter.remove();
                   this.handlerKey(key);
                  
               }
           }
       }
       catch(IOException ex)
        {
           ex.printStackTrace();
           this.ss.close();
       }
   }

 public static void main(String[] args) throws IOException
    {
       System.out.println("服务器启动 ");
       NioServer server = new NioServer();
       server.listen(); //服务器开始监听端口，提供服务
   }

 
}

//客户端

package com.netease.nio;

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.InetSocketAddress;
import java.nio.CharBuffer;

import java.util.Scanner;

//nio 连接服务器
public class NioClient {

 
 public static void main(String[] args) throws IOException{
  
  String host = "127.0.0.1";
  int port = 512;
  
  Socket socket = new Socket(host,port);
  System.out.println("客户端起动");
  
  while(true){
   
   Scanner in = new Scanner(System.in);
   
   String message = in.nextLine();
   
   PrintWriter pw = new PrintWriter(socket.getOutputStream());
   
   pw.write(message);
   
   pw.flush();
   
   InputStreamReader reader = new InputStreamReader(socket.getInputStream());
   
   CharBuffer buf = CharBuffer.allocate(100);
   reader.read(buf);
   
   buf.flip();
   System.out.println("client:"+String.valueOf(buf));
   
   if(message.equals("quit")){
    
    break;
   }
   buf.clear();
   
   
  }
  
  socket.close();
  
 }
}

以上有什么问题，请指出，谢谢!