AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Spring全家桶(八)AOP核心思想与AspectJ 5种类型通知

2017-05-17 716
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 一、AOP核心思想AOP是Aspect-Oriented Programming的缩写，翻译为面向切面编程。我个人理解切面就是一个方面。

一、AOP核心思想

AOP是Aspect-Oriented Programming的缩写，翻译为面向切面编程。我个人理解切面就是一个方面。
例子，一个接口里面有增删改查四个方法：

package com.stuspring.aop.impl;

/**
 * Created by bee on 17/5/15.
 */
public interface ArithmeticCalculator {
     int add(int i,int j);
     int sub(int i,int j);
     int mul(int i,int j);
     int div(int i,int j);
}

实现类：

package com.stuspring.aop.impl;

import org.springframework.stereotype.Component;

/**
 * Created by bee on 17/5/15.
 */
@Component("arithmeticCalculator")
public class ArithmeticCalculatorImpl implements ArithmeticCalculator {
    @Override
    public int add(int i, int j) {
        int result=i+j;
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result=i-j;
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result=i*j;
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result=i/j;
        return result;
    }
}

如果想给这四个方法分别加上前置日志功能，以其中一个为例,add方法变这样：

  @Override
    public int add(int i, int j) {
        System.out.println("The method add begins with " +i+","+j);
        int result=i+j;
        return result;
    }

手动给每个方法都加上固然可行，但是维护起来过于麻烦，面向切面编程就是为了解决这一问题。AOP的好处就是每个逻辑位于一个位置，代码不分散便于维护和升级，业务模块更简洁。

加一个日志切面：

package com.stuspring.aop.impl;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.List;

/**
 * Created by bee on 17/5/15.
 */

@Aspect
@Component
public class LoggingAspect {

    /**
     * 前置通知 方法开始之前执行
     * @param joinPoint
     */
    @Before("execution(public int com.stuspring.aop.impl.ArithmeticCalculatorImpl.*(int,int))")
    public void beforeMethod(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        List<Object> agrs = Arrays.asList(joinPoint.getArgs());
        System.out.println("The method " + methodName + " begins with " + agrs);
    }

    /**
     * 后置通知，方法执行完之后执行，不论方法是否出现异常
     * 后置通知中不能访问目标方法的执行结果
     */
    @After("execution(public int com.stuspring.aop.impl.ArithmeticCalculatorImpl.*(int,int))")
    public void afterMethod(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("The method " + methodName + " ends with " + args);
    }
}

新建spring配置文件beans-aspect.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:content="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/context
       http://www.springframework.org/schema/context/spring-context-4.3.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

    <content:component-scan base-package="com.stuspring.aop.impl"/>
    <aop:aspectj-autoproxy/>
</beans>

附maven依赖：

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

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.3.8.RELEASE</version>
        </dependency>

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

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.8.10</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.10</version>
        </dependency>

二、五种类型通知

  1. @Before前置通知：方法开始之前执行。

     /**
     * 前置通知 方法开始之前执行
     * @param joinPoint
     */
    @Before("execution(public int com.stuspring.aop.impl.ArithmeticCalculatorImpl.*(int,int))")
    public void beforeMethod(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        List<Object> agrs = Arrays.asList(joinPoint.getArgs());
        System.out.println("The method " + methodName + " begins with " + agrs);
    }

  2. @After后置通知：方法开始之后执行，不论方法是否出现异常。

       /**
     * 后置通知，方法执行完之后执行，不论方法是否出现异常
     * 后置通知中不能访问目标方法的执行结果
     */
    @After("execution(public int com.stuspring.aop.impl.ArithmeticCalculatorImpl.*(int,int))")
    public void afterMethod(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("The method " + methodName + " ends with " + args);
    }

  3. @AfterRunning：返回通知，在方法返回结果之后执行。

        /**
     * 返回通知，在方法正常结束之后执行的代码
     * 返回通知可以访问方法的返回值
     */

    @AfterReturning(value="execution(public int com.stuspring.aop.impl.ArithmeticCalculatorImpl.*(int,int))",returning = "result")
    public void afterReturning(JoinPoint joinPoint,Object result){

        String methodName=joinPoint.getSignature().getName();
        System.out.println("The method "+methodName+" ends with "+result);
    }

  4. @AfterThrowing：异常通知，在方法抛出异常之后。

        /**
     * 异常通知:在方法抛出异常之后执行
     * @param joinPoint
     * @param e
     */

    @AfterThrowing(value="execution(public int com.stuspring.aop.impl.ArithmeticCalculatorImpl.*(int,int))",throwing = "e")
    public void afterThrowing(JoinPoint joinPoint,Exception e){
        String methodName=joinPoint.getSignature().getName();
        System.out.println("The method "+methodName+" occurs execution: "+e);
    }

  5. @Around：环绕通知，围绕方法执行。

        /**
     * 环绕通知需要携带ProceedingJoinPoint类型的参数
     * 环绕通知类似于动态代理的全过程：ProceedingJoinPoint类型的参数可以决定是否执行目标方法
     * 环绕通知必须有返回值，返回值即为目标方法的返回值
     *
     * @param pjd
     */
    @Around("execution(public int com.stuspring.aop.impl.ArithmeticCalculatorImpl.*(..))")
    public Object aroundMethod(ProceedingJoinPoint pjd) {

        Object result = null;
        String methodName = pjd.getSignature().getName();

        try {
            //前置通知
            System.out.println("--->The method " + methodName + " begins with " + Arrays.asList(pjd.getArgs()));
            //执行目标方法
            result = pjd.proceed();
            //后置通知
            System.out.println("--->The method " + methodName + " ends with " + result);

        } catch (Throwable e) {
            //异常通知
            System.out.println("The method "+methodName+" occurs exception : "+e);
        }

        //后置通知
        System.out.println("The Method "+methodName+" ends!");
        return result;
    }

