[GO] [Gang of Four] Apprentissage des modèles de conception - Commande

Commande --commande

** Table des matières ** Le but de ce modèle est de réaliser que la demande peut être éditée dynamiquement en transformant la demande en un objet, et que la gestion de la maintenance est simplifiée en combinant une série de processus en un seul objet et en préparant une interface commune. N'est-ce pas.

Je vois souvent cette méthode.

Receiver.kt

    fun run(mode: ModeType) {
        when(mode) {
            ModeType.Begin -> {
                //Processus de préparation
                loadProperty()
                startDriver()
            }
            ModeType.Running -> {
                //Traitement principal
                running()
            }
            ModeType.After -> {
                //Terminer le traitement
                saveState()
                stopDriver()
            }
        }
    }

    private fun loadProperty(){}
    private fun startDriver(){}
    private fun running(){}
    private fun saveState(){}
    private fun stopDriver(){}

Puisque nous devions suspendre, nous voulions un mode qui n'appellerait que `` saveState () '', nous allons donc ajouter un mode et une implémentation.

Receiver.kt

        ModeType.Interruption -> {
            //Traitement de suspension
            saveState()
        }

Dans un autre mode encore ..., la classe Receiver doit être modifiée à l'infini, et le nombre de `` Mode augmentera régulièrement. En appliquant ce modèle, il sera possible d'avoir un comportement flexible sans modifier la classe `` Receiver ''.

Objectif

En encapsulant la demande en tant qu'objet, le client est paramétré avec différentes demandes et files d'attente et journaux de demandes. Il prend également en charge les opérations annulables.

Composant

· Une classe abstraite qui définit les méthodes exécutées par la classe Command Receiver -Concrete Command Command classe béton classe ・ Utilisateurs clients ・ Invocateur ・ Une classe qui sait émettre une commande Receiver

la mise en oeuvre

Une classe qui sait comment émettre une instruction Receiver

Avec interface

Receiver.kt

package command

interface Receiver {
    fun getName(): String
}

Classe de béton

Car.kt

package command

class Car(private val name: String): Receiver {

    override fun getName(): String {
        return "Le récepteur est${name}Est un objet"
    }

    fun openDoor() {
        println("ouvre la porte")
    }

    fun engineStart() {
        println("Démarrage du moteur")
    }

    fun engineStop() {
        println("Arrêt du moteur")
    }

    fun lock() {
        println("Fermer à clé")
    }

    fun unlock() {
        println("ouvrir")
    }

    fun pushAxelPedal() {
        println("Montez sur l'accélérateur")
    }

    fun pushBreakePedal() {
        println("Appuyez sur la pédale de frein")
    }
}

Une classe abstraite qui définit les méthodes exécutées par la classe Command Receiver

Command.kt

package command

interface Command {
    fun execute()
}

Concrete Command Classe de commande classe de béton

SimpleCommand.kt

package command

class SimpleCommand(private val receiver: Receiver, private val method: String): Command {
    override fun execute() {
        receiver.javaClass.getDeclaredMethod(method).invoke(receiver)
    }
}

MacroCommand.kt

package command

import kotlin.collections.ArrayList

class MacroCommand: Command {
    private val commandList = ArrayList<Command>()

    override fun execute() {
        commandList.forEach {
            it.execute()
        }
    }

    fun addCommand(command: Command) {
        commandList.add(command)
    }

    fun removeCommand(command: Command) {
        commandList.remove(command)
    }
}

Client Les personnes qui utilisent Créez une commande pour démarrer le moteur de la voiture.

Client.kt

package command

class Client {

    init {
        val receiver = Car("Prius")
        createStartCarCommand(receiver).execute()
    }

    private fun createStartCarCommand(receiver: Car): Command {
        val startCarCommand = MacroCommand()
        startCarCommand.addCommand(SimpleCommand(receiver, "unlock"))
        startCarCommand.addCommand(SimpleCommand(receiver, "openDoor"))
        startCarCommand.addCommand(SimpleCommand(receiver, "engineStart"))
        return startCarCommand
    }
}

Résultat d'exécution

[out-put]
ouvrir
ouvre la porte
Démarrage du moteur

Je voulais une commande pour arrêter le moteur de la voiture.

Client.kt

package command

class Client {

    init {
        val receiver = Car("Prius")
        createStopCarCommand(receiver).execute()
    }

    private fun createStopCarCommand(receiver: Car): Command {
        val stopCarCommand = MacroCommand()
        stopCarCommand.addCommand(SimpleCommand(receiver, "engineStop"))
        stopCarCommand.addCommand(SimpleCommand(receiver, "openDoor"))
        stopCarCommand.addCommand(SimpleCommand(receiver, "lock"))
        return stopCarCommand
    }
}

Résultat d'exécution

[out-put]
Arrêt du moteur
ouvre la porte
Fermer à clé

Je voulais créer une commande pour conduire une voiture.

Client.kt

package command

class Client {

    init {
        val receiver = Car("Prius")
        createCarRunCommand(receiver).execute()
    }

    private fun createCarRunCommand(receiver: Car): Command {
        return SimpleCommand(receiver, "pushAxelPedal")
    }
}

Résultat d'exécution

[out-put]
Montez sur l'accélérateur

J'avais besoin d'une commande pour démarrer le moteur de la voiture, faire fonctionner pendant un moment, puis arrêter le moteur.

Client.kt

package command

class Client {

    init {
        val receiver = Car("Prius")
        createStartAndRunAndStopCarCommand(receiver).execute()
    }

    private fun createStartAndRunAndStopCarCommand(receiver: Car): Command {
        val startAndRunAndStopCarCommand = MacroCommand()
        startAndRunAndStopCarCommand.addCommand(createStartCarCommand(receiver))

        val runCommand = createCarRunCommand(receiver)
        startAndRunAndStopCarCommand.addCommand(runCommand)
        startAndRunAndStopCarCommand.addCommand(runCommand)
        startAndRunAndStopCarCommand.addCommand(runCommand)
        startAndRunAndStopCarCommand.addCommand(runCommand)

        startAndRunAndStopCarCommand.addCommand(createStopCarCommand(receiver))

        return startAndRunAndStopCarCommand
    }

    private fun createStartCarCommand(receiver: Car): Command {
        val startCarCommand = MacroCommand()
        startCarCommand.addCommand(SimpleCommand(receiver, "unlock"))
        startCarCommand.addCommand(SimpleCommand(receiver, "openDoor"))
        startCarCommand.addCommand(SimpleCommand(receiver, "engineStart"))
        return startCarCommand
    }

    private fun createCarRunCommand(receiver: Car): Command {
        return SimpleCommand(receiver, "pushAxelPedal")
    }

    private fun createStopCarCommand(receiver: Car): Command {
        val stopCarCommand = MacroCommand()
        stopCarCommand.addCommand(SimpleCommand(receiver, "engineStop"))
        stopCarCommand.addCommand(SimpleCommand(receiver, "openDoor"))
        stopCarCommand.addCommand(SimpleCommand(receiver, "lock"))
        return stopCarCommand
    }
}

Résultat de sortie

[out-put]
ouvrir
ouvre la porte
Démarrage du moteur
Montez sur l'accélérateur
Montez sur l'accélérateur
Montez sur l'accélérateur
Montez sur l'accélérateur
Arrêt du moteur
ouvre la porte
Fermer à clé

Si vous lisez l'applicabilité du livre du GoF, l'essence de ce modèle est que vous pouvez annuler toute demande ** en objectivant la demande **, la classe dite MacroCommand '' `removeCommand``` Cela semble appeler une méthode, mais je ne peux pas penser à une situation dont j'ai besoin.