当前位置：首页 > news >正文

项目拓展-Apache对象池，对象池思想结合ThreadLocal复用日志对象

news 来源：原创 2025/6/15 7:34:46

优化日志对象创建以及日志对象复用

日志对象上下文实体类

traceId

请求到达时间戳

请求完成时间戳

请求总共耗费时长

get/post/put/delete请求方式

Http状态码

原始请求头中的所有键值对

请求体内容

响应体内容

失败Exception信息详细记录

是否命中缓存

package com.kira.scaffoldmvc.CommonPool;import lombok.Data;
import lombok.experimental.Accessors;/*** RTA代理上下文：存储请求处理全流程的关键信息* 设计特点：* - 线程隔离：通过ThreadLocal管理，确保每个请求独立使用* - 链式调用：通过@Accessors(chain = true)支持方法链风格* - 全量数据：包含请求、响应、转发和缓存等完整生命周期信息*/
@Data
@Accessors(chain = true)
public class RtaProxyContext {/*** 全局唯一请求ID（TraceID）* 用于全链路追踪，关联请求与响应日志*/private String reqXid;/*** 请求到达时间戳（毫秒）* 用于计算请求处理耗时*/private long reqTime;/*** 请求路径*/private String url;/*** HTTP请求方法（GET/POST等）*/private String reqType;/*** 请求头信息* 存储原始HTTP请求头的键值对*/private Object reqHeaders;/*** 请求体内容* 通常为JSON格式的广告请求参数*/private Object reqBody;/*** 响应体内容* 最终返回给客户端的内容*/private Object respBody;/*** HTTP响应状态码* 如200、403、500等*/private Integer respCode;/*** 响应完成时间戳（毫秒）* 用于计算总处理耗时：respTime - reqTime*/private long respTime;/*** 错误详情* 当请求处理过程中发生异常时记录*/private String errorDetails;/*** 请求体填充率* 广告请求中有效流量占比，范围0.0-1.0*/private double reqBodyFillRate;/*** 是否命中缓存标识* true表示响应数据来自缓存而非实时计算*/private Boolean cached = false;}

RtaProxyContextHolder-对象池定义与封装

最小空闲对象数：200（系统启动的时候预热）

最大空闲对象数：600

最大对象数：1000

setMaxTotal(1000)：池内对象的最大数量（活跃 + 空闲）

setMaxIdle(600)：最大空闲对象数，超过此数量的空闲对象将被销毁

setMinIdle(200)：最小空闲对象数，池会自动维持此数量的空闲对象

