In der modernen Anwendungsentwicklung erfreut sich die ereignisgesteuerte Entwicklung immer größerer Beliebtheit. Entwickler verwenden heutzutage häufig synchrone und asynchrone Callbacks in ihren Anwendungen, um Flexibilität zu erreichen. Während das Konzept in der Java-Gemeinde als Callbacks bekannt ist, wird es in der .NET-Welt als Delegates bezeichnet. Heute werden wir die Callback-Methoden anhand von drei einfachen Beispielen anschaulich erklären

Was ist ein Rückruf?

Callbacks ist ein Mechanismus in der objektorientierten Programmierung, der es einer Anwendung ermöglicht, abonnierte Ereignisse, die zur Laufzeit auftreten, über eine Listener-Schnittstelle zu behandeln. Die Abonnenten müssen eine konkrete Implementierung der abstrakten Methoden der Schnittstelle bereitstellen. Auf diese Weise werden bei jedem Auslösen des angegebenen Ereignisses die damit verbundenen vordefinierten Aktionen in der Reihenfolge ausgeführt, in der sie definiert wurden.

Beispiele:

Basisinstanz:

In diesem Beispiel wird das Konzept der Erstellung eines Rückrufs in vier Schritten erklärt:
Erstellen Sie zunächst eine Rückrufschnittstelle und deklarieren Sie darin die Methoden, die zurückgerufen werden sollen. Diese abstrakten Methoden repräsentieren die Ereignisse, die die Callback-Methoden in der Hauptklasse auslösen werden.

