# Variablen zur Laufzeit global speichern (Registry Pattern?)



## Djinndrache (30. Okt 2012)

Hallo,

Ich brauche im Prinzip eine Klasse, die Variablen von primitiven Datentypen speichert und zur Laufzeit jeder anderen Klasse anbieten kann.

Ich kenne das von PHP so, dass man (dank assoziativer Arrays) ein Registry Design Pattern anwenden kann. Diese Registry ist Singleton, kann somit zur Laufzeit von überall problemlos erreicht werden und hat eine einfache set und get Methode, die einen key und ein value ins Array schreibt (bzw anhand des keys den value zurückgibt).


Gibt es so etwas in der Art von Hause aus bei Java?
Falls nicht, wie baue ich mir so eine Registry selbst? Als assoziatives Array könnte ich eine Map nehmen, dann hätte ich einen key und einen value. Das Problem hier wäre aber, wenn ich verschiedene Datentypen speichern will. Der key könnte einfach ein String sein, soweit klar. Aber was ist mit dem value? Sagen wir ich will speichen ob Antialiasing aktiviert ist (boolean) und irgendeine Breite von einem Fenster (int). Ich kann doch nicht ein boolean und ein int in die selbe Map packen!?


Ich könnte einen kleinen Denkanstoß gebrauchen


----------



## Djinndrache (30. Okt 2012)

Um nicht ganze ohne Code da zu stehen, habe ich einen kleinen Versuch gewagt eine Java-Registry zu schreiben. Ich bin allerdings noch nicht wirklich ganz glücklich damit. Geht das nicht eleganter?


```
import java.util.HashMap;

public class Registry {

	private static Registry singleton = null;
	protected HashMap<String, Boolean> booleanMap = new HashMap<String, Boolean>();
	protected HashMap<String, Integer> intMap = new HashMap<String, Integer>();
	protected HashMap<String, Long> longMap = new HashMap<String, Long>();
	protected HashMap<String, Float> floatMap = new HashMap<String, Float>();
	protected HashMap<String, Double> doubleMap = new HashMap<String, Double>();
	protected HashMap<String, Character> charMap = new HashMap<String, Character>();
	protected HashMap<String, String> stringMap = new HashMap<String, String>();

	private Registry() {
	}

	public static Registry get() {
		if (singleton == null) {
			singleton = new Registry();
		}
		return singleton;
	}

	public boolean contains(String key) {
		return (booleanMap.containsKey(key) || intMap.containsKey(key) || longMap.containsKey(key) || floatMap.containsKey(key)
				|| doubleMap.containsKey(key) || charMap.containsKey(key) || stringMap.containsKey(key));
	}

	public boolean getBoolean(String key) {
		return booleanMap.get(key);
	}

	public int getInt(String key) {
		return intMap.get(key);
	}

	public long getLong(String key) {
		return longMap.get(key);
	}

	public float getFloat(String key) {
		return floatMap.get(key);
	}

	public double getDouble(String key) {
		return doubleMap.get(key);
	}

	public char getChar(String key) {
		return charMap.get(key);
	}

	public String getString(String key) {
		return stringMap.get(key);
	}

	public void put(String key, boolean value) {
		booleanMap.put(key, value);
	}

	public void put(String key, int value) {
		intMap.put(key, value);
	}

	public void put(String key, long value) {
		longMap.put(key, value);
	}

	public void put(String key, float value) {
		floatMap.put(key, value);
	}

	public void put(String key, double value) {
		doubleMap.put(key, value);
	}

	public void put(String key, char value) {
		charMap.put(key, value);
	}

	public void put(String key, String value) {
		stringMap.put(key, value);
	}
}
```


----------



## FerFemNemBem (30. Okt 2012)

Mahlzeit,

bei Dir ist es moeglich, einem Key saemtliche Typen zuzuweisen - soll heissen: "meinKey" kann in allen 7 Maps landen. Ist das gewollt?

Mach doch einfach eine Map<String, Object>. Da kannst Du alles reinpacken und stellst gleichzeitig sicher, dass ein Key nur einmal vorkommt.

Gruss, FFNB.


----------



