© Excellent backgrounds/Shutterstock.com
Design Patterns Teil 2: Handgefertigte Proxies

Der LEGO-Kasten für Softwareentwicklung


Proxies gibt es in verschiedenen Formen und Geschmacksrichtungen. So haben wir den Virtual Proxy für Lazy Initialization, den Remote Proxy für den Zugriff auf Objekte in entfernten Adressräumen und den Protection Proxy zum Hinzufügen einer Sicherheitsebene. Die Proxy-Design-Pattern-Struktur aus dem GoF-Buch ist in Abbildung 1 zu sehen [1].

In einigen Situationen möchten wir die Erstellung von Objekten vielleicht so lange hinauszögern, bis sie unbedingt benötigt werden. Das Hinausschieben kann uns sogar die Kosten für die Erstellung von Objekten ganz ersparen. Beispiele für solche Objekte mit hohen Erstellungskosten sind Threads, Datenbankverbindungen, große Arrays und Dateien.

kabutz_designpatterns_2_1.tif_fmt1.jpgAbb. 1: Proxy-Design-Pattern-Struktur aus dem GoF-Buch [1]

Beispielsweise ist eine neue HashMap ohne das Array mit den Einträgen 48 Bytes (Kasten: „Sizeof in Java“) groß. Dieses Array beginnt traditionell bei der Länge 16 und wächst, sobald es mehr als 75 % Belegung hat. Ein Array mit 16 Objekten belegt weitere 80 Bytes. Die Gesamtkosten einer neuen HashMap belaufen sich also auf 128 Bytes, auch wenn die HashMap kein einziges Element enthält.

Sizeof in Java

Objektgrößen in Java können mit der folgenden Formel abgeschätzt werden:

  • 12 Bytes für den Objektkopf

  • 4 Bytes für jeden Zeiger

  • 8 Bytes für lange und doppelte Felder

  • 4 Bytes für int- und float-Felder

  • 2 Bytes für Kurz- und Zeichenfelder

  • 1 Byte für Byte und Boole'sche Felder

Außerdem werden Objekte in 8-Byte-Schritten zugeordnet, siehe auch das Werkzeug Java Object Layout (JOL) [2].

CustomMap

Die CustomMap-Schnittstelle (Listing 1) enthält eine Untermenge von Methoden, die in java.util.Map definiert sind. In der Struktur der Proxy Design Patterns ist CustomMap ein Beispiel für das Subject-Interface.

Listing 1: CustomMap Interface

//:~ src/main/java/../ch02/virtual/CustomMap.java
 
public interface CustomMap<K, V> {
  int size();
  V get(Object key);
  V put(K key, V value);
  V remove(Object key);
  void clear();
  void forEach(BiConsumer<? super K, ? super V> action);
  // etc.
}

Die Klassenstruktur unserer CustomMap ist in Abbildung 2 zu sehen.

kabutz_designpatterns_2_2.tif_fmt1.jpgAbb. 2: Klassenstruktur unserer CustomMap

CustomHashMap

CustomHashMap implementiert CustomMap. Da wir das Rad nicht neu erfinden wollen, delegieren wir alle Methoden an eine java.util.HashMap. In der Struktur der Proxy Design Patterns ist CustomHashMap ein Beispiel für die Klasse RealSubject (Listing 2).

Listing 2: CustomHashMap Class

//:~ src/main/java/../ch02/virtual/CustomHashMap.java
 
public class CustomHashMap<K, V> implements CustomMap<K, V> {
  private final Map<K, V> map = new HashMap<>();
  {
    System.out.println("CustomHashMap constructed");
  }
  @Override
  public int size() {
    return map.size();
  }
  @Override
  public V get(Object key) {
    return map.get(key);
  }
  @Override
  public V put(K key, V value) {
    return map.put(key, value);
  }
  @Override
  public V remove(Object key) {
    return map.remove(key);
  }
  @Override
  public void clear() {
    map.clear();
  }
  @Override
  public void forEach(BiConsumer<? super K, ? super V> action) {
    map.forEach(action);
  }
  @Override
  public String toString() {
    return map.toString();
  }
}

VirtualHashMap

Zuletzt erstellen wir unseren Virtual Proxy namens VirtualCustomMap. Wenn wir den Virtual Proxy konstruieren, geben wir einen Supplier <CustomMap<K, V>> an. Beim ersten Aufruf einer Methode auf der CustomMap können wir die reale Karte mit dem Lieferanten erstellen und die Operationen an diese reale Karte delegieren. VirtualMap ist ein Beispiel für den Proxy in der Proxy-Struktur (Kasten: „VirtualMap: nicht threadsicher“, Listing 3).

