程序员潇然-疯狂的字节X»论坛 › 技术专栏 › 框架与中间件 › 网络模型简介以及阻塞和非阻塞编程示例（三） ...

[Netty] 网络模型简介以及阻塞和非阻塞编程示例（三）

框架与中间件 框架与中间件 7574 人阅读 | 0 人回复

一般情况下的文件读写，虽然之前的BIO较慢，但是大多数场景也基本没啥问题。

但是面对网络IO，动辄数万、十万、百万的并发来说，显然已经可以称之为不可用状态。

所以java很早前就推出了NIO，用来解决这个问题。

本文主要在重提一下阻塞的网络编程，然后在于NIO的实现进行对比。

通俗的说，网络编程就是把数据从一台计算机传输到另一台计算机，这中间需要经过各种中间设备（比如路由器、交换机），也会经过各种软件进行处理加工。 关于计算机网络的发展，可以参考专栏《计算机网络》https://www.crazybytex.com/collection-2.html

网络编程简介

看下百度百科介绍：

image.png

众所周知，计算机网络的TCP/IP协议，已经是事实上的标准，所有的操作系统，都提供了底层支持，对于开发人员来说，就是基于操作系统提供的系统调用进行编程，然而TCP/IP协议，较为复杂，比较偏向于底层，所以有了后来的socket，简化了网络编程的复杂度。

SOCKET编程

socket本质是编程接口（API），对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口。 不管是什么协议，从程序的角度看，就是一行行代码的实现，通过一系列代码的组合实现了某种功能，遵守了某些规则的程序。 如同我们平时写代码封装了类库，提供了一系列的接口可以被调用，socket编程的本质就是如此。 这样对于普通的开发来说就不需要过多的涉猎底层网络传输的内容，可以更加高效的专注于应用程序的开发。

从网络编程的视角看，一台计算机的结构大致如下：

image.png

现代计算机，肯定是都依赖操作系统的，而操作系统提供了两类接口： 人机交互，比如控制台输入，鼠标点击 编程接口，系统调用函数，供用户开发程序调用系统资源以及管理硬件

socket就是编程接口的一部分，用来网络编程。

tcp网络编程一个概要示意图如下

image.png

服务端和客户端初始化 socket，得到文件描述符；
服务端调用 bind，将绑定在 IP 地址和端口;
服务端调用 listen，进行监听；
服务端调用 accept，等待客户端连接；

客户端调用 connect，向服务器端的地址和端口发起连接请求；
服务端 accept 返回用于传输的 socket 的文件描述符；
客户端调用 write 写入数据；服务端调用 read 读取数据；

再详细点说的话，看下UNIX网络编程 接口：

#include <sys/socket.h>
int bind(int sockfd, const struct sockaddr *myaddr, socklen_t addrlen);

sockfd是由socket函数返回的套接口描述字，第二个参数是一个指向特定于协议的地址结构的指针，第三个参数是该地址结构的长度 调用bind 可以指定ip和端口号，也可以不指定

#include <sys/socket.h>
int connect(int sockfd, const struct sockaddr *servaddr, socklen_t addrlen);

sockfd是由socket函数返回的套接口描述字，第二、第三个参数分别是一个指向套接口地址结构的指针和该结构的大小。 套接口地址结构必须含有服务器的IP地址和端口号

如果是TCP套接字，调用connect 将会触发三次握手的过程。

#include <sys/socket.h>
int listen(int sockfd, int backlog);

sockfd是bind之后的套接口描述字，第二个参数规定了内核应该为相应套接口排队的最大连接个数

当socket创建时，默认是主动套接字-也就是将会调用connect发起连接的套接字，调用listen那么将会转换为被动套接字，也就是接受指向该连接的套接字

#include <sys/socket.h>
int accept(int sockfd, struct sockaddr *cliaddr, socklen_t *addrlen);

//返回：非负描述子——成功，-1——出错

参数sockfd是监听后的套接字，这个套接字用来监听一个端口，当有一个客户与服务器连接时，它使用一个与这个套接字关联的端口号

参数cliaddr和addrlen是一个结果参数，用来返回已连接客户的协议地址。 如果accept调用成功，那么其返回值是由内核自动生成的一个全新描述符，代表与客户端的连接

socket是一种网络通信模型，与我们常说的同步异步 阻塞非阻塞式没有直接关系的

因为他作为编程接口，底层都有各自的实现，不需要自己单独进行实现

image.png

简化以下形式如下

image.png

上图就是现在大家进行网络编程的一个通常的模型。 分为客户端和服务端，客户端与服务端建立连接之后，客户端发起请求，服务端返回响应。

对于java开发来说，一个简易的socket编程如下

package com.crazybytex.hello.socket;


