[GO] [Viererbande] Designmuster lernen --Proxy

Proxy-Proxy

** Inhaltsverzeichnis ** Eines der Motive besteht darin, dieses Muster anzuwenden, wenn ein Objekt verwendet wird, dessen Generierung und Initialisierung teuer ist (wenn es in einer GUI-Anwendung auf dem Bildschirm angezeigt wird) und es zum ersten Mal instanziiert.

Es ist erforderlich, 1000 Bilder auf einem bestimmten Bildschirm anzuzeigen, es können jedoch nur 10 Bilder im effektiven Zeichenbereich angezeigt werden. Wenn jedoch zum Zeitpunkt der Erstanzeige 1000 Grafikklassenobjekte instanziiert und 1000 Bilder geladen werden, müssen Ressourcen für die Verarbeitung bereitgestellt werden, die nicht so mit der Erstanzeige zusammenhängt.

Es scheint, dass dieses Muster verwendet wird, um solche Probleme zu lösen. Der Proxy wird dem Bereich zugewiesen, in dem das Grafikobjekt ursprünglich zugewiesen wurde, und das Bild wird nur geladen, wenn es Zeit ist, es anzuzeigen.

Zweck

Um den Zugriff auf ein Objekt zu steuern, geben Sie einen Ersatz oder Container für dieses Objekt an.

Komponente

・ Proxy Shadow Warrior Klasse -Abstrakte Klasse der Subject Proxy-Klasse und der Real Subject-Klasse ・ RealSubject echte Klasse

Implementierung

Implementieren Sie nun das Bildzeichnungsprogramm als Beispielcode. Da es schwierig ist, tatsächlich 1000 Teile zu instanziieren, wird die Anzahl der Zeichnungen zum Zeitpunkt der Erstanzeige auf 3 festgelegt.

Abstrakte Klasse der Subject Proxy-Klasse und der Real Subject-Klasse

Subject.kt

package proxy

interface Subject {
    fun draw()
}

RealSubject echte Klasse

Bildklasse Klasse zum Lesen von Sofortbildern nach der Instanziierung

Image.kt

class Image(private val filePath: String): Subject {

    init {
        loadImage(filePath)
    }

    override fun draw() {
        println("${filePath}Zeichnen")
    }

    private fun loadImage(filePath: String) {
        println("${filePath}Lesen")
    }
}

Verwenden Sie diese Bildklasse, um den Bildschirm zunächst anzuzeigen.

Client-Klasse

Client.kt

package proxy

class Client {
    private val initDrawNum = 3

    init {
        val imageList = getNonProxyImageList()
        for (i in 0 until initDrawNum) {
            imageList[i].draw()
        }
    }

    private fun getNonProxyImageList(): ArrayList<Subject> {
        val imageList = ArrayList<Subject>()
        imageList.add(Image("./image/Apfel.png "))
        imageList.add(Image("./image/Mandarine.png "))
        imageList.add(Image("./image/Pfirsiche.png "))
        imageList.add(Image("./image/Banane.png "))
        imageList.add(Image("./image/Painapuru.png "))
        imageList.add(Image("./image/Erdbeere.png "))

        return imageList
    }
}

[out-put]
./image/Apfel.Lesen Sie png
./image/Mandarine.Lesen Sie png
./image/Pfirsiche.Lesen Sie png
./image/Banane.Lesen Sie png
./image/Painapuru.Lesen Sie png
./image/Erdbeere.Lesen Sie png
./image/Apfel.Zeichne png
./image/Mandarine.Zeichne png
./image/Pfirsiche.Zeichne png

Alle Bilder wurden geladen, obwohl es ausreicht, nur drei anzuzeigen. Verwenden wir die Proxy-Klasse.

Proxy Shadow Warrior Class

Image Proxy-Klasse Einmal geladen, bleibt es für immer erhalten, aber es ist besser, eine Methode zu implementieren, um das geladene Bild freizugeben, wenn es den effektiven Zeichenbereich verlässt.

Es ist jedoch ärgerlich, deshalb werde ich es diesmal weglassen.

ImageProxy.kt

package proxy

class ImageProxy(private val filePath: String): Subject {
    var image: Image? = null

    override fun draw() {
        image?.let { unwrapImage ->
            unwrapImage.draw()
        } ?: run {
            val tmpImage = Image(filePath)
            tmpImage.draw()
            image = tmpImage
        }
    }
}

Client-Klasse wieder. Dieses Mal werden wir die Proxy-Klasse verwenden.

Client.kt

package proxy

class Client {
    private val initDrawNum = 3

    init {
        val imageList = getProxyImageList()
        for (i in 0 until initDrawNum) {
            imageList[i].draw()
        }
    }

    private fun getProxyImageList(): ArrayList<Subject> {
        val proxyImageList = ArrayList<Subject>()
        proxyImageList.add(ImageProxy("./image/Apfel.png "))
        proxyImageList.add(ImageProxy("./image/Mandarine.png "))
        proxyImageList.add(ImageProxy("./image/Pfirsiche.png "))
        proxyImageList.add(ImageProxy("./image/Banane.png "))
        proxyImageList.add(ImageProxy("./image/Painapuru.png "))
        proxyImageList.add(ImageProxy("./image/Erdbeere.png "))

        return proxyImageList
    }

    private fun getNonProxyImageList(): ArrayList<Subject> {
        val imageList = ArrayList<Subject>()
        imageList.add(Image("./image/Apfel.png "))
        imageList.add(Image("./image/Mandarine.png "))
        imageList.add(Image("./image/Pfirsiche.png "))
        imageList.add(Image("./image/Banane.png "))
        imageList.add(Image("./image/Painapuru.png "))
        imageList.add(Image("./image/Erdbeere.png "))

        return imageList
    }
}

Ausgabeergebnis

[out-put]
./image/Apfel.Lesen Sie png
./image/Apfel.Zeichne png
./image/Mandarine.Lesen Sie png
./image/Mandarine.Zeichne png
./image/Pfirsiche.Lesen Sie png
./image/Pfirsiche.Zeichne png

Jetzt können Sie so viel laden, wie Sie anzeigen möchten.