Spring中非静态类实例变量跨请求值残留问题及解决方案问询

在标注@Service的非静态服务类中定义了非final实例变量originalDetails，意图在单个方法流程的不同场景中复用，避免重复执行DB调用。该服务通过private final关键字注入到@Component类的构造方法中，但后续API调用时，originalDetails会保留上一次请求从DB获取的值。

代码示例如下：

构造方法类（Component） #

@Slf4j
@Component
@RequiredArgsConstructor
public class Constructor {

    private final Service service;

    public List<Restriction> checkRestrictions(A a, B b) {
        return service.checkRestriction(a, b);
    }
}

服务类（Service） #

@Slf4j
@Service
@RequiredArgsConstructor
public class Service {

    private TeamResponseDto originalDetails = null;

    public List<Restriction> checkRestriction(A a, B b){
        Restriction r1 = method1();
        Restriction r2 = method2();
        List<Restriction> list = new ArrayList();
        list.add(r1);list.add(r2);
        return list;
    }
    private Restriction method1(){
        if(something){
            return new Restriction();
        }
        originalDetails = dbCall();
        return new Restriction(originalDetails);
    }
    private Restriction method2(){
        originalDetails = originalDetails == null ? dbCall() : originalDetails;
        return new Restriction(originalDetails);
    }
}

首次请求正常，但后续新线程的API请求中，originalDetails仍保留首次获取的DB值。

1. 该问题的解决方案是什么？仅使用private关键字能否解决此问题？ #

解决方案 #

问题核心是Spring中@Service默认是单例Bean，整个应用生命周期内只有一个实例，实例变量originalDetails会被所有请求线程共享，导致脏数据。解决的关键是：不要用服务类的实例变量存储请求级别的数据，改用局部变量、请求上下文或线程隔离的存储方式。

仅用private关键字无法解决 #

private仅控制变量的访问权限，无法改变单例Bean实例变量被全局共享的本质。不管是private还是其他访问修饰符，只要是单例Bean的实例变量，都会被所有请求共享，因此仅修改为private不能解决问题。

2. 注入依赖时为何要使用final关键字？ #

• 保证依赖不可变：一旦注入完成，依赖实例的引用不会被替换，避免后续代码意外修改依赖，提升代码稳定性。
• 降低并发风险：final修饰的变量是只读的，减少了单例Bean在并发场景下因可变成员变量引发的线程安全问题。
• 简化代码编写：配合Lombok的@RequiredArgsConstructor，会自动为所有final修饰的成员变量生成构造方法，无需手动编写构造注入代码，减少冗余。

3. 如何在单个流程的多个方法间复用这个不可变变量？ #

单例List依然是全局共享的，会存在同样的线程安全问题，不推荐使用。以下是几种更优方案：

方案1：局部变量传递（最直接安全） #

将originalDetails作为局部变量在方法间传递，完全避免共享：

@Slf4j
@Service
@RequiredArgsConstructor
public class Service {

    public List<Restriction> checkRestriction(A a, B b){
        TeamResponseDto originalDetails = null;
        // 先判断是否需要获取数据
        if (!something) {
            originalDetails = dbCall();
        }
        Restriction r1 = method1(originalDetails);
        Restriction r2 = method2(originalDetails);
        List<Restriction> list = new ArrayList<>();
        list.add(r1);
        list.add(r2);
        return list;
    }

    private Restriction method1(TeamResponseDto originalDetails){
        if(something){
            return new Restriction();
        }
        return new Restriction(originalDetails);
    }

    private Restriction method2(TeamResponseDto originalDetails){
        TeamResponseDto details = originalDetails == null ? dbCall() : originalDetails;
        return new Restriction(details);
    }
}

方案2：ThreadLocal存储请求级数据 #

如果方法层级较深，传递参数繁琐，可以用ThreadLocal存储，每个线程拥有独立的变量副本：

@Slf4j
@Service
@RequiredArgsConstructor
public class Service {

    private final ThreadLocal<TeamResponseDto> originalDetailsHolder = new ThreadLocal<>();

    public List<Restriction> checkRestriction(A a, B b){
        try {
            Restriction r1 = method1();
            Restriction r2 = method2();
            List<Restriction> list = new ArrayList<>();
            list.add(r1);
            list.add(r2);
            return list;
        } finally {
            // 必须清理，避免线程池复用导致的内存泄漏
            originalDetailsHolder.remove();
        }
    }

    private Restriction method1(){
        if(something){
            return new Restriction();
        }
        TeamResponseDto details = dbCall();
        originalDetailsHolder.set(details);
        return new Restriction(details);
    }

    private Restriction method2(){
        TeamResponseDto details = originalDetailsHolder.get();
        details = details == null ? dbCall() : details;
        return new Restriction(details);
    }
}

方案3：封装上下文对象（扩展性好） #

如果需要共享的变量不止一个，可以封装成上下文对象作为参数传递：

// 定义上下文类
public class CheckRestrictionContext {
    private TeamResponseDto originalDetails;

    // getter、setter方法
    public TeamResponseDto getOriginalDetails() {
        return originalDetails;
    }

    public void setOriginalDetails(TeamResponseDto originalDetails) {
        this.originalDetails = originalDetails;
    }
}

// 服务类修改
@Slf4j
@Service
@RequiredArgsConstructor
public class Service {

    public List<Restriction> checkRestriction(A a, B b){
        CheckRestrictionContext context = new CheckRestrictionContext();
        Restriction r1 = method1(context);
        Restriction r2 = method2(context);
        List<Restriction> list = new ArrayList<>();
        list.add(r1);
        list.add(r2);
        return list;
    }

    private Restriction method1(CheckRestrictionContext context){
        if(something){
            return new Restriction();
        }
        TeamResponseDto details = dbCall();
        context.setOriginalDetails(details);
        return new Restriction(details);
    }

    private Restriction method2(CheckRestrictionContext context){
        TeamResponseDto details = context.getOriginalDetails();
        details = details == null ? dbCall() : details;
        return new Restriction(details);
    }
}

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