# Registry Pattern



## NecroniX (21. Feb 2010)

Hallo zusammen,

ich kenn das Registry Pattern aus PHP, aber wie setzt man das in Java um ?

Wäre gut wenn mir da einer helfen könnte !

Schon mal Danke.

Mfg
NecroniX


----------



## ice-breaker (21. Feb 2010)

Design Patterns sind unabhängig von Programmiersprachen, wenn du ein bestimmtes Problem bei der Implementierung hast, solltest du das genauer ansprechen.
Eventuell wäre auch "Inversion of Control" bzw. "Dependency Injection" viel eher das, was du suchst.


----------



## NecroniX (21. Feb 2010)

Mein Problem liegt dadrin, das ich nicht weiß wie die Variablen bzw Objekte in der Registry gespeichert werden. Bei PHP funzt das ja mit nem simplen Array, was meines Wissen bei Java so nicht möglich ist.


----------



## ice-breaker (21. Feb 2010)

```
Map<String, Object>
```


----------



## NecroniX (5. Mrz 2010)

Ich hab jetzt versucht das registry pattern mit dem Map Objekt zu verwirklichen. Komm aber einfach nicht weiter.
Z.B. hier:


```
import javax.script.*;
import Core.Event.*;


public class MainClass {
    public void main(String args[]) {
        SimpleBindings registry = new SimpleBindings();
        registry.put("EventHandler",new EventHandler());
        EventHandler eventHandler = registry.get("EventHandler");
    }
}
```

In Zeile 9 passen nun die Typen nicht zueinander. Was kann man dagegen tun ?
Schließlich sollen ja in dieser "Registry" alle möglichen Typen gespeichert werden.

Ich hoffe ihr könnt mir ein weiteres mal.

Mfg
NecroniX


----------



## Jay_030 (5. Mrz 2010)

Du musst explizit casten. PHP bindet da dynamisch den Typ, Java nicht.


```
EventHandler eventHandler = (EventHandler) registry.get("EventHandler");
```

Edit: Des Weiteren ist das nicht natürlich, dass du SimpleBindings verwendest. Das ist für Skriptsprachen in Java gedacht. Wenn du einfach nur Objekte ablegen möchtest, um diese später über einen String wieder zu bekommen, reicht eine Map, wie oben bereits erwähnt, völlig aus.


----------



## NecroniX (14. Mrz 2010)

@Jay
Sorry das ich dir erst jetzt danken kann. Hat mir zuerst sehr geholfen, aber bei meiner GUI mit Swing bin ich wieder am gleichen Problem stecken geblieben.

Beim Casten der Objekte gehen ja die Inhalt der ensprechenden Variablen verloren. Wie kann ich die Objekte nun so ablegen das ihre, Inhalte erhalten bleiben und ich sie dann unter nem Key in nem Table oder einer List ablegen kann. Ich dachte hier schon an Serialisierung, aber ich habe imo nur ne Serialiserung in ne XML gesehn und das wäre auf jedenfall zu Übertrieben. 

Bei meinem konkreten Fall will ich mit Swing ne GUI haben, wo ich auch noch nach dem "Adden" zu dem enstprechenden Container drauf zugreifen und sie z.B. deaktivieren etc. .

Hoffe ihr könnt mir hier bei helfen.

Mfg
NecroniX


----------



## MrWizenly (14. Mrz 2010)

Hallo, 

das Problem ist, dass Du hier keinen so "einfachen" Weg finden wirst wie in PHP. Wie schon Jay sagte wird in Java der Datentyp statisch festgelegt. Um Dir das casten zu ersparen, vor allem aber um eine erhöhte Typsicherheit zu erreichen, kannst Du auf Generics zurückgreifen.
Ice-breaker zeigte zwar schon wie man Generics verwenden kann, unglücklicherweise wurde aber auf den Typ Object für die abgelegten Werte zurückgegriffen. Hier kann entsprechend ein beliebiges Objekt abgelegt werden. 

Besser ist es einen spezifischen Typ zu verwenden. Am saubersten ist es, wenn Du ein Interface (oder eine abstrakte Basisklasse) erzeugst, welche alle Eigenschaften deklariert, die ein Registry Eintrag haben soll. Ein einfaches Beispiel könnte darin bestehen, dass ein solcher Eintrag eine String-Zeichenkette speichert und aktiviert/deaktiviert sein kann:


```
public interface IRegistryEntry {
  // Gibt den String-Wert zurück
  public String getValue();

  // Gibt zurück ob der Eintrag aktiviert ist oder nicht
  public boolean isActive();
}

public class RegistryEntry implements IRegistryEntry {
 
  private final String value;
  private boolean isActivated;

  // Konstruktor
  public RegistryEntry(final String value) {
    // Ruft den anderen Konstruktor auf und setzt den Eintrag als aktiviert
    this(value, true);
  }

  // Konstruktor
  public RegistryEntry(final String value, 
                             final boolean activated) {
     this.value = value;
     this.isActivated = activated;
  }

  public String getValue() {
    return this.value;
  }

  public boolean isActivated() {
    return this.isActivated;
  }

  public void setActivated(final boolean activated) {
    this.isActivated = activated;
  }
}
```

Eine Map<String, IRegistryEntry> könntest Du jetzt mit Exemplaren der Klasse füllen, die Abrufen und z.B. den Status (aktiviert) setzen. Die Änderung wirkt sich auf die Variablen aus und wird auch korrekt gespeichert. Die Objekte liegen aber nur im Hauptspeicher und nur für die Laufzeit des Programms vor. 

Ein anderes Thema wäre nun die Persistenz. Hierunter fällt das festschreiben der Registry, so dass diese Werte auch nach dem beenden des Programms zur Verfügung stehen (z.B. in einer Datei oder DB). Eine Möglichkeit die Registry festzuschreiben bestünde nun darin, dass Du diese serialisierst (und entsprechend beim Laden wieder deserialisierst). Das ist aber ein anderes Problem, dass von dem Pattern nicht berücksichtigt wird.

Zudem möchte ich explizit darauf hinweisen, dass dieses Pattern nicht unbedingt nach einer all zu sinnvollen Idee klingt. So wie es sich ließt kann es leicht und vermeintlich unbeabsichtigt dazu verleiten verstärkt mit globalen Variablen zu arbeiten. Die Verpackung in ein Objekt (das als Singleton vorliegt und leicht zugänglich ist) macht die Sache nicht wirklich besser. Ein sauberer Entwurf und ein ausreichendes Verständnis der OOP sollten in vielen Fällen die Verwendung einer Registry überflüssig machen, denke ich.


----------

