[JAVA] Pratique à utiliser lorsque vous souhaitez exécuter différents groupes de traitement en série

Aperçu

Il s'agit d'une pratique lorsque vous souhaitez exécuter différents groupes de traitement en série, sans se limiter à Android.

Détails

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.

Description de la source

Partie bibliothèque

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.

Pièces de mise en œuvre individuelles

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.

mérite

-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.

Supplément

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

Pratique à utiliser lorsque vous souhaitez exécuter différents groupes de traitement en série
Lorsque vous souhaitez utiliser la méthode à l'extérieur
Delicate est pratique à utiliser lorsque vous souhaitez réutiliser des pièces
Lorsque vous souhaitez lier InputStream dans JDBI3
[Swift] Utilisez nonzeroBitCount lorsque vous voulez popcnt dans Swift
Qu'utilisez-vous lors de la conversion en String?
[Ruby] Lorsque vous souhaitez remplacer plusieurs caractères
Si vous souhaitez utiliser Mockito avec Kotlin, utilisez mockito-kotlin
[swift5] Comment exécuter le traitement lorsque tabBar est appuyé
Lorsque vous souhaitez remplacer dynamiquement l'annotation dans Java 8
Remarques à vérifier lorsque vous essayez d'utiliser Lombok
Code à utiliser lorsque vous souhaitez traiter Json en Java avec uniquement des bibliothèques standard
Utilisez JLine lorsque vous souhaitez gérer les frappes sur la console caractère par caractère en Java
Lorsque vous souhaitez écrire explicitement OR ou AND avec ransack
docker-compose.yml lorsque vous voulez garder mysql en cours d'exécution avec docker
lombok.config lorsque vous voulez passer @Qualifier à @RequiredArgsConstructor avec lombok
ProxyFactory est pratique lorsque vous souhaitez tester AOP avec Spring!
Lorsque vous avez introduit la devise mais que vous souhaitez ajouter plus de colonnes
[RSpec] Lorsque vous souhaitez utiliser la variable d'instance du contrôleur dans le test [attribuer n'est pas recommandé]
[Traitement × Java] Comment utiliser les variables
[Traitement × Java] Comment utiliser les tableaux
Un mémo lorsque vous souhaitez effacer la partie horaire de l'agenda
Si vous souhaitez utiliser Oracle JDK 11 à partir de septembre (ajoutez Amazon Corretto)
Lorsque vous souhaitez que Rails désactive une session pour un contrôleur spécifique
Résumé des moyens lorsque vous souhaitez communiquer avec HTTP sur Android
eclipse Je veux vraiment que vous utilisiez la touche de raccourci transcendantale recommandée (Windows)