#StackOverflowError实战

// 问题代码1：忘记终止条件
public class CommissionService {

    /**
     * 计算用户返佣
     * 问题：没有终止条件，导致无限递归
     */
    public BigDecimal calculateCommission(Long userId) {
        User user = userDao.selectById(userId);
        BigDecimal selfCommission = calculateSelfCommission(userId);
        // 忘记判断user.getParentId()是否为null
        BigDecimal parentCommission = calculateCommission(user.getParentId());
        return selfCommission.add(parentCommission);
    }
}

// 问题代码2：终止条件错误
public class TreeService {

    /**
     * 遍历树结构
     * 问题：终止条件永远不满足
     */
    public void traverse(TreeNode node) {
        if (node == null) {
            return;
        }
        // 永远返回true，递归无法终止
        if (node.getChildren() != null && node.hasNext()) {
            traverse(node);
        }
        for (TreeNode child : node.getChildren()) {
            traverse(child);
        }
    }
}

// 问题代码3：递归深度过大
public class FibonacciService {

    /**
     * 斐波那契数列递归实现
     * 问题：指数级时间复杂度，深度过大
     * fib(100) 会栈溢出
     */
    public long fibonacci(int n) {
        if (n <= 1) return n;
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}

// 正确写法1：必须判断终止条件
public BigDecimal calculateCommission(Long userId) {
    if (userId == null) {
        return BigDecimal.ZERO;
    }

    User user = userDao.selectById(userId);
    if (user == null) {
        return BigDecimal.ZERO;
    }

    BigDecimal selfCommission = calculateSelfCommission(userId);

    // 必须判断：父节点是否存在，是否是自己的下级
    if (user.getParentId() == null || !user.getParentId().equals(userId)) {
        return selfCommission;
    }

    BigDecimal parentCommission = calculateCommission(user.getParentId());
    return selfCommission.add(parentCommission);
}

// 正确写法2：尾递归优化（需要JVM支持）
public long fibonacciTail(int n, long a, long b) {
    if (n == 0) return a;
    if (n == 1) return b;
    return fibonacciTail(n - 1, b, a + b);
}

// 正确写法3：迭代替代递归
public long fibonacciIterative(int n) {
    if (n <= 1) return n;
    long a = 0, b = 1;
    for (int i = 2; i <= n; i++) {
        long temp = a + b;
        a = b;
        b = temp;
    }
    return b;
}

// 记忆化搜索
public class FibonacciWithMemo {

    private Map<Integer, Long> cache = new HashMap<>();

    public long fibonacci(int n) {
        if (n <= 1) return n;
        if (cache.containsKey(n)) {
            return cache.get(n);
        }
        long result = fibonacci(n - 1) + fibonacci(n - 2);
        cache.put(n, result);
        return result;
    }
}

// 限制递归深度
public class SafeRecursiveService {

    private static final int MAX_DEPTH = 100;
    private int currentDepth = 0;

    public void safeRecursive() {
        if (currentDepth >= MAX_DEPTH) {
            throw new BizException("递归深度超限，最大深度：" + MAX_DEPTH);
        }
        try {
            currentDepth++;
            doRecursive();
        } finally {
            currentDepth--;
        }
    }

    private void doRecursive() {
        // 业务逻辑
    }
}

// 问题代码：AOP切面导致循环调用
@Aspect
@Component
@Slf4j
public class PerformanceAspect {

    @Around("execution(* com.example..*Service.*(..))")
    public Object measureTime(ProceedingJoinPoint point) throws Throwable {
        long start = System.currentTimeMillis();

        // 这里是关键：切面本身调用了Service方法
        // 如果被切入的方法内部调用了另一个Service
        // 而这个Service又触发了AOP
        // 可能导致循环

        // 正确的做法：不要在AOP切面中调用其他Service
        Object result = point.proceed();

        long cost = System.currentTimeMillis() - start;
        if (cost > 1000) {
            log.warn("方法执行慢: {} 耗时 {}ms", point.getSignature(), cost);
            // 错误：不要在这里调用alertService，可能循环
            // alertService.sendAlert(point.getSignature().toString());
        }

        return result;
    }
}

// 正确做法：使用异步或消息队列通知
@Aspect
@Component
@Slf4j
public class SafePerformanceAspect {

    @Autowired
    private AlertProducer alertProducer;  // 消息队列生产者

    @Around("execution(* com.example..*Service.*(..))")
    public Object measureTime(ProceedingJoinPoint point) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = point.proceed();
        long cost = System.currentTimeMillis() - start;

        if (cost > 1000) {
            // 正确：异步发送告警，不阻塞主流程
            alertProducer.sendAsync(
                "slow-method",
                point.getSignature().toString(),
                cost
            );
        }

        return result;
    }
}

// 问题代码：Service互相调用
@Service
public class UserService {

    @Autowired private OrderService orderService;

    public void deactivateUser(Long userId) {
        // 停用用户
        userDao.updateStatus(userId, 0);
        // 调用OrderService
        orderService.cancelUserOrders(userId);  // 这里会触发OrderService的逻辑
    }
}

@Service
public class OrderService {

    @Autowired private UserService userService;

    public void cancelUserOrders(Long userId) {
        // 取消用户所有订单
        orderDao.cancelByUserId(userId);
        // 错误：又调用回UserService
        userService.deactivateUser(userId);  // 死循环！
    }
}

// 解决方案1：使用ApplicationContext获取代理对象
@Service
public class OrderService {

    @Autowired private ApplicationContext applicationContext;

    public void cancelUserOrders(Long userId) {
        orderDao.cancelByUserId(userId);
        // 不要调用userService，避免循环
    }
}

// 解决方案2：提取公共方法到新Service
@Service
public class UserStatusService {  // 新Service

    @Autowired private UserDao userDao;
    @Autowired private OrderDao orderDao;

    // 统一的用户停用逻辑
    public void deactivateUser(Long userId) {
        userDao.updateStatus(userId, 0);
        orderDao.cancelByUserId(userId);
    }
}

// 解决方案3：使用@Lazy注解
@Service
public class OrderService {

    @Autowired @Lazy private UserService userService;
}

// 使用事件机制解耦，避免循环调用
@Service
public class UserService {

    @Autowired private ApplicationEventPublisher publisher;

    public void deactivateUser(Long userId) {
        userDao.updateStatus(userId, 0);
        // 发布事件，不直接调用
        publisher.publishEvent(new UserDeactivatedEvent(userId));
    }
}

@Service
public class OrderService {

    @EventListener
    public void handleUserDeactivated(UserDeactivatedEvent event) {
        // 监听事件，异步处理
        orderDao.cancelByUserId(event.getUserId());
    }
}

// 或者使用消息队列
@Service
public class UserService {

    @Autowired private MessageProducer producer;

    public void deactivateUser(Long userId) {
        userDao.updateStatus(userId, 0);
        producer.send("user.deactivated", userId);
    }
}

@Service
public class OrderService {

    @RabbitListener(queues = "user.deactivated.queue")
    public void handleUserDeactivated(Long userId) {
        orderDao.cancelByUserId(userId);
    }
}