Was ist das Prinzip und die Implementierungsmethode des dynamischen Java-Proxys?

Agentur bedeutet: In manchen Szenarien findet die Person einen Makler, der sie bei der Erledigung einiger Aufgaben unterstützt, z. B. den Makler eines Prominenten, einen Hauskäufer, der einen Immobilienmakler sucht usw.

Der Agent führt hauptsächlich einige zusätzliche Hilfsoperationen für das Verhalten des Objekts aus.

So erstellen Sie ein Proxy-Objekt:

Die repräsentative Proxy-Klasse in Java ist: Java.lang.reflect.Proxy

Proxy bietet eine statische Methode, die verwendet wird, um ein Proxy-Objekt für das Objekt zu generieren und

Hauptklasse:

public class Test {
    public static void main(String[] args) {
        //1、创建一个类，对象类必须实现接口
        star s=new star("小明");
        //为小明这个明星对象生成一个代理对象(经纪人)
        skill s2=StarAgentProxy.getProxy(s);
        s2.sing();//走代理的
        s2.jump();
        
        //运行结果：
        //代理开始
        //小明开始唱歌
        //代理结束
        //代理开始
        //小明开始跳舞
        //代理结束
    }
}

Sternklasse (Objektklasse):

//明星类
public class star implements skill{
    private String name;
 
    public star(String name) {
        this.name = name;
    }
    //重写方法
    public void jump(){
        System.out.println(name+"开始跳舞");
    }
    public void sing(){
        System.out.println(name+"开始唱歌");
    }
}

zurückzugeben Verhaltensschnittstellenklasse:

//行为类
public interface skill {
    void jump();//跳舞
    void sing();//唱歌
}

Proxyklasse:

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
 
//代理类
public class StarAgentProxy {
    //定义一个方法来返回一个明星对象的代理对象
    public static skill getProxy(star obj){
        //为小明这个对象生成一个代理对象
        /*
          public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces, 对象实现的接口列表
                                          InvocationHandler h)
         */
        return (skill) Proxy.newProxyInstance(obj.getClass().getClassLoader(),
                obj.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("代理开始");
                        //真正的让小明去唱歌、跳舞
                        //method==>正在调用的方法对象， args==>代表这个方法的参数
                        Object rs=method.invoke(obj,args);
                        System.out.println("代理结束");
                        return rs;
                    }
                });
    }
}

Implementierungsschritte:

1 Die Schnittstelle muss vorhanden sein

2. Der Proxy Das Objekt muss die Schnittstelle

3 implementieren. Verwenden Sie die von der Proxy-Klasse bereitgestellte Methode, um das Proxy-Objekt des Objekts

# abzurufen. 🎜🎜#

Rufen Sie die Methode über das Proxy-Objekt auf. Wie sieht der Ausführungsprozess aus?

1. Gehen Sie zuerst zum Agenten

2. Der Agent kann einige zusätzliche Hilfsarbeiten für die Methode

3 ausführen die Methode, die das Objekt tatsächlich auslöst

4 Rückkehr zum Agenten, der für die Rückgabe von Ergebnissen an den Aufrufer der Methode verantwortlich ist

Wichtige Schritte zur Optimierung des Codes: # 🎜🎜#

1. Es muss eine Schnittstelle vorhanden sein, und die Implementierungsklasse muss die Schnittstelle implementieren (normalerweise wird ein Proxy basierend auf der Schnittstelle implementiert).

2 Erstellen Sie ein Objekt der Implementierung Klasse, die ein Geschäftsobjekt ist, und erstellen Sie dann ein Proxy-Objekt für das Geschäftsobjekt # 🎜🎜#

Vorteile des dynamischen Proxys:

1 Es kann die Funktion der Methode ohne verbessern Ändern des Quellcodes der Methode und Verbesserung der Wiederverwendung des Codes

# 🎜🎜#2 Vereinfacht die Programmierarbeit, verbessert die Entwicklungseffizienz und verbessert die Skalierbarkeit von Softwaresystemen

3. Kann alle Methoden des Proxy-Objekts vertreten. Ein Framework zum Proxying von Implementierungsklassenobjekten jedes Schnittstellentyps (mit Generika) #🎜🎜 #

    public static <T> T get(T obj){
        return (T) Proxy.newProxyInstance(obj.getClass().getClassLoader(),
                obj.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        return null;
                    }
                });
    }

Das obige ist der detaillierte Inhalt vonWas ist das Prinzip und die Implementierungsmethode des dynamischen Java-Proxys?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!