1. Agentenmodus
Ein Agent ist eine Person oder Institution, die im Namen einer anderen Person oder Institution handelt. In manchen Fällen möchte oder kann ein Client ein Objekt nicht direkt referenzieren, und ein Proxy-Objekt kann als Vermittler zwischen dem Client und dem Zielobjekt fungieren.
Das Proxy-Muster stellt ein Proxy-Objekt für ein Objekt bereit und das Proxy-Objekt steuert den Verweis auf das Originalobjekt.
Beispiel aus dem wirklichen Leben: Sie sind über Neujahr mit Überstunden beschäftigt und haben keine Zeit, Bahntickets zu kaufen. Zu diesem Zeitpunkt können Sie das nahegelegene Ticketcenter anrufen und darum bitten, Ihnen ein Bahnticket nach Hause zu kaufen Fügen Sie zusätzliche Arbeitsgebühren hinzu. Es sollte jedoch klar sein, dass das Ticketcenter selbst keine Tickets verkauft. Nur der Bahnhof verkauft tatsächlich Tickets. Die Tickets, die das Ticketcenter an Sie verkauft, werden tatsächlich über den Bahnhof verkauft. Das ist sehr wichtig!
Im obigen Beispiel sind Sie der „Kunde“, das Ticketcenter ist die „Agentenrolle“, der Bahnhof ist die „reale Rolle“ und der Verkauf von Fahrkarten wird die „abstrakte Rolle“ genannt!
JAVA-Codebeispiel für den Agentenmodus:
Abstrakte Rolle: abstrakte Klasse oder Schnittstelle
Kopieren Sie den Codecode wie folgt:
SchnittstelleBusiness
{
void doAction();
}
Echte Rolle: Implementiert die Geschäftslogikschnittstelle wirklich
Agentenrolle: Sie implementiert nicht die Geschäftslogikschnittstelle, sondern ruft die eigentliche Rolle auf, um sie zu implementieren.
Kopieren Sie den Codecode wie folgt:
Die Klasse BusinessImplProxy implementiert Business
{
privat BusinessImpl bi;
public void doAction()
{
if (bi==null)
{
bi = new BusinessImpl();
}
doBefore();
bi.doAction();
doAfter();
}
public void doBefore()
{
System.out.println("Vorverarbeitung!");
}
public void doAfter()
{
System.out.println("Nachbearbeitung!");
}
}
//Testklasse
Klassentest
{
public static void main(String[] args)
{
//Referenzvariablen werden als abstrakte Rollentypen definiert
Business bi = new BusinessImplProxy();
bi.doAction();
}
}
Kopieren Sie den Codecode wie folgt:
<span></span>
Daher können mit der Unterstützung von JVM Proxy-Klassen („Agentenrollen“) zur Laufzeit dynamisch generiert werden, und wir können das Problem der Codeerweiterung im oben genannten Proxy-Modus lösen. Nach der Verwendung dynamischer Proxys sind keine „Agentenrollen“ erforderlich manuell zu generieren, die von der JVM zur Laufzeit dynamisch generiert wird, indem drei Parameter angegeben werden: Klassenlader, Schnittstellenarray und Aufrufhandler.
JAVA-Codebeispiel für den dynamischen Proxy-Modus:
Kopieren Sie den Codecode wie folgt:
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Method;
//Abstrakte Rolle: Die Implementierung des dynamischen Java-Proxys unterstützt derzeit nur Schnittstellen und keine abstrakten Klassen
Schnittstelle BusinessFoo
{
void foo();
}
SchnittstelleBusinessBar
{
String bar(String message);
}
//Echte Rolle: Geschäftslogikmethoden wirklich implementieren
Die Klasse BusinessFooImpl implementiert BusinessFoo
{
public void foo()
{
System.out.println("BusinessFooImpl.foo()");
}
}
Die Klasse BusinessBarImpl implementiert BusinessBar
{
öffentliche String-Leiste (String-Nachricht)
{
System.out.println("BusinessBarImpl.bar()");
Antwortnachricht;
}
}
//Dynamische Rolle: Proxy-Klasse dynamisch generieren
Die Klasse BusinessImplProxy implementiert InvocationHandler
{
privateObject obj;
BusinessImplProxy() {
}
BusinessImplProxy(Object obj) {
this.obj = obj;
}
public Object invoke(Object Proxy,Method method,Object[] args) löst Throwable aus
{
Objektergebnis = null;
doBefore();
result = method.invoke(obj,args);
doAfter();
Ergebnis zurückgeben;
}
public void doBefore(){
System.out.println("etwas vor Business Logic tun");
}
public void doAfter(){
System.out.println("etwas nach Business Logic tun");
}
öffentliche statische Objektfabrik (Objektobjekt)
{
Klasse cls = obj.getClass();
return Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),new BusinessImplProxy(obj));
}
}
//Testklasse
öffentliche Klasse DynamicProxy
{
public static void main(String[] args) wirft Throwable
{
BusinessFooImpl bfoo = new BusinessFooImpl();
BusinessFoo bf = (BusinessFoo)BusinessImplProxy.factory(bfoo);
bf.foo();
System.out.println();
BusinessBarImpl bbar = new BusinessBarImpl();
BusinessBar bb = (BusinessBar)BusinessImplProxy.factory(bbar);
String message = bb.bar("Hello,World");
System.out.println(message);
}
}
Beschreibung des Programmablaufs:
new BusinessFooImpl(); erstellt eine „echte Rolle“, übergibt sie an die Factory-Methode BusinessImplProxy.factory() und initialisiert dann den „Aufrufprozessor“ – die Klasse, die InvocationHandler implementiert. Und gibt eine dynamisch erstellte Proxy-Klasseninstanz zurück. Da die „Agentenrolle“ auch die von der „abstrakten Rolle“ bereitgestellte Geschäftslogikmethode implementieren muss, kann sie in BusinessBar umgewandelt und der Referenz-BB zugewiesen werden, die auf den BusinessBar-Typ verweist.
Mit der Methode newProxyInstance(ClassLoader Loader, Class<?>[] Interfaces, InvocationHandler h) können Programmierer Parameter angeben und die erforderliche Proxy-Klasse dynamisch zurückgeben, während die Methode invoke(Object Proxy, Method Method, Object[] Argumente) von verwendet wird Die JVM wird dynamisch zur Laufzeit aufgerufen. Wenn die Methode „bb.bar(„Hello,World“);“ ausgeführt wird, weist die JVM dynamisch einen „Aufrufprozessor“ zu, übergibt Parameter an den äußeren Aufruf und ruft method.invoke(obj, args) auf, um sie tatsächlich auszuführen !
Die statische Methode BusinessImplProxy.Factory wird zum dynamischen Generieren von Proxy-Klassen („Agentenrollen“) verwendet. Die Proxy-Rollen werden zur Laufzeit basierend auf verschiedenen Geschäftslogikschnittstellen BusinessFoo und BusinessBar dynamisch generiert. „Abstrakte Rolle“, „Agentenrolle“ und Aufrufhandler (Klasse, die die InvocationHandler-Schnittstelle implementiert) können alle geändert werden, sodass der dynamische Proxy von JAVA sehr leistungsfähig ist.