Beispielanalyse für den asynchronen Java-Rückrufmechanismus

1. Was ist ein Rückruf?

Rückruf, Rückruf. Es muss zunächst ein Anruf erfolgen, bevor es zu einem Rückruf zwischen dem Anrufer und dem Angerufenen kommt. In der Baidu-Enzyklopädie ist es also so:

Es gibt immer bestimmte Schnittstellen zwischen Softwaremodulen. In Bezug auf die Aufrufmethoden können sie in drei Kategorien unterteilt werden: synchrone Aufrufe, Rückrufe und asynchrone Aufrufe.
Rückruf ist eine besondere Art von Anruf und die drei Methoden unterscheiden sich ein wenig.

1. Synchroner Rückruf, also blockierend, einseitig.

2. Rückruf, also in beide Richtungen (ähnlich wie zwei Gänge bei einem Fahrrad).

3. Asynchroner Aufruf, d. h. Benachrichtigung durch asynchrone Nachricht.

2. Asynchrone Rückrufe in CS (Java-Fall)

Hier wird beispielsweise ein Szenario simuliert: Der Client sendet eine Nachricht an den Server und nachdem der Server sie verarbeitet hat (5 Sekunden), Es ruft den Client zurück und informiert Sie darüber, dass die Verarbeitung erfolgreich war. Der Code lautet wie folgt:

Callback-Schnittstellenklasse:

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

Simulierter 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);
    }
}

Simulierter 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 Klasse:

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

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

Führen Sie die Testklasse aus – die gedruckten Ergebnisse lauten wie folgt:

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

Analysieren Sie den Code Schritt für Schritt, die Kernzusammenfassung lautet wie folgt

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

3. Callback-Anwendungsszenarien

In welchen Szenarien werden Rückrufe am häufigsten verwendet? Aufruf vom Betriebssystem an Entwickler:

1. Der Nachrichtenmechanismus der Windows-Plattform 2. Rufen Sie die WeChat-Schnittstelle asynchron auf und reagieren Sie auf die Geschäftslogik entsprechend dem WeChat-Rückgabestatus. 3. Der Filter im Servlet basiert auf einer Rückruffunktion und benötigt Containerunterstützung.

Ergänzung: Der Unterschied zwischen Filter und Interceptor besteht darin, dass der Interceptor auf dem Reflexionsmechanismus von Java basiert und nichts mit dem Container zu tun hat. Aber es hat den gleichen Zweck wie der Rückrufmechanismus.

Kurz gesagt ermöglicht dieses Design dem zugrunde liegenden Code, Unterprogramme aufzurufen, die von der höheren Ebene (Implementierungsschicht) definiert werden, was die Flexibilität des Programms erhöht.

4. Modusvergleich

Wie oben erwähnt, verfolgen Filter und Intercepter ähnliche Ansätze, aber den gleichen Zweck. Tatsächlich ähnelt der Schnittstellen-Rückrufmechanismus auch einem Entwurfsmuster – dem Beobachtermuster:

Beobachtermuster:

GOF sagte: „Definieren Sie eine Eins-zu-Viele-Abhängigkeitsbeziehung von Objekten, Wenn sich der Status eines Objekts ändert, werden alle davon abhängigen Objekte benachrichtigt und aktualisiert. „Es handelt sich um ein Muster, das über die Rückrufmethode der Schnittstelle implementiert wird, das heißt, es ist eine Manifestation des Rückrufs.“

Schnittstellenrückruf:

Der Unterschied zum Beobachtermuster besteht darin, dass es sich um ein Prinzip und nicht um eine spezifische Implementierung handelt.

5. Erleben

Zusammenfassung der vier Schritte:

Der Mechanismus ist das Prinzip.
Modell ist Manifestation.
Erinnern Sie sich an bestimmte Szenarien und häufige Muster.
Dann verstehen Sie die Prinzipien gründlich.