springMVC源码分析--FlashMap和FlashMapManager重定向数据保存

在上一篇博客​​ springMVC源码分析--页面跳转RedirectView（三）​​中我们看到了在RedirectView跳转时会将跳转之前的请求中的参数保存到fFlashMap中，然后通过FlashManager保存起来。

protected void renderMergedOutputModel(Map<String, Object> model, HttpServletRequest request,  
            HttpServletResponse response) throws IOException {  
        //创建跳转链接  
        String targetUrl = createTargetUrl(model, request);  
        targetUrl = updateTargetUrl(targetUrl, model, request, response);  
        //获取原请求所携带的数据  
        FlashMap flashMap = RequestContextUtils.getOutputFlashMap(request);  
        if (!CollectionUtils.isEmpty(flashMap)) {  
            UriComponents uriComponents = UriComponentsBuilder.fromUriString(targetUrl).build();  
            flashMap.setTargetRequestPath(uriComponents.getPath());  
            flashMap.addTargetRequestParams(uriComponents.getQueryParams());  
            FlashMapManager flashMapManager = RequestContextUtils.getFlashMapManager(request);  
            if (flashMapManager == null) {  
                throw new IllegalStateException("FlashMapManager not found despite output FlashMap having been set");  
            }  
            //将数据保存起来，作为跳转之后请求的数据使用  
            flashMapManager.saveOutputFlashMap(flashMap, request, response);  
        }  
        //重定向操作  
        sendRedirect(request, response, targetUrl, this.http10Compatible);  
    }

接下来我们分别认识一下FlashMap和FalshMapManager

FlashMapManager是一个接口，定义了保存FlashMap和获取FlashMap的方法。

public interface FlashMapManager {

  //从session中获取flashMap
  FlashMap retrieveAndUpdate(HttpServletRequest request, HttpServletResponse response);

  //将falshMap保存到session中
  void saveOutputFlashMap(FlashMap flashMap, HttpServletRequest request, HttpServletResponse response);

}

两个实现方法都在AbstractFlashMapManager抽象方法中：

saveOutputFlashMap方法实现如下

@Override
  public final void saveOutputFlashMap(FlashMap flashMap, HttpServletRequest request, HttpServletResponse response) {
    if (CollectionUtils.isEmpty(flashMap)) {
      return;
    }
    String path = decodeAndNormalizePath(flashMap.getTargetRequestPath(), request);
    flashMap.setTargetRequestPath(path);
    if (logger.isDebugEnabled()) {
      logger.debug("Saving FlashMap=" + flashMap);
    }
    flashMap.startExpirationPeriod(getFlashMapTimeout());

    Object mutex = getFlashMapsMutex(request);
    if (mutex != null) {
      synchronized (mutex) {
        List<FlashMap> allFlashMaps = retrieveFlashMaps(request);
        allFlashMaps = (allFlashMaps != null ? allFlashMaps : new CopyOnWriteArrayList<FlashMap>());
        allFlashMaps.add(flashMap);
        //flashMap是在子类SessionFlashManager中
        updateFlashMaps(allFlashMaps, request, response);
      }
    }
    else {
      List<FlashMap> allFlashMaps = retrieveFlashMaps(request);
      allFlashMaps = (allFlashMaps != null ? allFlashMaps : new LinkedList<FlashMap>());
      allFlashMaps.add(flashMap);
        //flashMap是在子类SessionFlashManager中
      updateFlashMaps(allFlashMaps, request, response);
    }
  }

updateFlashMaps方法的实现机制就是将数据保存的请求的Session中，这样跳转后的请求可以从Session中获取数据，并且所有的实现都保存在同一个Session中，为了防止不同重定向请求的数据相互影响，这边有锁进行处理控制。

@Override
  protected void updateFlashMaps(List<FlashMap> flashMaps, HttpServletRequest request, HttpServletResponse response) {
    WebUtils.setSessionAttribute(request, FLASH_MAPS_SESSION_ATTRIBUTE, (!flashMaps.isEmpty() ? flashMaps : null));
  }

