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.
Abb. 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.
Abb. 2: Klassenstruktur unserer CustomMapCustomHashMap
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() = 0Seit 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...
