Spring Aop

最新推荐文章于 2022-08-21 17:11:19 发布
最新推荐文章于 2022-08-21 17:11:19 发布
阅读量633 收藏
点赞数 1
分类专栏： JAVA基础复习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kate2018/article/details/109556962
版权

AOP

Aspect-Oriented Programming面向切面编程,主要编程对象是切面。
好处:
  1. 每个事物逻辑位于一个位置, 代码不分散, 便于维护和升级
  2. 业务模块更简洁, 只包含核心业务代码.
    举例:让编写一个简单的加减乘除功能,但是写好add()、sub（）、mul（）、div四个方法之后,需要添加校验参数的功能、开始的时候显示传入参数的日志、结束了结果的日志，如果每个都加的话，代码就比较冗余，当然只有这三个功能还好，如果继续添加别的功能了就不便于维护。

AOP术语

  1. 切面(Aspect): 横切关注点(跨越应用程序多个模块的功能)被模块化的特殊对象，比如上述提到的校验参数、前置日志、后置日志组合在一起可以成为切面
  2. 通知(Advice):切面必须完成的工作比如上述提到的校验参数、打印前置日志、后置日志这些行为。
  3. 目标(Target):被通知的对象就是上述提到的对应的加减乘除四个方法的类，在动态代理中也可以理解为需要被代理的类
  4. 代理(Proxy):向目标对象应用通知之后创建的对象,在动态代理中为代理类
  5. 连接点（Joinpoint):连接点程序执行的某个特定位置：如类某个方法调用前、调用后、方法抛出异常后等。连接点由两个信息确定：方法表示的程序执行点；相对点表示的方位。例如 计算器类#add() 方法执行前的连接点，执行点为 计算器类#add()； 方位为该方法执行前的位置可以理解为参数校验、前置通知、后置通知的方法
  6. 切点（pointcut）:每个类都拥有多个连接点：例如计算器类的所有方法实际上都是连接点，即连接点是程序类中客观存在的事务。AOP 通过切点定位到特定的连接点。类比：连接点相当于数据库中的记录，切点相当于查询条件。切点和连接点不是一对一的关系，一个切点匹配多个连接点，切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。

AOP XML实现方式

个人理解不是那么到位,如果描述有误,望大佬指点迷津!
  1. 我使用的是maven导入依赖,也可以去Spring官网下载jar包进行使用
<dependencies>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.1.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.1.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.1.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.1.10.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>

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

2.目标对象

/**
 * 计算器加减乘除
 */
public interface Calculator {

    int add(int i, int j);
    int sub(int i, int j);

    int mul(int i, int j);
    int div(int i, int j);

}


public class CalculatorImpl implements Calculator{
    public int add(int i, int j) {
        int result = i + j;
        return result;
    }

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

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

    public int div(int i, int j) {
        int result = i / j;
        return result;
    }
}
  1. 切面类
package com.interview.springxmlaspect.dao;

import org.aspectj.lang.JoinPoint;//跟版本权限有关系
import org.aspectj.lang.ProceedingJoinPoint;

import java.util.Arrays;

/**
 * 切面类
 */
public class LoggingApect {

    /**
     * 前置通知
     */
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("前置:The method " + methodName + " begins with " + Arrays.asList(args));
    }

    /**
     * 返回通知
     */
    public void afterReturning(JoinPoint joinPoint, Object result){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("返回:The method " + methodName + " ends with " + result);
    }

    /**
     * 后置通知
     */
    public void afterMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("后置:The method " + methodName + " ends");
    }

    /**
     * 异常通知
     */
    public void afterThrowing(JoinPoint joinPoint, Exception e){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("异常:The method " + methodName + " occurs excetion:" + e);
    }

    /**
     * 环绕通知
     */

    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);
            throw new RuntimeException(e);
        }
        //后置通知
        System.out.println("后置:The method " + methodName + " ends");
        return result;
    }

}
  1. 配置文件
<?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/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
		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.0.xsd">

        <!--配置目标-->
        <bean id="calculator" class="com.interview.springxmlaspect.dao.CalculatorImpl"></bean>
        <!--配置切面bean-->
        <bean id="loggingApect" class="com.interview.springxmlaspect.dao.LoggingApect"></bean>
        <!--配置aop-->
        <aop:config>
            <!--配置切点表达式-->
            <aop:pointcut id="pointcut" expression="execution(* com.interview.springxmlaspect.dao.CalculatorImpl.*(int,int))"/>
            <!--配置切面及通知-->
            <aop:aspect  ref="loggingApect">
                <aop:before method="beforeMethod" pointcut-ref="pointcut"/>
                <aop:after method="afterMethod" pointcut-ref="pointcut"/>
                <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="e"/>
                <aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/>
                <aop:around method="aroundMethod" pointcut-ref="pointcut"></aop:around>
            </aop:aspect>
        </aop:config>
        <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
