亲宝软件园·资讯

展开

Java Netty框架

明天一定. 人气:1

什么是Netty

异步:发送请求无需等待响应,程式接着往下走。

事件驱动:一个连接事件或者断开事件,或者读事件或者写事件,发生后的后续处理。

Netty典型应用:

IO模型

简单理解就是用什么通道去进行数据发送和接收。

BIO:一个连接一个线程,连接不做任何事会造成不必要的线程开销。适用于连接数目较小且固定的架构。

NIO:服务端一个线程(也可以多个),维护一个多路复用器。由多路复用器去处理IO线程。适用于连接数目多且较短的架构

AIO:异步非阻塞,还未得到广泛应用。适用于连接数目多且连接较长的架构。

BIO

BIO编程简单流程

BIO简单实例

public class BIOserver {
    public static void main(String[] args) throws IOException {
        // 为了方便直接用了Executors创建线程池
        ExecutorService service = Executors.newCachedThreadPool();
        //指定服务端端口
        ServerSocket serverSocket = new ServerSocket(6666);
        System.out.println("服务器启动");
        while(true){
            //阻塞等待连接
            Socket socket = serverSocket.accept();
            System.out.println("连接到一个客户端");
            //每个连接对应一个线程
            service.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        handler(socket);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            });
        }
    }
    public static void handler(Socket socket) throws IOException {
        System.out.println("Thread:"+Thread.currentThread().getId());
        byte[] bytes = new byte[1024];
        InputStream inputStream = socket.getInputStream();
        while (true){
            //阻塞等待读取
            int n = inputStream.read(bytes);
            if(n!=-1){
                System.out.println(new String(bytes,0,n));
            }else {
                break;
            }
        }
        socket.close();
    }
}

测试:使用windows的telnet

使用 ctrl+]

 可以在服务端控制台看到,已经读取到发送的数据

NIO

三大核心部分:Channel(可类比Socket),Buffer,Selector

大概是这个样子。客户端和Buffer交互,Buffer和Channel是一对一的关系。Selector选择操作Channel(事件驱动,如果Channel有事件发生,Selector才去选择操作。)

Buffer

Buffer基本使用

ByteBuffer使用场景较为广泛。

buffer就是一个内存块,所以说nio是面向块/缓冲,底层是数组。数据读写是通过buffer。可以使用方法flip切换读写。

public class BufferNio {
    public static void main(String[] args) {
        //创建buffer容量为5个int
        IntBuffer buffer = IntBuffer.allocate(5);
        //放数据
        buffer.put(1);
        buffer.put(2);
        buffer.put(3);
        buffer.put(4);
        buffer.put(5);
        //读写切换
        buffer.flip();
        //取数据
        //内部维护一个索引,每次get索引都会往后边移动
        while(buffer.hasRemaining()){
            System.out.println(buffer.get());
        }
    }
}

Buffer四个主要属性

    // Invariants: mark <= position <= limit <= capacity
    private int mark = -1;
    private int position = 0;
    private int limit;
    private int capacity;

mark:标记,很少改变

position:下一个要被读元素的位置,为下次读写做准备

limit:缓冲器当前的终点,不能对缓冲区极限意外的区域读写,可变。

capacity:不可变,创建时指定的最大容量。

上边出现了读写切换的方法flip,我们看下源码,可以看出来通过改变属性实现可读可写的。

    public final Buffer flip() {
        limit = position;
        position = 0;
        mark = -1;
        return this;
    }

可以通过啊更改limit或者position来实现你想要的操作。参数自己决定

        buffer.limit(2);
        buffer.position(1);

Channel

可读可写,上接Selector,下连Buffer。

当客户端连接ServerSocketChannel时,创建客户端自己的SocketChannel。

本地文件写案例

public class ChannelNio {
    public static void main(String[] args) throws IOException {
        String str = "少壮不努力,老大徒伤悲";
        //创建输出流
        FileOutputStream os = new FileOutputStream("D:\\xxxxxxxxxxxxxxxxxxx\\a.txt");
        //获取FileChannel
        FileChannel channel = os.getChannel();
        //创建缓冲
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        //把字符串放入缓冲区
        buffer.put(str.getBytes());
        //反转ByteBuffer
        buffer.flip();
        //将ByteBuffer写入到FileChannel
        channel.write(buffer);
        //关闭流
        os.close();
    }
}

图示理解

本地文件读案例

public class ChannelNio {
    public static void main(String[] args) throws IOException {
        FileInputStream is = new FileInputStream("D:\\xxxxxxxxxxxxxxxxxxx\\a.txt");
        FileChannel channel = is.getChannel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        channel.read(buffer);
        System.out.println(new String(buffer.array()));
        is.close();
    }
}

本地文件拷贝案例

方法一

public class ChannelNio {
    public static void main(String[] args) throws IOException {
        FileInputStream is = new FileInputStream("D:\\xxxxxxxxxxxxxxxxxxx\\a.txt");
        FileChannel channel = is.getChannel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        FileOutputStream os = new FileOutputStream("D:\\xxxxxxxxxxxxxxxxxxx\\b.txt");
        FileChannel osChannel = os.getChannel();
        while (true){
            buffer.clear();
            int i = channel.read(buffer);
            if(i==-1){
                break;
            }
            buffer.flip();
            osChannel.write(buffer);
        }
        is.close();
        os.close();
    }
}

方法二

public class ChannelNio {
    public static void main(String[] args) throws IOException {
        FileInputStream is = new FileInputStream("D:\\xxxxxxxxxxxxxxxxxxx\\HELP.md");
        FileChannel channel = is.getChannel();
        FileOutputStream os = new FileOutputStream("D:\\xxxxxxxxxxxxxxxxxxx\\HELP222.md");
        FileChannel osChannel = os.getChannel();
        osChannel.transferFrom(channel,0,channel.size());
        is.close();
        os.close();
    }
}

Selector

用一个线程处理多个客户端连接。可以检测多个注册通道的事件,并作出相应处理。不用维护所有线程。

Selector可以获得被注册的SocketChannel的一个SelectionKey集合,然后监听select,获得有事件发生的SelectionKey,最后通过SelectionKey获得通道进行相应操作,完成业务。

加载全部内容

相关教程
猜你喜欢
用户评论