Java asynchronous callback mechanism example analysis

1. What is a callback?

Callback, callback. There must be a call first before there is a callback between the caller and the callee. So in Baidu Encyclopedia it is like this:

There are always certain interfaces between software modules. In terms of calling methods, they can be divided into three categories: synchronous calls, callbacks and asynchronous calls.
Callback is a special kind of call, and the three methods are a little different.

1. Synchronous callback, that is, blocking, one-way.

2. Callback, that is, two-way (similar to two gears on a bicycle).

3. Asynchronous call, that is, notification through asynchronous message.

2. Asynchronous callback in CS (Java case)

For example, here is a simulated scenario: the client sends msg to the server, and after the server processes it (5 seconds), it calls back to the client to inform the client that the processing is successful. The code is as follows:

Callback interface class:

public interface CSCallBack {
    
  public void process(String status); 
}

Simulated client:

public 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() {            
            @Override
            public void run() {
                server.getClientMsg(Client.this,msg);
            }
        }).start();
        System.out.println("客户端：异步发送成功");
    }    
            @Override
    public void process(String status) {
        System.out.println("客户端：服务端回调状态为：" + status);
    }
}

Simulated server:

public class Server {
 public void getClientMsg(CSCallBack csCallBack , String msg) {
        System.out.println("服务端：服务端接收到客户端发送的消息为:" + msg);        
       // 模拟服务端需要对数据处理
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("服务端:数据处理成功，返回成功状态 200");
        String status = "200";
        csCallBack.process(status);
    }
}

Test class:

public class CallBackTest {
    public static void main(String[] args) {
        Server server = new Server();
        Client client = new Client(server);

        client.sendMsg("Server,Hello~");
    }
}

Run the test class - the printed results are as follows:

客户端：发送的消息为：Server,Hello~
客户端：异步发送成功
服务端：服务端接收到客户端发送的消息为:Server,Hello~
（这里模拟服务端对数据处理时间，等待5秒）
服务端：数据处理成功，返回成功状态 200客户端：服务端回调状态为：200

Analyze the code step by step, The core summary is as follows

1、接口作为方法参数，其实际传入引用指向的是实现类
2、Client的sendMsg方法中，参数为final，因为要被内部类一个新的线程可以使用。这里就体现了异步。
3、调用server的getClientMsg()，参数传入了Client本身（对应第一点）。

3. Application scenarios of callbacks

In what scenarios are callbacks currently used more often? Calling from the operating system to developers:

1. The message mechanism of the Windows platform 2. Asynchronously call the WeChat interface and respond to the business logic according to the WeChat return status. 3. Filter in Servlet is based on callback function and needs container support.

Supplement: The difference between Filter and Interceptor is that the interceptor is based on Java’s reflection mechanism and has nothing to do with the container. But it is similar to the callback mechanism.

In short, this design allows the underlying code to call subroutines defined by the higher level (implementation layer), which enhances the flexibility of the program.

4. Mode Comparison

As mentioned above, Filter and Intercepter have the same purpose. In fact, the interface callback mechanism is also similar to a design pattern - the observer pattern:

Observer pattern:

GOF said - "Define a one-to-many dependency relationship of an object. When the state of an object changes, it sends At this time, all objects that depend on it are notified and updated. "It is a pattern that is implemented through the interface callback method, that is, it is a manifestation of callback.

Interface callback: The difference between

and the observer pattern is that it is a principle rather than a specific implementation.

5. Experience

Summary in four steps:

The mechanism is the principle.
Pattern is manifestation.
Remember specific scenarios and common patterns.
Then understand the principles in depth.