Spring AOP 与 AspectJ

最新推荐文章于 2024-08-07 02:49:08 发布
最新推荐文章于 2024-08-07 02:49:08 发布
阅读量151 收藏
点赞数
分类专栏： JavaEE-SSM 文章标签： spring java aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44776065/article/details/109726122
版权

文章目录

一、介绍

在传统的业务处理代码中，通常都会进行事务处理、日志记录等操作。虽然使用OOP可以通过组合或者继承的方式来达到代码的重用，但如果要实现某个功能（如日志记录），同样的代码仍然会分散到各个方法中。这样，如果想要关闭某个功能，或者对其进行修改，就必须要修改所有的相关方法。这不但增加了开发人员的工作量，而且提高了代码的出错率

AOP采取横向抽取机制，将分散在各个方法中的重复代码提取出来，然后在程序编译或运行时，再将这些提取出来的代码应用到需要执行的地方。这种采用横向抽取机制的方式，采用传统的OOP思想显然是无法办到的，因为OOP只能实现父子关系的纵向的重用。虽然AOP是一种新的编程思想，但却不是OOP的替代品，它只是OOP的延伸和补充

二、 AOP术语

在这里插入图片描述

  • Advice（通知/增强处理）：AOP框架在特定的切入点执行的增强处理，即在定义好的切入点处所要执行的程序代码。可以将其理解为切面类中的方法
  • Target Object（目标对象）：指所有被通知的对象，也被称为被增强对象。如果AOP框架采用的是动态的AOP实现，那么该对象就是一个被代理对象
  • Proxy（代理）：将通知应用到目标对象之后，被动态创建的对象
  • Weaving（织入）：将切面代码插入到目标对象上，从而生成代理对象的过程

三、AOP介绍

3.1 什么是AOP ？

  • AOP采取横向抽取机制，将分散在各个方法中的重复代码提取出来
  • 在程序编译或运行时，再将这些提取出来的代码应用到需要执行的地方

3.2 Spring通知类型

前置通知、后置通知、环绕通知、异常抛出通知、引介通知

  • org.springframework.aop.MethodBeforeAdvice（前置通知）
    在目标方法执行前实施增强，可以应用于权限管理等功能

  • org.springframework.aop.AfterReturningAdvice（后置通知）
    在目标方法执行后实施增强，可以应用于关闭流、上传文件、删除临时文件等功能

  • org.aopalliance.intercept.MethodInterceptor（环绕通知）
    在目标方法执行前后实施增强，可以应用于日志、事务管理等功能

  • org.springframework.aop.ThrowsAdvice（异常抛出通知）
    在方法抛出异常后实施增强，可以应用于处理异常记录日志等功能

  • org.springframework.aop.IntroductionInterceptor（引介通知）
    在目标类中添加一些新的方法和属性，可以应用于修改老版本程序

四、面向切面编程

4.1 面向切面AspectJ

  • 自定义的切面
public class MyAspect {
	
	// 前置通知
	public void beforeProxy(JoinPoint joinPoint) {
		System.out.print("前置通知： 模拟执行权限检查, ");
		System.out.print("目标类是: " + joinPoint.getTarget());
		System.out.println(", 被织入的方法： " + joinPoint.getSignature().getName());
	}
	
	// 后置通知
	public void afterReturningProxy(JoinPoint joinPoint) {
		System.out.print("后置通知：模拟记录日志...");
		System.out.print("目标类是：" + joinPoint.getTarget());
		System.out.println(", 被织入的目标方法: " + joinPoint.getSignature().getName());
	}
	
	// ProceedingJoinPoint是 JoinPoint的子接口， 表示可以执行的目标方法
	// 使用proceedingJoinPoint为参数，必须返回一个对象 Object
	// 必须接收一个参数，类型为 ProceedingJoinPoint
	// 必须抛出异常 throws Throwable
	public Object aroundProxy(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
		
		System.out.println("环绕通知开始执行， 模拟开启事务: ");
		
		Object obj = proceedingJoinPoint.proceed();
		
		System.out.println("环绕通知结束, 模拟关闭事务...");
		return obj;
	}
	
	public void afterThrowingProxy(JoinPoint joinPoint, Throwable exception) {
		System.out.println("抛出异常: " + exception.getMessage());
	}
	
