[GO] [Viererbande] Designmuster lernen - Befehl

Befehl - Befehl

** Inhaltsverzeichnis ** Mit diesem Muster soll erkannt werden, dass die Anforderung dynamisch bearbeitet werden kann, indem die Anforderung in ein Objekt umgewandelt wird, und dass das Wartungsmanagement vereinfacht wird, indem eine Reihe von Prozessen zu einem Objekt kombiniert und eine gemeinsame Schnittstelle vorbereitet wird. Nicht wahr.

Ich sehe diese Methode oft.

Receiver.kt

    fun run(mode: ModeType) {
        when(mode) {
            ModeType.Begin -> {
                //Vorbereitungsprozess
                loadProperty()
                startDriver()
            }
            ModeType.Running -> {
                //Hauptverarbeitung
                running()
            }
            ModeType.After -> {
                //Verarbeitung beenden
                saveState()
                stopDriver()
            }
        }
    }

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

Da wir anhalten mussten, wollten wir einen Modus, der nur `saveState ()` heißt, also werden wir einen Modus und eine Implementierung hinzufügen.

Receiver.kt

        ModeType.Interruption -> {
            //Suspendierungsverarbeitung
            saveState()
        }

Wenn es um einen weiteren Modus geht ... muss die Klasse "Receiver" endlos geändert werden, und die Anzahl der "Mode" wird stetig zunehmen. Durch Anwenden dieses Musters wird es möglich sein, ein flexibles Verhalten zu haben, ohne die Klasse "Empfänger" zu ändern.

Zweck

Durch die Kapselung der Anforderung als Objekt wird der Client mit verschiedenen Anforderungen und Warteschlangen und Protokollen von Anforderungen parametrisiert. Es unterstützt auch rückgängig zu machende Operationen.

Komponente

· Eine abstrakte Klasse, die die von der Command Receiver-Klasse ausgeführten Methoden definiert -Concrete Command Befehlsklasse konkrete Klasse ・ Client-Benutzer ・ Anrufer ・ Eine Klasse, die weiß, wie ein Empfängerbefehl ausgegeben wird

Implementierung

Eine Klasse, die weiß, wie man eine Empfängeranweisung ausgibt

Mit Schnittstelle

Receiver.kt

package command

interface Receiver {
    fun getName(): String
}

Konkrete Klasse

Car.kt

package command

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

    override fun getName(): String {
        return "Der Empfänger ist${name}Ist ein Objekt"
    }

    fun openDoor() {
        println("öffne die Tür")
    }

    fun engineStart() {
        println("Motorstart")
    }

    fun engineStop() {
        println("Motor stoppt")
    }

    fun lock() {
        println("Sperren")
    }

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

    fun pushAxelPedal() {
        println("Treten Sie auf das Gaspedal")
    }

    fun pushBreakePedal() {
        println("Treten Sie auf das Bremspedal")
    }
}

Eine abstrakte Klasse, die die von der Command Receiver-Klasse ausgeführten Methoden definiert

Command.kt

package command

interface Command {
    fun execute()
}

Konkreter Befehl Befehlsklasse konkrete Klasse

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 Menschen, die verwenden Erstellen Sie einen Befehl zum Starten des Automotors.

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

Ausführungsergebnis

[out-put]
Freischalten
öffne die Tür
Motorstart

Ich wollte einen Befehl, um den Automotor zu stoppen.

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

Ausführungsergebnis

[out-put]
Motor stoppt
öffne die Tür
Sperren

Ich wollte einen Befehl zum Autofahren erstellen.

Client.kt

package command

class Client {

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

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

Ausführungsergebnis

[out-put]
Treten Sie auf das Gaspedal

Ich brauchte einen Befehl, um den Automotor zu starten, eine Weile zu laufen und dann den Motor abzustellen.

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

Ausgabeergebnis

[out-put]
Freischalten
öffne die Tür
Motorstart
Treten Sie auf das Gaspedal
Treten Sie auf das Gaspedal
Treten Sie auf das Gaspedal
Treten Sie auf das Gaspedal
Motor stoppt
öffne die Tür
Sperren

Wenn Sie die Anwendbarkeit des GoF-Buches lesen, besteht das Herzstück dieses Musters darin, dass Sie ** jede Anfrage abbrechen können, indem Sie die Anfrage objektivieren **, die sogenannte `MacroCommand```-Klasse` removeCommand``` Es scheint eine Methode aufzurufen, aber ich kann mir keine Situation vorstellen, die ich brauche.