zoukankan      html  css  js  c++  java
  • spring aop的前奏,动态代理 (5)

    一、先看一个计算器的抽取和实现

    • 图中,有两个需求
      • 需求1-日志:在程序执行期间追踪正在发生的活动
      • 需求2-验证:希望计算器只能处理正数的运算
    • 其中实现的代码片段

    从代码片段中可以看出,代码混乱,代码分散,如果日志需求变更,必须修改所有方法。

    二、使用动态代理解决以上问题。

    1 设计原理

    • 代理设计模式的原理: 使用一个代理将对象包装起来, 然后用该代理对象取代原始对象. 任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时将方法调用转到原始对象上.

    2 代码实现

    2.1 接口代码

    public interface ArithmeticCalculator {
        int add(int i, int j);
        int sub(int i, int j);
        
        int mul(int i, int j);
        int div(int i, int j);
    }  
    

    2.2 实现接口的代码

    public class ArithmeticCalculatorImpl implements ArithmeticCalculator {
        @Override
        public int add(int i, int j) {
            int result = i + j;
            return result;
        }
        @Override
        public int sub(int i, int j) {
            int result = i - j;
            return result;
        }
        @Override
        public int mul(int i, int j) {
            int result = i * j;
            return result;
        }
        @Override
        public int div(int i, int j) {
            int result = i / j;
            return result;
        }
    }  
    

    2.3 测试代码

        public static void main(String[] args) {
            ArithmeticCalculator arithmeticCalculator = new ArithmeticCalculatorImpl();
            
            int result = arithmeticCalculator.add(11, 12);
            System.out.println("result:" + result);
            
            result = arithmeticCalculator.div(21, 3);
            System.out.println("result:" + result);
        }  
    

    打印出
    result:23
    result:7
    这个是原始的代码,接下来,我们加入动态代理

    2.3 创建动态代理类

    public class ArithmeticCalculatorLoggingProxy {
        // 要代理的对象
        private ArithmeticCalculator target;
        public ArithmeticCalculatorLoggingProxy(ArithmeticCalculator target) {
            super();
            this.target = target;
        }
        // 返回代理对象
        public ArithmeticCalculator getLoggingProxy() {
            ArithmeticCalculator proxy = null;
            ClassLoader loader = target.getClass().getClassLoader();
            Class[] interfaces = new Class[] { ArithmeticCalculator.class };
            InvocationHandler h = new InvocationHandler() {
                /**
                 * proxy: 代理对象。 一般不使用该对象 method: 正在被调用的方法 args: 调用方法传入的参数
                 */
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    String methodName = method.getName();
                    // 打印日志
                    System.out.println("[before] The method " + methodName + " begins with " + Arrays.asList(args));
                    // 调用目标方法
                    Object result = null;
                    try {
                        // 前置通知
                        result = method.invoke(target, args);
                        // 返回通知, 可以访问到方法的返回值
                    } catch (NullPointerException e) {
                        e.printStackTrace();
                        // 异常通知, 可以访问到方法出现的异常
                    }
                    // 后置通知. 因为方法可以能会出异常, 所以访问不到方法的返回值
                    // 打印日志
                    System.out.println("[after] The method ends with " + result);
                    return result;
                }
            };
            /**
             * loader: 代理对象使用的类加载器。 
             * interfaces: 指定代理对象的类型. 即代理代理对象中可以有哪些方法. 
             * h: 当具体调用代理对象的方法时, 应该如何进行响应, 实际上就是调用 InvocationHandler 的 invoke 方法
             */
            proxy = (ArithmeticCalculator) Proxy.newProxyInstance(loader, interfaces, h);
            return proxy;
        }
    }
    

    2.3.1 测试动态代理

        public static void main(String[] args) {
            ArithmeticCalculator arithmeticCalculator = new ArithmeticCalculatorImpl();
            
            arithmeticCalculator = 
                    new ArithmeticCalculatorLoggingProxy(arithmeticCalculator).getLoggingProxy();
            
            int result = arithmeticCalculator.add(11, 12);
            System.out.println("result:" + result);
            
            result = arithmeticCalculator.div(21, 3);
            System.out.println("result:" + result);
        }  
    

    打印出:
    [before] The method add begins with [11, 12]
    [after] The method ends with 23
    result:23
    [before] The method div begins with [21, 3]
    [after] The method ends with 7
    result:7

    2.4 动态代理类代码说明

    代理类中, Proxy.newProxyInstance(loader, interfaces, h); 这个类需要传递三个参数

    • loader: 代理对象使用的类加载器。使用目标方法的类加载器即可
    • interfaces: 指定代理对象的类型. 即代理代理对象中可以有哪些方法.
    • h: 当具体调用代理对象的方法时, 应该如何进行响应, 实际上就是调用 InvocationHandler 的 invoke 方法

    传递的h中InvocationHandler 的参数介绍:

    • proxy: 代理对象。 一般不使用该对象
    • method: 正在被调用的方法,调用method.invoke(目标对象, args);
    • args: 调用方法传入的参数
      public Object invoke(Object proxy, Method method, Object[] args)

    2.5 前置通知,后置通知,返回通知,异常通知

    在invoke方法中,可以看出,在方法前后分别可以打印日志,发生异常时,也可以在catch中对异常的处理,这几个不同的位置,分别为 : 前置通知,后置通知,返回通知,异常通知

    前置通知 : 调用目标方法之前执行的代码
    后置通知 : 调用目标方法之后执行的代码
    返回通知 : 可以得到目标方法返回值,从而进一步处理,在method.invoke(目标对象, args);之后
    异常通知 : 调用目标方法出异常时,catch中执行的代码,此时,返回通知无法别执行

    整个系列项目代码: http://git.oschina.net/nmc5/spring

  • 相关阅读:
    linux下Github 同步与下载
    Add 'GB18030' to gedit in Linux
    JGibbLDA的输出文件
    Gibbs LDA java实现
    Polylingual LDA
    Hash_Map 原理
    Map sorted by Value
    使用loadrunnersocket压力测试
    一次压力测试
    linux不知道文件在哪,想查找文件内的字符串
  • 原文地址:https://www.cnblogs.com/linhp/p/5881788.html
Copyright © 2011-2022 走看看