网络编程套接字

最新推荐文章于 2024-06-13 19:48:05 发布

银河罐头

最新推荐文章于 2024-06-13 19:48:05 发布

阅读量2.4k

点赞数 10

分类专栏： JavaEE初阶文章标签：网络 udp tcp/ip

本文链接：https://blog.csdn.net/qq_63983125/article/details/128884073

版权

JavaEE初阶专栏收录该内容

23 篇文章 20 订阅

订阅专栏

✏️作者：银河罐头
📋系列专栏：JavaEE

🌲“种一棵树最好的时间是十年前，其次是现在”

Socket 套接字

网络编程这里的核心，Socket API，操作系统给应用程序提供的网络编程 API。

可以认为 Socket API 是和传输层密切相关的。

传输层里提供了两个最核心的协议，UDP 和 TCP。因此 Socket API 也提供了两种风格，UDP 和 TCP

UDP 和 TCP

简单认识下 UDP 和 TCP

UDP ：无连接不可靠传输面向数据报全双工

TCP ：有连接可靠传输面向字节流全双工

什么是有连接？什么是无连接？

打电话就是有连接的，需要建立连接才能通信，建立连接需要对方"接受"

发短信/微信就是无连接的，直接发就行了

什么是可靠传输？什么是不可靠传输？

网络环境天然是复杂的，不可能保证传输的数据 100% 都能到达。发送方能知道自己的消息是不是发过去了，还是丢了。

打电话是可靠传输，发短信/微信是不可靠传输(带有已读功能的是可靠传输，比如钉钉)

可靠不可靠和有没有连接没有任何关系

面向字节流 && 面向数据报

面向字节流：数据传输就和文件读写类似，"流式"的

面向数据报：数据传输则以一个一个的"数据报"为基本单位(一个数据报可能是若干个字节，带有一定格式的)

全双工

一个通信通道，可以双向传输(既可以发送，也可以接收)

为啥 TCP 和 UDP 都是全双工呢？

一根网线里有 8 根线

UDP数据报套接字编程

DatagramSocket API

DatagramSocket 使用这个类表示一个 Socket 对象。在操作系统中也是把这个对象当成是一个文件处理的，相当于是文件描述符表上的某一项。

普通的文件对应的硬件设备是硬盘；socket 文件对应的硬件设备是网卡。

一个 Socket 对象就可以和另外一台主机进行通信了，如果要和多个不同的主机进行通信，就要有多个 socket 对象。

DatagramSocket 构造方法：

DatagramSocket() 没有指定端口，系统则会自动分配一个空闲的端口
DatagramSocket(int port) 这个版本是要传入一个端口号，此时就是让当前的这个 socket 对象和指定的端口(简单的整数)关联起来。

端口号用来标识主机上不同的应用程序

本质上不是进程和端口建立联系，而是进程里的 socket 对象和端口建立了联系

DatagramSocket 方法：

DatagramPacket 表示 UDP 中传输的一个报文，构造这个对象可以指定一些具体的数据进去。

void receive(DatagramPacket p) 此时传入的相当于是一个空的对象，receive 方法内部会对这个空对象进行内容填充，从而构造出结果数据了。这里的参数也是一个"输出型参数"
void send(DatagramPacket p)
void close() 释放资源，用完之后记得关闭

DatagramPacket API

DatagramPacket 构造方法：

DatagramPacket(byte[] buf, int length) 把 buf 这个缓冲区给设置进去了

DatagramPacket(byte[] buf, int offset, int length, SocketAddress address) 构造缓冲区 + 地址

SocketAddress 使用这个类表示 IP + 地址

DatagramPacket 方法：

InetAddress getAddress()

int getPort()

byte[] getData()

UdpEchoServer

编写一个最简单的 UDP 版本的客户端服务器程序，称之为回显服务器(echo server)

一个普通的服务器：收到请求，根据请求计算响应(业务逻辑)，返回响应；

echo server 省略了其中的"根据请求计算响应"，请求是啥就返回啥(这个代码没有实际的业务，这个代码也没啥作用和意义，只是展示了 socket api 的基本用法)

作为一个真正的服务器，"根据请求计算响应"这个环节是最重要的

举个栗子🌰：你去一家餐馆，点一份蛋炒饭，跟老板说"老板，我要一份蛋炒饭"，老板把饭炒好以后，给你端上来一份蛋炒饭，其中制作蛋炒饭的过程是最困难的，你点餐和老板给你把饭端上来这两个动作都是简单的

