NIO-编程实战(一）

一、NIO总共分为三大部分：

1、缓冲区：Buffer是所有的xxxBuffer类的父类，MappedByyteBuffer：映射的类，主要是映射系统中的内存。

缓存区分为两种，一种是直接缓冲区，另一种是非缓冲区。

缓存区有Buffer,ByteBuffer,LongBuffer,IntegerBuffer,FloatBuffer,DoubleBuffer。

非直接缓冲区主要存放在jvm缓存区中来拷贝

直接缓冲区--存在物理内存中。

2、选择器：poll模型是windows里面的，epoll是linux系统中的,select,kqueue是操作系统的。整个selector在构建的时候不是由java来构建的，而是由java语言调用c语言来是实现的，它的底层是系统的底层。

3、通道：NIO最关联的就是通道，而通道要和选择器的事件进行绑定。

二、关于Buffer的代码如下：

1、创建ByteBuffer的对象，这里不是new的，而是创建该对象时要分配内存：allocate代表分配一块内存空间，将ByteBuffer的对象指向内存空间里面去。单位是字节，代码如下：

1. ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
   
2. System.out.println("position:"+byteBuffer.position());
   
3. System.out.println("limit:"+byteBuffer.limit());
   
4. System.out.println("capacity:"+byteBuffer.capacity());
   
5. System.out.println("往bytebuffer里存放数据。。。");
   
6. byteBuffer.put("A23abc一二三".getBytes());
   
7. System.out.println("position:"+byteBuffer.position());
   
8. System.out.println("limit:"+byteBuffer.limit());
   
9. System.out.println("capacity:"+byteBuffer.capacity());
   

运行的结果如下：往缓存区里放数据只会导致position的大小会变，其他的不会变。

2、如何从缓存区中读数据

1. System.out.println("往bytebuffer里读取数据。。。");
   
2. byteBuffer.flip();// 开启读取模式
   
3. System.out.println("position:"+byteBuffer.position());
   
4. System.out.println("limit:"+byteBuffer.limit());
   
5. System.out.println("capacity:"+byteBuffer.capacity());
   
6. //应用程序的一个缓存
   
7. byte[] bytes = new byte[byteBuffer.limit()];
   
8. //读取到缓存区中
   
9. byteBuffer.get(bytes);
   
10. System.out.println(newString(bytes, 0, bytes.length));
    

运行的结果如下：这时position置为0，limit的值和上次的position的值一样，把position的值赋给limit。一旦缓冲区的容量定下来以后，那么缓冲区的容量是不可变的。读的数据就是从0的位置到15的位置。

3、rewind方法：

1. System.out.println("往bytebuffer里重复读取数据。。。" );
   
2. byteBuffer.rewind();

   
3. System.out.println("position:"+byteBuffer.position());
   
4. System.out.println("limit:"+byteBuffer.limit());
   
5. System.out.println("capacity:"+byteBuffer.capacity());
   
6. byte[] bytes2 = new byte[byteBuffer.limit()];
   
7. byteBuffer.get(bytes2);
   
8. System.out.println(newString(bytes2, 0, bytes.length));
   

运行的结果如下：rewind：重复读取，不加这个方法会报错，因为limit后面不能再读取数据了。这个方法的意思是重复读的意思。limit不会变，但是position会变为0。

4、clear方法：调用这个方法的意思又可以再进行写的操作。

1. System.out.println("清空缓存区。。。");
   
2. byteBuffer.clear();//// 值不清空 下标清空
   
3. System.out.println("position:"+byteBuffer.position());
   
4. System.out.println("limit:"+byteBuffer.limit());
   
5. System.out.println("capacity:"+byteBuffer.capacity());
   
6. System.out.println((char) byteBuffer.get());
   

运行的结果如下：

小结总结：上面的缓冲区是普通的缓冲区，直接放到了jvm当中的。而缓存区是不停的再读数据，会覆盖。

5、分散读取聚集写入

可以分开去读，写是在一起写。

注意：在分配指定大小的缓冲区的时候，如果是直接缓冲区的话是直接写在内存中，不是写在jvm的工作缓存区的。如果用分散读取聚集写入的话，不能用直接的缓冲区的方式，应该用普通的方式来分配。

代码如下：

1.        // 随机访问
   
2.        RandomAccessFile raf = new RandomAccessFile("d:/abc.txt", "rw");
   
3.        // 获取通信
   
4.        FileChannel channel = raf.getChannel();
   
5.        // 分配指定大小指定缓冲区      
   
6. 
   
7.        //这两个缓冲区是连通的
   
8.        //buf2相当于是备用缓冲区
   
9.        ByteBuffer buf1 = ByteBuffer.allocate(6);
   
10.        ByteBuffer buf2 = ByteBuffer.allocate(10);
    
11.        // 分散读取
    
12.        ByteBuffer[] bufs = {buf1, buf2};
    
13.        channel.read(bufs);
    
14.        for (ByteBuffer buf : bufs) {
    
15.            // 切换成读模式
    
16.            buf.flip();
    
17.        }
    
18.        System.out.println(new String(bufs[0].array(), 0, bufs[0].limit()));
    
19.        System.out.println("-----------------------------");
    
20.        System.out.println(new String(bufs[1].array(), 0, bufs[1].limit()));
    
21.        System.out.println("-----------重复读取-------------");
    
22.        RandomAccessFile raf2 = new RandomAccessFile("d:/abc.txt", "rw");
    
23.        // 获取通道
    
24.        FileChannel channel2 = raf2.getChannel();
    
25.        channel2.write(bufs);
    
26.        raf2.close();
    
27.        raf.close();
    

运行的结果如下：

关于管道的代码如下：

1. package com.gerry.nio.demo.nio.channel;
   
2. 
   
3. import java.io.*;  
   
4. import java.nio.*;  
   
5. import java.nio.channels.*;
   
6. 
   
7. /**
   
8. * 通道和流绑定
   
9. * 普通的缓冲区是基于jvm的，直接缓冲区是基于内存的。
   
10. */
    
11. public class FileInputProgram {  
    
12.    static public void main( String args[] ) throws Exception {  
    
13.        FileInputStream fin = new FileInputStream("d:/abc.txt");
    
14. 
    
15.        // 在jdk1.5之后可以通过文件的流对象获取通道
    
16.        FileChannel fc = fin.getChannel();  
    
17. 
    
18.        // 创建缓冲区
    
19.        ByteBuffer buffer = ByteBuffer.allocate(1024);  
    
20. 
    
21.        // 读取数据到缓冲区
    
22.        fc.read(buffer);  
    
23. 
    
24.        buffer.flip();  
    
25.        //判断是否已经读完
    
26.        while (buffer.remaining() > 0) {  
    
27.            byte b = buffer.get();  
    
28.            System.out.print(((char)b));  
    
29.        }  
    
30. 
    
31.        fin.close();
    
32.    }  
    
33. }
    

运行的结果如下：

1. package com.gerry.nio.demo.nio.channel;
   
2. 
   
3. import java.io.*;  
   
4. import java.nio.*;  
   
5. import java.nio.channels.*;  
   
6. 
   
7. public class FileOutputProgram {  
   
8.    static private final byte message[] = {'a','c','d','e'};
   
9. 
   
10.    static public void main( String args[] ) throws Exception {  
    
11.        FileOutputStream fout = new FileOutputStream( "e:/abc.txt");
    
12. 
    
13.        FileChannel fc = fout.getChannel();  
    
14. 
    
15.        ByteBuffer buffer = ByteBuffer.allocate( 1024 );  
    
16. 
    
17.        for (int i=0; i<message.length; ++i) {
    
18.            buffer.put(message[i]);
    
19.        }
    
20.        buffer.flip();
    
21.        fc.write( buffer );
    
22. 
    
23.        fout.flush();
    
24.        fout.close();  
    
25.    }  
    
26. }
    

运行的结果如下:

总结：上面的是关于nio的缓冲区和通道中常用的方法做了一个总结，明天继续写关于nio的selector的网络通信的应用以及netty的入门。