基于 Socket 的网络编程

package network;

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.nio.charset.StandardCharsets;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

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("启动服务器");
        // 此处使用 CachedThreadPool, 使用 FixedThreadPool 不太合适 (线程数量不应该固定)
        ExecutorService threadPool = Executors.newCachedThreadPool();
        while(true) {
            Socket clientSocket = serverSocket.accept();
            threadPool.submit(() -> {
                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(true) {
                // 1. 读取请求
                Scanner sc = new Scanner(inputStream);
                if(!sc.hasNext()) {
                    // 没有下个数据, 说明读完了. (客户端关闭了连接)
                    System.out.printf("[%s:%d] 客户端下线!\n",
                            clientSocket.getInetAddress(),
                            clientSocket.getPort());
                    break;
                }
                // 注意, 此处使用 next 是一直读取到 换行符/空格/其他空白符 结束, 但是最终结果不包含上述 空白符(因此后面要自己再补一个空白符).
                String request = sc.next();
                // 根据请求构造响应
                String response = process(request);
                // 3.返回响应结果.
                outputStream.write((response+"\n").getBytes(StandardCharsets.UTF_8));
                outputStream.flush();
                //   OutputString 没有 write(String) 这样的功能. 可以把 String 里的字节数组拿出来, 进行写入;
                //   也可以使用 字符流 来转换
//                PrintWriter printWriter = new PrintWriter(outputStream);
                // 此处使用 println 来输出 response, 让结果中带有一个 \n 换行. 方便对端来接收解析.
//                printWriter.println(response);
                // flush 用来刷新缓冲区, 保证当前写入的数据, 一定会发送出去(println 输出后有可能会先放在缓冲区, 等缓冲区满会自动输出)
//                printWriter.flush();

                System.out.printf("[%s:%d] req: %s; resp: %s \n",
                        clientSocket.getInetAddress().toString(),
                        clientSocket.getPort(), request, response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // finally 里的内容保证一定可以执行到
            try {
                clientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

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

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

package network;

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

// UDP 版本的回显客户端
public class UdpEchoClient {
    private DatagramSocket socket = null;

    // 存储的是服务器的 ip 和 端口号, 以便通讯使用
    private String serverIp;
    private int serverPort;

    // 一次通信, 需要有两个 ip, 两个 端口
    // 客户端的 ip : 127.0.0.1 已知
    // 客户端的 port 是系统自动分配
    // 服务器的 ip 和 端口, 需要手动告诉客户端, 才能顺利把消息发送给服务器
    public UdpEchoClient(String serverIp, int serverPort) throws SocketException {
        socket = new DatagramSocket();
        this.serverIp = serverIp;
        this.serverPort = serverPort;
    }

    public void start() throws IOException {
        System.out.println("客户端启动!");
        Scanner sc = new Scanner(System.in);

        while(true) {
            // 1. 从控制台读取要发送的数据
            System.out.println(">");
            String request = sc.next();
            if(request.equals("bye")) {
                System.out.println("goodbye!");
                break;
            }

            // 2. 构造成 UDP 请求, 并发送
            //    构造这个 Packet 的时候, 需要把 severIp 和 port 都传进来. 但是此处 IP 地址需要填写一个 32 位的整数形式
            //    上述的 IP 地址是一个字符串. 需要使用 InetAddress.getByName 来进行一个转换.
            DatagramPacket requestPacket = new DatagramPacket(
                    request.getBytes(), 0, request.getBytes().length,
                    InetAddress.getByName(this.serverIp), this.serverPort);
            socket.send(requestPacket);

            // 3. 读取服务器的 UDP 响应, 并解析
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 0, 4096);
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(), 0 , responsePacket.getLength());

            // 4. 把解析好的结果显示出来
            System.out.printf("[%s:%d] response: %s; request: %s;\n",
                    responsePacket.getAddress().toString(),
                    responsePacket.getPort(), response, request);

        }
    }

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