Java Web —— 第十天（AOP切面编程）

2024-08-31 04:04
文章标签 java web 编程 aop 切面 第十天

本文主要是介绍Java Web —— 第十天（AOP切面编程），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

AOP基础

AOP概述

AOP:Aspect Oriented Programming(面向切面编程、面向方面编程)，其实就是面向特定方法编程场景

案例部分功能运行较慢，定位执行耗时较长的业务方法，此时需要统计每一个业务方法的执行耗时

实现:

动态代理是面向切面编程最主流的实现。而SpringAOP是Spring框架的高级技术，旨在管理bean对象的过程中，主要通过底层的动态代理机制，对特定的方法进行编程 

Spring AOP快速入门

步骤: 统计各个业务层方法执行耗时

1.导入依赖:在pom.xml中导入AOP的依赖

        <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency>

2.编写AOP程序:针对于特定方法根据业务需要进行编程

package com.example.aop;import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;/*** @author hyk~*/@Slf4j
@Component //当前类交给IOC容器管理
@Aspect //当前类是一个AOP类
public class TimeAspect {@Around("execution(* com.example.service.*.*(..))") //切入点表达式public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {//1.记录开始时间long begin = System.currentTimeMillis();//2.调用原始方法运行Object result = joinPoint.proceed();//3.记录结束时间，计算方法执行耗时long end = System.currentTimeMillis();log.info(joinPoint.getSignature()+"方法执行耗时：{}ms",end-begin);return result;}}

3.运行测试

场景

记录操作日志

权限控制

事务管理

...

优势

代码无侵入

减少重复代码

提高开发效率

维护方便

AOP核心概念

连接点:JoinPoint，可以被AOP控制的方法(暗含方法执行时的相关信息)

通知:Advice，指哪些重复的逻辑，也就是共性功能(最终体现为一个方法)

切入点: PointCut，匹配连接点的条件，通知仅会在切入点方法执行时被应用

切面:Aspect，描述通知与切入点的对应关系 (通知+切入点)

目标对象: Target，通知所应用的对象

AOP执行流程

AOP进阶

通知类型

1.@Around: 环绕通知，此注解标注的通知方法在目标方法前、后都被执行

2.@Before:前置通知，此注解标注的通知方法在目标方法前被执行

3.@After:后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行

4.@AfterReturning:返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执

5.@AfterThrowing:异常后通知，此注解标注的通知方法发生异常后执行

package com.itheima.aop;import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;/*** 使用 Lombok 提供的 @Slf4j 注解，自动为该类生成日志记录器。*/
@Slf4j
/*** 将该类标记为 Spring 管理的组件，使其能够被 Spring 自动检测并注入。*/
@Component
/*** @Aspect 注解将该类声明为一个切面类，用于定义切点和通知。如果解开此注解，MyAspect1 类将作为一个切面生效。*/
// @Aspect
public class MyAspect1 {/*** 定义一个切点（Pointcut），表示在哪些方法或类上应用通知。* 此处的切点表达式为 execution(* com.itheima.service.impl.DeptServiceImpl.*(..))，* 表示切点是 com.itheima.service.impl.DeptServiceImpl 类中的所有方法。*/@Pointcut("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")public void pt() {}/*** 前置通知（Before advice），在目标方法执行之前执行。* 当 DeptServiceImpl 类中的任意方法被调用时，会先执行此通知。*/@Before("pt()")public void before() {log.info("before ...");}/*** 环绕通知（Around advice），在目标方法执行前后分别执行。* 该方法可以控制目标方法是否执行，甚至可以在执行前后添加自定义逻辑。** @param proceedingJoinPoint 用于控制目标方法的执行* @return 目标方法的返回值* @throws Throwable 可能抛出的异常*/@Around("pt()")public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {log.info("around before ...");// 调用目标对象的原始方法并获取其返回值Object result = proceedingJoinPoint.proceed();log.info("around after ...");return result;}/*** 后置通知（After advice），在目标方法执行完毕后执行，无论方法是否抛出异常。*/@After("pt()")public void after() {log.info("after ...");}/*** 返回通知（AfterReturning advice），在目标方法成功执行并返回结果后执行。* 如果方法抛出异常，则不会执行此通知。*/@AfterReturning("pt()")public void afterReturning() {log.info("afterReturning ...");}/*** 异常通知（AfterThrowing advice），在目标方法抛出异常后执行。*/@AfterThrowing("pt()")public void afterThrowing() {log.info("afterThrowing ...");}
}

正常运行 

有异常时

注意事项

@Around环绕通知需要自己调用 ProceedingJoinPoint.proceed() 来让原始方法执行，其他通知不需要考虑目标方法执行

@Around环绕通知方法的返回值，必须指定为object，来接收原始方法的返回值

@PointCut

该注解的作用是将公共的切点表达式抽取出来，需要用到时引用该切点表达式即可

通知顺序

当有多个切面的切入点都匹配到了目标方法，目标方法运行时，多个通知方法都会被执行

执行顺序

1.不同切面类中，默认按照切面类的类名字母排序:

目标方法前的通知方法:字母排名靠前的先执行

目标方法后的通知方法:字母排名靠前的后执行

2.用 @Order(数字) 加在切面类上来控制顺序

目标方法前的通知方法:数字小的先执行

目标方法后的通知方法:数字小的后执行

切入点表达式

切入点表达式:描述切入点方法的一种表达式

作用:主要用来决定项目中的哪些方法需要加入通知

常见形式

1.execution(.....):根据方法的签名来匹配

2.@annotation(.....) :根据注解匹配

切入点表达式-execution

execution 主要根据方法的返回值、包名、类名、方法名、方法参数等信息来匹配，语法为:

execution(访问修饰符? 返回值 包名.类名.?方法名(方法参数) throws 异常?)

其中带?的表示可以省略的部分

访问修饰符:可省略 (比如: public、protected)

包名.类名: 可省略

throws 异常:可省略(注意是方法上声明抛出的异常，不是实际抛出的异常)

使用通配符描述切入点

切入点表达式的语法规则：

1. 方法的访问修饰符可以省略

2. 返回值可以使用 * 号代替（任意返回值类型）

3. 包名可以使用 * 号代替，代表任意包（一层包使用一个 * ）

4. 使用 .. 配置包名，标识此包以及此包下的所有子包

5. 类名可以使用 * 号代替，标识任意类

6. 方法名可以使用 * 号代替，表示任意方法

7. 可以使用 * 配置参数，一个任意类型的参数

8. 可以使用 .. 配置参数，任意个任意类型的参数

同时匹配这两个方法

