Spring AOP 通知详解

其他 2020-04-14 09:49:02 阅读次数: 0

一、什么是Spring AOP

AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

AOP技术恰恰相反，它利用一种称为"横切"的技术，剖解开封装的对象，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任的封装，减少系统的重复代码，降低模块之间的耦合度，并有利于后期的可操作性和可维护性。

使用"横切"技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事物。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

AOP核心概念

1、横切关注点

“对哪些方法进行横切”看成是关注点的一个部分，“横切后怎么处理”也看成是一个关注点的另一个部分，等等。这些关注点称之为横切关注点

2、切面（Aspect）

类是对物体特征的抽象，切面就是对横切关注点的抽象，所以切面实际上是一个类

3、连接点（JoinPoint）

被拦截到的点，因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器

4、切入点（PointCut）

对连接点进行拦截的定义

5、通知（advice）

指的就是指拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类

6、目标对象

代理的目标对象

7、织入（weave）

将切面应用到目标对象并导致代理对象创建的过程

8、引入（introduction）

在不修改代码的前提下，引入可以在运行期为类动态地添加一些方法或字段

Spring对AOP的支持

Spring中AOP代理由Spring的IOC容器负责生成、管理，其依赖关系也由IOC容器负责管理。因此，AOP代理可以直接使用容器中的其它bean实例作为目标，这种关系可由IOC容器的依赖注入提供。Spring创建代理的规则为：

1、默认使用Java动态代理来创建AOP代理，这样就可以为任何接口实例创建代理了

2、当需要代理的类不是代理接口的时候，Spring会切换为使用CGLIB代理，也可强制使用CGLIB

AOP编程其实是很简单的事情，纵观AOP编程，程序员只需要参与三个部分：

1、定义普通业务组件

2、定义切入点，一个切入点可能横切多个业务组件

3、定义增强处理，增强处理就是在AOP框架为普通业务组件织入的处理动作

所以进行AOP编程的关键就是定义切入点和定义增强处理，一旦定义了合适的切入点和增强处理，AOP框架将自动生成AOP代理，即：代理对象的方法=增强处理+被代理对象的方法。

使用如下：

package com.leboop.aop.controller;

import com.leboop.aop.service.OperationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;


/**
 * Created by leboop on 2018/11/8.
 */
@Controller
@RequestMapping("/operation")
public class OperationController {
    @Autowired
    private OperationService operationService;

    @RequestMapping("/add")
    @ResponseBody
    public String add(@RequestParam int a, @RequestParam int b) {
        String result = operationService.add(a, b);

        return result;
    }

    @RequestMapping("/minus")
    @ResponseBody
    public String minus(@RequestParam int a, @RequestParam int b) {
        String result = operationService.minus(a, b);

        return result;
    }

    @RequestMapping("/multiply")
    @ResponseBody
    public String multiply(@RequestParam int a, @RequestParam int b) {
        String result = operationService.multiply(a, b);

        return result;
    }

    @RequestMapping("/divide")
    @ResponseBody
    public String divide(@RequestParam int a, @RequestParam int b) throws Exception{

        String result = operationService.divide(a, b);

        return result;
    }
}

package com.leboop.aop.service;

import org.springframework.stereotype.Service;

/**
 * Created by leboop on 2018/11/8.
 */
@Service
public class OperationService {

    public String add(int a, int b) {
        System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()
                + "方法开始执行");
        String result = String.valueOf(a + b);
        System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()
                + "方法执行结束");

        return result;
    }

    public String minus(int a, int b) {
        System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()
                + "方法开始执行");
        String result = String.valueOf(a - b);
        System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()
                + "方法执行结束");

        return result;
    }

    public String multiply(int a, int b) {
        System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()
                + "方法开始执行");
        String result = String.valueOf(a * b);
        System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()
                + "方法执行结束");

        return result;
    }

    public String divide(int a, int b) {
        System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()
                + "方法开始执行");
        String result = String.valueOf(a / b);
        System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()
                + "方法执行结束");

        return result;
    }
}

package com.leboop.aop.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * Created by leboop on 2018/11/8.
 * 切面
 */
@Component
@Aspect
public class OperationAspect {
    private static final String EXPRESSION =
            "execution(* com.leboop.aop.service.*.*(..))";

    /**
     * 切点
     */
    @Pointcut(EXPRESSION)
    private void pointCut() {
    }

    /**
     * 前置通知：方法体执行前通知
     *
     * @param joinPoint 连接点
     */
    @Before(EXPRESSION)
    public void beforeTest(JoinPoint joinPoint) {
        System.out.println("========================");
        System.out.println("前置通知开始执行");
        System.out.println("切点应用目标：" + joinPoint.getSignature());
        System.out.println("切点应用目标方法的参数值列表：" + Arrays.toString(joinPoint.getArgs()));
        System.out.println("前置通知执行完成");
    }