</beans>
  1. 测试类
 ApplicationContext context = null;

    public ApplicationContext getApplicationContext(){
        if (context == null) {
            context = new ClassPathXmlApplicationContext("applicationContext.xml");
        }
        return context;
    }

    /**
     * aop xml测试
     */
    @Test
    public void tes1(){
        ApplicationContext context = getApplicationContext();
        CalculatorImpl calculatorImpl=  context.getBean("calculator",CalculatorImpl.class);
        System.out.println(calculatorImpl.getClass().getName());
//        calculatorImpl.add(3,5);
        calculatorImpl.div(1,1);

    }

.

  • 前置通知
    方法执行前执行的方法
  • 后置通知
  •  方法执行完后执行的方法,无论是否发生异常都是执行
  • 返回通知
    没有发生异常才会执行
  • 异常通知
    发生异常执行的方法
  • 环绕通知
    环绕通知类似于包含有前置通知、返回通知、异常通知、后置通知
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);
            throw new RuntimeException(e);
        }
        //后置通知
        System.out.println("后置:The method " + methodName + " ends");
        return result;
    }
kate2018
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
spring boot获取请求url
qq_65125944的博客
07-09 2388
spring boot 实现Filter获取请求url路劲...
Springboot做请求次数统计思路
a15119950653的博客
02-28 1227
Springboot项目做请求次数统计思路
SpringBoot实战（六）自定义注解 + AOP 记录接口访问日志
ACGkaka的博客
04-01 3178
目录一、AOP的简单介绍1. AOP是什么2. AOP能做什么3. 切面执行顺序4. AOP注解二、实战代码1. 依赖引入2. AOP示例3. 定义接口，进行测试4. 源码地址 一、AOP的简单介绍 1. AOP是什么 AOP（Aspect Oriented Programming）–面向切面编程 通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。 实现方式：JDK动态代理、CGLIB代理。前者基于接口，后者基于子类。 2. AOP能做什么 统计接口
Spring Boot AOP 扫盲，实现接口访问的统一日志记录
沉默王二
02-22 7068
AOP 是 Spring 体系中非常重要的两个概念之一（另外一个是 IoC），今天这篇文章就来带大家通过实战的方式，在编程猫 SpringBoot 项目中使用 AOP 技术为 controller 层添加一个切面来实现接口访问的统一日志记录。 一、关于 AOP AOP，也就是 Aspect-oriented Programming，译为面向切面编程，是计算机科学中的一个设计思想，旨在通过切面技术为业务主体增加额外的通知（Advice），从而对声明为“切点”（Pointcut）的代码块进行统一管理和装饰。 这
Springboot AOP实现接口访问次数统计
qq_31236849的博客
04-11 1695
Springboot AOP实现接口访问次数统计
Spring AOP教程
12-07
Spring框架的关键组件之一是面向方面编程(AOP)框架。 面向方面的编程需要将程序逻辑分解成不同的部分。 此教程将通过简单实用的方法来学习Spring框架提供的AOP/面向方面编程。
Spring aop失效的几种解决方案
08-19
Spring AOP失效解决方案详解 作为一名IT行业大师，我将从给定的文件中生成相关知识点，主要介绍Spring AOP失效的几种解决方案。 标题解释 Spring AOP失效的几种解决方案是指在使用Spring框架时，Aspect Oriented ...
spring aop
03-28
Spring AOP，全称为Aspect-Oriented Programming（面向切面编程），是Spring框架的重要组成部分，它为Java应用程序提供了声明式的企业级服务，如事务管理、日志记录等。AOP的核心概念是切面（Aspect）和通知（Advice...
spring aop jar 包
07-26
Spring AOP(Aspect Oriented Programming，面向切面编程)是Spring框架的重要组成部分，它提供了一种在不修改源代码的情况下，对程序进行功能增强的技术。这个"spring aop jar 包"包含了实现这一功能所需的类和接口，...
Spring aop.docx
最新发布
12-14
**Spring AOP 入门** 在深入探讨Spring AOP之前，我们先理解AOP（面向切面编程）的概念。AOP是一种编程范式，旨在减少代码的重复性，提高代码的可维护性和可读性。它通过将关注点（如日志记录、事务管理、安全性等...
实战代码（四）：Springboot AOP实现接口访问次数统计
Smile丶
11-19 3768
一、理论基础 1.1 AOP是什么 AOP（Aspect Oriented Programming）–面向切面编程 可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术 以上介绍来自百度百科-AOP 1.2 AOP能做什么 统计接口访问次数 增强功能：在不改动代码的情况下，为接口增加一些额外的功能 二、实战代码 2.1 依赖引入 <!-- AOP --> <dependency> <groupId>org.aspectj&
SpringBoot使用AOP完成对全局接口访问次数的统计
Devbor的博客
06-09 3893
由于项目中需要统计全局接口访问次数，所以简单使用AOP实现了该功能。
SpringBoot后端统计网站的IP访问次数及地区
zhiwenganyong的博客
08-06 3080
SpringBoot后端统计网站的IP访问次数及地区,其中获取IP地址是用的ip2region，累加IP的访问次数是用redis的incr，后端会提供给前端一个接口当访问网站前端会调这个接口，然后用AOP在接口返回加入逻辑（也可以通过拦截器来拦截接口加入逻辑，但得先解决自动注入为null的问题，注入为null是因为拦截器加载是在springcontext创建之前完成的），先捕获请求获取真实IP,接着封装好消息发给MQ，MQ在进行后续操作。......
Spring boot 自定义注解+AOP
weixin_48913290的博客
08-21 586
作用:在不惊动原始设计的基础上为其进行功能增强，前面咱们有技术就可以实现这样的功能即代理模式。1.通知(Advice)——给目标方法添加额外操作称之为通知，也可以称为增强。2.连接点(Joinpoint)——就是可以增强的地方(方法的前后某个阶段)6.织入(Weaving)——将切面插入到目标从而生成代理对象的过程。然后，我们利用切面，将切入点改成该注解，就实现了，自定义注解的切面。4.切面(Aspect)——封装了通知和切入点用来横向插入的类。5.代理(Proxy)——将通知应用到目标类动态创建的对象。
SpringBoot中自定义注解(aop)实现控制器访问次数限制
weixin_42272558的博客
03-04 917
防止利用恶性URL访问刷爆服务器攻击，利用自定义注解实现这类攻击的防御操作。 1. 自定义注解 @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @Documented //最高优先级 @Order(Ordered.HIGHEST_PRECEDENCE) public @interface RequestLimit { /** * * 允许访问的次数，默认值MAX_VALUE */ int count() d
springboot相同IP限制接口访问次数(AOP事物)
weixin_46063418的博客
04-19 1221
文章转载自：https://blog.csdn.net/befroe_You/article/details/83748927 用于自己学习 应用场景：应项目需求，前后台分离，增强接口安全，限制相同IP访问接口的次数有限 解决：在项目中增加事物，在进接口方法前处理 思路： 1）@Before 在进入接口方法之前进入处理，within里面的书写表示写在控制器上方并且有对应注解的控制器会来到这里。 2）用获取的IP+对应url作为key,存到redis中，如果Redis存在这个key，然后时间处理器在超过设置时
SpringBoot项目AOP+自定义注解实现菜单点击量统计
你那么害怕明天，怎么能过好今天！
09-22 1608
一：在添加aop的依赖 <!-- aop依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 注意：在完成了引入AOP依赖包后，
SpringBoot AOP实现接口次数访问统计
紫芝的博客
09-23 4171
1 理论基础 1.1 AOP是什么 面向切面编程（AOP，Aspect Oriented Programming） 可以通过预编译方式和运行时动态代理，实现在不修改源代码的情况下，给程序动态增强功能的的一种技术 1.2 AOP能做什么 统计接口访问次数 数据库事务处理 增强功能：在不改动源代码的基础上，为接口增加一些额外的功能 2 Demo代码 2.1 引入依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="h
SpringBoot（审计） 统计接口调用次数及成功率
weixin_30412013的博客
10-18 2295
介绍： 　　很多时候会需要提供一些统计记录的，比如某个服务一个月的被调用量、接口的调用次数、成功调用次数等等。 优点： 　　使用AOP+Hendler对业务逻辑代码无侵入，完全解耦。通过spring boot自带的健康检查接口（/health）方便、安全。 注意： 　　数据没有被持久化，只保存在内存中，重启后数据将被重置。可按需自己实现 代码： 　　AOP:在AOP中调用Handl...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值