Spring学习之AspectJ开发

最新推荐文章于 2024-08-03 07:30:00 发布
最新推荐文章于 2024-08-03 07:30:00 发布
阅读量7.5k 收藏 23
点赞数 6
分类专栏： Java EE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43468667/article/details/88831441
版权

        上次我们学习了基于代理类的AOP实现。而新版本的Spring框架，建议使用AspectJ来开发AOP。所以接下来我们学习AspectJ开发AOP。
        AspectJ是一个基于Java语言的AOP框架，它提供了强大的AOP功能。Spring 2.0以后，Spring AOP引入了对AspectJ的支持，并允许直接使用AspectJ进行编程，而Spring自身的AOP API也尽量与AspectJ保持一致。
        使用AspectJ实现AOP有两种方式：一种是基于XML的声明式AspectJ，另一种是基于注解的声明式AspectJ。
        1.基于XML的声明式AspectJ
        基于XML的声明式AspectJ是指通过XML文件来定义切面、切入点及通知，所有的切面、切入点和通知都必须定义在<aop:config>元素内。
        <aop:config>元素及其子元素如下：（红色的为常用的配置元素）

在这里插入图片描述
        Spring配置文件中的<beans>元素可以包含多个<aop:config>，一个<aop:config>元素又可以包含属性和子元素，子元素包括<aop:pointcut>、<aop:advisor>、<aop:aspect>，配置时，这3个子元素必须按照此顺序定义。
        1.1配置切面
         在Spring的配置文件中，配置切面使用的是<aop:aspect>元素，该元素可以将定义好的Spring Bean转换成切面Bean，所以先定义一个普通的Spring Bean。配置<aop:aspect>元素时，通常会指定id和ref两个属性。

属性名称解释
id用来定义该切面的唯一标识名称。
ref用于引用普通的Spring Bean。

        1.2配置切入点
         当<aop:pointcut>元素作为<aop:config>元素的子元素定义时，表示该切入点是全局切入点，它可被多个切面所共享；当<aop:pointcut>元素作为<aop:aspect>元素的子元素时，表示该切入点只对当前切面有效。
         定义<aop:pointcut>元素时，通常会指定id和expression两个属性。

属性名称解释
id用于指定切入点的唯一标识名称。
expression用于指定切入点关联的切入点表达式。

        切入点表达式(举例说明)
在这里插入图片描述

        切入点表达式的基本格式：
在这里插入图片描述

        1.3配置通知
        使用<aop:aspect>的子元素可以配置5种常用通知，这5个子元素不支持使用子元素，但在使用时可以指定一些属性，其常用属性及其描述如下：

属性名称解释
pointcut该属性用于指定一个切入点表达式，Spring将在匹配该表达式的连接点时织入该通知。
pointcut-ref该属性指定一个已经存在的切入点名称，通常pointcut和pointcut-ref两个属性只需要使用其中之一。
method该属性指定一个方法名，指定将切面Bean中的该方法转换为增强处理。
throwing该属性只对<after-throwing>元素有效，用于指定一个形参名，异常通知方法可以通过该形参访问目标方法所抛出的异常。
returning该属性只对<after-returning>元素有效，用于指定一个形参名，后置通知方法可以通过该形参访问目标方法的返回值。

        我们通过案例来演示基于XML的声明式AspectJ的实现过程。
           (1).打开Eclipse，在SpringTest项目的src目录下，创建一个com.example.aspectjxml包，包中创建用户管理接口UserDao接口以及实现类UserDaoImpl类。

package com.example.aspectjxml;

public interface UserDao {
 public void addUser();
 public void delUser();
}

package com.example.aspectjxml;

public class UserDaoImpl implements UserDao{

 @Override
 public void addUser() {
  // TODO Auto-generated method stub
  System.out.println("添加用户");
 }
 
 @Override
 public void delUser() {
  // TODO Auto-generated method stub
  System.out.println("删除用户");
 }
 
}

           (2).在com.example.aspectjxml包，创建切面类MyAspect类。

package com.example.aspectjxml;

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

