Java之NIO

想要学习Java的Socket通信，首先要学习Java的IO和NIO基础，这方面可以阅读《Java NIO 系列教程》。  

下面展示自己代码熟悉Java的NIO编程的笔记。

1、缓冲区（Buffer）

/*
 * 一、缓冲区（Buffer）：在Java 中负责数据的存取。缓冲区就是数组。用于存储不同数据类型的数据
 *       
 *       根据数据类型不同（boolean除外），提供了相应类型的缓冲区
 *         ByteBuffer 那么实际上最常用的，因为网络传输的字节就是Byte
 *     　 CharBuffer
 *         ShortBuffer
 *         IntBuffer
 *         LongBuffer
 *      　FloatBuffer
 *      　DoubleBuffer
 *     
 *    上述缓冲区的管理方式几乎一致，通过allocate()获取缓冲区
 *    
 *  二、缓冲区存储数据的两个核心方法
 *      put()  : 存入数据到缓冲区中
 *      get()  : 获取缓冲区中的数据
 *      
 *  三、缓冲区中的四个核心属性
 *      capacity : 容量，表示缓冲区中最大存储数据的容量
 *      limit    : 界限，标识缓冲区中可以操作数据的大小（limit后面的数据不能进行读写的）
 *      position : 位置，标识缓冲区中正在操作数据的位置
 *      
 *      mark     : 标记，标识记录当前position的位置，可以通过reset()恢复到mark的位置
 *  
 *      0 <= mark <= position <= limit <= capacity
 *  四、直接缓冲区和非直接缓冲区
 *      非直接缓冲区： 通过allocate()方法分配缓冲区，将缓冲区建立在JVM的内存中。
 *      直接缓冲区 ：  通过allockateDirect()方法分配直接缓存区，将缓冲区建立在物理内存中。可以提高效率。
 *                  如果有数据需要一直在内存空间中重复用，并且数据量不大的情况下，就用allockateDirect()这种方法。
 *                  毕竟内存空间是有限的。
 */

相关代码：

package com.demo.test;

import java.nio.ByteBuffer;

public class TestBuffer {
    
    public void test3(){
        // 分配直接缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);
        System.out.println(buf.isDirect());// 判断这个缓冲区是直接还是非直接的。
    }
    
    public void test2(){
        String str = "abcde";
        
        // 1、分配一个指定大小的缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);
        
        // 2、利用put()存入数据到缓冲区中
        System.out.println("往buf插入所有字符串的bytes是："+str.getBytes());
        buf.put(str.getBytes());
        
        buf.flip();// 将插入模式转为查询模式，就是查询position位置会回到0
        
        System.out.println("创建和缓冲区等长度的字节数组，用来从缓冲区取出字节并存储以待读取操作");
        byte[] dst  = new byte[buf.limit()];
        System.out.println("从缓冲区中去除0开始的2位字节数据放进数组dst中");
        buf.get(dst, 0, 2);
        System.out.println("打印dst字节数组"+new String(dst, 0, 2));
        System.out.println("现在缓冲区的操作起始位置："+buf.position());
        
        // mark(); 标记
        System.out.println("标记");
        buf.mark();
        buf.get(dst, 2, 2);// 取出从2开始的2位字节数据放进
        System.out.println("打印dst字节数组"+new String(dst, 2, 2));
        System.out.println("现在缓冲区的操作起始位置："+buf.position());
        
        // reset(); 回复到mark的位置
        buf.reset();
        System.out.println("reset重置之后，缓冲区的操作起始位置回到："+buf.position());
        
        // 判断缓冲区中是否还有剩余的数据
        if(buf.hasRemaining()){
            // 获取缓冲区还可以操作的数量
            System.out.println("缓冲区还有可以操作的数量"+buf.remaining());
        }
    }
    