三、指定切面的优先级

切面的优先级可以用@Order注解指定，传入的整数值越小，优先级越高。
这里写图片描述

四、复用切点表达式

   /**
     *  定义一个方法用于声明切入点表达式。一般地，该方法不需要再写其它代码。
     */
    @Pointcut("execution(public int com.stuspring.aop.impl.ArithmeticCalculatorImpl.*(int,int))")
    public void declareJoinPointExpression(){
    }
    /**
     * 前置通知 方法开始之前执行
     * @param joinPoint
     */

    @Before("declareJoinPointExpression()")
    public void beforeMethod(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        List<Object> agrs = Arrays.asList(joinPoint.getArgs());
        System.out.println("The method " + methodName + " begins with " + agrs);
    }

外部类引用可以使用报名加方法名的方法。

五、配置文件方式配置AOP

接口：

package com.stuspring.aop.fileimpl;

/**
 * Created by bee on 17/5/16.
 */
public interface ArithmeticCalculator {
    int add(int i,int j);
    int sub(int i,int j);
    int mul(int i,int j);
    int div(int i,int j);
}

实现类：

package com.stuspring.aop.fileimpl;

/**
 * Created by bee on 17/5/16.
 */
public class ArithmeticCalculatorImpl implements ArithmeticCalculator {
    @Override
    public int add(int i, int j) {
        int result=i+j;
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result=i-j;
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result=i*j;
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result=i/j;
        return result;
    }
}

日志切面：

package com.stuspring.aop.fileimpl;

import org.aspectj.lang.JoinPoint;

/**
 * Created by bee on 17/5/16.
 */
public class LoggingAspect {

    public void beforeMethod(JoinPoint joinPoint){
        String methodName=joinPoint.getSignature().getName();
        System.out.println("The method begins with "+methodName);
    }
}

参数验证切面：

package com.stuspring.aop.fileimpl;

import org.aspectj.lang.JoinPoint;

/**
 * Created by bee on 17/5/16.
 */
public class ValidationAspect {

    public void validateArgs(JoinPoint joinPoint){
        System.out.println("validationMethod......");
    }
}

Spring配置文件：

<?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
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

    <!--配置bean-->
    <bean id="arithmeticCalculator" class="com.stuspring.aop.fileimpl.ArithmeticCalculatorImpl"/>
    <bean id="loggingAspect" class="com.stuspring.aop.fileimpl.LoggingAspect"/>
    <bean id="validationAspect" class="com.stuspring.aop.fileimpl.ValidationAspect"/>

    <aop:config>
        <!--配置切面表达式-->
        <aop:pointcut id="pointcut" expression="execution(public int com.stuspring.aop.fileimpl.ArithmeticCalculatorImpl.*(int,int))"/>
        <!--配置切面通知-->
        <aop:aspect ref="loggingAspect" order="2">
            <aop:before method="beforeMethod" pointcut-ref="pointcut"/>
        </aop:aspect>

        <aop:aspect ref="validationAspect" order="1">
            <aop:before method="validateArgs" pointcut-ref="pointcut"/>
        </aop:aspect>

    </aop:config>
</beans>

Main测试方法：

package com.stuspring.aop.fileimpl;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by bee on 17/5/16.
 */
public class Main {

