SpringAOP学习

---

只要你愿意走，踩过的都是路；只要你不回避与退缩，生命的掌声终会为你响起。

SpringAOP内容如下

AOP

AOP：Aspect Oriented Programming ⾯向切⾯编程。

---

AOP 的优点：

1.降低模块之间的耦合度。

2.使系统更容易扩展。

3.更好的代码复⽤。

4.⾮业务代码更加集中，不分散，便于统⼀管理。

5.业务代码更加简洁存粹，不参杂其他代码的影响。

---

AOP 是对⾯向对象编程的⼀个补充，在运⾏时，动态地将代码切⼊到类的指定⽅法、指定位置上的编程 思想就是⾯向切⾯编程。将不同⽅法的同⼀个位置抽象成⼀个切⾯对象，对该切⾯对象进⾏编程就是 AOP。

如何使⽤？

创建 Maven ⼯程，pom.xml 添加

<dependencies>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context</artifactId>
 <version>5.0.11.RELEASE</version>
 </dependency>

 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-aop</artifactId>
 <version>5.0.11.RELEASE</version>
 </dependency>

 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-aspects</artifactId>
 <version>5.0.11.RELEASE</version>
 </dependency>
</dependencies>

创建⼀个计算器接⼝ Cal，定义4个⽅法

package com.southwind.utils;
public interface Cal {
     public int add(int num1,int num2);
     public int sub(int num1,int num2);
     public int mul(int num1,int num2);
     public int div(int num1,int num2);
}

创建接⼝的实现类 CalImpl。

package com.southwind.utils.impl;
import com.southwind.utils.Cal;
public class CalImpl implements Cal {
   public int add(int num1, int num2) {
     System.out.println("add⽅法的参数是["+num1+","+num2+"]");
     int result = num1+num2;
     System.out.println("add⽅法的结果是"+result);
     return result;
 }
   public int sub(int num1, int num2) {
     System.out.println("sub⽅法的参数是["+num1+","+num2+"]");
     int result = num1-num2;
     System.out.println("sub⽅法的结果是"+result);
     return result;
 }

上述代码中，⽇志信息和业务逻辑的耦合性很⾼，不利于系统的维护，使⽤ AOP 可以进⾏优化，如何
来实现 AOP？使⽤动态代理的⽅式来实现。
给业务代码找⼀个代理，打印⽇志信息的⼯作交个代理来做，这样的话业务代码就只需要关注⾃身的业
务即可。

 public int mul(int num1, int num2) {
     System.out.println("mul⽅法的参数是["+num1+","+num2+"]");
     int result = num1*num2;
     System.out.println("mul⽅法的结果是"+result);
     return result;
 }
 public int div(int num1, int num2) {
     System.out.println("div⽅法的参数是["+num1+","+num2+"]");
     int result = num1/num2;
     System.out.println("div⽅法的结果是"+result);
     return result;
   }
}

以上是通过动态代理实现 AOP 的过程，⽐较复杂，不好理解，Spring 框架对 AOP 进⾏了封装，使⽤ Spring 框架可以⽤⾯向对象的思想来实现 AOP。

Spring 框架中不需要创建 InvocationHandler，只需要创建⼀个切⾯对象，将所有的⾮业务代码在切⾯ 对象中完成即可，Spring 框架底层会⾃动根据切⾯类以及⽬标类⽣成⼀个代理对象。

LoggerAspect

package com.southwind.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import java.util.Arrays;
@Aspect
@Component
public class LoggerAspect {
     @Before(value = "execution(public int com.southwind.utils.impl.CalImpl.*
(..))")
     public void before(JoinPoint joinPoint){
     //获取⽅法名
     String name = joinPoint.getSignature().getName();
     //获取参数
     String args = Arrays.toString(joinPoint.getArgs());
     System.out.println(name+"⽅法的参数是："+ args);
 }

     @After(value = "execution(public int com.southwind.utils.impl.CalImpl.*
(..))")
     public void after(JoinPoint joinPoint){
     //获取⽅法名
     String name = joinPoint.getSignature().getName();
     System.out.println(name+"⽅法执⾏完毕");
 }

     @AfterReturning(value = "execution(public int
com.southwind.utils.impl.CalImpl.*(..))",returning = "result")
     public void afterReturning(JoinPoint joinPoint,Object result){
     //获取⽅法名
     String name = joinPoint.getSignature().getName();
     System.out.println(name+"⽅法的结果是"+result);
 }
    @AfterThrowing(value = "execution(public int
com.southwind.utils.impl.CalImpl.*(..))",throwing = "exception")
     public void afterThrowing(JoinPoint joinPoint,Exception exception){
     //获取⽅法名
     String name = joinPoint.getSignature().getName();
     System.out.println(name+"⽅法抛出异常："+exception);
   }
}

LoggerAspect 类定义处添加的两个注解：

@Aspect ：表示该类是切⾯类。 @Component ：将该类的对象注⼊到 IoC 容器。

具体⽅法处添加的注解：

@Before ：表示⽅法执⾏的具体位置和时机。

CalImpl 也需要添加 @Component ，交给 IoC 容器来管理。

package com.southwind.utils.impl;
import com.southwind.utils.Cal;
import org.springframework.stereotype.Component;
@Component
public class CalImpl implements Cal {
   public int add(int num1, int num2) {
     int result = num1+num2;
     return result;
 }
 public int sub(int num1, int num2) {
     int result = num1-num2;
     return result;
 }
 public int mul(int num1, int num2) {
     int result = num1*num2;
     return result;
 }
 public int div(int num1, int num2) {
     int result = num1/num2;
     return result;
 }
}

<?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:context="http://www.springframework.org/schema/context"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:p="http://www.springframework.org/schema/p"
 xsi:schemaLocation="http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
 http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
 http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
">
 <!-- ⾃动扫描 -->
 <context:component-scan base-package="com.southwind">
</context:component-scan>
 <!-- 是Aspect注解⽣效，为⽬标类⾃动⽣成代理对象 -->
 <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

context:component-scan 将 com.southwind 包中的所有类进⾏扫描，如果该类同时添加了 @Component ，则将该类扫描到 IoC 容器中，即 IoC 管理它的对象。

aop:aspectj-autoproxy 让 Spring 框架结合切⾯类和⽬标类⾃动⽣成动态代理对象。

切⾯：横切关注点被模块化的抽象对象。

通知：切⾯对象完成的⼯作。

⽬标：被通知的对象，即被横切的对象。

代理：切⾯、通知、⽬标混合之后的对象。

连接点：通知要插⼊业务代码的具体位置。

切点：AOP 通过切点定位到连接点。