=================
== Time Stream ==
=================
一个小学生

Java动态代理机制解析

Java动态代理

动态代理是指在运行时动态生成代理类。不需要我们像静态代理那个去手动写一个个的代理类。生成动态代理类有很多方式:Java动态代理,CGLIB,Javassist,ASM库等。这里主要说一下Java动态代理的实现。

Java动态代理

InvocationHandler接口

Java动态代理中,每一个动态代理类都必须要实现InvocationHandler接口,当我们通过代理对象调用一个方法的时候,这个方法就会被转发给代理类的invoke方法来调用,InvocationHandler接口只有一个方法:

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

proxy,真实对象。method,我们调用的真实对象的方法。args,要调用真实对象的方法时接受的参数。

Proxy类

实现了InvocationHandler的类是动态代理类,而Proxy就是用来动态创建代理类对象的工具,通常情况下我们只使用newProxyInstance这个方法,newProxyInstance定义:

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

loader,对生成的代理类对象进行加载的ClassLoader。interfaces,代理对象会实现这些接口。h,动态代理对象调用方法的时候,要发送到哪个InvocationHandler上。

例子

我们知道,在之前的静态代理中,每个代理类都实现了特定接口,针对每一个事情都需要去定义一个代理类,会迅速的使类变多,重复也会多。而使用动态代理可以避免这一点,还是使用之前的找人还钱的例子。

Subject:

package me.cxis.test.gof.proxy.dynamicproxy;

/**
 * Created by cheng.xi on 2017-04-12 19:58.
 * 代理模式的主题类,这里代表的是欠钱的人
 */
public interface Subject {
    /**
     * 还给我的钱
     * @param moneyCount 欠钱数
     * @return 还给我的钱数
     */
    int giveMeMyMoney(int moneyCount);
}

RealSubject:

package me.cxis.test.gof.proxy.dynamicproxy;

/**
 * Created by cheng.xi on 2017-04-12 19:58.
 * 真实主题,这里代表的是欠我钱的人
 */
public class RealSubject implements Subject {
    @Override
    public int giveMeMyMoney(int moneyCount) {
        return moneyCount;
    }
}

DynamicProxy:

package me.cxis.test.gof.proxy.dynamicproxy;


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * Created by cheng.xi on 2017-04-12 19:59.
 * 代理
 */
public class DynamicProxy implements InvocationHandler{

    private Object target;

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

    public <T> T getProxy(){
        return (T) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("办事之前先收取点费用");
        System.out.println("开始办事");
        Object result = method.invoke(target,args);
        System.out.println("办完了");
        return result;
    }
}

测试方法:

package me.cxis.test.gof.proxy.dynamicproxy;

/**
 * Created by cheng.xi on 2017-04-12 20:06.
 */
public class Main {

    public static void main(String[] args) {
        Subject zhangsan = new RealSubject();
        Subject proxy = new DynamicProxy(zhangsan).getProxy();
        int money = proxy.giveMeMyMoney(1000);
        System.out.println(money);
    }
}

可以看到我们把之前的代理类,换成了现在的动态代理类,调用方法也有所改变,看起来没什么大的区别,但是当我们在需要一个类似的业务的时候,就有差别了,我们无需在定义第二个动态代理类,只需要有新的Subject1接口和RealSubject1实现即可,在我们测试方法中直接调用就可以了,动态代理类完全不需要改变。

Java动态代理的优缺点

优点:Java动态代理可以避免静态代理带来的代码冗余的问题。

缺点:Java动态代理只能针对接口创建代理,不能针对类创建代理。

Java动态代理到底做了什么?

其实动态代理是在运行时候为我们生成了一个代理类,大概如下:

public final class $Proxy1 extends Proxy implements Subject{
    private InvocationHandler h;
    private $Proxy1(){}
    public $Proxy1(InvocationHandler h){
        this.h = h;
    }
    public int giveMeMyMoney(int i){
    	////创建method对象
        Method method = Subject.class.getMethod("giveMeMyMoney", new Class[]{int.class});
        //调用了invoke方法
        return (Integer)h.invoke(this, method, new Object[]{new Integer(i)}); 
    }
}

从中可以看到,InvocationHandler是我们实现的那个类,我们实现了invoke方法,这里就是调用了invoke方法。

同时我们看到这个类实际上实现了我们的主题类Subject,看着和静态代理差不多了把。另外着重看下这个类继承了Proxy类,看到这里,对于JDK动态代理为什么不能代理类只能代理接口,就明了了,因为他已经继承了Proxy类。

动态代理的用处

  • Spring AOP就是使用的动态代理方式。
  • dubbo消费者初始化的时候生成代理,也是使用的动态代理。
  • hibernate的懒加载。

其他例子

延迟加载代理举例:

接口类:

public interface ILoadFile{
	String load();
}

真实实现类:

public class LoadFile implements ILoadFile{
	String fileContent = "";
    
    public LoadFile(){
    	try{
        	//这里模拟加载一个大文件,需要时间很长
        	Thread.sleep(10000);
            //加载完之后
            fileContent = "file contents...";
        }catch(Exception e){
        
        }
    }
    
    public String load(){
    	return fileContent;
    }
    
}

代理类:

public LoadFileHandler implements InvocationHandler{
	ILoadFile loadFile = null;
    
    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
    	if( loadFile == null){
        	loadFile = new LoadFile();
        }
        
        return loadFile.load();
    }
}

生成动态代理对象并使用:

public static void main(String[] args){
	ILoadFile loadFile = (ILoadFile)Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{ILoadFile.class},new LoadFileHandler());
    loadFile.load();
}