Dies ist eine Vorgehensweise, wenn Sie verschiedene Verarbeitungsgruppen seriell ausführen möchten, nicht nur für Android.
Die Verarbeitung erfolgt nach dem Konzept des Ereignisses, und die Verarbeitung erfolgt über eine Managerklasse, die Ereignisse nacheinander ausführt. Bitte beziehen Sie den Quellcode von GitHub. https://github.com/ken-maki/k_commons.eventChain
Die Konfiguration ist wie folgt.
com.android.k.commons.eventchain ┣lib ┃┣EventChainManager ┃┃Eine Managerklasse, die Ereignisse nacheinander ausführt, eine Methode, die unterbricht, wenn das Verarbeitungsergebnis des Ereignisses fehlschlägt, und ┃┃ Es gibt eine Methode, um alle Ereignisse unabhängig vom Verarbeitungsergebnis des Ereignisses auszuführen. ┃┣EventChaining ┃┃ Schnittstelle zur Implementierung von Event. ┣events ┃┣EventFoo ┃┃ Zeigen Sie einfach das Beispielereignis und den Toast an. ┃┣EventBar ┃ ┃ Beispielereignis, Toastanzeige und Ereignisergebnis werden als falsch zurückgegeben (Verarbeitungsfehler). ┃┗EventBaz ┃ Zeigen Sie einfach das Beispielereignis und den Toast an. ┗MainActivity Ereignisbeispielaktivität, die ausgeführt werden soll.
EventChainManager.java
public class EventChainManager {
List<Pair<EventChaining, Boolean>> mEvents = new ArrayList<Pair<EventChaining, Boolean>>();
/**
* add event.
* <p>
* added event is serial executed.if event failed, break execute.
* </p>
*
* @param event executable event
* @return this EventChainManager instance
*/
public EventChainManager chain(final EventChaining event) {
mEvents.add(Pair.create(event, false));
return this;
}
/**
* add event.
* <p>
* added event is serial executed.if event failed, forward next event.
* </p>
*
* @param event executable event
* @return this EventChainManager instance
*/
public EventChainManager chainForce(final EventChaining event) {
mEvents.add(Pair.create(event, true));
return this;
}
/**
* execute chain events.
* <p>
* delete the event after execution
* </p>
*
* @return returns true if it event all succeeds.
*/
public boolean execute() {
boolean result = executeAndLeave();
removeAll();
return result;
}
/**
* execute chain events.
* <p>
* leave the event after execution
* </p>
*
* @return returns true if it event all succeeds.
*/
public boolean executeAndLeave() {
for (Pair<EventChaining, Boolean> event : mEvents) {
EventChaining chainEvent = event.first;
boolean isForced = event.second;
if (!chainEvent.action() && !isForced) {
return false;
}
}
return true;
}
/**
* remove all added Event.
*
* @param event event to removed
*/
public void remove(final EventChaining event) {
mEvents.remove(event);
}
/**
* remove all added Events.
*/
public void removeAll() {
mEvents.clear();
}
}
Eine Klasse, die ein Ereignis ausführt. Es gibt zwei Methoden, um ein Ereignis hinzuzufügen. ・ Kettenmethode Wenn das Ergebnis der Ereignisverarbeitung falsch ist (Fehler), verwenden Sie es, wenn Sie die Verarbeitung dort stoppen möchten. ・ ChainForce-Methode Wird verwendet, wenn Sie die Verarbeitung unabhängig vom Erfolg oder Misserfolg der Ereignisverarbeitung fortsetzen möchten. Starten Sie danach die sequentielle Verarbeitung von Ereignissen mit der Methode execute. Wenn Sie das hinzugefügte Ereignis so lassen möchten, wie es ist, nachdem die sequentielle Verarbeitung von Ereignissen abgeschlossen ist (wenn Sie es später erneut verarbeiten möchten) Verwenden Sie die Methode executeAndLeave.
EventChaining.java
public interface EventChaining {
/**
* execute an event.
*
* @return returns true if it event succeeds.
*/
boolean action();
}
Eine kleine Klasse, eine Schnittstelle zum Implementieren von Ereignissen. Schreiben Sie die Implementierung von Event in die Aktionsmethode. Der Erfolg oder Misserfolg der Ereignisverarbeitung wird von boolean zurückgegeben.
EventFoo.java
public class EventFoo implements EventChaining {
Context mContext;
public EventFoo(final Context context) {
mContext = context;
}
@Override
public boolean action() {
Toast.makeText(mContext, "EventFoo executed.", Toast.LENGTH_SHORT).show();
return true;
}
}
Implementierung des Ereignisses. Sie müssen lediglich die Ereignisverkettung implementieren und die Aktion implementieren.
MainActivity.java
public class MainActivity extends AppCompatActivity {
EventChainManager eventChainManager = new EventChainManager();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
final Context context = this;
Button button = (Button) findViewById(R.id.button);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
eventChainManager
.chain(new EventFoo(context))
.chainForce(new EventBar(context))
.chain(new EventBaz(context))
.execute();
}
});
Button button2 = (Button) findViewById(R.id.button2);
button2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
eventChainManager
.chain(new EventFoo(context))
.chain(new EventBar(context))
.chain(new EventBaz(context))
.execute();
}
});
}
}
Die Verwendung ist wie folgt. Die Punkte sind wie folgt.
eventChainManager .chain(new EventFoo(context)) .chainForce(new EventBar(context)) .chain(new EventBaz(context)) .execute();
Wenn Sie es bei der Verwendung so implementieren, ist es leicht zu lesen, dass das Ereignis seriell ausgeführt wird. In diesem Fall bedeutet dies, dass die Verarbeitung bis zu EventBaz ausgeführt wird, unabhängig vom Verarbeitungsergebnis der zweiten verketteten EventBar.
-Verbessert die Lesbarkeit (sollte) Da Sie Ereignisse schreiben können, indem Sie sie mit eventChainManager # chain verbinden, Diese Reihe von Prozessen ist nacheinander verbunden, sodass Sie Ihre Absicht zum Ausdruck bringen können, da es sich um eine Reihe von Prozessen handelt.
Ich dachte, es wurde geschrieben, aber ich frage mich, ob es für Fälle geeignet ist, in denen eine komplizierte Verarbeitung nacheinander ausgeführt wird.
Quellcode https://github.com/ken-maki/k_commons.eventChain
Recommended Posts