AspectJ和Spring与AOP的关系

最新推荐文章于 2024-08-03 07:30:00 发布
最新推荐文章于 2024-08-03 07:30:00 发布
阅读量4.2k 收藏 8
点赞数 3
分类专栏： java Web 文章标签： AspectJ Spring AOP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cqf949544506/article/details/82998999
版权

        前面介绍过AOP面向切面编程是一种编程思想，是对OOP面向对象编程的一种补充。对于AOP这种编程思想，很多框架都进行了实现。Spring就是其中之一，可以完成面向切面编程。而AspectJ也实现了AOP的功能，且其实现方式更为简捷，使用更为方便，而且还支持注解式开发。所以，Spring又将AspectJ的对于AOP的实现也引入到了自己的框架中。后面使用AOP编程都是在Spring环境下使用AspectJ来进行的。

 

AspectJ的五种常用通知类型：

（1）前置通知

（2）后置通知

（3）环绕通知

（4）异常通知

（5）最终通知

其中最终通知是指，无论程序执行是否正常，该通知都会执行。类似于try...catch中的finally代码块。

 

AspectJ的切入点表达式

AspectJ定义了专门的表达式用于指定切入点。表达式的原型如下：

execution（[modifiers-pattern]  访问权限类型

                   ret-type-pattern       返回值类型

                   [declaring-type-pattern]  全限定性类名

                   name-pattern(param-pattern)  方法名(参数名)

                   [throws-pattern]  抛出异常类型

）

       切入点表达式要匹配的对象就是目标方法的方法名。表达式中加[]的部分表示可省略的部分，红色部分表示不可省略的部分，各部分之间用空格分开。在其中可以使用一下符号：

举几个例子：

execution(public * *(..))           指定切入点为：任意公共方法

execution(* *.service.*.*(..))    指定只有一级包下的service子包下所有类（接口）中所有方法为切入点

execution(* *..service.*.*(..))   指定所有包下的service子包下所有类（接口）中所有方法为切入点

execution(* *.SomeService.*(..))    指定只有一级包下的SomeService类（接口）中所有方法为切入点

execution(* *..SomeService.*(..))    指定所有包下的SomeService类（接口）中所有方法为切入点

 

AspectJ的开发环境

引入AOP联盟的jar包，这是AOP的规范

引入AspectJ的jar包，这是对上面AOP规范的实现

引入整合Spring和AspectJ的jar包

引入Spring的AOP jar包，因为上面Spring和AspectJ的整合jar包用到了Spring的AOP jar包

注意：这里只列举了需要额外引入的jar包，还需要Spring的四个基础包和日志包

基于注解的实现：

前置通知：

首先定义好要增强的接口和实现类

package com.hnu.service;

public interface SomeService {
	void doFirst();
	String doSecond();
	void doThird();

}

package com.hnu.service;

public class SomeServiceImpl implements SomeService {

	@Override
	public void doFirst() {
		System.out.println("执行doFirst()方法");
	}

	@Override
	public String doSecond() {
		System.out.println("执行doSecond()方法");
		return "abcde";
	}

	@Override
	public void doThird() {
		System.out.println("执行doThird()方法");
	}

}

编写切面类（是一个POJO类）

package com.hnu.service;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect   //表示当前类是切面
public class MyAspect {
	//@Before表示这是一个后置通知   execution表示匹配的连接点
	@Before("execution(* *..SomeService.doFirst(..))")
	public void myBefore(){
		System.out.println("执行前置通知方法");
	}
	
	@Before("execution(* *..SomeService.doFirst(..))")
	public void myBefore(JoinPoint jp){              //JoinPoint表示连接点
		System.out.println("执行前置通知方法   jp = " + jp);
	}
}

配置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:tx="http://www.springframework.org/schema/tx" 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.xsd">
        
       <!-- 注册切面 -->
       <bean id="myAspect" class="com.hnu.service.MyAspect"/>
        
       <!--  注册目标对象 -->
       <bean id="someService" class="com.hnu.service.SomeServiceImpl"/>
       
       <!--  注册AspectJ的自动代理 ，使用到了AOP约束-->
       <aop:aspectj-autoproxy/>
       

</beans>

测试类

package com.hnu.service;

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

public class Test {

	public static void main(String[] args) {
		//创建容器对象，加载Spring配置文件
		String resource = "com/hnu/service/applicationContext.xml";
		ApplicationContext ac = new ClassPathXmlApplicationContext(resource);
		
		SomeService service = (SomeService) ac.getBean("someService");
		
		service.doFirst();
		System.out.println("--------------------------");
		service.doSecond();
		System.out.println("--------------------------");
		service.doThird();
	}

}

运行结果：

 