public class MyAspect {
 //前置通知
 public void myBefore(JoinPoint joinPoint){
  System.out.println("前置通知:"+joinPoint);
  System.out.println("被植入增强处理的目标方法:"+joinPoint.getSignature().getName());
 }
 //后置通知
 public void myAfterReturrning(JoinPoint joinPoint){
  System.out.println("后置通知:"+joinPoint);
  System.out.println("被植入增强处理的目标方法:"+joinPoint.getSignature().getName());
 }
 /*
  * 环绕通知
  * proceedingJoinPoint是JoinPoint子接口，表示可以执行目标方法
  * 1.必须是Object类型的返回值
  * 2.必须接收一个参数，类型为ProceedingJoinPoint
  * 3.必须throws Throwable
  */
 public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
  System.out.println("环绕前通知");
  //执行当前目标方法
  Object obj = proceedingJoinPoint.proceed();
  System.out.println("环绕后通知");
  return obj;
 }
 //异常通知
 public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
  System.out.println("异常通知:"+e.getMessage());
 }
 //最终通知
 public void myAfter(){
  System.out.println("最终通知");
 }
}

           (3).在com.example.aspectjxml包，创建配置文件beans.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"
 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 id="userDao" class="com.example.aspectjxml.UserDaoImpl"></bean>
 <!-- 切面 -->
 <bean id="myAspect" class="com.example.aspectjxml.MyAspect"></bean>
 <aop:config>
  <!-- 配置切面 -->
  <aop:aspect ref="myAspect">
   <!-- 配置切入点 -->
   <aop:pointcut expression="execution(* com.example.aspectjxml.*.*(..))" id="myPointCut"/>
   <!-- 前置通知 -->
   <aop:before method="myBefore" pointcut-ref="myPointCut"/>
   <!-- 后置通知      returning属性：用于设置后置通知的第二个参数的名称，类型是Object -->
   <aop:after-returning method="myAfterReturrning" pointcut-ref="myPointCut" returning="returnVal"/>
   <!-- 环绕通知 -->
   <aop:around method="myAround" pointcut-ref="myPointCut"/>
   <!-- 异常通知：如果没有异常，将不会执行增强
        throwing属性：用于设置通知第二个参数的的名称、类型-->
   <aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e"/>
   <!-- 最终通知 -->
   <aop:after method="myAfter" pointcut-ref="myPointCut"/>
  </aop:aspect>
 </aop:config>
</beans>

           (4).在com.example.aspectjxml包，创建测试类JdkTest类。

package com.example.aspectjxml;

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

public class AspectjxmlTest {
 public static void main(String[] args) {
  ApplicationContext ac =
    new ClassPathXmlApplicationContext("com/example/aspectjxml/beans.xml");
  UserDao userDao = (UserDao) ac.getBean("userDao");
  userDao.addUser();
  System.out.println("--------分割线--------");
  userDao.delUser();
 }
}

           运行结果：

在这里插入图片描述

        2.基于注解的声明式AspectJ
        基于XML的声明式AspectJ存在一些不足，需要在Spring配置文件配置大量的代码信息，为了解决这个问题，AspectJ框架为AOP的实现提供了一套注解。

注解名称解释
@Aspect用来定义一个切面。
@pointcut用于定义切入点表达式。在使用时还需要定义一个包含名字和任意参数的方法签名来表示切入点名称，这个方法签名就是一个返回值为void，且方法体为空的普通方法。
@Before用于定义前置通知，相当于BeforeAdvice。在使用时，通常需要指定一个value属性值，该属性值用于指定一个切入点表达式(可以是已有的切入点，也可以直接定义切入点表达式)。
@AfterReturning用于定义后置通知，相当于AfterReturningAdvice。在使用时可以指定pointcut / value和returning属性，其中pointcut / value这两个属性的作用一样，都用于指定切入点表达式。returning属性值用于表示Advice方法中定义与此同名的形参，该形参可用于访问目标方法的返回值。
@Around用于定义环绕通知，相当于MethodInterceptor。在使用时需要指定一个value属性，该属性用于指定该通知被植入的切入点。
@After-Throwing用于定义异常通知来处理程序中未处理的异常，相当于ThrowAdvice。在使用时可指定pointcut / value和throwing属性。其中pointcut/value用于指定切入点表达式，而throwing属性值用于指定-一个形参名来表示Advice方法中可定义与此同名的形参，该形参可用于访问目标方法抛出的异常。
@After用于定义最终final 通知，不管是否异常，该通知都会执行。使用时需要指定一个value属性，该属性用于指定该通知被植入的切入点。
@DeclareParents用于定义引介通知，相当于IntroductionInterceptor (不要求掌握)。

        我们通过案例来演示基于Annotation的声明式AspectJ的实现过程。
           (1).打开Eclipse，在SpringTest项目的src目录下，创建一个com.example.aspectjannotation包，包中创建用户管理接口UserDao接口以及实现类UserDaoImpl类。

package com.example.aspectjannotation;

public interface UserDao {
 public void addUser();
 public void delUser();
}

package com.example.aspectjannotation;

import org.springframework.stereotype.Repository;

@Repository("userDao")
public class UserDaoImpl implements UserDao{
 @Override
 public void addUser() {
  // TODO Auto-generated method stub
  System.out.println("添加用户");
 }
 
 @Override
 public void delUser() {
  // TODO Auto-generated method stub
  System.out.println("删除用户");
 }
 
}

           (2).在com.example.aspectjannotation包，创建切面类MyAspect类。

