[GO] [Viererbande] Designmuster lernen - Kette der Verantwortung

Verantwortungskette - Verantwortungskette

** Inhaltsverzeichnis ** Ist es dieses Muster, das es Eltern und Kind ermöglicht, das zu verarbeitende Objekt in dem Objekt mit einer Eltern-Kind-Beziehung flexibel zu bestimmen?

Zweck

Vermeiden Sie das Kombinieren von Objekten, die Anforderungen senden und empfangen, indem Sie einem oder mehreren Objekten die Möglichkeit geben, die Anforderung zu verarbeiten. Mehrere empfangende Objekte sind in einer Kette verbunden, und Anforderungen werden entlang der Kette weitergeleitet, bis ein Objekt die Anforderung verarbeitet.

Komponente

-Handler Abstrakte Klasse der Eltern- und Kinderklasse -ConcreteHandler Handlers konkrete Klasse ・ Client-Benutzer

Implementierung

Wenn Sie die Teile vergleichen, aus denen der Bildschirm besteht, haben sie meiner Meinung nach die folgende Eltern-Kind-Beziehung.

Fenster
----Dialog, der im Fenster angezeigt werden soll
--------Schaltflächen im Dialog
----Knopf im Fenster

Implementieren Sie Beispielcode, mit dem Sie frei entscheiden können, welches Objekt behandelt werden soll, wenn ein Problem auftritt, indem Sie eines der Objekte bearbeiten.

Handler Abstrakte Klasse der Eltern- und Kinderklasse

Gemeinsame Klasse Eine Oberklasse aller Objekte. Wenn der Nachrichtentyp beim Instanziieren der Ansicht auf etwas anderes als Normal gesetzt ist, wird die Verarbeitung für den Fehler im Objekt ausgeführt. Die Ansicht, für die Normal festgelegt ist, überlässt die Verarbeitung der übergeordneten Ansicht. Und die übergeordnete Ansicht ... wiederholt

View.kt

package chainofresponsibility

abstract class View(private val parent: View?, private val messageType: MessageType) {
    enum class MessageType {
        Normal,
        Warning,
        Danger
    }

    protected fun handleHelp() {
        if (hasMessage()) {
            helpLogic()
        } else {
            parent?.handleHelp()
        }
    }

    abstract fun helpLogic()

    private fun hasMessage(): Boolean {
        val ret = MessageType.Normal != messageType

        if (ret) {
            createDialog()
        }
        return ret
    }

    private fun createDialog() {
        when (messageType) {
            MessageType.Warning -> {
                print("Warndialog:")
            }
            MessageType.Danger -> {
                print("Fehlerdialog:")
            }
        }
    }

}

ConcreteHandler Handlers konkrete Klasse

Fenster

Window.kt

package chainofresponsibility

class Window(parent: View?, messageType: View.MessageType): View(parent, messageType) {

    override fun helpLogic() {
        println("Probleme durch Fenster!")
    }
}

Dialog

Dialog.kt

package chainofresponsibility

class Dialog(parent: View?, messageType: View.MessageType): View(parent, messageType) {

    override fun helpLogic() {
        println("Durch den Dialog verursachte Fehler!")
    }
}

Taste Wenn Sie einen Wert ungleich Null an die Aktionsmethode übergeben, tritt ein Problem auf.

Button.kt

package chainofresponsibility

class Button(parent: View?, messageType: View.MessageType): View(parent, messageType) {

    fun action(arg: Int) {
        if (arg == 0) {
            println("Erfolgreiche Fertigstellung")
        } else {
            handleHelp()
        }
    }

    override fun helpLogic() {
        println("Probleme durch Tasten!")
    }
}

Client-Benutzer

In Aktion (1) tritt ein Problem auf. Im folgenden Beispielcode fängt das Fenster den Fehler ab, der in button1 aufgetreten ist, und das Dialogfeld fängt den Fehler ab, der in button2 aufgetreten ist. Wenn Sie den Nachrichtentyp des Dialogfelds in "Normal" ändern, wird er vom Fenster abgefangen.

Client.kt

package chainofresponsibility

class Client {
    init {
        //Fenster
        val window = Window(null, View.MessageType.Danger)
        //Schaltflächen direkt unter dem Fenster
        val button1 = Button(window, View.MessageType.Normal)
        //Dialog direkt unter dem Fenster
        val dialog = Dialog(window, View.MessageType.Warning)
        //Schaltflächen im Dialogfeld platziert
        val button2 = Button(dialog, View.MessageType.Normal)

        button1.action(0)
        button1.action(1)
        button1.action(0)

        button2.action(0)
        button2.action(1)
        button2.action(0)
    }
}

Ausgabeergebnis

[out-put]
Erfolgreiche Fertigstellung
Fehlerdialog: Fehler durch Fenster verursacht!
Erfolgreiche Fertigstellung
Erfolgreiche Fertigstellung
Warndialog: Fehler, der durch den Dialog verursacht wurde!
Erfolgreiche Fertigstellung

Wie wäre es mit diesem Muster ...

Auf den ersten Blick scheint es unmöglich zu sein, zu verwalten, welches übergeordnete Objekt damit umgeht und schließlich einen Fehler verursacht, aber in erster Linie ist es ein Muster, das es unnötig macht, das Objekt zu kennen, das die Nachricht empfängt. Ist das also in Ordnung? .. Hmm.