Java NIO系列使用示例

package com.nio.test;

import java.io.IOException;
import java.io.RandomAccessFile;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.DatagramChannel;
import java.nio.channels.FileChannel;
import java.nio.channels.Pipe;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CoderResult;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.Paths;

public class ChannelTest {
    public static void main(String[] args) throws Exception {
        new ChannelTest().filewrite();
        new ChannelTest().byteBufferUtf8();
        new ChannelTest().fileread();
        new ChannelTest().clientsocket();
        new ChannelTest().serverSocket();
        new ChannelTest().serverDatagram();
        new ChannelTest().clientDatagram();
        new ChannelTest().pipe();
        new ChannelTest().NIOPath();
    }

    private void fileread() {
        RandomAccessFile aFile;
        Charset charset = Charset.forName("UTF-8");
        CharsetDecoder decoder = charset.newDecoder();
        try {
            // 在使用FileChannel之前，必须先打开它。但是，我们无法直接打开一个FileChannel，
            // 需要通过使用一个InputStream、OutputStream或RandomAccessFile来获取一个FileChannel实例
            aFile = new RandomAccessFile("src/com/nio/test/nio-data.txt", "rw");

            FileChannel inChannel = aFile.getChannel();
            // 首先，分配一个Buffer。从FileChannel中读取的数据将被读到Buffer中。
            // create buffer with capacity of 48 byte
            ByteBuffer byteBuffer = ByteBuffer.allocate(48);// read into buffer.
            CharBuffer charBuffer = CharBuffer.allocate(48);

            // 调用多个read()方法之一 从FileChannel中读取数据。
            int bytesRead = inChannel.read(byteBuffer);

            char[] tmp = null; // 临时存放转码后的字符
            byte[] remainByte = null;// 存放decode操作后未处理完的字节。decode仅仅转码尽可能多的字节，此次转码不了的字节需要缓存，下次再转
            int leftNum = 0; // 未转码的字节数
            
            while (bytesRead != -1) {

                //System.out.println("Read " + bytesRead);
                byteBuffer.flip(); // make buffer ready for read
                decoder.decode(byteBuffer, charBuffer, false);
                
                charBuffer.flip();

                remainByte = null;
                leftNum = byteBuffer.limit() - byteBuffer.position();
                if (leftNum > 0) { // 记录未转换完的字节
                    remainByte = new byte[leftNum];
                    byteBuffer.get(remainByte, 0, leftNum);
                }
                
                // 输出已转换的字符
                tmp = new char[charBuffer.length()];
                while (charBuffer.hasRemaining()) {
                    charBuffer.get(tmp);
                    System.out.print(new String(tmp));
                }
                
                byteBuffer.clear(); // make buffer ready for writing
                charBuffer.clear();

                if (remainByte != null) {
                    byteBuffer.put(remainByte); // 将未转换完的字节写入bBuf，与下次读取的byte一起转换
                }
                
                bytesRead = inChannel.read(byteBuffer);
            }
            
            aFile.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    private void filewrite() throws Exception {
        RandomAccessFile accessFile = new RandomAccessFile("src/com/nio/test/nio-data11.txt", "rw");
        FileChannel fileChannel = accessFile.getChannel();
        String newDate = "New String to write to file" + System.currentTimeMillis();
        ByteBuffer buffer = ByteBuffer.allocate(48);
        buffer.clear();
        buffer.put(newDate.getBytes());
        buffer.flip();
        while (buffer.hasRemaining()) {
            fileChannel.write(buffer);
        }

        /**
         * FileChannel的truncate方法
         * 可以使用FileChannel.truncate()方法截取一个文件。截取文件时，文件将中指定长度后面的部分将被删除。如：
         * 
         * 1 channel.truncate(1024); 这个例子截取文件的前1024个字节。
         */
        //fileChannel.truncate(12);
        /**
         * FileChannel.force()方法将通道里尚未写入磁盘的数据制写到磁盘上。出于性能方面的考虑，操作系统会将数据缓存在内存中，
         * 所以无法保证写入到FileChannel里的数据一定会即时写到磁盘上。要保证这一点，需要调用force()方法。
         */
        fileChannel.force(true);// force()方法有一个boolean类型的参数，指明是否同时将文件元数据（权限信息等）写到磁盘上。

        fileChannel.close();
    }

    private void clientsocket() throws Exception {
        SocketChannel socketChannel = SocketChannel.open();
        //可以设置 SocketChannel 为非阻塞模式（non-blocking mode）.设置之后，就可以在异步模式下调用connect(), read() 和write()了。
        socketChannel.configureBlocking(false);
        socketChannel.connect(new InetSocketAddress("127.0.0.1", 60000));
        
        //为非阻塞模式的判断用
        while(!socketChannel.finishConnect()){
            socketChannelRead(socketChannel);
        }
    }
    
    /**
     * 
     * ServerSocketChannel
     * 
     * Java NIO中的 ServerSocketChannel 是一个可以监听新进来的TCP连接的通道, 
     * 就像标准IO中的ServerSocket一样。ServerSocketChannel类在 java.nio.channels包中。
     * 
     * @throws Exception 
     * 
     */
    private void serverSocket() throws Exception {
        // 通过调用 ServerSocketChannel.open() 方法来打开ServerSocketChannel.
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.socket().bind(new InetSocketAddress(60000));
        // ServerSocketChannel可以设置成非阻塞模式。在非阻塞模式下，accept()
        // 方法会立刻返回，如果还没有新进来的连接,返回的将是null。
        // 因此，需要检查返回的SocketChannel是否是null.
        serverSocketChannel.configureBlocking(false);
        // 通常不会仅仅只监听一个连接,在while循环中调用 accept()方法.
        while (true) {
            // 监听新进来的连接
            // 通过 ServerSocketChannel.accept() 方法监听新进来的连接。当
            // accept()方法返回的时候,它返回一个包含新进来的连接的 SocketChannel。
            // 因此, accept()方法会一直阻塞到有新连接到达。
            SocketChannel socketChannel = serverSocketChannel.accept();

            // 非阻塞模式
            if (socketChannel != null) {
                socketChannelRead(socketChannel);
            }
            //通过调用ServerSocketChannel.close() 方法来关闭ServerSocketChannel
            // serverSocketChannel.close();
        }
    }
    
    private static StringBuilder socketChannelRead(SocketChannel socketChannel) throws Exception {
        
        StringBuilder sb = new StringBuilder();
        
        Charset charset = Charset.forName("GBK");
        CharsetDecoder decoder = charset.newDecoder();

        ByteBuffer byteBuffer = ByteBuffer.allocate(10);
        CharBuffer charBuffer = CharBuffer.allocate(10);

        int bytesRead = socketChannel.read(byteBuffer);

        char[] tmp = null; // 临时存放转码后的字符
        byte[] remainByte = null;// 存放decode操作后未处理完的字节。decode仅仅转码尽可能多的字节，此次转码不了的字节需要缓存，下次再转
        int leftNum = 0; // 未转码的字节数

        while (bytesRead != -1) {

            // System.out.println("Read " + bytesRead);
            byteBuffer.flip(); // make buffer ready for read
            CoderResult result = decoder.decode(byteBuffer, charBuffer, false);
//            System.out.println("result:"+ result);
            charBuffer.flip();

            remainByte = null;
            leftNum = byteBuffer.limit() - byteBuffer.position();
            if (leftNum > 0) { // 记录未转换完的字节
                remainByte = new byte[leftNum];
                byteBuffer.get(remainByte, 0, leftNum);
            }

            // 输出已转换的字符
            tmp = new char[charBuffer.length()];
            while (charBuffer.hasRemaining()) {
                charBuffer.get(tmp);
                //sb.append(tmp);
                System.out.print(new String(tmp));
            }

            byteBuffer.clear(); // make buffer ready for writing
            charBuffer.clear();

            if (remainByte != null) {
                byteBuffer.put(remainByte); // 将未转换完的字节写入bBuf，与下次读取的byte一起转换
            }
            bytesRead = socketChannel.read(byteBuffer);
        }
        return sb;
    }
    
    /**
     * Java NIO中的DatagramChannel是一个能收发UDP包的通道。
     * 因为UDP是无连接的网络协议，所以不能像其它通道那样读取和写入。它发送和接收的是数据包。
     * 
     * @throws Exception
     */
    private void serverDatagram() throws Exception {
        /**
         * 这个例子打开的 DatagramChannel可以在UDP端口9999上接收数据包。
         */
        DatagramChannel channel = DatagramChannel.open();
        channel.socket().bind(new InetSocketAddress(60000));
        
        Charset charset = Charset.forName("GBK");
        CharsetDecoder decoder = charset.newDecoder();
        
        //通过receive()方法从DatagramChannel接收数据
        //receive()方法会将接收到的数据包内容复制到指定的Buffer.
        //如果Buffer容不下收到的数据，多出的数据将被丢弃。
        ByteBuffer byteBuffer = ByteBuffer.allocate(48);
        CharBuffer charBuffer = CharBuffer.allocate(48);
        byteBuffer.clear();
        channel.receive(byteBuffer);
        
        char[] tmp = null; // 临时存放转码后的字符
        while(true){
            byteBuffer.flip();
            
            CoderResult result = decoder.decode(byteBuffer, charBuffer, false);
            
            charBuffer.flip();
            tmp = new char[charBuffer.length()];
            while (charBuffer.hasRemaining()) {
                charBuffer.get(tmp);
                System.out.print(new String(tmp));
            }
            byteBuffer.clear();
            charBuffer.clear();
            channel.receive(byteBuffer);
        }
    }
    /**
     * 可以将DatagramChannel“连接”到网络中的特定地址的。由于UDP是无连接的，
     * 连接到特定地址并不会像TCP通道那样创建一个真正的连接。
     * 而是锁住DatagramChannel ，让其只能从特定地址收发数据。
     * 当连接后，也可以使用read()和write()方法，就像在用传统的通道一样。只是在数据传送方面没有任何保证。
     * 
     * @throws Exception
     */
    private void clientDatagram() throws Exception {
        DatagramChannel channel = DatagramChannel.open();
        String newData = "New^啊&ng& to write to fasdfsdafsdfdsfsadf1JLKJL)(&)&*(&&ile..." + System.currentTimeMillis();
        ByteBuffer buf = ByteBuffer.allocate(480);
        buf.clear();
        buf.put(newData.getBytes("GBK"));
        buf.flip();
        
        //通过send()方法从DatagramChannel发送数据  即使下面的地址无法连接也是可以发送数据的。
        int bytesSent = channel.send(buf, new InetSocketAddress("127.0.0.1", 60000));
        //UDP在数据传送方面没有任何保证。
    }
    
    /**
     * Java NIO 管道是2个线程之间的单向数据连接。Pipe有一个source通道和一个sink通道。
     * 数据会被写到sink通道，从source通道读取。
     * @throws Exception 
     */
    private void pipe() throws Exception {
        
        Pipe pipe = Pipe.open();

        //构建一条线程 ,获取管道的SinkChannel，用于数据录入
        Thread thread = new Thread(() -> {
            // 向管道写数据
            // 要向管道写数据，需要访问sink通道。
            // 通过调用SinkChannel的write()方法，将数据写入SinkChannel,像这样：
            Pipe.SinkChannel sinkChannel = pipe.sink();
            String newData = "New String to write to file..." + System.currentTimeMillis();
            ByteBuffer buf = ByteBuffer.allocate(48);
            buf.clear();
            try {
                buf.put(newData.getBytes("GBK"));

                buf.flip();
                while (buf.hasRemaining()) {
                    sinkChannel.write(buf);
                }
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        });
        
        //构建一条线程 ,让其去获取到SinkChannel录入的数据并输出
        Thread thread1 = new Thread(() -> {
            // 从管道读取数据
            // 从读取管道的数据，需要访问source通道，
            // 调用source通道的read()方法来读取数据，
            Pipe.SourceChannel sourceChannel = pipe.source();

            Charset charset = Charset.forName("GBK");
            CharsetDecoder decoder = charset.newDecoder();

            ByteBuffer byteBuffer = ByteBuffer.allocate(48);
            CharBuffer charBuffer = CharBuffer.allocate(48);

            char[] tmp = null; // 临时存放转码后的字符
            byte[] remainByte = null;// 存放decode操作后未处理完的字节。decode仅仅转码尽可能多的字节，此次转码不了的字节需要缓存，下次再转
            int leftNum = 0; // 未转码的字节数

            // read()方法返回的int值会告诉我们多少字节被读进了缓冲区。
            int bytesRead;
            try {
                bytesRead = sourceChannel.read(byteBuffer);

                while (bytesRead != -1) {

                    // System.out.println("Read " + bytesRead);
                    byteBuffer.flip(); // make buffer ready for read
                    CoderResult result = decoder.decode(byteBuffer, charBuffer, false);
                    // System.out.println("result:"+ result);
                    charBuffer.flip();

                    remainByte = null;
                    leftNum = byteBuffer.limit() - byteBuffer.position();
                    if (leftNum > 0) { // 记录未转换完的字节
                        remainByte = new byte[leftNum];
                        byteBuffer.get(remainByte, 0, leftNum);
                    }

                    // 输出已转换的字符
                    tmp = new char[charBuffer.length()];
                    while (charBuffer.hasRemaining()) {
                        charBuffer.get(tmp);
                        // sb.append(tmp);
                        System.out.print(new String(tmp));
                    }

                    byteBuffer.clear(); // make buffer ready for writing
                    charBuffer.clear();

                    if (remainByte != null) {
                        byteBuffer.put(remainByte); // 将未转换完的字节写入bBuf，与下次读取的byte一起转换
                    }
                    bytesRead = sourceChannel.read(byteBuffer);
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        });
        
        thread.run();
        Thread.sleep(2000L);
        thread1.run();
        
    }
    
    /**
     * Path接口是java NIO2的一部分。首次在java 7中引入。Path接口在java.nio.file包下，
     * 所以全称是java.nio.file.Path。 java中的Path表示文件系统的路径。可以指向文件或文件夹。
     * 也有相对路径和绝对路径之分。绝对路径表示从文件系统的根路径到文件或是文件夹的路径。
     * 相对路径表示从特定路径下访问指定文件或文件夹的路径。相对路径的概念可能有点迷糊,可以自己百度一下。
     * 不要将文件系统的path和操作系统的环境变量path搞混淆。java.nio.file.Path接口和操作系统的path环境变量没有任何关系。
     * 在很多方面，java.nio.file.Path接口和java.io.File有相似性，但也有一些细微的差别。
     * 在很多情况下，可以用Path来代替File类。
     */
    private void NIOPath() {
        //为了使用java.nio.file.Path实例，必须首先创建它。可以使用Paths 类的静态方法Paths.get()来产生一个实例。
        //请注意例子开头的两个import语句。想要使用Paths类和Path接口，必须首先引入相应包。
        //其次，注意Paths.get(“c:\\data\\myfile.txt”)的用法。
        //其使用了Paths.get方法创建了Path的实例。它是一个工厂方法。
        Path path = Paths.get("c:\\data\\myfile.txt");//绝对路径Path
        
        
        //创建相对路径Path
        //java NIO Path类也能使用相对路径。可以通过Paths.get(basePath, relativePath)创建一个相对路径Path。
        Path projects = Paths.get("d:\\data", "projects");
        //创建了一个指向d:\data\projects文件夹的实例。
        Path file = Paths.get("d:\\data", "projects\\a-project\\myfile.txt");
        //创建了一个指向 d:\data\projects\a-project\myfile.txt 文件的实例。
        //.表示当前路径。例如，如果以如下方式创建一个相对路径：
        //创建的Path实例对应的路径就是运行这段代码的项目工程目录。
        Path currentDir = Paths.get(".");
        System.out.println(currentDir.toAbsolutePath());
        //..表示父类目录。
        Path parentDir = Paths.get("..");
        String path1 = "d:\\data\\projects\\a-project\\..\\another-project";
        Path parentDir2 = Paths.get(path1);
        //d:\data\projects\another-project在a-project目录后面的..符号，
        //将指向的目录修改为projects目录，因此，最终path指向another-project目录。
        
        
        //Path 的normalize()方法可以标准化路径。
        String originalPath =
                 "d:\\data\\projects\\a-project\\..\\another-project";

        Path path3 = Paths.get(originalPath);
        System.out.println("path3 = " + path3);

        Path path2 = path3.normalize();
        System.out.println("path2 = " + path2);
        //如你所见，标准化后的路径不再包含 a-project\..部分，因为它是多余的。
        
        //Files.exists()
        //Files.exists()方法用来检查文件系统中是否存在某路径。
        //Path实例对应的路径可能在文件系统中并不存在。例如，如果打算新建一个文件夹，首先需要创建一个对应的Path实例，然后才能创建对应路径下的文件夹。
        //因为Path实例对应的路径在文件系统的存在性不确定，可以使用Files.exists()方法确认Path对应的路径是否存在 (也就是开发需要自己显式的去调用该方法确认)。
        //如下是Files.exists()的示例：
        Path path5 = Paths.get("data/logging.properties");

        boolean pathExists = Files.exists(path, new LinkOption[] { LinkOption.NOFOLLOW_LINKS });
        System.out.println(pathExists);
        //示例中首先创建了一个Path。然后，通过调用Files.exists方法并将path作为第一个参数确认path对应的路径是否存在。
        //注意下Files.exist()方法的第二个参数。第二个参数数组是评判路径是否存在时使用的规则。
        //示例中，数组包含LinkOption.NOFOLLOW_LINKS枚举类型，表示Files.exists不会跟进到路径中有连接的下层文件目录。
        //表示path路径中如果有连接，Files.exists方法不会跟进到连接中去
    }
    
    private void byteBufferUtf8() throws Exception {
        Charset charset = null;
        CharsetDecoder decoder = null;
        String charsetName = "UTF-8";
        int capacity = 10;

        charset = Charset.forName(charsetName);
        decoder = charset.newDecoder();

        String s = "客户端发送dsad德生科技电脑fdas上考虑迪士尼年少弗拉门发生ofjam打什么的即破发麦克 ‘；打， 饭哦按asdfasfsdfdfsfdsf都客户端发送dsad德生科技电脑fdas上考虑迪士尼年少弗拉门发生ofjam打什么的即破发麦克 ‘；打， 饭哦按asdfasfsdfdfsfdsf都客户端发送dsad德生科技电脑fdas上考虑迪士尼年少弗拉门发生ofjam打什么的即破发麦克 ‘；打， 饭哦按asdfasfsdfdfsfdsf都客户端发送dsad德生科技电脑fdas上考虑迪士尼年少弗拉门发生ofjam打什么的即破发麦克 ‘；打， 饭哦按asdfasfsdfdfsfdsf都";
        byte[] bytes = s.getBytes(charsetName);

        // 模拟接收的ByteBuffer size 10
        ByteBuffer byteBuffer = ByteBuffer.allocate(capacity);
        // 用于临时存放Bytebuffer转换后的字符
        CharBuffer charBuffer = CharBuffer.allocate(capacity);
        // 用于连接展示字符串
        StringBuilder sb = new StringBuilder();

        int i = 0;
        while (true) {
            byteBuffer.put(bytes[i]);
            i++;
            if (byteBuffer.remaining() == 0 || i == bytes.length) {
                byteBuffer.flip();
                CoderResult coderResult;
                if (i != bytes.length) {
                    coderResult = decoder.decode(byteBuffer, charBuffer, false);
                } else {
                    coderResult = decoder.decode(byteBuffer, charBuffer, true);
                }
                // 有错误
                if (coderResult.isError()) {
                    coderResult.throwException();
                }
                charBuffer.flip();
                sb.append(charBuffer);
                charBuffer.clear();
                byteBuffer.compact();
            }
            // 退出循环
            if (i == bytes.length) {
                break;
            }
        }
        System.out.println(sb);
    }
}