[笔记] 尚硅谷JavaNIO

byteBuffer.flip();//切换到读模式
byte[] data = new byte[byteBuffer.limit()];
byteBuffer.get(data);//获取数据

ByteBuffer.allocate(1024);//创建非直接缓冲区
ByteBuffer.allocateDirect(1024);//创建直接缓冲区

 byteBuffer.isDirect();
 //返回一个boolean，true是直接缓冲区，false是非直接缓冲区

 MappedByteBuffer mappedByteBuffer = inChannel.map(MapMode.READ_ONLY,0,inChannel.size());
 //只读模式 从0 到size

 //获取文件流
 FileInputStream fileInputStream = new FileInputStream("1.jpg");
 FileOutputStream fileOutputStream = new FileOutputStream("2.jpg");
 //获取文件通道
 FileChannel fileInputChannel = fileInputStream.openChannel();
 FileChannel fileOutputChannel = fileOutputStream.openChannel();
 //获取一个Buffer
 ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
 while((fileInputChannel.read(byteBuffer)) != -1){
     byteBuffer.flip();//切换到读模式
     fileOutputChannel.wirte(byteBuffer);
     byteBuffer.clear();//清空buf
 }
 //关闭通道
 fileOutChannel.close();
 fileInputChannel.close();
 fileInputStream.close();
 fileOutputStream.close();

 FileChannel inChannel = FileChannel.open(Paths.get("d:/1.mkv"), StandardOpenOption.READ);
 FileChannel outChannel = FileChannel.open(Paths.get("d:/2.mkv"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
 //StandardOpenOption是一个枚举类，其中有多个选项，用于设置该通道的作用
 //如读取：StandardOpenOption.READ
 //如读和写，则可利用Java的不定参数：
 //其中：StandardOpenOption.CREATE_NEW的类型意为
 // |— 如果存在就报错，如果不存在就新建
 //FileChannel.open("d:/1.mkv",StandardOpenOption.READ,StandardOpenOption.WRITE);
 //可以利用channel.map()获取内存映射文件Buffer
 //MappedByteBuffer是内存映射文件，道理和ByteBuffer.allocateDirect();一摸一样
 //MappedByteBuffer是在物理内存中。
 //内存映射文件，只有ByteBuffer支持！
 MappedByteBuffer inMappedBuf = inChannel.map(MapMode.READ_ONLY, 0, inChannel.size());
 MappedByteBuffer outMappedBuf = outChannel.map(MapMode.READ_WRITE, 0, inChannel.size());
 //MapMode 也是一个选项枚举类
 //直接对缓冲区进行数据的读写操作
 byte[] dst = new byte[inMappedBuf.limit()];
 inMappedBuf.get(dst);
 outMappedBuf.put(dst);
 //关闭通道
 inChannel.close();
 outChannel.close();

 FileChannel inChannel = FileChannel.open(Paths.get("d:/1.mkv"), StandardOpenOption.READ);
 FileChannel outChannel = FileChannel.open(Paths.get("d:/2.mkv"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
 //transferTo与transferFrom是一个效果
 //inChannel.transferTo(0, inChannel.size(), outChannel);
 //从0开始读取，读取到inChannel.size()位置，输出给outChannel
 outChannel.transferFrom(inChannel, 0, inChannel.size());
 //从inChannel获取，从第0个开始获取，获取到inChannel.size()大小的位置
 //channel.size();  -> 返回此通道文件的当前大小，以字节为单位。
 //FileChannel实例的size()方法将返回该实例所关联文件的大小。如:
 //long fileSize = channel.size();
 inChannel.close();
 outChannel.close();

 RandomAccessFile raf = new RandomAccessFile("1.txt","rw");
 //1.获取通道
 FileChannel fileChannel = raf.getChannel();
 //创建一个缓冲区
 ByteBuffer byteBuffer1 = ByteBuffer.allocate(100);
 ByteBuffer byteBuffer2 = ByteBuffer,allocate(1024);
 //通过分散读取进行读取
 ByteBuffer[] bufs = {byteBuffer1,byteBuffer2};
 fileChannel.read(bufs);
 for(ByteBuffer bb : bufs){
     bb.flip();//切换到读模式
 }
 //输出前100个字节
 System.out.println(new String(bufs[0].array(),0,bufs[0].limit()));
 //输出后1024个字节
 System.out.println(new String(bufs[1].array(),0,bufs[1].limit()));
 /* 通过结果我们可以看到，分散读取的确是按照顺序写入的 */

RandomAccessFile raf = new RandomAccessFile("1.txt","rw");
 RandomAccessFile raf2 = new RandomAccessFile("2.txt","rw");
 //1.获取通道
 FileChannel fileChannel = raf.getChannel();
 FileChannel fileChannel2 = raf2.getChannel();
 //创建一个缓冲区
 ByteBuffer byteBuffer1 = ByteBuffer.allocate(100);
 ByteBuffer byteBuffer2 = ByteBuffer.allocate(1024);
 ByteBuffer[] bufs = {byteBuffer1,byteBuffer2};
 fileChannel.read(bufs);//从文件中读取数据到bufs
 for(ByteBuffer bb : bufs){
     bb.flip();//切换到读模式
 }
 fileChannel2.write(bufs)
 fileChannel.close();
 fileChannel2.close();
 raf.close();
 raf2.close();
 //最终还是会按照顺序进行写入

 Charset charset = Charset.fromName("GBK");
 CharsetEncoder ce = charset.newEncoder();
 CharsetDecoder cd = charset.newDecoder();
 CharBuffer charBuffer = CharBuffer.allocate(1024);
 charBuffer.put("尚硅谷威武！");
 charBuffer.flip();//切换读模式
 //编码
 ByteBuffer byteBuffer = ce.encode(charBuffer);
 byteBuffer.flip();//切换成读模式
 for(int i=0;i<byteBuffer.limit;i++{
     System.out.println(byteBuffer.get);
 }
 byteBuffer.reset();//重置position指针
 //解码
 charBuffer = cd.decode(byteBuffer);

//客户端
@Test
public void client() throws IOException{
    //1. 获取通道
    SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));

    //2. 切换非阻塞模式
    sChannel.configureBlocking(false);

    //3. 分配指定大小的缓冲区
    ByteBuffer buf = ByteBuffer.allocate(1024);

    //4. 发送数据给服务端
    Scanner scan = new Scanner(System.in);

    while(scan.hasNext()){
        String str = scan.next();
        buf.put((new Date().toString() + "\n" + str).getBytes());
        buf.flip();
        sChannel.write(buf);
        buf.clear();
    }

    //5. 关闭通道
    sChannel.close();
}

//服务端
@Test
public void server() throws IOException{
    //1. 获取通道
    ServerSocketChannel ssChannel = ServerSocketChannel.open();

    //2. 切换非阻塞模式
    ssChannel.configureBlocking(false);

    //3. 绑定连接
    ssChannel.bind(new InetSocketAddress(9898));

    //4. 获取选择器
    Selector selector = Selector.open();

    //5. 将通道注册到选择器上, 并且指定"监听接收事件"
    ssChannel.register(selector, SelectionKey.OP_ACCEPT);

    //6. 轮询式的获取选择器上已经"准备就绪"的事件
    while(selector.select() > 0){

        //7. 获取当前选择器中所有注册的"选择键(已就绪的监听事件)"
        Iterator<SelectionKey> it = selector.selectedKeys().iterator();

        while(it.hasNext()){
            //8. 获取准备"就绪"的是事件
            SelectionKey sk = it.next();

            //9. 判断具体是什么事件准备就绪
            if(sk.isAcceptable()){
                //10. 若"接收就绪"，获取客户端连接
                SocketChannel sChannel = ssChannel.accept();

                //11. 切换非阻塞模式
                sChannel.configureBlocking(false);

                //12. 将该通道注册到选择器上
                sChannel.register(selector, SelectionKey.OP_READ);
            }else if(sk.isReadable()){
                //13. 获取当前选择器上"读就绪"状态的通道
                SocketChannel sChannel = (SocketChannel) sk.channel();

                //14. 读取数据
                ByteBuffer buf = ByteBuffer.allocate(1024);

                int len = 0;
                while((len = sChannel.read(buf)) > 0 ){
                    buf.flip();
                    System.out.println(new String(buf.array(), 0, len));
                    buf.clear();
                }
            }

            //15. 取消选择键 SelectionKey
            it.remove();
        }
    }
}

@Test
public void send() throws IOException{
    DatagramChannel dc = DatagramChannel.open();

    dc.configureBlocking(false);

    ByteBuffer buf = ByteBuffer.allocate(1024);

    Scanner scan = new Scanner(System.in);

    while(scan.hasNext()){
        String str = scan.next();
        buf.put((new Date().toString() + ":\n" + str).getBytes());
        buf.flip();
        dc.send(buf, new InetSocketAddress("127.0.0.1", 9898));
        buf.clear();
    }

    dc.close();
}

@Test
public void receive() throws IOException{
    DatagramChannel dc = DatagramChannel.open();

    dc.configureBlocking(false);

    dc.bind(new InetSocketAddress(9898));

    Selector selector = Selector.open();

    dc.register(selector, SelectionKey.OP_READ);

    while(selector.select() > 0){
        Iterator<SelectionKey> it = selector.selectedKeys().iterator();

        while(it.hasNext()){
            SelectionKey sk = it.next();

            if(sk.isReadable()){
                ByteBuffer buf = ByteBuffer.allocate(1024);

                dc.receive(buf);
                buf.flip();
                System.out.println(new String(buf.array(), 0, buf.limit()));
                buf.clear();
            }
        }

        it.remove();
    }
}

@Test
public void test1() throws IOException{
    //1. 获取管道
    Pipe pipe = Pipe.open();

    //2. 将缓冲区中的数据写入管道
    ByteBuffer buf = ByteBuffer.allocate(1024);

    Pipe.SinkChannel sinkChannel = pipe.sink();
    buf.put("通过单向管道发送数据".getBytes());
    buf.flip();
    sinkChannel.write(buf);

    //3. 读取缓冲区中的数据
    Pipe.SourceChannel sourceChannel = pipe.source();
    buf.flip();
    int len = sourceChannel.read(buf);
    System.out.println(new String(buf.array(), 0, len));

    sourceChannel.close();
    sinkChannel.close();
}