Spring Cloud Alibaba 微服务整合自定义日志注解完整教程

Spring Cloud 2025.0.0 整合自定义日志注解完整教程

本教程基于 Spring Cloud 2025.0.0 新特性，包含虚拟线程、响应式编程、AOT 原生编译支持

一、技术栈和架构

1.1 技术选型

• Spring Cloud 2025.0.0(代号: 2025.0.0)
• Spring Boot 4.0
• Java 21+(支持虚拟线程)
• 响应式编程(WebFlux + R2DBC)
• AOT 原生编译(GraalVM 23.0+)
• 分布式追踪(Micrometer + Brave)
• 日志收集(Logback + ELK)

1.2 架构图

┌─────────────────────────────────────────────────────────┐ │ 自定义日志注解系统 │ ├─────────────────────────────────────────────────────────┤ │ Log注解 → 切面处理 → 日志上下文 → 异步存储 → 分布式追踪 │ │ ↑ ↑ ↑ ↑ ↑ │ │ 业务方法 虚拟线程 MDC/Reactor Elasticsearch Sleuth│ └─────────────────────────────────────────────────────────┘

二、项目初始化

2.1 父工程 pom.xml

<?xml version="1.0" encoding="UTF-8"?><projectxmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-parent</artifactId><version>2025.0.0</version><relativePath/></parent><groupId>com.example</groupId><artifactId>spring-cloud-logging</artifactId><version>1.0.0</version><packaging>pom</packaging><modules><module>logging-annotation</module><module>logging-starter</module><module>user-service</module><module>order-service</module><module>gateway-service</module></modules><properties><java.version>21</java.version><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><!-- Spring Cloud 版本 --><spring-cloud.version>2025.0.0</spring-cloud.version><spring-cloud-alibaba.version>2025.0.0.0</spring-cloud-alibaba.version><!-- 工具版本 --><lombok.version>1.18.30</lombok.version><mapstruct.version>1.5.5.Final</mapstruct.version><guava.version>33.0.0-jre</guava.version><!-- 日志版本 --><logstash-logback.version>8.0</logstash-logback.version><micrometer-tracing.version>1.2.0</micrometer-tracing.version><!-- GraalVM --><graalvm.version>23.0.0</graalvm.version></properties><dependencyManagement><dependencies><!-- Spring Cloud --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-dependencies</artifactId><version>${spring-cloud.version}</version><type>pom</type><scope>import</scope></dependency><!-- Spring Cloud Alibaba --><dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-alibaba-dependencies</artifactId><version>${spring-cloud-alibaba.version}</version><type>pom</type><scope>import</scope></dependency></dependencies></dependencyManagement><build><pluginManagement><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>3.11.0</version><configuration><source>21</source><target>21</target><annotationProcessorPaths><path><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>${lombok.version}</version></path><path><groupId>org.mapstruct</groupId><artifactId>mapstruct-processor</artifactId><version>${mapstruct.version}</version></path></annotationProcessorPaths></configuration></plugin><!-- Spring Boot AOT Plugin --><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><configuration><image><builder>paketobuildpacks/builder-jammy-tiny:latest</builder><env><BP_NATIVE_IMAGE>true</BP_NATIVE_IMAGE></env></image></configuration></plugin><!-- GraalVM Native Image Plugin --><plugin><groupId>org.graalvm.buildtools</groupId><artifactId>native-maven-plugin</artifactId><version>${graalvm.version}</version></plugin></plugins></pluginManagement></build><profiles><profile><id>native</id><build><plugins><plugin><groupId>org.graalvm.buildtools</groupId><artifactId>native-maven-plugin</artifactId><executions><execution><id>build-native</id><goals><goal>compile-no-fork</goal></goals><phase>package</phase></execution></executions></plugin></plugins></build></profile></profiles></project>

三、日志注解模块 (logging-annotation)

3.1 pom.xml

<?xml version="1.0" encoding="UTF-8"?><projectxmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"><parent><groupId>com.example</groupId><artifactId>spring-cloud-logging</artifactId><version>1.0.0</version></parent><modelVersion>4.0.0</modelVersion><artifactId>logging-annotation</artifactId><dependencies><!-- Spring Boot Starter --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><!-- AOP --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency><!-- 响应式 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-webflux</artifactId></dependency><!-- 分布式追踪 --><dependency><groupId>io.micrometer</groupId><artifactId>micrometer-tracing</artifactId></dependency><!-- Lombok --><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency></dependencies></project>

3.2 基础注解定义

3.2.1 核心日志注解

