JDK动态代理原理:只能代理接口,不能代理类问题

时间:2022-11-22 一位远方的诗人人气:0

动态代理是许多框架底层实现的基础，比如Spirng的AOP等，其实弄清楚了动态代理的实现原理，它就没那么神奇了，下面就来通过案例和分析JDK底层源码来揭秘她的神秘面纱，让她呈现在我们面前。

一、代理模式定义

存在一个代理对象，并且这个代理对象持有真实对象的引用，以实现对真实对象的访问控制。

1、举个例子，现在公司一般都有VPN，使我们在家也能访问到公司的内网（比如连接公司的数据库等），实现居家办公。这里VPN相当于一个代理，而公司内网相当于被代理对象，也就是真实对象。

我们不能直接访问公司内网（真实对象），但是我们通过VPN（代理对象），输入身份信息，确认无误后就可以访问到公司内网。

这就是代理模式的作用----控制对象的访问。

代理模式的分类

1、静态代理

该代理对象持有被代理对象的引用，客户端通过调用代理对象的方法间接实现调用真实对象的方法。

代理对象可以在调用真实对象的方法前面加入一些操作：比如身份验证，如果身份验证没有通过，则不能访问真实对象的方法，否则可以调用真实对象的方法；也可以在调用真实对象方法后，加入一些操作，比如记录访问日志。

真实对象接口，提供两个服务方法

/**
 *
 * People 真实对象的接口包含两个方法
 *
 */
public interface People {
    voidsayHello(String msg);
 
    voidsayBye(String msg);
}
 
真实对象接口的具体实现
 
/**
 *
 *Student
 * 真实对象接口的实现
 */
public class Student implements People {
 
    @Override
    public void sayHello(String msg) {
      System.out.println("Hello "+msg);
    }
 
    @Override
    public void sayBye(String msg) {
        System.out.println("ByeBye "+msg);
    } 
}

代理对象：

/**
 *
 *StaticProxy
 * 代理对象，控制对真实对象的访问控制
 */
public class StaticProxy implements People {
    //真实对象，客户端不能直接访问
    private Peoplepeople;
   
    publicStaticProxy(){
        this.people=new Student();
    }
 
    @Override
    public void sayHello(String msg) {
        booleanfriendFlag=true;
        if(friendFlag){
            people.sayHello(msg);
        }
        System.out.println("记录访问日志");
      
    }
 
    @Override
    public void sayBye(String msg) {
        booleanfriendFlag=true;
        if(friendFlag){
            people.sayBye(msg);
        }
        System.out.println("记录访问日志");
    }
}

客户端调用及结果：

public class Test_Demo {
    public static void main(String[] args) {
        //创建静态代理对象
        StaticProxy proxy = new StaticProxy();
        //调用静态代理对象方法
        proxy.sayHello("nihao");
        proxy.sayBye("zaijian");       
    }
}

输出结果为：
nihao
记录访问日志
zaijian
记录访问日志

上面就是静态代理的一个实现，通过静态代理，实现了访问控制，但是在每个真实对象方法之前都加入了访问控制代码来验证权限。

如果有很多个方法，则要在每个方法调用前都加入验证权限的代码，这样非常的不灵活且有大量的重复代码，即使把验证权限抽象出来做过方法或者类，但是还是得在每个方法前加一段调用权限验证的代码，比如，一个客户端只用其中的一个方法，但是代理中两个方法都要加入权限控制，要满足其他客户端的调用需求，上面接口中只有两个方法还好，但是如果有上百个方法那岂不是很臃肿。

那么有什么办法解决了，那就是动态代理。

2、动态代理

动态的生成代理类，而不用像静态代理一样，在编译期间进行定义类。动态代理更加灵活，不用显示的在所有方法前面或者后面加入权限验证、记录日志等操作。

动态代理的实现和静态代理一样，不同的是代理类的创建方式不同：

（1）静态代理是直接新增一个代理类；
（2）动态代理是通过JDK的Proxy和一个调用处理器InvocationHandler来实现的，通过Proxy来生成代理类实例，而这个代理实例通过调用处理器InvocationHandler接收不同的参数灵活调用真实对象的方法。

因此：我们需要做的是创建调用处理器，该调用处理器必须实现JDK的InvocationHandler

1、动态代理的实现如下:

（1）被代理接口：

public interface Car {
    public void run();
    public void laba(String str);
}

（2）被代理接口实现类：

public class BenChi implements Car {
    @Override
    public void run() {
        System.out.println("奔驰启动快");
    }
    @Override
    public void laba(String str) {
        System.out.println("过路口要减速鸣笛"+str);
    }
}

（3）代理类：

