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

Proxy-proxy

** Table des matières ** L'un des motifs est d'appliquer ce modèle lors de l'utilisation d'un objet coûteux à générer et à initialiser (lors de son affichage à l'écran dans une application GUI) et de l'instancier pour la première fois.

Il est nécessaire d'afficher 1000 images sur un certain écran, mais seules 10 images peuvent être affichées dans la zone de dessin effective. Malgré cela, si 1000 objets de classe Graphics sont instanciés et 1000 images sont chargées au moment de l'affichage initial, les ressources doivent être consacrées à un traitement qui n'est pas si lié à l'affichage initial.

Il semble que ce modèle soit utilisé pour résoudre de tels problèmes. Affectez Proxy à la zone où l'objet graphique est initialement affecté et chargez l'image uniquement lorsqu'il est temps de l'afficher.

Objectif

Pour contrôler l'accès à un objet, fournissez un substitut ou un conteneur pour cet objet.

Composant

・ Classe Proxy Shadow Warrior -Classe abstraite de la classe Subject Proxy et de la classe Real Subject ・ Classe réelle RealSubject

la mise en oeuvre

Maintenant, implémentez le programme de dessin d'image comme exemple de code. Comme il est difficile d'instancier réellement 1000 pièces, le nombre de dessins au moment de l'affichage initial est défini sur 3.

Classe abstraite de la classe Subject Proxy et de la classe Real Subject

Subject.kt

package proxy

interface Subject {
    fun draw()
}

RealSubject classe réelle

Classe d'image Classe pour lire l'image instantanée après instanciation

Image.kt

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

    init {
        loadImage(filePath)
    }

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

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

Utilisons cette classe Image pour afficher initialement l'écran.

Classe de client

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/pomme.png "))
        imageList.add(Image("./image/Mandarine.png "))
        imageList.add(Image("./image/Les pêches.png "))
        imageList.add(Image("./image/banane.png "))
        imageList.add(Image("./image/Painapuru.png "))
        imageList.add(Image("./image/fraise.png "))

        return imageList
    }
}

[out-put]
./image/pomme.Lire le png
./image/Mandarine.Lire le png
./image/Les pêches.Lire le png
./image/banane.Lire le png
./image/Painapuru.Lire le png
./image/fraise.Lire le png
./image/pomme.Dessiner png
./image/Mandarine.Dessiner png
./image/Les pêches.Dessiner png

Toutes les images ont été chargées, mais il suffit d'en afficher seulement trois. Utilisons la classe Proxy.

Classe Proxy Shadow Warrior

Classe de proxy d'image Une fois chargée, elle est conservée pour toujours, mais il est préférable d'implémenter une méthode pour libérer l'image chargée lorsqu'elle sort de la zone de dessin effective.

Cependant, c'est ennuyeux, je vais donc l'omettre cette fois.

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

Classe de client à nouveau. Cette fois, nous utiliserons la classe Proxy.

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/pomme.png "))
        proxyImageList.add(ImageProxy("./image/Mandarine.png "))
        proxyImageList.add(ImageProxy("./image/Les pêches.png "))
        proxyImageList.add(ImageProxy("./image/banane.png "))
        proxyImageList.add(ImageProxy("./image/Painapuru.png "))
        proxyImageList.add(ImageProxy("./image/fraise.png "))

        return proxyImageList
    }

    private fun getNonProxyImageList(): ArrayList<Subject> {
        val imageList = ArrayList<Subject>()
        imageList.add(Image("./image/pomme.png "))
        imageList.add(Image("./image/Mandarine.png "))
        imageList.add(Image("./image/Les pêches.png "))
        imageList.add(Image("./image/banane.png "))
        imageList.add(Image("./image/Painapuru.png "))
        imageList.add(Image("./image/fraise.png "))

        return imageList
    }
}

Résultat de sortie

[out-put]
./image/pomme.Lire le png
./image/pomme.Dessiner png
./image/Mandarine.Lire le png
./image/Mandarine.Dessiner png
./image/Les pêches.Lire le png
./image/Les pêches.Dessiner png

Vous pouvez maintenant charger autant que vous le souhaitez.