后置通知，环绕通知，异常通知的使用和前置通知相同，唯一需要改变的就是切面类，这里就只列出切面类的写法

package com.hnu.service;

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;

@Aspect   //表示当前类是切面
public class MyAspect {
	
	@Before("execution(* *..SomeService.doFirst(..))")
	public void myBefore(){
		System.out.println("执行前置通知方法");
	}
	
	@Before("execution(* *..SomeService.doFirst(..))")
	public void myBefore(JoinPoint jp){
		System.out.println("执行前置通知方法   jp = " + jp);
	}
	
	@AfterReturning("execution(* *..SomeService.doSecond(..))")
	public void myAfterReturning(){
		System.out.println("执行后置通知方法");
	}
	
	//注意这里虽然能获取方法返回值，但是不能修改
	@AfterReturning(value="execution(* *..SomeService.doSecond(..))",returning="result")
	public void myAfterReturning(Object result){
		System.out.println("执行后置通知方法  result= " + result);
	}
	
	@Around("execution(* *..SomeService.doSecond(..))")
	public Object myAround(ProceedingJoinPoint pjp) throws Throwable{
		System.out.println("执行环绕通知方法，目标方法执行之前");
		Object result = pjp.proceed();
		System.out.println("执行环绕通知方法，目标方法执行之后");
		if(result != null){                                //可以修改目标方法的返回结果
			result = ((String)result).toUpperCase();
		}
		return result;
	}
	
	@AfterThrowing("execution(* *..SomeService.doThird(..))")
	public void myAfterThrowing(){
		System.out.println("执行异常通知方法");
	}
	
	@AfterThrowing(value="execution(* *..SomeService.doThird(..))",throwing="ex")
	public void myAfterThrowing(Exception ex){
		System.out.println("执行异常通知方法  ex = " + ex.getMessage());
	}
	
	@After("execution(* *..SomeService.doThird(..))")
	public void myAfter(){
		System.out.println("执行最终通知方法");
	}
}

 

定义切入点

通过上面的代码我们可以看到名称表达式execution()有大量冗余，可以通过定义切入点解决。

package com.hnu.service;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

@Aspect   //表示当前类是切面
public class MyAspect {
	
	@After("doThirdPointcut()")     //第二部：直接使用这个切入点
	public void myAfter(){
		System.out.println("执行最终通知方法");
	}
	
	//第一步：定义了一个切入点，叫doThirdPointcut()
	@Pointcut("execution(* *..SomeService.doThird(..))")
	public void doThirdPointcut(){}
}

 

 

基于XML的实现：

编写切面类（是一个POJO类），把上面的切面类删除所有的注解即可

package com.hnu.service;

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

public class MyAspect {
	
	public void myBefore(){
		System.out.println("执行前置通知方法");
	}
	
	public void myBefore(JoinPoint jp){
		System.out.println("执行前置通知方法   jp = " + jp);
	}
	
	public void myAfterReturning(){
		System.out.println("执行后置通知方法");
	}
	
	//注意这里虽然能获取方法返回值，但是不能修改
	public void myAfterReturning(Object result){
		System.out.println("执行后置通知方法  result= " + result);
	}
	
	public Object myAround(ProceedingJoinPoint pjp) throws Throwable{
		System.out.println("执行环绕通知方法，目标方法执行之前");
		Object result = pjp.proceed();
		System.out.println("执行环绕通知方法，目标方法执行之后");
		if(result != null){                                //可以修改目标方法的返回结果
			result = ((String)result).toUpperCase();
		}
		return result;
	}
	
	public void myAfterThrowing(){
		System.out.println("执行异常通知方法");
	}
	
	public void myAfterThrowing(Exception ex){
		System.out.println("执行异常通知方法  ex = " + ex.getMessage());
	}
	
	public void myAfter(){
		System.out.println("执行最终通知方法");
	}
	
}

下面是关键的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:tx="http://www.springframework.org/schema/tx" 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.xsd">
        
       <!-- 注册切面 -->
       <bean id="myAspect" class="com.hnu.service.MyAspect"/>
        
       <!--  注册目标对象 -->
       <bean id="someService" class="com.hnu.service.SomeServiceImpl"/>
       
       <!-- AOP配置 -->
       <aop:config>
       		<aop:pointcut expression="execution(* *..SomeService.doFirst())" id="doFirstPointcut"/>
       		<aop:pointcut expression="execution(* *..SomeService.doSecond())" id="doSecondPointcut"/>
       		<aop:pointcut expression="execution(* *..SomeService.doThird())" id="doThirdPointcut"/>
       		
       		<aop:aspect ref="myAspect">
       			<aop:before method="myBefore" pointcut="execution(* *..SomeService.doFirst())"/>  <!-- 不使用自定义切入点写法 -->
       			<aop:before method="myBefore(org.aspectj.lang.JoinPoint)" pointcut-ref="doFirstPointcut"/>
       			
       			<aop:after-returning method="myAfterReturning" pointcut-ref="doSecondPointcut"/>
       			<aop:after-returning method="myAfterReturning(java.lang.Object)" pointcut-ref="doSecondPointcut" returning="result"/>
       			
       			<aop:around method="myAround" pointcut-ref="doSecondPointcut"/>
       			
       			<aop:after-throwing method="myAfterThrowing" pointcut-ref="doThirdPointcut"/>
       			<aop:after-throwing method="myAfterThrowing(java.lang.Exception)" pointcut-ref="doThirdPointcut" throwing="ex"/>
       			
       			<aop:after method="myAfter" pointcut-ref="doThirdPointcut"/>
       		</aop:aspect>
       </aop:config>

