Java笔记之——动态代理

动态代理是JDK 1.3以上的版本里的一个特性,实现了代理模式。通过JDK的动态代理特性,可以为任意Java对象创建代理对象,对于具体使用来说,这个特性是通过Java Reflection API来完成的,可以在java.lang.reflect中找到Proxy对象。

在Spring AOP实现中,核心技术就是动态代理,学习动态代理,也能让我们更好地理解面向切面思想。本文先介绍代理模式,然后再介绍静态代理,再由静态代理的缺点、问题引出动态代理。

一、代理模式

1.1 代理模式介绍

代理模式就是给某一个对象创建一个代理对象,由这个代理对象控制对原对象的引用,而创建这个代理对象后可以在调用原对象时增加一些额外的操作。代理模式结构图如下:
代理模式结构图.png

  • Subject:抽象主题,它是代理对象的真实对象要实现的接口。
  • RealSubject:被代理的类,即目标对象。
  • ProxySubject:代理类,除了实现抽象主题定义的接口外,还必须持有它所代理对象的引用。

在ProxySubject的调用过程中,如果客户调用ProxySubject的request方法,会在调用目标对象的request方法的前后调用一系列的处理,而这一系列的处理相对于目标对象来说是透明的,目标对象对这些处理可以毫不知情。

1.2 代理的作用

为什么要用代理?举个栗子,以明星为例,明星要做的事情就是唱歌、跳舞。而对于去哪唱歌、跳舞等等琐碎的事情,这种事显然明星不会自己安排,交给他的经纪人(即代理对象)来完成。这样把两者管理的内容抽离开,条理很清晰,明星就做明星该做的事,经纪人就做经纪人该做的事。

之所以要用到代理,是因为我们需要扩展目标对象的一些功能,但是这些功能与目标对象要完成的内容又关系不大,或者我们不想改动目标对象实现的功能,而只愿在其事件发生前后加入相应的扩展内容,比如,在某一事件发生的前后,用日志记录下来。

二、静态代理

以一个简单例子进行介绍:

public interface Greeting {
    void sayHello(String name);
}

这是一个Greeting接口,即Subject。以下是实现类:

public class GreetingImpl implements Greeting {
    @Override
    public void sayHello(String name) {
        System.out.println("Hello! "+name);
    }
}

以下是代理类:

public class GreetingProxy implements Greeting {

    private GreetingImpl greetingImpl;

    public GreetingProxy(GreetingImpl greetingImpl) {
        this.greetingImpl = greetingImpl;
    }
    @Override
    public void sayHello(String name) {
        before();
        greetingImpl.sayHello(name);
        after();
    }

    private void before() {
        System.out.println("Before");
    }

    private void after() {
        System.out.println("After");
    }
}

测试类及测试结果:

public class Client {
    public static void main(String[] args){
        Greeting greetingProxy = new GreetingProxy(new GreetingImpl());
        greetingProxy.sayHello("Tom");
    }
}

\\测试结果
Before
Hello! Tom
After

上面的HelloProxy就是一个静态代理的例子。它的特点:

  • 一个静态代理只能服务于一种类型的目标对象;
  • 若要服务于多类型的目标对象,则需要为每种目标对象都实现一个静态代理对象。

这样,很容易就能发现静态代理的问题,如果我们要代理的目标对象较多的情况下,使用静态代理将会造成代理对象多、代码量大的问题。

三、JDK动态代理

为了解决静态代理类存在的问题,我们采用JDK动态代理进行修改。以下是动态代理类:

public class DynamicProxy implements InvocationHandler {
    private Object target;
    public DynamicProxy(Object target) {
        this.target = target;
    }

    @SuppressWarnings("unchecked")
    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 {
        before();
        Object result = method.invoke(target,args);
        after();
        return result;
    }

    private void before() {
        System.out.println("Before");
    }

    private void after() {
        System.out.println("After");
    }
}

通过定义一个代理类,实现InvocationHandler接口,该接口位于JDK反射包中,需要实现invoke方法,在该方法中,直接通过反射去invoke method,在调用前后分别处理before和after,最后将result返回。同时,我们在类中添加了getProxy方法,封装了获取代理对象的过程,主要是通过Proxy.newProxyInstance进行获取。这样就完成了动态代理类的定义,在该类中,我们没有实现任何一个目标对象的抽象接口,也就是说,我们可以通过该类代理多种目标对象类。测试类及结果如下:

public static void main(String[] args){
        DynamicProxy dynamicProxy = new DynamicProxy(new GreetingImpl());
        Greeting greetingProxy = dynamicProxy.getProxy();
        greetingProxy.sayHello("Tom");
}
\\测试结果
Before
Hello! Tom
After

四、CGlib动态代理

相比较静态代理,上面的动态代理类算是方便了很多,当接口变了,代理类不用动。然而,该类却也有它搞不定的地方,比如要代理一个没有任何接口的类,它就没办法实现了。

而CGLib这个类库恰恰能够解决这个问题,它是一个在运行期间动态生成字节码的工具,也就是动态生成代理类了。
以下是利用CGLib写的动态代理类:

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CGLibProxy implements MethodInterceptor {

    private static CGLibProxy instance = new CGLibProxy();

    private CGLibProxy() {

    }

    public static CGLibProxy getInstance() {
        return instance;
    }

    @SuppressWarnings("unchecked")
    public <T> T getProxy(Class<T> cls) {
        return (T) Enhancer.create(cls,this);
    }

    @Override
    public Object intercept(Object target, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        before();
        Object result = methodProxy.invokeSuper(target,args);
        after();
        return result;
    }

    private void before() {
        System.out.println("Before");
    }

    private void after() {
        System.out.println("After");
    }
}

通过实现CGLib给我们提供的MethodInterceptor实现类,并实现intercept方法,完成代理类的编写。测试类及测试结果如下:

public class Client {
    public static void main(String[] args){
        Greeting greeting = CGLibProxy.getInstance().getProxy(GreetingImpl.class);
        greeting.sayHello("Tom");
    }
}
\\测试结果,需要注意,这里还需要导入asm包到项目中,不然会报错
Before
Hello! Tom
After

与动态代理不同的是,这里不需要任何的接口信息,对谁都可以生成动态代理对象。

五、总结

代理模式的应用,能够帮助我们对某一类的功能进行扩展。虽然静态代理类能够帮我们实现,但由于其只能对一种类型的目标对象服务,所以在目标对象较多的情况下,我们需要用到动态代理。动态代理分JDK动态代理和CGLib动态代理,JDK动态代理需要代理的对象实现一个接口,而CGLib不需要。CGLib创建代理的速度比较慢,但创建代理后运行的速度却非常快,而JDK动态代理正好相反。

顺便提一下: JDK动态代理类的实现代码是,为传入接口中的每一个方法,以及从java.lang.Object中继承来的equals()、hashCode()、toString()方法都生成了对应的实现,并且统一调用了InvocationHandler对象的invoke()方法来实现这些方法的内容,各个方法的区别不过是传入的参数和Method对象有所不同而已,所以无论调用动态代理的哪一个方法,实际上都是在执行InvocationHandler.invoke()中的代理逻辑。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值