package com.kira.scaffoldmvc.CommonPool;import lombok.Data;
import lombok.experimental.Accessors;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;//ThreadLocal结合对象池,封装了对象池的相关操作
@Slf4j
public class RtaProxyContextHolder {private static final ThreadLocal<RtaProxyContext> CONTEXT_HOLDER = new ThreadLocal<>();public static final GenericObjectPool<RtaProxyContext> RTA_PROXY_CONTENT_POOL = new GenericObjectPool<>(new RtaProxyContextFactory(),//对象池工厂new GenericObjectPoolConfig<>() {{//对象池配置setMaxTotal(1000);//最大对象数setMaxIdle(600);//最大空闲对象数setMinIdle(200);//最小空闲对象数}});//自定义对象池工厂private static class RtaProxyContextFactory extends BasePooledObjectFactory<RtaProxyContext> {//创建新对象@Overridepublic RtaProxyContext create() {return new RtaProxyContext();}//负责将新创建或从其他地方获取的 RtaProxyContext 对象包装成 PooledObject<RtaProxyContext> 类型的对象// 这里使用 DefaultPooledObject 进行包装，以便对象池进行统一管理//将其他地方的对象(例如不是对象池创建的对象)转换成对象池对象实现复用@Overridepublic PooledObject<RtaProxyContext> wrap(RtaProxyContext context) {return new DefaultPooledObject<>(context);}@Overridepublic void destroyObject(PooledObject<RtaProxyContext> p) {// 销毁对象的逻辑}}public static RtaProxyContext getContext() {return CONTEXT_HOLDER.get();}public static RtaProxyContext borrowContext() {RtaProxyContext rtaProxyContext;try {//先从对象池获取对象rtaProxyContext = RTA_PROXY_CONTENT_POOL.borrowObject();} catch (Exception e) {//对象池获取对象失败,为了保证对象池可以成功创建,所以要new一个对象rtaProxyContext = new RtaProxyContext();log.warn("Failed to pull from pool");}//将详细的日志对象放到ThreadLocal里面CONTEXT_HOLDER.set(rtaProxyContext);return rtaProxyContext;}public static void returnContext(RtaProxyContext context) {//将日志对象从ThreadLocal中移除CONTEXT_HOLDER.remove();//将原本的日志对象的大部分值变成空值if (context != null) {try {context.setReqXid(null);context.setReqTime(-1);context.setReqType(null);context.setReqHeaders(null);context.setReqBody(null);context.setRespBody(null);context.setRespCode(-1);context.setRespTime(-1);context.setErrorDetails(null);context.setReqBodyFillRate(-1);context.setCached(false);RTA_PROXY_CONTENT_POOL.returnObject(context);} catch (Exception e) {log.warn("Failed to return to pool");}}}//日志打印对象池的状态public static void printPoolStatus() {log.info("Context Pool状态, 活跃对象数 {}, 空闲对象数 {}, 等待获取对象的线程数 {}, 对象创建总次数 {}, 对象销毁总次数 {}.",RTA_PROXY_CONTENT_POOL.getNumActive(),RTA_PROXY_CONTENT_POOL.getNumIdle(),RTA_PROXY_CONTENT_POOL.getNumWaiters(),RTA_PROXY_CONTENT_POOL.getCreatedCount(),RTA_PROXY_CONTENT_POOL.getDestroyedCount());}// 动态调整对象池配置public static void adjustPoolConfig(int maxTotal, int maxIdle, int minIdle) {GenericObjectPoolConfig<RtaProxyContext> config = new GenericObjectPoolConfig<>();config.setMaxTotal(maxTotal);config.setMaxIdle(maxIdle);config.setMinIdle(minIdle);// 应用新配置RTA_PROXY_CONTENT_POOL.setConfig(config);log.info("对象池配置已更新: maxTotal={}, maxIdle={}, minIdle={}", maxTotal, maxIdle, minIdle);}}

RtaProxyContextHolder-请求拦截器

package com.kira.scaffoldmvc.CommonPool;import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.HandlerInterceptor;import java.util.Collections;
import java.util.stream.Collectors;/*** HTTP请求拦截器：管理请求生命周期内的上下文对象(RtaProxyContext)* 主要功能：* 1. 请求进入时从对象池获取上下文对象并初始化* 2. 请求处理过程中通过ThreadLocal存储上下文* 3. 请求结束后记录日志并归还对象到池** 线程安全机制：* - 使用ThreadLocal确保每个请求线程拥有独立的上下文实例* - 对象池复用机制减少频繁创建/销毁对象的开销*/
@Component
@RequiredArgsConstructor
public class RtaProxyContextInterceptor implements HandlerInterceptor {private final LogService logService;@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {// 1. 从对象池获取可复用的上下文对象//    若池为空则创建新对象，避免频繁new操作带来的GC压力RtaProxyContext rtaProxyContext = RtaProxyContextHolder.borrowContext();// 2. 初始化上下文：设置请求基础信息rtaProxyContext.setReqTime(System.currentTimeMillis())//请求时间戳.setReqXid(request.getHeader("traceId"))// 全局唯一请求ID(traceId).setReqType(request.getMethod())// HTTP方法(GET/POST等).setReqHeaders(Collections.list(request.getHeaderNames())//请求头信息.stream().collect(Collectors.toMap(name -> name, request::getHeader))).setUrl(request.getRequestURI());//请求url// 3. 放行请求继续处理链return true;}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {// 1. 从当前线程获取上下文对象//    确保与preHandle中设置的是同一个实例RtaProxyContext rtaProxyContext = RtaProxyContextHolder.getContext();// 2. 补充响应信息：状态码、响应时间、异常详情rtaProxyContext.setRespCode(response.getStatus())               // HTTP响应状态码.setRespTime(System.currentTimeMillis())                   // 响应完成时间.setErrorDetails(ex != null ? ex.getMessage() : null);    // 异常信息(若有)// 3. 针对特定API路径记录详细日志//    注意：此处硬编码路径需根据实际业务调整if ("/api/v1/aff_rta".equals(request.getRequestURI())) {//因为该日志是打印对象信息,所以封装了对应的实现类logService.logRtaAccess(RtaAccessLog.from(rtaProxyContext));     // 记录访问日志}// 4. 关键资源回收步骤：//    - 从ThreadLocal中移除引用，防止内存泄漏//    - 重置对象状态并归还到对象池供后续请求复用RtaProxyContextHolder.returnContext(rtaProxyContext);}
}

定时任务-打印对象池状态

package com.kira.scaffoldmvc.CommonPool;import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;@Component
public class SysMonitorConfig {@Scheduled(fixedRateString = "${sys.monitor.pool.rate:300000}")public void monitorContextPool() {RtaProxyContextHolder.printPoolStatus();}}

定时任务-自适应调整对象池参数

package com.kira.scaffoldmvc.CommonPool;import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;import java.util.ArrayList;
import java.util.concurrent.ConcurrentLinkedQueue;import static com.kira.scaffoldmvc.CommonPool.RtaProxyContextHolder.RTA_PROXY_CONTENT_POOL;@Component
public class SysMonitorConfig {// 滑动窗口配置private final ArrayList<Integer> list = new ArrayList<>();//最大修改范围是原来对象池范围的两倍或三倍private final Integer minIdle = 600;private final Integer maxIdle = 1800;private final Integer maxTotal = 3000;//每五分钟打印一次对象池状态,并将当前活跃对象数放进List中@Scheduled(cron = "0 0/5 * * * *")public void monitorContextPool() {RtaProxyContextHolder.printPoolStatus();list.add(RTA_PROXY_CONTENT_POOL.getNumActive());}//每半小时统计后5个滑动窗口里的对象数,如果平均活跃对象数大于当前对象池中配置的最大空闲对象数,则更新@Scheduled(cron = "0 0/30 * * * *")public void adjustContextPool() {Integer averageIdle = 0;Integer sum = 0;for (int i = list.size() - 1, j = 0; j < 6; i--, j++) {sum += list.get(i);}averageIdle = sum / 6;if(averageIdle>RTA_PROXY_CONTENT_POOL.getMaxIdle() && RTA_PROXY_CONTENT_POOL.getMaxIdle()!=maxIdle){//平均活跃数大于对象池最大空闲对象数,则进行更新,如果对象池最大空闲对象数已经更新到了可达到的最大值,那么就没必要更新int minSize = 200;if(averageIdle/2>RTA_PROXY_CONTENT_POOL.getMaxIdle()){//如果平均活跃数/2大于最小活跃数,则直接更新成允许范围的最大值minSize=minIdle;}int maxSize = RTA_PROXY_CONTENT_POOL.getMaxIdle();while(maxSize<averageIdle){maxSize += 600;}if(maxSize>maxIdle){maxSize=maxIdle;}//更新对象池配置RtaProxyContextHolder.adjustPoolConfig(maxTotal,maxSize,minSize);}}}