public class P_Class implements InvocationHandler {
    private Car car;
    public P_Class(Car car){
        this.car = car;
    }
    public Car createProxy(){
        Car car_proxy = (Car) Proxy.newProxyInstance(car.getClass().getClassLoader(), 
                car.getClass().getInterfaces(), this);
        return car_proxy;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if("run".equals(method.getName())){
            System.out.println("开车不喝酒，喝酒不开车");
            method.invoke(car, args);
            System.out.println("安全伴我行");
            System.out.println(proxy.getClass().getName());            
        }
        return null;
    }
}

（4）测试类：

public class Test_Demo {
    public static void main(String[] args) {
        Car benchi = new BenChi();
        Car benchi_proxy = new P_Class(benchi).createProxy();
        benchi_proxy.run();
        benchi.laba("dididididi");    
    }
}

输出结果：

开车不喝酒，喝酒不开车
奔驰启动快
安全伴我行
com.sun.proxy.$Proxy0
过路口要减速鸣笛dididididi

2、Proxy动态生成一个代理实例源码分析：

/**
     * 
     * 通过Proxy动态生成一个代理实例
     *return:Object
     */
    public Object getProxy(){
        /*
         * Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

注意：loader类加载器用于加载代理类的字节码；interfaces为代理类需要实现的接口；h为代理对象实际调用的方法即invoke方法。
         * 第一个参数的作用就是 获取当前类的类加载器,作用是用来生成类的
         * 第二个参数是获取真实对象的所有接口    获取所有接口的目的是用来生成代理的,因为代理要实现所有的接口
         * 第三个参数是 调用处理器  这里传入调用处理器，是因为生成代理实例需要 调用处理器    为什么需要调用处理器，因为生成的代理不能直接调用真实对象的方法,而是通过调用处理器来调用真实对象的方法，具体就是通过上面定义的P_Class重写父类InvocationHandler的invoke方法
         */
       return  Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this );
    }
}

这样则实现了动态代理，客户端调用代理不同的方法，都实现了对真实对象的间接调用，并且经过了代理对象的权限验证。

但是我们只在一个地方加入了权限验证的代码，并没有在每个方法前面都加入，这样更加灵活和优雅。

但是我们重头到尾都没有看到像静态代理类那样的一个动态代理类，那么JDK的Proxy是怎么得到动态代理类的实例的呢？真的不建立一个类，就能获取该类的实例吗？

二、JDK动态原理详解

这是不可能的，Java中必须要有类，才会有该类的实例。其实不是没有代理类，而是JDK在运行期间帮我们生成了一个代理类的字节码，通过类加载器加载这个字节码，然后执行引擎进行一系列处理后生成代理类，再进行实例化。

下面就来看JDK是怎么生成代理类并且实例化的：

核心代码就是：

Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this );

看看JDK的底层实现

贴出代码，去掉了异常和判断

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
      
     
        Class<?> cl = getProxyClass(loader, interfaces);
       
// Class[] constructorParams =
         { InvocationHandler.class };
 
            Constructor cons = cl.getConstructor(constructorParams);
            return cons.newInstance(new Object[] { h });
        }

1、生成代理类

通过源码可以知道，生成代理类是通过如下方法实现的：

Class<?> cl =getProxyClass(loader, interfaces);

2、生成代理类字节码

再追踪一下，这个方法里面内容很多，但是最关键的就是下面这个方法：

   byte[] proxyClassFile = ProxyGenerator.generateProxyClass(

                    proxyName, interfaces);

通过这个方法就生成了代理类的字节码，只不过调用完就不存在了。所以我们看不到它的源码。

注意：生成的动态代理类其实跟静态代理类还是有区别的，静态代理是我们直接控制真实对象的方法调用，而动态代理是通过调用处理器的invoke方法来调用真实对象的方法，而这个invoke方法就是我们自己覆写的方法。

可以看出是通过反射实现的，通过传入的不同的方法对象和参数来调用真实对象的不同方法。

刚开始我和网上很多人一样都有一个疑问，对于invoke方法发参数，Method和args在我们覆写的invoke方法中都有用到，但是对于第一个参数，代理对象proxy没有用，所以不知道这个东西调用处理器传给我们有什么用。

第一个参数proxy的作用：

（1）可以通过反射获取代理对象的信息，同时可以反复调用代理对象。

注意：this指向的是当前类，而不是代理类即$Proxy0。

proxy解释说明参考文档连接：http://stackoverflow.com/questions/22930195/understanding-proxy-arguments-of-the-invoke-method-of-java-lang-reflect-invoca

以上为个人经验，希望能给大家一个参考，也希望大家多多支持。

加载全部内容