Spring AOP实现方式

最新推荐文章于 2024-10-08 09:00:00 发布
最新推荐文章于 2024-10-08 09:00:00 发布
阅读量133 收藏
点赞数 1
文章标签： spring aop xml java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43198844/article/details/116271710
版权
本文详细介绍了Spring AOP的三种实现方式：XML结合接口、XML自定义类以及注解方式。通过具体代码示例展示了如何配置切点、通知，并在实际应用中进行测试。同时强调了使用注解时必须配置<aop:aspectj-autoproxy/>以启用AOP。
摘要由CSDN通过智能技术生成

Spring AOP实现方式

  1. XML+接口方式开启
  2. XML+自定义类方式实现
  3. 注解方式开启

引入依赖：（虽然该项目不是springboot项目，但是只需引入下面一个依赖即可）

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-aop</artifactId>
  <version>2.4.4</version>
</dependency>

①XML+接口方式开启（spring API）

我们首先要了解一下我们都有哪些接口可以实现：

springAPI接口

第一步我们先配置好类包括切面类和要切入的类

切面类：(包括切入时间和切入内容)

package com.offcn.aop;

import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
/**
 * method:切入点方法名
 * args：切入点方法参数
 * target：切入点方法所在类对象
 */
//实现前置通知类接口，在切入点方法执行前先执行前置通知
public class AopBefore implements MethodBeforeAdvice {
  @Override
  public void before(Method method, Object[] args, Object target) throws Throwable {
    System.out.println("前置通知..........");
  }
}

package com.offcn.aop;

import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
/**
 *  returnValue:切入点方法返回值
 *  method:切入点的方法名
 *  args:切点方法参数
 *  target:切点方法所在类的对象
 */
//实现后置通知类接口，在切入点方法执行后还要执行后置通知
public class AopAfterReturning implements AfterReturningAdvice { 
  @Override
  public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
    System.out.println("后置通知.......");
  }
}

切入目标类：

package com.offcn.service;
public class UserService {
  public void add(){
    System.out.println("增加了一个用户...");
  }
}

其次在xml文件中引入aop约束并注册bean，以下两种方法任选其一即可：

<?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/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <bean id="userService" class="com.offcn.service.UserService"></bean>
    <bean id="aopAfter" class="com.offcn.aop.AopAfterReturning"></bean>
    <bean id="aopBefore" class="com.offcn.aop.AopBefore"></bean>
    
</beans>

如果嫌每个类都要配置bean麻烦可以通过在每个类上添加注解@Component，然后在配置文件中添加扫描包即可：


<?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/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    
   <context:component-scan base-package="com.offcn"></context:component-scan>
    <!--这样nbcb包下每个有注解的类都会注册到容器当中——>
</beans>

注册完成之后，需要通过标签<aop:config ></aop:config >来定义切面，切点。在bean下面开启AOP。

  • 配置切点名字id：pointcut（名字随意取），切点位置表达式expression：execution(* com.offcn.service.UserService.*(…)) 意思为UserService包下所有方法都是切入点，如果只想切入特定方法，只需把 * 号替换成相应的方法即可。(…)表示所有方法的参数不定，可以没有可以有多个。
  • 配置通知：接下来我们就要配置切面，切点映射关系，即告诉切面切入的位置是哪。
  <aop:config>
      	<!-- 配置切点即切入位置在哪里，可以配置多个切点只需id不同即可-->
        <aop:pointcut id="pointcut" expression="execution(* com.xxx.service.UserService.*(..))"/>
        
        <!--
        <aop:pointcut id="pointcut1" expression="execution(* com.xxx.service.xxx.*(..))"/>
        <aop:pointcut id="pointcut2" expression="execution(* com.xxx.service.xxx.*(..))"/>
        -->
        
        <!--配置切面，切点映射关系，告诉每个切面的切入位置分别是什么-->
        <aop:advisor advice-ref="aopAfter" pointcut-ref="pointcut"></aop:advisor>
        <aop:advisor advice-ref="aopBefore" pointcut-ref="pointcut"></aop:advisor>
      
  </aop:config>

