JDK动态代理浅析

2019-01-05 13:10:13来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

Java中的动态代理设计模式是非常经典且非常重要的设计模式之一,在感叹设计者的天才设计至于,我们想去探究一下这个设计模式是如何来实现的;

著名的spring框架的AOP的原理就是Java的动态代理机制;

在Spring中动态代理是实现有两种:JDK动态代理和Cglib动态代理,本篇分析的是JDK动态代理的实现;

查看下篇 [ Cglib动态代理浅析 ]

在探究动态代理之前,先看一下静态代理,这可以帮助我们更好的理解动态代理;

以公司老板和员工为例,现在Boss有一些项目要完成(定义接口)

public interface Boss {
    public void doSomethinig();
    public void finishTasks(String name);
}

这些工作肯定是需要雇员工去做的(去实现老板定义的接口)

public class Employee implements Boss {
    @Override
    public void doSomethinig() {
        System.out.println("员工工作中 ...");
    }
    @Override
    public void finishTasks(String name) {
        System.out.println("员工正在完成项目 " + name + " ...");
    }
}

我们先使用静态代理,这时候我们雇一个项目经理负责代理员工完成工作,可能有点不恰当哈,先这么理解吧;(同样需要实现老板的接口,代理员工执行任务)

public class Manager implements Boss {
    private Employee employee = new Employee();
    @Override
    public void doSomethinig() {
        // 员工完成工作之前
        System.out.println(">>>>>员工完成工作之前");
        // 员工正在完成工作
        employee.doSomethinig();
        // 员工完成工作之后
        System.out.println("员工完成工作之后>>>>>");
    }
    @Override
    public void finishTasks(String name) {
        // 员工完成工作之前
        System.out.println(">>>>>员工完成工作之前");
        // 员工正在完成工作
        employee.finishTasks(name);
        // 员工完成工作之后
        System.out.println("员工完成工作之后>>>>>");
    }
}

 

写个测试类

public class TestProxy {
    public static void main(String[] args) {
        Manager manager = new Manager();
        manager.doSomethinig();
        manager.finishTasks("Java静态代理");
    }
}

 

刚开始,我也一直很疑惑,员工都已经实现Boss的所有方法了,而且在测试类中也直接new出来员工对象了,直接员工.方法执行不就完了,为什么还要多此一举使用一个代理类来完成执行呢?先看测试执行结果:

>>>>>员工完成工作之前
员工工作中 ...
员工完成工作之后>>>>>

>>>>>员工完成工作之前
员工正在完成项目 Java静态代理 ...
员工完成工作之后>>>>>

 

可以看出在项目经理代理类中,我们其实是可以在员工方法执行之前和执行之后做一些操作的,具体可以做什么和能做什么,你们发挥自己想象力;

代理模式应用在实际项目中,是能够帮我们完成很多事情的,比如个大框架中最常见的日志记录,数据库事务控制,权限验证等等,就不一一列举了(当然它们使用的肯定不是静态代理,而是接下来要说的动态代理了);

但是静态代理又一个非常大的弊端,就是每个接口都需要一个代理类去实现和执行,随着业务的数量越来越复杂的时候,代理类的代码量也是十分惊人的,这对于项目来说是很难去管理维护的;而动态代理的出现,正是用来解决这个问题的;

在Java的动态代理机制中,有两个至关重要的对象:

InvocationHandler 接口
Proxy 类

 

我们看看JDK API是怎么描述InvocationHandler 的(摘自JDK API 1.6.0中文版)

public interface InvocationHandler
InvocationHandler 是代理实例的调用处理程序实现的接口。 
每个代理实例都具有一个关联的调用处理程序。
对代理实例调用方法时,将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。
invoke方法描述(摘自JDK API 1.6.0中文版)

invoke Object invoke(Object proxy,Method method,Object[] args)throws Throwable
    在代理实例上处理方法调用并返回结果。
    在与方法关联的代理实例上调用方法时,将在调用处理程序上调用此方法。