packagecom.example.logging.annotation;importorg.springframework.core.annotation.AliasFor;importjava.lang.annotation.*;importjava.util.concurrent.TimeUnit;/** * 自定义日志注解 * Spring Cloud 2025.0.0 新特性支持 */@Target({ElementType.METHOD,ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Documented@Inheritedpublic@interfaceLoggable{/** * 模块名称 */Stringmodule()default"";/** * 操作类型 */LogTypetype()defaultLogType.OTHER;/** * 操作描述 */@AliasFor("value")Stringdescription()default"";@AliasFor("description")Stringvalue()default"";/** * 是否记录方法参数 */booleanlogParams()defaulttrue;/** * 是否记录返回值 */booleanlogResult()defaulttrue;/** * 是否记录执行时间 */booleanlogTime()defaulttrue;/** * 慢查询阈值（毫秒） */longslowThreshold()default1000;/** * 是否启用异步记录 */booleanasync()defaulttrue;/** * 异步记录策略 */AsyncStrategyasyncStrategy()defaultAsyncStrategy.VIRTUAL_THREAD;/** * 是否启用虚拟线程 */booleanvirtualThread()defaulttrue;/** * 日志级别 */LogLevellevel()defaultLogLevel.INFO;/** * 是否推送到日志中心 */booleanpushToCenter()defaulttrue;/** * 业务标识表达式（SpEL） */StringbizNo()default"";/** * 是否记录堆栈信息 */booleanstackTrace()defaultfalse;/** * 日志分组 */Stringgroup()default"default";/** * 操作类型枚举 */enumLogType{SELECT,// 查询INSERT,// 新增UPDATE,// 更新DELETE,// 删除IMPORT,// 导入EXPORT,// 导出LOGIN,// 登录LOGOUT,// 登出UPLOAD,// 上传DOWNLOAD,// 下载EXECUTE,// 执行CALL,// 调用OTHER// 其他}/** * 异步策略枚举 */enumAsyncStrategy{VIRTUAL_THREAD,// 虚拟线程THREAD_POOL,// 线程池REACTIVE,// 响应式IMMEDIATE// 立即执行}/** * 日志级别枚举 */enumLogLevel{TRACE,DEBUG,INFO,WARN,ERROR}}

3.2.2 响应式日志注解

packagecom.example.logging.annotation;importorg.springframework.core.annotation.AliasFor;importreactor.core.publisher.Flux;importreactor.core.publisher.Mono;importjava.lang.annotation.*;importjava.util.concurrent.CompletableFuture;/** * 响应式日志注解 * 支持 Reactive Streams */@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)@Documented@Loggablepublic@interfaceReactiveLog{/** * 是否跟踪响应式流 */booleantraceStream()defaultfalse;/** * 最大跟踪元素数量 */intmaxTraceElements()default10;/** * 响应式超时时间（毫秒） */longtimeout()default30000;/** * 是否记录背压 */booleanlogBackpressure()defaultfalse;/** * 支持的类型 */Class<?>[]supportTypes()default{Mono.class,Flux.class,CompletableFuture.class};/** * 响应式操作类型 */ReactiveOperationoperation()defaultReactiveOperation.UNKNOWN;enumReactiveOperation{MONO_CREATE,MONO_TRANSFORM,MONO_DELAY,FLUX_STREAM,FLUX_WINDOW,FLUX_BUFFER,FUTURE_ASYNC,FUTURE_COMPLETABLE,UNKNOWN}}

3.2.3 分布式追踪注解

packagecom.example.logging.annotation;importorg.springframework.core.annotation.AliasFor;importjava.lang.annotation.*;/** * 分布式追踪注解 * 集成 Micrometer Tracing */@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)@Documented@Loggablepublic@interfaceTraceLog{/** * Span名称 */StringspanName()default"";/** * 是否创建新Span */booleannewSpan()defaulttrue;/** * Span类型 */SpanKindkind()defaultSpanKind.INTERNAL;/** * 是否记录异常栈 */booleanlogStackTrace()defaulttrue;/** * 标签（key=value格式） */String[]tags()default{};/** * 事件 */String[]events()default{};/** * 是否远程调用 */booleanremote()defaultfalse;/** * 远程服务名称 */StringremoteService()default"";/** * Span类型枚举 */enumSpanKind{CLIENT,// 客户端SERVER,// 服务端PRODUCER,// 生产者CONSUMER,// 消费者INTERNAL// 内部调用}}

3.2.4 性能监控注解

packagecom.example.logging.annotation;importorg.springframework.core.annotation.AliasFor;importjava.lang.annotation.*;importjava.util.concurrent.TimeUnit;/** * 性能监控注解 * 集成 Micrometer Metrics */@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)@Documented@Loggablepublic@interfaceMetricLog{/** * 指标名称 */Stringname()default"";/** * 指标描述 */Stringdescription()default"";/** * 指标类型 */MetricTypetype()defaultMetricType.TIMER;/** * 是否记录分位数 */booleanpercentiles()defaulttrue;/** * 分位数值 */double[]percentileValues()default{0.5,0.95,0.99};/** * 是否记录直方图 */booleanhistogram()defaultfalse;/** * SLA配置（毫秒） */long[]slas()default{10,50,100,500,1000};/** * 指标类型枚举 */enumMetricType{COUNTER,// 计数器TIMER,// 计时器GAUGE,// 仪表LONG_TASK_TIMER,// 长任务计时器DISTRIBUTION_SUMMARY// 分布摘要}}

3.3 日志上下文

3.3.1 日志上下文实体

packagecom.example.logging.context;importlombok.Data;importlombok.experimental.Accessors;importorg.springframework.http.server.reactive.ServerHttpRequest;importorg.springframework.web.server.ServerWebExchange;importreactor.util.context.Context;importreactor.util.context.ContextView;importjava.io.Serializable;importjava.time.Duration;importjava.time.LocalDateTime;importjava.util.Map;importjava.util.concurrent.ConcurrentHashMap;importjava.util.concurrent.atomic.AtomicReference;/** * 日志上下文 * 支持虚拟线程和响应式编程 */@Data@Accessors(chain=true)publicclassLogContextimplementsSerializable{privatestaticfinallongserialVersionUID=1L;// 基本信息privateStringlogId;privateStringtraceId;privateStringspanId;privateStringparentSpanId;// 方法信息privateStringclassName;privateStringmethodName;privateStringsignature;// 业务信息privateStringmodule;privateStringoperation;privateStringdescription;privateStringbizNo;// 参数和结果privateObject[]args;privateObjectresult;privateThrowablethrowable;// 时间信息privateLocalDateTimestartTime;privateLocalDateTimeendTime;privateDurationduration;// 线程信息privateThreadInfothreadInfo;// 请求信息privateRequestInforequestInfo;// 扩展属性privateMap<String,Object>attributes=newConcurrentHashMap<>();// 响应式上下文privateReactiveContextreactiveContext;// 追踪信息privateTraceInfotraceInfo;/** * 创建日志上下文 */publicstaticLogContextcreate(){LogContextcontext=newLogContext();context.setLogId(generateLogId());context.setStartTime(LocalDateTime.now());context.setThreadInfo(ThreadInfo.capture());context.setTraceInfo(TraceInfo.capture());returncontext;}/** * 从ServerWebExchange创建 */publicstaticLogContextfromExchange(ServerWebExchangeexchange){LogContextcontext=create();ServerHttpRequestrequest=exchange.getRequest();RequestInforequestInfo=newRequestInfo();requestInfo.setRequestId(request.getId());requestInfo.setMethod(request.getMethod().name());requestInfo.setUri(request.getURI().toString());requestInfo.setHeaders(newConcurrentHashMap<>(request.getHeaders().toSingleValueMap()));requestInfo.setQueryParams(newConcurrentHashMap<>(request.getQueryParams().toSingleValueMap()));requestInfo.setRemoteAddress(request.getRemoteAddress()!=null?request.getRemoteAddress().getAddress().getHostAddress():"");requestInfo.setUserAgent(request.getHeaders().getFirst("User-Agent"));context.setRequestInfo(requestInfo);// 设置追踪信息StringtraceId=request.getHeaders().getFirst("X-B3-TraceId");StringspanId=request.getHeaders().getFirst("X-B3-SpanId");if(traceId!=null){context.setTraceId(traceId);}if(spanId!=null){context.setSpanId(spanId);}returncontext;}/** * 计算持续时间 */publicLogContextcalculateDuration(){if(startTime!=null){this.endTime=LocalDateTime.now();this.duration=Duration.between(startTime,endTime);}returnthis;}/** * 设置异常 */publicLogContextwithException(Throwablethrowable){this.throwable=throwable;returnthis;}/** * 设置结果 */publicLogContextwithResult(Objectresult){this.result=result;returnthis;}/** * 设置响应式上下文 */publicLogContextwithReactiveContext(ContextViewcontextView){this.reactiveContext=ReactiveContext.from(contextView);returnthis;}/** * 添加属性 */publicLogContextaddAttribute(Stringkey,Objectvalue){this.attributes.put(key,value);returnthis;}/** * 生成日志ID */privatestaticStringgenerateLogId(){returnjava.util.UUID.randomUUID().toString().replace("-","");}/** * 线程信息 */@Data@Accessors(chain=true)publicstaticclassThreadInfoimplementsSerializable{privatelongthreadId;privateStringthreadName;privatebooleanvirtual;privateThread.Statestate;privateintpriority;privatelongthreadGroupId;privateStringthreadGroupName;publicstaticThreadInfocapture(){Threadthread=Thread.currentThread();ThreadInfoinfo=newThreadInfo();info.setThreadId(thread.threadId());info.setThreadName(thread.getName());info.setVirtual(thread.isVirtual());info.setState(thread.getState());info.setPriority(thread.getPriority());ThreadGroupgroup=thread.getThreadGroup();if(group!=null){info.setThreadGroupId(group.getId());info.setThreadGroupName(group.getName());}returninfo;}}/** * 请求信息 */@Data@Accessors(chain=true)publicstaticclassRequestInfoimplementsSerializable{privateStringrequestId;privateStringmethod;privateStringuri;privateMap<String,String>headers;privateMap<String,String>queryParams;privateStringremoteAddress;privateStringuserAgent;privateMap<String,String>pathVariables;}/** * 响应式上下文 */@Data@Accessors(chain=true)publicstaticclassReactiveContextimplementsSerializable{privateContextViewcontextView;privatebooleanonVirtualThread;privateStringscheduler;privatelongsubscriptionTime;privatelongrequestTime;publicstaticReactiveContextfrom(ContextViewcontextView){ReactiveContextcontext=newReactiveContext();context.setContextView(contextView);context.setOnVirtualThread(Thread.currentThread().isVirtual());context.setSubscriptionTime(System.currentTimeMillis());returncontext;}}/** * 追踪信息 */@Data@Accessors(chain=true)publicstaticclassTraceInfoimplementsSerializable{privateStringtraceId;privateStringspanId;privateStringparentSpanId;privatebooleansampled;privateStringbaggage;publicstaticTraceInfocapture(){// 这里可以从MDC或ThreadLocal获取追踪信息TraceInfoinfo=newTraceInfo();// 实际实现中会从Tracing API获取returninfo;}}}

四、日志切面实现

4.1 基础切面处理器

packagecom.example.logging.aspect;importcom.example.logging.annotation.Loggable;importcom.example.logging.context.LogContext;importcom.example.logging.event.LogEvent;importcom.example.logging.service.LogService;importlombok.RequiredArgsConstructor;importlombok.extern.slf4j.Slf4j;importorg.aspectj.lang.ProceedingJoinPoint;importorg.aspectj.lang.annotation.Around;importorg.aspectj.lang.annotation.Aspect;importorg.aspectj.lang.annotation.Pointcut;importorg.aspectj.lang.reflect.MethodSignature;importorg.springframework.context.ApplicationEventPublisher;importorg.springframework.core.annotation.AnnotationUtils;importorg.springframework.expression.Expression;importorg.springframework.expression.ExpressionParser;importorg.springframework.expression.spel.standard.SpelExpressionParser;importorg.springframework.expression.spel.support.StandardEvaluationContext;importorg.springframework.stereotype.Component;importreactor.core.publisher.Flux;importreactor.core.publisher.Mono;importjava.lang.reflect.Method;importjava.time.Duration;importjava.time.Instant;importjava.util.concurrent.CompletableFuture;importjava.util.concurrent.Executors;importjava.util.concurrent.atomic.AtomicReference;/** * 日志切面处理器 * Spring Cloud 2025.0.0 新特性支持 */@Slf4j@Aspect@Component@RequiredArgsConstructorpublicclassLogAspectHandler{privatefinalApplicationEventPublishereventPublisher;privatefinalLogServicelogService;privatefinalLogExpressionEvaluatorexpressionEvaluator;// 虚拟线程执行器privatestaticfinaljava.util.concurrent.ExecutorServiceVIRTUAL_EXECUTOR=Executors.newThreadPerTaskExecutor(Thread.ofVirtual().name("log-virtual-",0).factory());/** * 切入点：所有@Loggable注解的方法 */@Pointcut("@annotation(com.example.logging.annotation.Loggable)")publicvoidloggablePointcut(){}/** * 环绕通知 */@Around("loggablePointcut()")publicObjecthandleLog(ProceedingJoinPointjoinPoint)throwsThrowable{MethodSignaturesignature=(MethodSignature)joinPoint.getSignature();Methodmethod=signature.getMethod();// 获取注解配置Loggableloggable=AnnotationUtils.findAnnotation(method,Loggable.class);if(loggable==null){returnjoinPoint.proceed();}// 创建日志上下文LogContextlogContext=createLogContext(joinPoint,loggable);// 记录开始logStart(logContext,loggable);InstantstartTime=Instant.now();Objectresult=null;Throwablethrowable=null;try{// 执行目标方法result=joinPoint.proceed();// 根据返回类型处理if(resultinstanceofMono){returnhandleMonoResult((Mono<?>)result,logContext,loggable,startTime);}elseif(resultinstanceofFlux){returnhandleFluxResult((Flux<?>)result,logContext,loggable,startTime);}elseif(resultinstanceofCompletableFuture){returnhandleFutureResult((CompletableFuture<?>)result,logContext,loggable,startTime);}returnresult;}catch(Throwablet){throwable=t;throwt;}finally{// 处理同步结果handleSyncResult(result,throwable,logContext,loggable,startTime);}}/** * 创建日志上下文 */privateLogContextcreateLogContext(ProceedingJoinPointjoinPoint,Loggableloggable){MethodSignaturesignature=(MethodSignature)joinPoint.getSignature();Methodmethod=signature.getMethod();LogContextcontext=LogContext.create();context.setClassName(joinPoint.getTarget().getClass().getName());context.setMethodName(method.getName());context.setSignature(signature.toString());context.setModule(loggable.module());context.setOperation(loggable.value());context.setDescription(loggable.description());// 解析业务编号if(!loggable.bizNo().isEmpty()){StringbizNo=expressionEvaluator.evaluateBizNo(joinPoint,loggable.bizNo());context.setBizNo(bizNo);}// 记录参数if(loggable.logParams()){context.setArgs(joinPoint.getArgs());}returncontext;}/** * 处理Mono结果 */privateMono<?>handleMonoResult(Mono<?>mono,LogContextlogContext,Loggableloggable,InstantstartTime){AtomicReference<Instant>subscribeTime=newAtomicReference<>(Instant.now());returnmono.contextWrite(ctx->{// 在Reactor Context中存储日志信息returnctx.put("log.context",logContext).put("log.startTime",startTime).put("log.subscribeTime",subscribeTime.get());}).doOnSubscribe(subscription->{subscribeTime.set(Instant.now());if(loggable.async()){VIRTUAL_EXECUTOR.submit(()->logService.logAsyncStart(logContext));}else{logService.logSyncStart(logContext);}}).doOnSuccess(result->{Durationduration=Duration.between(startTime,Instant.now());logContext.withResult(result).calculateDuration();if(loggable.async()){VIRTUAL_EXECUTOR.submit(()->logService.logAsyncSuccess(logContext,duration));}else{logService.logSyncSuccess(logContext,duration);}// 检查慢查询if(duration.toMillis()>loggable.slowThreshold()){logService.logSlowQuery(logContext,duration,loggable.slowThreshold());}// 发布事件if(loggable.pushToCenter()){eventPublisher.publishEvent(newLogEvent(logContext,loggable));}}).doOnError(throwable->{Durationduration=Duration.between(startTime,Instant.now());logContext.withException(throwable).calculateDuration();if(loggable.async()){VIRTUAL_EXECUTOR.submit(()->logService.logAsyncError(logContext,duration,throwable));}else{logService.logSyncError(logContext,duration,throwable);}// 发布事件if(loggable.pushToCenter()){eventPublisher.publishEvent(newLogEvent(logContext,loggable));}}).doOnCancel(()->{Durationduration=Duration.between(startTime,Instant.now());if(loggable.async()){VIRTUAL_EXECUTOR.submit(()->logService.logAsyncCancel(logContext,duration));}});}/** * 处理Flux结果 */privateFlux<?>handleFluxResult(Flux<?>flux,LogContextlogContext,Loggableloggable,InstantstartTime){AtomicReference<Instant>subscribeTime=newAtomicReference<>(Instant.now());AtomicReference<Integer>elementCount=newAtomicReference<>(0);returnflux.contextWrite(ctx->{returnctx.put("log.context",logContext).put("log.startTime",startTime);}).doOnSubscribe(subscription->{subscribeTime.set(Instant.now());if(loggable.async()){VIRTUAL_EXECUTOR.submit(()->logService.logAsyncStart(logContext));}}).doOnNext(element->{intcount=elementCount.updateAndGet(c->c+1);if(loggable.async()&&count<=10){VIRTUAL_EXECUTOR.submit(()->logService.logAsyncElement(logContext,element,count));}}).doOnComplete(()->{Durationduration=Duration.between(startTime,Instant.now());logContext.calculateDuration();if(loggable.async()){VIRTUAL_EXECUTOR.submit(()->logService.logAsyncComplete(logContext,duration,elementCount.get()));}// 发布事件if(loggable.pushToCenter()){eventPublisher.publishEvent(newLogEvent(logContext,loggable));}}).doOnError(throwable->{Durationduration=Duration.between(startTime,Instant.now());logContext.withException(throwable).calculateDuration();if(loggable.async()){VIRTUAL_EXECUTOR.submit(()->logService.logAsyncError(logContext,duration,throwable));}else{logService.logSyncError(logContext,duration,throwable);}// 发布事件if(loggable.pushToCenter()){eventPublisher.publishEvent(newLogEvent(logContext,loggable));}});}/** * 处理Future结果 */privateCompletableFuture<?>handleFutureResult(CompletableFuture<?>future,LogContextlogContext,Loggableloggable,InstantstartTime){if(loggable.async()){VIRTUAL_EXECUTOR.submit(()->logService.logAsyncStart(logContext));}else{logService.logSyncStart(logContext);}returnfuture.whenComplete((result,throwable)->{Durationduration=Duration.between(startTime,Instant.now());if(throwable!=null){logContext.withException(throwable).calculateDuration();if(loggable.async()){VIRTUAL_EXECUTOR.submit(()->logService.logAsyncError(logContext,duration,throwable));}else{logService.logSyncError(logContext,duration,throwable);}}else{logContext.withResult(result).calculateDuration();if(loggable.async()){VIRTUAL_EXECUTOR.submit(()->logService.logAsyncSuccess(logContext,duration));}else{logService.logSyncSuccess(logContext,duration);}// 检查慢查询if(duration.toMillis()>loggable.slowThreshold()){logService.logSlowQuery(logContext,duration,loggable.slowThreshold());}}// 发布事件if(loggable.pushToCenter()){eventPublisher.publishEvent(newLogEvent(logContext,loggable));}});}/** * 处理同步结果 */privatevoidhandleSyncResult(Objectresult,Throwablethrowable,LogContextlogContext,Loggableloggable,InstantstartTime){Durationduration=Duration.between(startTime,Instant.now());logContext.calculateDuration();if(throwable!=null){logContext.withException(throwable);if(loggable.async()){VIRTUAL_EXECUTOR.submit(()->logService.logAsyncError(logContext,duration,throwable));}else{logService.logSyncError(logContext,duration,throwable);}}else{logContext.withResult(result);if(loggable.async()){VIRTUAL_EXECUTOR.submit(()->logService.logAsyncSuccess(logContext,duration));}else{logService.logSyncSuccess(logContext,duration);}// 检查慢查询if(duration.toMillis()>loggable.slowThreshold()){logService.logSlowQuery(logContext,duration,loggable.slowThreshold());}}// 发布事件if(loggable.pushToCenter()){eventPublisher.publishEvent(newLogEvent(logContext,loggable));}}/** * 记录开始日志 */privatevoidlogStart(LogContextcontext,Loggableloggable){switch(loggable.level()){caseTRACE:log.trace("【开始】{} - {}#{} [线程:{}]",context.getOperation(),context.getClassName(),context.getMethodName(),Thread.currentThread().getName());break;caseDEBUG:log.debug("【开始】{} - {}#{}",context.getOperation(),context.getClassName(),context.getMethodName());break;caseINFO:log.info("【开始】{} - {}#{}",context.getOperation(),context.getClassName(),context.getMethodName());break;caseWARN:caseERROR:// 不记录开始日志break;}}}

4.2 响应式切面处理器

packagecom.example.logging.aspect;importcom.example.logging.annotation.ReactiveLog;importcom.example.logging.context.LogContext;importlombok.RequiredArgsConstructor;importlombok.extern.slf4j.Slf4j;importorg.aspectj.lang.ProceedingJoinPoint;importorg.aspectj.lang.annotation.Around;importorg.aspectj.lang.annotation.Aspect;importorg.aspectj.lang.reflect.MethodSignature;importorg.springframework.core.annotation.AnnotationUtils;importorg.springframework.stereotype.Component;importreactor.core.publisher.Flux;importreactor.core.publisher.Mono;importreactor.core.scheduler.Schedulers;importjava.lang.reflect.Method;importjava.time.Duration;importjava.time.Instant;importjava.util.concurrent.atomic.AtomicInteger;importjava.util.concurrent.atomic.AtomicLong;/** * 响应式日志切面 * Spring Cloud 2025.0.0 响应式增强 */@Slf4j@Aspect@Component@RequiredArgsConstructorpublicclassReactiveLogAspect{/** * 处理响应式日志 */@Around("@annotation(com.example.logging.annotation.ReactiveLog)")publicObjecthandleReactiveLog(ProceedingJoinPointjoinPoint)throwsThrowable{MethodSignaturesignature=(MethodSignature)joinPoint.getSignature();Methodmethod=signature.getMethod();ReactiveLogreactiveLog=AnnotationUtils.findAnnotation(method,ReactiveLog.class);if(reactiveLog==null){returnjoinPoint.proceed();}// 创建日志上下文LogContextlogContext=LogContext.create();logContext.setClassName(joinPoint.getTarget().getClass().getName());logContext.setMethodName(method.getName());Objectresult=joinPoint.proceed();if(resultinstanceofMono){returnwrapMono((Mono<?>)result,logContext,reactiveLog);}elseif(resultinstanceofFlux){returnwrapFlux((Flux<?>)result,logContext,reactiveLog);}returnresult;}/** * 包装Mono */privateMono<?>wrapMono(Mono<?>mono,LogContextcontext,ReactiveLogreactiveLog){AtomicLongsubscribeTime=newAtomicLong();AtomicLongrequestTime=newAtomicLong();returnmono.doOnSubscribe(subscription->{subscribeTime.set(System.currentTimeMillis());logReactiveStart(context,"MONO",reactiveLog);}).doOnRequest(n->{requestTime.set(System.currentTimeMillis());if(reactiveLog.logBackpressure()){log.debug("【MONO】请求元素: {}",n);}}).doOnNext(value->{longprocessTime=System.currentTimeMillis()-requestTime.get();if(reactiveLog.traceStream()){log.debug("【MONO】处理元素: {}, 耗时: {}ms",value,processTime);}}).doOnSuccess(value->{longtotalTime=System.currentTimeMillis()-subscribeTime.get();logReactiveSuccess(context,"MONO",value,totalTime,reactiveLog);}).doOnError(throwable->{longtotalTime=System.currentTimeMillis()-subscribeTime.get();logReactiveError(context,"MONO",throwable,totalTime,reactiveLog);}).timeout(Duration.ofMillis(reactiveLog.timeout())).onErrorResume(throwable->{log.error("【MONO】响应式超时: {}ms",reactiveLog.timeout(),throwable);returnMono.error(throwable);}).doFinally(signalType->{if(reactiveLog.traceStream()){log.debug("【MONO】最终信号: {}",signalType);}});}/** * 包装Flux */privateFlux<?>wrapFlux(Flux<?>flux,LogContextcontext,ReactiveLogreactiveLog){AtomicLongsubscribeTime=newAtomicLong();AtomicIntegerelementCount=newAtomicInteger(0);AtomicLongtotalElements=newAtomicLong(0);returnflux.doOnSubscribe(subscription->{subscribeTime.set(System.currentTimeMillis());logReactiveStart(context,"FLUX",reactiveLog);}).doOnRequest(n->{if(reactiveLog.logBackpressure()){log.debug("【FLUX】请求元素: {}",n);}}).doOnNext(element->{intcount=elementCount.incrementAndGet();totalElements.incrementAndGet();if(reactiveLog.traceStream()&&count<=reactiveLog.maxTraceElements()){log.debug("【FLUX】元素[{}]: {}",count,element);}}).doOnComplete(()->{longtotalTime=System.currentTimeMillis()-subscribeTime.get();logReactiveComplete(context,"FLUX",elementCount.get(),totalTime,reactiveLog);}).doOnError(throwable->{longtotalTime=System.currentTimeMillis()-subscribeTime.get();logReactiveError(context,"FLUX",throwable,totalTime,reactiveLog);}).timeout(Duration.ofMillis(reactiveLog.timeout())).onErrorResume(throwable->{log.error("【FLUX】响应式超时: {}ms",reactiveLog.timeout(),throwable);returnFlux.error(throwable);}).doFinally(signalType->{if(reactiveLog.traceStream()){log.debug("【FLUX】最终信号: {}, 总元素: {}",signalType,totalElements.get());}});}privatevoidlogReactiveStart(LogContextcontext,Stringtype,ReactiveLogreactiveLog){log.info("【响应式{}】开始 - {}#{} [线程:{}]",type,context.getClassName(),context.getMethodName(),Thread.currentThread().getName());}privatevoidlogReactiveSuccess(LogContextcontext,Stringtype,Objectvalue,longtotalTime,ReactiveLogreactiveLog){log.info("【响应式{}】成功 - {}#{}, 结果: {}, 耗时: {}ms",type,context.getClassName(),context.getMethodName(),value!=null?value.toString():"null",totalTime);}privatevoidlogReactiveComplete(LogContextcontext,Stringtype,intelementCount,longtotalTime,ReactiveLogreactiveLog){log.info("【响应式{}】完成 - {}#{}, 元素数: {}, 耗时: {}ms",type,context.getClassName(),context.getMethodName(),elementCount,totalTime);}privatevoidlogReactiveError(LogContextcontext,Stringtype,Throwablethrowable,longtotalTime,ReactiveLogreactiveLog){log.error("【响应式{}】失败 - {}#{}, 耗时: {}ms, 错误: {}",type,context.getClassName(),context.getMethodName(),totalTime,throwable.getMessage(),throwable);}}

五、日志服务实现

5.1 日志服务接口

packagecom.example.logging.service;importcom.example.logging.context.LogContext;importreactor.core.publisher.Mono;importjava.time.Duration;/** * 日志服务接口 */publicinterfaceLogService{// 同步日志voidlogSyncStart(LogContextcontext);voidlogSyncSuccess(LogContextcontext,Durationduration);voidlogSyncError(LogContextcontext,Durationduration,Throwablethrowable);// 异步日志voidlogAsyncStart(LogContextcontext);voidlogAsyncSuccess(LogContextcontext,Durationduration);voidlogAsyncError(LogContextcontext,Durationduration,Throwablethrowable);voidlogAsyncCancel(LogContextcontext,Durationduration);voidlogAsyncComplete(LogContextcontext,Durationduration,intelementCount);voidlogAsyncElement(LogContextcontext,Objectelement,intindex);// 慢查询日志voidlogSlowQuery(LogContextcontext,Durationduration,longthreshold);// 虚拟线程日志voidlogVirtualThreadMetrics();// 响应式日志Mono<Void>logReactiveStart(LogContextcontext);Mono<Void>logReactiveSuccess(LogContextcontext,Durationduration);Mono<Void>logReactiveError(LogContextcontext,Durationduration,Throwablethrowable);}

5.2 日志服务实现

packagecom.example.logging.service.impl;importcom.example.logging.context.LogContext;importcom.example.logging.service.LogService;importio.micrometer.core.instrument.MeterRegistry;importio.micrometer.core.instrument.Timer;importlombok.RequiredArgsConstructor;importlombok.extern.slf4j.Slf4j;importorg.springframework.beans.factory.ObjectProvider;importorg.springframework.cloud.sleuth.Tracer;importorg.springframework.stereotype.Service;importreactor.core.publisher.Mono;importreactor.core.scheduler.Schedulers;importjava.time.Duration;importjava.util.Map;importjava.util.concurrent.ConcurrentHashMap;importjava.util.concurrent.Executors;importjava.util.concurrent.TimeUnit;importjava.util.concurrent.atomic.AtomicInteger;importjava.util.concurrent.atomic.AtomicLong;/** * 日志服务实现 * 集成分布式追踪和性能指标 */@Slf4j@Service@RequiredArgsConstructorpublicclassDefaultLogServiceImplimplementsLogService{privatefinalMeterRegistrymeterRegistry;privatefinalObjectProvider<Tracer>tracerProvider;// 虚拟线程执行器privatefinaljava.util.concurrent.ExecutorServicevirtualExecutor=Executors.newThreadPerTaskExecutor(Thread.ofVirtual().name("log-virtual-",0).factory());// 统计信息privatefinalAtomicLongtotalLogs=newAtomicLong(0);privatefinalAtomicLongerrorLogs=newAtomicLong(0);privatefinalAtomicLongslowLogs=newAtomicLong(0);privatefinalAtomicIntegervirtualThreadCount=newAtomicInteger(0);// 计时器缓存privatefinalMap<String,Timer>timerCache=newConcurrentHashMap<>();@OverridepublicvoidlogSyncStart(LogContextcontext){totalLogs.incrementAndGet();log.debug("【同步开始】{} - {}#{} [追踪ID:{}]",context.getOperation(),context.getClassName(),context.getMethodName(),getTraceId());// 记录指标meterRegistry.counter("log.sync.start","module",context.getModule(),"operation",context.getOperation()).increment();}@OverridepublicvoidlogSyncSuccess(LogContextcontext,Durationduration){log.info("【同步成功】{} - {}#{}, 耗时: {}ms [追踪ID:{}]",context.getOperation(),context.getClassName(),context.getMethodName(),duration.toMillis(),getTraceId());// 记录计时指标Timertimer=getOrCreateTimer(context.getModule(),context.getOperation());timer.record(duration);// 记录成功率meterRegistry.counter("log.sync.success","module",context.getModule()).increment();}@OverridepublicvoidlogSyncError(LogContextcontext,Durationduration,Throwablethrowable){errorLogs.incrementAndGet();log.error("【同步失败】{} - {}#{}, 耗时: {}ms, 错误: {} [追踪ID:{}]",context.getOperation(),context.getClassName(),context.getMethodName(),duration.toMillis(),throwable.getMessage(),getTraceId(),throwable);// 记录错误指标meterRegistry.counter("log.sync.error","module",context.getModule(),"exception",throwable.getClass().getSimpleName()).increment();}@OverridepublicvoidlogAsyncStart(LogContextcontext){virtualExecutor.submit(()->{try{totalLogs.incrementAndGet();virtualThreadCount.incrementAndGet();log.debug("【异步开始】{} - {}#{} [虚拟线程:{}, 追踪ID:{}]",context.getOperation(),context.getClassName(),context.getMethodName(),Thread.currentThread().threadId(),getTraceId());// 记录虚拟线程指标meterRegistry.gauge("log.virtual.thread.count",virtualThreadCount);meterRegistry.counter("log.async.start","module",context.getModule()).increment();}catch(Exceptione){log.error("异步开始日志记录失败",e);}});}@OverridepublicvoidlogAsyncSuccess(LogContextcontext,Durationduration){virtualExecutor.submit(()->{try{log.info("【异步成功】{} - {}#{}, 耗时: {}ms [虚拟线程:{}, 追踪ID:{}]",context.getOperation(),context.getClassName(),context.getMethodName(),duration.toMillis(),Thread.currentThread().threadId(),getTraceId());// 记录计时指标Timertimer=getOrCreateTimer(context.getModule(),context.getOperation());timer.record(duration);// 记录成功率meterRegistry.counter("log.async.success","module",context.getModule()).increment();}catch(Exceptione){log.error("异步成功日志记录失败",e);}finally{virtualThreadCount.decrementAndGet();}});}@OverridepublicvoidlogAsyncError(LogContextcontext,Durationduration,Throwablethrowable){virtualExecutor.submit(()->{try{errorLogs.incrementAndGet();log.error("【异步失败】{} - {}#{}, 耗时: {}ms, 错误: {} [虚拟线程:{}, 追踪ID:{}]",context.getOperation(),context.getClassName(),context.getMethodName(),duration.toMillis(),throwable.getMessage(),Thread.currentThread().threadId(),getTraceId(),throwable);// 记录错误指标meterRegistry.counter("log.async.error","module",context.getModule(),"exception",throwable.getClass().getSimpleName()).increment();}catch(Exceptione){log.error("异步错误日志记录失败",e);}finally{virtualThreadCount.decrementAndGet();}});}@OverridepublicvoidlogAsyncCancel(LogContextcontext,Durationduration){virtualExecutor.submit(()->{try{log.warn("【异步取消】{} - {}#{}, 耗时: {}ms [虚拟线程:{}]",context.getOperation(),context.getClassName(),context.getMethodName(),duration.toMillis(),Thread.currentThread().threadId());meterRegistry.counter("log.async.cancel","module",context.getModule()).increment();}catch(Exceptione){log.error("异步取消日志记录失败",e);}finally{virtualThreadCount.decrementAndGet();}});}@OverridepublicvoidlogAsyncComplete(LogContextcontext,Durationduration,intelementCount){virtualExecutor.submit(()->{try{log.info("【异步完成】{} - {}#{}, 元素数: {}, 耗时: {}ms [虚拟线程:{}]",context.getOperation(),context.getClassName(),context.getMethodName(),elementCount,duration.toMillis(),Thread.currentThread().threadId());meterRegistry.counter("log.async.complete","module",context.getModule(),"elementCount",String.valueOf(elementCount)).increment();}catch(Exceptione){log.error("异步完成日志记录失败",e);}finally{virtualThreadCount.decrementAndGet();}});}@OverridepublicvoidlogAsyncElement(LogContextcontext,Objectelement,intindex){virtualExecutor.submit(()->{try{if(index<=10){// 只记录前10个元素log.debug("【异步元素】{} - {}#{}, 元素[{}]: {} [虚拟线程:{}]",context.getOperation(),context.getClassName(),context.getMethodName(),index,element!=null?element.toString():"null",Thread.currentThread().threadId());}}catch(Exceptione){// 忽略元素记录错误}});}@OverridepublicvoidlogSlowQuery(LogContextcontext,Durationduration,longthreshold){slowLogs.incrementAndGet();virtualExecutor.submit(()->{try{log.warn("【慢查询】{} - {}#{}, 耗时: {}ms, 阈值: {}ms [追踪ID:{}]",context.getOperation(),context.getClassName(),context.getMethodName(),duration.toMillis(),threshold,getTraceId());// 记录慢查询指标meterRegistry.counter("log.slow.query","module",context.getModule(),"duration",String.valueOf(duration.toMillis()),"threshold",String.valueOf(threshold)).increment();}catch(Exceptione){log.error("慢查询日志记录失败",e);}});}@OverridepublicvoidlogVirtualThreadMetrics(){virtualExecutor.submit(()->{try{intcount=virtualThreadCount.get();intactiveThreads=Thread.activeCount();log.debug("【虚拟线程统计】活跃虚拟线程: {}, 总线程: {}, 总日志: {}, 错误日志: {}, 慢查询: {}",count,activeThreads,totalLogs.get(),errorLogs.get(),slowLogs.get());// 记录到指标meterRegistry.gauge("log.metrics.total",totalLogs);meterRegistry.gauge("log.metrics.errors",errorLogs);meterRegistry.gauge("log.metrics.slow",slowLogs);}catch(Exceptione){log.error("虚拟线程指标记录失败",e);}});}@OverridepublicMono<Void>logReactiveStart(LogContextcontext){returnMono.fromRunnable(()->{log.debug("【响应式开始】{} - {}#{}",context.getOperation(),context.getClassName(),context.getMethodName());}).subscribeOn(Schedulers.boundedElastic()).then();}@OverridepublicMono<Void>logReactiveSuccess(LogContextcontext,Durationduration){returnMono.fromRunnable(()->{log.info("【响应式成功】{} - {}#{}, 耗时: {}ms",context.getOperation(),context.getClassName(),context.getMethodName(),duration.toMillis());}).subscribeOn(Schedulers.boundedElastic()).then();}@OverridepublicMono<Void>logReactiveError(LogContextcontext,Durationduration,Throwablethrowable){returnMono.fromRunnable(()->{log.error("【响应式失败】{} - {}#{}, 耗时: {}ms, 错误: {}",context.getOperation(),context.getClassName(),context.getMethodName(),duration.toMillis(),throwable.getMessage(),throwable);}).subscribeOn(Schedulers.boundedElastic()).then();}/** * 获取或创建计时器 */privateTimergetOrCreateTimer(Stringmodule,Stringoperation){Stringkey=module+"."+operation;returntimerCache.computeIfAbsent(key,k->Timer.builder("log.execution.time").description("Method execution time").tag("module",module).tag("operation",operation).publishPercentiles(0.5,0.95,0.99).publishPercentileHistogram().register(meterRegistry));}/** * 获取追踪ID */privateStringgetTraceId(){try{Tracertracer=tracerProvider.getIfAvailable();if(tracer!=null&&tracer.currentSpan()!=null){returntracer.currentSpan().context().traceId();}}catch(Exceptione){// 忽略异常}return"N/A";}/** * 关闭资源 */publicvoidshutdown(){virtualExecutor.shutdown();try{if(!virtualExecutor.awaitTermination(5,TimeUnit.SECONDS)){virtualExecutor.shutdownNow();}}catch(InterruptedExceptione){virtualExecutor.shutdownNow();Thread.currentThread().interrupt();}log.info("日志服务关闭完成");}}

六、日志自动配置

6.1 自动配置类

packagecom.example.logging.autoconfigure;importcom.example.logging.aspect.LogAspectHandler;importcom.example.logging.aspect.ReactiveLogAspect;importcom.example.logging.service.LogService;importcom.example.logging.service.impl.DefaultLogServiceImpl;importlombok.extern.slf4j.Slf4j;importorg.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;importorg.springframework.boot.autoconfigure.condition.ConditionalOnProperty;importorg.springframework.boot.context.properties.EnableConfigurationProperties;importorg.springframework.context.annotation.Bean;importorg.springframework.context.annotation.Configuration;importorg.springframework.context.annotation.EnableAspectJAutoProxy;importorg.springframework.scheduling.annotation.EnableAsync;importorg.springframework.scheduling.annotation.EnableScheduling;importjava.util.concurrent.Executors;/** * 日志自动配置 */@Slf4j@Configuration@EnableAspectJAutoProxy@EnableAsync@EnableScheduling@EnableConfigurationProperties(LogProperties.class)@ConditionalOnProperty(prefix="spring.logging",name="enabled",havingValue="true",matchIfMissing=true)publicclassLogAutoConfiguration{/** * 日志切面处理器 */@Bean@ConditionalOnMissingBeanpublicLogAspectHandlerlogAspectHandler(){returnnewLogAspectHandler();}/** * 响应式日志切面 */@Bean@ConditionalOnMissingBeanpublicReactiveLogAspectreactiveLogAspect(){returnnewReactiveLogAspect();}/** * 日志服务 */@Bean@ConditionalOnMissingBeanpublicLogServicelogService(){returnnewDefaultLogServiceImpl();}/** * 虚拟线程执行器 */@Bean(destroyMethod="shutdown")publicjava.util.concurrent.ExecutorServicevirtualThreadExecutor(){returnExecutors.newThreadPerTaskExecutor(Thread.ofVirtual().name("global-virtual-",0).factory());}/** * 日志指标调度器 */@BeanpublicLogMetricsSchedulerlogMetricsScheduler(LogServicelogService){returnnewLogMetricsScheduler(logService);}}

6.2 配置属性

packagecom.example.logging.autoconfigure;importlombok.Data;importorg.springframework.boot.context.properties.ConfigurationProperties;importjava.time.Duration;importjava.util.HashMap;importjava.util.Map;/** * 日志配置属性 */@Data@ConfigurationProperties(prefix="spring.logging")publicclassLogProperties{/** * 是否启用日志功能 */privatebooleanenabled=true;/** * 是否启用异步日志 */privatebooleanasyncEnabled=true;/** * 是否启用虚拟线程 */privatebooleanvirtualThreadEnabled=true;/** * 是否启用响应式日志 */privatebooleanreactiveEnabled=true;/** * 默认日志级别 */privateStringdefaultLevel="INFO";/** * 慢查询阈值（毫秒） */privatelongslowThreshold=1000;/** * 是否记录方法参数 */privatebooleanlogParams=true;/** * 是否记录返回值 */privatebooleanlogResult=true;/** * 是否记录执行时间 */privatebooleanlogTime=true;/** * 是否推送到日志中心 */privatebooleanpushToCenter=true;/** * 日志中心地址 */privateStringcenterUrl="http://localhost:8080";/** * 连接超时时间 */privateDurationconnectTimeout=Duration.ofSeconds(5);/** * 读取超时时间 */privateDurationreadTimeout=Duration.ofSeconds(10);/** * 重试次数 */privateintretryTimes=3;/** * 批量发送大小 */privateintbatchSize=100;/** * 批量发送间隔 */privateDurationbatchInterval=Duration.ofSeconds(5);/** * 模块配置 */privateMap<String,ModuleConfig>modules=newHashMap<>();@DatapublicstaticclassModuleConfig{privatebooleanenabled=true;privateStringlevel="INFO";privatebooleanasync=true;privatebooleanvirtualThread=true;privatebooleanlogParams=true;privatebooleanlogResult=true;privatelongslowThreshold=1000;}}

七、日志 Starter 模块

7.1 pom.xml

<?xml version="1.0" encoding="UTF-8"?><projectxmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"><parent><groupId>com.example</groupId><artifactId>spring-cloud-logging</artifactId><version>1.0.0</version></parent><modelVersion>4.0.0</modelVersion><artifactId>logging-starter</artifactId><dependencies><!-- 内部模块依赖 --><dependency><groupId>com.example</groupId><artifactId>logging-annotation</artifactId><version>${project.version}</version></dependency><!-- Spring Boot Starter --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><!-- AOP --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency><!-- 配置处理器 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-configuration-processor</artifactId><optional>true</optional></dependency><!-- Micrometer 追踪 --><dependency><groupId>io.micrometer</groupId><artifactId>micrometer-tracing</artifactId></dependency><!-- Micrometer 指标 --><dependency><groupId>io.micrometer</groupId><artifactId>micrometer-core</artifactId></dependency><!-- Reactor --><dependency><groupId>io.projectreactor</groupId><artifactId>reactor-core</artifactId></dependency></dependencies></project>

7.2 spring.factories

# Auto Configure org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ com.example.logging.autoconfigure.LogAutoConfiguration # Spring Boot Configuration Processor org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ com.example.logging.autoconfigure.LogPropertiesConfiguration

八、使用示例

8.1 用户服务示例

packagecom.example.user.service;importcom.example.logging.annotation.Loggable;importcom.example.logging.annotation.ReactiveLog;importcom.example.logging.annotation.TraceLog;importlombok.RequiredArgsConstructor;importlombok.extern.slf4j.Slf4j;importorg.springframework.stereotype.Service;importorg.springframework.transaction.annotation.Transactional;importreactor.core.publisher.Flux;importreactor.core.publisher.Mono;importjava.util.List;importjava.util.concurrent.CompletableFuture;importjava.util.concurrent.Executors;/** * 用户服务示例 */@Slf4j@Service@RequiredArgsConstructorpublicclassUserService{/** * 同步方法日志 */@Loggable(module="用户管理",value="创建用户",type=Loggable.LogType.INSERT,bizNo="#user.username")@TransactionalpublicUsercreateUser(Useruser){// 业务逻辑returnuserRepository.save(user);}/** * 异步方法日志 */@Loggable(module="用户管理",value="批量导入用户",async=true,virtualThread=true,slowThreshold=5000)publicCompletableFuture<List<User>>batchImport(List<User>users){returnCompletableFuture.supplyAsync(()->{// 批量处理逻辑returnuserRepository.saveAll(users);},Executors.newVirtualThreadPerTaskExecutor());}/** * 响应式方法日志 */@ReactiveLog(traceStream=true,maxTraceElements=20,timeout=30000)@Loggable(module="用户管理",value="查询用户列表",async=true)publicFlux<User>listUsers(intpage,intsize){returnuserRepository.findAll().skip(page*size).take(size).doOnNext(user->log.debug("处理用户: {}",user.getUsername()));}/** * 分布式追踪日志 */@TraceLog(spanName="user.update",tags={"userId=#userId","operation=update"},remote=false)@Loggable(module="用户管理",value="更新用户信息",level=Loggable.LogLevel.INFO)publicMono<User>updateUser(LonguserId,UserDTOdto){returnuserRepository.findById(userId).flatMap(user->{user.setEmail(dto.getEmail());user.setPhone(dto.getPhone());returnuserRepository.save(user);});}/** * 错误处理示例 */@Loggable(module="用户管理",value="删除用户",level=Loggable.LogLevel.ERROR,stackTrace=true)publicvoiddeleteUser(LonguserId){try{userRepository.deleteById(userId);}catch(Exceptione){log.error("删除用户失败: {}",userId,e);thrownewBusinessException("删除用户失败");}}/** * 虚拟线程示例 */@Loggable(module="用户管理",value="并发处理用户",async=true,virtualThread=true,asyncStrategy=Loggable.AsyncStrategy.VIRTUAL_THREAD)publicvoidprocessUsersConcurrently(List<Long>userIds){try(varscope=newjava.util.concurrent.StructuredTaskScope.ShutdownOnFailure()){for(LonguserId:userIds){scope.fork(()->processUser(userId));}scope.join();}catch(InterruptedExceptione){Thread.currentThread().interrupt();thrownewRuntimeException("处理中断",e);}}privateUserprocessUser(LonguserId){// 处理单个用户returnuserRepository.findById(userId).map(user->{// 业务处理returnuser;}).orElseThrow(()->newRuntimeException("用户不存在"));}}