Rufen wir die Schnittstelle ActionListenerCallback auf, mit den abstrakten Methoden onActionSuccess und onActionFailure , die mit einer konkreten Implementierung als Argument an den setActionListener übergeben werden, durch eine anonyme Instanz des ActionListenerCallback.

 public interface ActionListenerCallback { public void onActionSuccess(String successMessage; public void onActionFailure(Throwable throwableError); }

Erstellen Sie die WorkerClass, das ist die Klasse, die das Ereignis erzeugt und die entsprechenden Callback-Methoden basierend auf den vordefinierten Bedingungen auslöst. Die WorkerClass enthält die setActionListener-Methode, die es den Subscriber-Objekten ermöglicht, ihre Callbacks als Argument zu senden, und zwar über eine anonyme ActionListenerCallback-Schnittstelle.

public class Worker { ActionListenerCallback callBack; public Worker() { //Initialisierung des Callback-Objekts aus dem Konstruktor this.callBack = null; } public void setActionListener(ActionListenerCallback callBack) { this.callBack = callBack; System.out.println("Ausführen einer Aufgabe, bevor der Callback aufgerufen wird"); if (this.callBack!= null) { callBack.onActionSuccess (successMessage); else callBack.onActionFailure (throwableError); } } 

Stellen Sie die gewünschte Reaktion auf das Ereignis bereit, indem Sie die Callback-Methoden in der SubscriberActivity-Klassedefinieren. Im folgenden Code wird mit der setActionListenermethodeder anonyme ActionListenerCallback an das Worker-Objekt angehängt, so dass es bereit ist zu reagieren, wenn das angegebene Ereignis ausgelöst wird.

public class SubscriberActivity extends Activity { @Overrideprotected void onCreate(Bundle savedInstanceState) { Worker worker = new Worker (); worker.setActionListener(new ActionListenerCallback () { @Overridepublic void onActionSuccess(StringsuccessMessage) { System.out.println("Das Ereignis wurde erfolgreich ausgelöst"); } @Overridepublic void onActionFailure(Throwable throwableError) { System.err.println("Fehler: " + throwableError.getMessage()); } }); } }

Android Callback Listener Beispiel:

Wir haben uns für das zweite Beispiel aus dem Android-Framework entschieden, weil es so beliebt ist. Android hält die Interaktion zwischen dem Endbenutzer und der Anwendung aufrecht, indem es das weit verbreitete Listener Design Pattern verwendet. Alle UI-Komponenten, wie z. B. eine Schaltfläche, erben von der Klasse View, die wiederum die Schnittstelle Callback aus dem Paket android.graphics.drawable implementiert. Die Klasse View enthält alle Ereignis-Listener, um die verschiedenen Ereignisse der Benutzeroberfläche abzufangen. Jeder dieser Listener enthält nur eine Callback-Methode.

Werfen wir einen Blick auf einen der meistgenutzten Callbacks in Android, onClick(), er ist im View.OnClickListenerinterfacedeklariert, wie unten zu sehen. Wenn das Klick-Ereignis auf das jeweilige UI-Element eintritt, wird die Methode OnClick() ausgelöst und führt die von den abonnierenden Objekten definierten Operationen aus

public static interface OnClickListener() { void onClick(View view); }

Dann wird der Callback-Code definiert und über das OnClickListener-Interfacean die Schaltfläche angehängt, um auf das Auslösen des Klick-Ereignisses zu warten. Das Oberflächenelement, das in diesem Beispiel eine Schaltfläche ist, verwendet die setOnClickListener-Methode aus seiner Oberklasse View, um das Ereignis zu abonnieren und eine eigene Implementierung der Callback-Funktion bereitzustellen.

Button button = (Button) findViewById(R.id.button); button.setOnClickListener(new View.OnClickListener() { @Overridepublic void onClick(View view) { InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(view.getWindowToken(), 0); startRegistration(); });

Für eine vollständige Referenz finden Sie unten den setOnClickListener in der Klasse View.

public void setOnClickListener(@Nullable View.OnClickListener l) { throw new RuntimeException("Stub!");

} 

Orchestration SDK Callback Beispiel:

Um die Reaktionsfähigkeit der integrierten Anwendung zu erhalten, verwendet das Orchestration SDK einen asynchronen Ansatz, bei dem der Integrator konkrete Implementierungen der Callback-Methoden für die verschiedenen vom Orchestration SDK bereitgestellten Aktivitäten bereitstellen muss. Auf diese Weise wird das integrierende Objekt bei einem Listener registriert, und es könnte seine Ausführung mit einer anderen Operation fortsetzen. Immer, wenn ein Ereignis eintritt, führt das Orchestrierungs-SDK den mit diesem Ereignis verknüpften Code aus, einschließlich der vom integrierenden Entwickler definierten Callback-Methoden.

HINWEIS: Die Callback-Methoden werden unter Android vom UI-Thread und unter iOS vom Hauptthread aufgerufen.

Ein Beispiel für die Verwendung der Callback-Methoden des Orchestration SDK findet sich in der MainActivity der Beispielanwendung. Die sendCommandToServerMethodeinstanziiert ein CommandSender-Objekt mit einem anonymen Objekt des CommandSenderCallbackInterface. Dieses Anonym trägt die konkrete Implementierung von onCommandSendingFailureundonCommandSendingSuccess. Außerdem wird der Anwendungskontext als Argument an das CommandSender-Objektübergeben.
Nach dieser Einrichtung werden die Callback-Methoden in der festgelegten Reihenfolge aufgerufen, wenn die asynchrone Ausführungsmethode auf dem CommandSender-Objekt
ausgeführt wird

private void sendCommandToServer(String command) { CommandSender commandSender = new CommandSender(getApplicationContext(), new CommandSenderCallback() { @Overridepublic void onCommandSendingFailure() { UIUtils.hideProgress(progressDialog); UIUtils.displayAlert(MainActivity.this, getString(R.string.dialog_error_title), getString(R.string.dialog_error_content_sending)); } @Overridepublic void onCommandSendingSuccess(String serverCommand) { orchestrator.execute(serverCommand); } }); commandSender.execute(command);

Dieses Tutorial war ein Einstieg in das Konzept der Callback-Methoden und sollte ein grundlegendes Verständnis für den Fluss zwischen den verschiedenen Aktivitäten der OneSpan Mobile Security Suite vermitteln. Wir werden uns auf dieses Grundkonzept stützen, wenn wir in den kommenden Blogs weiter darauf eingehen. Wenn Sie in der Zwischenzeit Fragen haben, wenden Sie sich an uns in den OneSpan Community Portal-Foren.

OneSpan Sign-Entwickler-Community

Treten Sie der OneSpan Sign Developer Community bei! Foren, Blogs, Dokumentationen, SDK-Downloads und mehr.

Tritt heute bei