java--NIO详解--Buffer、channel与网络编程

目录

  • 一、buffer--缓冲区的基本使用
    • 1.核心与基础用法
    • 2.实现字符集转换
  • 二、Channel的基本使用
  • 三、socketChannel网络编程--阻塞式
  • 四、socketChannel网络编程--非阻塞式
    • 1.Client客户端类
    • 2.Server服务端

一、buffer–缓冲区的基本使用

1.核心与基础用法

初始化缓冲区:XXXBuffer.allocate(int capacity)
数据加入缓冲区:buffer.put(byte[] data)
切换为读模式:byteBuffer.flip()
读取缓冲区中的数据:buffer.get(byte[] data)

代码示例:

package nio;

import org.junit.Test;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.util.SortedMap;

public class BufferTest {
    @Test  // buffer的基本使用
    public void nioBufferTest(){
        System.out.println("********初始化缓冲区********");
        ByteBuffer byteBuffer = ByteBuffer.allocate(512); // 初始化缓冲区
        System.out.println("capacity:"+byteBuffer.capacity());  // 容量
        System.out.println("limit:"+byteBuffer.limit());  // 界限,可操作容量
        System.out.println("position:"+byteBuffer.position());  // 正在操作的位置

        System.out.println("********加入数据********");
        byte[] bytes = "hello,nio".getBytes();
        byteBuffer.put(bytes); // 加入数据
        System.out.println("position:"+byteBuffer.position()); // position变化
        System.out.println("limit:"+byteBuffer.limit());  // 不变

        System.out.println("********读模式********");
        byteBuffer.flip(); // 切换为读模式
        System.out.println("limit:"+byteBuffer.limit());  // 加入数据字节数
        System.out.println("position:"+byteBuffer.position());  // 0

        System.out.println("********读取数据********");
        byte[] bytes1 = "1234567".getBytes();
        byteBuffer.get(bytes1);
        System.out.println(new String(bytes1));
        System.out.println("limit:"+byteBuffer.limit());  // 加入数据字节数
        System.out.println("position:"+byteBuffer.position());  // 已读取的总长度7
        byteBuffer.get("89".getBytes());
        System.out.println("limit:"+byteBuffer.limit());  // 加入数据字节数
        System.out.println("position:"+byteBuffer.position());  // 已读取的总长度7+2=9

        System.out.println("********重复读********");
        byteBuffer.rewind();  // 恢复到刚切换为读状态时的状态
        System.out.println("limit:"+byteBuffer.limit());  // 加入数据字节数
        System.out.println("position:"+byteBuffer.position());  // 0

        System.out.println("********清空********");
        byteBuffer.clear(); // 恢复到刚初始化时的状态
        System.out.println("limit:"+byteBuffer.limit());  // 加入数据字节数
        System.out.println("position:"+byteBuffer.position());  // 0
        byteBuffer.put("1234567".getBytes());

        System.out.println("********标记与reset********");
        byteBuffer.flip();
        byteBuffer.get(bytes1,0,4);
        System.out.println(new String(bytes1, 0, 4));
        System.out.println("position:"+byteBuffer.position());  // 0

        byteBuffer.mark();
        byteBuffer.get(bytes1,0,2);
        System.out.println(new String(bytes1, 0, 2));
        System.out.println("position:"+byteBuffer.position());  // 0
        byteBuffer.reset();
        System.out.println("position:"+byteBuffer.position());  // 0

        System.out.println(byteBuffer.hasRemaining()); // 是否还有未操作数量
        System.out.println(byteBuffer.remaining());  // 可操作数量
        // 打印所有未操作的
        if (byteBuffer.hasRemaining()) {
            int n = byteBuffer.remaining();
            byteBuffer.get(bytes,0,n);
            System.out.println(new String(bytes, 0, n));
        }
    }
}

2.实现字符集转换

 @Test // 字符集转换
    public void charsetTest() throws IOException {
        SortedMap<String, Charset> availableCharsets = Charset.availableCharsets();
        System.out.println("********可用字符集********");
        System.out.println(availableCharsets);

        System.out.println("****************");
        Charset gbk = Charset.forName("GBK");  // 通过名称获取字符集实例
        Charset utf8 = Charset.forName("utf-8");  // 通过名称获取字符集实例

        CharsetEncoder charsetEncoder = gbk.newEncoder();// 通过字符集实例获取编码器(编码:字符串-->字节数组)
        CharsetDecoder charsetDecoder = utf8.newDecoder(); // 通过字符集实例获取解码器(编码:字节数组-->字符串)

        CharBuffer charBuffer = CharBuffer.allocate(100);
        charBuffer.put("encode decode 字符转换");
        charBuffer.flip(); // 转换为读模式才可以正确执行下面的语句

        ByteBuffer byteBuffer = charsetEncoder.encode(charBuffer); // 将charBuffer转换为byteBuffer

        System.out.println("********ByteBuffer********");
        for (int i = 0; i < byteBuffer.limit(); i++) {
            System.out.print(byteBuffer.get() + " ");
        }
        System.out.println();

        System.out.println("********CharBuffer********");
        byteBuffer.flip();
        CharBuffer charBuffer1 = charsetDecoder.decode(byteBuffer); // 执行报错,不能转换为utf-8
        System.out.println(charBuffer1);
    }

