Detaillierte Einführung in den dynamischen Proxy- und Reflexionsmechanismus in Java (Codebeispiel)

Der Inhalt dieses Artikels ist eine detaillierte Einführung (Codebeispiel) über dynamische Proxy- und Reflexionsmechanismen. Ich hoffe, dass er für Sie hilfreich ist.

Reflexionsmechanismus

Eine von der Java-Sprache bereitgestellte Grundfunktion. Durch Reflexion können wir diese Klasse oder dieses Objekt bedienen, z. B. die Methoden, Eigenschaften und Konstruktionsmethoden abrufen , usw.

Dynamischer Proxy: unterteilt in dynamischen JDK-Proxy und dynamischen cglib-Proxy (dynamischer Proxy im Frühjahr).

Statischer Proxy

Die Beziehung zwischen dem Agenten und dem Agenten wird im Voraus bestimmt (während der Kompilierung), das heißt, wenn die Agentenklasse vor dem bestimmt wird Das Programm wird ausgeführt. Diese Situation wird als statischer Proxy

dynamischer Proxy

Proxy-Klasse bezeichnet, die erstellt wird, wenn das Programm ausgeführt wird. Mit anderen Worten: Die Proxy-Klasse ist nicht im Java-Code definiert, sondern wird zur Laufzeit basierend auf unseren „Anweisungen“ im Java-Code dynamisch generiert.

Der Vorteil eines dynamischen Proxys gegenüber einem statischen Proxy ist:

Der dynamische Proxy kann die Funktionen der Proxy-Klasse bequem auf einheitliche Weise verarbeiten (aufrufen), anstatt sie einzeln zu ändern Funktion. Eine Proxy-Klassenfunktion, flexibler und erweiterbarer.

Dynamischer Proxy von JDK (abhängig von der Schnittstelle)

Im dynamischen Proxy-Mechanismus von Java gibt es zwei wichtige Klassen oder Schnittstellen, eine ist die InvocationHandler-Schnittstelle und die andere Eine davon ist die Proxy-Klasse.

Die InvocationHandler-Schnittstelle ist für die Verarbeitung der Vorgänge des Proxy-Objekts verantwortlich.

Die Proxy-Klasse wird nur dann zum Erstellen dynamischer Proxy-Klasseninstanzobjekte verwendet Objekt erhalten wird, können die erforderlichen Aufrufe der Agent-Methode erfolgen.

Die Proxy-Klasse des dynamischen Proxys wird in der statischen Proxy-Klasse geändert. Die dynamische Proxy-Klasse implementiert die InvocationHandler-Schnittstelle und überschreibt die Invoke-Methode.

Das folgende Beispiel:

public interface AppService {
	void createApp(String name);
	void deleteApp(String name);
}
//代理类（比如微商代理）
public class AppServiceImpl implements AppService{

	@Override
	public void createApp(String name) {
		System.out.print("App["+name+"] has been created.");
	}

	@Override
	public void deleteApp(String name) {
		System.out.print("App["+name+"] has been delete.");
	}
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class LoggerInterceptor implements InvocationHandler {
    private Object target; //委托类(被代理类)的实例，比如厂家
    public LoggerInterceptor(Object target){  
        this.target = target;  
    }  
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
		System.out.println("Entered "+target.getClass().getName()+"-"+method.getName()+",with arguments{"+args[0]+"}");  
        Object result = method.invoke(target, args);
       //调用目标对象的方法  （调用厂家的方法（createApp）及参数（Kevin Test））
        System.out.println("Before return:"+result);  
        return result;  
	}

}

import java.lang.reflect.Proxy;

public class test {

public static void main(String[] args) {
　　　　AppService target = new AppServiceImpl();//生成目标对象 (代理类的对象)
　　　　//接下来创建代理对象 
　　　　AppService proxy = (AppService) Proxy.newProxyInstance( 
　　　　target.getClass().getClassLoader(), 
　　　　target.getClass().getInterfaces(), new LoggerInterceptor(target)); 
　　　　proxy.createApp("Kevin Test1"); 
　　　　proxy.deleteApp("Kevin Test2"); 
　　}

}/**
* 1、jdk的动态代理实现方式是依赖于接口的，首先使用接口来定义好操作规范。
* 2、通过proxy类产生的代理对象调用被代理对象的操作。
* 3、而这个操作又被分发给InvocationHandler接口的invoke方法具体执行
* 
* 在java的动态代理机制中，有两个重要的类或接口，一个是InvocationHandler接口、另一个则是 Proxy类，这个类和接口是实现我们动态代理所必须用到的。
InvocationHandler接口是给动态代理类实现的，负责处理被代理对象的操作的，而Proxy是用来创建动态代理类实例对象的，因为只有得到了这个对象我们才能调用那些需要代理的方法。
* 
* 此方法的参数含义如下 
proxy：代表动态代理对象 
method：代表正在执行的方法 
args：代表当前执行方法传入的实参 
返回值：表示当前执行方法的返回值
* 
* 如上：
* 使用了Proxy类的newProxyInstance方法生成代理对象，然后用这个对象去调用createApp()和deleteApp()方法，
* 其实系统会将这2个方法分发给invoke()方法区执行。其中proxy对象的类是系统帮我们动态创建了，其实实现了我们的业务接口AppService
* 
*/

cglib dynamischer Proxy (Vererbungsmethode)

MethodInterceptor wird im cglib dynamischen Proxy verwendet Erzielen Sie eine dynamische Agentenklasse.

Im Interceptor MethodInterceptor wird die Proxy-Methode von der InvokSuper-Methode von MethodProxy aufgerufen.

Die MethodProxy-Klasse generiert Proxy-Methoden und Signaturen von Proxy-Methoden.

Der Unterschied zwischen dem dynamischen JDK-Proxy und dem dynamischen Cglib-Proxy:

1. Der dynamische JDK-Proxy implementiert die Schnittstelle des Proxy-Objekts, während Cglib das Proxy-Objekt erbt.

2. Da Cglib ein Vererbungsmechanismus ist, kann es keine von final geänderten Methoden vertreten.

3. Sowohl JDK als auch Cglib schreiben Klassenbytecode direkt, während Cglib das ASM-Framework zum Schreiben von Klassenbytecode verwendet. Die Generierung von Agentenanalogen ist besser als bei JDK Low Effizienz.

4. JDK ruft Proxy-Methoden über den Reflection-Implementierungsmechanismus auf, während cglib Methoden direkt über den Fashclass-Mechanismus aufruft, was effizienter ist.

Fastcalss-Mechanismus:

Generieren Sie eine Klasse für die Proxy-Klasse und die Proxy-Klasse. Diese Klasse weist der Methode der Proxy-Klasse oder der Proxy-Klasse einen Index zu .

Dieser Index wird als Eingabeparameter verwendet, und Fashclass kann die aufzurufende Methode direkt finden und direkt aufrufen. Dadurch entfallen Reflexionsaufrufe und es ist äußerst effizient.

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in den dynamischen Proxy- und Reflexionsmechanismus in Java (Codebeispiel). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!