java中AOP的理解和使用

已于 2023-09-05 10:10:04 修改
阅读量4.2k 收藏 14
点赞数 2
文章标签： java jvm 面试 springcloud spring boot
于 2022-09-27 16:36:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43626529/article/details/127073049
版权

java中AOP的理解和使用

1.什么是AOP？

AOP就是面向切面编程，或者叫面向方面编程，或者开玩笑的说叫面向方便面编程，如果粗俗的理解，就是可以自定义注解，然后通过自己定义的方式定义注解的作用。

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

2.AOP的作用（特点）是什么？

AOP代表的是一个横向的关 系，将“对象”比作一个空心的圆柱体，其中封装的是对象的属性和行为；则面向方面编程的方法，就是将这个圆柱体以切面形式剖开，选择性的提供业务逻辑。而 剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹，但完成了效果。

实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。

3.AOP的注解

1.Target

@Target 注解的作用目标

	（1）@Target(ElementType.TYPE) —— 接口、类、枚举、注解
	（2）@Target(ElementType.FIELD) —— 字段、枚举的常量
	（3）@Target(ElementType.METHOD) —— 方法
	（4）@Target(ElementType.PARAMETER) —— 方法参数
	（5）@Target(ElementType.CONSTRUCTOR) —— 构造函数
    （6）@Target(ElementType.LOCAL_VARIABLE) —— 局部变量
	（7）@Target(ElementType.ANNOTATION_TYPE) —— 注解
	（8）@Target(ElementType.PACKAGE) —— 包

2.Retention

@Retention 注解的保留位置

（1） RetentionPolicy.SOURCE:这种类型的Annotations只在源代码级别保留,编译时就会被忽略,在class字节码文件中不包含。
（2）RetentionPolicy.CLASS:这种类型的Annotations编译时被保留,默认的保留策略,在class文件中存在,但JVM将会忽略,运行时无法获得。
（3）RetentionPolicy.RUNTIME:这种类型的Annotations将被JVM保留,所以他们能在运行时被JVM或其他使用反射机制的代码所读取和使用。

3.Document

说明该注解将被包含在javadoc中

4.Inherited

说明子类可以继承父类中的该注解

5.Aspect

作用是把当前类标识为一个切面供容器读取

6.Pointcut

Pointcut是植入Advice的触发条件。每个Pointcut的定义包括2部分，一是表达式，二是方法签名。方法签名必须是 public及void型。可以将Pointcut中的方法看作是一个被Advice引用的助记符，因为表达式不直观，因此我们可以通过方法签名的方式为 此表达式命名。因此Pointcut中的方法只需要方法签名，而不需要在方法体内编写实际代码

4.通知形式

 (1) 前置通知（@Before）：在目标方法调用之前调用通知
 (2) 后置通知（@After）：在目标方法完成之后调用通知
 (3) 环绕通知（@Around）：在被通知的方法调用之前和调用之后执行自定义的方法
 (4) 返回通知（@AfterReturning）：在目标方法成功执行之后调用通知
 (5) 异常通知（@AfterThrowing）：在目标方法抛出异常之后调用通知

5.代码使用

1.定义主体类

在这里插入图片描述

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
/**
 * @Documented 是元注解，可以修饰其他注解。许多注解头部都有@Documented注解
 * 例如jdk中自带的@Deprecated注解(路径是：java/lang/Deprecated.java)头部就含有这个注解
 *
 * 在自定义注解的时候可以使用@Documented来进行标注，如果使用@Documented标注了，在生成javadoc的时候就会把@Documented注解给显示出来。
 */
@Documented
public @interface ClhTestAOP {
	String chen() default "1";
	String liang() default "1";
	String hong() default "1";
}

2.设置切面

在这里插入图片描述
在这里插入图片描述



@Slf4j
@Aspect
@Component
public class ClhTestAOPAspect {


	private String chen = "";
	private String liang = "";
	private String hong = "";


	/**
	 * 切点
	 */
	@Pointcut(value = "@annotation(annotation.ClhTestAOP)")
	public void logPointCut() {

	}


