Analyse détaillée du mécanisme proxy en Java

Cet article présente principalement l'interprétation détaillée du mécanisme Java Proxy. Il est toujours très bon. Je le partage avec tous les amis qui en ont besoin peuvent s'y référer.

Le proxy dynamique est en fait la classe java.lang.reflect.Proxy qui génère dynamiquement un octet de classe basé sur toutes les interfaces que vous spécifiez. Cette classe héritera de la classe Proxy et implémentera toutes les interfaces que vous spécifiez (vous spécifiez. dans les paramètres Le tableau d'interface transmis); puis utilisez le chargeur de classe que vous avez spécifié pour charger l'octet de classe dans le système, et enfin générer un objet d'une telle classe et initialiser certaines valeurs de l'objet, telles que invocationHandler, aux membres de méthode correspondant à toutes les interfaces. Après initialisation, l'objet est renvoyé au client appelant. De cette façon, le client obtient un objet proxy qui implémente toutes vos interfaces. Veuillez consulter l'exemple d'analyse :

1 Classe d'interface métier

public interface BusinessProcessor {
 public void processBusiness();
}

2 Cours de mise en œuvre commerciale

public class BusinessProcessorImpl implements BusinessProcessor {
 public void processBusiness() {
 System.out.println("processing business.....");
 }
}

Trois cours d'agent commercial

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class BusinessProcessorHandler implements InvocationHandler {
 private Object target = null;
 BusinessProcessorHandler(Object target){
 this.target = target;
 }
 public Object invoke(Object proxy, Method method, Object[] args)
  throws Throwable {
 System.out.println("You can do something here before process your business");
 Object result = method.invoke(target, args);
 System.out.println("You can do something here after process your business");
 return result;
 }
}

Quatre classes d'applications client

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
public class Test {
 public static void main(String[] args) {
 BusinessProcessorImpl bpimpl = new BusinessProcessorImpl();
 BusinessProcessorHandler handler = new BusinessProcessorHandler(bpimpl);
 BusinessProcessor bp = (BusinessProcessor)Proxy.newProxyInstance(bpimpl.getClass().getClassLoader(), bpimpl.getClass().getInterfaces(), handler);
 bp.processBusiness();
 }
}

Jetons maintenant un œil aux résultats d'impression :

You can do something here before process your business
processing business.....
You can do something here after process your business

À travers les résultats, nous pouvons facilement voir le rôle du proxy. Il peut effectuer le travail auxiliaire que vous souhaitez avant et après vos méthodes commerciales principales. tels que les journaux, les mécanismes de sécurité, etc.

Analysons maintenant le fonctionnement de la classe ci-dessus.

Il n'y a pas grand chose à dire sur les catégories 1 et 2. Examinons d’abord la troisième catégorie. Implémente la méthode d'invocation de l'interface InvocationHandler. En fait, cette classe est la méthode d'interface fixe finalement appelée par Proxy. Le proxy n'a pas d'importance dans la manière dont la méthode commerciale du client est mise en œuvre. Lorsque le client appelle Proxy, il appellera uniquement l'interface d'invocation d'InvocationHandler, notre méthode réellement implémentée doit donc être appelée dans la méthode d'invocation. La relation est la suivante :

 BusinessProcessorImpl bpimpl = new BusinessProcessorImpl();
 BusinessProcessorHandler handler = new BusinessProcessorHandler(bpimpl);
BusinessProcessor bp = (BusinessProcessor)Proxy.newProxyInstance(....);
bp.processBusiness()-->invocationHandler.invoke()-->bpimpl.processBusiness();

Alors quel genre d'objet est bp ? Changeons la méthode principale et jetons un œil :

 public static void main(String[] args) {
 BusinessProcessorImpl bpimpl = new BusinessProcessorImpl();
 BusinessProcessorHandler handler = new BusinessProcessorHandler(bpimpl);
 BusinessProcessor bp = (BusinessProcessor)Proxy.newProxyInstance(bpimpl.getClass().getClassLoader(), bpimpl.getClass().getInterfaces(), handler);
 bp.processBusiness();
 System.out.println(bp.getClass().getName());
 }

Résultat de sortie :

You can do something here before process your business
processing business.....
You can do something here after process your business
$Proxy0

bp s'avère être un objet de classe $Proxy0. Alors à quoi ressemble ce cours ? D'ACCORD Écrivons deux autres méthodes pour imprimer cette classe et voir de quoi il s'agit avec trois têtes et six bras ? Nous écrivons les deux méthodes statiques suivantes sous main.

public static String getModifier(int modifier){
 String result = "";
 switch(modifier){
  case Modifier.PRIVATE:
  result = "private";
  case Modifier.PUBLIC:
  result = "public";
  case Modifier.PROTECTED:
  result = "protected";
  case Modifier.ABSTRACT :
  result = "abstract";
  case Modifier.FINAL :
  result = "final";
  case Modifier.NATIVE :
  result = "native";
  case Modifier.STATIC :
  result = "static";
  case Modifier.SYNCHRONIZED :
  result = "synchronized";
  case Modifier.STRICT :
  result = "strict";
  case Modifier.TRANSIENT :
  result = "transient";
  case Modifier.VOLATILE :
  result = "volatile";
  case Modifier.INTERFACE :
  result = "interface";
 }
 return result;
 }
 public static void printClassDefinition(Class clz){
 String clzModifier = getModifier(clz.getModifiers());
 if(clzModifier!=null && !clzModifier.equals("")){
  clzModifier = clzModifier + " ";
 }
 String superClz = clz.getSuperclass().getName();
 if(superClz!=null && !superClz.equals("")){
  superClz = "extends " + superClz;
 }
 Class[] interfaces = clz.getInterfaces();
 String inters = "";
 for(int i=0; i<interfaces.length; i++){
  if(i==0){
  inters += "implements ";
  }
  inters += interfaces[i].getName();
 }
 System.out.println(clzModifier +clz.getName()+" " + superClz +" " + inters );
 System.out.println("{");
 Field[] fields = clz.getDeclaredFields();
 for(int i=0; i<fields.length; i++){
  String modifier = getModifier(fields[i].getModifiers());
  if(modifier!=null && !modifier.equals("")){
  modifier = modifier + " ";
  }
  String fieldName = fields[i].getName();
  String fieldType = fields[i].getType().getName();
  System.out.println("  "+modifier + fieldType + " "+ fieldName + ";");
 }
 System.out.println();
 Method[] methods = clz.getDeclaredMethods();
 for(int i=0; i<methods.length; i++){
  Method method = methods[i];
  String modifier = getModifier(method.getModifiers());
  if(modifier!=null && !modifier.equals("")){
  modifier = modifier + " ";
  }
  String methodName = method.getName();
  Class returnClz = method.getReturnType();
  String retrunType = returnClz.getName();
  Class[] clzs = method.getParameterTypes();
  String paraList = "(";
  for(int j=0; j<clzs.length; j++){
  paraList += clzs[j].getName();
  if(j != clzs.length -1 ){
   paraList += ", ";
  }
  }
  paraList += ")";
  clzs = method.getExceptionTypes();
  String exceptions = "";
  for(int j=0; j<clzs.length; j++){
  if(j==0){
   exceptions += "throws ";
  }
  exceptions += clzs[j].getName();
  if(j != clzs.length -1 ){
   exceptions += ", ";
  }
  }
  exceptions += ";";
  String methodPrototype = modifier +retrunType+" "+methodName+paraList+exceptions;
  System.out.println("  "+methodPrototype );
 }
 System.out.println("}");
 }

Réécrivez la méthode principale

 public static void main(String[] args) {
 BusinessProcessorImpl bpimpl = new BusinessProcessorImpl();
 BusinessProcessorHandler handler = new BusinessProcessorHandler(bpimpl);
 BusinessProcessor bp = (BusinessProcessor)Proxy.newProxyInstance(bpimpl.getClass().getClassLoader(), bpimpl.getClass().getInterfaces(), handler);
 bp.processBusiness();
 System.out.println(bp.getClass().getName());
 Class clz = bp.getClass();
 printClassDefinition(clz);
 }

Regardons maintenant Regardez à nouveau le résultat :

You can do something here before process your business
processing business.....
You can do something here after process your business
$Proxy0
$Proxy0 extends java.lang.reflect.Proxy implements com.tom.proxy.dynamic.BusinessProcessor
{
  java.lang.reflect.Method m4;
  java.lang.reflect.Method m2;
  java.lang.reflect.Method m0;
  java.lang.reflect.Method m3;
  java.lang.reflect.Method m1;
  void processBusiness();
  int hashCode();
  boolean equals(java.lang.Object);
  java.lang.String toString();
}

Évidemment, la méthode Proxy.newProxyInstance fera les choses suivantes :

1, Générez dynamiquement une classe basée sur les interfaces du deuxième paramètre transmis pour implémenter l'interface dans les interfaces. Dans cet exemple, il s'agit de la méthode processBusiness de l'interface BusinessProcessor. Et il hérite de la classe Proxy et réécrit trois méthodes telles que hashcode, toString et equals. Pour une implémentation spécifique, veuillez vous référer à ProxyGenerator.generateProxyClass(...); Dans cet exemple, la classe $Proxy0

2 est générée et la classe nouvellement générée est chargée dans le jvm via le chemin transmis. dans le classloder du premier paramètre. Autrement dit, chargez la classe $Proxy0

3, utilisez le troisième paramètre, appelez le constructeur $Proxy0 (InvocationHandler) de $Proxy0 pour créer un objet de $Proxy0 et utilisez le paramètre interfaces pour parcourir toutes ses méthodes d'interface, et générer plusieurs variables membres de méthode de l'objet d'initialisation de l'objet méthode

4, et renvoyer l'instance de $Proxy0 au client.
Tout va bien maintenant. Voyons comment le client l'ajuste et cela deviendra clair.

1. Le client obtient l'objet instance de $Proxy0 Puisque $Proxy0 hérite de BusinessProcessor, il n'y a aucun problème à le convertir en BusinessProcessor.

BusinessProcessor bp = (BusinessProcessor)Proxy.newProxyInstance(....);

2, bp.processBusiness();

appelle en fait $Proxy0.processBusiness(); de $Proxy0.processBusiness() consiste à appeler la méthode d'invocation via InvocationHandler !

Résumé

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!