SpringFramework学习-(11)初识AOP

谁借莪１个温暖的怀抱￠ 2022-06-02 01:59 255阅读 0赞

一提到SpringFramework，肯定会提到SpringFramework的IOC容器和AOP切面。前面已经从IOC的运用，自己的IOC容器，源码级解析IOC等介绍了IOC容器，所以这里就不再赘述IOC容器的相关知识了，本篇将介绍一下SpringFramework的AOP知识。

# 1.什么是AOP #

AOP: (Aspect Oriented Programming) 面向切面编程。什么意思？是否有面向其他的编程？

答案是肯定的：有OOP（面向对象编程）

OOP（面向对象编程）针对业务处理过程的实体及其属性和行为进行抽象封装，以获得更加清晰高效的逻辑单元划分，如封装继承多态。在传统 OOP 编程里以对象为核心，整个软件系统由系列相互依赖的对象所组成，而这些对象将被抽象成一个一个的类，并允许使用类继承来管理类与类之间一般到特殊的关系。随着软件规模的增大，应用的逐渐升级，慢慢出现了一些 OOP 很难解决的问题。

AOP技术则是对OOP的一种补充，它是一种“横切”技术，能够解剖封装的对象内部做一些其他操作，AOP被广泛应用于处理一些具有横切性质的系统级服务，如事务管理、安全检查、缓存、对象池管理等。

# 2.AOP能做什么 #

举个例子（可能不恰当）：  
1）我们做一款计算器软件，刚开始的时候业务需求不明确或者后期没有计划，我们只返回计算结果就可以了；  
2）后来产品经理说这个不好，记录的信息不够全面，我需要将每一次计算传入的数据都通过日志的形式记录下来，并且计算的结果也打印下来；  
3）开发人员可能将所欲的计算方法都打开，在每一个计算方法的开始和结尾都打印出传入的参数和计算的结果，任务完成了；  
4）后来产品经理又说这个还是不够好，为了给某个公司定制这个计算器，需要把这个公司的名称也打印出来；  
5）开发人员又打开每一个计算方法，在之前的打印前面添加对应公司的公司名称；  
6）随着大数据发展，光记录这些操作不行呀，需要把每个人的IP也记录下；  
7）开发人员又打开每一个计算方法，添加IP；  
….  
n）开发人员卒。

不难发现这种方法是行不通的，在多次的改动中，很多的内容都是重复的。

![这里写图片描述][SouthEast]  
图片引自：[https://www.ibm.com/developerworks/cn/java/j-lo-springaopcglib/][https_www.ibm.com_developerworks_cn_java_j-lo-springaopcglib]

我们需要一种通用的方法，在每次执行的时候调用就好了。

![这里写图片描述][SouthEast 1]

但是，手动调用这个通用方法做的工作量也不小啊！我们希望有一种特殊的方法：我们只要定义该方法，无须在方法中显式调用它，系统会“自动”执行该特殊方法。  
实现这个需求的技术就是 AOP（虽然我们知道代理模式可以实现，但是我们这里先不说代理模式）。

# 3.AOP小例子 #

通过上面的介绍，基本上也可以了解到某些使用AOP的场景。看看使用AOP的效果吧：  
这里使用的是maven构建，需要添加AOP的jar

<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>${springframework}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>${springframework}</version>
    </dependency>

定义接口

/** * 计算器接口 */
    public interface Calculator { 
    
        public int add(int a,int b);
    
    }

实现接口并加入到IOC容器

@Component
    public class CalculatorImpl implements Calculator{ 
    
        public int add(int a, int b) {
            int result = a + b;
            return result;
        }
    
    }

创建切面LoggerAspect ：

package com.jd.aop;
    
    import java.util.Arrays;
    import java.util.List;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.After;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.springframework.core.annotation.Order;
    import org.springframework.stereotype.Component;
    
    /** * 日志切面 * 1)把该类放入到ioc容器@Component@Aspect，声明切面 * 2)制定该切面在哪些方法之前执行@before */
    @Aspect
    @Component
    public class LoggerAspect { 
    
        @Before("execution(public int com.jd.aop.CalculatorImpl.add(int, int))")
        public void beforeMethod(JoinPoint joinPoint){
            String name = joinPoint.getSignature().getName();
            List<Object> args = Arrays.asList(joinPoint.getArgs());
            System.out.println(name+" invoke beforeMethod ..logger..,args:"+args);
        }
    
        @After("execution(public int com.jd.aop.CalculatorImpl.add(int, int))")
        public void afterMethod(JoinPoint joinPoint){
            String name = joinPoint.getSignature().getName();
            List<Object> args = Arrays.asList(joinPoint.getArgs());
            System.out.println(name+" invoke afterMethod ..logger..,args:"+args);
        }
    }

配置文件springaop.xml：

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd">
    
        
        <context:component-scan base-package="com.jd.aop"></context:component-scan>
    
        
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
    </beans>

测试：

package com.jd.aop;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class AopTest { 
    
        private ApplicationContext ac = null;
        private Calculator calculator = null;
        {
            ac = new ClassPathXmlApplicationContext("springaop.xml");
            calculator = ac.getBean(Calculator.class);
        }
    
        @Test
        public void testAop(){
            System.out.println("计算开始");
            int result = calculator.add(4, 2);
            System.out.println("计算结束");
            System.out.println("==>result:"+result);
    
        }
    }

执行结果：

> 计算开始  
> add invoke beforeMethod ..logger..,args:\[4, 2\]  
> add invoke afterMethod ..logger..,args:\[4, 2\]  
> 计算结束  
> ==>result:6

由结果我们看到了虽然我们在结算方法add上面什么都没有打印，按时执行结果我们看到了环绕着add方法，我们可以获取到传递的参数。所以这就是AOP的一个简单效果。

当然这里面有很多的细节配置并没有介绍，原理也没有介绍。  
下一篇我们将一起看看其中的细节和原理的简单实现，敬请期待….

[SouthEast]: /images/20220602/8b692d5955874840be721b5e503a2b6a.png
[https_www.ibm.com_developerworks_cn_java_j-lo-springaopcglib]: https://www.ibm.com/developerworks/cn/java/j-lo-springaopcglib/
[SouthEast 1]: /images/20220602/67fc263e9c484ad7a9e810d1d448a2e7.png