代码收藏家技术教程 2025-03-02

网络编程（TCP/UDP）

什么是网络编程

网络编程指的是，网络上的主机，不同的进程，通过网络的方式实现通信。同一个主机但是不同进程之间通信也是网络编程，但是我们主要编程对象是不同主机至今啊的通信。

网络编程实际上就是把传输层和应用层进行封装，然后利用java提供的api进行通过，代码的形式交给传输层然后进行通信。

网络编程的基本概念

客户端和服务器

客户端：发起通信的一方，实际上就是我们平时的应用之类的。
服务器：接受数据的一方，接收数据并进行处理。

客户端服务器的定义实际上是谁发起了通信，谁接受了数据。

请求和响应

请求：request，客户端给服务器发送的数据。

响应：response，服务器返回给客户端的数据。

Socket关键字

Socket是系统提供的方式用于网络通信，网络通信常常基于Socket关键字。

TCP和UDP是传输层的两个重要的协议。

TCP的特点

有连接（必须要双方都接通了才能进行通信，需要三次握手四次挥手）。

可靠传输（可以知道对方是否接收到了数据）。

面向字节流（网络中的传输数据是字节模式，以字节为单位）。

全双工（可以双向通信）。

UDP的特点

无连接（就是类似于QQ直接发出去，无需等待对方建立连接）。

不可靠传输（对方就算对方没有接收到，发送端也不知道有没有对方是否接收到）。

面向数据报（单位是数据报）。

全双工（可以双向通信）。

UDP编程：

1.DatagramSocket

Datagramsocket是UDP Socket的关键方法，用来发送和接受UDP数据。

构造方法：

重要方法：

2.DatagramPacket

DatagramPacket是UDP Socket发送数据的数据报（每次接收和发送数据的基本单位就是数据报）。

构造方法：

3.UDP回显服务器

服务器和客户端都要指定一个端口号，但是一般服务器的端口号要显式指定，客户端不能显式指定，系统会自动分配。服务器需要把端口号明确下来，需要让别人找到。客户端的端口号不能指定，因为有可能被别人占用了（避免端口号冲突），交给系统分配。

服务器的端口号在程序员手里，服务器的哪些端口号被使用了，程序员都知道的。客户端在客户上面。一个服务器程序需要长时间运行。

new DatagramPacket（）用来承载从网卡这边读到的数据，读到数据需要指定一个内存空间来保存这个数据。socket（网卡）读取数据，，并且保存到requestpacket里面。

receive会阻塞，直到客户端发送数据。

package network;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UdpEchoServer {
    //服务器代码，创建一个DatagramSocket，后续操作网卡

    private DatagramSocket socket=null;

    public UdpEchoServer(int port) throws SocketException {
        this.socket = new DatagramSocket(port);

        //socket=new DatagramSocket();这是让系统分配的方法。




    }
    public void start() throws IOException {
        while (true){
            //读取请求并且解析
            DatagramPacket requestPacket=new DatagramPacket(new byte[4096],4096);
            //从网卡中读取数据，并且存储在packet中，有数据才会接受不然就会阻塞
            socket.receive(requestPacket);
            //拿到数据,并且放入到String中,取区间内的字节，构造成String，这里的getlength实际上不是4096，是收到的数据的真实长度
            String request=new String(requestPacket.getData(),0, requestPacket.getLength());
            //根据请求计算响应！！！！一般服务器最重要的
            String response=process(request);


            //将响应写回去
            //UDP是无连接的，每次都要指定数据要发给谁
            //构造数据报，需要指定数据内容，也要指定发给谁
            //不能直接getlength，获取字符为单位的如果都是英文单词，那字符字节一样，中午不一样，网络传输都是字节为单位
            DatagramPacket responsePacket=new DatagramPacket(response.getBytes(),response.getBytes().length,requestPacket.getSocketAddress());
            socket.send(responsePacket);





            System.out.printf("[%s:%d] req=%s resp=%s",requestPacket.getAddress().toString(),responsePacket.getPort(),request,response);

        }



    }


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

    public static void main(String[] args) throws IOException {
        UdpEchoServer udpEchoServer=new UdpEchoServer(9090);
        udpEchoServer.start();
        



    }
}

对于客户端，服务器的端口号可以由系统随机分配，但需要知道服务器的IP地址及端口号，不然就不知道发送数据给谁。

客户端发送数据
构造数据报通过socket发送给服务器
服务器进行读取并且返回给客户端
客户端输出发送的响应

package network;

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

