SpringBoot如何使用AOP实现统计全局接口访问次数
AOP是什么AOP（AspectOrientedProgramming），也就是面向切面编程，是通过预编译方式和运行期间动态代理实现程序功能的传统已维护的一种技术。AOP的作用和优势作用：在程序运行期间，在不修改源代码的情况下对某些方法进行功能增强优势：减少重复代码，提高开发效率，并且便于维护常见的动态代理技术jdk代理：基于接口的动态代理技术cglib代理：基于父类的动态代理技术AOP相关概念Listitem-Target（目标对象）：代理的目标对象Proxy（代理）：一个类被AOP织入增强后，就产生一
AOP是什么
AOP（Aspect Oriented Programming），也就是面向切面编程，是通过预编译方式和运行期间动态代理实现程序功能的传统已维护的一种技术。
AOP的作用和优势
作用：在程序运行期间，在不修改源代码的情况下对某些方法进行功能增强
优势：减少重复代码，提高开发效率，并且便于维护
常见的动态代理技术
jdk代理：基于接口的动态代理技术
cglib代理：基于父类的动态代理技术
AOP相关概念
List item- Target（目标对象）：代理的目标对象
Proxy（代理）：一个类被AOP织入增强后，就产生一个结果代理类
Joinpoint（连接点）：连接点是指那些被拦截到的点。在Spring中，这些点指的是方法，因为Spring只支持方法类型的连接点（可以被增强的方法叫连接点）
PointCut（切入点）：切入点是指我们要对哪些Joinpoint进行拦截的定义
Advice（通知/增强）：通知是指拦截到Joinpoint之后所要做的事情就是通知
Aspect（切面）：是切入点和通知的结合
Weaving（织入）：把增强应用到目标对象来创建新的代理对象的过程。Spring采用动态代理织入，而AspectJ采用编译器织入和类装载器织入
实现
我在这里采用基于注解形式的的AOP开发。
开发步骤
加入依赖
org.springframework.boot spring-boot-starter-aop org.aspectj aspectjrt 1.9.4 org.aspectj aspectjweaver 1.9.4 cglib cglib 3.2.12
创建目标接口和目标类（内部有切点）
创建切面类（内部有增强方法）
将目标类和切面类的对象创建权交给Spirng
在切面类中使用注解配置织入关系
在配置文件中开启组件扫描和AOP自动代理
因为我的项目是SpringBoot Web项目，在这里开启注解就好了。
下面的代码为使用到的原子计数类。
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicCounter {
private static final AtomicCounter atomicCounter = new AtomicCounter();
/**
* 单例，不允许外界主动实例化
*/
private AtomicCounter() {
}
public static AtomicCounter getInstance() {
return atomicCounter;
}
private static AtomicInteger counter = new AtomicInteger();
public int getValue() {
return counter.get();
}
public int increase() {
return counter.incrementAndGet();
}
public int decrease() {
return counter.decrementAndGet();
}
// 清零
public void toZero(){
counter.set(0);
}
}下面的代码为实现的全局接口监控。
我在项目中简单使用了Redis作缓存，所有你可以看到有Redis相关的操作。
使用 @Before 用于配置前置通知。指定增强的方法在切入点方法之前执行。
使用@ @AfterReturning 用于配置后置通知。指定增强的方法在切入点方法之后执行。
使用@ @AfterThrowing 用于配置异常抛出通知。指定增强的方法在出现异常时执行。
@Component
@Aspect
public class GlobalActuator {
private static final Logger log = LoggerFactory.getLogger(GlobalActuator.class);
@Resource
private StringRedisTemplate stringRedisTemplate;
ThreadLocal startTime = new ThreadLocal<>();
ConcurrentHashMap countMap = new ConcurrentHashMap();
/**
* 匹配控制层层通知 这里监控controller下的所有接口
*/
@Pointcut("execution(* com.sf.controller.*Controller.*(..))")
private void controllerPt() {
}
/**
* 在接口原有的方法执行前，将会首先执行此处的代码
*/
@Before("com.sf.actuator.GlobalActuator.controllerPt()")
public void doBefore(JoinPoint joinPoint) throws Throwable {
startTime.set(System.currentTimeMillis());
//获取传入目标方法的参数
Object[] args = joinPoint.getArgs();
}
/**
* 只有正常返回才会执行此方法
* 如果程序执行失败，则不执行此方法
*/
@AfterReturning(returning = "returnVal", pointcut = "com.sf.actuator.GlobalActuator.controllerPt()")
public void doAfterReturning(JoinPoint joinPoint, Object returnVal) throws Throwable {
Signature signature = joinPoint.getSignature();
String declaringName = signature.getDeclaringTypeName();
String methodName = signature.getName();
String mapKey = declaringName + methodName;
// 执行成功则计数加一
int increase = AtomicCounter.getInstance().increase();
HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
synchronized (this) {
//在项目启动时，需要在Redis中读取原有的接口请求次数
if (countMap.size() == 0) {
JSONObject jsonObject = RedisUtils.objFromRedis(StringConst.INTERFACE_ACTUATOR);
if (jsonObject != null) {
Set strings = jsonObject.keySet();
for (String string : strings) {
Object o = jsonObject.get(string);
countMap.putIfAbsent(string, o);
}
}
}
}
// 如果此次访问的接口不在countMap，放入countMap
countMap.putIfAbsent(mapKey, 0);
countMap.compute(mapKey, (key, value) -> (Integer) value + 1);
synchronized (this) {
// 内存计数达到30 更新redis
if (increase == 30) {
RedisUtils.objToRedis(StringConst.INTERFACE_ACTUATOR, countMap, Constants.AVA_REDIS_TIMEOUT);
//删除过期时间
stringRedisTemplate.persist(StringConst.INTERFACE_ACTUATOR);
//计数器置为0
AtomicCounter.getInstance().toZero();
}
}
//log.info("方法执行次数:" + mapKey + "------>" + countMap.get(mapKey));
//log.info("URI:[{}], 耗费时间:[{}] ms", request.getRequestURI(), System.currentTimeMillis() - startTime.get());
}
/**
* 当接口报错时执行此方法
*/
@AfterThrowing(pointcut = "com.sf.actuator.GlobalActuator.controllerPt()")
public void doAfterThrowing(JoinPoint joinPoint) {
HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
log.info("接口访问失败，URI:[{}], 耗费时间:[{}] ms", request.getRequestURI(), System.currentTimeMillis() - startTime.get());
}
} 这里再给出Controller层代码。
@GetMapping("/interface/{intCount}")
@ApiOperation(value = "查找接口成功访问次数（默认倒序）")
public Result> findInterfaceCount(
@ApiParam(name = "intCount", value = "需要的接口数") @PathVariable Integer intCount
) {
HashMap hashMap = new HashMap<>();
JSONObject jsonObject = RedisUtils.objFromRedis(StringConst.INTERFACE_ACTUATOR);
if (jsonObject != null) {
Set strings = jsonObject.keySet();
for (String string : strings) {
Integer o = (Integer) jsonObject.get(string);
hashMap.putIfAbsent(string, o);
}
}
//根据value倒序
Map sortedMap = hashMap.entrySet().stream().sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
//返回列表
List resultList = new ArrayList<>();
//排序后中的map中所有的key
Object[] objects = sortedMap.keySet().toArray();
for (int i = 0; i < intCount; i++) {
InterfaceDto interfaceDto = new InterfaceDto();
interfaceDto.setName((String) objects[i]);
interfaceDto.setCount(sortedMap.get((String) objects[i]));
resultList.add(interfaceDto);
}
return Result.success(resultList);
} 项目运行一段时间后，在Redis中可以看到接口的请求次数。
Web最终效果图如下：
AOP日志记录通过将日志功能与业务逻辑解耦，使代码更清晰、维护更便捷。1.首先需引入SpringAOP和AspectJ依赖；2.定义切点（Pointcut）指定拦截方法；3.编写通知（Advice）处理日志逻辑，如@Before、@AfterReturning等；4.创建切面（Aspect）整合切点与通知，并标注@Aspect和@Component；5.启用AOP自动代理。敏感数据可通过脱敏、限制记录字段或调整日志级别来避免泄露。性能影响取决于日志复杂度，建议异步记录和优化操作。选择切点表达式时应结合方法
SpringAOP基于Java动态代理来实现面向方面编程，允许在不修改原始代码情况下，在方法执行前后插入附加逻辑。具体步骤如下：创建代理对象，使用Proxy.newProxyInstance()方法，提供类加载器、接口和调用处理器。调用处理器的invoke()方法，获取目标对象、拦截器链，并依次调用拦截器invoke()。最后，如果没有异常，调用目标对象的方法。
随着软件开发的不断发展，越来越多的编程语言和技术层出不穷。其中，PHP作为一门广泛应用于Web开发的脚本语言，在不断发展和革新的过程中，也涌现出了许多重要的概念和技术，如面向对象编程（OOP）、设计模式等，而今天我们要探讨的是PHP中的另一种编程方式——面向切面编程（AOP）。什么是AOP？AOP，全称是Aspect-OrientedProgramming
springBoot项目常用目录springBoot项目的目录结构及名规范介绍基于SpringBoot开发时的目录结构及命名规范，通过介绍能够为你解决，在实际项目中如何规划目录结构？如何命名目录更规范？各个目录分别代表什么含义？等三个问题。目录说明servicex//项目名|-admin-ui//管理服务前端代码(一般将UI和SERVICE放到一个工程中，便于管理)|-servicex-auth//模块1|-servicex-common//模块2|-servicex-gateway//模块3|-serv
SpringBoot的架构可以分为以下几个主要组件：Spring核心模块：springBoot的核心模块提供了Spring框架的基本功能，包括依赖注入、aop、事务管理等。这些模块是Spring应用程序的基础，为SpringBoot的开发提供了坚实的基础。SpringBootStarter：SpringBootStarter是一个预先配置好的依赖项集合，它可以帮助开发者快速构建Spring应用程序。SpringBootStarter提供了各种各样的依赖项，涵盖了各种常用的功能，如web开发、数据访问、安全
解析SpringBoot和SpringMVC之间的异同SpringBoot和SpringMVC是Java领域中非常重要的开发框架。虽然它们都属于Spring框架的一部分，但是在使用和功能上有一些明显的区别。本文将对SpringBoot和SpringMVC进行比较，解析它们之间的异同。首先，让我们来了解一下SpringBoot。SpringBo
探索Spring中AOP的常见应用方式概述：随着软件开发的不断发展，业务逻辑的复杂性也日益增加。为了提高代码的可维护性和重用性，以及实现切面关注点的分离，面向切面编程（AOP）的概念被引入到软件开发中。Spring框架是Java开发中广泛应用的框架之一，也提供了强大的AOP支持。本文将探索Spring中AOP的常见应用方式，并提供具体的代码示例。一、前置通知
Spring中AOP的常见应用方式解析引言：在软件开发过程中，面向切面编程（AOP）是一种很重要的技术，它能够通过在程序运行期间动态地将特定的代码片段织入到目标方法中，提供额外的功能和扩展。而Spring作为一个强大的开发框架，提供了丰富的AOP支持，本文将详细介绍Spring中AOP的常见应用方式，包括声明式和编程式两种方式，并提供具体的代码示例。一、声明
近年来，随着云计算和分布式架构的兴起，微服务架构的应用越来越广泛。而SpringCloud和SpringBoot作为Java开发中的两个重要框架，对于微服务的实现起到了重要的作用。然而，很多人对于它们在微服务领域的不同应用方式还存在一定的疑惑。本文将从不同的角度探索SpringCloud和SpringBoot在微服务中的应用方式。首先，我们来了解一下Spri
SpringBoot与SpringMVC的不同之处在哪里？SpringBoot和SpringMVC是两个非常流行的Java开发框架，用于构建Web应用程序。尽管它们经常分别被使用，但它们之间的不同之处也是很明显的。首先，SpringBoot可以被看作是一个Spring框架的扩展或者增强版。它旨在简化Spring应用程序的初始化和配置过程，以帮助开发人
火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力，依托字节自研豆包多模态大模型，凭借火山方舟一站式平台，提供模型精调、推理部署、智能应用搭建等全链路服务，结合高性能AI算力，助力各行业快速落地大模型数字化与智能化应用。
