网络编程详解

喝养乐多长不高

于 2024-09-04 20:34:49 发布

阅读量436

点赞数 18

文章标签：网络服务器运维 java 网络编程 TCP UDP

本文链接：https://blog.csdn.net/hyldzbg/article/details/141642577

版权

什么是网络编程

网络编程，指网络上的主机，通过不同的进程，以编程的方式实现网络通信（或称为网络数据传输）

发送端和接收端

发送端：数据的发送方进程，称为发送端。发送端主机即网络通信中的源主机。
接收端：数据的接收方进程，称为接收端。接收端主机即网络通信中的目的主机。

//注意：发送端和接收端只是相对的，只是一次网络数据传输产生数据流向后的概念

socket套接字

Socket套接字针对传输层协议主要划分为如下:

流套接字：传输层TCP协议

TCP协议特点：

有链接
可靠传输
面向字节流
有接收缓冲区和发送缓冲区
大小不限

数据报套接字：传输层UDP协议

UDP协议特点：

无连接
不可靠传输
面向数据报
有接收缓冲区无发送缓冲区
大小首先一次最多64kb

对于数据报来说，可以简单的理解为，传输数据是一块一块的，发送一块数据假如100个字节，必须一次发送，接收也必须一次接收100个字节，而不能分100次，每次接收1个字节。

TCP和UDP的区别

TCP是有连接的UDP是无连接的

连接：是一种抽象的概念，本质上就是建立连接的双方，各自保存对方的信息。

TCP想要通信，就需要先建立连接，做完之后，才能进行后续通信，如果A想要和B建立连接，但是B拒绝了，通信就无法完成。

UDP想要通信就直接发送数据即可，不需要征得对方的同意UDP自身也不会保存对方的信息(UDP不知道但是写程序的人自己要知道，UDP自己不会保存，在调用UDP的socket api时要把对方的位置啥的传过去

TCP是可靠传输的，UDP是不可靠传输的

注意：在网上进行通信发送一个信息，这个消息是不可能做到100%送达的，所谓的可靠传输也是退而求其次，A向B发消息，消息是不是到达B这一方，A是可以知道的，如果传输失败，就可以才需一定的措施（比如重传之类的）

TCP是面向字节流的，UDP是面向数据报的

这个字节流和文件操作的字节流是一个意思，TCP也是和文件操作一样，以字节为单位来进行传输，UDP则是按照数据报(有严格的格式)为单位，来进行传输的

TCP和UDP都是全双工的

一个通信道路，允许双向通信，就是全双工，一个通信道路，只能单向通信，就是半双工，代码中使用一个Socket对象，就可以发送数据也能接收数据。

UDPapi的使用

使用DatagramPacket这个类来表示一个UDP数据报，每次进行传输都要以UDP数据报为基本单位

DatagramPacket 构造方法：

方法签名	方法说明
DatagramPacket(byte[] buf, int length)	构造一个DatagramPacket以用来接收数据报，接收的数据保存在字节数组（第一个参数buf）中，接收指定长度（第二个参数length）
DatagramPacket(byte[] buf, int offset, int length, SocketAddress address)	构造一个DatagramPacket以用来发送数据报，发送的数据为字节数组（第一个参数buf）中，从0到指定长度（第二个参数length）。address指定目的主机的IP和端口号

DatagramPacket 方法：

socket其实也是操作系统中的一个概念，本质上是一种特殊的文件，Socket就属于是把网卡这个设备给抽象成文件了，往socket文件中写数据，就相当于通过网卡发送数据，从socket文件读取数据，就相当于通过网卡接收数据

DatagramSocket 构造方法：

DatagramSocket 方法：

方法签名	方法说明
void receive(DatagramPacket p)；	从此套接字接收数据报（如果没有接收到数据报，该方法会阻塞等待）
void send(DatagramPacket p)	从此套接字发送数据报包（不会阻塞等待，直接发送）
void close()	关闭此数据报套接字

使用UDP实现一个回显服务器

服务器和客户端都需要创建Socket对象，但是服务器的socket一般要显示的指定一个端口号，而客户端的socket一般不能显示指定，是由系统自动分配一个随机端口

服务器

public class UDPechoServer {
    //创建一个DatagramSocket对象，是后续网卡操作的基础
    public DatagramSocket socket = null;
    public UDPechoServer(int port) throws SocketException {
        //这样写是手动指定端口号
        socket = new DatagramSocket(port);
        //socket = new DatagramSocket();
        //这样写是系统自动分配端口号
    }
    public void start() throws IOException {
        System.out.println("服务器，启动！");
        while (true){
            //1.读取请求并解析
            //DatagramPacket就是一个数据包，里面储存要传输的信息
            DatagramPacket requestPacket = new DatagramPacket(new byte[1024],1024);
            //接收客户端的请求，并将数据存储到requestPacket中，如果没有就会阻塞等待
            socket.receive(requestPacket);
            //当前完成recrive之后，数据是以二进制的形式储存到DatagramPacket中了
            //想要把这个数据显示出来还要把这个数据，转换成字符
            //这里的范围不是0~1024，而是具体接收到的数据所占空间的范围
            String request = new String(requestPacket.getData(),0,requestPacket.getLength());
            //这里的getLength()是接收的数据的实际长度不是1024
            //2.根据请求计算响应(由于此处是回显服务器，请求是啥，回应就是啥)
            String response = this.process(request);
            //3.把响应写到客户端，搞一个响应对象，DatagramPacket
            //往DatagramPacket里构造刚刚的数据，再通过send返回
            //这里不能使用response.length()因为字符集的原因，response里面的中文可能占三个字节
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,
                    requestPacket.getSocketAddress());
            //返回请求
            socket.send(responsePacket);
            //打印一个日志，把这次数据的详细情况打印下来
            //这里显示的端口是系统分配给客户端的端口
            System.out.printf("[%s,%d] req:%s  res:%s\n",requestPacket.getAddress().toString(),
                   requestPacket.getPort(),request,response );
        }
    }

    public String process(String request){
        return request;
    }

    public static void main(String[] args) throws IOException {
        //需要手动创建端口号
        UDPechoServer server = new UDPechoServer(9090);
        server.start();
    }
}

