Spring的AOP

一：概念

好多个任务之前的一个共有环节，再具体任务之前做点事情，任务之后做点事情< 事情是共有的，不是某一个具体的业务，这种情况，想到切面的思想
例：我要从兰州出发到重庆吃火锅

1.起始对象 兰州（没有真实存在main 项目开始)
2.目标对象（Target Object） 重庆
3.代理对象（AOP Proxy ） 代驾(Spring帮我们创建的 责任链模式）
4.切面对象（Aspect） 好几个城市(沈阳 天津 济南 南京)
5.切入点（Pointcut） 切入点 目标对象中的方法(吃火锅)
6.连接点（Join point） 连接点 切面对象中的方法(加油 收费。。)
7.建议/通知（Advice） 建议/通知 连接点中执行的过程（连接点方法中执行的过程，代码）方式如下几种：

• before前置建议/通知
• after-return后置建议/通知
• after-throwing异常建议/通知 COtio
• after最终建议/通知
• around环绕建议/通知(前后建议/通知)

二.代码

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

    <bean name="controller" class="controller.TestController"></bean>
    <bean name="aspect1" class="aspect.Aspect1"></bean>
    <!--给切面对象aspect1做一个说明-->
    <aop:config>
        <!--说明那一个是切面对象,ref:切面对象的name-->
        <aop:aspect id="mycut" ref="aspect1">
            <!--说明切点：目标对象中的方法，（就是执行目标对象中的那个方法时会触发切点）-->
            <!--expression * 切点所在包 切点所在类 切点的方法-->
            <aop:pointcut id="mycut" expression="execution(* controller.TestController.test())"/>
            <!--切面对象做的建议方式（连接点的执行 连接点是切面中的方法）-->
            <!--method:切面对象中的方法名 pointcut-ref:在什么时候执行（切点执行完后执行）-->
            <aop:before method="beforeMethod" pointcut-ref="mycut"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>

目标类中

package controller;
/**
 * 这是一个controller
 * 可以理解为是之前的servlet(以后发送请求访问那个目标对象)
 */
public class TestController {
    public void test(){
        System.out.println("目标对象目标对象");
    }
}

切面对象类

package aspect;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * 这是一个切面对象
 */
public class Aspect1 {
    //切面对象中的分方法本身叫连接点
    //方法什么时候：在最终目标之前 之后执行方法
    public void beforeMethod(){
        System.out.println("切面对象中的分方法");
    }
    //环绕通知
    public void aroundMethod(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕建议前部分");
        //中间的等待目标执行完
        proceedingJoinPoint.proceed();//相当于chain.doFilter();放行
        System.out.println("环绕建议后部分");
    }
}

测试类

package test;

import controller.TestController;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.awt.*;

public class TestMain {
    public static void main(String[] args) {
        BeanFactory factory= new ClassPathXmlApplicationContext("ApplicationContext.xml") ;
        TestController testController=(TestController) factory.getBean("controller");
        testController.test();
    }
}