Spring Boot中Service如何识别调用它的Controller？

Spring生态支持多种方式让Service知晓调用方的Controller，不需要额外传入ID或创建多个Service实现，下面是几种可行的方案：

1. 利用请求上下文（Web环境专用） #

因为Controller是处理HTTP请求的组件，每个请求对应独立线程，Spring会将请求上下文存入RequestContextHolder。你可以在Service中通过它获取当前请求的处理器方法，进而拿到Controller的类信息：

import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.HandlerMapping;
import org.springframework.web.method.HandlerMethod;

@Service
public class MyService {
    public void call() {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attributes != null) {
            HandlerMethod handlerMethod = (HandlerMethod) attributes.getAttribute(
                HandlerMapping.BEST_MATCHING_HANDLER_ATTRIBUTE,
                RequestAttributes.SCOPE_REQUEST
            );
            Class<?> controllerClass = handlerMethod.getBeanType();
            
            if (controllerClass.equals(ControllerA.class)) {
                // 执行Controller A调用时的自定义逻辑
            } else if (controllerClass.equals(ControllerB.class)) {
                // 执行Controller B调用时的自定义逻辑
            }
        }
    }
}

注意：这种方式仅适用于Web请求场景，如果是异步调用或非Web环境（比如定时任务），RequestContextHolder可能拿不到有效信息。

2. 解析线程栈轨迹（通用场景） #

通过获取当前线程的栈轨迹，遍历找到带有@Controller或@RestController注解的类，即为调用方Controller：

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RestController;

@Service
public class MyService {
    public void call() {
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        for (StackTraceElement element : stackTrace) {
            try {
                Class<?> clazz = Class.forName(element.getClassName());
                if (clazz.isAnnotationPresent(Controller.class) || clazz.isAnnotationPresent(RestController.class)) {
                    if (clazz.equals(ControllerA.class)) {
                        // Controller A对应的逻辑
                    } else if (clazz.equals(ControllerB.class)) {
                        // Controller B对应的逻辑
                    }
                    break;
                }
            } catch (ClassNotFoundException e) {
                // 忽略无法加载的类
            }
        }
    }
}

注意：栈轨迹解析的性能略低，且如果Controller被Spring AOP代理，可能需要处理代理类的情况（比如通过AopUtils.getTargetClass()获取原始类）。

3. 自定义注解+ThreadLocal（灵活通用） #

通过自定义注解标记Controller方法，结合AOP将调用方Controller信息存入ThreadLocal，Service从ThreadLocal中读取：

步骤1：定义自定义注解 #

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CallerController {
    Class<?> value();
}

步骤2：在Controller方法上添加注解 #

@Controller
public class ControllerA {
    @Autowired
    private MyService service;

    @CallerController(ControllerA.class)
    public void handleRequest() {
        service.call();
    }
}

@Controller
public class ControllerB {
    @Autowired
    private MyService service;

    @CallerController(ControllerB.class)
    public void handleRequest() {
        service.call();
    }
}

步骤3：编写AOP切面存入ThreadLocal #

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class CallerAspect {
    private static final ThreadLocal<Class<?>> CALLER_CONTROLLER = new ThreadLocal<>();

    @Before("@annotation(CallerController)")
    public void beforeInvoke(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        CallerController annotation = signature.getMethod().getAnnotation(CallerController.class);
        CALLER_CONTROLLER.set(annotation.value());
    }

    @After("@annotation(CallerController)")
    public void afterInvoke() {
        CALLER_CONTROLLER.remove(); // 避免内存泄漏
    }

    public static Class<?> getCallerController() {
        return CALLER_CONTROLLER.get();
    }
}

步骤4：在Service中获取调用方信息 #

@Service
public class MyService {
    public void call() {
        Class<?> caller = CallerAspect.getCallerController();
        if (caller.equals(ControllerA.class)) {
            // 执行对应逻辑
        } else if (caller.equals(ControllerB.class)) {
            // 执行对应逻辑
        }
    }
}

这种方式既适用于Web环境，也支持非Web场景，且性能较好，是比较推荐的灵活方案。

内容的提问来源于stack exchange，提问作者danilakds