Spring中使用AOP的几种方式

最新推荐文章于 2024-06-08 13:54:29 发布
最新推荐文章于 2024-06-08 13:54:29 发布
阅读量868 收藏 4
点赞数 1
分类专栏： 后端开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42078760/article/details/106772875
版权

在Spring中使用AOP进行切面编程主要有以下几种方式：

  1. XML配置
  2. XML+注解
  3. 纯注解

XML配置

新建实体类XmlAopBean及切片类XmlAopService

实体类XmlAopBean

package XmlAopBean;

import java.text.MessageFormat;

public class XmlAopBean {

    public void runWithoutArgs() {
        System.out.println("这是无参方法。");
    }

    public void runWithArgs(Integer arg) {
        Integer i=1/arg;
        System.out.println(MessageFormat.format("这是有参方法，参数：{0}", arg));
    }
}

AOP类XmlAopService

package XmlAopBean;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

import java.text.MessageFormat;

public class XmlAopService {

    public void doBefore(JoinPoint joinPoint) {
        System.out.println(MessageFormat.format("前置通知参数：{0}", joinPoint.getArgs()));
    }

    public void doAfter(JoinPoint joinPoint) {
        System.out.println(MessageFormat.format("后置通知方法：{0}", joinPoint.getSignature()));
    }

    public void doEnd(JoinPoint joinPoint) {
        System.out.println(MessageFormat.format("最终通知目标类：{0}", joinPoint.getTarget()));
    }

    public void doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println(MessageFormat.format("前环绕通知代码位置：{0}", proceedingJoinPoint.getSourceLocation()));
        proceedingJoinPoint.proceed();
        System.out.println(MessageFormat.format("后环绕通知执行类型：{0}", proceedingJoinPoint.getKind()));
    }
    
    public void doAfterThrow(JoinPoint joinPoint){
        System.out.println(MessageFormat.format("异常通知{0}", joinPoint.getThis()));
    }
}

JoinPoint ：获取切入点方法的相关信息

ProceedingJoinPoint ：环绕通知内切入点方法占位

xmlAopBean.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns="http://www.springframework.org/schema/beans"
       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.0.xsd"
>

    <bean class="XmlAopBean.XmlAopBean" id="xmlAopBean"/>
    <bean class="XmlAopBean.XmlAopService" id="xmlAopService"/>

    <aop:config>
        <aop:pointcut id="xmlAopPointCut" expression="execution(void XmlAopBean.XmlAopBean.*(..))"/>

        <aop:aspect ref="xmlAopService">
            <aop:before method="doBefore" pointcut-ref="xmlAopPointCut"/>
            <aop:after method="doAfter" pointcut-ref="xmlAopPointCut"/>
            <aop:after-returning method="doEnd" pointcut-ref="xmlAopPointCut"/>
            <aop:around method="doAround" pointcut-ref="xmlAopPointCut"/>
        </aop:aspect>
    </aop:config>

</beans>
导入依赖
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.14</version>
        </dependency>
引入约束
       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"
配置AOP
<aop:config>
        <aop:pointcut id="xmlAopPointCut" expression="execution(void XmlAopBean.XmlAopBean.*(..))"/>

        <aop:aspect ref="xmlAopService">
            <aop:before method="doBefore" pointcut-ref="xmlAopPointCut"/>
            <aop:after method="doAfter" pointcut-ref="xmlAopPointCut"/>
            <aop:after-returning method="doEnd" pointcut-ref="xmlAopPointCut"/>
            <aop:around method="doAround" pointcut-ref="xmlAopPointCut"/>
        </aop:aspect>
    </aop:config>

单元测试

import AnnotationAopBean.AnnotationAopBean;
import XmlAopBean.XmlAopBean;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {BaseConfig.class})
public class AOPBeanTest {

    ...

    @Test
    public void xmlAopBeanTest() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("xmlAopBean.xml");

        XmlAopBean xmlAopBean = applicationContext.getBean("xmlAopBean", XmlAopBean.class);

        xmlAopBean.runWithArgs(1);
        xmlAopBean.runWithoutArgs();
    }
}

输出结果

前置通知参数：1
前环绕通知代码位置：org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint$SourceLocationImpl@6d5620ce
这是有参方法，参数：1
后环绕通知执行类型：method-execution
最终通知目标类：XmlAopBean.XmlAopBean@60db1c0e
后置通知方法：void XmlAopBean.XmlAopBean.runWithArgs(Integer)
前置通知参数：{0}
前环绕通知代码位置：org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint$SourceLocationImpl@18f8cd79
这是无参方法。
后环绕通知执行类型：method-execution
最终通知目标类：XmlAopBean.XmlAopBean@60db1c0e
后置通知方法：void XmlAopBean.XmlAopBean.runWithoutArgs()