Listing 3: VirtualCustomMap Proxy Class

//:~ src/main/java/../ch02/virtual/VirtualCustomMap.java
 
public class VirtualCustomMap<K, V> implements CustomMap<K, V> {
  private final Supplier<CustomMap<K, V>> mapSupplier;
  private CustomMap<K, V> realMap;
  public VirtualCustomMap(Supplier<CustomMap<K, V>> mapSupl) {
    this.mapSupplier = mapSupl;
  }
  private CustomMap<K, V> getRealMap() { // not thread-safe
    if (realMap == null) realMap = mapSupplier.get();
    return realMap;
  }
  @Override
  public int size() {
    return getRealMap().size();
  }
  @Override
  public V get(Object key) {
    return getRealMap().get(key);
  }
  @Override
  public V put(K key, V value) {
    return getRealMap().put(key, value);
  }
  @Override
  public V remove(Object key) {
    return getRealMap().remove(key);
  }
  @Override
  public void clear() {
    getRealMap().clear();
  }
  @Override
  public void forEach(BiConsumer<? super K, ? super V> action) {
    getRealMap().forEach(action);
  }
}

VirtualMap: nicht threadsicher

Unsere VirtualMap ist nicht threadsicher. Wenn zwei Threads eine Methode gleichzeitig aufrufen, könnten wir versehentlich zwei reale Maps erstellen. Wir werden dies später beheben, indem wir den Virtual mit einem Protection Proxy kombinieren.

Schauen wir uns an, wie wir das nutzen können. Unsere lokale variable Karte zeigt auf eine VirtualMap-Instanz. Die eigentliche HashMap wird erst erstellt, wenn wir eine Methode wie put() oder get() zum ersten Mal aufrufen. Wenn wir das tun, wird der Anbieter aufgerufen und die HashMap erstellt. Danach werden alle Aufrufe an die enthaltene HashMap geroutet (Listing 4).

Listing 4: VirtualProxyDemo

//:~ src/main/java/../ch02/virtual/VirtualProxyDemo.java
 
    CustomMap<String, Integer> map =
      new VirtualCustomMap<>(CustomHashMap::new);
    System.out.println("Virtual Map created");
    map.put("one", 1);
    map.put("life", 42);
    System.out.println("map.get(\"life\") = " + map.get("life"));
    System.out.println("map.size() = " + map.size());
    System.out.println("clearing map");
    map.clear();
    System.out.println("map.size() = " + map.size());
    // end::listing[]
  }
}

Listing 5 zeigt die Ausgabe von VirtualProxyDemo.

Listing 5: Ausgabe von VirtualProxyDemo

Virtual Map created
CustomHashMap constructed
map.get("life") = 42
map.size() = 2
clearing map
map.size() = 0

Seit Java 7 haben sowohl ArrayList als auch HashMap standardmäßig Zero-Length-Element-Arrays. ArrayDeque, Vector und Hashtable ordnen ihre Arrays noch während der Konstruktion zu.

Aufruf von Remote-Methoden mit Remote-Proxy

Bei Botschaften handelt es sich um lokale Vertretungen ferner Länder. Wir besuchen sie, wenn wir ein Visum beantragen müssen, unseren Pass erneuern lassen oder mit einer entfernten Einrichtung interagieren wollen, ohne in ein Flugzeug zu steigen. Botschaften sind ein bisschen wie Remote Proxys. Wir möchten ein Visum für einen Besuch in Kanada beantragen (Listing 6).

Listing 6: Canada

//:~ src/main/java/../ch02/remote/Canada.java
 
public interface Canada {
  boolean canGetVisa(String name,
                     boolean married,
                     boolean rich);
}

Unsere Implementierungsklasse ist innerhalb von RealCanada (Listing 7) definiert, die die wichtigsten Attribute prüft. Wir werden dies mit dem Spark Framework [3] veröffentlichen (Listing 8). Das wars mit der Serverseite. Wenn wir den ServicePublisher betreiben, erstellt er einen REST-Dienst, mit dem wir uns verbinden können. Als Nächstes erstellen wir einen Remote Proxy, der sich mit dem REST-Dienst verbindet und die Methode aufruft (Listing 9).

Listing 7: RealCanada

//:~ src/main/java/../ch02/remote/RealCanada.java
 
public class RealCanada implements Canada {
  @Override
  public boolean canGetVisa(String name,
                            boolean married,
                            boolean rich) {
    return married && rich || !married && rich || rich;
    // every country loves rich tourists ... :-)
  }
}

Listing 8: Remote Proxy Publisher

//:~ src/main/java/../ch02/remote/ServicePublisher.java
 
public class ServicePublisher...

headline from sands settings