    public void test(){
        String str = "abcde";
        
        // 1、分配一个指定大小的缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);
        System.out.println("--调用allocate之后--");
        System.out.println(buf.capacity());
        System.out.println(buf.limit());
        System.out.println("position:"+buf.position());
        
        // 2、利用put()存入数据到缓冲区中
        System.out.println("字符串的bytes是："+str.getBytes());
        buf.put(str.getBytes());

        System.out.println("--调用put之后--");
        System.out.println(buf.capacity());
        System.out.println(buf.limit());
        System.out.println("position:"+buf.position());
        
        // 3、前面是存入数据的模式，存入5个字节之后，position的位置从原本0现在到5了
        buf.flip();
        //   现在要将存储数据模式改成读取模式，position的位置会变回为0
        
        System.out.println("--调用flip切换模式之后--");
        System.out.println(buf.capacity());
        System.out.println(buf.limit());
        System.out.println("position:"+buf.position());
        
        // 4、利用get()读取缓冲区中的数据
        byte[] dst = new byte[buf.limit()];// 创建和缓冲区一样大的字节数据
        buf.get(dst);
        System.out.println(new String(dst,0,dst.length));
        
        System.out.println("--调用get()切换模式之后--");
        System.out.println(buf.capacity());
        System.out.println(buf.limit());
        System.out.println("position:"+buf.position());// 打印输出的结果会发现position变回5了
        
        // 5、可重复读取
        buf.rewind();
        
        System.out.println("--调用rewind()切换模式之后--");
        System.out.println(buf.capacity());
        System.out.println(buf.limit());
        System.out.println("position:"+buf.position());
        
        // 6、清空缓冲区。但是缓冲区中的数据依然存在，但是出于“被遗忘”状态
        buf.clear();
        
        System.out.println("--调用clear()切换模式之后--");
        System.out.println(buf.capacity());
        System.out.println(buf.limit());
        System.out.println("position:"+buf.position());
        
        // 看看缓冲区有没有数据
        System.out.println((char)(buf.get()+1));
        
    }
}

 2、通道（Channel）

由java.nio.channels包定义的。Channel表示IO源与目标打开的连接。Channel类似于传统的“流”。只不过Channel本身不能直接访问数据，Channel只能与Buffer进行交互。

先完成文件的复制：

/*
 * 一、通道（Channel）：用于源节点与目标节点的连接。在Java NIO中负责缓冲区中数据的传输。
 *                      Channel本身不存储数据，因此需要配合缓冲区进行传输
 * 
 * 二、通道的主要实现类
 *         java.nio.channels.Channel接口
 *             |--FileChannel
 *             |--SocketChannel
 *          |--ServerSocketChannel
 *            |--DatagramChannel
 *    
 * 三、获取通道
 *         1、Java针对支持通道的类提供了getChannel()方法
 *             本地：
 *                 FileInputStream/FileOutputStream
 *                 RandomAccessFile随机存储文件流
 *             网络：
 *                 Socket
 *                 ServerSocket
 *                 DatagramSocket
 * 
 *         2、在JDK1.7中的NIO.2针对各个通道提供了一个静态的方法
 *         3、在JDK1.7中的NIO.2的Files工具类的newByteChannel()
 *             
 * 四、通道之间的数据传输
 *         transferFrom()
 *         transferTo()
 * 
 * 五、分散（Scatter）和聚集（Gather）
 *         分散读取（Scattering Reads）：将通道中的数据分散到多个缓冲区中
 *         聚集写入（Gathering Writes）：将多个缓冲区中的数据聚集到通道中
 */