new byte[]这个对象是用来承载从网卡这边读到的数据，收到数据的时候，需要搞一个内存空间来保存这个数据，DatagramPacket内部不能自己分配空间，所以就需要程序员自己手动分配，再交给DatagramPacket

这里的 response.getBytes().length不能换成response.length()，如果这个字符串里都是英文字符，此时字节和字符个数是一样的，如果包含中文就不一样了

刚刚说了socket本质上是一个特殊的文件，那么为什么最后不用close？

socket是文件描述符表里的一个表项，每打开一个文件，就会占用里面的一个位置，文件描述符表是再pcb上的(跟随进程)，这个socket在整个程序运行中都是需要使用的，不能提前关闭，当socket不再使用的时候，就意味着程序就要结束了，进程结束此时文件描述符表，就随着pcb销毁了，随着销毁的过程中，socket就被系统回收了。

什么时候会出现文件泄露？

代码中频繁的打开文件，但是不关闭，在一个进程中，不断积累打开的文件，文件描述符表里的空间不断被消耗，最终消耗殆尽。

客户端

public class UDPechoClient {
    public DatagramSocket socket = null;
    public String serverid = "";
    public int serverport;
    public UDPechoClient(String serverid,int serverport) throws SocketException {
        //创建的对象，不能手动指定端口
        socket = new DatagramSocket();
        //由于UDP自身不会持有对端的信息，就需要在应用程序里，把对端的情况记录下来
        //这里主要记录对端ip和端口
        this.serverid = serverid;
        this.serverport = serverport;
    }
    public void start() throws IOException {
        System.out.println("客户端，启动！");
        Scanner scanner = new Scanner(System.in);
        while (true){
            //1.控制台读取数据，作为请求
            System.out.println("请输入你的请求");
            String request = scanner.next();
            //2.把请求内容构造成DatagramPacket对象，发给服务器
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,
                    InetAddress.getByName(serverid),serverport);
            socket.send(requestPacket);
            //3，尝试读取服务器返回的响应
            DatagramPacket responsePacket = new DatagramPacket(new byte[1024],1024);
            socket.receive(responsePacket);
            //4.把响应转换成字符串
            String response = new String(responsePacket.getData(),0,responsePacket.getLength());
            System.out.println("接收响应:" + response);
        }
    }

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