//UDP 版本的回显服务器
public class UdpEchoServer {
    //网络编程，本质上是要操作网卡
    //但是网卡不方便直接操作，在操作系统内核中华，使用了一种特殊的叫做 "socket"这样的文件来操作网卡
    //因此进行网络通信，首先得要有一个 socket 对象
    private DatagramSocket socket = null;
    //对于服务器来说，创建 socket 对象的同时要给他绑定上一个具体的端口号
    //服务器一定要关联上一个具体的端口
    //因为在网络传输中，服务器是被动的一方，如果是操作系统随机分配的端口，那么客户端就不知道端口是啥了，也就无法进行通信了
    public UdpEchoServer(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }
    public void start() throws IOException {
        System.out.println("服务器启动");
        //服务器不是只给一个客户端提供服务就完了，需要服务很多客户端
        while(true){
            //只要有客户端过来，就可以提供服务
            //1.读取客户端发来的请求是啥
            // receive 方法的参数是一个输出型参数，需要先构造好一个空白的 DatagramPacket 对象，发给 receive 进行填充
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
            socket.receive(requestPacket);
            //此时这个 DatagramPacket 是一个特殊的对象，并不方便直接进行处理，可以把这里包含的数据拿出来，构造成一个字符串
            String request = new String(requestPacket.getData(),0,requestPacket.getLength());
            //2.根据请求计算响应，由于这里是回显服务器，请求和响应相同
            String response = process(request);
            //3.把响应协会到客户端,send的参数也是一个 DatagramPacket,需要把这个 Packet 对象给构造好
            //此处这里的响应对象，不能是空的字节数组构造了，而是要使用响应数据来构造
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,requestPacket.getSocketAddress());
            socket.send(responsePacket);
            //4.打印一下，当前这次请求响应的处理中间结果
            System.out.printf("[%s:%d] req: %s;resp: %s\n",requestPacket.getAddress().toString(),requestPacket.getPort(),request,response);
        }
    }
    //这个方法就表示根据请求计算响应
    public String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        //端口号可以在 1024 ~ 65535 里任意指定一个
        UdpEchoServer server = new UdpEchoServer(9090);
        server.start();
    }
}

关于服务器一定要关联上一个具体的端口这一点

举个栗子🌰：假设我在某学校三食堂 5 号窗口，租了个店面，卖肉夹馍。

此时的三食堂就相当于我的 IP 地址，5 号窗口相当于我的端口号。我开了个餐厅，相当于我搭起了个服务器。

如果我作为一个服务器，我是一个随机端口，会有啥效果？(如果不是固定端口)。每次服务器启动就是一个不同的端口了。

有顾客觉得好吃下一回再来这个5号窗口时，发现不卖肉夹馍了?!

因此作为服务器得固定端口，才方便客户端找到我

对于 UDP 来说，传输数据的基本单位，DatagramPacket

receive 内部会针对参数对象填充数据，填充的数据来自网卡。

服务器的工作流程：

1.读取请求并解析

2.根据请求计算响应

3.构造响应发给对应的客户端

UdpEchoClient

public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String serverIP = null;
    private int serverPort = 0;
    //一次通信需要 2 个 IP ，2 个端口
    //客户端的 IP 是 127.0.0.1 已知的
    //客户端的端口是系统分配的
    //服务器的 IP 和端口需要告诉客户端，才能顺利把消息发给服务器
    public UdpEchoClient(String serverIP,int serverPort) throws SocketException {
        socket = new DatagramSocket();
        this.serverIP = serverIP;
        this.serverPort = serverPort;
    }
    public void start(){
        System.out.println("客户端启动");
        while(true){
            //1.从控制台读取要发送的数据
            System.out.print("> ");
            String request = scanner.next();
            if(request.equals("exit")){
                System.out.println("goodbye");
                break;
            }
            //2.构造成 UDP 请求并发送
            //构造这个 Packet 的时候，需要把 serverIP和 Port 都传入过来，但是此处的 IP 地址需要填写的是一个 32 位的整数形式，
            //上述 IP 地址是一个字符串，需要使用 InetAddress.getByName()来做一个转换
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,
                    InetAddress.getByName(serverIP),serverPort);
            socket.send(requestPacket);
            //3.读取 UDP 的响应并解析
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(),0,responsePacket.getLength());
            //4.把解析好的结果显示出来
            System.out.println(response);
        }
    }
    public static void main(String[] args) throws IOException {
        UdpEchoClient udpEchoClient = new UdpEchoClient("127.0.0.1",9090);
        udpEchoClient.start();
    }
}

