[GO] Modèle de poids mouche en Java

introduction

Présentation des modèles de conception de [GoF](https://ja.wikipedia.org/wiki/Gang of for _ (Information Engineering)) ["Introduction aux modèles de conception appris dans le langage Java augmenté et révisé"]( https://www.amazon.co.jp/ Édition révisée supplémentaire Introduction aux modèles de conception appris en langage Java-Yuki-Hiroshi / dp / 4797327030 / ref = pd_lpo_sbs_14_t_0? _ Encoding = UTF8 & psc = 1 & refRID = 2ZE4GPYNN55JGDR5QMHP) Je vais résumer sur.

Modèle de poids mouche

Qu'est-ce que Flyweight

C'est un cours de boxe léger, "fly class". La classe légère signifie «légèreté», ce qui signifie qu'elle consomme moins de mémoire. Pour créer un objet, il est nécessaire d'en faire un nouveau et d'allouer de la mémoire (instanciation), mais la création de nombreux objets consomme beaucoup de mémoire et ralentit le traitement. Pour résoudre ces problèmes, il est conseillé de l'utiliser à plusieurs reprises pour des instances déjà nouvelles. Un modèle qui supprime la consommation de mémoire en partageant ** des objets sans en créer autant que possible ** est appelé un ** modèle Flyweight **.

Personnage

Le modèle Flyweight est utilisé par les classes qui apparaissent dans le diagramme de classes ci-dessous.

Classe d'implémentation

• Flyweight Représente une classe à partager et à utiliser. Il n'y a pas de méthode particulière à mettre en œuvre, donc il n'y a pas de difficultés.

• FlyweightFactory Cette classe sert d'usine pour générer des "poids mouche". Si vous créez un rôle Flyweight via ce rôle d'usine, vous disposerez d'une méthode qui vous permettra de partager des instances. Il a un champ pool pour stocker l'instance partagée et une méthode getFlyewight pour obtenir le poids Fly.

• Client C'est une classe qui utilise Flyweight en utilisant FlyweightFactory. Comme avec Flyweight, il n'y a pas de méthodes spécifiques à mettre en œuvre, donc il n'y a pas de points difficiles.

Exemple concret

À titre d'exemple concret, nous expliquerons en nous basant sur la classe suivante.

Classe d'implémentation

• ** Classe de timbre **

Stamp.java

package sample;

public class Stamp {
	//lettre
	private char charname;
	//Nombre de fois d'utilisation
	private int useCount = 0;
	//Nombre de générations
	private int newCount = 0;

	public int getUseCount() {
		return useCount;
	}

	public void setUseCount(int useCount) {
		this.useCount = useCount;
	}

	public int getNewCount() {
		return newCount;
	}

	public void setNewCount(int newCount) {
		this.newCount = newCount;
	}

	//constructeur
	public Stamp(char charname) {
		this.charname = charname;
	}

	//Afficher les caractères
	public void print() {
		System.out.println("charname:" + this.charname);
	}
}

La classe Stamp est une classe Flyweight partagée et utilisée. Il reçoit le caractère «charname», est généré et imprime le caractère avec la méthode «print». De plus, bien que les champs soient fournis pour que le nombre d'utilisations (ʻuseCount) et le nombre de générations (newCount`) puissent être facilement compris, ils ne sont pas obligatoires.

• ** Classe StampFactory **

StampFactory.java

package sample;

import java.util.HashMap;
import java.util.Map.Entry;

public class StampFactory {
	//Gérer les instances de Stamp déjà générées
	private HashMap<String, Stamp> pool = new HashMap<>();
	//Motif singleton
	private static StampFactory singleton = new StampFactory();

	//constructeur
	private StampFactory() {
	}

	//Obtenir une instance singleton
	public static StampFactory getInstance() {
		return singleton;
	}

	//Instanciation de timbre(partager)
	public synchronized Stamp getStamp(char charname) {
		//Clé(lettre)Valeur associée à(Instance de timbre)Obtenir
		Stamp bc = pool.get("" + charname);
		//Clé(lettre)Valeur associée à(Instance de timbre)Si n'a pas pu être obtenu
		if (bc == null) {
			//Créez une instance de Stamp ici
			bc = new Stamp(charname);
			//Comptez le nombre de nouveaux
			bc.setNewCount(bc.getNewCount() + 1);
			//Magasin dans HashMap
			pool.put("" + charname, bc);
		}
		//Comptez le nombre d'utilisations indépendamment de la présence ou de l'absence de nouveau
		bc.setUseCount(bc.getUseCount() + 1);
		return bc;
	}

	//Sortie de toutes les instances de Stamp gérées par HashMap
	public void printAllPool() {
		for (Entry<String, Stamp> entry : pool.entrySet()) {
			System.out.println(
					entry.getKey() + " : " + entry.getValue().getUseCount() + " : " + entry.getValue().getNewCount());
		}
	}
}

Cette classe sert de FlayweightFactory, qui est l'usine qui génère la classe Stamp. Il a un champ pool comme carte pour gérer les instances générées, et un champ singleton qui se représente car il applique ici le modèle Singleton. Pour utiliser cette classe, appelez d'abord la méthode getInstance de l'extérieur pour renvoyer l'instance StampFactory qui se représente elle-même. Ensuite, pour l'instance StampFactory retournée, appelez la méthode getStamp avec charname comme argument. Si une instance Stamp avec le charname passé comme argument en tant que clé a déjà été créée, elle sera obtenue à partir de pool, mais si l'instance n'a pas encore été créée, une instance sera créée et stockée dans pool. Faire. De plus, lorsqu'une instance est créée, elle est incrémentée de newCount et en incrémentant ʻuseCount, que l'instance soit créée ou non, le nombre de générations et l'utilisation de chaque instance de Stamp sont comptés. De plus, printAllPool` est implémenté comme une méthode pour sortir toutes les instances de Stamp stockées dans le pool. Le contenu à sortir est "Caractères clés: Nombre d'utilisations: Nombre de générations".

Classe d'exécution

• ** Classe principale **

Main.java

package sample;

import java.util.ArrayList;

public class Main {
	public static void main(String[] args) {
		//Préparation de l'instance de tampon
		StampFactory factory = StampFactory.getInstance();
		ArrayList<Stamp> stamps = new ArrayList<>();
		stamps.add(factory.getStamp('a'));
		stamps.add(factory.getStamp('b'));
		stamps.add(factory.getStamp('c'));
		stamps.add(factory.getStamp('f'));
		stamps.add(factory.getStamp('e'));
		stamps.add(factory.getStamp('a'));
		stamps.add(factory.getStamp('b'));
		stamps.add(factory.getStamp('c'));
		stamps.add(factory.getStamp('d'));
		stamps.add(factory.getStamp('f'));
		stamps.add(factory.getStamp('a'));
		for (Stamp s : stamps) {
			s.print();
		}
		System.out.println("-------------------------------");
		System.out.println("charname : useCount : newCount");
		//Sortie de toutes les instances de Stamp gérées par HashMap
		factory.printAllPool();
	}
}

C'est une classe qui sert de client qui utilise Flyweight et FlyweightFactory. En appelant la méthode getInstance, qui est une méthode statique de la classe StampFactory, pour obtenir l'instance stampFactory, et en appelant la méthode getStamp pour l'instance stampFactory obtenue, l'instance stamp est stockée dans le champ pool. Enfin, en appelant printAllPool (), tous les champs du pool sont affichés.

Résultat d'exécution

Le résultat de l'exécution de Main.java est le suivant. Même pour les caractères dont ʻuseCount est supérieur à 1, le newCount` n'est qu'une seule fois, indiquant que l'instance est réutilisée.

Résultat d'exécution

charname:a
charname:b
charname:c
charname:f
charname:e
charname:a
charname:b
charname:c
charname:d
charname:f
charname:a
-------------------------------
charname : useCount : newCount
a : 3 : 1
b : 2 : 1
c : 2 : 1
d : 1 : 1
e : 1 : 1
f : 2 : 1

Avantages et inconvénients

En utilisant le modèle Flyweight, vous pouvez réduire le nombre de nouveaux objets et économiser de la mémoire. En revanche, l'inconvénient est que les objets stockés dans le pool ne sont pas soumis au garbage collection et restent en mémoire, il est donc nécessaire de les gérer intentionnellement pour ne pas manquer de mémoire.

Résumé

Vous avez découvert le modèle Flyweight, qui réduit la consommation de mémoire en partageant des instances. L'exemple de code est téléchargé ci-dessous, veuillez donc vous y référer si vous le souhaitez.

• Exemple de code Flyweight

En outre, d'autres modèles de conception sont résumés ci-dessous, veuillez donc vous y référer également.

• [Mis à jour de temps en temps] Résumé des modèles de conception en Java

Les références

• [Introduction aux modèles de conception appris dans le langage Java augmenté et révisé](https://www.amazon.co.jp/ Introduction aux modèles de conception appris dans le langage Java augmenté et révisé-Yuki-Hiroshi / dp / 4797327030 / ref = pd_lpo_sbs_14_t_0? _Encoding = UTF8 & psc = 1 & refRID = 2ZE4GPYNN55JGDR5QMHP)