[GO] Fliegengewichtsmuster in Java

Einführung

Einführung in die Entwurfsmuster von [GoF](https://ja.wikipedia.org/wiki/Gang of for _ (Information Engineering)) ["Einführung in Entwurfsmuster, die in der erweiterten und überarbeiteten Java-Sprache gelernt wurden"]( https://www.amazon.co.jp/ Erweiterte und überarbeitete Ausgabe Einführung in Entwurfsmuster, die in der Java-Sprache gelernt wurden-Yuki-Hiroshi / dp / 4797327030 / ref = pd_lpo_sbs_14_t_0? _ Encoding = UTF8 & psc = 1 & refRID = 2ZE4GPYNN55JGDR5M Ich werde über zusammenfassen.

Fliegengewichtsmuster

Was ist Fliegengewicht?

Es ist eine leichte Boxklasse, "Fliegenklasse". Die leichte Klasse bedeutet "Leichtigkeit", was bedeutet, dass sie weniger Speicher verbraucht. Um ein Objekt zu erstellen, müssen Sie neue Schritte ausführen, um Speicher zuzuweisen (zu instanziieren). Das Erstellen vieler Objekte verbraucht jedoch viel Speicher und verlangsamt den Prozess. Um diese Probleme zu lösen, ist es ratsam, es für bereits neue Instanzen wiederholt zu verwenden. Das Muster, das den Speicherverbrauch unterdrückt, indem ** Objekte auf diese Weise so wenig wie möglich gemeinsam genutzt werden, wird als ** Fliegengewichtsmuster ** bezeichnet.

Charakter

Das Fliegengewichtsmuster wird von den Klassen verwendet, die im folgenden Klassendiagramm angezeigt werden.

Implementierungsklasse

• Flyweight Stellt eine Klasse dar, die gemeinsam genutzt und verwendet werden soll. Es sind keine bestimmten Methoden zu implementieren, daher gibt es keine Schwierigkeiten.

• FlyweightFactory Diese Klasse dient als Fabrik zur Erzeugung von "Fliegengewicht". Wenn Sie über diese Factory-Rolle eine Flyweight-Rolle erstellen, verfügen Sie über eine Methode, mit der Sie Instanzen gemeinsam nutzen können. Es hat ein "Pool" -Feld zum Speichern der gemeinsam genutzten Instanz und eine "getFlyewight" -Methode zum Abrufen des Flyweight.

• Client Es ist eine Klasse, die Flyweight unter Verwendung von "FlyweightFactory" verwendet. Wie bei Flyweight gibt es keine spezifischen Methoden zur Implementierung, daher gibt es keine schwierigen Punkte.

Konkretes Beispiel

Als konkretes Beispiel werden wir anhand der folgenden Klasse erklären.

Implementierungsklasse

• ** Briefmarkenklasse **

Stamp.java

package sample;

public class Stamp {
	//Brief
	private char charname;
	//Anzahl der Nutzungszeiten
	private int useCount = 0;
	//Anzahl der Generationen
	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;
	}

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

	//Zeichen anzeigen
	public void print() {
		System.out.println("charname:" + this.charname);
	}
}

Die "Stamp" -Klasse ist eine gemeinsam genutzte und verwendete Fliegengewichtsklasse. Es empfängt das Zeichen "charname", wird generiert und druckt das Zeichen mit der Methode "print". Außerdem werden die Anzahl der Verwendungen (useCount) und die Anzahl der Generationen ( newCount) mit Feldern versehen, damit sie leicht zu verstehen sind, aber nicht benötigt werden.

• ** StampFactory Klasse **

StampFactory.java

package sample;

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

public class StampFactory {
	//Verwalten Sie bereits generierte Stempelinstanzen
	private HashMap<String, Stamp> pool = new HashMap<>();
	//Singleton-Muster
	private static StampFactory singleton = new StampFactory();

	//Konstrukteur
	private StampFactory() {
	}

	//Singleton-Instanz abrufen
	public static StampFactory getInstance() {
		return singleton;
	}

	//Stempelinstanziierung(Aktie)
	public synchronized Stamp getStamp(char charname) {
		//Schlüssel(Brief)Wert verbunden mit(Stempelinstanz)Bekommen
		Stamp bc = pool.get("" + charname);
		//Schlüssel(Brief)Wert verbunden mit(Stempelinstanz)Wenn nicht erhalten werden konnte
		if (bc == null) {
			//Erstellen Sie hier eine Instanz von Stamp
			bc = new Stamp(charname);
			//Zählen Sie die Anzahl der neuen
			bc.setNewCount(bc.getNewCount() + 1);
			//In HashMap speichern
			pool.put("" + charname, bc);
		}
		//Zählen Sie die Anzahl der Verwendungen unabhängig vom Vorhandensein oder Fehlen neuer
		bc.setUseCount(bc.getUseCount() + 1);
		return bc;
	}

