[转]深入理解Java Proxy机制

落日映苍穹つ 2022-05-23 04:39 198阅读 0赞

## [\[转\]深入理解Java Proxy机制][Java Proxy] ##

该文章转自网络，原文不可考，给出转载文章链接：http://blog.csdn.net/rokii/article/details/4046098

看项目代码看到一段写的很美的代理机制，整理一下：

动态代理其实就是java.lang.reflect.Proxy类动态的根据您指定的所有接口生成一个class byte，该class会继承Proxy类，并实现所有你指定的接口（您在参数中传入的接口数组）；然后再利用您指定的classloader将 class byte加载进系统，最后生成这样一个类的对象，并初始化该对象的一些属性，如invocationHandler，以及所有的接口对应的Method成员。 初始化之后将对象返回给调用的客户端。这样客户端拿到的就是一个实现你所有的接口的Proxy对象。请看实例分析：

业务接口

public interface BusinessProcessor {
     public void processBusiness();
    }

业务接口实现类

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

业务代理类

![复制代码][copycode.gif]

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;
     　　}
    
    }

![复制代码][copycode.gif]

客户端应用类

![复制代码][copycode.gif]

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();
     }
    }

![复制代码][copycode.gif]

打印结果：

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

通过结果我们就能够很简单的看出Proxy的作用了，它能够在你的核心业务方法前后做一些你所想做的辅助工作，如log日志，安全机制等等。

现在我们来分析一下上面的类的工作原理。  
  
类一二没什么好说的。

先看看类三吧：实现了InvocationHandler接口的invoke方法。其实这个类就是最终Proxy调用的固定接口方法。Proxy不管客户端的业务方法是怎么实现的。当客户端调用Proxy时，它只  
  
会调用InvocationHandler的invoke接口，所以我们的真正实现的方法就必须在invoke方法中去调用。关系如下：

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

那么bp到底是怎么样一个对象呢。我们改一下main方法看一下就知道了：

![复制代码][copycode.gif]

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());
     }

![复制代码][copycode.gif]

输出结果：

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

bp原来是个$Proxy0这个类的对象。那么这个类到底是长什么样子呢？好的。我们再写二个方法去把这个类打印出来看个究竟，是什么三头六臂呢？我们在main下面写如下两个静态方法。

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

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("}");
     }

![复制代码][copycode.gif]

再改写main方法

![复制代码][copycode.gif]

现在我们再看看输出结果：

> 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();  
> \}

很明显，Proxy.newProxyInstance方法会做如下几件事：  
  
1，根据传入的第二个参数interfaces动态生成一个类，实现interfaces中的接口，该例中即BusinessProcessor接口的processBusiness方法。并且继承了Proxy类，重写了hashcode,toString,equals等三个方法。具体实现可参看 ProxyGenerator.generateProxyClass(...); 该例中生成了$Proxy0类  
  
2，通过传入的第一个参数classloder将刚生成的类加载到jvm中。即将$Proxy0类load  
  
3，利用第三个参数，调用$Proxy0的$Proxy0(InvocationHandler)构造函数 创建$Proxy0的对象，并且用interfaces参数遍历其所有接口的方法，并生成Method对象初始化对象的几个Method成员变量  
  
4，将$Proxy0的实例返回给客户端。  
  
现在好了。我们再看客户端怎么调就清楚了。  
  
1，客户端拿到的是$Proxy0的实例对象，由于$Proxy0继承了BusinessProcessor，因此转化为BusinessProcessor没任何问题。  
  
BusinessProcessor bp = (BusinessProcessor)Proxy.newProxyInstance(....);  
  
2，bp.processBusiness()；  
  
实际上调用的是$Proxy0.processBusiness();那么$Proxy0.processBusiness()的实现就是通过InvocationHandler去调用invoke方法啦!

分类:  [java基础篇][java]

[Java Proxy]: https://www.cnblogs.com/huntfor/p/4720862.html
[copycode.gif]: /images/20220523/b48e77a29c9c4422b53f04ff82726b70.png
[ExpandedBlockStart.gif]: /images/20220523/de553101ea9040428fcb245819de6758.png
[java]: http://www.cnblogs.com/huntfor/category/600921.html