XML+注解

新建实体类XmlAnnotationAopBean和AOP类XmlAnnotationAopService

实体类XmlAnnotationAopBean

package XmlAnnotationAopBean;

import org.springframework.stereotype.Component;

import java.text.MessageFormat;

@Component
public class XmlAnnotationAopBean {

    public void runWithoutArgs() {
        System.out.println("这是无参方法。");
    }

    public void runWithArgs(Integer arg) {
        Integer i = 1 / arg;
        System.out.println(MessageFormat.format("这是有参方法，参数：{0}", arg));
    }
}

AOP类XmlAnnotationAopService

package XmlAnnotationAopBean;

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

import java.text.MessageFormat;

@Component
@Aspect
public class XmlAnnotationAopService {

    @Pointcut("execution(void XmlAnnotationAopBean.*(..))")
    public void pointCut() {
    }

    @Before("pointCut()")
    public void doBefore(JoinPoint joinPoint) {
        System.out.println(MessageFormat.format("前置通知参数：{0}", joinPoint.getArgs()));
    }

    @After("pointCut()")
    public void doAfter(JoinPoint joinPoint) {
        System.out.println(MessageFormat.format("后置通知方法：{0}", joinPoint.getSignature()));
    }

    @AfterReturning("pointCut()")
    public void doEnd(JoinPoint joinPoint) {
        System.out.println(MessageFormat.format("最终通知目标类：{0}", joinPoint.getTarget()));
    }

    @Around("pointCut()")
    public void doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println(MessageFormat.format("前环绕通知代码位置：{0}", proceedingJoinPoint.getSourceLocation()));
        proceedingJoinPoint.proceed();
        System.out.println(MessageFormat.format("后环绕通知执行类型：{0}", proceedingJoinPoint.getKind()));
    }
    
    @AfterThrowing("pointCut()")
    public void doAfterThrow(JoinPoint joinPoint){
        System.out.println(MessageFormat.format("异常通知{0}", joinPoint.getThis()));
    }
}

@Aspect：指定为切面类

XmlAnnotationAopBean.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns="http://www.springframework.org/schema/beans" xmlns:context="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/aop
       http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"
>

    <context:component-scan base-package="XmlAnnotationAopBean"/>
    <aop:aspectj-autoproxy/>

</beans>

aop:aspectj-autoproxy/：开启自动AOP代理

单元测试

import XmlAnnotationAopBean.XmlAnnotationAopBean;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:XmlAnnotationAopBean.xml")
public class XmlAnnotationAopBeanTest {
    @Autowired
    private XmlAnnotationAopBean xmlAnnotationAopBean;

    @Test
    public void xmlAnnotationAopBeanTest() {
        xmlAnnotationAopBean.runWithArgs(1);
        xmlAnnotationAopBean.runWithoutArgs();
    }
}

输出结果

前环绕通知代码位置：org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint$SourceLocationImpl@5965d37
前置通知参数：1
这是有参方法，参数：1
后环绕通知执行类型：method-execution
后置通知方法：void XmlAnnotationAopBean.XmlAnnotationAopBean.runWithArgs(Integer)
最终通知目标类：XmlAnnotationAopBean.XmlAnnotationAopBean@38467116
前环绕通知代码位置：org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint$SourceLocationImpl@5b7a7f33
前置通知参数：{0}
这是无参方法。
后环绕通知执行类型：method-execution
后置通知方法：void XmlAnnotationAopBean.XmlAnnotationAopBean.runWithoutArgs()
最终通知目标类：XmlAnnotationAopBean.XmlAnnotationAopBean@38467116

纯注解

新建配置注解类BaseConfig、实体类AnnotationAopBean和AOP类AnnotationAopService

注解配置BaseConfig

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan(basePackages = "AnnotationAopBean")
@EnableAspectJAutoProxy
public class BaseConfig {
}

@EnableAspectJAutoProxy：开启自动AOP代理

实体类AnnotationAopBean

package AnnotationAopBean;

import org.springframework.stereotype.Component;

import java.text.MessageFormat;

@Component
public class AnnotationAopBean {

    public void runWithoutArgs() {
        System.out.println("这是无参方法。");
    }

    public void runWithArgs(Integer arg) {
        Integer i = 1 / arg;
        System.out.println(MessageFormat.format("这是有参方法，参数：{0}", arg));
    }
}

AOP类AnnotationAopService

package AnnotationAopBean;

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

import java.text.MessageFormat;

@Component
@Aspect
public class AnnotationAopService {


    @Pointcut("execution(void AnnotationAopBean.*(..))")
    public void pointCut() {
    }