</beans>

 

 

Cs_hnu_xiaogou
关注
专栏目录
spring AOP和AspectJ的区别关系
weixin_46164384的博客
06-18 908
动态代理 接口： interface MyInteface { public void say(); public void getNameToyou(); public void eat(String s); } 实现接口的对象： public class MyUser implements MyInteface{ public void say() { System.out.println("Hello"); } public void getNameToyou() { S
深入探析切面编程：解密 AspectJ 与 Spring AOP 的 AOP 魔法
m0_71777195的博客
08-22 668
这个表格总结了AspectJ和Spring AOP在不同方面的区别。特性/方面AspectJSpring AOP实现方式独立的切面编程框架，扩展了Java语法Spring框架的一部分，基于动态代理和字节码增强技术功能复杂性提供更高级的切面编程能力，支持复杂的切面逻辑更专注于常见的切面功能，适用于简单的切面逻辑依赖性独立使用，需要AspectJ编译器或插件与Spring框架集成，依赖于Spring框架织入方式支持编译时织入和运行时织入。
AOP框架之：Spring AOP和AspectJ
xuxiao1987的专栏
12-17 554
AOP是Spring框架的重要组成部分。目前我所接触的AOP实现框架有Spring AOP还有就是AspectJ(还有另外几种我没有接触过)。我们先来说说他们的区别： AspectJ是一个比较牛逼的AOP框架，他可以对类的成员变量，方法进行拦截。由于 AspectJ 是 Java 语言语法和语义的扩展，所以它提供了自己的一套处理方面的关键字。除了包含字段和方法之外，AspectJ 的方面声明还包...
Java中的AOP技术：AspectJ与Spring AOP
最新发布
微赚开发者技术分享博客
08-03 450
大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！这两者是Java领域中实现AOP的主要工具，通过它们可以实现代码的横切关注点（如日志记录、安全检查等）分离，从而提高代码的可维护性和重用性。AOP是一种强大的技术，能够帮助开发者将日志记录、安全检查等横切关注点从业务逻辑中分离出来，简化代码，提升系统的可维护性和扩展性。AspectJ是一个功能强大的AOP框架，它是对Java语言的扩展，允许你定义切面（Aspect）以声明性地指定横切关注点。
SpringAop与AspectJ的联系与区别
热门推荐
yzgyjyw的博客
05-19 1万+
SpringAop与AspectJ的联系与区别区别AspectJAspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。spring aopSpring提供了四种类型的Aop支持 * 基于经典的SpringAOP * 纯POJO切面 * @ASpectJ注解驱动的切面 * 注入式Asp
springAop和AspectJ的关系
Leon_Jinhai_Sun的博客
03-05 592
Aop是一种概念 springAop、AspectJ都是Aop的实现，SpringAop有自己的语法，但是语法复杂，所以SpringAop借助了AspectJ的注解，但是底层实现还是自己的
框架源码专题：Spring的Aop实现原理，Spring AOP 与 AspectJ 的关系
qq_1149513559的博客
09-27 977
文章目录1. Spring AOP 与 AspectJ 的关系2. Spring AOP术语解释3. Spring AOP应用实例4. Spring AOP有几种配置方式？5. Spring AOP源码解析 1. Spring AOP 与 AspectJ 的关系         Spring AOP 要实现的是在我们原来写的代码的基础上，进行一定的包装，如在方法执行前、方法返回后、方法抛出异常后等地方进行一定的拦截处理或者增强
AspectJ的Aop和Spring的Aop
黄文孝同学的博客
06-13 502
原文地址：https://blog.csdn.net/a128953ad/article/details/50509437 AOP(Aspect OrientedProgramming, 面向切面/方面编程) 旨在从业务逻辑中分离出来横切逻辑【eg:性能监控、日志记录、权限控制等】，提高模块化，即通过AOP解决代码耦合问题，让职责更加单一。 运用技术： SpringAOP使用了两种代理机制，一种是基于JDK的动态代理，另一种是基于CGLib的动态代...
Aspectj与SpringAOP比较记录
YYniannian的博客
07-28 179
Aspect： 一种标准代码/功能, 分散在应用程序中的多个位置, 通常与实际的业务逻辑不同 (例如, 事务管理)。每个方面都侧重于特定的跨裁剪功能
spring-aop-aspectj-ctw:用AspectJ编译Spring AOP
05-17
Spring和AspectJ编译时的编织 Spring AOP的一个常见问题是获取Pointcut到达类的内部方法调用。 在这个示例中，您可以在一个简单的Spring Boot示例中看到如何使用AspectJ处理节拍时间编织。 示例场景 在此示例中，将...
spring中的AOP与AspectJ的区别？
maerrrr的博客
12-21 1万+
根据我看spring官方文档的理解（不出意外是最正确的答案）： ①选择spring的AOP还是AspectJ? spring确实有自己的AOP。功能已经基本够用了，除非你的要在接口上动态代理或者方法拦截精确到getter和setter。这些都是写奇葩的需求，一般不使用。 ②在使用AOP的时候，你是用xml还是注解的方式（@Aspect）？ 1）如果使用xml方式，不需要任何额外
Spring的AOP依赖包-AspectJ
03-31
Spring4.3.7的AOP依赖包-AspectJ
spring AOP 实例（@AspectJ）
03-25
一个基于@AspectJ的spring2.0 AOP应用实例，很小很简单，没有任何额外信息，最适合AOP入门学习。使用log4j打印信息。把项目直接import进myeclipse就可以使用啦......
spring对AOP的支持(使用AspectJ进行AOP演示)
03-05
博文链接：https://shaqiang32.iteye.com/blog/201914
SpringAop与AspectJ的联系与区别____比较分析 Spring AOP 和 AspectJ 之间的差别
qq_43842093的博客
12-18 940
SpringAop与AspectJ的联系与区别 区别 AspectJ AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。 spring aop Spring提供了四种类型的Aop支持 * 基于经典的SpringAOP * 纯POJO切面 * @ASpectJ注解驱动的切面 * 注入式AspectJ切面（其实与Spring并无多大的关系，这个就是使用AspectJ这个框架实现Aop编程） 基于经典
spring讲解五：springAop 、Aop、AspectJ他们的关系是什么？ 他们的核心又是什么 ？
chuxin_mm的博客
03-20 685
首先： AOP是一种思想，是一种面向切面编程的思想，AOP的主要作用就是，告诉我们可以通过动态代理的方式，织入一段代码到已经写到另一段代码中去。 再说： SpringAop 和 AspectJ 都是两个框架，它主要就是通过AOP的思想，来实现面向切面编程。 因为动态代理的方式，不止一种，所以也出现了两个框架，其实实现的作用都是一样的。 他们的核心就是： 动态代理。 最开始实...
Spring Aop 与 AspectJ 有什么区别和联系
程序员小乐
05-21 565
????推荐大家关注一个公众号????点击上方 "编程技术圈"关注,星标或置顶一起成长后台回复“大礼包”有惊喜礼包！每日英文Make the person mature is not the time, but the experience. subway tasted, through the nature; through the world, see light the wo...
Spring AOP与AspectJ
qq798280904的博客
04-11 590
当你不用Spring AOP提供的注解时，Spring AOP和AspectJ没半毛钱的关系，前者是JDK动态代理（接口级别），用到了CGLIB(Code Generation Library)，CGLIB是一个代码生成类库，可以在运行时候动态是生成某个类的子类。代理模式为要访问的目标对象提供了一种途径，当访问对象时，它引入了一个间接的层。后者是静态代理，在编译阶段就已经编译到字节码文件中。这种情况下不使用注解，使用xml配置。
Spring之AOP，DI，IOC和AspectJ
青鸟飞鱼
01-05 423
目录 1.DI(依赖注入)，IOC(控制反转) 2.AOP 2.1 JAVA 代理实现 3.AspectJ 依赖注入和控制反转是对同一件事情的不同描述，从某个方面讲，就是它们描述的角度不同。依赖注入是从应用程序的角度在描述，可以把依赖注入描述完整点：应用程序依赖容器创建并注入它所需要的外部资源；而控制反转是从容器的角度在描述，描述完整点：容器控制应用程序，由容器反向的向应用程序注入应用程...
AspectJ：Spring AOP 实现与概念解析
"aspectj.pdf" 本文将介绍AspectJ，一种广泛使用的面向切面编程(AOP)框架，尤其在Spring框架中...在Spring框架中，AspectJ与AOP的结合进一步简化了企业级应用的复杂性，尤其是在事务管理、日志记录和权限控制等方面。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值