构造这个 socket 对象，不需要显示的绑定一个端口，让操作系统自动分配一个端口

对于服务器来说，端口必须是确定好的；

对于客户端来说，端口可以是系统分配的。

服务器的端口是要固定指定的：目的是为了方便客户端找到服务器程序

客户端的端口是由系统随机分配的：如果手动指定，可能会和客户端其他程序的端口冲突(服务器上面的程序可控，客户端是运行在用户电脑上，环境更复杂，不可控)

127.0.0.1 => 32位的整数(给计算机看的)

=> 点分十进制(给人看的)

每个部分是 0 ~ 255 一个字节

服务器 - 客户端交互执行过程：

1.一定是服务器先启动，服务器运行到 receive() 阻塞

2.客户端读取用户输入的内容

3.客户端发送请求

4.客户端阻塞等待响应过来；服务器收到请求，从阻塞中返回。

5.服务器根据请求计算响应

6.服务器发送响应

7.客户端从阻塞中返回，读到响应了

启动服务器，客户端

在 IDEA 上可以手动设置打开多个客户端，让服务器同时和多个客户端进行通信

、

每次点运行都是创建了一个客户端进程。

当前的服务器和客户端的程序，都是在自己的本机上跑的。而实际上网络存在的意义是跨主机通信。当前按这个程序可以做到跨主机通信。

举个栗子🌰：如果张三(服务器)在北京，李四(客户端)在南京。李四想要和张三实现网络通信，不可行。因为张三的电脑没有外网IP，只能在局域网内部进行访问，除非李四到张三家里才可以和张三通信。

不过，李四可以连上"云服务器"(有外网 IP)这样的特殊的电脑，任何一个连上网络的设备都能访问。

UdpDictServer

回显服务器缺少业务逻辑，在上述代码的基础上稍作调整，实现一个"查词典"的服务器。(英文翻译成中文)

package network;
import java.io.IOException;
import java.net.SocketException;
import java.util.HashMap;
import java.util.Map;

//对于 DictServer 来说，和 EchoServer 相比，大部分都是一样的，
// 主要是"根据请求计算响应"这一步不太一样
public class UdpDictServer extends UdpEchoServer{
    private Map<String,String> dict = new HashMap<>();
    public UdpDictServer(int port) throws SocketException {
        super(port);
        //给这个 Dict 设置下内容
        dict.put("cat","小猫");
        dict.put("dog","小狗");
        //这里可以无限多的设置键值对...
    }
    @Override
    public String process(String request){
        //查词典的过程
        return dict.getOrDefault(request,"当前单词没有查到结果！");
    }

    public static void main(String[] args) throws IOException {
        UdpDictServer udpDictServer = new UdpDictServer(9090);
        udpDictServer.start();
    }
}

端口冲突

一个端口只能被一个进程使用，如果有多个使用就不行。

前面的UdpEchoServer 和 UdpDictServer 端口都是 9090

UdpEchoServer server = new UdpEchoServer(9090);

UdpDictServer udpDictServer = new UdpDictServer(9090);

此时如果同时运行 UdpEchoServer 和 UdpDictServer 就会抛异常

TCP流套接字编程

TCP 提供的 API 主要是 2 个类。

ServerSocket API

ServerSocket : 专门给服务器使用的 Socket 对象

ServerSocket 构造方法：

ServerSocket(int port) ：创建一个服务端流套接字Socket，并绑定到指定端口
ServerSocket 方法：

Socket accept() ：开始监听指定端口（创建时绑定的端口），有客户端连接后，返回一个服务端Socket
对象，并基于该Socket建立与客户端的连接，否则阻塞等待。

TCP是有连接，此处的 accept() 相当于是"接电话"

Socket API

2)Socket : 既会给客户端使用，也会给服务器使用

注意，TCP不需要一个类来表示 “TCP 数据报”，因为 UDP 是以数据报为单位来传输的，而 TCP 是以字节为单位进行传输的

Socket 在服务器这边是由 accept() 返回的；

在客户端这边，代码里构造指定一个 IP 和端口号(此处的 IP 和端口是服务器的 IP 和端口)，有了这个信息就能和服务器建立连接了。

