java Proxy(代理机制)

简介:

我们知道Spring主要有两大思想,一个是IoC,另一个就是AOP,对于IoC,依赖注入就不用多说了,而对于Spring的核心AOP来说,我们不但要知道怎么通过AOP来满足的我们的功能,我们更需要学习的是其底层是怎么样的一个原理,而AOP的原理就是java的动态代理机制,所以本篇随笔就是对java的动态机制进行一个回顾。

  在java的动态代理机制中,有两个重要的类或接口,一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class),这一个类和接口是实现我们动态代理所必须用到的。首先我们先来看看java的API帮助文档是怎么样对这两个类进行描述的:

InvocationHandler:


InvocationHandler is the interface implemented by the invocation handler of a proxy instance. 

Each proxy instance has an associated invocation handler. When a method is invoked on a proxy instance, the method invocation is encoded and dispatched to the invoke method of its invocation handler.

每一个动态代理类都必须要实现InvocationHandler这个接口,并且每个代理类的实例都关联到了一个handler,当我们通过代理对象调用一个方法的时候,这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。我们来看看InvocationHandler这个接口的唯一一个方法 invoke 方法:


Object invoke(Object proxy, Method method, Object[] args) throws Throwable

我们看到这个方法一共接受三个参数,那么这三个参数分别代表什么呢?


Object invoke(Object proxy, Method method, Object[] args) throws Throwable

proxy:  指代我们所代理的那个真实对象
method:  指代的是我们所要调用真实对象的某个方法的Method对象
args:  指代的是调用真实对象某个方法时接受的参数

如果不是很明白,等下通过一个实例会对这几个参数进行更深的讲解。

接下来我们来看看Proxy这个类:


Proxy provides static methods for creating dynamic proxy classes and instances, and it is also the superclass of all dynamic proxy classes created by those methods.

Proxy这个类的作用就是用来动态创建一个代理对象的类,它提供了许多的方法,但是我们用的最多的就是 newProxyInstance 这个方法:


public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,  InvocationHandler h)  throws IllegalArgumentException
Returns an instance of a proxy class for the specified interfaces that dispatches method invocations to the specified invocation handler.

这个方法的作用就是得到一个动态的代理对象,其接收三个参数,我们来看看这三个参数所代表的含义:


public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

loader:  一个ClassLoader对象,定义了由哪个ClassLoader对象来对生成的代理对象进行加载

interfaces:  一个Interface对象的数组,表示的是我将要给我需要代理的对象提供一组什么接口,如果我提供了一组接口给它,那么这个代理对象就宣称实现了该接口(多态),这样我就能调用这组接口中的方法了

h:  一个InvocationHandler对象,表示的是当我这个动态代理对象在调用方法的时候,会关联到哪一个InvocationHandler对象上

好了,下面给出代理样例:

首先我们定义了一个HjzggMethod类型的接口


package com.hjzgg.proxy;

public interface HjzggMethod {
    public int addMethod(int a, int b);
    public int subMethod(int a, int b);
}

接着,定义了一个类来实现这个接口,这个类就是我们的真实对象,HjzggMethodImpl 类


package com.hjzgg.proxy;

public class HjzggMethodImpl implements HjzggMethod {

    @Override
    public int addMethod(int a, int b) {
        System.out.println("我执行了!");
        return a+b;
    }

    @Override
    public int subMethod(int a, int b) {
        return a-b;
    }

}

创建动态代理类,这个类并没有实现InvocationHandler ,而是在类方法中间接的创建一个InvocationHandler 实例


package com.hjzgg.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class MethodProxy {
    private HjzggMethod target;
    public MethodProxy(HjzggMethod target)
    {
        super();
        this.target = target;
    }
    public HjzggMethod getMethodProxy()
    {
        HjzggMethod proxy = null;
        //代理对象由哪一个类加载器加载
        ClassLoader loader = target.getClass().getClassLoader();
        //代理对象的类型,即其中有哪些方法
        //Class[] interfaces = new Class[]{HjzggMethod.class};
        Class[] interfaces = target.getClass().getInterfaces();
        //当调用代理对象其中的方法时,该执行的代码
        InvocationHandler h = new InvocationHandler(){
            @Override
            public Object invoke(Object proxy, java.lang.reflect.Method method, Object[] args) throws Throwable {
                String methodName = method.getName();
                System.out.println(method);
                System.out.println("the method: " + methodName + "开始, 参数: "+Arrays.asList(args));
                Object result = method.invoke(target, args);
                System.out.println("the method: "+methodName+"结束, 结果: " + result);
                return result;
            }
        };
        proxy=(HjzggMethod) Proxy.newProxyInstance(loader, interfaces, h);
        return proxy;
    }
}

最后测试类如下:


package com.hjzgg.proxy;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class ProxyTest {
    
    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("}");
     }
    
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{
        HjzggMethod method = new HjzggMethodImpl();
        System.out.println(method.getClass().getMethod("addMethod", int.class, int.class));
        HjzggMethod methodProxy = new MethodProxy(method).getMethodProxy();
        methodProxy.addMethod(10, 20);
        
        printClassDefinition(methodProxy.getClass());
    }
}

最后的输出结果:


public int com.hjzgg.proxy.HjzggMethodImpl.addMethod(int,int)
public abstract int com.hjzgg.proxy.HjzggMethod.addMethod(int,int)
the method: addMethod开始, 参数: [10, 20]
the method: addMethod结束, 结果: 30
$Proxy0 extends java.lang.reflect.Proxy implements com.hjzgg.proxy.HjzggMethod
{
    java.lang.reflect.Method m1;
    java.lang.reflect.Method m3;
    java.lang.reflect.Method m0;
    java.lang.reflect.Method m4;
    java.lang.reflect.Method m2;

    int subMethod(int, int);
    boolean equals(java.lang.Object);
    java.lang.String toString();
    int hashCode();
    int addMethod(int, int);
}

从输出结果来看,原来通过 HjzggMethod methodProxy = new MethodProxy(method).getMethodProxy();得到的HjzggMethod 实例其实是继承自Proxy 的,并且实现了HjzggMethod (我们之前定义的接口)接口中的方法。在实现的方法(比如addMethod)中是通过 InvocationHandler 调用invoke方法,然后InvocationHandler的invoke方法中又调用method中的invoke来实现。执行的顺序是  methodProxy.addMethod(10, 20); -> InvocationHandler中的invoke() -> method中的invoke()。还有就是method这个对象是可以通过接口.class来获得的。method.invoke(obj, args)中的obj实体一定是实现了该method对应的接口。恰巧我们在创建代理对象的时候,(HjzggMethod) Proxy.newProxyInstance(loader, interfaces, h),也有interfaces(接口的字节码文件对象)。

通过下面的例子,你就可以轻松的理解InvocationHandler中invoke()方法中的method是如何得来的!


Method method = HjzggMethod.class.getMethod("addMethod", int.class, int.class);//通过HjzggMethod接口得到Methed实例

HjzggMethod hjzggMethod = new HjzggMethodImpl();//创建实现HjzggMethod接口的HjzggMethodImpl对象
method.invoke(hjzggMethod, 10, 20);//执行方法, 相当于hjzggMethod.addMethod(10, 20);


目录
相关文章
|
3月前
|
缓存 负载均衡 安全
|
6月前
|
网络协议 算法 Java
Java中如何通过代理实现对HTTP2网站的访问?
Java中如何通过代理实现对HTTP2网站的访问?
|
6月前
|
Java Python
设置代理ip——java
设置代理ip——java
|
6月前
|
设计模式 Java
java中的jdk代理和cglib代理
在Java中,代理是一种设计模式,它允许一个对象(代理)控制对另一个对象(真实对象)的访问。Java中的代理主要分为两种类型:JDK(Java Dynamic Proxy)代理和CGLIB(Code Generation Library)代理。
|
安全 Java
Java基础之代理
要想创建一个代理对象,需要使用Proxy类的newProxyInstance方法。
83 0
|
设计模式 Java 数据库连接
Java 动态代理机制 (一) JDK Proxy详解
JDK Proxy 代理是可以根据我们的 接口 Interface 生成类的字节码,从而可以在 Java 中为所欲为的一种技术,包括对象增强(修改成员变量),函数增强(在函数前后执行别的代码),根据接口名执行不同逻辑 等。在 Mybatis 中有典型应用。它的本质是 由 Proxy 生成一个 代理对象,实现我们的接口。这个对象中有我们的回调函数。当调用 代理对象的接口方法时,这个对象再调用我们的回调函数,我们的回调函数再调用原对象的对应方法。从而实现代理。为了实现代理模式,Proxy 用了另外一种设计模式:命令模式。 不过,如果我们没有接口,直接是个类,那么 Proxy 将不能用,我们可能需
|
设计模式 Java 数据库连接
Java 中创建代理的几种方式
代理模式 设计模式最初由 GOF 在《设计模式》一书中总结,将其划分为创建型、结构型、行为型三大类。其中结构型模式总结了一些将类或对象组合在一起的经典结构。
274 0
Java HttpClient 如何使用代理IP请求接口
Java HttpClient 如何使用代理IP请求接口
|
缓存 Java Spring
【小家Java】JDK动态代理技术,你真学会了吗?(Proxy、ProxyClassFactory)
【小家Java】JDK动态代理技术,你真学会了吗?(Proxy、ProxyClassFactory)
【小家Java】JDK动态代理技术,你真学会了吗?(Proxy、ProxyClassFactory)