public class UdpEchoClient {
    private DatagramSocket socket;
    private String address;
    private int port;

    public UdpEchoClient(String address, int port) throws SocketException {
        this.address = address;
        this.port = port;
        socket=new DatagramSocket();//这里表示服务器的随机端口创建
    }
    public void start() throws IOException {
        System.out.println("客户端启动");
        Scanner input=new Scanner(System.in);
        while (true){
            //没有输入数据的时候就跳出循环
            if(!input.hasNext()){
                break;
            }
            //读取所有的数据
            String request=input.next();
            //将内容构造成datagrampacket发送出去,并且需要找到对方的ip地址和端口号
            DatagramPacket datagramPacket=new DatagramPacket(request.getBytes(),request.getBytes().length, InetAddress.getByName(address),port);
            //通过网卡进行发送数据报
            socket.send(datagramPacket);

            //读取服务器内容并且显示在客户端。
            DatagramPacket responseDatagramPacket=new DatagramPacket(new byte[4096],4096);
            socket.receive(responseDatagramPacket);
            String response=new String(responseDatagramPacket.getData(),0,responseDatagramPacket.getLength());
            System.out.println(response);



        }
    }

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

但是实际上这个程序不能跨主机通信，如果想要实现跨主机通信，就要把程序部署到云服务器上面。

4.UDP翻译回显服务器

基于上述回显服务器，还可以实现出一些其他带有一点业务逻辑的服务器。

进行业务逻辑的修改实际上就是进行对回显服务器的继承，再实现更多的细节和代码。

上述的操作是在process的代码中实现的，我们只要进行继承然后重写方法就可以达到汉译英的效果了。

package network;

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

public class UdpDireServer extends UdpEchoServer{
    private Map<String,String> map;
    public UdpDireServer(int port) throws SocketException {
        super(port);
        map = new HashMap<>();
        map.put("cat", "小猫");
        map.put("bear", "小熊");
    }