    @Before("pointCut()")
    public void doBefore(JoinPoint joinPoint) {
        System.out.println(MessageFormat.format("前置通知参数：{0}", joinPoint.getArgs()));
    }

    @After("pointCut()")
    public void doAfter(JoinPoint joinPoint) {
        System.out.println(MessageFormat.format("后置通知方法：{0}", joinPoint.getSignature()));
    }

    @AfterReturning("pointCut()")
    public void doEnd(JoinPoint joinPoint) {
        System.out.println(MessageFormat.format("最终通知目标类：{0}", joinPoint.getTarget()));
    }

    @Around("pointCut()")
    public void doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println(MessageFormat.format("前环绕通知代码位置：{0}", proceedingJoinPoint.getSourceLocation()));
        proceedingJoinPoint.proceed();
        System.out.println(MessageFormat.format("后环绕通知执行类型：{0}", proceedingJoinPoint.getKind()));
    }
    
    @AfterThrowing("pointCut()")
    public void doAfterThrow(JoinPoint joinPoint){
        System.out.println(MessageFormat.format("异常通知{0}", joinPoint.getThis()));
    }
}

单元测试

import AnnotationAopBean.AnnotationAopBean;
import XmlAopBean.XmlAopBean;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {BaseConfig.class})
public class AOPBeanTest {
    @Autowired
    private AnnotationAopBean annotationAopBean;

    @Test
    public void annotationAopBeanTest() {
        annotationAopBean.runWithArgs(1);
        annotationAopBean.runWithoutArgs();
    }
    
    ....
}

输出结果

前环绕通知代码位置：org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint$SourceLocationImpl@5f9edf14
前置通知参数：1
这是有参方法，参数：1
后环绕通知执行类型：method-execution
后置通知方法：void AnnotationAopBean.AnnotationAopBean.runWithArgs(Integer)
最终通知目标类：AnnotationAopBean.AnnotationAopBean@68746f22
前环绕通知代码位置：org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint$SourceLocationImpl@2f01783a
前置通知参数：{0}
这是无参方法。
后环绕通知执行类型：method-execution
后置通知方法：void AnnotationAopBean.AnnotationAopBean.runWithoutArgs()
最终通知目标类：AnnotationAopBean.AnnotationAopBean@68746f22

源码下载

git@github.com:Angryshark128/Practice.git

