Introduction détaillée au proxy dynamique et au mécanisme de réflexion en Java (exemple de code)

Le contenu de cet article est une introduction détaillée (exemple de code) sur le proxy dynamique et le mécanisme de réflexion en Java. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Mécanisme de réflexion

Une fonction de base fournie par le langage Java. Grâce à la réflexion, nous pouvons faire fonctionner cette classe ou cet objet, comme l'obtention des méthodes, des propriétés et des méthodes de construction. , etc.

Proxy dynamique : divisé en proxy dynamique JDK et proxy dynamique cglib (proxy dynamique au printemps).

Procuration statique

La relation entre l'agent et l'agent est déterminée à l'avance (c'est-à-dire si la classe de l'agent est déterminée avant le). le programme s'exécute Il existe déjà. Cette situation est appelée proxy statique

proxy dynamique

classe proxy créée lors de l'exécution du programme. En d'autres termes, la classe proxy n'est pas définie dans le code Java, mais est générée dynamiquement pendant l'exécution en fonction de nos « instructions » dans le code Java.

L'avantage du proxy dynamique par rapport au proxy statique est :

Le proxy dynamique peut facilement gérer (invoquer) les fonctions de la classe proxy de manière uniforme, au lieu de modifier chaque fonction. Une fonction de classe proxy, plus flexible et extensible.

Proxy dynamique du JDK (dépend de l'interface)

Dans le mécanisme de proxy dynamique de Java, il existe deux classes ou interfaces importantes, l'une est l'interface InvocationHandler et l'autre L’une est la classe Proxy.

L'interface InvocationHandler est implémentée pour la classe proxy dynamique et est responsable du traitement des opérations de l'objet proxy

La classe Proxy est utilisée pour créer des objets d'instance de classe proxy dynamique uniquement en obtenant. cet objet peut effectuer les appels requis.

La classe proxy du proxy dynamique est modifiée sur la classe proxy statique, la classe proxy dynamique implémente l'interface InvocationHandler et remplace la méthode Invoke. La méthode Invoke est exécutée via la méthode et les paramètres de la classe proxy entrante.

L'exemple suivant :

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
* 
*/

proxy dynamique cglib (mode héritage)

proxy dynamique cglib Utilisez MethodInterceptor pour implémenter des classes proxy dynamiques.

Dans l'intercepteur MethodInterceptor, la méthode proxy est appelée par la méthode InvokSuper de MethodProxy.

La classe MethodProxy génère des méthodes proxy et des signatures de méthodes proxy.

La différence entre le proxy dynamique JDK et le proxy dynamique Cglib :

1. Le proxy dynamique JDK implémente l'interface de l'objet proxy, tandis que Cglib hérite de l'objet proxy.

2. Parce que Cglib est un mécanisme d'héritage, il ne peut pas proxy de méthodes modifiées par final.

3. JDK et Cglib produisent du bytecode pendant l'exécution. JDK écrit directement le bytecode de classe, tandis que Cglib utilise le framework ASM pour écrire le bytecode de classe ; efficacité.

4. JDK appelle les méthodes proxy via le mécanisme d'implémentation de réflexion, tandis que cglib appelle les méthodes directement via le mécanisme Fashclass, qui est plus efficace.

Mécanisme Fastcalss :

Générer une classe pour la classe proxy et la classe proxy. Cette classe attribuera un index à la méthode de la classe proxy ou de la classe proxy. .

Cet index est utilisé comme paramètre d'entrée, et Fashclass peut directement localiser la méthode à appeler et l'appeler directement. Cela élimine le besoin d’appels de réflexion, ce qui est donc très efficace.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!