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

/**
 * @author haomin
 * @date 2022/09/26 09:56
 **/
public class Client {
    public static void main(String[] args) throws IOException {
        // 本机-本机
        // 目前服务器在本机: 127.0.0.1
        // 目前服务器的端口是: 8080

        // 本机只发送一次请求
        String word = "apple";

        // 准备发送请求
        String request = "请求格式头\r\n" + word + "请求格式尾\r\n";
        byte[] bytes = request.getBytes("UTF-8");
        DatagramPacket sent = new DatagramPacket(
                bytes, 0, bytes.length,
                InetAddress.getLoopbackAddress(),
                8088
        );
        DatagramSocket socket = new DatagramSocket(9999);
        Log.println("发送请求");
        socket.send(sent);

        byte[] buf = new byte[1024];
        DatagramPacket received = new DatagramPacket(buf, buf.length);
        socket.receive(received);
        int n = received.getLength();
        String response = new String(buf, 0, n, "utf-8");
        System.out.println(response);
    }
}

UDP客户端

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Arrays;
import java.util.HashMap;

/**
 * @author haomin
 * @date 2022/09/26 09:57
 **/
public class Server {
    // 1. 可以写在文件中
    // 2. 可以写在数据库中
    private static final HashMap<String, String> map = new HashMap<>();
    static {
        map.put("apple", "苹果");
        map.put("banana", "香蕉");
    }

    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(8080);
        while(true){
            // 1. 读取请求
            byte[] buf = new byte[1024];
            DatagramPacket received = new DatagramPacket(buf, buf.length);
            socket.receive(received); // 服务器会阻塞在这

            // 2. 处理
            InetAddress address = received.getAddress(); // 获得ip
            int port = received.getPort();               // 获得端口
            int n = received.getLength();                // 真正收到的数据长度
            byte[] actualData = Arrays.copyOf(buf, n);   // 真正有用的数据
            // byte[] + 字符集编码 -> String
            String request = new String(actualData, 0, actualData.length, "utf-8");

            // 3. 分析请求
            if(!request.startsWith("请求格式头\r\n") && !request.startsWith("请求格式尾\r\n")){
                continue; // 不符合应用层的请求协议，不做处理
            }
            String englishWord = request.substring("请求格式头\r\n".length(), request.length() - "请求格式尾\r\n".length());
            Log.println(englishWord);
            String chineseWord = map.getOrDefault(englishWord, "不认识");

            // 4. 发送响应
            String response = String.format("收到，响应为\r\n%s\r\n", chineseWord);
            // String + 字符集编码 -> byte[]
            byte[] bytes = response.getBytes("utf-8");
            DatagramPacket sent = new DatagramPacket(
                    bytes, 0, bytes.length,
                    address,
                    port
            );
            socket.send(sent);
            Log.println("响应成功"+response);
        }
    }
}

Log 日志?

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @author haomin
 * @date 2022/09/26 10:30
 **/
public class Log {
    public static void println(Object o){
        Date date = new Date();
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        String now = dateFormat.format(date);

        System.out.println(now + ": " + o.toString());
    }

    public static void print(Object o){
        Date date = new Date();
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        String now = dateFormat.format(date);

        System.out.print(now +": "+ o.toString());
    }

    public static void printf(String fmt, Object... args){
        Date date = new Date();
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        String now = dateFormat.format(date);

        System.out.printf(now + ": " + fmt, args);
    }

    public static void main(String[] args) {
        println("hello word");
        print("hello word\r\n");
        printf("%s","hello word");
    }
}

🧸4. TCP流套接字编程

和刚才UDP类似，实现一个简单的英译汉的功能

4.1 ServerSocket API

ServerSocket 是创建TCP服务端Socket的API。

ServerSocket 构造方法：

ServerSocket 方法：

4.2 Socket API

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

Socket 方法：

4.3?TCP中的长短连接

TCP发送数据时，需要先建立连接，什么时候关闭连接就决定是短连接还是长连接：
长连接:拨通电话->请求->响应->请求->响应->...->请求->响应->挂断电话
短连接:拨通电话->请求->响应->挂断电话->拨通电话->请求->响应->挂断电话...

对比以上长短连接，两者区别如下：

