Java EE初阶——网络编程

客户端与服务器之间的交互：一问一答（web开发），一问多答（下载），多问一答（上传），多问多答（远程控制）

2. Socket 套接字

3. UDP数据报套接字编程

UDP（用户数据报协议）的核心类在java.net 包中：

1. DatagramSocket

• 用于发送和接收UDP数据包。

1. DatagramSocket 构造方法

2. DatagramSocket 核心方法

2. DatagramPacket

• 封装UDP数据包，包含数据、目标地址和端口。

1. DatagramPacket 构造方法

2. DatagramPacket 核心方法

服务端：

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

public class UdpEchoServer {
    private DatagramSocket socket = null;
    public UdpEchoServer(int port) throws SocketException {
        //创建 DatagramSocker 对象，创建失败，如端口号被其他进程占用，抛出异常
        socket = new DatagramSocket(port);//服务器需手动指定一个端口号
    }
    //启动服务器
    public void start() throws IOException {
        System.out.println("服务器端启动");
        //服务器需不停进行请求响应操作
        while(true){
            //1. 读取请求并解析
            //创建 DatagramPacket 对象，内部包含一个手动设置长度的字节数组，保存收到的消息正文（UDP数据报载荷部分）
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
            //receive 从网卡读取到一个UDP数据报，存放在requestPacket对象中，字节数组存放UDP数据报载荷部分，其他属性存放报头及源IP及源端口等
            socket.receive(requestPacket);//具有阻塞等待功能
            //将字节数组存放的UDP数据报载荷部分转换为 String 类型，方便后续操作
            String request = new String(requestPacket.getData(),0,requestPacket.getLength());
            //2. 根据请求计算响应
            String response = process(request);
            //3. 把响应返回到客户端
            //创建 DatagramPacket 对象,包含请求中的源IP及源端口，作为响应中的目的IP及目的端口
            // 此时需要告知⽹卡, 要发的内容是啥, 要发给谁
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,requestPacket.getSocketAddress());
            socket.send(responsePacket);
            //打印日志
            System.out.printf("[%s,%d] req:%s,reap:%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 udpEchoServer = new UdpEchoServer(9096);//1024<端口号<65535
        udpEchoServer.start();
    }
}

客户端：

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

public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String serverIP;//请求的目的IP
    private int serverport;//请求的目的端口
    //客户端主动给服务器发送请求，需要知道服务器的ip及端口号
    public UdpEchoClient(String serverIP,int serverport) throws SocketException {
        this.serverIP = serverIP;
        this.serverport = serverport;
        socket = new DatagramSocket();//客户端系统随机分配端口
    }
    public void start() throws IOException {
        System.out.println("客户端启动");
        Scanner scan = new Scanner(System.in);
        //客户端不停进行请求响应
        while(true){
            System.out.print("->");
            //1. 从客户端读取要发送的请求
            if(!scan.hasNext()){
                System.out.println("客户端关闭");
                break;
            }
            String response = scan.next();
            //2. 构造请求并发送给服务器端
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,
                    InetAddress.getByName(serverIP),serverport);
            socket.send(responsePacket);
            //读取服务器的响应
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
            socket.receive(requestPacket);
            //把响应打印到控制台上
            String request = new String(requestPacket.getData(),0,requestPacket.getLength());
            System.out.println(request);
        }
    }

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

       

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

public class UdpEchoProcess extends UdpEchoServer{
    private HashMap<String,String> map = new HashMap<>();
    public UdpEchoProcess(int port) throws SocketException {
        super(port);
        map.put("hello","你好");
        map.put("cat","小猫");
        map.put("dog","小狗");
    }
    @Override
    public String process(String request){
        //查找
        return map.getOrDefault(request,"此单词不存在");
    }

    public static void main(String[] args) throws IOException {
        UdpEchoProcess udpEchoProcess = new UdpEchoProcess(9096);
        udpEchoProcess.start();//直接调用父类start方法
    }
}

4. TCP流套接字编程

阻塞式 I/O（java.net 包）

适用于简单、同步的TCP通信。

1.  ServerSocket（服务端）

构造方法

核心方法

2. Socket（客户端/服务端通信）

构造方法

核心方法

3. InetSocketAddress

SocketAddress 是 Java 中表示通用套接字地址的抽象类，没有定义任何具体方法，位于 java.net 包中。它是所有具体套接字地址类（如 InetSocketAddress）的父类，主要用于为不同类型的网络地址提供统一的抽象接口。