参数:
    proxy 
        - 在其上调用方法的代理实例,指代我们所代理的那个真实对象
    method 
        - 对应于在代理实例上调用的接口方法的 Method 实例。
        - Method 对象的声明类将是在其中声明方法的接口,该接口可以是代理类赖以继承方法的代理接口的超接口。
        - 指代的是我们所要调用真实对象的某个方法的Method对象
    args 
        - 包含传入代理实例上方法调用的参数值的对象数组,如果接口方法不使用参数,则为 null- 基本类型的参数被包装在适当基本包装器类(如 java.lang.Integer 或 java.lang.Boolean)的实例中。 
        - 指代的是调用真实对象某个方法时接受的参数
返回:
    从代理实例的方法调用返回的值。
    如果接口方法的声明返回类型是基本类型,则此方法返回的值一定是相应基本包装对象类的实例;
    否则,它一定是可分配到声明返回类型的类型。
    如果此方法返回的值为 null 并且接口方法的返回类型是基本类型,则代理实例上的方法调用将抛出 NullPointerException。
    否则,如果此方法返回的值与上述接口方法的声明返回类型不兼容,则代理实例上的方法调用将抛出 ClassCastException。

 

我们再来看看Proxy类(摘自JDK API 1.6.0中文版)

public class Proxy extends Object implements Serializable 
Proxy 提供用于创建动态代理类和实例的静态方法,它还是由这些方法创建的所有动态代理类的超类。
Proxy.newProxyInstance方法(摘自JDK API 1.6.0中文版)

public static Object newProxyInstance(
    ClassLoader loader,
    Class<?>[] interfaces,
    InvocationHandler h)
    throws IllegalArgumentException
    返回一个指定接口的代理类实例,该接口可以将方法调用指派到指定的调用处理程序。
        - 此方法相当于: 
            Proxy.getProxyClass(loader, interfaces).
            getConstructor(new Class[] { InvocationHandler.class }).
            newInstance(new Object[] { handler });
        - Proxy.newProxyInstance 抛出 IllegalArgumentException,原因与 Proxy.getProxyClass 相同。

参数:
    loader
        - 定义代理类的类加载器
        - ClassLoader对象,定义了由哪个ClassLoader对象来对生成的代理对象进行加载
    interfaces
        - 代理类要实现的接口列表
        - Interface对象的数组,表示的是我将要给我需要代理的对象提供一组什么接口
        - 如果我提供了一组接口给它,那么这个代理对象就宣称实现了该接口(多态),这样我就能调用这组接口中的方法了
    h 
        - 指派方法调用的调用处理程序
        - InvocationHandler对象,表示的是当我这个动态代理对象在调用方法的时候,会关联到哪一个InvocationHandler对象上
返回:
    一个带有代理类的指定调用处理程序的代理实例,它由指定的类加载器定义,并实现指定的接口

 

现在,我们使用动态代理来决绝刚才的问题,Boss和员工还是原来的

public interface Boss {
    public void doSomethinig();
    public void finishTasks(String name);
}

 

员工

public class Employee implements Boss {
    @Override
    public void doSomethinig() {
        System.out.println("员工工作中 ...");
    }
    @Override
    public void finishTasks(String name) {
        System.out.println("员工正在完成项目 " + name + " ...");
    }
}

 

这时候我们使用动态代理,雇一个领导,来代理所有的事情;

