【Java入门提高篇】Day11 Java代理——JDK动态代理

  今天来看看Java的另一种代理方式——JDK动态代理

  我们之前所介绍的代理方式叫静态代理,也就是静态的生成代理对象,而动态代理则是在运行时创建代理对象。动态代理有更强大的拦截请求功能,因为可以获得类的运行时信息,可以根据运行时信息来获得更为强大的执(骚)行(操)力(作)。

  我们还是以上一个例子为例,这里的IStars接口和Stars类都不需要修改,只需要修改代理类。

  创建JDK动态代理需要先实现InvocationHandler接口,并重写其中的invoke方法,具体步骤如下:

  1. 创建一个类实现InvocationHandler接口。

  2. 给Proxy类提供委托类的ClassLoader和Interfaces来创建动态代理类。

  3. 利用反射机制得到动态代理类的构造函数。

  4. 利用动态代理类的构造函数创建动态代理类对象。

  我们用动态代理来改造一下之前的类:

  接口和委托类不需要修改:

public interface IStars {
    void sing();
    void dance();
}
public class Stars implements IStars{
    private String name;

    public Stars(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void sing(){
        System.out.println(getName() + " 唱了一首歌.");
    }

    public void dance(){
        System.out.println(getName() + " 跳了一支舞.");
    }
}

  这是使用动态代理后的代理类:

public class StarsNewProxy implements InvocationHandler {

    //代理类持有委托类的对象引用
    private Object object;

    //保存sing和dance的次数
    private int num;

    public StarsNewProxy(Object object){
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (!runBefore(method)){
            return null;
        };
        //利用反射机制将请求分派给委托类处理,Method的invoke返回Object对象作为方法执行结果
        Object result = method.invoke(object,args);
        runAfter(method);
        return result;
    }

    private boolean runBefore(Method method){
        System.out.println("我是代理,拦截到请求");
        if (method.getName().equals("dance")){
            System.out.println("抱歉,明星脚受伤了,不能跳舞表演了。");
            return false;
        }
        return true;
    }

    private void runAfter(Method method){
        System.out.println("我是代理,请求处理完毕");
    }
}

  新建一个工厂类来返回代理实例:

public class StarsNewProxyFactory {
    //构建工厂类,客户类调用此方法获得代理对象
    //对于客户类而言,代理类对象和委托类对象是一样的,不需要知道具体返回的类型
    public static IStars getInstance(String name){
        IStars stars = new Stars(name);
        InvocationHandler handler = new StarsNewProxy(stars);
        IStars proxy = null;
        proxy = (IStars) Proxy.newProxyInstance(
                stars.getClass().getClassLoader(),
                stars.getClass().getInterfaces(),
                handler
        );
        return proxy;
    }
}

  改写一下测试类:

public class Test {
    public static void main(String[] args){
//        testA();
        testB();
    }

    /**
     * 静态代理
     */
    private static void testA(){
        //创建目标对象
        IStars stars = new Stars("Frank");

        //代理对象,把目标传给代理对象,建立关系
        IStars starsProxy = new StarsProxy(stars);
        for (int i = 0;i < 5; i++){
            starsProxy.sing();
        }
    }

    /**
     * JDK动态代理
     */
    private static void testB(){
        IStars proxy = StarsNewProxyFactory.getInstance("Frank");
        proxy.dance();
        proxy.sing();
    }
}

  输出如下:

我是代理,拦截到请求
抱歉,明星脚受伤了,不能跳舞表演了。
我是代理,拦截到请求
Frank 唱了一首歌.
我是代理,请求处理完毕

  使用动态代理时实现了InvocationHandler接口并重写了invoke方法,invoke方法的三个参数:

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

proxy:  被代理的对象
method:  被代理对象的某个方法的Method对象
args:  被代理对象的某个方法接受的参数

  Proxy的newProxyInstance方法详情如下:

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

loader:  一个ClassLoader对象,定义了由哪个ClassLoader对象来对生成的代理对象进行加载

interfaces:  一个Interface对象的数组,表示的是我将要给我需要代理的对象提供一组什么接口,如果我提供了一组接口给它,那么这个代理对象就宣称实现了该接口(多态),这样我就能调用这组接口中的方法了

h:  一个InvocationHandler对象,表示的是当我这个动态代理对象在调用方法的时候,会关联到哪一个InvocationHandler对象上

  可以看到,这里的动态代理跟静态代理一样,在代理类内部保存了一个委托类的实例,实际上都是调用原来的委托实例来进行需要的操作,代理类相当于给委托类加上一个外壳,把委托类置于代理类的内部,从而可以控制客户类对委托类的访问,就像上例中,代理类拦截了客户类对Stars类的dance方法的访问,并且输出了补充信息。

  动态代理跟静态代理最大的不同便是生成代理类的时期不同,静态代理是在编译期,而动态代理则是在运行时根据委托类信息动态生成。

  其次,动态代理实现的是InvocationHandler接口,而静态代理则是直接实现公共接口。当然动态代理也是需要实现相同的接口的,只是将接口信息放在了getInstance内部,相当于代理类跟委托类之间的约定,“这几个方法帮我代理一下吧”。

  最后,动态代理可以获得更多的运行时信息,使用起来也会更加灵活。

  至此,JDK动态代理讲解完毕,欢迎大家继续关注!

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏菩提树下的杨过

ruby学习笔记(11)--symbol与hash参数

symbol是啥就不深入的讨论了,只简单说说symbol的好处 ruby内部对于每个对象,都会有一个数字id用来标识并区分,可以用xxx.object_id来查...

18510
来自专栏白驹过隙

Python - 学习经验分享

31312
来自专栏Python小屋

Python运算符+与+=的那些事

这两个运算符很多语言都提供了,好像也没啥好说的,不就是像下面这样子用嘛。 >>> x = 3 >>> y = x+6 >>> y 9 >>> x += 6 >>...

2715
来自专栏java技术学习之道

一张图搞定Java原型模式

1575
来自专栏SHERlocked93的前端小站

JS 利用高阶函数实现函数缓存(备忘模式)

高阶函数就是那种输入参数里面有一个或者多个函数,输出也是函数的函数,这个在js里面主要是利用闭包实现的,最简单的就是经常看到的在一个函数内部输出另一个函数,比如

4853
来自专栏ml

C与C++在const用法上的区别

       首先,C和C++在大体结构上不同,却在语法上相同。  所以在使用的时候,我们会时常遇到一些莫名其妙的问题,觉得语法上是正确的,但是编译的时候却出现...

3214
来自专栏C/C++基础

C++ new的三种面貌

C++中使用new运算符产生一个存在于Heap(堆)上对象时,实际上调用了operator new()函数和placement new()函数。在使用new创建...

981
来自专栏微信公众号:Java团长

触摸Java常量池

java常量池是一个经久不衰的话题,也是面试官的最爱,题目花样百出,这次好好总结一下。

1811
来自专栏程序员互动联盟

【答疑释惑】C++异常处理是咋回事?

疑惑一 C++的异常处理 一、什么是异常处理 一句话:异常处理就是处理程序中的错误。 二、为什么需要异常处理,以及异常处理的基本思想 C++ 之父Bjarne ...

3255
来自专栏云霄雨霁

Java虚拟机--类加载过程

1858

扫码关注云+社区