建立连接、关闭连接的耗时：短连接每次请求、响应都需要建立连接，关闭连接；而长连接只需要第一次建立连接，之后的请求、响应都可以直接传输。相对来说建立连接，关闭连接也是要耗时的，长连接效率更高。
主动发送请求不同：短连接一般是客户端主动向服务端发送请求；而长连接可以是客户端主动发送请求，也可以是服务端主动发。
两者的使用场景有不同：短连接适用于客户端请求频率不高的场景，如浏览网页等。长连接适用于客户端与服务端通信频繁的场景，如聊天室，实时游戏等。

4.4 示例一：TCP请求响应（短连接）

TCP服务端

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

/**
 * @author haomin
 * @date 2022/09/27 18:33
 **/
// UDP: 无连接       面向数据报文-写信（一信一送）
// TCP: 有连接       面向字节流  -写信（一堆信一送）-打电话(连接好才行)
public class Server {
    private static final HashMap<String, String> map = new HashMap<>();
    static {
        map.put("apple", "苹果");
        map.put("banana", "香蕉");
    }

    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080);
        while (true){
            // 1. 接通连接（电话） —— accept
            Socket socket = serverSocket.accept(); // 阻塞
            InetAddress inetAddress = socket.getInetAddress(); // 得到客户端地址
            int port = socket.getPort();                       // 得到客户端端口

            InputStream is = socket.getInputStream();  // is: 用于读数据
            OutputStream os = socket.getOutputStream();// os: 用于写数据

            // 2. 读取请求
            Scanner scanner = new Scanner(is, "utf-8");
            String header = scanner.nextLine();
            String englishWord = scanner.nextLine();

            // 3. 处理业务
            String chineseWord = map.getOrDefault(englishWord, "不认识");

            // 4. 发送响应
            // 好的\r\n苹果\r\n
            // OutputStream -> OutputStreamWriter -> PrintWriter
            OutputStreamWriter writer = new OutputStreamWriter(os, "utf-8");
            PrintWriter printWriter = new PrintWriter(writer);

            printWriter.printf("好的\r\n%s\r\n", chineseWord);
            printWriter.flush();

            socket.close();
            Log.println("服务器响应成功");
        }
    }
}

TCP客户端

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

/**
 * @author haomin
 * @date 2022/09/27 18:33
 **/
public class 短连接Client {
    public static void main(String[] args) throws IOException {
        while (true) {
            Socket socket = new Socket("127.0.0.1", 8080);

            InputStream is = socket.getInputStream();
            Scanner scanner = new Scanner(is, "utf-8");

            OutputStream os = socket.getOutputStream();
            OutputStreamWriter writer = new OutputStreamWriter(os, "utf-8");
            PrintWriter printWriter = new PrintWriter(writer);

            // 发送请求
            printWriter.println("我是Java19班的\r\nbanana\r\n");
            printWriter.flush();

            // 读取响应
            String header = scanner.nextLine();
            String chineseWord = scanner.nextLine();
            System.out.println("响应结果：" + chineseWord);

            socket.close();
        }
    }
}

4.5 示例二：TCP请求响应（长连接）

TCP服务端

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

/**
 * @author haomin
 * @date 2022/09/27 18:33
 **/
// UDP: 无连接       面向数据报文-写信（一信一送）
// TCP: 有连接       面向字节流  -写信（一堆信一送）-打电话(连接好才行)
public class 长连接Server {
    private static final HashMap<String, String> map = new HashMap<>();
    static {
        map.put("apple", "苹果");
        map.put("banana", "香蕉");
    }

    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080);
        while (true){
            // 1. 接通连接（电话） —— accept
            Socket socket = serverSocket.accept(); // 阻塞
            InetAddress inetAddress = socket.getInetAddress(); // 得到客户端地址
            int port = socket.getPort();                       // 得到客户端端口

            InputStream is = socket.getInputStream();  // is: 用于读数据
            OutputStream os = socket.getOutputStream();// os: 用于写数据
            // OutputStream -> OutputStreamWriter -> PrintWriter
            OutputStreamWriter writer = new OutputStreamWriter(os, "utf-8");
            PrintWriter printWriter = new PrintWriter(writer);

            // 2. 读取请求
            Scanner scanner = new Scanner(is, "utf-8");
            while (scanner.hasNextLine()) {
                String header = scanner.nextLine();
                String englishWord = scanner.nextLine();

                // 3. 处理业务
                String chineseWord = map.getOrDefault(englishWord, "不认识");

                // 4. 发送响应
                // 好的\r\n苹果\r\n
                printWriter.printf("好的\r\n%s\r\n", chineseWord);
                printWriter.flush();
                Log.println("服务器响应成功");
            }
            socket.close();
        }
    }
}

