Java FlowExecutionRepositoryException类代码示例

import org.springframework.webflow.execution.repository.FlowExecutionRepositoryException; //导入依赖的package包/类
public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception exception) {
    if (exception instanceof FlowExecutionRepositoryException && !(exception instanceof BadlyFormattedFlowExecutionKeyException)) {
        String urlToRedirectTo = request.getRequestURI() + (request.getQueryString() != null ? '?' + request.getQueryString() : "");
        log.debug("Error getting flow information for URL [{}]", urlToRedirectTo, exception);
        Map<String, Object> model = new HashMap();
        model.put(this.modelKey, StringEscapeUtils.escapeHtml4(exception.getMessage()));
        return new ModelAndView(new RedirectView(urlToRedirectTo), model);
    } else if (exception instanceof AbstractFlowExecutionException) {
        if (log.isDebugEnabled()) {
            log.error("Flow execution error", exception);
        } else {
            log.error("Flow execution error: {}", exception.getMessage());
        }
        return ((AbstractFlowExecutionException) exception).getModelAndView();
    } else {
        log.debug("Ignoring the received exception due to a type mismatch", exception);
        return null;
    }
}
 

import org.springframework.webflow.execution.repository.FlowExecutionRepositoryException; //导入依赖的package包/类
@Override
public ModelAndView resolveException(final HttpServletRequest request,
    final HttpServletResponse response, final Object handler,
    final Exception exception) {

    /*
     * Since FlowExecutionRepositoryException is a common ancestor to these exceptions and other
     * error cases we would likely want to hide from the user, it seems reasonable to check for
     * FlowExecutionRepositoryException.
     *
     * BadlyFormattedFlowExecutionKeyException is specifically ignored by this handler
     * because redirecting to the requested URI with this exception may cause an infinite
     * redirect loop (i.e. when invalid "execution" parameter exists as part of the query string
     */
    if (!(exception instanceof FlowExecutionRepositoryException)
          || exception instanceof BadlyFormattedFlowExecutionKeyException) {
        logger.debug("Ignoring the received exception due to a type mismatch", exception);
        return null;
    }

    final String urlToRedirectTo = request.getRequestURI()
            + (request.getQueryString() != null ? '?'
            + request.getQueryString() : "");

    logger.debug("Error getting flow information for URL [{}]", urlToRedirectTo, exception);
    final Map<String, Object> model = new HashMap<>();
    model.put(this.modelKey, StringEscapeUtils.escapeHtml4(exception.getMessage()));

    return new ModelAndView(new RedirectView(urlToRedirectTo), model);
}
 

import org.springframework.webflow.execution.repository.FlowExecutionRepositoryException; //导入依赖的package包/类
@Override
public ModelAndView resolveException(final HttpServletRequest request,
    final HttpServletResponse response, final Object handler,
    final Exception exception) {

    /*
     * Since FlowExecutionRepositoryException is a common ancestor to these exceptions and other
     * error cases we would likely want to hide from the user, it seems reasonable to check for
     * FlowExecutionRepositoryException.
     *
     * BadlyFormattedFlowExecutionKeyException is specifically ignored by this handler
     * because redirecting to the requested URI with this exception may cause an infinite
     * redirect loop (i.e. when invalid "execution" parameter exists as part of the query string
     */
    if (!(exception instanceof FlowExecutionRepositoryException)
          || exception instanceof BadlyFormattedFlowExecutionKeyException) {
        LOGGER.debug("Ignoring the received exception due to a type mismatch", exception);
        return null;
    }

    final String urlToRedirectTo = request.getRequestURI()
            + (request.getQueryString() != null ? '?'
            + request.getQueryString() : StringUtils.EMPTY);

    LOGGER.debug("Error getting flow information for URL [{}]", urlToRedirectTo, exception);
    final Map<String, Object> model = new HashMap<>();
    model.put(this.modelKey, StringEscapeUtils.escapeHtml4(exception.getMessage()));

    return new ModelAndView(new RedirectView(urlToRedirectTo), model);
}
 

import org.springframework.webflow.execution.repository.FlowExecutionRepositoryException; //导入依赖的package包/类
@Override
public ModelAndView resolveException(final HttpServletRequest request,
    final HttpServletResponse response, final Object handler,
    final Exception exception) {

    /*
     * Since FlowExecutionRepositoryException is a common ancestor to these exceptions and other
     * error cases we would likely want to hide from the user, it seems reasonable to check for
     * FlowExecutionRepositoryException.
     *
     * BadlyFormattedFlowExecutionKeyException is specifically ignored by this handler
     * because redirecting to the requested URI with this exception may cause an infinite
     * redirect loop (i.e. when invalid "execution" parameter exists as part of the query string
     */
    if (!(exception instanceof FlowExecutionRepositoryException)
          || exception instanceof BadlyFormattedFlowExecutionKeyException) {
        logger.debug("Ignoring the received exception due to a type mismatch", exception);
        return null;
    }

    final String urlToRedirectTo = request.getRequestURI()
            + (request.getQueryString() != null ? "?"
            + request.getQueryString() : "");

    logger.debug("Error getting flow information for URL [{}]", urlToRedirectTo, exception);
    final Map<String, Object> model = new HashMap<String, Object>();
    model.put(this.modelKey, StringEscapeUtils.escapeHtml(exception.getMessage()));

    return new ModelAndView(new RedirectView(urlToRedirectTo), model);
}
 

import org.springframework.webflow.execution.repository.FlowExecutionRepositoryException; //导入依赖的package包/类
public FlowExecution getFlowExecution(final FlowExecutionKey key) throws FlowExecutionRepositoryException {
    if (!(key instanceof ClientFlowExecutionKey)) {
        throw new IllegalArgumentException(
                "Expected instance of ClientFlowExecutionKey but got " + key.getClass().getName());
    }
    final byte[] encoded = ((ClientFlowExecutionKey) key).getData();
    try {
        final SerializedFlowExecutionState state = (SerializedFlowExecutionState) this.transcoder.decode(encoded);
        final FlowDefinition flow = this.flowDefinitionLocator.getFlowDefinition(state.getFlowId());
        return this.flowExecutionFactory.restoreFlowExecution(
                state.getExecution(), flow, key, state.getConversationScope(), this.flowDefinitionLocator);
    } catch (IOException e) {
        throw new ClientFlowExecutionRepositoryException("Error decoding flow execution", e);
    }
}
 

import org.springframework.webflow.execution.repository.FlowExecutionRepositoryException; //导入依赖的package包/类
public FlowExecutionKey parseFlowExecutionKey(final String encodedKey) throws FlowExecutionRepositoryException {
    return ClientFlowExecutionKey.parse(encodedKey);
}
 

import org.springframework.webflow.execution.repository.FlowExecutionRepositoryException; //导入依赖的package包/类
public FlowExecutionLock getLock(final FlowExecutionKey key) throws FlowExecutionRepositoryException {
    return NOOP_LOCK;
}
 

import org.springframework.webflow.execution.repository.FlowExecutionRepositoryException; //导入依赖的package包/类
public void putFlowExecution(final FlowExecution flowExecution) throws FlowExecutionRepositoryException {} 

import org.springframework.webflow.execution.repository.FlowExecutionRepositoryException; //导入依赖的package包/类
public void removeFlowExecution(final FlowExecution flowExecution) throws FlowExecutionRepositoryException {}