package com.example.aspectjannotation;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
//切面类
@Aspect
@Component
public class MyAspect {
 //定义切入点表达式
 @Pointcut("execution(* com.example.aspectjannotation.*.*(..))")
 //定义一个返回值为void、方法体为空的方法来命名切入点
 private void myPointCut(){ 
 
 }
 @Before("myPointCut()")
 public void myBefore(JoinPoint joinpoint){
  System.out.println("前置通知："+joinpoint);
  System.out.println("被植入增强处理的目标方法为："+joinpoint.getSignature().getName());
 }
 @AfterReturning("myPointCut()")
 public void myAfterReturning(JoinPoint joinpoint){
  System.out.println("后置通知："+joinpoint);
  System.out.println(",被植入增强处理的目标方法为："+joinpoint.getSignature().getName());
 }
 @Around("myPointCut()")
 public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
  System.out.println("环绕开始。。。");
  Object obj = proceedingJoinPoint.proceed();
  System.out.println("环绕结束。。。");
  return obj;
 }
 @AfterThrowing(value="myPointCut()",throwing="e")
 public void myAfterThrowing(JoinPoint joinpoint,Throwable e){
  System.out.println("异常通知："+e.getMessage());
 }
 @After("myPointCut()")
 public void myAfter(){
  System.out.println("最终通知");
 }
 
}

           (3).在com.example.aspectjannotation包，创建配置文件beans.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:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
                     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
                     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
  <!-- 指定需要扫描的包，使注解生效 -->                   
 <context:component-scan base-package="com.example.aspectjannotation"></context:component-scan>
 <!-- 启动基于注解的声明式AspectJ支持 -->
 <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

           (4).在com.example.aspectjannotation包，创建测试类JdkTest类。

package com.example.aspectjannotation;

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

public class AspectjannotationTest {
 public static void main(String[] args) {
  ApplicationContext ac = 
    new ClassPathXmlApplicationContext("com/example/aspectjannotation/beans.xml");
  UserDao userDao = (UserDao) ac.getBean("userDao");
  userDao.addUser();
  System.out.println("--------分割线--------");
  userDao.delUser();
 }
 
}

           运行结果：
在这里插入图片描述
           使用注解的方式更加简单、方便，所以，在实际开发中建议使用注解的方式进行AOP开发。
           注意：如果在同一个连接点有多个通知需要执行，那么在同一切面中，目标方法之前的前置通知和环绕通知的执行顺序是未知的，目标方法之后的后置通知和环绕通知的执行顺序是未知的。

           这就是Spring中AspectJ开发，若有错漏，欢迎指正，希望大家一起学习进步！！！！
           如果转载以及CV操作，请务必注明出处，谢谢！