Socket 方法：

InputStream getInputStream() ：返回此套接字的输入流

OutputStream getOutputStream() ：返回此套接字的输出流

进一步通过 Socket 对象获取到内部的流对象，通过流对象来发送和接收

之前的文件操作是操作硬盘，这里是操作网卡，读网卡，写网卡。

TcpEchoServer

public class TcpEchoServer {
    private ServerSocket serverSocket = null;

    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }
    public void start() throws IOException {
        System.out.println("服务器启动");
        while (true){
            //使用 clientSocket 和具体的客户端进行交流
            Socket clientSocket = serverSocket.accept();
            //效果是建立连接，前提是有客户端来连接
            //客户端在构造 Socket 对象的时候指定服务器的 IP 和 端口
            //如果没有客户端来连接，就会阻塞
            processConnection(clientSocket);
        }
    }

    //使用这个方法来处理一个连接
    //这一个连接对应一个客户端，但是这里面可能涉及到多次交互
    private void processConnection(Socket clientSocket) {
        System.out.printf("[%s:%d] 客户端上线\n",clientSocket.getInetAddress().toString(),
                clientSocket.getPort());
        //基于上述 socket 对象和客户端进行通信
        try(InputStream inputStream = clientSocket.getInputStream();
                OutputStream outputStream = clientSocket.getOutputStream()){
            //由于要处理多个请求和响应，此处用 while 循环
            while(true){
                //1.读取请求
                Scanner scanner = new Scanner(inputStream);
                if(!scanner.hasNext()){
                    //没有下个数据说明读完了，(客户端关闭了连接)
                    System.out.printf("[%s:%d] 客户端下线!\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
                    break;
                }
                //next一直读到 换行/空格/空白符 结束，最终返回结果里不包换上述空白符
                String request = scanner.next();
                //2.根据请求构造响应
                String response = process(request);
                //3.返回响应结果
                //OutputStream 没有 write String 这样的功能，可以把 String 里面的字节数组拿出来，进行写入
                //也可以用字符流来转换一下
                PrintWriter printWriter = new PrintWriter(outputStream);
                //此处用 println 来写入，让结果中带有一个 \n 换行，方便对端来进行接收解析
                printWriter.println(response);
                //flush 来刷新缓冲区，保证当前写入的数据，确实是发送出去了
                printWriter.flush();
                System.out.printf("[%s:%d] req:%s res:%s",clientSocket.getInetAddress().toString(),
                                  clientSocket.getPort(),request,response);
            }
        }catch(IOException e){
            e.printStackTrace();
        }finally {
            //更合适的做法，是把 close 放到 finally 里面，保证他一定能够执行到
            try {
                clientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    private String process(String request) {
        return request;
    }
}

任意一个客户端连上来都会返回/创建一个 socket 对象，socket 就是文件，每次创建一个 clientSocket 对象，就要占用一个文件描述符表的位置，因此在使用完毕之后要释放。

前面的 UdpEchoServer 的 socket 没有手动释放，一方面是因为这些 socket 的生命周期更长(伴随整个程序)，另一方面是这些 socket 不多，固定数量。

而此处的 clientSocket ，数量多，每个客户端有一个，生命周期更短。

TcpEchoClient

public class TcpEchoClient {
    private Socket socket = null;
    public TcpEchoClient(String serverIp,int serverPort) throws IOException {
        //socket 构造方法 能够识别 点分十进制 的 IP地址，比 DatagramPacket 更方便
        //new 这个对象的同时就会进行 TCP 连接操作
        socket = new Socket(serverIp,serverPort);

    }
    public void start(){
        Scanner scanner = new Scanner(System.in);
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()){
            while(true){
                //1.先从键盘读取用户输入的内容
                System.out.print("> ");
                String request = scanner.next();
                if(request.equals("exit")){
                    System.out.println("goodbye");
                    break;
                }
                //2.把读到的内容构造成请求，发送给服务器
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(request);
                printWriter.flush();
                //3.读取服务器发来的响应
                Scanner respScanner = new Scanner(inputStream);
                String response = respScanner.next();
                //4.把响应内容打印到屏幕上
                System.out.println(response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException {
        TcpEchoClient client = new TcpEchoClient("127.0.0.1",9090);
        client.start();
    }
}

服务器同时连接多个客户端

当前代码中还有一个重要的问题：当前的服务器，同一时刻只能处理一个连接(只能给一个客户端提供服务)

当启动服务器之后，启动客户端1可以看到正常的上线提示；再启动客户端2此时发现没有任何提醒了。

客户端1给服务器发送消息正常，而客户端2发送消息则没有任何提示。

(相当于打电话占线了)

当客户端1退出之后，客户端2就可以正常发消息了。

针对 TcpEchoServer 里的代码而言，当客户端连上服务器之后，代码就执行到了 processConnection 这个方法的循环中，此时意味着只要processConnection 这个方法的循环不结束，processConnection 这个方法就结束不了，从而无法第二次调用 accept().

那如果 processConnection 里面不用循环可行吗？

不行，虽然不使用循环，读取请求的时候，可能会阻塞，(next一直读到空白符才结束)

//next一直读到 换行/空格/空白符 结束，最终返回结果里不包换上述空白符
String request = scanner.next();

这里的解决办法是可以采用多线程。

每次收到一个连接，就创建一个新线程，由这个新线程负责处理这个新的客户端。每个线程都是独立的执行流，每个独立的执行流是各自执行各自的逻辑，彼此之间是并发的逻辑，不会发生这边阻塞影响到另一边的情形。

public class TcpEchoServer {
   public void start() throws IOException {
        System.out.println("服务器启动");
        while (true){
            //使用 clientSocket 和具体的客户端进行交流
            Socket clientSocket = serverSocket.accept();
            Thread t = new Thread(()->{
                processConnection(clientSocket);
            });
            t.start();
        }
    }
}

如果客户端特别多，很多客户端频繁的来建立连接，就需要频繁创建/销毁线程了。此时就可以用线程池来做进一步的优化。

public void start() throws IOException {
        System.out.println("服务器启动");
        //此处使用 cachedThreadPool,使用 FixedThreadPool不太合适(线程数量不太应该是固定的)
        ExecutorService threadPool = Executors.newCachedThreadPool();
        while (true){
            //使用 clientSocket 和具体的客户端进行交流
            Socket clientSocket = serverSocket.accept();
            
            //使用线程池
            threadPool.submit(()->{
                processConnection(clientSocket);
            });
        }
    }

Tcp 中的长短连接

TCP有连接的场景下，针对连接这个概念有两种典型的表现形式。

1)短连接：客户端每次给服务器发消息，先建立连接，发送请求，读取响应，关闭连接，下次再发送则重新建立连接

2)长连接：客户端，建立连接之后，连接先不着急断开，然后再发送请求读取响应，再发送请求读取响应，若干轮之后，客户端确实短时间之内不再需要使用这个连接了，此时再断开。

C10M 问题

上述 TcpEchoServer 虽然是使用了线程池了，但是还不够。

如果客户端非常多，而且客户端连接都迟迟不断开，就会导致咱们的机器上有很多线程，如果一个服务器有几千个客户端就得是几千个线程，有几万个客户端，几万个线程…

这个事情对于机器来说是个很大的负担。

多开服务器是能解决这个问题，但是多开服务器意味着成本的增加。

是否有办法解决单机支持更大量客户端的问题呢？C10M 问题

C10K 问题：单机处理 1 w 个客户端

C10M 问题：单机处理 1kw 个客户端(1kw不是具体数量，只是为了描述比C10K多很多)

针对上述多线程的版本，最大问题是机器承担不了这么大的线程开销。

是否有办法让 1 个线程处理多个客户端的连接？

IO多路复用(IO多路转接)

举个栗子🌰：相当于一个人同时接 2 个电话，这2个电话传输过来的内容是有停顿的，IO过程中也会有等待，IO多路复用就是充分利用等待时间，做别的事。

比如生活中到饭点我去买饭，打算取买个饭再买杯奶茶再去取个快递，干这3件事，最省时间的做法是我先去买饭点好饭之后，利用这个等饭的时间取点杯奶茶，然后立马去取快递，这样做就充分利用了这个等待时间。

给这个线程安排个集合，这个集合就放了一堆连接，这个线程就负责监听这个集合，哪个连接有数据来了线程就来处理哪个连接。这个其实就应用了一个事实，虽然连接有很多，但是这些连接的请求并非严格意义的同时，总还是有间隔时间的。

在操作系统里，提供了一些原生 API：select , poll , epoll。在 Java 中，提供了一组 NIO 这样的类，就封装了上述多路复用的 API。