    @Override
    public String process(String request) {
        if(map.get(request)!=null){
            return map.get(request);
        }
        return request;
    }

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

观察一下运行结果，发现没有问题。

以上就是UDP的回显服务器的开发和运行了。

TCP编程：

1.ServerSocket

ServerSocket是创建TCP服务端Socket的API（只能给服务器使用）。

构造方法：

重要方法：

2.Socket

Socket 类用于创建客户端 Socket，或服务器端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket. (服务器端和客户端都能使用)

构造方法：

重要方法：

3.TCP回显服务器程序

TCP和UDP的区别就是TCP是有连接的，就和打电话一样需要一方接通另外一方才能进行通话。所以要等待客户端发起请求后，服务器确认接通之后，才可以进行通信，TCP的首要任务就是建立连接。

和UDP回显服务器一样，对于这里的服务器，同样需要指定端口号创建TCP服务器端Socket，即ServerSocket。

服务器启动之后，需要通过accept方法来监听当前端口。
成功建立连接之后，就可以返回一个Socket方法，这个对象保存了对端的信息，即客户端信息，可以用来接收和发送请求等（TCP是面向字节流），可以通过该方法来发送和接收数据。

后续流程和UCP回显服务器一致。此处由于每有一个客户端连接，就会有一个clientSocket，这里消耗的Socket会越来越多，因此每当一个客户端连接结束，就需要释放这个clientSocket。

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.time.temporal.IsoFields;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TcpEchoServer {
    private ServerSocket serverSocket;

    public TcpEchoServer(int port) throws IOException {
        serverSocket=new ServerSocket(port);
    }


    public void start() throws IOException {
        System.out.println("服务器启动");
        //ExecutorService threadPool = Executors.newCachedThreadPool();
        while (true){
            while (true) {
                //监听当前绑定的端口，等待客户端连接 连接后，返回一个socket，里面保存客户端(对端)信息
                Socket clientSocket = serverSocket.accept();
                processConnection(clientSocket);
            }
            

        }
    }

    private void processConnection(Socket clientSocket) throws IOException {
        //返回ip地址和对应的端口
        System.out.printf("[%s:%d] 客户端上线\n", clientSocket.getInetAddress(), clientSocket.getPort());
        try(OutputStream outputStream=clientSocket.getOutputStream();
            InputStream inputStream=clientSocket.getInputStream()) {
            //不断读取输入的数据
            while (true){
                Scanner scanner=new Scanner(inputStream);
                if (!scanner.hasNext()) {
                    System.out.printf("[%s:%d] 客户端下线\n",
                            clientSocket.getInetAddress(), clientSocket.getPort());
                    break;
                }
                //next是等到/n才结束，也就是用户输入换行（回车）
                String request=scanner.next();
                String response=process(request);

                PrintWriter printWriter=new PrintWriter(outputStream);
                printWriter.println(response);
                printWriter.flush();
                System.out.printf("[%s:%d] request:%s response:%s\n", clientSocket.getInetAddress(), clientSocket.getPort(), request, response);

        }

    }finally {
            clientSocket.close();
        }
        }

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

    public static void main(String[] args) throws IOException {
        TcpEchoServer tcpEchoServer = new TcpEchoServer(9090);
        tcpEchoServer.start();

    }
}

对于客户端，需要指定服务器的IP和端口号建立连接。使用 Socket(String host, int port) 创建Socket的时候，就开始发起与对应服务器建立连接的请求了。

实际上TCP回显服务器和UDP很相似。，但是TCP是面向字节流。

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class TcpEchoClient {
    private Socket clientSocket;

    public TcpEchoClient(String serverAddress, int serverPort) throws IOException {
        clientSocket=new Socket(InetAddress.getByName(serverAddress),serverPort);
    }
    public void start() {
        try(InputStream inputStream=clientSocket.getInputStream();
            OutputStream outputStream=clientSocket.getOutputStream();
            Scanner scanner=new Scanner(System.in)) {
            while (true){
                System.out.print("->");
                String request=scanner.next();

                PrintWriter printWriter=new PrintWriter(outputStream);
                printWriter.println(request);
                printWriter.flush();

                //读取服务器发送的数据
                Scanner inputScanner=new Scanner(inputStream);
                String response=inputScanner.next();

                System.out.println(response);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    public static void main(String[] args) throws IOException {
        TcpEchoClient tcpEchoClient = new TcpEchoClient("127.0.0.1", 9090);
        tcpEchoClient.start();
    }


}

在这里我们需要先运行服务器，再运行客户端，通常服务器都需要先启动，不然客户端会因为连接不上服务器而报错。

实际上这里还存在一个问题。这里的服务器只能给先获取连接的客户端提供服务，如果其他客户端想访问则会失败。

分析过程：

第一个客户端连上服务器之后，服务器就会从accept这里返回（解除阻塞），然后进入到processConnection方法中。
.接下来服务器就会在processConnection循环处理客户端的请求，只有当客户端退出之后，连接结束，才会退出循环。
而服务器在循环处理客户端请求的时候，第二个客户端发起连接请求，而服务器这里并不能执行到accept。因此并不能成功连接，只有当客户端退出，才会执行回到accept进行连接。

第二个客户端之前发的请求为什么能被立即处理？

当前TCP在内核中，每个 socket 都是有缓冲区的。客户端发送的数据通过客户端代码，已经写入到服务器的缓冲区了，这里数据确实发送了，只不过数据在服务器的接收缓冲区中。
一旦第一个客户端退出，回到第一层循环，执行accept连接操作，后续processConnection方法里的 next 就能把之前缓冲区的内容给读出来。

实际上可以通过多线程来解决此问题，为每个访问的客户端都创建一个线程，使其可以通过单独的线程来进行访问服务器。

4. 服务器引入多线程

    //多线程
    public void start() throws IOException {
        System.out.println("服务器启动！");
        while (true) {
            //监听当前绑定的端口，等待客户端连接 连接后，返回一个socket，里面保存客户端(对端)信息
            Socket clientSocket = serverSocket.accept();
 
            Thread t = new Thread(() -> {
                try {
                    processConnection(clientSocket);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            });
            t.start();
        }
    }

但是实际上，像这样频繁创建和销毁线程对服务器来说是一个不小的开销。

每有一个客户端连接，就会创建一个新的线程，每当这个客户端结束，就要销毁这个线程。

如果客户端比较多，并且频繁连接、关闭，就会使服务器频繁创建和销毁线程

因此我们使用了线程池。

5.服务器引入线程池

    public void start() throws IOException {
        System.out.println("服务器启动！");
        ExecutorService threadPool = Executors.newCachedThreadPool();
        while (true) {
            Socket clientSocket = serverSocket.accept();
 
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        processConnection(clientSocket);
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
        }
    }

6.TCP字典服务器

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class TcpDictServer extends TcpEchoServer{
    Map<String,String> map=new HashMap<>();


    public TcpDictServer(int port) throws IOException {
        super(port);
        map.put("cat","小猫");


    }

    @Override
    public String process(String request) {
        return map.getOrDefault(request,"未查找到单词");
    }

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