Die Java Dynamic Proxy -Klasse befindet sich unter dem Paket java.lang.reflect und umfasst im Allgemeinen hauptsächlich die folgenden zwei Klassen:
(1) InvocationHandler: In dieser Schnittstelle ist nur eine Methode definiert
öffentliches Objekt aufrufen (Objekt OBJ, Methode Methode, Objekt [] args)
Im tatsächlichen Gebrauch bezieht sich der erste Parameter obj im Allgemeinen auf die Proxy -Klasse. Die Methode ist die Proxy -Methode, wie z. Diese abstrakte Methode wird in der Proxy -Klasse dynamisch implementiert.
(2) Proxy: Diese Klasse ist eine dynamische Proxy -Klasse, und seine Funktion ähnelt dem ProxySubject im obigen Beispiel, das haupt interne h.
Statische Klasse getProxyClass (Classloader Loader, Klasse [] Schnittstellen)
Holen Sie sich eine Proxy -Klasse, in der Loader der Klassenlader ist und Schnittstellen ein Array aller Schnittstellen, die der realen Klasse gehören.
Statisches Objekt NewProxyInstance (Classloader Loader, Klasse [] Schnittstellen, InvocationHandler H)
Gibt eine Instanz der Proxy -Klasse zurück.
Der sogenannte dynamische Proxy ist eine Klasse: Es ist eine Klasse, die zur Laufzeit generiert wird. Natürlich können Sie die Instanz der Klasse als jede dieser Schnittstellen verwenden. Natürlich ist dieser dynamische Proxy tatsächlich ein Proxy, der bei der Generierung seiner Instanz keine wesentliche Arbeit leistet.
Bei Verwendung dynamischer Proxyklassen müssen wir die InvocationHandler -Schnittstelle implementieren:
Siehe das Programm Thema.java
Siehe das Programm RealSubject.java
Siehe Programm Dynamicsubject.java
Siehe den Programm Client.java
Die Codekopie lautet wie folgt:
Paket com.langsin.dynamicproxy;
// abstrakte Rolle (zuvor war es eine abstrakte Klasse, sie sollte hier in eine Schnittstelle geändert werden):
öffentliche Schnittstelle Fach
{
abstrakte öffentliche void request ();
}
Die Codekopie lautet wie folgt:
Paket com.langsin.dynamicproxy;
// Spezifische Rolle
öffentliche Klasse RealSubject implementiert Fach
{
public RealSubject ()
{
}
öffentliche void request ()
{
System.out.println ("From Real Subjekt");
}
}
Die Codekopie lautet wie folgt:
Paket com.langsin.dynamicproxy;
Import Java.lang.reflect.InvocationHandler;
import Java.lang.reflect.Method;
// Proxy -Prozessor
/**
* Die internen Eigenschaften der Proxy -Klasse sind Objektklasse.
* Zusätzlich wird die Invoke -Methode in dieser Klasse auch in der Methode implementiert.
* Tatsächlich soll die Methode vom Proxy -Objekt ausgeführt werden.
* Args ist der Parameter, der zur Durchführung des entsprechenden Betriebs des Proxy -Objekts erforderlich ist.
* Durch dynamische Proxyklassen können wir einige verwandte Operationen vor oder nach dem Anruf ausführen
*/
öffentliche Klasse Dynamicsubject implementiert InvocationHandler
{
privates Objekt Sub;
öffentliche Dynamicsubject ()
{
}
öffentliches Dynamicsubject (Objekt OBJ)
{
sub = obj;
}
öffentliches Objekt auf Incoke (Object Proxy, Methode Methode, Object [] Args) wirft Throwable ab
{
System.out.println ("vor dem Anruf" + Methode);
method.invoke (sub, args);
System.out.println ("nach dem Aufrufen" + Methode);
null zurückkehren;
}
}
Die Codekopie lautet wie folgt:
Paket com.langsin.dynamicproxy;
Import Java.lang.reflect.InvocationHandler;
importieren java.lang.reflect.proxy;
// Client
Kunde der öffentlichen Klasse
{
statische öffentliche void main (String [] args) wirft Throwable aus
{
RealSubject rs = new RealSubject ();
InvocationHandler ds = new Dynamicsubject (RS);
Klasse <?> Cls = rs.getClass ();
// Folgendes ist ein Einmalergenerationser Agent
Subjekt = (Subjekt) Proxy.NewProxyInstance (
cls.getClassloader (), cls.getInterfaces (), ds);
Betreff.Request ();
}
}
Beispiel 2:
Die Codekopie lautet wie folgt:
Paket com.langsin.dynamicproxy;
Import Java.lang.reflect.InvocationHandler;
import Java.lang.reflect.Method;
importieren java.lang.reflect.proxy;
importieren java.util.list;
Import Java.util.Vector;
öffentliche Klasse VectorProxy implementiert InvocationHandler
{
privates Objekt Proxyobj;
public vectorProxy (Objekt obj) {
Proxyobj = obj;
}
öffentliche statische Objektfabrik (Objekt obj) {
Klasse <?> Cls = obj.getClass ();
return proxy.newproxyinstance (cls.getClassloader (), cls.getInterfaces (), New VectorProxy (OBJ));
}
öffentliches Objekt invoke (Object Proxy, Methode Methode, Object [] args) wirft Throwable {aus
System.out.println ("vor dem Anruf" + Methode);
if (args! = null) {
für (int i = 0; i <args.length; i ++) {
System.out.println (args [i] + "");
}
}
Object Object = methode.invoke (Proxyobj, Args);
System.out.println ("nach dem Aufrufen" + Methode);
Objekt zurückgeben;
}
@Suppresswarnings ("Unbekämpft")
public static void main (String [] args) {
Liste <string> v = (Liste <string>) Fabrik (neuer Vektor <string> (10));
v.Add ("neu");
V.Add ("York");
System.out.println (v);
v.Remove (0);
System.out.println (v);
}
}
Beispiel 3.
Die Codekopie lautet wie folgt:
Paket com.langsin.dynamicproxy;
öffentliche Schnittstelle Foo {
void doaction ();
}
Paket com.langsin.dynamicproxy;
öffentliche Klasse fooimpl implementiert foo {
public fooimpl () {
}
public void doaction () {
System.out.println ("in fooimp1.doaction ()");
}
}
Paket com.langsin.dynamicproxy;
öffentliche Klasse fooimpl2 implementiert Foo {
public fooImpl2 () {
}
public void doaction () {
System.out.println ("in fooimp2.doaction ()");
}
}
Paket com.langsin.dynamicproxy;
Import Java.lang.reflect.InvocationHandler;
import Java.lang.reflect.Method;
öffentliche Klasse CommonInvocationHandler implementiert InvocationHandler {
// Dynamische Ausführung von Objekten, Objekte, die Rückrufe erfordern
privates Objektziel;
// Konstruktorinjektion unterstützen
public CommonInvocationHandler () {
}
// Konstruktorinjektion unterstützen
public CommonInvocationHandler (Objektziel) {
Settarget (Ziel);
}
/**
*
* Verwenden Sie die Setter -Methode, um injizieren
*
* @param Ziel
*
*/
public void settarget (Objektziel) {
this.target = Ziel;
}
/**
*
* Rufen Sie die in Proxy angegebene Methode auf und geben Sie die Parameterlisten -Argumente ein
*
* @param Proxy
* Der Typ der Proxy -Klasse, z. B. das Definieren der Proxy -Schnittstelle, die der Methode entspricht
*
* @param Methode
* Methode zur Proxyed
*
* @param args
* Parameter, die die Proxy -Methode aufrufen
*
* @zurückkehren
*
* @throws java.lang.throwable
*
*/
öffentliches Objekt invoke (Object Proxy, Methode Methode, Object [] args) wirft Throwable {aus
return methode.invoke (target, args);
}
}
Paket com.langsin.dynamicproxy;
importieren java.lang.reflect.proxy;
Public Class Demo {
public static void main (String [] args) {
// 1. General Dynamic Proxy Implementierung
CommonInvocationHandler -Handler = new CommonInvocationHandler ();
Foo f;
// 2. Schnittstellenimplementierung 1
Handler.Settarget (new fooimpl ());
// Methode Parameter Beschreibung: Proxy -Klasse, Proxy -Klassen -Implementierungsliste, Proxy -Klassenprozessor
// Verbinden Sie die Proxy -Klasse, die Schnittstellenmethoden und die Prozessoren in der Proxy -Klasse.
// Wenn die Proxy -Klasse die angegebene Schnittstellenliste nicht implementiert, wird eine illegale Parameterausnahme ausgeworfen
f = (foo) proxy.newproxyinstance (foo.class.getClassloader (),
neue Klasse [] {foo.class},
Handler);
f.doaction ();
// 3. Interface Implementierung 2
Handler.Settarget (new fooImpl2 ());
f = (foo) proxy.newproxyinstance (foo.class.getClassloader (),
neue Klasse [] {foo.class},
Handler);
f.doaction ();
}
}
Da ich nur begrenztes literarisches Talent habe, ist der größte Teil des Inhalts Code