java框架013——Spring AOP面向切面编程

已于 2022-11-07 14:05:10 修改
阅读量529 收藏
点赞数
分类专栏： # spring 文章标签： spring java
于 2021-10-17 11:31:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45084986/article/details/120800097
版权

一、Spring AOP简介

AOP的全称是Aspect-Oriented Programming，即面向切面编程（也称面向方面编程）。它是面向对象编程（OOP）的一种补充，目前已成为一种比较成熟的编程方式。

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

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

类与切面的关系
在这里插入图片描述
AOP的使用，使开发人员在编写业务逻辑时可以专心于核心业务，而不用过多的关注于其他业务逻辑的实现，这不但提高了开发效率，而且增强了代码的可维护性。

二、AOP术语

在这里插入图片描述
连接点：可以被增强的方法
切入点：实际被增强的方法
通知(增强)：实际增强的逻辑部分称为通知(增强)
前置通知
后置通知
环绕通知
异常通知
最终通知
切面：是动作，把通知应用到切入点过程

Proxy（代理）：将通知应用到目标对象之后，被动态创建的对象。
Weaving（织入）：将切面代码插入到目标对象上，从而生成代理对象的过程。

三、JDK动态代理（基于接口实现）

3.1、先抛出问题

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

3.1、使用JDK动态代理解决问题（实际开发不常使用，学习了解原理）

JDK动态代理是通过java.lang.reflect.Proxy 类来实现的，我们可以调用Proxy类的newProxyInstance()方法来创建代理对象。对于使用业务接口的类，Spring默认会使用JDK动态代理来实现AOP。

newProxyInstance()方法
方法有三个参数:
第一参数：类加载器
第二参数：增强方法所在的类，这个类实现的接口，支持多个接口
第三参数：实现这个接口InvocationHandler，创建代理对象，写增强的部分。

步骤：
1、创建接口类
2、创建接口的实现类
3、使用Proxy创建接口代理对象
在这里插入图片描述
代理的作用：附加功能由动态代理来做，核心功能的业务处理由service来实现
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

四、AspectJ开发

4.1、AspectJ简介（不是spring组成部分）

AspectJ是一个基于Java语言的AOP框架，它提供了强大的AOP功能。Spring 2.0以后，Spring AOP引入了对AspectJ的支持，并允许直接使用AspectJ进行编程，而Spring自身的AOP API也尽量与AspectJ保持一致。新版本的Spring框架，也建议使用AspectJ来开发AOP。

使用AspectJ实现AOP有两种方式：
一种是基于XML的声明式AspectJ，另一种是基于注解的声明式AspectJ。

4.2、AspectJ开发准备

下载AspectJ的jar包https://mvnrepository.com/artifact/org.aspectj/aspectjweaver
需要导入的jar包
在这里插入图片描述

4.3、通知的类型

按照通知在目标类方法的连接点位置，主要可以分为以下类型：

1、环绕通知：在目标方法执行前后实施增强，可以应用于日志、事务管理等功能。
2、前置通知：在目标方法执行前实施增强，可以应用于权限管理等功能。
3、返回通知：在目标方法成功执行后实施增强，可以应用于关闭流、上传文件、删除临时文件等功能。
4、后置（最终）通知：在目标方法执行后实施增强，不论是否发生异常，该通知都要执行，该类通知可用于释放资源。
5、异常抛出通知：在方法抛出异常后实施增强，可以应用于处理异常记录日志等功能。

4.4、基于注解的AspectJ

4.4.1、AspectJ注解

AspectJ框架为AOP的实现提供了一套注解，用以取代Spring配置文件中为实现AOP功能所配置的臃肿代码。AspectJ的注解及其描述如下所示：
在这里插入图片描述

4.4.2、切入点表达式

在这里插入图片描述

execution(modifiers-pattern  ret-type-pattern  declaring-type-pattern name-pattern(param-pattern) throws-pattern)

