Il s'agit d'une pratique lorsque vous souhaitez exécuter différents groupes de traitement en série, sans se limiter à Android.
Le traitement est géré par le concept d'événement et le traitement est exécuté via une classe de gestionnaire qui exécute les événements de manière séquentielle. Veuillez obtenir le code source de GitHub. https://github.com/ken-maki/k_commons.eventChain
La configuration est la suivante.
com.android.k.commons.eventchain ┣lib ┃┣EventChainManager ┃ ┃ Une classe de gestionnaire qui exécute des événements de manière séquentielle, une méthode qui s'interrompt lorsque le résultat du traitement de l'événement échoue, et ┃┃ Il dispose d'une méthode pour exécuter tous les événements quel que soit le résultat du traitement de l'événement. ┃┣EventChaining ┃┃ Interface pour implémenter l'événement. ┣events ┃┣EventFoo ┃┃ Affichez simplement l'exemple d'événement et un toast. ┃┣EventBar ┃ ┃ Exemple d'événement, affichage du toast et résultat de l'événement renvoyé comme faux (échec du traitement). ┃┗EventBaz ┃ Affichez simplement l'exemple d'événement et un toast. ┗MainActivity Exemple d'activité d'événement à exécuter.
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();
}
}
Une classe qui exécute un événement. Il existe deux méthodes pour ajouter un événement. ・ Méthode de la chaîne Si le résultat du traitement des événements est faux (échec), utilisez-le lorsque vous souhaitez y arrêter le traitement. ・ Méthode ChainForce Utilisé lorsque vous souhaitez poursuivre le traitement indépendamment du succès ou de l'échec du traitement des événements. Après cela, démarrez le traitement séquentiel des événements avec la méthode execute. Lorsque vous souhaitez conserver l'événement ajouté tel quel une fois le traitement séquentiel des événements terminé (lorsque vous souhaitez le traiter à nouveau plus tard) Utilisez la méthode executeAndLeave.
EventChaining.java
public interface EventChaining {
/**
* execute an event.
*
* @return returns true if it event succeeds.
*/
boolean action();
}
Une petite classe, une interface pour implémenter des événements. Écrivez l'implémentation d'Evénement dans la méthode d'action. Le succès ou l'échec du traitement des événements est renvoyé par booléen.
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;
}
}
Mise en œuvre de l'événement. Tout ce que vous avez à faire est de mettre en œuvre le chaînage d'événements et de mettre en œuvre l'action.
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();
}
});
}
}
L'utilisation est comme ça. Les points sont les suivants.
eventChainManager .chain(new EventFoo(context)) .chainForce(new EventBar(context)) .chain(new EventBaz(context)) .execute();
Si vous l'implémentez comme ceci lors de son utilisation, il sera facile de lire que l'événement est exécuté en série. Dans ce cas, cela signifie que le traitement est exécuté jusqu'à EventBaz quel que soit le résultat du traitement de la deuxième EventBar chaînée.
-Améliore la lisibilité (devrait) Puisque vous pouvez écrire des événements en les connectant à l'aide de la chaîne eventChainManager #, Cette série de processus est connectée en séquence, vous pouvez donc exprimer votre intention car il s'agit d'un lot de processus.
Je pensais qu'il était écrit, mais je me demande s'il convient aux cas où un traitement compliqué est exécuté séquentiellement.
Code source https://github.com/ken-maki/k_commons.eventChain
Recommended Posts