【网络编程】理解客户端和服务器并使用Java提供的api实现回显服务器

public class UdpEchoServer {
    private DatagramSocket socket = null;
    public UdpEchoServer(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }
    public void start() throws IOException {
        System.out.println("服务器启动");
        while (true) {
            //每次循环，都是一次处理请求，进行响应的过程
            //1. 读取请求并解析
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(requestPacket);
            // 将读到的字节数组转换成 String 方便后续操作
            String request = new String(requestPacket.getData(),0,requestPacket.getLength());
            //2. 根据请求计算响应
            String response = process(request);
            //3. 把响应返回到客户端
            // 与请求数据报创建不同，请求数据报是使用空白字节数组，而此处直接把 String 里包含的字节数组作为参数创建，
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), response.getBytes().length,
                    requestPacket.getSocketAddress());  // 因为 UDP 无连接，因此必须从【请求数据报】中获取对应客户端的 ip 和端口
            socket.send(responsePacket);
            //打印日志
            System.out.printf("[%s:%d] req: %s, resp: %s\n",requestPacket.getAddress().toString(),
                    requestPacket.getPort(), request, response);
        }
    }
    private String process(String request) {
        return request;
    }
    public static void main(String[] args) throws IOException {
        UdpEchoServer server = new UdpEchoServer(9090);
        server.start();
    }
}

public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String serverIp;
    private int serverPort;
    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.print("-> "); //表示提示用户输入
            if (!sc.hasNext()) {   //hasNext 具有阻塞功能
                break;
            }
            String request = sc.next();
            //2. 构造请求并发送
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
                    InetAddress.getByName(serverIp), serverPort);
            socket.send(requestPacket);
            //3. 读取服务器的响应
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
            // 阻塞等待响应数据返回
            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();
    }
}

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) {
            // 当客户端创建出 socket 后（new socket），就会和对应的服务器进行 tcp 连接建立流程
            // 此时通过 accept 方法来“接听电话”，然后才能进行通信
            Socket clientSocket = serverSocket.accept();
            Thread t = new Thread(() -> {
                processConnection(clientSocket);
            });
            t.start();
        }
    }
    private void processConnection(Socket clientSocket) {
        System.out.printf("[%s:%d] 客户端上线！\n", clientSocket.getInetAddress(), clientSocket.getPort());
        // 循环读取客户端的请求并返回响应
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()){
            // 可以使用 inputStream 原本的 read 方法进行读取
            // 但是比较繁琐，为了【方便读入】，这里使用 Scanner 对输入流进行输入
            Scanner sc = new Scanner(inputStream);
            while (true) {   // 长连接
                if (!sc.hasNext()) {
                    // 读取完毕，客户端断开连接
                    System.out.printf("[%s:%d] 客户端下线！\n", clientSocket.getInetAddress(), clientSocket.getPort());
                    break;
                }
                //1. 读取请求并解析，此处使用 next ，需要注意 next 的读入规则
                String request = sc.next();
                //2. 根据请求计算响应
                String response = process(request);
                //3. 把响应返回给客户端
                /*  通过这种方式也可以写回，但是这种方式不方便添加 \n
                outputStream.write(response.getBytes(),0,response.getBytes().length);*/
                // 因此为了【方便写入】，给 outputStream 也套一层，即使用 printWriter
                // 此处的 printWriter 就类似于 Scanner 将输入流包装了一下，而 printWriter 对输出流包装了一下
                PrintWriter printWriter = new PrintWriter(outputStream);
                // 通过 println 在末尾添加了 \n，与客户端的 scNetwork.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 {
                clientSocket.close();
        }
    } 
    private String process(String request) {
        return request;
    }
    public static void main(String[] args) throws IOException {
        TcpEchoServer server = new TcpEchoServer(9090);
        server.start();
    }
}

public class TcpEchoClient {
    private Socket socket = null;
    public TcpEchoClient(String serverIp, int serverPort) throws IOException {
        // 这里直接将 ip 和 port 传入，是由于 tcp 是有连接的，socket 里能够保存 ip 和 port
        socket = new Socket(serverIp,serverPort);
        // 因此也不需要额外创建【类成员对象】来保存 ip 和 port
    }
    public void start() {
        System.out.println("客户端启动！");
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()){
            // 此处的 scanner 用于控制台读取数据
            Scanner scConsole = new Scanner(System.in);
            // 此处的 scanner 用于读取服务器响应回来的数据
            Scanner scNetwork = new Scanner(inputStream);
            // 此处 printWriter 用于向服务器写入请求数据
            PrintWriter printWriter = new PrintWriter(outputStream);
            while (true) {
                // 这里流程和 UDP 的客户端类似
                //1. 从控制台读取输入的字符串
                System.out.print("-> ");
                if (!scConsole.hasNext()) {
                    break;
                }
                String request = scConsole.next();
                //2. 把请求发送给服务器，
                // 使用 printWriter 是为了使发送的请求末尾带有 \n，与服务器的 sc.next 呼应
                printWriter.println(request);
                // 刷新缓冲区，确保数据能够发送出去
                printWriter.flush();
                //3. 从服务器读取响应
                String response = scNetwork.next();
                //4. 打印响应
                System.out.println(response);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    public static void main(String[] args) throws IOException {
        TcpEchoClient client = new TcpEchoClient("127.0.0.1", 9090);
        client.start();
    }
}