Spring AOP 简介以及简单用法

墨蓝 2022-09-23 05:53 170阅读 0赞

# Spring AOP 简介以及简单用法 #

如果你去面试java开发， 那么Spring的AOP和DI几乎是必问的问题。

那么AOP是什么呢？

## 一. AOP ##

所谓Aop就是 Aspect-OrientedProgramming, 中文就是面向切面编程。

我们之前听说面向过程编程， 以及面向对象编程， 而这个面向切面编程我们可以视为是面向对象编程的1个补充(增强);

在一般的方法(函数)中， 为了方便，可能只写了业务代码  
1. 业务代码

而我们我们可以将其补充成4个部分。

1.  验证参数
2.  前置日志
3.  业务代码
4.  后置日志

### 1.1 横切关注点 (Crosscutting Concerns) ###

大家看上面的方法， 就像用刀子把1个方法横向切成4块， 我们把上面除业务代码外任意一个部分就叫做横切关注点.

### 1.2 切面 (Aspect) ###

我们可以把横切关注点进行分组， 其中任意一组就叫做切面

例如上面的例子中， 我们可以分成

1.  验证切面 (1. 验证参数)
2.  日志切面 (2. 前置日志， 4.后置日志)

### 1.3 通知 (Advice) ###

所谓通知就是切面要完成的工作。

例如对于日志通知来讲， 里面执行日志的方法我们就可以称为1个通知。

### 1.4 目标 (Target) ###

所谓目标就是被通知的对象， 也就是指上面例子中的原方法本身啦。

### 1.5 代理 (Proxy) ###

当目标被通知后产生的对象就叫做代理, 因为AOP的原理就是利用代理来实现的， 如果想了解动态代理的可以参考[这里][Link 1]

### 1.6 连接点 (Joinpoint) ###

所谓Joinpoint就是程序执行到的某个位置，

上面例子中， 业务代码方法的执行之前， 执行之后， 抛出异常后 都可以视为某个连接点。

### 1.7 切点 (PointCut) ###

每个方法都存在多个连接点， 而Spring AOP利用切点来定位到具体那些连接点。  
Joinpoint 和 PointCut 的关系可以作如下比喻，假如Joinpoint的数据里的记录， 那么PointCut就相当于查询条件

### 1.8 小结 ###

而Spring的AOP 能在不修改具体某个方法的前提下， 利用动态代理技术将通知注入到这个方法的各个连接点中， 令到这个方法得到了必要的补充。

对于上面的例子种， 我们原来的方法只有业务代码， 但是我们可以利用Spring AOP加入 验证参数， 日志等功能！

## 二. 具体例子 ##

### 2.1 还没使用AOP的例子 ###

我们首先利用spring创建两个计算类。

1个加法类， 1个减法类。

bean config 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.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd">
    
        
        <context:component-scan base-package="com.home.aop"></context:component-scan>
    </beans>

注意引入aop命名空间

计算接口 Calculator

package com.home.aop;
    
    public interface Calculator { 
        public double getResult(double a, double b);
    }

加法类 AddCalculator

package com.home.aop;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class AddCalculator implements Calculator { 
    
        @Override
        public double getResult(double a, double b) {
            return a + b;
        }
    }

减法类 SubCalculator

package com.home.aop;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class SubCalculator implements Calculator { 
    
        @Override
        public double getResult(double a, double b) {
            return a - b;
        }
    }

Client 代码

package com.home.aop;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class AopMain { 
        public static void f(){
            g();
        }
    
        public static void g(){
            ApplicationContext ctx = new ClassPathXmlApplicationContext("bean-aop.xml");
    
            Calculator addCal = (Calculator) ctx.getBean("addCalculator");
            Calculator subCal = (Calculator) ctx.getBean("subCalculator");
    
            System.out.println(addCal.getResult(3, 1));
            System.out.println(subCal.getResult(3, 1));
        }
    }

执行结果

Jul 05, 2016 10:10:00 PM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
    INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@5d79a4c9: startup date [Tue Jul 05 22:10:00 CST 2016]; root of context hierarchy
    Jul 05, 2016 10:10:00 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
    INFO: Loading XML bean definitions from class path resource [bean-aop.xml]
    4.0
    2.0

### 2.2 小结 ###

上面例子中， 加法类和减法类中只包含了业务代码， 我们可以将视为两个Target(目标), 下面我们就利用AOP技术为这两个Target加入通知。

### 2.3 AOP 前置通知 ###

这个任务的需求很简单。

1.  不能修加法类和减法类
2.  在加法类和减法类的getResult()方法执行时， 在业务代码执行前输出两个参数(log).

首先maven里要引入这些lib

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>
    
            <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${org.springframework.version}</version>
     </dependency>
    
     <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.8.8</version>
        </dependency>
    
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.8</version>
        </dependency>

然后在bean-config xml里加入下面这个句话， enable spring aop 功能

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

然后新建1个类LoggingAspect

package com.home.aop;
    
    import java.util.Arrays;
    import java.util.List;
    
    import org.springframework.stereotype.Component;
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    
    @Aspect
    @Component
    public class LoggingAspect { 
    
        //@Before("execution(public double com.home.aop.AddCalculator.getResult(double,double))")
        @Before("execution(public * com.home.aop.*.*(..))")
        public void beforeExecute(JoinPoint joinPoint){
            String classname = joinPoint.getTarget().getClass().getSimpleName();
            String methodName = joinPoint.getSignature().getName();
            List<Object> args = Arrays.asList(joinPoint.getArgs());
            System.out.println("before Execute! --class name: " + classname + ", method name: " + methodName + " " + args );
        }
    
    }

方法beforeExecute的意思就是我们要为目标执行之前 而注入的方法。

上面@Before 注解表示这是1个前置通知。 括号里面的就是PointCut(切点)， 上面说过了， 相当于数据库里的查询条件

然后Spring AOP 会根据PointCut 查找出所有符合条件的目标。

内容就很简单了， 无非就是输出被执行的类名方法名和参数…

执行结果：

Jul 06, 2016 12:30:03 AM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
    INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@6924181b: startup date [Wed Jul 06 00:30:03 CST 2016]; root of context hierarchy
    Jul 06, 2016 12:30:03 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
    INFO: Loading XML bean definitions from class path resource [bean-aop.xml]
    before Execute! --class name: AddCalculator, method name: getResult [3.0, 1.0]
    4.0
    before Execute! --class name: SubCalculator, method name: getResult [3.0, 1.0]
    2.0

## 三 总结 ##

项目中， 如果不用AOP 我们往往要为每个方法添加日志代码， 十分难于维护， 可读性也大大下降， 而AOP的出现， 就能解决这些问题。

[Link 1]: http://blog.csdn.net/nvd11/article/details/51527127