Cicada128
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring中AOP的使用
Harrison
12-28 111
AOP是面向切面编程。是指通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。简单来讲就是不改变原来业务代码的情况下给程序动态的添加功能的一种技术。例如通过AOP进行 日志记录、异常处理、事务处理等。 引入依赖包：spring-aspects <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId>
Spring AOP的几种实现方式总结
08-31
下面我们将深入探讨Spring AOP的核心概念以及几种实现方式。 **核心概念** 1. **横切关注点**：这是在应用程序中的某个特定位置（如数据访问、事务管理等）执行的通用任务。例如，日志记录、性能度量等。 2. **切...
Spring AOP的使用
daijianzhou的专栏
04-19 613
Spring AOP的使用 AOP框架是Spring的关键组件之一，可以通过AOP对项目的权限和日志等进行管理 AOP的相关概念 Aspect：切面，一般以类的形式展示，通过@Aspect实现。 Pointcut：切点，连接点的集合。 Join point：连接点，代表的是一个方法。 Advice：通知，织入到连接点的一段代码。通知包括“环绕”通知、“前置”通知和“后置”通知等。 Target object：目标对象，需要织入的目标。 AOP proxy：AOP 代理，APO代理包括 JDK 动态代理和
SpringAOP 常见应用场景
最新发布
Zyw907155124的博客
06-08 1991
常见应用场景:日志记录、权限检查、事务管理、异常处理、性能监控、缓存、参数校验和转换、API调用统计、SLF4J、Logback、Log4j等日志框架集成、自定义注解的处理。 1、AOP实现 性能监控；2、AOP实现 API调用统计；3、AOP实现 缓存；4、AOP实现自定义滑动窗口限流
在Spring中使用AOP实现日志功能
weixin_34220834的博客
08-29 80
步骤： 1.创建一个动态WEB项目； 2.导入以下十个jar包： com.springsource.net.sf.cglib -2.2.0.jar com.springsource.org.aopalliance-1.0.0 .jar com.springsource.org.aspectj.weaver-1.6.8 .RELEASE.jar com...
Spring 使用AOP
qq_44336097的博客
04-26 224
AOP是Aspect Oriented Programming，即面向切面编程。 那什么是AOP？ 我们先回顾一下OOP：Object Oriented Programming，OOP作为面向对象编程的模式，获得了巨大的成功，OOP的主要功能是数据封装、继承和多态。 而AOP是一种新的编程方式，它和OOP不同，OOP把系统看作多个对象的交互，AOP把系统分解为不同的关注点，或者称之为切面（Aspect）。 要理解AOP的概念，我们先用OOP举例，比如一个业务组件BookService，它有几个业务方法：
详解spring中aop不生效的几种解决办法
08-19
本文将详细介绍Spring中AOP不生效的几种解决办法，希望能够对大家的学习或者工作产生一定的参考价值。 解决办法一：检查AOP配置 在Spring中，AOP的配置是通过xml文件或注解的方式实现的。如果AOP不生效，第一步...
Spring aop失效的几种解决方案
08-19
作为一名IT行业大师，我将从给定的文件中生成相关知识点，主要介绍Spring AOP失效的几种解决方案。 标题解释 Spring AOP失效的几种解决方案是指在使用Spring框架时，Aspect Oriented Programming（面向方面编程）...
使用Spring的注解方式实现AOP实例
08-30
使用Spring的注解方式实现AOP实例的步骤主要包括以下几个方面： 首先，需要导入AspectJ提供的jar包，包括aspectjrt.jar和aspectjweaver.jar等。这些jar包提供了AspectJ框架的核心功能，能够支持AOP的实现。 其次，...
Spring AOP在web应用中的使用方法实例
08-25
在Spring AOP中，有几种不同的方式来配置和使用切面，包括基于XML的声明式配置和基于注解的配置。以下我们将详细探讨基于XML配置的声明式AOP使用方法： 1. **使用ProxyFactoryBean** ProxyFactoryBean是Spring提供...
在spring中如何使用aop
05-01
详细的介绍了在spring中如何使用和配置aop的5种处理器。从注解和配置文件两个方面都进行了介绍。主要从注解的方式进行了介绍
spring--使用AOP的几种方式
fenfeng2012
02-20 297
使用AOP需要的一些概念  1.通知(Advice) 通知定义了在切入点代码执行时间点附近需要做的工作。 Spring支持五种类型的通知： Before(前)  org.apringframework.aop.MethodBeforeAdvice After-returning(返回后) org.springframework.aop.AfterReturningAdvice After...
【深入Spring】Spring使用AOP的几种方式
SmallCatBaby的博客
02-14 107
1.经典的基于代理的AOP [1]前置通知 public class BeforeAdvice implements MethodBeforeAdvice{ @Override public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable { ...
Spring--AOP使用
aruba的博客
05-19 148
Spring的AOP也是基于AspectJ，和安卓中(之前文章：Android--AOP架构设计之使用AspectJ监测方法耗时)使用相比，Spring集成了它，所以配置起来方便很多 一、概念 重新整理下AOP的概念： 术语 描述 连接点 Joint point 增强的方法，也就是我们想要处理的方法。包括：方法，成员变量访问，异常处理程序执行等 切入点 Pointcut 表示...
Spring之AOP
猎户星座
09-04 1388
AOP（Aspect Orient Programming），一般称为面向切面编程，作为面向对象的一种补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、日志、缓存等等。AOP实现的关键在于AOP框架自动创建的AOP代理，AOP代理主要分为静态代理和动态代理，静态代理的代表为AspectJ；而动态代理则以Spring AOP为代表，包括JDK动态代理和CGLIB动态代理。静态代理是编译期...
spring aop使用
cjwdemo的博客
05-26 318
package com.cjwdemo.demoBySpring;import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.cont
SPRING AOP的使用
tianlong1569的专栏
11-15 668
Spring 作为现在最主流的框架，其IoC和AOP为所有开发都提供了非常方便及简单的开发体验。但是很多新手在Spring的使用中，只使用的Spring最基本的IoC功能，其核心的AOP涉及很少。这样就造成了很多人在编写代码时和以前不用框架一样，只是省去了常用的set或get方法。并没有直接用到Spring的核心功能。因此我在这里针对Spring AOP做一个简单的介绍，可以让大家领略Spri
SpringAOP使用
Mr杭的博客
03-13 476
使用SpringAOPAOP是什么？    Aspect Oriented Programming(面向切面编程)：将有共同处理的业务，从传统的业务中抽离出来单独的封装，通过装配(注解)的方式作用于系统。在不修改系统业务逻辑的前提下给系统追加功能。AOP三要素1.切面：追加什么？单独封装的切面代码。2.通知：什么时候追加？前置，后置，异常，最终，环绕。3.切入点：切谁？方法/类型/bean限定表达...
spring的aop有几种声明方式
06-01
Spring的AOP有三种声明方式： 1. 基于XML的声明方式：使用XML文件配置切面、切入点、通知等元素，然后通过配置文件中的<aop:config>元素启用AOP。 2. 基于注解的声明方式：使用@AspectJ注解定义切面、切入点、通知...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值