二、Channel的基本使用

第一步:获取通道:

  • fileXXXStream.getChannel()
  • FileChannel fc = FileChannel.open(path,openOption)
    .

第二步:实例化一个/多个缓冲区,例如:
ByteBuffer bb= ByteBuffer.allocate(512);
.
第三步:数据读入通道读取数据并写入到缓冲区:
fc.read(bb);
.
第n步:用其他通道操作该缓冲区;
fcn.write(bb);

package nio;

import org.junit.Test;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class ChannelTest {
    // 通道用于源节点与目标节点的连接,不负责存储
    // FileChannel  SocketChannel  ServerSocketChannel  DatagramChannel


    @Test   获取通道方式一:getChannel()
    public void channelTest1()  {

        FileInputStream fileInputStream = null; // 文件输入流,读取文件
        FileOutputStream fileOutputStream = null; // 文件输出流
        FileChannel fileInputStreamChannel = null;  // 数据读入通道
        FileChannel fileOutputStreamChannel = null; // 数据写出通道
        try {
            fileInputStream = new FileInputStream("yellowBoy.jpg");
            fileOutputStream = new FileOutputStream("yb.jpg");

            fileInputStreamChannel = fileInputStream.getChannel();
            fileOutputStreamChannel = fileOutputStream.getChannel();

            ByteBuffer byteBuffer = ByteBuffer.allocate(512); //  缓冲区

            while (fileInputStreamChannel.read(byteBuffer) != -1) {  // 数据读入通道读取数据并写入到缓冲区
                byteBuffer.flip(); // 缓冲区读模式
                fileOutputStreamChannel.write(byteBuffer); // 数据写出通道写入缓冲区中的数据
                byteBuffer.clear(); // 清空数据,下次继续写入
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileInputStreamChannel != null) {
                    fileInputStreamChannel.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fileOutputStreamChannel != null) {
                    fileOutputStreamChannel.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fileInputStream != null) {
                    fileInputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fileOutputStream == null) {
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }



    }

    @Test   获取通道方式一:getChannel(),使用多个缓冲区
    public void channelTest2()  {
        FileInputStream fileInputStream = null; // 文件输入流,读取文件
        FileOutputStream fileOutputStream = null; // 文件输出流
        FileChannel fileInputStreamChannel = null;  // 数据读入通道
        FileChannel fileOutputStreamChannel = null; // 数据写出通道
        try {
            fileInputStream = new FileInputStream("channel.txt");
            fileOutputStream = new FileOutputStream("c.txt");

            fileInputStreamChannel = fileInputStream.getChannel();
            fileOutputStreamChannel = fileOutputStream.getChannel();

            ByteBuffer byteBuffer = ByteBuffer.allocate(10); //  缓冲区
            ByteBuffer byteBuffer1 = ByteBuffer.allocate(200); //  缓冲区
            ByteBuffer[] byteBuffers = {byteBuffer,byteBuffer1};

            while (fileInputStreamChannel.read(byteBuffers) != -1) {
                fileInputStreamChannel.read(byteBuffers);  // 读取数据按顺序写入到多个缓冲区(缓冲区为写模式)
                System.out.println(new String(byteBuffer.array()));
                byteBuffer.flip();  // 缓冲区切换为读模式
                byteBuffer1.flip();
                fileOutputStreamChannel.write(byteBuffers); // 从多个缓冲区读取数据写入到通道(缓冲区为读模式)
                byteBuffer.clear();
                byteBuffer1.clear();
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileInputStreamChannel != null) {
                    fileInputStreamChannel.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fileOutputStreamChannel != null) {
                    fileOutputStreamChannel.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fileInputStream != null) {
                    fileInputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fileOutputStream == null) {
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }



    }

    @Test  // FileChannel.open(),通过直接缓冲区
    public void channelTest3(){
        FileChannel readFileChannel = null;
        FileChannel writeFileChanel = null;
        try {
            // 初始化一个通道,参数一:java.nio.file.Paths.get(文件路径),参数二:OpenOption
            readFileChannel = FileChannel.open(Paths.get("yellowBoy.jpg"), StandardOpenOption.READ);
            long size = readFileChannel.size();
            writeFileChanel = FileChannel.open(Paths.get("yb.jpg"), StandardOpenOption.WRITE, StandardOpenOption.READ,StandardOpenOption.CREATE_NEW);

            readFileChannel.transferTo(0,size,writeFileChanel);

            // 等价
            // writeFileChanel.transferFrom(readFileChannel,0,size);

            // 等价
            /*MappedByteBuffer readBuffer = readFileChannel.map(FileChannel.MapMode.READ_ONLY, 0,size);
            MappedByteBuffer writeBuffer = writeFileChanel.map(FileChannel.MapMode.READ_WRITE, 0, size);

            byte[] bytes = new byte[(int) size];
            readBuffer.get(bytes);
            writeBuffer.put(bytes);*/

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (writeFileChanel != null) {
                    writeFileChanel.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (readFileChannel != null) {
                    readFileChannel.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

三、socketChannel网络编程–阻塞式

package nio;

import org.junit.Test;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class SocketChannelTest {
    @Test  // 使用socketChannel进行网络编程
    public void socketChannelClient() throws IOException {
        // 创建SocketChannel实例
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",33333));

        // FileChannel实例用于读取本地文件
        FileChannel fileChannel = FileChannel.open(Paths.get("yellowBoy.jpg"), StandardOpenOption.READ);
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        // fileChannel读取数据到byteBuffer中
        while (fileChannel.read(byteBuffer)!=-1){
            byteBuffer.flip();
            // socketChannel读取byteBuffer中的数据并写入到socketChannel
            socketChannel.write(byteBuffer);
            byteBuffer.clear();
        }
        socketChannel.shutdownOutput();  // 告诉服务器输出完成,不然会阻塞

        int len = 0;
        while((len = socketChannel.read(byteBuffer))!=-1){  // socketChannel接收服务端反馈的消息
            byteBuffer.flip();
            System.out.println(new String(byteBuffer.array(),0,len));
            byteBuffer.clear();
        };

        socketChannel.close();
        fileChannel.close();

    }
    @Test
    public void socketChannelServer()  {
        ServerSocketChannel serverSocketChannel = null;
        FileChannel fileChannel = null;
        SocketChannel socketChannel = null;
        try {
            // 服务端专用ServerSocketChannel实例
            serverSocketChannel = ServerSocketChannel.open();

            // 跟客户端一个道理,用于接收到客户端的文件保存到本地
            fileChannel = FileChannel.open(Paths.get("boyY.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);

            serverSocketChannel.bind(new InetSocketAddress(33333)); // 绑定端口,跟客户端的socketChannel同样的端口

            // 接收文件,生成socketChannel实例
            socketChannel = serverSocketChannel.accept();

            ByteBuffer byteBuffer = ByteBuffer.allocate(512);

            // 读取
            while(socketChannel.read(byteBuffer)!=-1){
                byteBuffer.flip();
                // 写入到本地
                fileChannel.write(byteBuffer);
                byteBuffer.clear();
            }
            // 发送反馈信息
            byteBuffer.put("收到了一张小黄人的图片".getBytes());
            byteBuffer.flip();
            socketChannel.write(byteBuffer);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                socketChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                serverSocketChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                fileChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

四、socketChannel网络编程–非阻塞式

1.Client客户端类

package nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.Scanner;

public class Client {
    public static void main(String[] args) throws IOException {
        SocketChannel sc = SocketChannel.open(new InetSocketAddress("127.0.0.1",33333));
        sc.configureBlocking(false); // 切换为非阻塞模式

        ByteBuffer bb = ByteBuffer.allocate(1024);
        Scanner scanner = new Scanner(System.in);
        System.out.println("input: ");
        while (!scanner.hasNext("exit")){  // 键盘写入,exit停止写入
            String str = scanner.next();
            bb.put(str.getBytes());  // 将写入的内容存储到缓冲区
            bb.flip(); // 读模式
            sc.write(bb); // 写入到Socket通道
            bb.clear();
            System.out.println("input: ");
        }
        System.out.println("已退出");
        scanner.close();
        sc.close();
    }
}

2.Server服务端

package nio;

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

public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.configureBlocking(false);
        ssc.bind(new InetSocketAddress(33333));

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

        ssc.register(selector,SelectionKey.OP_ACCEPT); // 注册,selector选择器监听ssc通道的accept事件

        //ssc.accept(); // ssc开始accept事件,并被selector监听

        while (selector.select() > 0){  // 获取selector上所有的就绪的事件个数
            // 获取所有selector上所有的就绪的事件
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()){
                // 一个就绪事件
                SelectionKey selectionKey = iterator.next();
                // 就绪事件为accept
                if(selectionKey.isAcceptable()){
                    SocketChannel sc = ssc.accept();
                    sc.configureBlocking(false);
                    sc.register(selector,SelectionKey.OP_READ);

                // 就绪事件为read
                }else if (selectionKey.isReadable()){
                    SocketChannel selectableChannel = (SocketChannel) selectionKey.channel();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                    int len = 0;
                    while ((len = selectableChannel.read(byteBuffer)) > 0){
                        byteBuffer.flip();
                        System.out.println(new String(byteBuffer.array(),0,len));
                        byteBuffer.clear();
                    }
                }
            }
            iterator.remove();
        }
    }
}

你可能感兴趣的:(java,buffer,nio,java)