0
点赞
收藏
分享

微信扫一扫

Java网络编程进化史：从IO到NIO再到Netty

毅会 2022-01-06 阅读 38
java

Java网络编程进化史：从IO到NIO再到Netty

一、相关介绍

（一）同步阻塞模式（Blocking IO）

1.传统的阻塞式通信流程
早期的 Java 网络相关的 API(java.net包) 使用 Socket(套接字)进行网络通信，不过只支持阻塞函数使用。
要通过互联网进行通信，至少需要一对套接字：

  1. 运行于服务器端的 Server Socket。
  2. 运行于客户机端的 Client Socket。

2.Socket 网络通信过程
简单来说分为下面 4 步：

  1. 建立服务端并且监听客户端请求；
  2. 客户端请求，服务端和客户端建立连接；
  3. 两端之间可以传递数据；
  4. 关闭资源。

服务器端：

  1. 创建ServerSocket对象并且绑定地址（ip）和端口号(port)：server.bind(new InetSocketAddress(host, port))；
  2. 通过 accept()方法监听客户端请求；
  3. 连接建立后，通过输入流读取客户端发送的请求信息；
  4. 关闭相关资源

客户端：

  1. 创建Socket对象并且连接指定的服务器的地址（ip）和端口号(port)：socket.connect(inetSocketAddress)；
  2. 连接建立后，通过输出流向服务器端发送请求信息；
  3. 通过输入流获取服务器响应的信息；
  4. 关闭相关资源

3.同步阻塞模型（BIO）
同步阻塞IO模型是最简单的IO模型，用户线程在内核进行IO操作时如果数据没有准备好会被阻塞。Java中的阻塞模式BIO，就是在java.net包中的Socket套接字的实现，Socket套接字是TCP/UDP等传输层协议的实现。

BIO特点：

  1. 一个线程负责连接，多线程则为每一个接入开启一个线程；
  2. 一个请求一个应答；
  3. 请求之后应答之前客户端会一直等待（阻塞）。

（二）同步非阻塞的模型（Non-Blocking IO）

NIO的特性
NIO 提供了与传统 BIO 模型中的 Socket和 ServerSocket 相对应的SocketChannel 和ServerSocketChannel两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模式：

  • 阻塞模式 : 基本不会被使用到。使用起来就像传统的网络编程一样，比较简单，但是性能和可靠性都不好。对于低负载、低并发的应用程序，勉强可以用一下以提升开发速率和更好的维护性;
  • 非阻塞模式 ： 与阻塞模式正好相反，非阻塞模式对于高负载、高并发的（网络）应用来说非常友好，但是编程麻烦，这个是大部分人诟病的地方。所以， 也就导致了 Netty 的诞生。

（三）Netty

Netty的简介

  1. Netty 是一个基于 NIO 的 client-server(客户端服务器)框架，使用它可以快速简单地开发网络应用程序。
    它极大地简化并简化了 TCP 和 UDP 套接字服务器等网络编程,并且性能以及安全性等很多方面甚至都要更好。
  2. 支持多种协议如 FTP，SMTP，HTTP 以及各种二进制和基于文本的传统协议。
  3. 用官方的总结就是：Netty 成功地找到了一种在不妥协可维护性和性能的情况下实现易于开发，性能，稳定性和灵活性的方法。

Netty的特点

  • 统一的 API，支持多种传输类型，阻塞和非阻塞的；
  • 简单而强大的线程模型；
  • 自带编解码器解决 TCP 粘包/拆包问题；
  • 自带各种协议栈；
  • 真正的无连接数据包套接字支持；
  • 比直接使用 Java 核心 API 有更高的吞吐量、更低的延迟、更低的资源消耗和更少的内存复制；
  • 安全性不错，有完整的 SSL/TLS 以及 StartTLS 支持；
  • 社区活跃；
  • 成熟稳定，经历了大型项目的使用和考验，而且很多开源项目都使用到了 Netty 比如我们经常接触的Dubbo、RocketMQ 等等。

Netty的作用

  1. 作为 RPC 框架的网络通信工具；
  2. 实现一个自己的 HTTP 服务器；
  3. 实现一个即时通讯系统；
  4. 消息推送系统。

二、IO实例

