Java动态代理

最新推荐文章于 2024-11-01 00:45:00 发布

序猿_

最新推荐文章于 2024-11-01 00:45:00 发布

阅读量485

点赞数

分类专栏： JAVA

JAVA 专栏收录该内容

26 篇文章

订阅专栏

本文详细介绍了如何使用Java动态代理来实现在不修改原有代码的情况下，为方法调用添加额外的功能。通过具体实例展示了动态代理的实现步骤及原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

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

所以我们先写一个接口：

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的动态代理