public class TestChannel {
    // 1、利用通道完成文件的复制（非直接缓冲区）
    public void    test(){
        long start = System.currentTimeMillis();
        
        FileInputStream fis = null;
        FileOutputStream fos = null;
        // 获取通道
        FileChannel inChannel = null;
        FileChannel outChannel = null;
        try {
            fis = new FileInputStream("1.png");
            fos = new FileOutputStream("2.png");
            inChannel = fis.getChannel();
            outChannel = fos.getChannel();
            // 分批额指定大小的缓冲区
            ByteBuffer buf = ByteBuffer.allocate(1024);
            
            // 将通道中的数据存入缓冲区中
            while(inChannel.read(buf)!=-1){
                buf.flip();//切换读取数据的模式
                // 将缓冲区中的数据写入通道中
                outChannel.write(buf);
                buf.clear();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if(outChannel != null){
                try {
                    outChannel.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(inChannel != null){
                try {
                    inChannel.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("1、耗费的时间："+(end - start));
        
    }
    
    // 2、利用通道完成文件的复制（直接缓冲区，内存映射文件的方式）
    public void test2(){
        
        long start = System.currentTimeMillis();
        
        FileChannel inChannel = null;
        // CREATE_NEW 存在就报错
        FileChannel outChannel = null;
        try {
            inChannel = FileChannel.open(Paths.get("1.png"), StandardOpenOption.READ); 
            outChannel = FileChannel.open(Paths.get("3.png"), StandardOpenOption.WRITE,StandardOpenOption.READ,StandardOpenOption.CREATE);
            
            // 物理内存映射文件
            MappedByteBuffer inMapByteBuffer = inChannel.map(MapMode.READ_ONLY,0,inChannel.size());
            MappedByteBuffer outMapByteBuffer = outChannel.map(MapMode.READ_WRITE,0,inChannel.size());
            
            // 直接对缓冲区进行数据的读写操作
            byte[] dst = new byte[inMapByteBuffer.limit()];
            inMapByteBuffer.get(dst);
            outMapByteBuffer.put(dst);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally{
            if(inChannel!=null){                
                try {
                    inChannel.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(outChannel!=null){                
                try {
                    outChannel.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        
        long end = System.currentTimeMillis();
        System.out.println("2、耗费的时间："+(end - start));
        
    }
    
    // 通道之间的数据传输
    public void test3(){
        FileChannel inChannel = null;
        // CREATE_NEW 存在就报错
        FileChannel outChannel = null;
        
        try {
            inChannel = FileChannel.open(Paths.get("1.png"), StandardOpenOption.READ); 
            outChannel = FileChannel.open(Paths.get("4.png"), StandardOpenOption.WRITE,StandardOpenOption.READ,StandardOpenOption.CREATE);
            
//        inChannel.transferTo(0, inChannel.size(), outChannel);
            outChannel.transferFrom(inChannel, 0, inChannel.size());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally{
            if(inChannel!=null){                
                try {
                    inChannel.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(outChannel!=null){                
                try {
                    outChannel.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        
    }
    
    // 分散（Scatter）和聚集（Gather）
    public void test4(){
        // 文件路径： webapp/index.html
        try {
            RandomAccessFile raFile = new RandomAccessFile("webapp/index.html", "rw");
            FileChannel fileChannel = raFile.getChannel();
            
            ByteBuffer tBuffer = ByteBuffer.allocate(24);
            ByteBuffer tBuffer2 = ByteBuffer.allocate(80);
            
            // 分散读取到两个字节缓冲区数组中
            ByteBuffer[] bBuffers = {tBuffer,tBuffer2};
            fileChannel.read(bBuffers);
            // 打印之前需要修改一下缓冲区的写入模式为读取模式
            for (ByteBuffer byteBuffer : bBuffers) {
                byteBuffer.flip();
            }
            System.out.println(new String(bBuffers[0].array(),0,bBuffers[0].limit()));
            System.out.println("===========");
            System.out.println(new String(bBuffers[1].array(),0,bBuffers[1].limit()));
            
            
            // 聚集写入到通道中
            RandomAccessFile randomAccFile2 = new RandomAccessFile("test.html", "rw");
            FileChannel fileChannel2 = randomAccFile2.getChannel();
            
            fileChannel2.write(bBuffers);
            
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

>>1、字节缓冲区要么是直接的,要么是非直接的。如果为直接字节缓冲区,则Java虚拟机会尽最大努力直接在 此缓冲区上执行本机 I/O 操作。也就是说,在每次调用基础操作系统的一个本机 I/O 操作之前(或之后), 虚拟机都会尽量避免将缓冲区的内容复制到中间缓冲区中(或从中间缓冲区中复制内容)。

>>2、直接字节缓冲区可以通过调用此类的allocateDirect()工厂方法来创建。此方法返回的缓冲区进行分配和取消 分配所需成本通常高于非直接缓冲区。直接缓冲区的内容可以驻留在常规的垃圾回收堆之外,因此,它们对 应用程序的内存需求量造成的影响可能并不明显。所以,建议将直接缓冲区主要分配给那些易受基础系统的 本机 I/O 操作影响的大型、持久的缓冲区。一般情况下,最好仅在直接缓冲区能在程序性能方面带来明显好 处时分配它们。

>>3、直接字节缓冲区还可以通过FileChannel的map()方法将文件区域直接映射到内存中来创建。该方法返回 MappedByteBuffer 。Java 平台的实现有助于通过 JNI 从本机代码创建直接字节缓冲区。如果以上这些缓冲区 中的某个缓冲区实例指的是不可访问的内存区域,则试图访问该区域不会更改该缓冲区的内容,并且将会在 访问期间或稍后的某个时间导致抛出不确定的异常。

>>4、字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其isDirect()方法来确定。提供此方法是为了能够在 性能关键型代码中执行显式缓冲区管理。

3、字符集（Charset）

　　
　　　　编码：字符串 --> 字节数组 将字符序列转为字节序列的过程叫编码
　　　　解码：字节数组 --> 字符串 将字节序列转为字符序列的过程叫解码

代码：

// 编码解码
    public void test6(){
        // 获取字符集合中的GBK字符集
        Charset cs1 = Charset.forName("GBK");
        
        // 获取编码器
        CharsetEncoder ce = cs1.newEncoder();
        // 获取解码器
        CharsetDecoder cd = cs1.newDecoder();
        
        // 创建字符串缓冲区
        CharBuffer cBuf = CharBuffer.allocate(1024);
        cBuf.put("何杨很帅！");
        cBuf.flip();
        
        try {
            // 开始编码
            ByteBuffer bBuf = ce.encode(cBuf);
            System.out.println("用GBK编码之后：");
            for (int i = 0; i < bBuf.limit(); i++) {
                System.out.println(bBuf.get());
            }
            
            // 然后开始解码回去
            bBuf.flip();
            CharBuffer cBuf2 = cd.decode(bBuf);
            System.out.println("用GBK解码之后：");
            System.out.println(cBuf2.toString());
            
            System.out.println("------------");
            
            System.out.println("获取UTF-8字符集");
            Charset cs2 = Charset.forName("UTF-8");
            bBuf.flip();
            CharBuffer cBuf3 = cs2.decode(bBuf);// 也可以直接用字符集进行解码
            
            System.out.println("用字符集进行解码之后："+cBuf3.toString());
            
            
        } catch (CharacterCodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }

 4、使用NIO完成网络通信

/*
 * 一、使用NIO完成网络通信的三个核心：
 *         1、通道（Channel）：负责连接
 *             java.nio.channels.Channel 接口：
 *                 |--SelectableChannel
 *                 |--ServerSocketChannel
 *                 |--DatagramChannel
 * 
 *                 |--Pipe.SinkChannel
 *                 |--Pipe.SourceChannel
 * 
 *         2、缓冲区（Buffer）：负责数据的存取
 *     
 *         3、选择器（Selector）：是SelectableChannel的多路复合器。
 *                             用于监控SelectableChannel的IO状况
 */

4-1、下面先实现阻塞式通道

public class TestBlockingNIO {
    // 客户端
    @Test
    public void client(){
        try {
            System.out.println("客户端开始创建。");
            // 1、获取Socket通道
            SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
            // 2、分配指定大小的缓冲区
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            // 3、读取本地文件，并发到服务端
            // 先需要文件通道获取本地文件
            FileChannel fileChannel = FileChannel.open(Paths.get("2.png"), StandardOpenOption.READ);
            System.out.println("开始发送图片数据");
            while (fileChannel.read(byteBuffer) != -1) {
                byteBuffer.flip();
                socketChannel.write(byteBuffer);
                byteBuffer.clear();
                System.out.println("发送一次");
            }
            
            System.out.println("--开始停止输出--");
            // 4、客户端发送完数据之后要停止通道的输出
            socketChannel.shutdownOutput();
            // --发送完了图片数据之后才会进行下面一步，其实这里也是单线程阻塞的。--
            System.out.println("--发送完了图片数据之后才会进行下面一步，其实这里也是单线程阻塞的。--");
            
            // 5、接收服务端的反馈
            int len = 0;
            while((len = socketChannel.read(byteBuffer))!=-1){
                byteBuffer.flip();
                System.out.println(new String(byteBuffer.array(), 0, len));
                byteBuffer.clear();
                
            }
            socketChannel.shutdownInput();// 停止客户端的接收输入
            
            // 6、关闭通道
            fileChannel.close();
            socketChannel.close();
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    // 服务端
    @Test
    public void server(){
        try {
            System.out.println("服务器开始启动。。。");
            // 1、获取服务端SocketChannel
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            // 2、绑定连接端口号
            serverSocketChannel.bind(new InetSocketAddress(9898));
            // 3、获取客户端连接的通道
            SocketChannel sChannel = serverSocketChannel.accept();
            
            // 4、创建一个指定大小的缓冲区
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            
            // 5、接收的数据通道也要文件通道 StandardOpenOption.CREATE表示有文件就覆盖，没文件就创建
            FileChannel fileChannel = FileChannel.open(Paths.get("4.png"), StandardOpenOption.WRITE,StandardOpenOption.CREATE);
            
            System.out.println("开始接收图片数据");
            while (sChannel.read(byteBuffer)!=-1) {
                byteBuffer.flip();
                fileChannel.write(byteBuffer);
                byteBuffer.clear();
                System.out.println("接收一次");
            }
            
            System.out.println("接收完毕客户端发来的数据，开始反馈数据给客户端");
            
            // 6、发送反馈给客户端
            byteBuffer.put("服务器接收数据成功".getBytes());
            byteBuffer.flip();
            sChannel.write(byteBuffer);
            
            // 7、关闭通道
            fileChannel.close();
            sChannel.close();
            serverSocketChannel.close();
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

 4-2、然后是实现非阻塞通道

package com.demo.test;

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.Scanner;

import org.junit.Test;

public class TestNonBlockingNIO {
    
    @Test
    public void startClient(){
        SocketChannel sChannel = null;
        // 获取通道
        try {
            
            System.out.println("启动客户端");
            
            sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",9898));
            
            // 切换非阻塞模式
            sChannel.configureBlocking(false);
            
            ByteBuffer buf = ByteBuffer.allocate(1024);
            
            System.out.println("开始通过输入框输入给服务器端发送数据");
            Scanner scan = new Scanner(System.in);
            while (scan.hasNext()) {
                String str = scan.next();
                buf.put(str.getBytes());
                buf.flip();
                sChannel.write(buf);
                buf.clear();                
            }
            
            scan.close();
            
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (sChannel != null) {
                try {
                    sChannel.close();
                    System.out.println("关闭客户端Socket通道");
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
    
    
    // 启动非阻塞的NIO的Socket服务器程序
    @Test
    public void startServer(){
        ServerSocketChannel serverSocketChannel = null;
        try {
            System.out.println("启动服务器Socket。");
            
            // --ServerSocketChannel--
            // 直接用 服务器Socket通道类 获取 服务器Socket通道
            serverSocketChannel = ServerSocketChannel.open();
            // 设置为非阻塞模式
            serverSocketChannel.configureBlocking(false);
            // 用 服务器Socket通道 来绑定端口号,端口是需要new的对象
            serverSocketChannel.bind(new InetSocketAddress(9898));
            
            // --Selector--
            // 获取选择器，选择器也是通过类似类方法的open方法创建
            Selector sel = Selector.open();
            
            // --注册--
            // 服务器Socket通道注册选择器，指定的接收事件
            serverSocketChannel.register(sel, SelectionKey.OP_ACCEPT);
            
            // --开始处理接收到的--
            // 轮询式的获取选择器上已经准备就绪的事件
            while (sel.select() > 0) {
                // 使用迭代器获取所有的 "已经接收准备就绪的" 选择键
                Iterator<SelectionKey> it = sel.selectedKeys().iterator();
                
                while (it.hasNext()) {
                    SelectionKey selKey = it.next();
                    // 如果是接收就绪
                    if (selKey.isAcceptable()) {
                        System.out.println("接收就绪，接收客户端的Socket通道。");
                        // 通过服务器Socket通道获取客户端的连接的Socket通道
                        SocketChannel socketChannel = serverSocketChannel.accept();
                        // 设置这个客户端发过来的通道为非阻塞模式
                        socketChannel.configureBlocking(false);
                        // 再将这个客户端发过来的通道注册选择器,因为已经准备好了，那就注册设置为读就绪状态
                        socketChannel.register(sel, SelectionKey.OP_READ);
                        
                        // 如果是读就绪状态
                    }else if (selKey.isReadable()) {
//                        System.out.println("读就绪，开始读取客户端的Socket通道里的数据。");
                        // 通过选择器获取这个通道
                        SocketChannel socketChannel = (SocketChannel) selKey.channel();
                        
                        // 读取数据
                        // 创建一个ByteBuffer
                        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                        
                        // 从通道中读取数据到字节缓冲
                        int len;
                        while ((len = socketChannel.read(byteBuffer))>0) {
                            byteBuffer.flip();
                            System.out.println("开始读取的数据是：");
                            System.out.println(new String(byteBuffer.array(),0,len));
                            byteBuffer.clear();
                        }
                        
                    }
                    // 记得用完it之后要取消掉
                    it.remove();
                }
            }
            
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                if (serverSocketChannel != null) {
                    serverSocketChannel.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    
    
}