1.新建服务器端
请添加图片描述
请添加图片描述
新建Java类为server

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class server {
    public static void main(String[] args) throws IOException {
        //创建客户端的Socket对象(SevereSocket)
        //ServerSocket (int port)创建绑定到指定端口的服务器套接字
        ServerSocket ss=new ServerSocket(50000);

        //Socket accept()侦听要连接到此套接字并接受他
        Socket s=ss.accept();

        //获取输入流，读数据，并把数据显示在控制台
        InputStream is=s.getInputStream();
        byte[] bys=new byte[1024];
        int len=is.read(bys);
        String data=new String(bys,0,len);
        System.out.println("数据是："+data);

        //释放资源
        s.close();
        ss.close();
    }
}

如下所示
请添加图片描述
2.新建客户端
步骤同上，新建项目名称改为IOclient，类名改为client
如下所示
请添加图片描述
编译并同时运行服务端和客户端
结果如下
请添加图片描述

三、NIO实例

服务器端
名称改为NIOserver，代码如下

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 NIOserver {
    //网络通信IO操作，TCP协议，针对面向流的监听套接字的可选择通道（一般用于服务端）
    private ServerSocketChannel serverSocketChannel;
    private Selector selector;

    /*
     *开启服务端
     */
    public void start(Integer port) throws Exception {
        serverSocketChannel = ServerSocketChannel.open();
        selector = Selector.open();
        //绑定监听端口
        serverSocketChannel.socket().bind(new InetSocketAddress(port));
        //设置为非阻塞模式
        serverSocketChannel.configureBlocking(false);
        //注册到Selector上
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        startListener();
    }
    private void startListener() throws Exception {
        while (true) {
            // 如果客户端有请求select的方法返回值将不为零
            if (selector.select(1000) == 0) {
                System.out.println("current not exists task");
                continue;
            }
            // 如果有事件集合中就存在对应通道的key
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            // 遍历所有的key找到其中事件类型为Accept的key
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                if (key.isAcceptable())
                    handleConnection();
                if (key.isReadable())
                    handleMsg(key);
                iterator.remove();
            }
        }
    }
    /**
     * 处理建立连接
     */
    private void handleConnection() throws Exception {
        SocketChannel socketChannel = serverSocketChannel.accept();
        socketChannel.configureBlocking(false);
        socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
    }
    /*
     * 接收信息
     */
    private void handleMsg(SelectionKey key) throws Exception {
        SocketChannel channel = (SocketChannel) key.channel();
        ByteBuffer attachment = (ByteBuffer) key.attachment();
        channel.read(attachment);
        System.out.println("current msg: " + new String(attachment.array()));
    }

    public static void main(String[] args) throws Exception {
        NIOserver myServer = new NIOserver();
        myServer.start(8888);
    }
}

如下所示
请添加图片描述
客户端
名称改为NIO，代码如下

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class NIOclient {
    public static void main(String[] args) throws Exception {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);

        // 连接服务器
        if (!socketChannel.connect(new InetSocketAddress("127.0.0.1", 8888))) {
            while (!socketChannel.finishConnect()) {
                System.out.println("connecting...");
            }
        }
        //发送数据
        String str = "hello netty";
        ByteBuffer byteBuffer = ByteBuffer.wrap(str.getBytes());
        socketChannel.write(byteBuffer);
        System.in.read();
    }
}

如下所示
请添加图片描述
编译并同时运行
请添加图片描述

四、Netty实例

服务器端
改名为Nettyserver
导入Netty框架依赖
请添加图片描述
请添加图片描述
输入io.netty:netty-all进行搜索
请添加图片描述
请添加图片描述
请添加图片描述
代码如下：

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import java.net.InetSocketAddress;

/**
 *
 */
public class Nettyserver {

    private int port;

    public static void main(String[] args){
        new Nettyserver(18080).start();
    }

    public Nettyserver(int port) {
        this.port = port;
    }