    /**
     * @param joinPoint
     */
    @After(EXPRESSION)
    public void afterTest(JoinPoint joinPoint) {
        System.out.println("========================");
        System.out.println("后置通知开始执行");
        System.out.println("切点应用目标：" + joinPoint.getSignature());
        System.out.println("切点应用目标的参数值：" + Arrays.toString(joinPoint.getArgs()));
        System.out.println("后置通知执行完成");
    }

    /**
     * @param joinPoint
     * @param resultValue
     */
    @AfterReturning(pointcut = "pointCut()", returning = "resultValue")
    public void afterReturningTest(JoinPoint joinPoint, Object resultValue) {
        System.out.println("========================");
        System.out.println("正常返回通知开始执行");
        System.out.println("切点应用目标：" + joinPoint.getSignature());
        System.out.println("返回值：" + resultValue);
        System.out.println("正常返回通知执行完成");
    }

    @AfterThrowing(pointcut = "pointCut()", throwing = "e")
    public void afterThrowingTest(JoinPoint joinPoint, Throwable e) {
        System.out.println("========================");
        System.out.println("异常返回通知开始执行");
        System.out.println("切点应用目标：" + joinPoint.getSignature());
        System.out.println("异常：" + e);
        System.out.println("异常返回通知执行完成");
    }

    @Around(value = "pointCut()")
    public Object aroundTest(ProceedingJoinPoint proceedingJoinPoint) {
        System.out.println("========================");
        System.out.println("环绕通知开始执行");
        System.out.println("切点应用目标：" + proceedingJoinPoint.getSignature());
        Object result = null;
        System.out.println("切点应用目标的参数值：" + Arrays.toString(proceedingJoinPoint.getArgs()));
        try {
            System.out.println("环绕通知中目标方法开始执行");
            result = proceedingJoinPoint.proceed();
            System.out.println("环绕通知中目标方法执行结束");
        } catch (Throwable throwable) {
            System.out.println("执行异常通知");
        }
        System.out.println("环绕通知通知执行完成");

        return result;
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
     http://www.springframework.org/schema/aop
     http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context-4.0.xsd
     http://www.springframework.org/schema/mvc
     http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
    
    <!-- 自动组件扫描（5大组件：@Component,@Repository,@Service,@Name,@Controller） -->
    <context:component-scan base-package="com.leboop.aop"/>

    <!-- 简化HandlerMapping配置 -->
    <mvc:annotation-driven />

    <!-- viewResolver视图解析器配置 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <aop:aspectj-autoproxy/>
</beans>
<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         metadata-complete="true" version="3.0">
  <!-- 前端控制器DispatcherServlet配置 -->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
</web-app>
http://localhost:8080/operation/divide.do?a=4&b=2
========================
前置通知开始执行
切点应用目标：String com.leboop.aop.service.OperationService.divide(int,int)
切点应用目标方法的参数值列表：[4, 2]
前置通知执行完成
divide方法开始执行
divide方法执行结束
========================
后置通知开始执行
切点应用目标：String com.leboop.aop.service.OperationService.divide(int,int)
切点应用目标的参数值：[4, 2]
后置通知执行完成
========================
正常返回通知开始执行
切点应用目标：String com.leboop.aop.service.OperationService.divide(int,int)
返回值：2
正常返回通知执行完成
http://localhost:8080/operation/divide.do?a=4&b=0
========================
前置通知开始执行
切点应用目标：String com.leboop.aop.service.OperationService.divide(int,int)
切点应用目标方法的参数值列表：[4, 0]
前置通知执行完成
divide方法开始执行
========================
后置通知开始执行
切点应用目标：String com.leboop.aop.service.OperationService.divide(int,int)
切点应用目标的参数值：[4, 0]
后置通知执行完成
========================
异常返回通知开始执行
切点应用目标：String com.leboop.aop.service.OperationService.divide(int,int)
异常：java.lang.ArithmeticException: / by zero
异常返回通知执行完成
http://localhost:8080/operation/divide.do?a=4&b=0
========================
环绕通知开始执行
切点应用目标：String com.leboop.aop.service.OperationService.divide(int,int)
切点应用目标的参数值：[4, 0]
环绕通知-前置通知执行
环绕通知-目标方法开始执行
========================
前置通知开始执行
切点应用目标：String com.leboop.aop.service.OperationService.divide(int,int)
切点应用目标方法的参数值列表：[4, 0]
前置通知执行完成
divide方法开始执行
环绕通知--异常通知执行
环绕通知执行完成
========================
后置通知开始执行
切点应用目标：String com.leboop.aop.service.OperationService.divide(int,int)
切点应用目标的参数值：[4, 0]
后置通知执行完成
========================
正常返回通知开始执行
切点应用目标：String com.leboop.aop.service.OperationService.divide(int,int)
返回值：null
正常返回通知执行完成
leboop（二宝）
发布了89 篇原创文章 · 获赞 79 · 访问量 10万+
私信 关注

猜你喜欢

转载自blog.csdn.net/L_15156024189/article/details/83869591
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022