在Spring Boot中使用MapDB作为请求生命周期状态存储的实践及清理方案问询

当然有开发者尝试过用MapDB实现请求级别的状态存储，不过要注意MapDB默认是持久化存储，所以必须采用内存模式来适配请求生命周期的临时存储需求，避免不必要的磁盘IO开销。下面是具体的实现方案和关键操作细节：

1. 配置内存版MapDB实例 #

首先创建一个单例的内存模式MapDB实例，确保多线程下的安全性：

import org.mapdb.DB;
import org.mapdb.DBMaker;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.concurrent.ConcurrentMap;

@Configuration
public class MapDBConfig {
    @Bean
    public DB requestStateDB() {
        return DBMaker.memoryDB()
                .transactionDisable() // 关闭事务，提升性能
                .make();
    }

    @Bean
    public ConcurrentMap<String, ConcurrentMap<String, Object>> requestStateMap(DB db) {
        return db.hashMap("requestStates")
                .createOrOpen();
    }
}

这里用嵌套的ConcurrentMap：外层key是请求唯一ID，内层是该请求的状态键值对（比如isDebug）。

2. 绑定请求上下文与初始化状态容器 #

通过Spring的拦截器，在请求进入时生成唯一请求ID，绑定到请求上下文，并初始化该请求的状态容器：

import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.UUID;
import java.util.concurrent.ConcurrentMap;

public class RequestStateInterceptor implements HandlerInterceptor {
    private final ConcurrentMap<String, ConcurrentMap<String, Object>> requestStateMap;

    public RequestStateInterceptor(ConcurrentMap<String, ConcurrentMap<String, Object>> requestStateMap) {
        this.requestStateMap = requestStateMap;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        String requestId = UUID.randomUUID().toString();
        // 将请求ID存入请求上下文
        request.setAttribute("REQUEST_ID", requestId);
        // 初始化该请求的状态容器
        requestStateMap.put(requestId, new ConcurrentHashMap<>());
        return true;
    }
}

记得在Spring配置类中注册这个拦截器，让它生效。

3. 封装状态读写工具类 #

写一个工具类统一处理状态的读写，简化业务代码的调用：

import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import java.util.concurrent.ConcurrentMap;

@Component
public class RequestStateManager {
    private final ConcurrentMap<String, ConcurrentMap<String, Object>> requestStateMap;

    public RequestStateManager(ConcurrentMap<String, ConcurrentMap<String, Object>> requestStateMap) {
        this.requestStateMap = requestStateMap;
    }

    public void setRequestState(String key, Object value) {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attributes == null) return;
        String requestId = (String) attributes.getRequest().getAttribute("REQUEST_ID");
        ConcurrentMap<String, Object> stateMap = requestStateMap.get(requestId);
        if (stateMap != null) {
            stateMap.put(key, value);
        }
    }

    public Object getRequestState(String key) {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attributes == null) return null;
        String requestId = (String) attributes.getRequest().getAttribute("REQUEST_ID");
        ConcurrentMap<String, Object> stateMap = requestStateMap.get(requestId);
        return stateMap != null ? stateMap.get(key) : null;
    }
}

业务代码中就可以直接注入RequestStateManager，调用setRequestState("isDebug", true)或者getRequestState("isDebug")来操作状态。

4. 请求结束时的状态清理 #

还是用之前的拦截器，在afterCompletion方法中执行清理操作，无论请求成功还是失败都会触发：

@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
    String requestId = (String) request.getAttribute("REQUEST_ID");
    if (requestId != null) {
        requestStateMap.remove(requestId);
    }
}

额外的内存泄漏防护 #

如果遇到极端情况（比如容器崩溃导致拦截器未执行），可以加一个定时任务定期清理超时的请求状态：

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.Iterator;
import java.util.concurrent.ConcurrentMap;

@Component
public class RequestStateCleanupTask {
    private final ConcurrentMap<String, ConcurrentMap<String, Object>> requestStateMap;
    // 假设请求超时时间为30秒
    private static final long TIMEOUT_MS = 30000;

    public RequestStateCleanupTask(ConcurrentMap<String, ConcurrentMap<String, Object>> requestStateMap) {
        this.requestStateMap = requestStateMap;
    }

    @Scheduled(fixedRate = 60000) // 每分钟执行一次
    public void cleanupTimeoutStates() {
        long currentTime = System.currentTimeMillis();
        Iterator<String> iterator = requestStateMap.keySet().iterator();
        while (iterator.hasNext()) {
            String requestId = iterator.next();
            // 这里可以修改为存储请求创建时间，比如在preHandle时把时间存入内层Map
            Long createTime = (Long) requestStateMap.get(requestId).get("createTime");
            if (createTime != null && currentTime - createTime > TIMEOUT_MS) {
                iterator.remove();
            }
        }
    }
}

需要在配置类上加上@EnableScheduling开启定时任务。

注意事项 #

• 优先用内存模式：绝对不要用持久化模式的MapDB做请求级存储，磁盘IO会严重拖垮性能。
• 线程安全：必须使用ConcurrentMap或者MapDB提供的并发安全集合，避免多线程请求下的状态混乱。
• 替代方案考量：如果只是简单的请求级状态存储，Spring自带的RequestAttributes（通过RequestContextHolder操作）已经足够轻量，只有当你需要MapDB的原子操作、复杂数据结构支持时，才推荐用MapDB。

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