	/**
	 * 前置通知（@Before）：在目标方法调用之前调用通知
	 * 后置通知（@After）：在目标方法完成之后调用通知
	 * 环绕通知（@Around）：在被通知的方法调用之前和调用之后执行自定义的方法
	 * 返回通知（@AfterReturning）：在目标方法成功执行之后调用通知
	 * 异常通知（@AfterThrowing）：在目标方法抛出异常之后调用通知
	 * @param joinPoint
	 * @return
	 */
	@Before(value = "logPointCut()")
	public void doBefore(ProceedingJoinPoint joinPoint){
		MethodSignature signature = (MethodSignature) joinPoint.getSignature();
		Method method = signature.getMethod();
		ClhTestAOP clhTestAOP = method.getAnnotation(ClhTestAOP.class);
		if (clhTestAOP != null) {
			chen = clhTestAOP.chen();
			liang = clhTestAOP.liang();
			hong = clhTestAOP.hong();
		}

		if(chen.equals("1")) {
			log.info("@Before ================== chen 1 ");
		}else {
			log.info("@Before ================== chen default ");
		}

		if(liang.equals("1")) {
			log.info("@Before ================== liang 1 ");
		}else {
			log.info("@Before ================== liang default ");
		}

		if(hong.equals("1")) {
			log.info("@Before ================== hong 1 ");
		}else {
			log.info("@Before ================== hong default ");
		}

	}

	@After(value = "logPointCut()")
	public void doAfter(ProceedingJoinPoint joinPoint){
		MethodSignature signature = (MethodSignature) joinPoint.getSignature();
		Method method = signature.getMethod();
		ClhTestAOP clhTestAOP = method.getAnnotation(ClhTestAOP.class);
		if (clhTestAOP != null) {
			chen = clhTestAOP.chen();
			liang = clhTestAOP.liang();
			hong = clhTestAOP.hong();
		}

		if(chen.equals("1")) {
			log.info("@After ================== chen 1 ");
		}else {
			log.info("@After ================== chen default ");
		}

		if(liang.equals("1")) {
			log.info("@After ================== liang 1 ");
		}else {
			log.info("@After ================== liang default ");
		}

		if(hong.equals("1")) {
			log.info("@After ================== hong 1 ");
		}else {
			log.info("@After ================== hong default ");
		}

	}

	@Around(value = "logPointCut()")
	public void doAround(ProceedingJoinPoint joinPoint){
		MethodSignature signature = (MethodSignature) joinPoint.getSignature();
		Method method = signature.getMethod();
		ClhTestAOP clhTestAOP = method.getAnnotation(ClhTestAOP.class);
		if (clhTestAOP != null) {
			chen = clhTestAOP.chen();
			liang = clhTestAOP.liang();
			hong = clhTestAOP.hong();
		}

		if(chen.equals("1")) {
			log.info("@Around ================== chen 1 ");
		}else {
			log.info("@Around ================== chen default ");
		}

		if(liang.equals("1")) {
			log.info("@Around ================== liang 1 ");
		}else {
			log.info("@Around ================== liang default ");
		}

		if(hong.equals("1")) {
			log.info("@Around ================== hong 1 ");
		}else {
			log.info("@Around ================== hong default ");
		}

	}

	@AfterReturning(value = "logPointCut()")
	public void doAfterReturning(ProceedingJoinPoint joinPoint){
		MethodSignature signature = (MethodSignature) joinPoint.getSignature();
		Method method = signature.getMethod();
		ClhTestAOP clhTestAOP = method.getAnnotation(ClhTestAOP.class);
		if (clhTestAOP != null) {
			chen = clhTestAOP.chen();
			liang = clhTestAOP.liang();
			hong = clhTestAOP.hong();
		}

		if(chen.equals("1")) {
			log.info("@AfterReturning ================== chen 1 ");
		}else {
			log.info("@AfterReturning ================== chen default ");
		}

		if(liang.equals("1")) {
			log.info("@AfterReturning ================== liang 1 ");
		}else {
			log.info("@AfterReturning ================== liang default ");
		}

		if(hong.equals("1")) {
			log.info("@AfterReturning ================== hong 1 ");
		}else {
			log.info("@AfterReturning ================== hong default ");
		}

	}