TCP客户端

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

/**
 * @author haomin
 * @date 2022/09/27 18:33
 **/
public class 长连接Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1", 8080);

        for (int i = 0; i < 3; i++) {
            InputStream is = socket.getInputStream();
            Scanner scanner = new Scanner(is, "utf-8");

            OutputStream os = socket.getOutputStream();
            OutputStreamWriter writer = new OutputStreamWriter(os, "utf-8");
            PrintWriter printWriter = new PrintWriter(writer);

            // 发送请求
            printWriter.printf("我是Java19班的\r\napple\r\n");
            printWriter.flush();

            // 读取响应
            String header = scanner.nextLine();
            String chineseWord = scanner.nextLine();
            System.out.println("响应结果：" + chineseWord);
        }

        socket.close();
    }
}

4.6?示例三：TCP请求响应（多线程+自定义协议）

TCP服务端

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author haomin
 * @date 2022/09/27 18:33
 **/
// UDP: 无连接       面向数据报文-写信（一信一送）
// TCP: 有连接       面向字节流  -写信（一堆信一送）-打电话(连接好才行)
public class 多线程长连接Server {
    private static final HashMap<String, String> map = new HashMap<>();
    static {
        map.put("apple", "苹果");
        map.put("banana", "香蕉");
    }

    private static class ServerTask implements Runnable{
        private final Socket socket;
        private ServerTask(Socket socket){
            this.socket = socket;
        }
        @Override
        public void run() {
            try {
                InetAddress inetAddress = socket.getInetAddress(); // 得到客户端地址
                int port = socket.getPort();                       // 得到客户端端口

                InputStream is = socket.getInputStream();  // is: 用于读数据
                OutputStream os = socket.getOutputStream();// os: 用于写数据
                // OutputStream -> OutputStreamWriter -> PrintWriter
                OutputStreamWriter writer = new OutputStreamWriter(os, "utf-8");
                PrintWriter printWriter = new PrintWriter(writer);

                // 2. 读取请求
                Scanner scanner = new Scanner(is, "utf-8");
                while (scanner.hasNextLine()) {
                    String header = scanner.nextLine();
                    String englishWord = scanner.nextLine();

                    // 3. 处理业务
                    String chineseWord = map.getOrDefault(englishWord, "不认识");

                    // 4. 发送响应
                    // 好的\r\n苹果\r\n
                    printWriter.printf("好的\r\n%s\r\n", chineseWord);
                    printWriter.flush();
                    Log.println("服务器响应成功");
                }
                socket.close();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) throws IOException {
        ExecutorService service = Executors.newFixedThreadPool(10);
        ServerSocket serverSocket = new ServerSocket(8080);
        while (true){
            // 1. 接通连接（电话） —— accept
            Socket socket = serverSocket.accept(); // 阻塞
            ServerTask task = new ServerTask(socket);
            service.execute(task);
        }
    }
}

TCP客户端

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

/**
 * @author haomin
 * @date 2022/09/27 18:33
 **/
public class 长连接子输入Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1", 8080);
        Scanner systemInSc = new Scanner(System.in);

        while (systemInSc.hasNextLine()){
            String w = systemInSc.nextLine();

            InputStream is = socket.getInputStream();
            Scanner scanner = new Scanner(is, "utf-8");

            OutputStream os = socket.getOutputStream();
            OutputStreamWriter writer = new OutputStreamWriter(os, "utf-8");
            PrintWriter printWriter = new PrintWriter(writer);

            // 发送请求
            printWriter.printf("我是Java19班的\r\n%s\r\n", w);
            printWriter.flush();

            // 读取响应
            String header = scanner.nextLine();
            String chineseWord = scanner.nextLine();
            System.out.println("响应结果：" + chineseWord);
        }

        socket.close();
    }
}