测试

package com.offcn.main;

import com.offcn.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
  public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.add();
  }
}

结果：

注意

这里有一个问题要注意，假设上面说的UserService不是一个类，而是一个接口，我们把他的实现类注册到spring容器中，那么我们调用context.getBean（）方法时，第二个参数不能写成实现类的class，只能写接口的class。

public interface UserService {
  public void add(); 
}

public class UserServiceImpl implements UserService{
  @Override
  public void add() {
    System.out.println("增加了一个用户........");
  }
}

 <bean id="userServiceImpl" class="com.offcn.service.UserServiceImpl"></bean>

正确写法：

    ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
    UserService userService = context.getBean("userServiceImpl", UserService.class);
    userService.add();
    //或者我们不写第二个参数直接强转
    //ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
    //UserService userService = (UserService)context.getBean("userServiceImpl");
    //serviceImpl.add();

错误写法：

    ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
    UserServiceImpl serviceImpl = context.getBean("userServiceImpl", UserServiceImpl.class);
    serviceImpl.add();

报错：

报错

错误原因为spring动态代理，代理的是接口！

②XML+自定义类方式实现

第一种方式我们采用spring自带的API接口，如果要实现某种通知我们还需记住相应的接口并且一个接口只能实现一种通知，多种通知我们要多种实现类来完成，略嫌麻烦。第二种就允许我们可以自定类和方法来实现通知。

首先配置文件注册bean：

<?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/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <bean id="userServiceImpl" class="com.offcn.service.UserServiceImpl"></bean>
    <!--注册bean时我们只需把切面类注册进来即可-->
    <bean id="myAdvice" class="com.offcn.aop.MyAdvice"></bean>
    
    
</beans>

public class UserServiceImpl implements UserService{
  @Override
  public void add() {
    System.out.println("增加了一个用户........");
  }
}

自定义切面类，包含各种通知方法：

public class MyAdvice {

  public void before(){
    System.out.println("前置通知.....");
  }

  public void after(){
    System.out.println("后置通知.....");
  }

  public void throwing(){
    System.out.println("异常通知.....");
  }

}

配置AOP：

<aop:config>
         <!--先配置切点 确定切入位置-->
        <aop:pointcut id="pointcut" expression="execution(* com.offcn.service.UserServiceImpl.*(..))"/>
         <!--配置自定义切面类映射-->
        <aop:aspect  ref="myAdvice">
         <!--配置切面类中切点映射关系-->
            <aop:before method="before" pointcut-ref="pointcut"></aop:before>
            <aop:after-returning method="after" pointcut-ref="pointcut"></aop:after-returning>
            <aop:after-throwing method="throwing" pointcut-ref="pointcut"></aop:after-throwing>
          </aop:aspect>
    </aop:config>

测试

package com.offcn.main;

import com.offcn.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
  public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.add();
  }
}

结果：

注意：

  • 异常通知只有在方法发生异常时才会通知，其他时候不产生作用。

  • 在使用环绕通知时，必须在方法中添加参数ProceedingJoinPoint并且调用proceed方法，切入点的方法即userService.add()才能运行，不然切入点方法不会运行，请自行测试：

public void around(ProceedingJoinPoint pjp){
    System.out.println("环绕通知1.....");
    try {
      pjp.proceed();
    } catch (Throwable throwable) {
      throwable.printStackTrace();
    }
    System.out.println("环绕通知2.....");
  }
  • <aop:after >和<aop:after-returning >区别：
    after无论是否发生异常，都会通知。
    after-returning只有在不发生异常时才会有作用。

③注解方式开启AOP（常用）

以上两种方法都要在配置文件中注入映射关系才能起作用，稍显繁琐。通过注解的方式，我们就可以从配置文件中解脱出来。常用注解有以下几种：

常用注解

首先我们还是注册bean，通过注解的方式我们选择第二种即扫描包的形式注册：

