Java动态代理

最近做项目用到了动态代理，感觉还不熟悉，花了一个下午终于搞明白了动态代理，动态代理使用很简单，原理也不难，现在把使用方法记下来，以备用。

首先要明白的是，要代理一个类必须要有一个接口，就是被代理类必须实现了某个接口

 

所以我们先写一个接口：

package jdk.proxy.test;

/**

 * 说话的接口，对某个人说话，并且要有返回值

 * @authordemo

 *

 */

public interface Speak {

    public String speak(String toSomeBody);

}

 

 

 

然后再写People类，他实现了Speak接口：

package jdk.proxy.test;

 

import java.util.Random;

 

/**

 * People类,实现Speak接口

 * @authordemo

 *

 */

public class People implements Speak{

 

    @Override

    public String speak(String toSomeBody) {

       System.out.println("Hello"+toSomeBody);

       try {

           Thread.currentThread().sleep(newRandom().nextInt(10000));//随机休眠10秒以内的时间

       } catch (InterruptedException e) {

           e.printStackTrace();

       }

       return"return stris: Hello "+toSomeBody;

    }

 

}

那么，现在我们需要算出来这个人说话用了多长时间，也就是在调用People1的speak()方法前后各进行一些处理，在不改变源代码的情况下，有什么办法呢？

1、  继承：再写一个类，People2，继承与People，并且重写speak()方法，那么我们就可以在调用People1的speak方法前后做任何感兴趣的逻辑。

2、  聚合：新写一个类People1TimeProxy，他也实现Speak接口，但是这个类拥有一个People的对象，在实现Speak接口的speak()方法中，People3直接调用People1的逻辑，这样也可以在People1的speak()方法前后执行想要的逻辑。

 

以上的两种方式都不太好，第一种方式是大家最容易想到的方式，但是非常不灵活，一般不推荐使用。第二种方式灵活性要高于第一种，可以理解为静态代理，但是也还不够灵活，比如说现在我想在让这个人也实现走路的接口，算出他走路的时间，那么我们是不是还得写一个People1WalkProxy··也就是静态代理是依赖于接口的，有多少个接口就需要多少个代理，显然也不是非常灵活。

 

好，下面开始介绍动态代理，动态代理就是可以不管有多少个接口，我只要一个代理类就可以了，要使用动态代理，我们需要实现一个接口，叫做InvocationHandler,实现方法invoke。实现这个接口的目的就是让jdk知道我想在某个方法(这里是speak()方法)前后加入什么逻辑，可以这么写

 

package jdk.proxy.test;

 

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

/**

 * 代理逻辑

 * @authordemo

 *

 */

public class PeopleTimeHandler implements InvocationHandler {

 

    private Objecttarget;//需要代理的目标

   

    public PeopleTimeHandler() {//默认构造方法

       super();

    }

   

    public PeopleTimeHandler(Object target) {//有参数的构造方法

       super();

       this.target = target;

    }

 

    public Object getTarget() {//

       returntarget;

    }

 

    public void setTarget(Object target) {//target的getter andsetter

       this.target = target;

    }

 

    @Override

    public Objectinvoke(Object proxy, Method method, Object[] args)//InvocationHandler的方法，定义我们需要在代理对象的方法前执行什么逻辑

           throws Throwable {

       System.out.println(“proxy name is:”proxy.getClass().getName());

       long start=System.currentTimeMillis();

       System.out.println("----------startto speak ---------");//得到起始时间

      

       Object obj=method.invoke(target, args);//这是利用反射机制，调用target对象的method方法，args是该方法需要传入的参数，obj是这个方法的返回值

      

       System.out.println("----------endto speak ---------");//得到结束时间

       long end=System.currentTimeMillis();

       System.out.println(" thispeople speak cost time "+(end-start)+"ms");

       return obj;

    }

 

}

 

 

现在被代理的对象有了，代理的逻辑也有了，我们只需要一个代理对象，用一个Client类测试一下：

package jdk.proxy.test;

 

import java.lang.reflect.Proxy;

 

public class TestClient {

 

    public static void main(String[] args) {

       PeopleTimeHandler handler =new PeopleTimeHandler(new People());//代理类

       //得到代理对象，第一个参数是指定classloader，第二个参数指定被代理的类的接口，是一个Class数组，第三个参数是代理类

       Speak sp = (Speak) Proxy.newProxyInstance(

              Speak.class.getClassLoader(),new Class[] { Speak.class },handler);

       String str = sp.speak(" Wupeng ");

       System.out.println("***************************" + str);

    }

}

 

组后打印出：

proxy name is :$Proxy0

----------start to speak---------

Hello  Wupeng

----------end to speak---------

 this people speak cost time 3953ms

***************************returnstr is: Hello  Wupeng

 

 

总结：使用动态代理很简单，但是我们需要弄清楚它的实现方式。

我们在调用java.lang.reflect.Proxy.newProxyInstance(ClassLoader,Interface,Handler)方法的时候，其实是java.lang.reflect.proxy为我们动态的生成了一个类，并且把这个类加载到内存，这个类叫做$Proxy0，最后把这个类的对象返回

下面谈谈$Proxy0这个类，它动态的实现了我们传入的接口interface，所以我们就可以把它强转为传入的任意接口interface，并且它的内部也有一个Handler接口的对象，而在实现这个接口的方法时，$Proxy0直接调用的handler的invoke(Objectproxy,method,args)方法，将自己作为proxy传入，即 handler.invoke(this,method,args)，这样我们在handler里面加入逻辑就会被执行。

      

文笔有限，只能写到这里，如果大家还是不理解，可以参考下尚学堂的动态代理视频，马士兵老师从头到尾的模拟了jdk的动态代理