解码百度“代码艺术”：从圈复杂度治理到虚拟线程重构，卓越工程师的Java编码实战

// ❌ 烂代码特征：嵌套if、魔法值、串行阻塞、职责混乱
@Service
public class OldAggregationService {
    public UserDashboardDTO getDashboard(String userId) {
        UserDashboardDTO dto = new UserDashboardDTO();
        if (userId != null && !userId.isEmpty()) {
            // 串行阻塞调用，3个RPC耗时累加（假设每个200ms = 总耗时600ms）
            UserBase base = rpcClient.getUser(userId);
            if (base != null && "ACTIVE".equals(base.getStatus())) {
                dto.setBase(base);
                List<Long> ids = rpcClient.getPoints(userId); 
                if (ids != null && !ids.isEmpty()) {
                    dto.setPoints(ids.stream().mapToLong(Long::longValue).sum());
                } else {
                    dto.setPoints(0L);
                }
                // 权限校验嵌套
                if ("ADMIN".equals(base.getRole())) {
                    dto.setPermissions(rpcClient.getAdminTree());
                } else if ("USER".equals(base.getRole())) {
                    dto.setPermissions(rpcClient.getUserTree());
                } else {
                    dto.setPermissions(new ArrayList<>());
                }
            } else {
                throw new RuntimeException("用户不存在");
            }
        } else {
            throw new IllegalArgumentException("ID非法");
        }
        return dto;
    }
}

// ✅ 卓越工程师代码：圈复杂度 = 3，且全异步并行
@Service
public class ArtOfCodeAggregationService {

    // 虚拟线程执行器（无需池化，随建随用）
    private final ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();

    public UserDashboardDTO getDashboard(String userId) {
        // 1. 防御性编程：卫语句前置，降低嵌套
        if (userId == null || userId.isBlank()) {
            throw new IllegalArgumentException("User ID must not be blank");
        }

        // 2. 使用结构化并发（Structured Concurrency）进行并行RPC
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            
            // 子任务1：获取用户基础信息（必须成功）
            StructuredTaskScope.Subtask<UserBase> baseSubtask = scope.fork(() -> 
                rpcClient.getUser(userId)
            );
            
            // 子任务2：获取积分（允许失败降级）
            StructuredTaskScope.Subtask<Long> pointsSubtask = scope.fork(() -> {
                List<Long> list = rpcClient.getPoints(userId);
                return list == null ? 0L : list.stream().mapToLong(Long::longValue).sum();
            });

            // 子任务3：获取权限树（基于角色）
            // 注意：为了演示，这里先join等待base完成以获取角色，但虚拟线程开销极小
            scope.join(); // 等待所有子任务完成或任一失败
            scope.throwIfFailed(e -> new ServiceException("RPC call failed", e));

            // 3. 结果组装：业务逻辑平铺，无任何嵌套
            UserBase base = baseSubtask.get();
            if (!"ACTIVE".equals(base.getStatus())) {
                throw new BusinessException("User is not active");
            }

            long points = pointsSubtask.get();
            List<String> permissions = PermissionStrategy.getPermissionsByRole(base.getRole());

            return UserDashboardDTO.builder()
                    .base(base)
                    .points(points)
                    .permissions(permissions)
                    .build();

        } catch (InterruptedException | ExecutionException e) {
            Thread.currentThread().interrupt();
            throw new SystemException("Concurrent aggregation interrupted", e);
        }
    }
}

// 策略枚举：彻底消灭 if-else
enum PermissionStrategy {
    ADMIN("ADMIN") { 
        @Override List<String> get() { return List.of("READ", "WRITE", "DELETE"); } 
    },
    USER("USER") { 
        @Override List<String> get() { return List.of("READ"); } 
    },
    GUEST("GUEST") { 
        @Override List<String> get() { return Collections.emptyList(); } 
    };

    private final String role;
    private static final Map<String, PermissionStrategy> CACHE = 
        Stream.of(values()).collect(Collectors.toMap(s -> s.role, Function.identity()));

    public static List<String> getPermissionsByRole(String role) {
        return CACHE.getOrDefault(role, GUEST).get();
    }
    abstract List<String> get();
}

@Aspect
@Component
public class ObservableLogAspect {
    private static final Logger log = LoggerFactory.getLogger(ObservableLogAspect.class);

    @Around("@annotation(org.springframework.web.bind.annotation.GetMapping) || @annotation(org.springframework.web.bind.annotation.PostMapping)")
    public Object logFullParams(ProceedingJoinPoint pjp) throws Throwable {
        // 1. 注入 TraceId (若上游未传则生成)
        String traceId = MDC.get("traceId");
        if (traceId == null) {
            traceId = UUID.randomUUID().toString().replace("-", "");
            MDC.put("traceId", traceId);
        }

        long start = System.nanoTime();
        String methodName = pjp.getSignature().toShortString();
        // 2. 记录入参（Jackson序列化，注意脱敏）
        String argsJson = JsonUtils.toJson(pjp.getArgs());

        try {
            Object result = pjp.proceed();
            // 3. 记录出参与耗时（结构化JSON，方便ELK直接索引）
            log.info("【API】traceId={}, method={}, cost_ms={}, args={}, response={}",
                    traceId, methodName, TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start),
                    argsJson, JsonUtils.toJson(result));
            return result;
        } catch (Throwable t) {
            log.error("【API-ERROR】traceId={}, method={}, cost_ms={}, args={}, error={}",
                    traceId, methodName, TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start),
                    argsJson, t.getMessage(), t);
            throw t;
        } finally {
            // 4. 防止内存泄漏（虚拟线程大量创建，必须清理ThreadLocal）
            MDC.remove("traceId");
        }
    }
}

<properties>
    <java.version>21</java.version>
    <spring-boot.version>3.2.0</spring-boot.version>
</properties>
<dependencies>
    <!-- 启用虚拟线程需要 Spring Boot 3.2 及以上 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <!-- 排除默认的 Logback，改用 Log4j2 异步高性能 -->
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-logging</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-log4j2</artifactId>
    </dependency>
    <!-- 开启虚拟线程的Tomcat适配器 -->
    <dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-core</artifactId>
    </dependency>
</dependencies>

@Bean
public TomcatProtocolHandlerCustomizer<?> protocolHandlerVirtualThreadExecutorCustomizer() {
    return protocolHandler -> protocolHandler.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
}