public class Leader implements InvocationHandler {
    private Object target;
    // 返回一个代理对象,并绑定被代理对象
    public Object getProxyInstance(Object object) {
        this.target = object;
        // Proxy的newProxyInstance方法需要三个参数
        return Proxy.newProxyInstance(
            // 1.一个类加载器,通常可以从已经被加载的对象中获取类加载器
            object.getClass().getClassLoader(),
            // 2.希望代理实现的接口列表
            object.getClass().getInterfaces(),
            // 3.一个InvocationHandler接口的实现
            this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 这里我们简单输出一下invoke的第二第三个参数
        System.out.println("method : " + method);
        System.out.println("args : " + args);
        if (args != null) {
        System.out.print("arg : ");
        for (Object arg : args) {
            System.out.print(arg + " ");
            }
            System.out.println();
        }
        // 员工完成工作之前
        System.out.println(">>>>>员工完成工作之前");
        // 员工正在完成工作
        Object invoke = method.invoke(target, args);
        // 员工完成工作之后
        System.out.println("员工完成工作之后>>>>>");
        return invoke;
    }
}

 

测试类:

public class LeaderTest {
    public static void main(String[] args) {
        Employee employee = new Employee();
        Leader leader = new Leader();
        Boss boss = (Boss) leader.getProxyInstance(employee);
        boss.doSomethinig();
        boss.finishTasks("Java动态代理");
    }
}

 

控制台输出:

Method : public abstract void com.guitu18.Boss.doSomethinig()
args : null
>>>>>员工完成工作之前
员工工作中 ...
员工完成工作之后>>>>>

Method : public abstract void com.guitu18.Boss.finishTasks(java.lang.String)
args : [Ljava.lang.Object;@1c7c054
arg : Java动态代理 
>>>>>员工完成工作之前
员工正在完成项目 Java动态代理 ...
员工完成工作之后>>>>>

 

我们在方法中打印invoke方法的第二个参数Method method,从控制台看出,我们在调用方法的时候,实际上使用的是代理对象来调用真实对象的方法的:

Method : public abstract void com.guitu18.Boss.doSomethinig()
Method : public abstract void com.guitu18.Boss.finishTasks(java.lang.String)

 

而打印invoke方法的第三个参数Object[] args时我们发现,该数组其实就是真实方法接收的参数,如果没有则为null;

args : null

args : [Ljava.lang.Object;@1c7c054
arg : Java动态代理

 

现在,我们可以在method.invoke方法的前后都加上自己的一些操作;

在各大框架中,使用动态代理的比比皆是,比如如著名的Spring框架的AOP原理,比如Shiro的权限验证,拦截器等等;

从以上代码中,我们也可以看出,使用动态代理之后,代理类的代码量已经被固定下来了,不会随着业务的复杂和庞大而变得越来越多;

其实在这里,我们已经可以把代码写成代理工厂模式了,简化一些操作:

public class ProxyFactory {
    public static Object getProxyInstance(final Object target) {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // 方法执行前
                        System.out.println("开始事务...");
                        // 执行方法
                        Object invoke = method.invoke(target, args);
                        // 方法执行后
                        System.out.println("提交/回滚事务...");
                        return invoke;
                    }
                });
    }
}

 

在ProxyFactory里,提供了一个静态方法,我么仅需要传递进来一个代理类的具体实现,就能够获得一个代理对象,在这个方法中,Proxy.newProxyInstance需要的第三个参数,是以匿名内部类的方式去提供和定义的,更加简洁和灵活;

编写测试类:

public class ProxyFactoryTest {
    public static void main(String[] args) {
        Boss boss = (Boss) ProxyFactory.getProxyInstance(new Employee());
        boss.doSomethinig();
        boss.finishTasks("Java动态代理");
    }
}

 

控制台输出:

开始事务...
员工工作中 ...
提交/回滚事务...

开始事务...
员工正在完成项目 Java动态代理 ...
提交/回滚事务...

 

在动态代理技术里,由于不管用户调用代理对象的什么方法,都是调用开发人员编写的处理器的invoke方法(这相当于invoke方法拦截到了代理对象的方法调用)。

并且,开发人员通过invoke方法的参数,还可以在拦截的同时,知道用户调用的是什么方法,因此利用这两个特性,就可以实现一些特殊需求;

例如:

数据库事务的操作,在方法执行前开启事务,执行完毕提交事务,如果方法执行出错,回滚事务; 拦截用户的访问请求,以检查用户是否有访问权限,有权限继续执行,没权限不执行做其他操作; 增强,动态为某个对象添加额外的功能;

尾巴:

  1. 动态代理是十分强大的设计模式,代理类的代码量被固定下来,不会因为业务的逐渐庞大而庞大;
  2. 可以实现AOP编程,实际上静态代理也可以实现,总的来说,AOP可以算作是代理模式的一个典型应用;
  3. 解耦,通过参数就可以判断真实类,不需要事先实例化,更加灵活多变;

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:javaSE练习2——流程控制_2.1

下一篇:Java基础之java的四大特性