<?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/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
   
    <context:component-scan base-package="com.offcn"></context:component-scan>
    <!--通过<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@Aspect切面的bean创建代理，织入切面。如果要通过注解方式启动aop，必须写上，否则      切面不会生效-->
    <aop:aspectj-autoproxy/>
</beans>

接下来我们需要在切入点类上添加注解@Component：

@Component
public class UserServiceImpl implements UserService{

  @Override
  public void add() {
    System.out.println("增加了一个用户........");
  }

}

切面类除了@Component外还需要添加注解@Aspect：

package com.offcn.aop;

import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class MyAdviceComponent {
    
  //使用 @Pointcut注解声明切点表达式,避免频繁使用表达式。否则必须在每个注解上面标明切点表达式！
  @Pointcut(value = "execution(* com.offcn.service.UserServiceImpl.*(..))")
  public void qiedian(){};

  @Before("qiedian()")
  public void before(){
    System.out.println("前置通知.....");
  }

  @AfterReturning("qiedian()")
  public void afterReturning(){
    System.out.println("后置返回通知.....");
  }

}

测试

package com.offcn.main;

import com.offcn.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
  public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
     //使用注解方式注册bean，getBean时只需把要注入的类的首字母小写，其他不变即可取得该类对象
    UserService service = (UserService)context.getBean("userServiceImpl");
    service.add();
  }
}

结果：

image.png

注意

使用注解时必须在配置文件中标明<aop:aspectj-autoproxy/ >，否则注解不起作用！除非该项目是springboot项目，那么就不需要写了！

以上就是我对spring aop的总结，欢迎您的纠正。如果能帮到你，请给我点一个赞。

月色真美日记
关注
Spring AOP 实现方式与应用
流楚丶格念的博客
08-24 1692
AOP（Aspect Oriented Programming）是面向切面编程，它是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。所谓切面，相当于应用对象间的横切点，我们可以将其单独抽象为独立的模块。连接点（join point）：对应的是具体被拦截的对象，因为Spring只能支持方法，所以被拦截的对象往往就是指特定的方法，AOP将通过动态代理技术把它织入对应的流程中。切点（point cut）：有时候，我们的切面不单单应用于
Spring Aop的简单实现
09-12
一个基于配置文件的Spring AOP的实现。实现了前置通知，后置通知，以及拦截器的功能，配置中有详细的注释。
spring AOP的实现原理
weixin_30340775的博客
06-26 208
姓名：陈中娇 班级：软件151 基于代理(Proxy)的AOP实现 首先，这是一种基于代理(Proxy)的实现方式。下面这张图很好地表达了这层关系： 这张图反映了参与到AOP过程中的几个关键组件(以@Before Advice为例)： 调用者Beans - 即调用发起者，它只知道目标方法所在Bean，并不清楚代理以及Advice的存在 目标方法所在Bean - 被调...
Spring AOP
最新发布
m0_74209411的博客
10-08 863
介绍了Spring AOP的核心概念：切点、通知、切面、 连接点等，介绍了切点的表达式：@annotation 以及 execution ，介绍了 通知的类型以及作用。以及在不同切面下的优先级确定
Spring学习总结（三）——Spring实现AOP的多种方式
weixin_30561177的博客
08-04 697
AOP（Aspect Oriented Programming）面向切面编程，通过预编译方式和运行期动态代理实现程序功能的横向多模块统一控制的一种技术。AOP是OOP的补充，是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。AOP可以分为静态织入与动态织入，静态织入即在编译前将...
Spring AOP实现原理
武汉红喜
06-27 389
  AOP的实现者 AOP工具的设计目标是把横切的问题（如性能监视、事务管理）模块化。使用类似于OOP的方式进行切面的编程工作。位于AOP工具核心的是连接点模型，它提供了一种机制，可以识别出在哪里发生了横切。 AspectJ AspectJ是语言级的AOP实现，2001年由Xerox PARC的AOP小组发布。AspectJ扩展了Java语言，定义了AOP语法，能够在编译器提供横切代码的织...