明昕1024
关注
专栏目录
spring——Aspectj
qq_43650773的博客
12-15 1100
spring——Aspectj 1.1 介绍 AspectJ是一个基于Java语言的AOP框架 Spring2.0以后新增了对AspectJ切点表达式支持 @AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面 新版本Spring框架，建议使用AspectJ方式来开发AOP 主要用途：自定义开发 1.2 切入点表达式【掌握】 1.executio...
Spring用AspectJ开发AOP(基于Annotation)
08-25
描述: 主要介绍了Spring用AspectJ开发AOP(基于Annotation)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友可以参考下。 描述中强调了本文的主要内容，即使用AspectJ...
AspectJ在Spring中的使用
weixin_33912638的博客
11-18 321
在上一篇AspectJ的入门中，简单的介绍了下AspectJ的使用，主要是以AspectJ的example作为例子。介绍完后也留下了几个问题：1）我们在spring中并没有看到需要aspectj之类的关键词，而是使用java代码就可以了，这是如何做到的2）Spring中如何做到不使用特殊的编译器实现aop的（AspectJ如何在运行期使用）3）Sprin...
Java中的AOP技术：AspectJ与Spring AOP
最新发布
微赚开发者技术分享博客
08-03 448
大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！这两者是Java领域中实现AOP的主要工具，通过它们可以实现代码的横切关注点（如日志记录、安全检查等）分离，从而提高代码的可维护性和重用性。AOP是一种强大的技术，能够帮助开发者将日志记录、安全检查等横切关注点从业务逻辑中分离出来，简化代码，提升系统的可维护性和扩展性。AspectJ是一个功能强大的AOP框架，它是对Java语言的扩展，允许你定义切面（Aspect）以声明性地指定横切关注点。
spring中AspectJ
hongcaixia的博客
01-27 3975
AspectJ 一、介绍 l AspectJ是一个基于Java语言的AOP框架 l Spring2.0以后新增了对AspectJ切点表达式支持 l @AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面 新版本Spring框架，建议使用AspectJ方式来开发AOP l 主要用途：自定义开发 二、切入点表达式 1....
spring中的aspectJ表达式
linchunhua的专栏
01-15 3464
Spring AOP supports the following AspectJ pointcut designators (PCD) for use in pointcut expressions:   表　达　式 说明 execution 匹配方法执行连接点。我们可以指定包、类或者方法名，以及方法的可见性、返回值和参数类型。这是应
Spring-------AspectJ
qq_32659773的博客
04-22 193
AspectJ简介 AspectJ是一个基于Java语言的AOP框架 Spring2.0以后新增了对AspectJ切点表达式支持 @AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面 新版本Spring框架，建议使用AspectJ方式来开发AOP 主要用途：自定义开发 2.2 切入点表达式【掌握】 execution() 用...
Spring AspectJ的学习一
05-26
**Spring AspectJ 学习详解** 在Java世界中，Spring框架以其强大的依赖注入（DI）和面向切面编程（AOP）能力而闻名。AspectJ是AOP领域的一个强大工具，它扩展了Java语言，允许开发者创建所谓的"切面"，来封装横切...
Spring AOP AspectJ使用及配置过程解析
08-25
新版本的 Spring 框架建议我们都使用 AspectJ 方式来开发 AOP，并提供了非常灵活且强大的切点表达式。当然，无论使用 Spring 自己的 AOP 还是 AspectJ 相关的概念都是相同的。 AspectJ 配置依赖 AspectJ 配置...
spring源码导入所需aspectj包
09-14
7. **使用`spring源码导入.txt`**：这个文件可能是Spring源码导入的指南或说明，具体内容可能包括如何获取和导入Spring的源码到开发环境中，以便于调试和学习Spring的内部工作原理。 通过以上步骤，你可以在Spring...
Spring AOP + AspectJ annotation example
04-03
总结来说，Spring AOP与AspectJ注解的结合使用是Java开发中的强大工具，它们提供了一种优雅的方式来管理横切关注点，提高了代码的可读性和可维护性。通过学习和熟练掌握这一技术，开发者能够更好地应对复杂的企业级...
【归纳总结】Spring之AspectJ
Octavius_的博客
03-31 255
AspectJ实际上是对AOP编程思想的一个实践 有三种实践方式： 切入点表达式 advisor aspect 需要导包： <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.6</version&gt
Spring AspectJ
黄文孝同学的博客
12-28 2780
Hello，这里来简单的说一下AspectJ的使用 概述： AspectJ是一个基于Java语言的AOP框架，在Spring2.0以后添加了对AspectJ切入点表达式的支持 @AspectJ允许在Bean类定义切面 Spring配置文件 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.sprin...
spring-AspectJ
azjnf1847的博客
05-22 92
动态代理 ProxyFactoryBean织入切面数量太多不利于围护 BeanNameAutoProxyCreater-------------根据Bean名称创建代理 DefaultAdvisorAutoProxyCreator-------------根据Advisor本身包含信息创建代理 AnnotationAwareAspectJAutoPr...
Spring AspectJ支持
IT界幼稚生的博客
02-18 368
@AspectJ切面使用@Aspect注解配置，拥有@Aspect的任何Bean将被Spring自动识别并应用 用@Aspect注解的类可以由方法和字段，它们也可能包括切入点（pointcut），通知（Advice）和引入（introduction）声明 @Aspect注解是不能够通过类路径自动检测发现的，所以需要配合使用@Component注释或者在XML配置bean 一个类中的@Aspe...
spring的aspectj简介
wwzuizz的博客
01-08 238
准备工作  导入对应的包 book是被增强，mybook是增强
Spring AspectJ 框架
m0_51343808的博客
09-08 142
1.什么是AspectJ AspectJ 是一个基于 Java 语言的 AOP 框架。在 Spring 2.0 以后，新增了对 AspectJ 框 架的支持。在 Spring 框架中建议使用 AspectJ 框架开发 AOP。 2.AspectJ 框架中的通知类型 3.AspectJ 框架配置 AOP 方式 3.1通过 XML 文件配置 AOP 通过 AspectJ 配置方式 通过 Spring 的 Schema_based 方式 ...
spring-AspectJ的用法
menghuanzhiming的博客
12-12 820
1、Spring使用AspectJ的AOP开发:(注解) 步骤一:创建web项目,引入jar包maven管理： <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <versio
Spring框架深度学习：@AspectJ的AOP实践
Spring架构设计上，除了核心的IoC容器，还包括了AOP模块、数据访问/集成模块、Web模块等多个组成部分，形成了一个全面的应用程序开发框架。通过这些模块，Spring能够为开发者提供从底层数据存储到Web应用程序的全...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值