 @Pointcut("execution(* com.itheima.service.DeptService.list()) ||"+"execution(* com.itheima.service.DeptService.delete(java.lang.Integer))")private void pt(){}@Before("pt()")public void before(){log.info("MyAspect6 ... before ...");}

注意事项

根据业务需要，可以使用且 (&&)、或()、非(!)来组合比较复杂的切入点表达式

书写建议

所有业务方法名在命名时尽量规范，方便切入点表达式快速匹配。如:查询类方法都是find 开头，更新类方法都是update开头

描述切入点方法通常基于接口描述，而不是直接描述实现类，增强拓展性

在满足业务需要的前提下，尽量缩小切入点的匹配范围。如:包名匹配尽量不使用..，使用*匹配单个包

@annotation

@annotation 切入点表达式，用于匹配标识有特定注解的方法

@annotation(com.itheima.anno.Log)

实现步骤：

1. 编写自定义注解

自定义注解：MyLog

@Retention(RetentionPolicy.RUNTIME) // 该注解在运行时可用
@Target(ElementType.METHOD) // 该注解只能用于方法
public @interface MyLog {
}

2. 在业务类要做为连接点的方法上添加自定义注解

业务类：DeptServiceImpl

连接点

在Spring中用JoinPoint抽象了连接点，用它可以获得方法执行时的相关信息，如目标类名、方法 名、方法参数等。

对于@Around通知，获取连接点信息只能使用ProceedingJoinPoint类型

对于其他四种通知，获取连接点信息只能使用JoinPoint，它是ProceedingJoinPoint的父类型

package com.itheima.aop;import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
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;import java.util.Arrays;//切面类
@Slf4j
@Aspect
@Component
public class MyAspect8 {@Pointcut("execution(* com.itheima.service.DeptService.*(..))")private void pt(){}@Before("pt()")public void before(JoinPoint joinPoint){log.info("MyAspect8 ... before ...");}@Around("pt()")public Object around(ProceedingJoinPoint joinPoint) throws Throwable {log.info("MyAspect8 around before ...");//1. 获取 目标对象的类名 .String name1 = joinPoint.getTarget().getClass().getName();log.info("目标对象的类名：{}",name1);//2. 获取 目标方法的方法名 .String name2 = joinPoint.getSignature().getName();log.info("目标方法的方法名:{}",name2);//3. 获取 目标方法运行时传入的参数 .Object[] args = joinPoint.getArgs();log.info("目标方法运行时传入的参数:{}",Arrays.toString(args));//4. 放行 目标方法执行 .Object result = joinPoint.proceed();//5. 获取 目标方法运行的返回值 .log.info("目标方法运行的返回值:{}",result);log.info("MyAspect8 around after ...");return result;}
}

AOP案例

案例

将案例中 增、删、改 相关接口的操作日志记录到数据库表中

就是当访问部门管理和员工管理当中的增、删、改相关功能接口时，需要详细的操作日志，并保存 在数据表中，便于后期数据追踪。

操作日志信息包含： 操作人、操作时间、执行方法的全类名、执行方法名、方法运行时参数、返回值、方法执行时长

1. AOP起步依赖
<!--AOP起步依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
2. 导入准备好的数据库表结构

并引入对应的实体类 数据表

-- 操作日志表
create table operate_log(id int unsigned primary key auto_increment comment 'ID',operate_user int unsigned comment '操作人',operate_time datetime comment '操作时间',class_name varchar(100) comment '操作的类名',method_name varchar(100) comment '操作的方法名',method_params varchar(1000) comment '方法参数',return_value varchar(2000) comment '返回值',cost_time bigint comment '方法执行耗时, 单位:ms'
) comment '操作日志表';
3.实体类
//操作日志实体类
@Data
@NoArgsConstructor
@AllArgsConstructor
public class OperateLog {private Integer id; //主键IDprivate Integer operateUser; //操作人IDprivate LocalDateTime operateTime; //操作时间private String className; //操作类名private String methodName; //操作方法名private String methodParams; //操作方法参数private String returnValue; //操作方法返回值private Long costTime; //操作耗时
}
4.Mapper接口
@Mapper
public interface OperateLogMapper {@Insert("insert into operate_log (operate_user, operate_time,class_name, method_name, method_params, return_value, cost_time)" +" values (#{operateUser}, #{operateTime}, #{className}, #{methodName}, #{methodParams}, #{returnValue}, #{costTime})")void insert(OperateLog operateLog);
5.自定义注解@Log
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Log {
}
6.修改业务实现类

在增删改业务方法上添加@Log注解

7.定义切面类，完成记录操作日志的逻辑
package com.example.aop;import com.alibaba.fastjson.JSONObject;
import com.example.mapper.OperateLogMapper;
import com.example.pojo.OperateLog;
import com.example.utils.JwtUtils;
import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
import java.util.Arrays;/*** @author hyk~*/
@Slf4j // 为当前类引入日志功能，方便打印日志信息
@Component // 将当前类作为一个组件管理起来，Spring会自动扫描并管理它
@Aspect // 声明该类为一个切面类，用于定义横切关注点，即对方法执行前后进行拦截和处理
public class LogAspect {@Autowiredprivate HttpServletRequest request; // 自动注入HttpServletRequest对象，用于获取请求信息@Autowiredprivate OperateLogMapper operateLogMapper; // 自动注入OperateLogMapper对象，用于操作数据库记录操作日志@Around("@annotation(com.example.anno.Log)") // 环绕通知：拦截被@Log注解标记的方法，执行前后插入额外逻辑public Object recordLog(ProceedingJoinPoint joinPoint) throws Throwable {// 获取请求头中的JWT令牌并解析，提取操作人的IDString jwt = request.getHeader("token"); // 从请求头中获取JWT令牌Claims claims = JwtUtils.parseJWT(jwt); // 解析JWT令牌，获取其中的声明Integer operateUser = (Integer) claims.get("id"); // 从声明中提取操作人ID// 获取操作时间，记录当前时间LocalDateTime operateTime = LocalDateTime.now();// 获取操作的类名，通过连接点获取目标类的名称String className = joinPoint.getTarget().getClass().getName();// 获取操作的方法名，通过连接点获取目标方法的名称String methodName = joinPoint.getSignature().getName();// 获取操作方法的参数，通过连接点获取方法的参数，并转换为字符串Object[] args = joinPoint.getArgs();String methodParams = Arrays.toString(args);// 记录操作开始时间，用于计算操作耗时Long begin = System.currentTimeMillis();// 调用目标方法，执行被拦截的方法Object result = joinPoint.proceed();// 记录操作结束时间Long end = System.currentTimeMillis();// 获取操作方法的返回值，并转换为JSON字符串String returnValue = JSONObject.toJSONString(result);// 计算操作耗时Long costTime = end - begin;// 创建操作日志对象，包含操作人、操作时间、类名、方法名、参数、返回值和耗时等信息OperateLog operateLog = new OperateLog(null, // 日志的主键ID，通常由数据库自动生成operateUser, // 操作人IDoperateTime, // 操作时间className, // 操作类名methodName, // 操作方法名methodParams, // 操作方法参数returnValue, // 操作方法返回值costTime // 操作耗时);// 将操作日志插入数据库，持久化存储operateLogMapper.insert(operateLog);// 打印操作日志，记录到日志文件中log.info("AOP操作日志：{}", operateLog);// 返回目标方法的执行结果return result;}
}
解释
  • @Aspect：定义了一个切面，用于在方法执行的前后插入逻辑。
  • @Around：使用环绕通知，拦截指定注解标记的方法，在其执行前后添加逻辑。
  • 日志记录逻辑：每次有标记了@Log注解的方法被调用时，都会记录操作人的ID、操作的时间、类名、方法名、参数、返回值及耗时，并将这些信息存储到数据库中。

这篇关于Java Web —— 第十天（AOP切面编程）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1122832。

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
JAVA智听未来一站式有声阅读平台听书系统小程序源码

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来，一站式有声阅读平台听书系统 🌟&nbsp;开篇：遇见未来，从“智听”开始 在这个快节奏的时代，你是否渴望在忙碌的间隙，找到一片属于自己的宁静角落？是否梦想着能随时随地，沉浸在知识的海洋，或是故事的奇幻世界里？今天，就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统，它正悄悄改变着我们的阅读方式，让未来触手可及！ 📚&nbsp;第一站：海量资源，应有尽有 走进“智听
阅读更多...
Linux 网络编程 --- 应用层

Linux 网络编程 --- 应用层

一、自定义协议和序列化反序列化 代码： 序列化反序列化实现网络版本计算器 二、HTTP协议 1、谈两个简单的预备知识 https://www.baidu.com/ --- 域名 --- 域名解析 --- IP地址 http的端口号为80端口，https的端口号为443 url为统一资源定位符。CSDNhttps://mp.csdn.net/mp_blog/creation/editor
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2