retrieveAndUpdate获取FlashMap的实现如下：

@Override
  public final FlashMap retrieveAndUpdate(HttpServletRequest request, HttpServletResponse response) {
    List<FlashMap> allFlashMaps = retrieveFlashMaps(request);
    ........
  }

retrieveFlashMaps中的实现机制就是从Session中获取数据

@Override
  @SuppressWarnings("unchecked")
  protected List<FlashMap> retrieveFlashMaps(HttpServletRequest request) {
    HttpSession session = request.getSession(false);
    return (session != null ? (List<FlashMap>) session.getAttribute(FLASH_MAPS_SESSION_ATTRIBUTE) : null);
  }

当重定向的请求在浏览器中重定向之后会进入的DispatcherServlet的doService方法

@Override
  protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {

    ........
    
    //从Session中获取保存的FlashMap中的值
    FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
    if (inputFlashMap != null) {
      request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
    }
    //将值保存到request中。这样就不需要通过浏览器跳转组装链接来传递参数了
    request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
    request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);

    .......
    
  }

FlashMap简单来说就是一个HashMap，用于数据保存。

public final class FlashMap extends HashMap<String, Object> implements Comparable<FlashMap> {

  private String targetRequestPath;

  private final MultiValueMap<String, String> targetRequestParams = new LinkedMultiValueMap<String, String>(4);

  private long expirationTime = -1;

  public void setTargetRequestPath(String path) {
    this.targetRequestPath = path;
  }
  public String getTargetRequestPath() {
    return this.targetRequestPath;
  }
  public FlashMap addTargetRequestParams(MultiValueMap<String, String> params) {
    if (params != null) {
      for (String key : params.keySet()) {
        for (String value : params.get(key)) {
          addTargetRequestParam(key, value);
        }
      }
    }
    return this;
  }

  
  public FlashMap addTargetRequestParam(String name, String value) {
    if (StringUtils.hasText(name) && StringUtils.hasText(value)) {
      this.targetRequestParams.add(name, value);
    }
    return this;
  }

  public MultiValueMap<String, String> getTargetRequestParams() {
    return this.targetRequestParams;
  }

  public void startExpirationPeriod(int timeToLive) {
    this.expirationTime = System.currentTimeMillis() + timeToLive * 1000;
  }

  public void setExpirationTime(long expirationTime) {
    this.expirationTime = expirationTime;
  }

  public long getExpirationTime() {
    return this.expirationTime;
  }

  public boolean isExpired() {
    return (this.expirationTime != -1 && System.currentTimeMillis() > this.expirationTime);
  }

  @Override
  public int compareTo(FlashMap other) {
    int thisUrlPath = (this.targetRequestPath != null ? 1 : 0);
    int otherUrlPath = (other.targetRequestPath != null ? 1 : 0);
    if (thisUrlPath != otherUrlPath) {
      return otherUrlPath - thisUrlPath;
    }
    else {
      return other.targetRequestParams.size() - this.targetRequestParams.size();
    }
  }

  @Override
  public boolean equals(Object other) {
    if (this == other) {
      return true;
    }
    if (!(other instanceof FlashMap)) {
      return false;
    }
    FlashMap otherFlashMap = (FlashMap) other;
    return (super.equals(otherFlashMap) &&
        ObjectUtils.nullSafeEquals(this.targetRequestPath, otherFlashMap.targetRequestPath) &&
        this.targetRequestParams.equals(otherFlashMap.targetRequestParams));
  }

  @Override
  public int hashCode() {
    int result = super.hashCode();
    result = 31 * result + ObjectUtils.nullSafeHashCode(this.targetRequestPath);
    result = 31 * result + this.targetRequestParams.hashCode();
    return result;
  }

  @Override
  public String toString() {
    return "FlashMap [attributes=" + super.toString() + ", targetRequestPath=" +
        this.targetRequestPath + ", targetRequestParams=" + this.targetRequestParams + "]";
  }

}