SpringAOP - 注解方式实现

---

简述

---

xml配置方式实现AOP → xml实现

 AOP: 
 	- 面向切面编程，
 	- AOP是一种编程范式，Spring将AOP思想引入到框架中，
 	- 使用AOP可以对某个模块的功能进行增强，
 	- SpringAOP底层使用的是动态代理来实现，
 	- 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率，
 	- AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码

• 学习AOP的原因：

在OOP中要实现一个功能的增强，可以继承类或实现一个接口来完成，这样就会使得代码的耦合度增强；
AOP思想通过无缝切入来实现，无需继承类或实现接口，从而达到解耦。
可以在不修改源代码的前提下，对程序功能进行增强！（解耦合，强功能）

---

AOP的术语

---

• 通知的类型：

@Before				-- 前置通知（在目标类的方法执行之前执行）
@AfterReturing		-- 后置通知（在目标类的方法正常执行后的通知, 程序出现异常, 则不会执行）
@After				-- 最终通知（在目标类的方法执行之后执行，如果程序出现了异常，最终通知也会执行）
@Around				-- 环绕通知（在目标类方法的执行前后执行）
@AfterThrowing		-- 异常抛出通知（在目标类方法执行出现异常时, 才会调用该通知）

• 相关术语

Joinpoint(连接点)	-- 连接点是指那些被拦截到的点。在spring中，目标类的所有方法都可当做是一个连接点
Pointcut(切入点)		-- 切入点是指我们要对哪些Joinpoint进行拦截的定义
Advice(通知/增强)	-- 通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
Introduction(引介)	-- 引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field
Target(目标对象)		-- 代理的目标对象
Weaving(织入)		-- 是指把增强应用到目标对象来创建新的代理对象的过程
Proxy（代理）		-- 一个类通过AOP织入增强后，就会产生一个结果代理类
Aspect(切面)			-- 是切入点与通知的结合

---

注解方式实现Spring AOP

---

使用 Maven 来完成

• 完整构建图
  
• pom.xml

<!-- 导入4个依赖 -->
<dependencies>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-webmvc</artifactId>
		<version>5.1.5.RELEASE</version>
	</dependency>

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

	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-test</artifactId>
		<version>5.1.5.RELEASE</version>
	</dependency>

	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.12</version>
	</dependency>
</dependencies>

• 导入依赖后的jar包
  
• MyService 接口

package com.zlk.service;

public interface MyService {

    public void before();
    
    public void after();
    
    public void around();
    
    public void afterReturning();
    
    public void afterThrowing();
}

• MyServiceImpl 类，被拦截类 (MyService 接口的实现类)

package com.zlk.service.impl;

import org.springframework.stereotype.Service;

import com.zlk.service.MyService;

@Service("myService")  // 等价于==> <bean id="myService" class="com.zlk.service.impl.MyServiceImpl"></bean>
public class MyServiceImpl implements MyService {

    @Override
    public void before() {
        System.out.println("before message");
    }

    @Override
    public void after() {
//        int a = 10 / 0;
        System.out.println("after message");
    }

    @Override
    public void around() {
        System.out.println("around message");
    }

    @Override
    public void afterReturning() {
//        int a = 10 / 0;
        System.out.println("afterReturning message");
    }

    @Override
    public void afterThrowing() {
//        int a = 10 / 0;
        System.out.println("afterThrowing message");
    }
}

• MyAop 切面类

package com.zlk.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect		// 使用 @Aspect 来声明切面类，注解方式才需要加
@Component  // 让切面类成为Spring管理的Bean，等价于 ==>  <bean id="myAop" class="com.zlk.aop.MyAop"></bean>
public class MyAop {
    
    // 切入点
    @Pointcut("execution(* *..*.before(..))")
    public void anyMethod() { }

    // 测试 @Pointcut
    // 前置通知
    // 在目标类的方法执行之前执行
    @Before("anyMethod()")
    public void beforeAdvice() {
        System.out.println("前置通知！");
    }
    
    // 最终通知
    // 在目标类的方法执行之后执行，如果程序出现了异常，最终通知也会执行
    @After("execution(* *..*.after(..))")
    public void afterAdvice() {
        System.out.println("最终通知！");
    }
    
    // 后置通知
    // 方法正常执行后的通知, 程序出现异常, 则不会执行
    @AfterReturning("execution(* *..*.afterReturning(..))")
    public void afterReturningAdvice() {
        System.out.println("后置通知！");
    }
    
    // 环绕通知
    // 在目标类方法的执行前后执行
    @Around("execution(* *..*.around(..))")
    public void aroundAdvice(ProceedingJoinPoint joinPoint) {
        System.out.println("环绕通知 - 前");
        
        try {
            joinPoint.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        
        System.out.println("环绕通知 - 后");
    }
    
    // 异常抛出通知
    // 在目标类方法执行出现异常时, 才会调用该通知
    @AfterThrowing("execution(* *..*.afterThrowing(..))")
    public void afterThrowingAdvice() {
        System.out.println("异常抛出通知");
    }
}

• applicationContext.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:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

	<!-- 开启自动代理, 注解方式才需要开启 -->
	<aop:aspectj-autoproxy />
	
	<context:component-scan base-package="com.zlk" />
	
</beans>

• MyTest 测试类

package com.zlk.test;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.zlk.service.MyService;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class MyTest {

    @Resource(name = "myService")
    private MyService myService;

    @Test
    public void run1() {
        // 测试前置通知
//        myService.before();

        // 测试最终通知
        myService.after();

        // 测试后置通知
//        myService.afterReturning();

        // 测试环绕通知
//        myService.around();

        // 测试异常抛出通知
//        myService.afterThrowing();
    }
}