在这里插入图片描述
(1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强）
语法结构:,

execution([权限修饰符][返回类型][类全路径][方法名称]([参数列表]))

举例1:对com.dgut.dao.BookDao类里面的add进行增强
execution(* com.dgut.dao.BookDao.add(..))

举例2:对 com.dgut.dao.BookDao类里面的所有的方法进行增强
vexecution(* com.dgut.daa.BookDao.*(..))

举例3:对com.dgut.dao包里面所有类，类里面所有方法进行增强
execution(*com.dgut.dao.*.*(..))

4.4.、基于注解的AspectJ内容

获取方法的方法名
获取方法的参数
获取方法的返回结果
处理特定异常
环绕通知用法
重用切入点表达式
切面的优先级------->@Order(2) // 第二个切面，后使用

4.4.、实例(实现接口情况)

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

MyAspect .java

package com.dgut.spring.aop.aspectj;

import java.util.Arrays;

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.core.annotation.Order;
import org.springframework.stereotype.Component;

//创建一个切面
@Component
@Aspect//声明这是一个切面类
@Order(2) // 第二个切面，后使用
public class MyAspect {

	// 重用切入点表达式
	@Pointcut("execution(* com.dgut.spring.aop.aspectj.CalculatorImpl.*(..))")
	public void myPointCut() {}

	// 前置通知
	// 切CalculatorImpl类的add方法参数任意..，返回值任意*
	@Before("execution(* com.dgut.spring.aop.aspectj.CalculatorImpl.add(..))")
	public void beforeAnnouncement(JoinPoint jp) {
		String methodName = jp.getSignature().getName();
		Object[] args = jp.getArgs();
		System.out.println("Before Announcement===> " + "要切入的方法名：" + methodName + "() ，对应的参数：" + Arrays.asList(args));
	}

	// 返回通知
	// 切CalculatorImpl类的所有方法参数任意..，返回值为res和参数Object res同名，表示两个是一致的
	@AfterReturning(value = "myPointCut()", returning = "res")
	public void afterReturningAnnouncement(JoinPoint jp, Object res) {
		String methodName = jp.getSignature().getName();
		System.out.println("AfterReturning Announcement===> " + "要切入的方法名：" + methodName + "() ，返回结果：" + res);
	}

	// 后置（最终）通知
	// 切CalculatorImpl类的所有方法参数任意..，返回值任意*
	@After("myPointCut()")
	public void afterAnnouncement(JoinPoint jp) {
		String methodName = jp.getSignature().getName();
		System.out.println("After Announcement===> " + "要切入的方法名：" + methodName + "()");
	}

	// 异常抛出通知
	// 切CalculatorImpl类的所有方法参数任意..，异常返回值ex和接收参数Exception ex同名，表示两个是一致的
	@AfterThrowing(value = "myPointCut()", throwing = "ex")
	public void exceptionAnnouncement(JoinPoint jp, Exception ex) {
		String methodName = jp.getSignature().getName();
		System.out.println("Exception Announcement===> " + "要切入的方法名：" + methodName + "()" + " throwing Exception:" + ex);
	}

	// 环绕通知
	// 切CalculatorImpl类的所有方法参数任意..，异常返回值ex和接收参数Exception ex同名，表示两个是一致的
	@Around("myPointCut()")
	public Object aroundAnnouncement(ProceedingJoinPoint pjp) {
		Object res = null;

		try {
			// 前置通知
			System.out.println("前置通知");
			res = pjp.proceed();
			// 返回通知
			System.out.println("返回通知");
		} catch (Throwable e) {
			// 异常抛出通知
			System.out.println("异常抛出通知");
			e.printStackTrace();
		} finally {
			// 后置（最终）通知
			System.out.println("后置（最终）通知");
		}
		return res;
	}

}

OtherAspect .java

package com.dgut.spring.aop.aspectj;

import java.util.Arrays;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

//创建一个切面
@Component
@Aspect
@Order(1) // 第一个切面，先使用
public class OtherAspect {
	// 前置通知
	// 切CalculatorImpl类的add方法参数任意..，返回值任意*
	@Before("execution(* com.dgut.spring.aop.aspectj.CalculatorImpl.add(..))")
	public void beforeAnnouncement(JoinPoint jp) {
		String methodName = jp.getSignature().getName();
		Object[] args = jp.getArgs();
		System.out.println("<===Before Announcement===> " + "要切入的方法名：" + methodName + "() ，对应的参数：" + Arrays.asList(args));
	}
}

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

4.4.、实例(没有实现接口情况)

在这里插入图片描述
步骤：
(1）开启注解扫描
(2）使用注创建CalculatorImpl和MyAspect（OtherAspect 可选）对象
(3）在增强类上面添加注解@Aspect
(4）在spring配置文件中开启生成代理对象
(4）在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置.
在这里插入图片描述
在这里插入图片描述
MyAspect .java

package com.dgut.spring.aop.aspectj;

import java.util.Arrays;

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.core.annotation.Order;
import org.springframework.stereotype.Component;

//创建一个切面
@Component
@Aspect
@Order(2) // 第二个切面，后使用
public class MyAspect {

	// 重用切入点表达式
	@Pointcut("execution(* com.dgut.spring.aop.aspectj.CalculatorImpl.*(..))")
	public void myPointCut() {

	}

	// 前置通知
	// 切CalculatorImpl类的add方法参数任意..，返回值任意*
	@Before("execution(* com.dgut.spring.aop.aspectj.CalculatorImpl.add(..))")
	public void beforeAnnouncement(JoinPoint jp) {
		String methodName = jp.getSignature().getName();
		Object[] args = jp.getArgs();
		System.out.println("Before Announcement===> " + "要切入的方法名：" + methodName + "() ，对应的参数：" + Arrays.asList(args));
	}

	// 返回通知
	// 切CalculatorImpl类的所有方法参数任意..，返回值为res和参数Object res同名，表示两个是一致的
	@AfterReturning(value = "myPointCut()", returning = "res")
	public void afterReturningAnnouncement(JoinPoint jp, Object res) {
		String methodName = jp.getSignature().getName();
		System.out.println("AfterReturning Announcement===> " + "要切入的方法名：" + methodName + "() ，返回结果：" + res);
	}

	// 后置（最终）通知
	// 切CalculatorImpl类的所有方法参数任意..，返回值任意*
	@After("myPointCut()")
	public void afterAnnouncement(JoinPoint jp) {
		String methodName = jp.getSignature().getName();
		System.out.println("After Announcement===> " + "要切入的方法名：" + methodName + "()");
	}

	// 异常抛出通知
	// 切CalculatorImpl类的所有方法参数任意..，异常返回值ex和接收参数Exception ex同名，表示两个是一致的
	@AfterThrowing(value = "myPointCut()", throwing = "ex")
	public void exceptionAnnouncement(JoinPoint jp, Exception ex) {
		String methodName = jp.getSignature().getName();
		System.out.println("Exception Announcement===> " + "要切入的方法名：" + methodName + "()" + " throwing Exception:" + ex);
	}

	// 环绕通知
	// 切CalculatorImpl类的所有方法参数任意..，异常返回值ex和接收参数Exception ex同名，表示两个是一致的
	@Around("myPointCut()")
	public Object aroundAnnouncement(ProceedingJoinPoint pjp) {
		Object res = null;

		try {
			// 前置通知
			System.out.println("前置通知");
			res = pjp.proceed();
			// 返回通知
			System.out.println("返回通知");
		} catch (Throwable e) {
			// 异常抛出通知
			System.out.println("异常抛出通知");
			e.printStackTrace();
		} finally {
			// 后置（最终）通知
			System.out.println("后置（最终）通知");
		}
		return res;
	}

}

OtherAspect .java

package com.dgut.spring.aop.aspectj;

import java.util.Arrays;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

//创建一个切面
@Component
@Aspect
@Order(1) // 第一个切面，先使用
public class OtherAspect {
	// 前置通知
	// 切CalculatorImpl类的add方法参数任意..，返回值任意*
	@Before("execution(* com.dgut.spring.aop.aspectj.CalculatorImpl.add(..))")
	public void beforeAnnouncement(JoinPoint jp) {
		String methodName = jp.getSignature().getName();
		Object[] args = jp.getArgs();
		System.out.println("<===Before Announcement===> " + "要切入的方法名：" + methodName + "() ，对应的参数：" + Arrays.asList(args));
	}
}

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

4.5、基于XML的AspectJ(作为了解)

基于XML的声明式AspectJ是指通过XML文件来定义切面、切入点及通知，所有的切面、切入点和通知都必须定义在<aop:config>元素内。
在这里插入图片描述

4.5.1、XML文件中常用元素的配置方式如下：

-王二毛-
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring 面向切面编程AOP实现详解
08-25
主要介绍了Spring 面向切面编程AOP实现详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring AOP面向切面编程实现原理方法详解
08-18
主要介绍了Spring AOP面向切面编程实现原理方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring Aop面向切面的java代码
05-23
写了SpringAop的两种代理的实现，jdk动态代理和cglib代理的代码，及测试。
Java实现AOP面向切面编程的实例教程共4页.pdf.z
10-30
Java实现AOP面向切面编程的实例教程共4页.pdf.zip
16.2 Spring框架-AOP面向切面编程
最新发布
04-12
16.2 Spring框架-AOP面向切面编程
JAVA简单AOP切面编程；依赖注入；代码配置Bean源码
10-07
JAVA简单AOP切面编程；依赖注入；代码配置Bean源码 JAVA简单AOP切面编程；依赖注入；代码配置Bean源码
java面向切面编程
DiCaprioleo的博客
11-08 2704
简单描述了面向切面编程的原理
Java基础之面向切面编程（AOP）
qq_53350943的博客
02-19 1407
Java基础之面向切面编程（AOP）面向切面编程中，切面就是可以加入到源功能位置中的代码。
Java切面的实现方式
weixin_49151141的博客
04-04 4861
是指在软件开发中，将某些横跨多个组件的功能，如日志记录、性能监控、权限控制等，抽象出来形成一个独立的模块，称之为切面。切面可以被应用到多个模块中，提供相同的功能。基于继承的切面实现 这种实现方式需要通过继承的方式实现，具体操作为：首先定义一个抽象类，实现该类时可以重写一些方法，从而达到切面的目的。以上是三种实现切面的方式，分别基于继承、代理和注解。其中，基于注解的方式是。的实现方式，而基于继承和代理的方式可以使用。中实现切面的技术有多种，下面分别介绍。
Java教程：SpringBoot项目如何使用自定义注解实现AOP切面功能
wfeil211的博客
03-28 1289
Java教程：SpringBoot项目如何使用自定义注解实现AOP切面功能
Java AOP Framework概述
ttyy1112的专栏
09-18 209
通过上述介绍，希望大家能够明白AspectJ和Spring AOP框架的原理及实现方式，以及了解Spring AOP采用了AspectJ的注解但没有采用其织入方式，而是通过动态代理的方式（JDK动态代理和CGLIB动态代理）生成代理类和代理对象。Spring AOP支持自动代理，如果目标对象实现了接口，则会采用JDK动态代理，如果没有实现接口则采用CGLIB动态代理。可以通过配置改变使用哪种动态代理，Spring Boot2.0前后的默认配置不同等。
【Java 初级】Spring核心之面向切面编程(AOP)
激流丶的博客
06-12 2505
AOP（面向切面编程）是一种编程范式，用于将横切关注点（如日志记录、性能统计等）从主要业务逻辑中分离出来。通过将这些横切关注点与业务逻辑分离开来，可以提高代码的可重用性、可维护性和可扩展性。在AOP中，切面是一个模块化的单元，它封装了与横切关注点相关的行为，并可以在多个不同的应用程序中重用。切面可以通过一种称为“织入”的过程将其与主要业务逻辑相结合，从而创建一个完整的应用程序。
Spring @Aspect、@Before、@After 注解实现 AOP 切面功能
热门推荐
蚩尤后裔-汪茂雄
08-22 5万+
Spring AOP 注解概述 1、Spring 的 AOP 功能除了在配置文件中配置一大堆的配置，比如切入点、表达式、通知等等以外，使用注解的方式更为方便快捷，特别是 Spring boot 出现以后，基本不再使用原先的 beans.xml 等配置文件了，而都推荐注解编程。 @Aspect 切面声明，标注在类、接口（包括注解类型）或枚举上。 @Pointcut 切入点声明，即切入到哪些目标类的目标方法。 value 属性指定切入点表达式，默认为 ""，用于被通知注解引用
JAVA（Spring）学习笔记---＞动态代理+切面
xwe_147jyz的博客
03-28 1284
代理分为静态代理和动态代理，今天笔者就和大家聊一聊动态代理，期间我们加入了切面，笔者并且进行了两个单元测试，一个没有加切面，一个加入切面，我们来看看结果有什么不同，大家就知道笔者加入切面的用意。 首先笔者用一个通俗易懂的例子来概述代理，由浅入深，大家就能理解深入理解代理，希望读者能认真看完，一定会对你们在这一块有所帮助的。 代理： 代理就好比租房子，这个过程中有三方人。第一个是租客，第二个是中介，第三个是房东。那么，代理是什么？这里的代理就是中介，租客只需要找中介租房子，而找房子的事就交个中介就行了，
Spring自定义注解的使用（实现切面aspect）
qq_19891197的博客
10-13 6534
Spring自定义注解的使用（实现切面aspect）
JAVA：面向切面编程AOP
weixin_42277946的博客
06-04 2045
面向切面编程AOP
Java中的面向切面编程（AOP）
pedro7k的博客
04-03 1万+
一、什么是AOP？ Aspect Oriented Programming ，即面向切面编程。 AOP是对面向对象编程的一个补充。 它的目的是将复杂的需求分解为不同的切面，将散布在系统中的公共功能集中解决。 它的实际含义是在运行时将代码切入到类的指定方法、指定位置上，将不同方法的同一个位置抽象为一个切面对象，并对该对象进行编程。 下面是AOP的一个示意图 二、AOP的优点和一些概念 1、AOP的优点 降低模块之间的耦合度 使系统更容易扩展 更好的代码复用 非业务代码更加集中，不分散，便于统一管理
什么是 Java 中的 AOP（面向切面编程）？如何使用它来实现横切关注点？
u013749113的博客
05-15 966
定义一个接口和实现类，其中实现类是目标对象。AOP 是一种重要的编程思想和技术，它允许将横切关注点和主业务逻辑分离，从而实现系统的模块化设计。在 Java 中，AOP 主要通过代理模式和动态字节码生成实现。使用 AOP 实现横切关注点需要定义切面、配置切面和创建代理对象三个步骤。在实际开发中，AOP 可以用于实现日志记录、安全检查、事务管理等横切关注点，从而提高系统的可维护性和可扩展性。
java 切面详解_Java-AOP(面向切面编程)详解
weixin_31115505的博客
02-25 6310
AOP(面向切面编程)是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。(以上为抄的，纯理论)。例如：在一个web工程(利用spring mvc搭建)中做了一个拦截器，拦截所有的url请求，对异常的请求进行拦截，实现安全...
spring aop面向切面编程
08-15
对的，Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一个重要特性。它允许开发者通过在应用程序中定义横切关注点（cross-cutting concerns），将这些关注点与核心业务逻辑分离开来。 在传统的面向对象编程中，我们通常将核心业务逻辑集中在一个或多个类中，然后通过在这些类中调用其他类或方法来实现特定功能。这样做的问题是，横切关注点（如日志记录、事务管理、安全检查等）会被散布在各个类和方法中，导致代码的重复性和难以维护性。 而使用Spring AOP，我们可以通过定义切面（Aspect）来集中处理这些横切关注点。切面是一个模块化单元，它包含了一组通知（Advice），以及定义了切入点（Pointcut）的规则。通知定义了在切入点执行前、执行后、抛出异常时等不同时间点要执行的逻辑。 通过将切面与核心业务逻辑进行织入（Weaving），即将切面的逻辑插入到核心业务逻辑中，我们可以实现横切关注点的功能，并且不需要修改原有的业务逻辑代码。 总结来说，Spring AOP提供了一种解耦横切关注点与核心业务逻辑的方式，使得应用程序的代码更加清晰、模块化，同时也提高了代码的可重用性和可维护性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值