    public void start() {
        /**
         * 创建两个EventLoopGroup，即两个线程池，boss线程池用于接收客户端的连接，
         * 一个线程监听一个端口，一般只会监听一个端口所以只需一个线程
         * work池用于处理网络连接数据读写或者后续的业务处理（可指定另外的线程处理业务，
         * work完成数据读写）
         */
        EventLoopGroup boss = new NioEventLoopGroup(1);
        EventLoopGroup work = new NioEventLoopGroup();
        try {
            /**
             * 实例化一个服务端启动类，
             * group（）指定线程组
             * channel（）指定用于接收客户端连接的类，对应java.nio.ServerSocketChannel
             * childHandler（）设置编码解码及处理连接的类
             */
            ServerBootstrap server = new ServerBootstrap()
                    .group(boss, work).channel(NioServerSocketChannel.class)
                    .localAddress(new InetSocketAddress(port))
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline()
                                    .addLast("decoder", new StringDecoder())
                                    .addLast("encoder", new StringEncoder())
                                    .addLast(new HelloWorldServerHandler());
                        }
                    });
            //绑定端口
            ChannelFuture future = server.bind().sync();
            System.out.println("server started and listen " + port);
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            boss.shutdownGracefully();
            work.shutdownGracefully();
        }
    }

    public static class HelloWorldServerHandler extends ChannelInboundHandlerAdapter {

        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            System.out.println("HelloWorldServerHandler active");
        }

        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            System.out.println("server channelRead..");
            System.out.println(ctx.channel().remoteAddress()+"->Server :"+ msg.toString());
            ctx.write("server write"+msg);
            ctx.flush();
        }
    }
}

如下所示
请添加图片描述

服务端
改名为Nettyclient，导包步骤相同
代码如下

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
/**
 *
 */
public class Nettyclient {
    private static final String HOST = "localhost";
    private static final int PORT= 18080;

    public static void main(String[] args){
        new Nettyclient().start(HOST, PORT);
    }

    public void start(String host, int port) {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap client = new Bootstrap().group(group).channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY, true).handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline()
                                    .addLast("decoder", new StringDecoder())
                                    .addLast("encoder", new StringEncoder())
                                    .addLast(new HelloWorldClientHandler());
                        }
                    });
            ChannelFuture future = client.connect(host, port).sync();
            future.channel().writeAndFlush("Hello Netty Server ,I am a netty client");
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            group.shutdownGracefully();
        }
    }

    public static class HelloWorldClientHandler extends ChannelInboundHandlerAdapter {
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            System.out.println("HelloWorldClientHandler Active");
        }

        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            System.out.println("HelloWorldClientHandler read Message:"+msg);
        }
    }
}

如下所示
请添加图片描述
编译并同时运行
请添加图片描述

参考

从 BIO、NIO 聊到 Netty，最后还要实现个 RPC 框架！
基于IO、NIO、Netty的TCP聊天程序

举报

相关推荐

数据技术进化史：从数据仓库到数据中台再到数据飞轮

数据数据仓库数据管理大数据从数据仓库到数据中台再到数据飞轮，我了解的数据技术进化史

数据技术进化史：从数据仓库到数据中台再到数据飞轮的旅程

数据数据仓库数据中台数据飞轮百度大数据从数据仓库到数据中台再到数据飞轮，我了解的数据技术进化史

Java进化史：从Java 8到Java 17的语言特性全解析

java开发语言JavaAPIHTTPPython后端开发

从数据仓库到数据中台再到数据飞轮：我了解的数据技术进化史​

数据数据仓库数据驱动大数据从数据仓库到数据中台再到数据飞轮，我了解的数据技术进化史

从数据仓库到数据中台再到数据飞轮：社交媒体的数据技术进化史

ssh运维

从数据仓库到数据中台再到数据飞轮：金融行业的数据技术进化史

数据数据仓库迭代大数据从数据仓库到数据中台再到数据飞轮，我了解的数据技术进化史

从数据仓库到数据中台再到数据飞轮：数据技术进化史与未来展望

数据数据仓库结构化Java后端开发数据中台过时了？为什么现在都在说数据飞轮？

从数据仓库到数据中台再到数据飞轮，我了解的数据技术进化史

数据数据仓库数据驱动大数据从数据仓库到数据中台再到数据飞轮，我了解的数据技术进化史

加密世界的进化史

区块链

JAVA中容器设计的进化史：从白盒到黑盒，再到跻身为设计模式之一的迭代器

java迭代器循环遍历容器Java编程语言yyds干货盘点
0 条评论