import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;


/**
* @description server
* @Author 本文作者 程序员潇然 疯狂的字节X https://www.crazybytex.com/
* @Date 11:59 2022/7/4
**/
public class SocketServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = null;
        Socket socket = null;
        Reader reader = null;
        OutputStream os = null;
        PrintWriter pw = null;
        try {
            //1、创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并监听此端口
            //1024-65535的某个端口
            serverSocket = new ServerSocket(9527);
            //2、调用accept()方法开始监听，等待客户端的连接
            socket = serverSocket.accept();
            //3、获取输入流，并读取客户端信息
            reader = new InputStreamReader(socket.getInputStream());
            char chars[] = new char[1024];
            int len;
            String strClient = "";
            while ((len = reader.read(chars)) != -1) {
                strClient = new String(chars, 0, len);
                System.out.println("Receive from client message=: " + strClient);
            }
            //关闭输入流
            socket.shutdownInput();
            //4、获取输出流，响应客户端的请求
            os = socket.getOutputStream();
            pw = new PrintWriter(os);
            pw.write("Hello client ,response from server");
            pw.flush();
            //5、关闭资源
            pw.close();
            os.close();
            reader.close();
            socket.close();
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }


    }
}
package com.crazybytex.hello.socket;


import java.io.*;
import java.net.Socket;


/**
* @description client
* @Author 本文作者 程序员潇然 疯狂的字节X https://www.crazybytex.com/
* @Date 11:59 2022/7/4
**/
public class SocketClient {


    public static void main(String[] args) {
        try {
            //1、创建客户端Socket，指定服务器地址和端口
            Socket socket = new Socket("127.0.0.1", 9527);
            //2、获取输出流，向服务器端发送信息
            //字节输出流
            OutputStream os = socket.getOutputStream();
            //将输出流包装成打印流
            PrintWriter pw = new PrintWriter(os);
            pw.write("hello server ,i'm client");
            pw.flush();
            socket.shutdownOutput();


            //3、获取输入流，并读取服务器端的响应信息
            InputStream is = socket.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String info = null;
            while ((info = br.readLine()) != null) {
                System.out.println("Receive from server message=: " + info);
            }


            //4、关闭资源
            br.close();
            is.close();
            pw.close();
            os.close();
            socket.close();
        } catch (IOException e) {
            System.out.println(e);
        }
    }
}

image.png

image.png

image.png

值得注意的是，如果在如图所示位置加断点

image.png

server启动后，并不会走到断点，当有客户端连接发送数据时，才会走到断点 这也说明了 accept方法是一个阻塞方法。

image.png

对于java中的socket编程，核心概念如上图所示，基于请求响应模式 服务端监听端口，等待远程连接 客户端根据远程服务器的ip地址以及端口号，发起连接 建立连接后，基于流，进行请求和响应。

socket是应用层与传输层之间的编程接口，socket就是对底层函数的封装，java是面向对象的编程语言 所以java中的socket就是对这些方面的一个抽象

一种通俗的网络编程模式如下图所示，通道不仅限于InputStream 和OutputStream ，随着java的发展，随之而来的还有Channel 换句话说，大致的网络编程模型是基本固定的，而变化的是IO的具体处理

image.png

介绍了阻塞式的网络编程，下面展示一个非阻塞的。

示例代码gitee:

https://gitee.com/crazybytex/java-code-fragment/tree/master/src/main/java/com/crazybytex/fragment/nio

package com.crazybytex.fragment.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.nio.charset.StandardCharsets;
import java.util.Iterator;
import java.util.Set;

/**
 * @Author 本文作者 程序员潇然 疯狂的字节X https://www.crazybytex.com/
 * @Date 2022/10/10 14:41
 * @Description TODO
 **/
