代理模式——静态代理和动态代理

放上我参考的认为写的很好的博客链接,自己写主要是为了学习一遍,谨慎参考。

链接

为什么要用动态代理呢?当然是静态代理太固定了,对于每一个要代理的对象,我们都要写一个代理类,不够灵活。而动态代理能够在运行时创建一个实现了一组给定接口的新类。

动态代理

代理类的特性

代理类实在程序运行过程中创建的,所有的代理类都扩展于Proxy类,为了履行代理对象的职责,所需的任何附加数据都必须存储在调用处理器中。

另外,所有的代理类都覆盖了Object中的方法,这些方法的调用都会调用调用处理器中的invoke。当然这些方法没有被重新定义。

调用处理器(invocation handler)

代理类要能够实现指定的接口,那么它需要下列方法:

  • 指定接口所需要的全部方法
  • Object类中的全部方法

当然,这些方法的定义自然是不能在运行时定义,这时候就需要用到调用处理器,调用处理器是实现了InvocationHandler接口的类对象。接口中有一个方法:

代理模式——静态代理和动态代理

 

 

public Object invoke(Object proxy, Method method, Object[] args)

当调用代理对象的任何方法时,调用处理器的invoke方法都会被调用

  • Object proxy
    被代理对象
  • Method method
    要调用的方法
  • Object[] args
    方法调用时所需要的参数

创建代理对象(Proxy.newProxyInstance)

代理模式——静态代理和动态代理

 

 

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

 

 

  • ClassLoader loader
    类的加载器
  • Class<?>[] interfaces
    需要实现的接口
  • InvocationHandler h
    一个调用处理器
通过该方法可以生成一个代理对象。

使用案例(来自于JAVA核心技术卷一)

这个案例实际上代理的是Integer类以及Comparable接口

TraceHandler.java

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

public class TraceHandler implements InvocationHandler {

    Object target; //要代理的对象

    public TraceHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        /**
         * 打印代理方法的相关信息
         */
        System.out.print(target);
        System.out.print("."+method.getName()+"(");
        System.out.println(Arrays.toString(args)+")");
        return method.invoke(target,args);  //用反射包中的invoke方法调用实际的方法
    }
}

 

 

ProxyTest.java

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

/**
 * 创建一个数组用于接受代理了Integer类的代理对象,也就是放置0到1000的数值,但不是Integer类型了。
 * 代理了Comparable接口,接替了代理类(integer)中的compareTo方法,根据我们的调用处理器定义调用invoke
 * 方法时它会打印调用方法的相关信息
 */
public class ProxyTest {
    public static void main(String[] args) {
        Object[] elements = new Object[1000];
        
        for(int i = 0;i< elements.length;i++){
            TraceHandler handler = new TraceHandler(Integer.valueOf(i));
            Object proxyInstance = Proxy.newProxyInstance(Integer.class.getClassLoader(), new Class[]{Comparable.class}, handler);
            elements[i]  = proxyInstance;
        }
        int i = Arrays.binarySearch(elements, 188);  //它会多次调用compareTo方法用于比较大小,而调用compareTo方法实际上会调用invoke方法
        if(i>=0)
            System.out.println(elements[i]);

    }
}


代理模式——静态代理和动态代理

 


 

 

上一篇:我的Java学习笔记-语法


下一篇:动态代理