    public static void main(String[] args) {
        ApplicationContext ctx=new ClassPathXmlApplicationContext("beans-aspectfile.xml");
        ArithmeticCalculator calculator= (ArithmeticCalculator) ctx.getBean("arithmeticCalculator");
        System.out.println(calculator.add(2,4));
    }
}
文章标签：
Spring
Java
关键词：
Spring AOP
Spring类型
Spring aop aspectj
Spring AspectJ
aop aspectj
姚攀
目录
相关文章
互联网课堂
|
1月前
|
XML Java 数据安全/隐私保护
Spring Aop该如何使用
本文介绍了AOP（面向切面编程）的基本概念和术语，并通过具体业务场景演示了如何在Spring框架中使用Spring AOP。文章详细解释了切面、连接点、通知、切点等关键术语，并提供了完整的示例代码，帮助读者轻松理解和应用Spring AOP。
互联网课堂
53 2
Spring Aop该如何使用
一位隐者
|
20天前
|
监控 安全 Java
什么是AOP？如何与Spring Boot一起使用？
什么是AOP？如何与Spring Boot一起使用？
一位隐者
46 5
潇洒洒
|
25天前
|
Java 开发者 Spring
深入解析：Spring AOP的底层实现机制
在现代软件开发中，Spring框架的AOP（面向切面编程）功能因其能够有效分离横切关注点（如日志记录、事务管理等）而备受青睐。本文将深入探讨Spring AOP的底层原理，揭示其如何通过动态代理技术实现方法的增强。
潇洒洒
52 8
砖业洋__
|
1月前
|
Java 开发者 Spring
Spring高手之路24——事务类型及传播行为实战指南
本篇文章深入探讨了Spring中的事务管理，特别是事务传播行为（如REQUIRES_NEW和NESTED）的应用与区别。通过详实的示例和优化的时序图，全面解析如何在实际项目中使用这些高级事务控制技巧，以提升开发者的Spring事务管理能力。
砖业洋__
52 1
Spring高手之路24——事务类型及传播行为实战指南
游客fmoyiwnvddywe
|
25天前
|
Java 开发者 Spring
Spring AOP 底层原理技术分享
Spring AOP（面向切面编程）是Spring框架中一个强大的功能，它允许开发者在不修改业务逻辑代码的情况下，增加额外的功能，如日志记录、事务管理等。本文将深入探讨Spring AOP的底层原理，包括其核心概念、实现方式以及如何与Spring框架协同工作。
游客fmoyiwnvddywe
62 6
张志凌
|
25天前
|
XML 监控 安全
深入调查研究Spring AOP
【11月更文挑战第15天】
张志凌
36 5
最好zzz
|
25天前
|
Java 开发者 Spring
Spring AOP深度解析：探秘动态代理与增强逻辑
Spring框架中的AOP（Aspect-Oriented Programming，面向切面编程）功能为开发者提供了一种强大的工具，用以将横切关注点（如日志、事务管理等）与业务逻辑分离。本文将深入探讨Spring AOP的底层原理，包括动态代理机制和增强逻辑的实现。
最好zzz
35 4
砖业洋__
|
2月前
|
存储 缓存 Java
Spring高手之路23——AOP触发机制与代理逻辑的执行
本篇文章深入解析了Spring AOP代理的触发机制和执行流程，从源码角度详细讲解了Bean如何被AOP代理，包括代理对象的创建、配置与执行逻辑，帮助读者全面掌握Spring AOP的核心技术。
砖业洋__
48 3
Spring高手之路23——AOP触发机制与代理逻辑的执行
进步`于辰
|
1月前
|
Java Spring
[Spring]aop的配置与使用
本文介绍了AOP（面向切面编程）的基本概念和核心思想。AOP是Spring框架的核心功能之一，通过动态代理在不修改原代码的情况下注入新功能。文章详细解释了连接点、切入点、通知、切面等关键概念，并列举了前置通知、后置通知、最终通知、异常通知和环绕通知五种通知类型。
进步`于辰
37 1
蓝易云
|
1月前
|
安全 Java 测试技术
Java开发必读，谈谈对Spring IOC与AOP的理解
Spring的IOC和AOP机制通过依赖注入和横切关注点的分离，大大提高了代码的模块化和可维护性。IOC使得对象的创建和管理变得灵活可控，降低了对象之间的耦合度；AOP则通过动态代理机制实现了横切关注点的集中管理，减少了重复代码。理解和掌握这两个核心概念，是高效使用Spring框架的关键。希望本文对你深入理解Spring的IOC和AOP有所帮助。
蓝易云
39 0

热门文章

最新文章

  • 1
    Spring AOP 详细深入讲解+代码示例
  • 2
    非侵入式AOP监控之——AspectJ使用
  • 3
    一起谈.NET技术，IoC+AOP的简单实现
  • 4
    AOP动态代理解析4-jdk代理的实现
  • 5
    Spring AOP不拦截从对象内部调用的方法原因
  • 6
    利用Spring的AOP来配置和管理你的二级缓存(EHCache)
  • 7
    spring.net aop 讲解
  • 8
    PostSharp AOP编程：3.PostSharp的LocationInterceptionAspect类基本组成
  • 9
    spring aop 多数据源
  • 10
    MSBuild + MSILInect实现编译时AOP之预览
  • 1
    Spring高手之路18——从XML配置角度理解Spring AOP
    95
  • 2
    Spring Boot中一般如何使用线程池？
    753
  • 3
    Spring Boot 源码面试知识点
    101
  • 4
    【MongoDB 专栏】MongoDB 与 Spring Boot 的集成实践
    253
  • 5
    深入探索Spring Boot Web应用源码及实战应用
    105
  • 6
    ruoyi-nbcio从spring2.7.18升级springboot到3.1.7，java从java8升级到17（二）
    350
  • 7
    springboot全局自定义异常
    44
  • 8
    RabbitMQ的springboot项目集成使用-01
    147
  • 9
    什么是Spring Boot 自动配置？
    60
  • 10
    Spring cloud原理详解
    79

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第二阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 相关实验场景

    更多
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    DataWorks