public class Server {
    public static void main(String[] args) throws IOException, InterruptedException {

        //1.打开一个服务器通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

        //2.绑定对应的端口号
        serverSocketChannel.bind(new InetSocketAddress(8888));

        //3.通道默认是阻塞的，需要设置为非阻塞
        serverSocketChannel.configureBlocking(false);

        //4.创建选择器
        Selector selector = Selector.open();

        //5.将服务器通道注册到选择器上，并且指定注册监听事件为OP_ACCEPT
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("服务端启动成功!");

        while (true) {
            //6.检查选择器是否有事件
            int select = selector.select(2000);
            if (select == 0) {
                continue;
            }

            //7.获取事件集合
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()) {
                //8.判断事件是否是客户端连接事件SelectionKey.isAcceptable()
                SelectionKey key = iterator.next();

                //9.得到客户端通道，并将通道注册到选择器上，并且指定监听事件为OP_READ
                if (key.isAcceptable()) {
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    System.out.println("客户端已连接......" + socketChannel);

                    //必须设置通道为非阻塞, 因为selector需要轮询监听每个通道的事件
                    socketChannel.configureBlocking(false);

                    //并指定监听事件为OP_READ
                    socketChannel.register(selector, SelectionKey.OP_READ);
                }

                //10.判断是否是客户端读就绪事件SelectionKey.isReadable()
                if (key.isReadable()) {

                    //11.得到客户端通道,读取数据到缓冲区
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                    int read = socketChannel.read(byteBuffer);
                    if (read > 0) {
                        System.out.println("客户端消息:" +
                                new String(byteBuffer.array(), 0, read,
                                        StandardCharsets.UTF_8));

                        //12.给客户端回写数据
                        socketChannel.write(ByteBuffer.wrap("收到消息了".getBytes(StandardCharsets.UTF_8)));
                        socketChannel.close();
                    }
                }

                //13.从集合中删除对应的事件, 因为防止二次处理.
                iterator.remove();
            }
        }
    }

}

package com.crazybytex.fragment.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;

/**
 * @Author 本文作者 程序员潇然 疯狂的字节X https://www.crazybytex.com/
 * @Date 2022/10/10 14:41
 * @Description TODO
 **/
public class Client {
    public static void main(String[] args) throws IOException {
        //1.打开通道
        SocketChannel socketChannel = SocketChannel.open();

        //2.设置连接IP和端口号
        socketChannel.connect(new InetSocketAddress("127.0.0.1", 8888));

        //3.写数据
        socketChannel.write(ByteBuffer.wrap("服务端你好".getBytes(StandardCharsets.UTF_8)));

        //4.读取服务器写回的数据
        ByteBuffer readBuffer = ByteBuffer.allocate(1024);
        int read = socketChannel.read(readBuffer);
        System.out.println("服务端返回消息：" + new String(readBuffer.array(), 0, read, StandardCharsets.UTF_8));

        //5.释放资源
        socketChannel.close();


    }

}

先运行server

image.png

在启动客户端

image.png

再看下服务端

image.png

从执行结果看，也没有多大区别，但是实现方式完全变化了。

ServerSocketChannel 绑定了本地的端口，并且注册到了Selector上
通过Selector可以获取事件集合，遍历这个集合可以获得就绪的事件
根据事件的类型，可以进行相关的处理逻辑。

不再是直接的通过socket建立连接后的单纯阻塞读取，演变成了基于事件驱动的模型。

抽象出来了Selector SelectionKey Channel 等概念，Channel 关联到Selector，注册绑定关注的SelectionKey（事件），当事件产生响应时，就会获得相应的回调（也就是进入了相关事件的处理逻辑），这样不需要关注过程，只需要写相关的处理逻辑即可。

这是过程就是事件注册与处理结果回调，这个与前面提到的IO多路复用是不是有点类似呢？

毕竟上层应用，不需要关注底层，只需要关注事件的注册以及相关事件的处理即可。

后续展开介绍网络编程模型。

common_log.png 转载务必注明出处：程序员潇然，疯狂的字节X，https://crazybytex.com/thread-202-1-1.html

关注下面的标签，发现更多相似文章
Netty
NIO

文章被以下专栏收录:

上一篇: 深入分析select、poll、epoll模型 （二）
下一篇: 网络编程模型 Reactor设计模式(四)
返回列表
    黄小斜学Java

    疯狂的字节X

  • 目前专注于分享Java领域干货，公众号同步更新。原创以及收集整理，把最好的留下。
    包括但不限于JVM、计算机科学、算法、数据库、分布式、Spring全家桶、微服务、高并发、Docker容器、ELK、大数据等相关知识，一起进步，一起成长。
公众号 加微信 EMail 捐助我
Links
微博 知乎 Github gitee
热门推荐
海康摄像头接入 wvp-GB28181-pro平台测试验
[md]### 简介 开箱即用的28181协议视频平台 `https://github.c
[CXX1300] CMake '3.18.1' was not
[md][CXX1300] CMake '3.18.1' was not found in SDK, PATH, or
[若依]微服务springcloud版新建增添加一个
[md]若依框架是一个比较出名的后台管理系统，有多个不同版本。
网站地图

专注于分享计算机相关技术，目前专注于Java领域。
网络上充斥着海量资料信息，而我们却越来越难以找到合适的资料。
希望通过留下自己的一份成长路线，既可以巩固自己所学，也可以照亮他人~

关注公众号

加我的微信

微信捐助我

支付宝捐助我

版权所有 © 疯狂的字节X （ 程序员潇然） 工商网监认证苏公网安备 32011502011619号 苏ICP备2022021582号-1