import java.lang.Thread;

// 1. 定义回调接口：约定服务端处理完后要调用的方法
interface CSCallback {
    // 服务端处理完成后，回调客户端的这个方法传递状态
    void process(String status);
}

// 2. 服务端类：接收消息、处理、回调客户端
class Server {
    // 方法参数用接口CSCallback：接收“实现了该接口的客户端对象”
    public void getClientMsg(CSCallback csCallback, String msg) {
        // 打印服务端接收消息的日志
        System.out.println("服务端：收到客户端消息 -> [" + msg + "]，开始处理（预计5秒）...");
        
        try {
            // 模拟服务端处理数据的耗时（阻塞当前线程5秒）
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 处理完成，准备回调客户端
        System.out.println("服务端：数据处理完成，准备返回状态");
        String resultStatus = "200（成功）";
        // 调用“客户端实现的process方法”：实际执行的是Client类的process
        csCallback.process(resultStatus);
    }
}

// 3. 客户端类：实现回调接口，发送消息给服务端
class Client implements CSCallback {
    private Server server; // 客户端持有服务端的引用（用于发消息）

    // 构造方法：初始化时关联服务端
    public Client(Server server) {
        this.server = server;
    }

    // 客户端发送消息的方法（异步）
    public void sendMsg(final String msg) {
        System.out.println("客户端：准备发送消息 -> [" + msg + "]");
        
        // 启动新线程：让服务端的处理在新线程中执行，不阻塞客户端主线程
        new Thread(new Runnable() {
            public void run() {
                // 把“客户端自己（实现了CSCallback）”和消息传给服务端
                server.getClientMsg(Client.this, msg);
            }
        }).start();

        // 主线程不用等待，直接继续执行
        System.out.println("客户端：消息已异步发出，主线程可以做其他事");
    }

    // 实现回调接口的方法：服务端处理完后会调用这个方法
    @Override
    public void process(String status) {
        System.out.println("客户端：收到服务端回调 -> 处理状态：" + status);
    }
}

// 4. 测试类：启动程序
public class TestCallBack {
    public static void main(String[] args) {
        // 创建服务端实例
        Server server = new Server();
        // 创建客户端实例（关联服务端）
        Client client = new Client(server);
        
        // 客户端发送消息
        client.sendMsg("Server, Hello! 我是客户端~");
        // 验证主线程不阻塞：这行代码会在服务端处理时直接执行
        System.out.println("测试类：主线程未被阻塞，继续执行其他逻辑");
    }
}

interface CSCallback { // 定义回调的“协议”：服务端处理完后要调用这个方法
    public void process(String status);
}

class Server { // 服务端：接收客户端消息、处理、回调通知
    public void getClientMsg(CSCallback csCallback, String msg) {
        // 1. 打印接收消息的日志
        System.out.println("服务端：服务端接收到客户端发送的消息为 [" + msg + "], 经过5秒后...");
        
        try {
            Thread.sleep(5 * 1000); // 模拟服务端“处理数据需要5秒”（阻塞当前线程）
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 2. 处理完成后，准备回调客户端
        System.out.println("服务端：数据处理成功，返回成功状态 [200]");
        String status = "200";
        csCallback.process(status); // 调用客户端实现的process方法（回调！）
    }
}

class Client implements CSCallback { // 客户端：实现回调接口，接收服务端的通知
    private Server server; // 客户端持有服务端的引用（要给服务端发消息）

    // 构造方法：初始化服务端对象
    public Client(Server server) {
        this.server = server;
    }

    // 客户端发送消息的方法
    public void sendMsg(final String msg) {
        System.out.println("客户端：发送的消息为 [" + msg + "]");
        
        // 关键：创建新线程，异步调用服务端的getClientMsg
        new Thread(new Runnable() {
            public void run() {
                // 把“客户端自己（this）”和消息传给服务端
                server.getClientMsg(Client.this, msg); 
            }
        }).start(); // 启动线程，异步执行
        
        // 主线程不用等服务端处理，直接继续执行
        System.out.println("客户端：异步发送成功");
    }

    // 实现回调接口的方法：服务端处理完后会调用这个方法
    public void process(String status) {
        System.out.println("客户端：服务端回调状态为 [" + status + "]");
    }
}

// 接口
interface CSCallback {
    void process(String status);
}

// 实现类（客户端）
class Client implements CSCallback {
    @Override
    public void process(String status) {
        System.out.println("回调状态：" + status);
    }
}

// 服务端方法：参数是CSCallback接口
public void getClientMsg(CSCallback csCallback, String msg) {
    // 逻辑...
}

// 调用时传参：传入“实现了CSCallback的Client对象”
Client client = new Client();
server.getClientMsg(client, "消息"); // ✅ 完全合法

// 耦合度极高！如果换一个Client2类，这个方法就用不了了
public void getClientMsg(Client client, String msg) { ... }

// 服务端方法里的参数：接口类型的引用变量
CSCallback csCallback;

Client client = new Client(); // 创建Client对象（实现了CSCallback）
server.getClientMsg(client, "消息"); // 把Client对象传给csCallback参数

csCallback.process(status); // 实际调用的是Client类重写的process方法

public class Test {
    public static void main(String[] args) {
        // 接口类型变量，指向实现类对象
        CSCallback callback = new Client(); 
        
        // 打印变量的真实类型：class Client（不是接口）
        System.out.println(callback.getClass().getName()); 
        
        // 调用process，实际执行Client的process方法
        callback.process("200"); 
    }
}