	// 最终通知
	public void afterProxy() {
		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"
	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">

	<!-- 1 目标类 -->
	<bean id="userDAO" class="com.hlq.AspectJ.UserDAOImpl" />
	<!-- 2 切面 -->
	<bean id="myAspect" class="com.hlq.AspectJ.MyAspect" />
	<!-- 3 aop编程 -->

	<aop:config>
		<!-- 配置切面 -->
		<aop:aspect ref="myAspect">
			<!-- 3.1 配置切入点，通知最后增强哪些方法 -->
			<aop:pointcut
				expression="execution(* com.hlq.AspectJ.*.add*(..))"
				id="addPointCut" />
			
			<!-- 配置另一个切入点 -->
			<aop:pointcut expression="execution(* com.hlq.AspectJ.*.delete*(..))" id="deletePointCut"/>
			<!-- 3.2 关联通知Advice和切入点pointCut -->
			
			<!-- 3.2.1 前置通知 -->
			<aop:before method="beforeProxy" pointcut-ref="addPointCut" />
			<!-- 3.2.2 后置通知,在方法返回之后执行，就可以获得返回值 returning属性：用于设置后置通知的第二个参数的名称,类型是Object -->
			<aop:after-returning method="afterReturningProxy"
				pointcut-ref="deletePointCut" returning="returnVal" />
			<!-- 3.2.3 环绕通知 -->
			<aop:around method="aroundProxy" pointcut-ref="addPointCut" />
			<!-- 3.2.4 抛出通知：用于处理程序发生异常-->
			<!-- * 注意：如果程序没有异常，将不会执行增强 -->
			<!-- * throwing属性：用于设置通知第二个参数的名称，类型Throwable -->
			<aop:after-throwing method="afterThrowingProxy"
				pointcut-ref="addPointCut" throwing="exception" />
			<!-- 3.2.5 最终通知：无论程序发生任何事情，都将执行 -->
			<aop:after method="afterProxy" pointcut-ref="addPointCut" />
			
		</aop:aspect>
	</aop:config>
</beans>
  • 测试
public class UserDAOImpl implements UserDAO {
	
	public void addUser() {
		System.out.println("UserDAO addUser is called... ");
	}
	
	public void deleteUser() {
		System.out.println("UserDAO deleteUser is called...");
	}
	
	public UserDAOImpl() {
		super();
	}
	
}

public class AspectTest {
	
	public static void main(String[] args) {
		
		String xmlPath = "com/hlq/AspectJ/aspectConf.xml";
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
		
		UserDAO userDAO = (UserDAO)applicationContext.getBean("userDAO");
		
		userDAO.addUser();
		userDAO.deleteUser();
		
	}
	
}

前置通知： 模拟执行权限检查, 目标类是: com.hlq.AspectJ.UserDAOImpl@4686afc2, 被织入的方法： addUser
环绕通知开始执行， 模拟开启事务: 
UserDAO addUser is called... 
最终通知，结束后释放资源... 
环绕通知结束, 模拟关闭事务...
UserDAO deleteUser is called...
后置通知：模拟记录日志...目标类是：com.hlq.AspectJ.UserDAOImpl@4686afc2, 被织入的目标方法: deleteUser

4.2 注解式的Aspect

  • 定义注解切面
@Aspect
@Component
public class AspectJ {

	// 定义切入点表达式
	@Pointcut("execution(* com.hlq.annotationAspect.*.add*(..))")
	// 使用一个返回值为void、方法体为空的方法来命名切入点
	private void addPointCut() {
	}

	@Pointcut("execution(* com.hlq.annotationAspect.*.delete*(..))")
	public void deletePointCut() {
	}

	// 前置通知
	@Before("addPointCut()")
	public void beforeProxy(JoinPoint joinPoint) {
		System.out.print("前置通知： 模拟执行权限检查, ");
		System.out.print("目标类是: " + joinPoint.getTarget());
		System.out.println(", 被织入的方法： " + joinPoint.getSignature().getName());
	}

	// 后置通知
	@AfterReturning("deletePointCut()")
	public void afterReturningProxy(JoinPoint joinPoint) {
		System.out.print("后置通知：模拟记录日志...");
		System.out.print("目标类是：" + joinPoint.getTarget());
		System.out.println(", 被织入的目标方法: " + joinPoint.getSignature().getName());
	}

//	// ProceedingJoinPoint是 JoinPoint的子接口， 表示可以执行的目标方法
//	// 使用proceedingJoinPoint为参数，必须返回一个对象 Object
//	// 必须接收一个参数，类型为 ProceedingJoinPoint
//	// 必须抛出异常 throws Throwable
//	@Around("myPointCut()")
//	public Object aroundProxy(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
//
//		System.out.println("环绕通知开始执行， 模拟开启事务: ");
//
//		Object obj = proceedingJoinPoint.proceed();
//
//		System.out.println("环绕通知结束, 模拟关闭事务...");
//		return obj;
//	}
//
//	@AfterThrowing(value="myPointCut()", throwing="exception")
//	public void afterThrowingProxy(JoinPoint joinPoint, Throwable exception) {
//		System.out.println("抛出异常: " + exception.getMessage());
//	}
//
//	// 最终通知
//	@After("myPointCut()")
//	public void afterProxy() {
//		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: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.hlq.annotationAspect" />

	<!-- 启动基于注解的声明式AspectJ支持 -->
	<aop:aspectj-autoproxy />

</beans>
  • 编写任意测试类
@Repository("userDAO")
public class UserDAOImpl implements UserDAO {
	
	public void addUser() {
		System.out.println("UserDAO addUser is called... ");
	}
	
	public void deleteUser() {
		System.out.println("UserDAO deleteUser is called...");
	}

	
}

public class AspectTest {
	
	public static void main(String[] args) {
		
		String xmlPath = "com/hlq/annotationAspect/aspectConf.xml";
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
		
		UserDAO userDAO = (UserDAO)applicationContext.getBean("userDAO");
		
		userDAO.addUser();
		userDAO.deleteUser();
		
	}
	
}


前置通知： 模拟执行权限检查, 目标类是: com.hlq.annotationAspect.UserDAOImpl@56dc1551, 被织入的方法： addUser
UserDAO addUser is called... 
UserDAO deleteUser is called...
后置通知：模拟记录日志...目标类是：com.hlq.annotationAspect.UserDAOImpl@56dc1551, 被织入的目标方法: deleteUser
LiQiang33
关注
专栏目录
Spring AOP 和 AspectJ
Leon的博客
05-26 375
在本节将学习Spring AOP的用法和一些高级的AOP主题，如通知优先权（Advice precedence）和引入（Introduction）使用Spring AOP的核心实现技术在所有版本中都一样：动态代理；因为AspectJ已经成长为一个完整流行的AOP框架，Spring在其AOP框架中支持使用AspectJ注解编写POJO aspect。但是在Spring AOP中使用AspectJ as
夯实Spring（三） | Spring Aop 与 AspectJ
qq_38425803的博客
11-02 487
前言          谈起spring，Aop当然是其中的重中之重。本文简要讲解Aop理论知识，以及根据demo着重讲解Aspectj的基本用法。spring Aop 的语法这里不作介绍。 Aop是什么？        Aop是面向切面编程，它通过动态代理的方式为程序添加统一的功能，集中解决一些公共问题。如日志处理，事务控制等等。  &n
Spring-03 Aop简介，实现原理，基于ProxyFactoryBean实现Aop，基于AspectJ开发的实现
qq_41520945的博客
10-21 310
Spring-03 1. SpringAop简介 AOP的全称是Aspect-Oriented Programming，即面向切面编程（也称面向方面编程）。它是面向对象编程（OOP）的一种补充，目前已成为一种比较成熟的编程方式。 aop 解决的问题就是将共同重复的代码就行抽离（日志，事务，鉴权） 什么是切面？切面就是一个类，类里面包含类某一类具体业务（日志，事务，鉴权），用这个类 去拦截/增强 你需要监控的方法或者业务 1.1类与切面的关系 AOP的使用，使开发人员在编写业务逻辑时可以专心于核心业务
Java中的AOP技术：AspectJ与Spring AOP
最新发布
weixin_30061949的博客
08-07 48
Java中的AOP技术：AspectJ与Spring AOP大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天我们将探讨Java中的AOP（面向切面编程）技术，主要聚焦于AspectJ和Spring AOP。这两者是Java领域中实现AOP的主要工具，通过它们可以实现代码的横切关注点（如日志...
Spring AOP和AspectJ
yzy199391的博客
03-05 3085
文章目录面向切面编程AOP术语通知(Advice)连接点(Join point)切点(Pointcut)切面(Aspect)引入(Introduction)织入(Weaving)Spring对AOP的支持通过切点选择连接点编写切点在切点中选择bean使用注解创建切面处理通知中的参数通过注解引入新功能在XML中声明切面声明前置和后置通知声明环绕通知为通知传递参数通过切面引入新的功能注入AspectJ...
Spring AOP与AspectJ
qq_34690003的博客
03-29 640
spring AOP
Spring全家桶(八)AOP核心思想与AspectJ 5种类型通知
1.02^365=1377.41
05-17 2110
一、AOP核心思想AOP是Aspect-Oriented Programming的缩写，翻译为面向切面编程。我个人理解切面就是一个方面。 例子，一个接口里面有增删改查四个方法：package com.stuspring.aop.impl;/** * Created by bee on 17/5/15. */ public interface ArithmeticCalculator {
Spring Aop之AspectJ注解配置实现日志管理的方法
08-28
Spring Aop之AspectJ注解配置实现日志管理的方法 Spring Aop是基于AspectJ实现的面向切面编程（AOP），它提供了一个灵活的方式来实现日志管理。通过使用AspectJ注解，可以轻松地实现日志记录、性能监控、安全检查...
Spring AOP与AspectJ的应用及对比
Java技术攻略的博客
02-24 353
AOP，即面向切面编程是很常用的技术，特别是在Java Web开发中。而最流行的AOP框架分别是Spring AOP和AspectJ。AOP场景应用特别多，还是需要掌握的。
比较Spring AOP和AspectJ
JKX_geek的博客
03-19 493
个人博客导航页（点击右侧链接即可打开个人博客）：大牛带你入门技术栈 介绍 当前有多个可用的AOP库，这些库必须能够回答许多问题： 它与我现有的或新的应用程序兼容吗？ 在哪里可以实施AOP？ 它与我的应用程序集成的速度有多快？ 性能开销是多少？ 在本文中，我们将着眼于回答这些问题，并介绍Spring AOP和AspectJ（这两种最流行的Java AOP框架）。 2. AO...
spring AOP和AspectJ的区别关系
weixin_46164384的博客
06-18 909
动态代理 接口： 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
比较Spring AOP与AspectJ
weixin_34130269的博客
01-25 386
本文翻译自博客Comparing Spring AOP and AspectJ 介绍 如今有多个可用的AOP库，这些组件需要回答一系列的问题： 是否与我现有的应用兼容？ 我在哪实现AOP？ 集成到我的应用是否很快？ 性能开销是多少？ 本文中，我们将会着重回答这些问题，并介绍两款Java最流行的AOP框架：Spring AOP 和 AspectJ。 AOP概念 在我们开始之前，让我们对术语和...
《Spring攻略》第3章 Spring AOP和AspectJ支持
爱.NET
07-16 130
1启用Spring的AspectJ注解支持 问题： Spring支持在其AOP框架中使用AspectJ注解编写的POJO aspect。但是，你必须首先启用Spring中的AspectJ注解支持。 解决方案： 你只需要在Bean配置文件中定义一个空的XML元素&lt;aop:aspectj-autoproxy/&gt;，就可以启用Spring IoC容器中的AspectJ注解支持。 然后...
Spring AOP以及AspectJ
啦啦啦小骑士的博客
01-11 452
一、
AOP的两种实现-Spring AOP以及AspectJ
wjheha的博客
12-08 354
原文链接：https://blog.csdn.net/dm_vincent/article/details/57526325
Spring AOP 和 AspectJ 详解
feigeswjtu的专栏
01-14 1129
最近在看《Spring 实战》，说真的第四章《面向切面编程的Spring》讲的真心很烂，看了几遍都不清楚到底要表达什么，也没有讲清楚Spring AOP 和 AspectJ的区别关系，终于让我找到了一篇文章关于 Spring AOP (AspectJ) 你该知晓的一切，写的是真好，这里记录一下。 接下来举个我自己项目代码的例子。 我们知道，很多时候，要判断当前用户是否已经登录，也就是进行鉴权，
Spring AOP与Aspectj
倾城之恋的专栏
10-03 923
1. AOP：Aspect Oriented Programming(面向切面编程) 2. 利用动态代理实现面向切面编程（底层原理是动态代理这你理解的没错） 3. Spring实现动态代理配置是有两种配置文件：1、 xml文件方式；2、annotation方式(使用AspectJ类库实现的。 4. aspectJ类库，AspectJ是一个专门用来实现动态代理(AOP编程)的类库，AspectJ是面
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值