Spring实现AOP的4种方式
08-27 2414
Spring实现AOP的4种方式
springAOP的三种实现方式示例代码
08-18
Spring AOP 三种实现方式示例代码 Spring AOP（Aspect-Oriented Programming）是 Spring 框架中的一种面向方面编程技术，主要用于解决横切关注点的问题。AOP 的主要思想是将横切逻辑代码从业务逻辑代码中分离出来，...
spring aop实现原理
03-15
NULL 博文链接：https://zhang-yingjie-qq-com.iteye.com/blog/319927
spring aop实现用户权限管理的示例
08-28
本篇文章主要介绍了使用 Spring AOP 实现用户权限管理的示例，通过 AOP 方式来实现权限管理，可以降低项目后期开发的可扩展性和代码重复率。 知识点一：AOP 在实际项目中的应用场景 AOP（Aspect-Oriented ...
Spring AOP实现机制
08-02
Spring AOP的实现机制中文版，动态代理及原理，自定义类加载器
spring aop
07-17
spring aop spring aop spring aop
Spring AOP的实现
u011993094的博客
06-20 188
Spring AOP的实现1， 前言2，AOP联盟定义2.1 Advice通知2.2 Pointcut切点2.3 Advisor通知器3，建立AopProxy代理对象4，常见问题 -引用 1， 前言 好雨知时节，润物细无声 ------杜浦 Aspect是一种模块化机制，描述分散在对象、类或函数中的横切关注点(crosscutting concern)。分离关注点使解决特定领域问题的代码从业务逻辑【不再有】中独立出来，这样分散在整个应用程序中的变动就可以很好地管理起来-----维基百科 2，AOP联
springAOP的简单实现
humian151的博客
02-09 320
面向方面编程 (AOP) 提供从另一个角度来考虑程序结构以完善面向对象编程（OOP）。面向对象将应用程序分解成 各个层次的对象，而AOP将程序分解成各个方面 或者说 关注点 。这使得可以模块化诸如事务管理等这些横切多个对象的关注点。(这些关注点术语称作横切关注点。) 我们通过一个简单的实例来先进入spring的aop，面向方面（面向切面）编程 编写接口类Foo public interface Fo
Spring AOP具体实现
iceyung的专栏
03-14 1433
认识一下AOP 学习Spring的时候，我们都知道其两大特性一个是IOC，一个是AOP，中文名称分别为控制反转和面向切面。控制反转的含义我们大致能理解，面向切面比较抽象，只听说过面向对象OOP，AOP的作用是什么呢？ 引文1和2 3进行了详细的理论和实践解释，本文主要通过引文中的内容，完成从项目创建到AOP实现测试整个过程，可参看参考文献后，再具体的查看本文的完整实现代码。 构建Springboo...
SpringAOP简单实现（三种实现方式）
weixin_60785926的博客
04-03 2931
AOP的三种实现方式
Spring AOP 的实现过程
进击的豌豆的博客
07-14 3903
原文：Spring AOP 的实现过程aop 的作用是在书写上将辅助业务逻辑从主业务的逻辑中拆出来，实现主业务和辅助业务的，但在执行主业务逻辑的时候，辅助业逻辑业也会执行。从而保证拆前拆后功能不变。那辅助业务拆出来放在哪里？辅助业务封装在切面中，所以 。什么是切面？切面就是一个类，并且被 注释。辅助业务在切面的哪里？辅助业务封装在切面的方法里，不同的方法封装不同的辅助业务逻辑。切面中的方法是怎么触发的呢？给封装辅助业务逻辑所在的方法标注 其中一个或几个注解。这样当主业务方法执行时，辅助业务的逻辑所在的方法就
SpringAop 实现记录操作日志
fchen521的博客
12-03 2119
SpringAop 实现记录操作日志
Spring AOP 实现方式详解
"本文总结了Spring AOP的几种实现方式，包括核心概念的解析以及具体的实现技术，如Java动态代理和AspectJ编织等。" 在软件开发中，Spring AOP（面向切面编程）是一种强大的工具，它允许程序员将关注点分离，使代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值