	@AfterThrowing(value = "logPointCut()")
	public void doAfterThrowing(ProceedingJoinPoint joinPoint){
		MethodSignature signature = (MethodSignature) joinPoint.getSignature();
		Method method = signature.getMethod();
		ClhTestAOP clhTestAOP = method.getAnnotation(ClhTestAOP.class);
		if (clhTestAOP != null) {
			chen = clhTestAOP.chen();
			liang = clhTestAOP.liang();
			hong = clhTestAOP.hong();
		}

		if(chen.equals("1")) {
			log.info("@AfterThrowing ================== chen 1 ");
		}else {
			log.info("@AfterThrowing ================== chen default ");
		}

		if(liang.equals("1")) {
			log.info("@AfterThrowing ================== liang 1 ");
		}else {
			log.info("@AfterThrowing ================== liang default ");
		}

		if(hong.equals("1")) {
			log.info("@AfterThrowing ================== hong 1 ");
		}else {
			log.info("@AfterThrowing ================== hong default ");
		}

	}

}

3.使用AOP注解

在这里插入图片描述

	@ClhTestAOP(chen = "chen", liang = "liang", hong = "hong")
	public void test() {
		System.out.println("测试AOP··········");
	}
acx匿
关注
  • 2
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java核心库实现简单的AOP
08-24
主要介绍了如何用Java核心库实现简单的AOP，帮助大家为了更好的理解和学习AOP的思想，感兴趣的朋友可以了解下
java AOP aspectjrt-1.8.14 AOP核心大集合
12-04
spring-aop：AOP核心功能，例如代理工厂等等 aspectjweaver：简单理解，支持切入点表达式等等 aspectjrt：简单理解，支持aop相关注解等等
【java知识点】AOP的使用
等待中的小码农
04-22 4163
1.AOP的使用场景 在实际工作中，可能会存在需要在调用方法前后调用其它接口，例如： 1>调用业务方法前，需要根据头部信息来调用外部接口获取到所需的信息，来决定后续方法执行的逻辑； 2>调用业务方法后，日志信息的记录（请求参数、返回结果、执行时长等）。 2.JoinPoint 介绍 JointPoint是程序运行过程中可识别的点，这个点可以用来作为AOP切入点。JointPoint对象则包含了和切入相关的很多信息。比如切入点的对象，方法，属性等。我们可以通过反射的方式获取这些点的状态和信息，用
Java AOP 简单实例演示
mo_sss的博客
03-20 1261
面向切面编程在切面类中使用@Pointcut注解列出需要增强的方法（即原有代码的函数，我们就叫它们目标函数execution(修饰符 返回值 包名.包名.包名.类名.方法名(…))如也可用*替代进行模糊匹配如如并在@Pointcut注解下面定义一个没有内容的切入点签名函数（我们将该函数定义为sig()
Java平台AOP技术研究
02-04
3.1Java平台AOP技术概览3.1.1AOP技术在Java平台中的应用AOP在实验室应用和商业应用上，Java平台始终走在前面。从最初也是目前最成熟的AOP工具——AspectJ，到目前已经融和在企业级容器JBoss中的JBossAOP，均建立在Java平台上。前面已经描述到，AOP的目的就是将核心关注点和横切关注点分离，实际上这就是一种分散关注（seperationofconcerns）的思路。在Java平台下，如果要开发企业级的应用，非J2EE莫属。一个J2EE应用系统只有部署在J2EE容器中才能运行，那么为什么要划分为J2EE容器和J2EE应用系统？通过对J2EE容器运行机制的分析，
java AOP原理以及实例用法总结
08-26
在本篇文章里我们给大家整理了关于java AOP原理以及相关知识点总结，正在学习的朋友们参考下。
Java AOP篇
热门推荐
wk3510的博客
11-12 1万+
AOP，一般成为面向切面，作为面向对象OOP的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”(Aspect)，减少系统中的重复代码，降低了模块之间的耦合度，提高了系统的可维护性。可用于权限认证，日志和事务处理.
Java AOP的底层实现原理
北风浊酒
02-12 700
一、什么是AOP 1、AOP：Aspect Oriented Programming（面向切面编程），OOP是面向对象编程，AOP是在OOP基础之上的一种更高级的设计思想。 2、OOP和AOP之间也存在一些区别，OOP侧重于对象的提取和封装。----封装对象 AOP侧重于方面组件，方面组件可以理解成封装了通用功能的组件，方面组件可以通过配置方式，灵活地切入到某一批目标对象方法上。----封装...
Java中的AOP是什么？如何实现AOP
2301_77769537的博客
05-07 1710
通过动态代理，应用程序可以在不修改其原始代码的情况下，将横切关注点从主要逻辑中分离出来，从而实现更高的可重用性和可维护性。通过使用AOP，开发人员可以更轻松地实现应用程序的横切关注点，从而提高应用程序的可重用性和可维护性，并且更好地管理和组织代码。AOP是一种编程范式，它使开发人员能够在不改变应用程序原有逻辑的情况下，将横切关注点（例如日志记录、事务管理、安全性等）从应用程序的主要逻辑中分离出来。总之，AOP是一种非常有用的软件设计模式，它可以帮助我们更好地管理和组织代码，从而提高软件的质量和可维护性
java之路——AOP知识详解以及程序中的应用
m0_68987535的博客
06-18 1582
在学习AOP中，来了解spring的主要内容。Spring 的核心内容包括IOC，AOP等。IOCSpring 的 IOC（Inversion of Control）是指通过容器帮用户管理组件及实现对象之间解耦。Spring 中的 IOC 容器可以自动管理对象之间的依赖关系和生命周期。用户只需要通过配置或者注解的方式告诉 Spring 哪些组件需要注入到哪些对象中，Spring 的 IOC 容器就会自动为用户完成依赖注入。AOPSpring 的 AOP 是指基于切面的编程。
JAVA aop 实现的几种方式，以及原理解析
qq_39355721的博客
06-19 2376
编写自定义切面类System.out.println("方法执行前");System.out.println("方法执行后");在beans.xml中配置测试类不变，再次执行结果：方法执行前添加了一个用户方法执行后。
IOC和AOP深刻理解基础代码测试
09-17
Java web 开发中的必备神器。IOC和AOP深刻理解其原理，基础代码测试。完整的基础测试项目打包。妈妈再也不用担心我不懂切面编程和控制反转了。干货。仅供初学者使用。
理解Spring AOP实现与思想 案例代码
06-06
博客《理解Spring AOP实现与思想》案例代码，对Java技术感兴趣的朋友可以关注一下我，我在csdn为您准备了很多Java干货。
Java中AOP编程实现.rar
07-09
Java中AOP编程实现
spring_aop1.rar_java aop_spring mvc 例子
09-14
spring中aop入门的例子，里面有说明文件，希望对理解spring的aop有帮助
java AOP实现字段加密/解密
12-12
java AOP实现字段加密/解密 参数加密： @EncryptMethod //添加service实现上面 @EncryptField //添加entity 实现字段上面
mybatisPlus使用MetaObjectHandler对字段进行更新
最新发布
m0_56356631的博客
04-23 335
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1439
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 603
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
java aop 的理解
03-30
Java AOP（面向切面编程）是一种编程范式，它允许程序员将横切关注点（如日志记录、性能测量、事务管理等）从应用程序的主业务逻辑中分离出来。通过将这些关注点切入到程序的特定点（称为切点）中，AOP可以在不修改现有代码的情况下提高代码的可重用性、可维护性和可扩展性。 在Java AOP中，切点是程序中的特定方法或代码段，它们被称为连接点。切面是应用于连接点的一个或多个横切关注点的集合，例如日志记录、性能测量等。切面可以通过编写Java注解或XML配置来定义。 Java AOP框架提供了许多工具和类库，以简化切面的编写和应用。一些流行的Java AOP框架包括Spring AOP、AspectJ和JBoss AOP等。这些框架提供了许多有用的切点和切面，可以轻松地将它们应用于现有的Java应用程序中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值