• Spring入门第十七课


    AOP编程

    问题:

    代码混乱:

    越来越多的非业务需求(日志和验证等)加入后,原有的业务方法急剧膨胀,每个方法在处理核心逻辑的同事还必须兼顾其他多个关注点。

    代码分散:以日志需求为例,只是为了满足这个单一需求,就不得不在多个模块(方法)里面多次重复相同的日志代码,如果日志需求发生变化,必须修改所有模块。

    先看使用动态代理:

    package logan.study.aop.helloworld;
    
    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);
        
    
    }
    package logan.study.aop.helloworld;
    
    public class ArithmeticCalculatorImpl implements ArithmeticCalculator {
    
        @Override
        public int add(int i, int j) {
            // TODO Auto-generated method stub
            int result = i + j;
            return result;
        }
    
        @Override
        public int sub(int i, int j) {
            // TODO Auto-generated method stub
            int result = i - j;
            return result;
        }
    
        @Override
        public int mul(int i, int j) {
            // TODO Auto-generated method stub
            int result = i * j;
            return result;
        }
    
        @Override
        public int div(int i, int j) {
            // TODO Auto-generated method stub
            int result = i / j;
            return result;
        }
    
    }
    package logan.study.aop.helloworld;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.util.Arrays;
    
    public class ArithmeticCalculatorLoggingProxy {
        
        //要代理的对象
        private ArithmeticCalculator target;
        
        public ArithmeticCalculatorLoggingProxy(ArithmeticCalculator target){
            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:正在返回的那个对象,一般情况下,在invok方法中都不使用该对象
                 * method:正在被调用的方法
                 * args:调用方法时传入的参数
                 */
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    // TODO Auto-generated method stub
                    String methodName = method.getName();
                    //日志
                    System.out.println("The method "+ methodName + "begin with " + Arrays.asList(args));
                    //执行方法
                    Object result = method.invoke(target, args);
                    //日志
                    System.out.println("The method " + methodName + "end with result = " + result);
                    //返回
                    return result;
                }
            };
            proxy = (ArithmeticCalculator) Proxy.newProxyInstance(loader, interfaces, h);
            
            return proxy;
        }
    
    }
    package logan.study.aop.helloworld;
    
    public class Main {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            ArithmeticCalculator target = new ArithmeticCalculatorImpl();
            ArithmeticCalculator proxy =  new ArithmeticCalculatorLoggingProxy(target).getLoggingProxy();
            
            int result = proxy.add(1, 2);
            System.out.println("-->"+result);
            
            result = proxy.div(8, 2);
            System.out.println("-->"+result);
            
    
        }
    
    }

    返回的结果:

    The method addbegin with [1, 2]
    The method addend with result = 3
    -->3
    The method divbegin with [8, 2]
    The method divend with result = 4
    -->4

    但是使用动态代理比较麻烦,有没有更简单的方法来实现呢?

    AOP(Aspect-Oriented-Programming,面向切面编程)是一种新的方法论,是对传统OOP(Object-Oriented-Programming,面向对象编程)的补充。

    AOP的主要编程对象是切面(Aspect),而切面是模块化横切关注点。

    在应用AOP编程时,仍然需要定义公共功能,但是可以明确地定义这个功能在哪里,以什么方式应用,并且不必修改受影响的类,这样一来,横切关注点就被模块化到特殊的对象(切面)里。

    AOP好处:

    -每个事物逻辑错位与一个位置,代码不分散,便于维护和升级

    -业务模块更简洁,只包含核心的业务代码

    AOP术语

    切面(Aspect):横切关注点(跨越应用程序多个模块的功能)被模块化的特殊对象。

    通知(Advice):切面必须要完成的工作。

    目标(Target):被通知的对象。

    代理(Proxy):向目标对象应用通知之后创建的对象。

    连接点(Joinpoint):程序执行的每个特定位置:如类某个方法调用前,调用后,方法抛出异常等等,连接点由两个信息确定:方法表示的程序的执行点,相对点表示的方位,例如ArithmeticCalculator#add()方法执行前的连接点执行点为ArithmeticCalculator#add();方位为该方法执行前的位置。

    切点(pointcut):每个类都拥有多个连接点,例如:ArithmethicCalculator的所有方法实际上都是连接点,即连接点是程序类中客观存在的事务,AOP通过切点定位到特定的连接点。类比:连接点相当于数据库中的记录,切点相当于查询条件,切点和连接点不是一对一关系,一个切点匹配多个连接点,切点通过org.springframework.aop.Pointcut接口进行描述,它使用类和方法作为连接点的查询条件。

  • 相关阅读:
    Linux环境下入侵工具Knark的分析及防范 java程序员
    六个步骤即可防范ARP地址欺骗类病毒 java程序员
    巧用命令行 揪出ARP欺骗病毒母机方法 java程序员
    poj3264Balanced Lineup(线段树RMQ)
    有了1A的把握再去提交
    poj2828Buy Tickets(线段树 单点更新+区间求和+区间第K值)
    poj2513Colored Sticks(无向图判欧拉路、回路+trie树)
    ACM数学(转)
    sdut2381Broken Keyboard
    sdut2383Decode the Strings(循环节)
  • 原文地址:https://www.cnblogs.com/LoganChen/p/6913060.html
Copyright © 2020-2023  润新知