NIO2实例

/**
 *
 */
package zngz.server;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.io.Reader;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousChannelGroup;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.nio.channels.SocketChannel;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author Administrator
 *
 */
public class ZngzServer {
 
 private AsynchronousServerSocketChannel ssc = null;
 AcceptCompletionHandler acceptHandler = new AcceptCompletionHandler();

 public ZngzServer() {
  try {
   init();
   ssc.accept(ssc, acceptHandler);
   start();
  } catch (IOException e) {
   e.printStackTrace();
  }
 }

 public void init() throws IOException {
  final ExecutorService executor = Executors.newCachedThreadPool();
  final AsynchronousChannelGroup channelgroup = AsynchronousChannelGroup.withCachedThreadPool(executor, 8);
  ssc = AsynchronousServerSocketChannel.open(channelgroup);
  ssc.bind(new InetSocketAddress(9996));
 }

 public void start() {
  final ScheduledThreadPoolExecutor scheduleds = new ScheduledThreadPoolExecutor(1);
  scheduleds.scheduleAtFixedRate(new workThread(), 1000, 1000,TimeUnit.MILLISECONDS);
  //workThread test = new workThread();
  //Thread t1= new Thread(test);
  //t1.start();
 }

 public static void main(String[] args) {
  new ZngzServer();
 }

 private class AcceptCompletionHandler implements CompletionHandler<AsynchronousSocketChannel, AsynchronousServerSocketChannel> {
  @Override
  public void completed(final AsynchronousSocketChannel clientSocket,final AsynchronousServerSocketChannel ssc) {
    if(clientSocket.isOpen()){
     System.out.println("ClientSocket is Open");
    }    
    ssc.accept(ssc, this);
    ByteBuffer readbuffer = ByteBuffer.allocate(40584);  
    clientSocket.read(readbuffer, readbuffer,new ReaderCompletionHandler(clientSocket)); 
    // 向socket管道中发送数据
    // fileChannel.transferTo(position, count, target);
    // 从socket管道中取数据
    // fileChannel.transferFrom(arg0, arg1, arg2);
  }
  @Override
  public void failed(final Throwable arg0, final AsynchronousServerSocketChannel ssc) {
   if(ssc.isOpen()){
    try {
     ssc.close();
    } catch (IOException e) {
     e.printStackTrace();
    }
   }
  }
 }

 private class ReaderCompletionHandler implements CompletionHandler<Integer, ByteBuffer> { 
  AsynchronousSocketChannel clientSocket =null;

  public ReaderCompletionHandler(
    final AsynchronousSocketChannel clientSocket) {
   this.clientSocket = clientSocket;
  }

  @Override
  public void completed(final Integer result, final ByteBuffer readbuffers) {
   // 如果读取完毕
   if (result == -1) {
    try {
     clientSocket.close();
    } catch (IOException e) {
     e.printStackTrace();
    }
   }
   // 没有读取完毕
   else if (result > 0) {
    readbuffers.flip();
    clientSocket.write(readbuffers, readbuffers,new WriteCompletedHandler());
    //readbuffers.flip();
    readbuffers.clear();
    clientSocket.read(readbuffers, readbuffers, this);
   }
  }
  @Override
  public void failed(final Throwable exc,  final ByteBuffer readbuffer) {
   readbuffer.flip();
   readbuffer.clear();
  }
 }

 private class WriteCompletedHandler implements CompletionHandler<Integer, ByteBuffer> {  
  @Override
  public void completed(final Integer result,final ByteBuffer bytebuffers) {
   System.out.println("WriteCompletedHandler......." + bytebuffers);
   final File writeFile = new File("D:"+File.separator+"file"+File.separator+"zzc_write.txt");
   System.out.println("WriteCompletedHandler......,write File" +writeFile.getName());
            RandomAccessFile raf = null;
    try {
     raf = new RandomAccessFile(writeFile, "rwd");
     raf.seek(raf.length());
     bytebuffers.flip();
     raf.write(bytebuffers.array(), bytebuffers.position(),bytebuffers.remaining());
     System.out.println("write Buffer="+bytebuffers.array().toString());
     //AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(Paths.get(writeFile.getPath()), StandardOpenOption.READ,StandardOpenOption.WRITE,StandardOpenOption.CREATE);
     //fileChannel.write(bytebuffer, bytebuffer.position());
    } catch (Exception ex) {
     ex.printStackTrace();
    } 
  }
  @Override
  public void failed(final Throwable arg0,final ByteBuffer bytebuffer) {
   if (null != bytebuffer) {
    bytebuffer.flip();
    bytebuffer.clear();
   }
  }
 }

 class workThread implements Runnable {
  SocketChannel clientChannel = null;  
  public workThread() {
   try {
    clientChannel = SocketChannel.open();
    clientChannel.connect(new InetSocketAddress(9996));
   } catch (IOException e) {
    e.printStackTrace();
   }
  }
  @Override
  public void run() {
   System.out.println("Thread Start.......");
   try {
    final File file = new File("D:/file/zzc.txt");
    System.out.println("AcceptCompletionHandler...."+ file.getName());
    final Reader r = new BufferedReader(new FileReader(file));
    int temp = 0;
    String str = "";
    while ((temp = r.read()) != -1) {
     str += (char) temp;
    }
    System.out.println("File readSource =" + str);
    final ByteBuffer readbuffer = ByteBuffer.wrap(str.getBytes());
                                                readbuffer.flip();
    clientChannel.write(readbuffer); 
   } catch (IOException e) {
    e.printStackTrace();
   }
   System.out.println("Thread Stop ........");
  }
 }
}