在这个代码里用到了3个DatagramPacket的构造方法

只指定字节数组缓冲区(服务器收到请求和客户端受到响应的时候用到)
指定字节缓冲区，同时指定一个InetAddress对象,这个对象就同时包含了IP和端口(服务器返回响应给客户端)
指定字节数组缓冲区，同时指定IP+端口号

程序执行流程

服务器先启动，服务器启动之后就会进入循环，执行到receive这里并阻塞(此时还没有客户端过来)
客户端开始启动，也会先进入while循环，执行到scanner.next并且也在这里阻塞，当用户在控制台输入字符串之后，next就会返回，从而构造请求数据并发送出来
客户端发送出数据后：

服务器：就会从receive中返回得到，进一步解析请求为字符串，执行process操作，执行send操作

客户端：继续往下执行，执行到receive，等待服务器的响应

客户端收到响应后，就会从receive中返回得到，执行这里的打印操作，也就把响应给显示出来了
服务器这边完成一次循环之后，又执行到receive这里，客户端这边完成一次循环后又执行到scanner.next这里

TCPapi的使用

TCP的socket api和UDP的socket api差异有很涉及到两个关键的类

ServerSocket(给服务器使用的类，使用这个类来绑定端口号)
Socket(既可以给服务器使用又可以给客户端使用)

如果有客户端和服务器建立连接，这个时候服务器的应用程序是不需要做出任何操作(也没有任何感知的)，内核就直接完成了连接建立的流程(三次握手)，完成流程后，就会在内核的队列中排队(这个队列是每个serverSocket都有的)。应用程序要想和客户端进行通信，就需要通过一个accept方法，把内核队列里已经建立好的连接对象，拿到应用程序中。

ServerSocket API

ServerSocket 是创建TCP服务端Socket的API

ServerSocket构造方法：

方法签名	方法说明
ServerSocket(int port)	创建一个服务端流套接字Socket，并绑定接口

ServerSocket方法：

Socket API：

Socket 是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket，不管是客户端还是服务端Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。

Socket构造方法：

方法签名	方法说明
Socket(String host,int port)	创建一个客户流套接字Socket，并与对应IP的主机上对应的端口进程建立联系

Socket方法：

方法签名	方法说明
InetAddress getInetAddress()	返回套接字所连接的地址
InputStream getInputStream()	返回此套接字的输入流
OutputStream getOutputStream()	返回此套接字的输出流

使用TCP实现一个回显服务器