## maki (30. Okt 2012)

Darf man fragen wozu das gut sein soll?

Mag sein dass das in PHP Sinn ergibt(?), in Java, einer OO Sprache, ist das sicherlich nicht so sicher.. globale Variablen zB. will man in OOP Sprachen normalerweise gar nicht haben.


----------



## Djinndrache (30. Okt 2012)

FerFemNemBem hat gesagt.:


> Mahlzeit,
> 
> bei Dir ist es moeglich, einem Key saemtliche Typen zuzuweisen - soll heissen: "meinKey" kann in allen 7 Maps landen. Ist das gewollt?
> 
> ...



Nein, das ist natürlich nicht gewollt, der Code war nur kurz runtergeschrieben um zu skizzieren was ich meine.
Reicht es da einfach ein Object einzuspeichern, oder wäre es sinnvoller ein generic RegistryEntry<T> anzulegen?



maki hat gesagt.:


> Darf man fragen wozu das gut sein soll?
> 
> Mag sein dass das in PHP Sinn ergibt(?), in Java, einer OO Sprache, ist das sicherlich nicht so sicher.. globale Variablen zB. will man in OOP Sprachen normalerweise gar nicht haben.



Ich habe diese Idee verfolgt um Einstellungen zur Laufzeit zu speichern und zu verwalten. Sagen wir ein Benutzer möchte in einem Grafikprogramm das Antialiasing (de)aktivieren, so könnte ich dies als boolean in einer Registry speichern. Diese Registry kann diese Einstellung dann jeder anderen Klasse mitteilen, die Informationen zu dieser Benutzereinstellung benötigt.
Ein anderes Beispiel wäre vielleicht in einer Art Paint-Programm um das aktuell gewählte Tool und die Farbe zu speichern, wobei hier wohl schon fast get und set Methoden besser oder zumindest ausreichend wären.
Außerdem könnte ich die Registry so erweitern, dass man RegistryListener hinzufügen kann; somit würden alle Klassen, die die aktuelle Antialiasingeinstellung benötigen, direkt benachrichtigt werden, wenn es Änderungen gibt, und könnten zur Laufzeit diese Einstellung jederzeit berücksichtigen.

Das erscheint mir derzeit jedenfalls sinnvoller als wenn ich eine Klasse habe, die die Antialiasingvariable (mit get und set Methoden) hat und bei jedem Wertewechsel der Variable noch sämtliche interessierte Klassen mit notify-Methoden benachrichtigen muss, dass es einen neuen Wert abzuholen gibt.

In PHP hab ich das Registry-Pattern in Verbindung mit dem MVC-Pattern kennengelernt. Dort habe ich insbesondere gern per Controller Variablen gespeichert, die der View (also quasi das Template) dann abrufen kann. (Somit war der Code sehr schön vom visuellen Design getrennt und das HTML/CSS-Layout konnte von kreativen Leuten erstellt werden, die absolut null Plan von PHP haben)


Ich bin aber sehr aufgeschlossen, wenn es eine bessere Möglichkeit in Java gibt, um solcherlei Einstellungen zur Laufzeit zu verwalten.


----------



## faetzminator (30. Okt 2012)

Normalerweise sollte man dazu ein DI-Framework wie Spring verwenden, in welchem man konfigurieren kann, welche Objekte welche Abhängigkeiten besitzen. Benötigt eine Klasse irgendwelche Settings, wird das einfach konfiguriert und ist zur Laufzeit vorhanden. Siehe auch Dependency Injection ? Wikipedia


----------



## maki (30. Okt 2012)

> Ich habe diese Idee verfolgt um Einstellungen zur Laufzeit zu speichern und zu verwalten.


Für Konfigurationen macht das Sinn.
Für MVC weniger 

Viele Frameworks  (Apache commons, Spring, etc. pp.) bieten eine Config bzw. Configuration Klasse die das abdeckt.
Ist aber nix verkehrtes daran, wenn du dir das selber schreibst, solange es richtig ist 

Deine "Registry" nutzt aus irgendeinem Grund protected  (??) Instanzvariablen, dein Singleton ist nicht Threadsicher...


----------