	//Geben Sie alle von HashMap verwalteten Stempelinstanzen aus
	public void printAllPool() {
		for (Entry<String, Stamp> entry : pool.entrySet()) {
			System.out.println(
					entry.getKey() + " : " + entry.getValue().getUseCount() + " : " + entry.getValue().getNewCount());
		}
	}
}

Diese Klasse dient als FlayweightFactory, die Fabrik, die die Stamp-Klasse generiert. Es hat ein "Pool" -Feld als Map zum Verwalten der generierten Instanzen und ein "Singleton" -Feld, das sich selbst darstellt, weil es hier das Singleton-Muster anwendet. Um diese Klasse zu verwenden, rufen Sie zuerst die Methode "getInstance" von außen auf, um die StampFactory-Instanz zurückzugeben, die sich selbst darstellt. Rufen Sie dann für die zurückgegebene StampFactory-Instanz die Methode "getStamp" mit dem Argument "charname" auf. Wenn bereits eine Stempelinstanz mit dem als Argument als Schlüssel übergebenen Zeichennamen erstellt wurde, wird diese aus "pool" abgerufen. Wenn die Instanz jedoch noch nicht erstellt wurde, wird sie erstellt und in "pool" gespeichert. Machen. Wenn eine Instanz erstellt wird, wird sie um "newCount" und durch Erhöhen von "useCount" um +1 erhöht, unabhängig davon, ob die Instanz erstellt wurde oder nicht. Die Anzahl der Generationen und die Verwendung jeder Stamp-Instanz werden gezählt. Zusätzlich wird printAllPool als Methode implementiert, um alle im Pool gespeicherten Stamp-Instanzen auszugeben. Der auszugebende Inhalt lautet "Schlüsselzeichen: Anzahl der Verwendungen: Anzahl der Generationen".

Ausführungsklasse

-** Hauptklasse **

Main.java

package sample;

import java.util.ArrayList;

public class Main {
	public static void main(String[] args) {
		//Vorbereitung der Stempelinstanz
		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");
		//Geben Sie alle von HashMap verwalteten Stempelinstanzen aus
		factory.printAllPool();
	}
}

Es ist eine Klasse, die als Client dient und Flyweight und FlyweightFactory verwendet. Durch Aufrufen der getInstance-Methode, einer statischen Methode der StampFactory-Klasse, um die stampFactory-Instanz abzurufen, und durch Aufrufen der getStamp-Methode für die erhaltene stampFactory-Instanz wird die stamp-Instanz im Poolfeld gespeichert. Durch Aufrufen von printAllPool () werden schließlich alle Poolfelder ausgegeben.

Ausführungsergebnis

Das Ergebnis der Ausführung von "Main.java" ist wie folgt. Selbst für Zeichen, deren "useCount" größer als 1 ist, ist "newCount" nur einmal vorhanden, was darauf hinweist, dass die Instanz wiederverwendet wird.

Ausführungsergebnis

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

Vorteile und Nachteile

Mithilfe des Flyweight-Musters können Sie die Anzahl neuer Objekte reduzieren und Speicherplatz sparen. Andererseits besteht der Nachteil darin, dass die im Pool gespeicherten Objekte keiner Speicherbereinigung unterliegen und im Speicher verbleiben. Daher müssen sie absichtlich verwaltet werden, damit nicht der Speicher ausgeht.

Zusammenfassung

Sie haben das Flyweight-Muster kennengelernt, das den Speicherverbrauch durch gemeinsame Nutzung von Instanzen reduziert. Der Beispielcode wird unten hochgeladen. Wenn Sie möchten, lesen Sie ihn bitte.

• Flyweight-Beispielcode

Darüber hinaus sind unten weitere Entwurfsmuster zusammengefasst. Bitte beziehen Sie sich auch auf diese.

• [Von Zeit zu Zeit aktualisiert] Zusammenfassung der Entwurfsmuster in Java

Verweise

• [Einführung in Entwurfsmuster, die in der erweiterten und überarbeiteten Java-Sprache gelernt wurden](https://www.amazon.co.jp/ Einführung in Entwurfsmuster, die in der erweiterten und überarbeiteten Java-Sprache gelernt wurden-Yuki-Hiroshi / dp / 4797327030 / ref = pd_lpo_sbs_14_t_0? = UTF8 & psc = 1 & refRID = 2ZE4GPYNN55JGDR5QMHP)