服务器：

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

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){
            //接收到客户端的连接就会执行processClient
            Socket clientSocket = serverSocket.accept();
            //不能直接调用，不然当有多个客户端时，服务器会阻塞在processclient内部
            //还可以使用线程池来进一步提高效率
            Thread t = new Thread(() -> {
                try {
                    processCilent(clientSocket);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            });
          t.start();
        }
    }

    public void processCilent(Socket clientSocket) throws IOException {
        //打印日志表示客户端上线
        System.out.printf("[%s:%d客户端上线]\n",clientSocket.getInetAddress(),clientSocket.getPort());
        //接下来进行数据的交互
        try(InputStream inputStream = clientSocket.getInputStream();
            OutputStream outputStream = clientSocket.getOutputStream()) {
            //使用try（）的方式避免后续忘记close
            while (true){
                Scanner scanner = new Scanner(inputStream);
                if(!scanner.hasNext()){
                    //断开连接(已经读完或其他原因)
                    System.out.println("客户端下线");
                    break;
                }
                //1.读取数据并解析，此处使用next来作为读取的方式，next的规则是，读到“空白符就返回”
                String request = scanner.next();
                //根据请求，给出回应
                String response = process(request);
                //3.把响应写回到客户端，把Sting转成字节数组，写入到OutputStream
                //也可以使用PrintWriter把OutputStream包裹一下，来写入字符串
                PrintWriter printWriter = new PrintWriter(outputStream);
                //此处的println不是打印在控制台，而是写入到OutputStream对应的对象流，也就是写入到clientSocket文件
                //自然这个数据也就通过网络发送出去了(发给当前这个服务器连接的另外一端)
                //使用println带有\n也是为了后续，客户端方便使用next读取数据
                printWriter.println(response);
                //不要忘记刷新缓存区
                printWriter.flush();
                //打印一下此次交互的内容
                System.out.printf("[%s:%d] req:%s  resp:%s\n",clientSocket.getInetAddress(),
                        clientSocket.getPort(),request,response);

            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            //当process处理完一个连接就表示可以关闭了
            clientSocket.close();
        }
    }
    public String process(String request){
        return request;
    }

    public static void main(String[] args) throws IOException {
        TCPechoServer server = new TCPechoServer(8080);
        server.start();
    }
}

注意：TCP是以字节流的方式进行通信的，每次没有固定的说，传输多少个字节，所以一般程序员会手动约定出，从哪里到哪里是一个完整的数据报，每次循环一次，就处理一个数据报即可，这里就是约定了使用\n作为数据报结束标记，而且正好可以搭配scanner.next来完成请求的读取过程。

客户端：

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

public class TCPechoCilent {
    private Socket socket = null;
    public TCPechoCilent(String ip,int port) throws IOException {
        socket = new Socket(ip,port);
    }
    public void Start(){
        System.out.println("客户端启动");
        Scanner scanner = new Scanner(System.in);
            try (InputStream inputStream = socket.getInputStream();
                 OutputStream outputStream = socket.getOutputStream()){
                PrintWriter writer = new PrintWriter(outputStream);
                Scanner scanner1 = new Scanner(inputStream);
                while (true){
                    //1.从控制台读取用户输入的内容
                    System.out.println("请输入请求");
                    String request = scanner.next();
                    //2.把请求把送给服务器
                    //使用println，是为了让请求后面带上换行，方便服务器读取
                    writer.println(request);
                    writer.flush();
                    //3.读取服务器返回的响应
                    String response = scanner1.next();
                    //4.打印响应
                    System.out.println("响应："+response);
                }


            } catch (IOException e) {
                throw new RuntimeException(e);
            }

    }
    public static void main(String[] args) throws IOException {
        TCPechoCilent cilent = new TCPechoCilent("127.0.0.1",8080);
        cilent.Start();
    }
}

注意：这里和UDP不一样，这里的CilentSocket对象(Socket)要进行close，DatagramSocket和ServerSocket都是在程序中，只有这么一个对象，生命周期贯穿整个程序，CilentSocket则是在循环中每次有一个新客户来建立连接，都会创建出新的ClientSocket并且Socket最多使用到客户端退出(断开连接)。如果有很多客户端都要建立连接，每个客户端都会创建一个ClientSocket，如果断开连接时没有手动close，此时这个Socket对象就会占用文件描述符表的位置，数量多了之后就会导致文件泄露问题。

以上就是博主对网络编程知识的分享，在之后的博客中会陆续分享有关线程的其他知识，如果有不懂的或者有其他见解的欢迎在下方评论或者私信博主，也希望多多支持博主之后和博客！！🥰🥰

喝养乐多长不高

关注

18
点赞
踩
5

收藏

觉得还不错? 一键收藏
2
评论
网络编程详解

socket是文件描述符表里的一个表项，每打开一个文件，就会占用里面的一个位置，文件描述符表是再pcb上的(跟随进程)，这个socket在整个程序运行中都是需要使用的，不能提前关闭，当socket不再使用的时候，就意味着程序就要结束了，进程结束此时文件描述符表，就随着pcb销毁了，随着销毁的过程中，socket就被系统回收了。
复制链接

扫一扫