InetSocketAddress 是 Java 中用于表示 IP 地址 + 端口号 的组合

1. 作用

• 封装 IP 和端口：将 InetAddress（或主机名）与端口号合并为一个对象。

• 支持主机名解析：在构造时自动解析域名（如 "www.example.com"）为 IP 地址。

• 不可变对象：一旦创建，其地址和端口不可修改。

2. 构造方法

3. 核心方法

4. PrintWriter 

PrintWriter 是 Java 中用于格式化输出文本的类，位于 java.io 包中。

1. 构造方法

2. 核心方法

(1) 写入数据

(2) 控制缓冲区

(3) 错误检查

为什么数据没有发送到客户端？

• 未调用 flush() 或未设置 autoFlush=true，数据可能留在缓冲区。

TcpEchoServer:

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.util.Scanner;

public class TcpEchoServer {
    // 用于监听客户端连接的服务器Socket
    private ServerSocket serverSocket = null;
    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);// 创建ServerSocket并绑定指定端口
    }
    // 启动服务器，循环等待客户端连接
    public void start() throws IOException {
        System.out.println("服务器启动");
        while(true){
            Socket cilentSocket = serverSocket.accept();// 接受客户端连接（具有阻塞等待功能）
            processConnection(cilentSocket);
        }
    }
    private void processConnection(Socket cilentSocket) {
        // 使用try-with-resources确保流自动关闭
        try(InputStream inputStream = cilentSocket.getInputStream();
        OutputStream outputStream = cilentSocket.getOutputStream()){
            // 使用 Scanner 读取客户端发送的数据
            Scanner scanner = new Scanner(inputStream);
            // 使用 PrintWriter 向客户端写回响应数据
            PrintWriter printWriter = new PrintWriter(outputStream);
            // 持续处理客户端请求
            while (true){
                // 判断是否还有输入数据
                if(!scanner.hasNext()){
                    // 客户端关闭连接
                    System.out.printf("[%s,%d] 客户端下线\n",cilentSocket.getInetAddress(),cilentSocket.getPort());
                    break;
                }
                // 1.读取客户端请求
                String request = scanner.next();
                // 2.根据请求处理请求
                String response = process(request);
                // 3.将响应写回客户端
                printWriter.println(response);
                printWriter.flush();// 立即刷新缓冲区,确保数据被发送
                // 打印日志
                System.out.printf("[%s,%d] req:%s resp:%s",cilentSocket.getInetAddress(),cilentSocket.getPort(),request,response);
            }
        }catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            try{
                //cilentSocket每个客户端都有一个，随着客户端越来越多，消耗的socket也越来越多
                //如果不及时释放，可能会“耗尽文件描述符”导致崩溃
                cilentSocket.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
    private String process(String request){
        return request;// 直接返回请求内容（简单回显实现）
    }

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

TcpEchoClient:

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

public class TcpEchoClient {
    private Socket socket = null;
    public TcpEchoClient(String serverIP,int serverPort) throws IOException {
        // 这个 new 操作完成之后, 就完成了 tcp 连接的建⽴.
        //可以将ip与port直接传给socket对象
        socket = new Socket(serverIP,serverPort);
    }
    private void start(){
        System.out.println("客户端启动");
        try(InputStream inputStream = socket.getInputStream();
            OutputStream outputStream = socket.getOutputStream()){
            Scanner scan = new Scanner(System.in);
            Scanner scanner = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);
            while (true){
                // 1. 从控制台输⼊字符串
                System.out.print("->");
                if(!scan.hasNext()){
                    break;
                }
                String request = scan.next();
                // 2. 把请求发送给服务器
                printWriter.println(request);
                printWriter.flush();// 立即刷新缓冲区,确保数据被发送
                // 3. 从服务器读取响应
                String response = scanner.next();
                // 4. 把响应打印出来
                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",9096);
        tcpEchoClient.start();
    }
}

1. 在使用 Scanner 读取用户输入时，通常推荐使用 next() 方法而不是 nextLine()，因为 next() 以空白符（如空格、制表符、换行符等）作为输入的分隔符，能够较稳定地读取单个词或指令。而 nextLine() 会读取整行内容，直到遇到换行符为止，用户按下 Enter 键后会将整行（包括隐藏字符如 \r 或 \n）一并作为输入内容，这可能导致读取结果出现空行或意外字符，尤其是在混合使用多种输入方法（如先用 next() 再用 nextLine()）时容易出错。因此，如果输入仅为单个词或命令，使用 next() 更加简洁可靠；如果需要读取整句或含空格的完整输入内容，则应小心使用 nextLine() 并注意清除缓冲区中的残留换行符。

2. 在 ServerSocket 程序中，serverSocket 是唯一的监听对象，通常在服务器启动后持续运行，只有在程序退出或服务器关闭时才会释放资源。相比之下，每当有一个客户端连接进来，服务器就会为其创建一个独立的 clientSocket 对象。如果服务器不及时关闭这些客户端 clientSocket，随着连接数的增多，系统的文件描述符资源会逐渐被占满，最终可能导致程序抛出 “Too many open files” 错误，从而崩溃。因此，在每次处理完客户端请求后，必须在 finally 块中显式关闭对应的客户端 clientSocket，以确保资源及时释放，保证服务器的稳定性和可持续运行。

1. 多个客户端访问服务器：

1. 问题：

当多个客户端访问服务器时，我们发现服务器只能与第一个访问服务器的客户端建立连接，其余客户端必须等上一个客户端退出时才能与服务器建立连接，这是为什么？

• serverSocket.accept()：这行代码会阻塞，直到有一个客户端连接；

• 然后 processConnection() 会 持续处理这个客户端的所有请求，直到客户端关闭连接之前不会结束；

• 在这个过程中，服务器主线程是“卡”在这个 processConnection() 方法中，不能继续 accept() 下一个客户端。

结果就是：

• 单线程、串行 的服务器只能同时服务一个客户端。

• 后续客户端虽然连接请求已发出，但由于 accept() 没有再次被调用，连接处于排队状态（操作系统层面的 TCP backlog）。

• 只有当前客户端断开连接，processConnection() 结束后，主线程才能返回到循环顶部，再 accept() 下一个客户端。

2. 解决方法：

1. 服务器引入多线程/并发：

要实现多个客户端同时访问服务器，你需要让服务器在 accept() 之后，为每一个客户端连接启动一个线程 来处理它，这样主线程可以继续接受下一个客户端连接：

    // 启动服务器，循环等待客户端连接
    public void start() throws IOException {
        System.out.println("服务器启动");
        while(true){
            Socket cilentSocket = serverSocket.accept();// 接受客户端连接（具有阻塞等待功能）
            //创建线程
            Thread t = new Thread(()->{
                processConnection(cilentSocket);
            });
            t.start();
        }
    }

2. 服务器引⼊线程池：

  // 启动服务器，循环等待客户端连接
    public void start() throws IOException {
        System.out.println("服务器启动");
        //创建线程池
        ExecutorService pool = Executors.newCachedThreadPool();
        while(true){
            Socket cilentSocket = serverSocket.accept();// 接受客户端连接（具有阻塞等待功能）
            //提交任务
            pool.submit(()->{
                processConnection(cilentSocket);
            });
        }
    }

协程（coroutine）是一种比线程更轻量的并发机制。常运行于用户态，用户态可以手动调度的方式让一个线程“并发”的做多个任务，相比于传统线程，它们的调度不依赖操作系统，而由程序自身控制。多个协程可以复用一个线程，协程之间的切换不需要内核态参与，因此切换速度快、资源开销小。

在 Java 中，可以通过 虚拟线程（Virtual Thread，Java 21+） 实现协程模型，从而大幅提升并发处理能力。协程特别适合处理 I/O 阻塞型任务，比如网络通信、数据库访问等。

2.  IO 多路复用

I/O 多路复用指的是用一个线程监控多个连接通道（Channel），只有当某个通道就绪时才处理它。

I/O 多路复用是一种高效的事件驱动模型，允许单个线程同时监控多个 Socket 连接的 I/O 状态（如是否可读可写）。常见实现包括：

• Linux 的 select, poll, epoll

• Java 的 java.nio.Selector

虽然一个线程可能维护了数万个 socket，但在同一时刻，真正处于“活跃状态”（即可读、可写）的连接通常是极少数。大部分连接处于“等待状态”，并不会频繁发生 I/O 操作。

通过 I/O 多路复用，线程只在真正需要处理数据时才进行读取或写入，从而极大提高了线程利用率和系统并发能力，特别适合于高并发 + I/O 密集型场景（如聊天室、消息中间件、网关服务等）。