@Override
 protected void doFilterInternal(
     HttpServletRequest request, HttpServletResponse response, FilterChain chain)
     throws ServletException, IOException {
   UrlPathHelper helper = new UrlPathHelper();
   String suffix = helper.getPathWithinApplication(request);
   StopWatch stopWatch = new StopWatch();
   stopWatch.start();
   try {
     chain.doFilter(request, response);
   } finally {
     stopWatch.stop();
     int status = getStatus(response);
     Object bestMatchingPattern =
         request.getAttribute(HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE);
     HttpStatus httpStatus = HttpStatus.OK;
     try {
       httpStatus = HttpStatus.valueOf(status);
     } catch (Exception ex) {
       // not convertible
     }
     if (bestMatchingPattern != null) {
       suffix = bestMatchingPattern.toString().replaceAll("[{}]", "-");
     } else if (httpStatus.is4xxClientError()) {
       suffix = UNKNOWN_PATH_SUFFIX;
     }
     String gaugeKey = getKey("response" + suffix);
     MetricFilterAutoConfiguration.this.gaugeService.submit(
         gaugeKey, stopWatch.getTotalTimeMillis());
     String counterKey = getKey("status." + status + suffix);
     MetricFilterAutoConfiguration.this.counterService.increment(counterKey);
   }
 }
예제 #2
0
  /**
   * Handles requests with message handler implementation. Previously sets Http request method as
   * header parameter.
   *
   * @param method
   * @param requestEntity
   * @return
   */
  private ResponseEntity<String> handleRequestInternal(
      HttpMethod method, HttpEntity<String> requestEntity) {
    Map<String, ?> httpRequestHeaders = headerMapper.toHeaders(requestEntity.getHeaders());
    Map<String, String> customHeaders = new HashMap<String, String>();
    for (Entry<String, List<String>> header : requestEntity.getHeaders().entrySet()) {
      if (!httpRequestHeaders.containsKey(header.getKey())) {
        customHeaders.put(
            header.getKey(), StringUtils.collectionToCommaDelimitedString(header.getValue()));
      }
    }

    HttpServletRequest request =
        ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
    UrlPathHelper pathHelper = new UrlPathHelper();

    customHeaders.put(CitrusHttpMessageHeaders.HTTP_REQUEST_URI, pathHelper.getRequestUri(request));
    customHeaders.put(
        CitrusHttpMessageHeaders.HTTP_CONTEXT_PATH, pathHelper.getContextPath(request));

    String queryParams = pathHelper.getOriginatingQueryString(request);
    customHeaders.put(
        CitrusHttpMessageHeaders.HTTP_QUERY_PARAMS, queryParams != null ? queryParams : "");

    customHeaders.put(CitrusHttpMessageHeaders.HTTP_REQUEST_METHOD, method.toString());

    Message<?> response =
        messageHandler.handleMessage(
            MessageBuilder.withPayload(requestEntity.getBody())
                .copyHeaders(convertHeaderTypes(httpRequestHeaders))
                .copyHeaders(customHeaders)
                .build());

    return generateResponse(response);
  }
예제 #3
0
 private void setDefaultConfiguredEncoding(
     HttpServletRequest request, GrailsContentBufferingResponse contentBufferingResponse) {
   UrlPathHelper urlHelper = new UrlPathHelper();
   String requestURI = urlHelper.getOriginatingRequestUri(request);
   // static content?
   if (requestURI.endsWith(HTML_EXT)) {
     contentBufferingResponse.setContentType("text/html;charset=" + defaultEncoding);
   }
 }
예제 #4
0
 /**
  * 获得当的访问路径
  *
  * <p>HttpServletRequest.getRequestURL+"?"+HttpServletRequest.getQueryString
  *
  * @param request
  * @return
  */
 public static String getLocation(HttpServletRequest request) {
   UrlPathHelper helper = new UrlPathHelper();
   StringBuffer buff = request.getRequestURL();
   String uri = request.getRequestURI();
   String origUri = helper.getOriginatingRequestUri(request);
   buff.replace(buff.length() - uri.length(), buff.length(), origUri);
   String queryString = helper.getOriginatingQueryString(request);
   if (queryString != null) {
     buff.append("?").append(queryString);
   }
   return buff.toString();
 }
  /*
   * (non-Javadoc)
   *
   * @see
   * org.springframework.web.servlet.mvc.Controller#handleRequest(javax.servlet
   * .http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
   */
  public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)
      throws Exception {

    String requestedPath =
        (StringUtils.isEmpty(mapping))
            ? helper.getPathWithinApplication(request)
            : helper.getPathWithinServletMapping(request);

    if (StringUtils.isNotEmpty(controllerMapping)) {
      requestedPath = requestedPath.substring(controllerMapping.length());
    }

    requestHandler.processRequest(requestedPath, request, response);
    return null;
  }
 /**
  * @deprecated Use {@link
  *     org.codehaus.groovy.grails.web.servlet.mvc.GrailsWebRequest#getContextPath() instead}
  * @param request The Servlet Reqest
  * @return The Application URI
  */
 @Deprecated
 public String getApplicationUri(ServletRequest request) {
   String appUri = (String) request.getAttribute(GrailsApplicationAttributes.APP_URI_ATTRIBUTE);
   if (appUri == null) {
     appUri = urlHelper.getContextPath((HttpServletRequest) request);
   }
   return appUri;
 }
 /**
  * Returns the context path of the request.
  *
  * @return the path
  */
 @Override
 public String getContextPath() {
   final HttpServletRequest request = getCurrentRequest();
   String appUri = (String) request.getAttribute(GrailsApplicationAttributes.APP_URI_ATTRIBUTE);
   if (appUri == null) {
     appUri = urlHelper.getContextPath(request);
   }
   return appUri;
 }
예제 #8
0
파일: Pager.java 프로젝트: JohnDumas/riot
  private void prepareLinkPrefix(HttpServletRequest request) {
    StringBuffer url = new StringBuffer(urlPathHelper.getOriginatingRequestUri(request));

    url.append('?');
    if (copyParameters) {
      String query = urlPathHelper.getOriginatingQueryString(request);
      if (query != null) {
        int i = query.indexOf(pageParam);
        if (i != -1) {
          url.append(query.substring(0, i));
        } else {
          url.append(query).append('&');
        }
      }
    }
    url.append(pageParam);
    url.append('=');
    linkPrefix = url.toString();
  }
 @Override
 protected String getMediaTypeKey(NativeWebRequest webRequest) {
   HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
   if (request == null) {
     logger.warn("An HttpServletRequest is required to determine the media type key");
     return null;
   }
   String path = PATH_HELPER.getLookupPathForRequest(request);
   String filename = WebUtils.extractFullFilenameFromUrlPath(path);
   String extension = StringUtils.getFilenameExtension(filename);
   return (StringUtils.hasText(extension)) ? extension.toLowerCase(Locale.ENGLISH) : null;
 }
예제 #10
0
  protected void setUp() throws Exception {
    super.setUp();

    urlPathHelper = new UrlPathHelper();
    urlPathHelper.setUrlDecode(true);
    urlPathHelper.setDefaultEncoding("UTF-8");

    sitePropertiesService = new MockSitePropertiesService();
    sitePropertiesService.setProperty(
        siteKey_1, SitePropertyNames.URL_DEFAULT_CHARACTER_ENCODING, "UTF-8");

    urlPathHelperManager = new UrlPathHelperManager();
    urlPathHelperManager.setSitePropertiesService(sitePropertiesService);

    sitePathResolver = new SitePathResolver();
    sitePathResolver.setSitePathPrefix("/site");
    sitePathResolver.setUrlPathHelperManager(urlPathHelperManager);

    httpServletRequest = new MockHttpServletRequest();
    // httpServletRequest.setCharacterEncoding("ISO-8859-1");
  }
  /**
   * Lookup the CMS Content Page for this request.
   *
   * @param request The request
   * @return the CMS content page
   */
  protected ContentPageModel getContentPageForRequest(final HttpServletRequest request) {
    // Get the path for this request.
    // Note that the path begins with a '/'
    final String lookupPathForRequest = urlPathHelper.getLookupPathForRequest(request);

    try {
      // Lookup the CMS Content Page by label. Note that the label value must begin with a '/'.
      return getCmsPageService().getPageForLabel(lookupPathForRequest);
    } catch (final CMSItemNotFoundException ignore) {
      // Ignore exception
    }
    return null;
  }
  protected void addCategoryToModel(HttpServletRequest request, ModelMap model) {
    Category rootCategory = null;
    if (getRootCategoryId() != null) {
      rootCategory = catalogService.findCategoryById(getRootCategoryId());
    } else if (getRootCategoryName() != null) {
      rootCategory = catalogService.findCategoryByName(getRootCategoryName());
    }

    if (rootCategory == null) {
      throw new IllegalStateException(
          "Catalog Controller configured incorrectly - rootId category not found: "
              + rootCategoryId);
    }

    String url =
        pathHelper.getRequestUri(request).substring(pathHelper.getContextPath(request).length());
    String categoryId = request.getParameter("categoryId");
    if (categoryId != null) {
      Category category = catalogService.findCategoryById(new Long(categoryId));
      if (category != null) {
        url = category.getUrl();
      }
    }

    List<Long> categoryIdList =
        catalogService.getChildCategoryURLMapByCategoryId(rootCategory.getId()).get(url);
    List<Category> categoryList = null;
    if (categoryIdList != null) {
      categoryList = new ArrayList<Category>(categoryIdList.size());
      for (Long id : categoryIdList) {
        categoryList.add(catalogService.findCategoryById(id));
      }
    }

    addCategoryListToModel(categoryList, rootCategory, url, model);
    model.addAttribute("rootCategory", rootCategory);
  }
예제 #13
0
 public static boolean matchAll(
     HttpServletRequest request,
     UrlPathHelper urlPathHelper,
     PathMatcher pathMatcher,
     String[] patterns) {
   if (ArrayUtils.isNotEmpty(patterns)) {
     String lookupPath = urlPathHelper.getLookupPathForRequest(request);
     for (String pattern : patterns) {
       if (!pathMatcher.match(pattern, lookupPath)) {
         return false;
       }
     }
   }
   return true;
 }
  @Override
  protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
    String lookupPath = urlPathHelper.getLookupPathForRequest(request);
    if (logger.isDebugEnabled()) {
      logger.debug("Looking up handler method for path " + lookupPath);
    }

    HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);

    if (logger.isDebugEnabled()) {
      if (handlerMethod != null) {
        logger.debug("Returning handler method [" + handlerMethod + "]");
      } else {
        logger.debug("Did not find handler method for [" + lookupPath + "]");
      }
    }

    return (handlerMethod != null) ? handlerMethod.createWithResolvedBean() : null;
  }
  @Override
  protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
    String url = URL_PATH_HELPER.getPathWithinApplication(request);

    UrlMatch match = routeSet.getBestMatch(request, url);
    if (match != null) {
      routeSet.setCurrentMatch(request, match);
      Object controller = specialRoutes.get(match.getRoute());

      if (controller == null) {
        String controllerName = match.getParameters().get(controllerParameterName);

        if (controllerName != null) {
          return controllerName + controllerNameSuffix;
        }
      }

      return controller;
    }

    return null;
  }
  /**
   * Overrides the default behaviour to establish the handler from the GrailsApplication instance
   *
   * @param request The request
   * @param cache Whether to cache the Handler in the request
   * @return The HandlerExecutionChain
   * @throws Exception
   */
  protected HandlerExecutionChain getHandler(HttpServletRequest request, boolean cache)
      throws Exception {
    String uri = urlHelper.getPathWithinApplication(request);
    if (logger.isDebugEnabled()) {
      logger.debug("Looking up Grails controller for URI [" + uri + "]");
    }
    GrailsControllerClass controllerClass =
        (GrailsControllerClass)
            application.getArtefactForFeature(ControllerArtefactHandler.TYPE, uri);
    final String actionName =
        (String) request.getAttribute(GrailsApplicationAttributes.ACTION_NAME_ATTRIBUTE);

    if (controllerClass != null) {
      HandlerInterceptor[] interceptors;
      // if we're in a development environment we want to re-establish interceptors just in case
      // they
      // have changed at runtime

      if (GrailsUtil.isDevelopmentEnv()) {
        interceptors = establishInterceptors(getWebApplicationContext());
      } else {
        interceptors = this.interceptors;
      }
      if (controllerClass.isFlowAction(actionName)) {
        FlowHandler flowHandler =
            new AbstractFlowHandler() {
              public String getFlowId() {
                return actionName;
              }
            };
        return new HandlerExecutionChain(flowHandler, interceptors);
      } else {
        return new HandlerExecutionChain(mainController, interceptors);
      }
    }
    return null;
  }
 /**
  * Determines the list of {@link MediaType} for the given {@link HttpServletRequest}.
  *
  * <p>The default implementation invokes {@link #getMediaTypeFromFilename(String)} if {@linkplain
  * #setFavorPathExtension favorPathExtension} property is <code>true</code>. If the property is
  * <code>false</code>, or when a media type cannot be determined from the request path, this
  * method will inspect the {@code Accept} header of the request.
  *
  * <p>This method can be overridden to provide a different algorithm.
  *
  * @param request the current servlet request
  * @return the list of media types requested, if any
  */
 protected List<MediaType> getMediaTypes(HttpServletRequest request) {
   if (this.favorPathExtension) {
     String requestUri = urlPathHelper.getLookupPathForRequest(request);
     String filename = WebUtils.extractFullFilenameFromUrlPath(requestUri);
     MediaType mediaType = getMediaTypeFromFilename(filename);
     if (mediaType != null) {
       if (logger.isDebugEnabled()) {
         logger.debug(
             "Requested media type is '" + mediaType + "' (based on filename '" + filename + "')");
       }
       return Collections.singletonList(mediaType);
     }
   }
   if (this.favorParameter) {
     if (request.getParameter(this.parameterName) != null) {
       String parameterValue = request.getParameter(this.parameterName);
       MediaType mediaType = getMediaTypeFromParameter(parameterValue);
       if (mediaType != null) {
         if (logger.isDebugEnabled()) {
           logger.debug(
               "Requested media type is '"
                   + mediaType
                   + "' (based on parameter '"
                   + this.parameterName
                   + "'='"
                   + parameterValue
                   + "')");
         }
         return Collections.singletonList(mediaType);
       }
     }
   }
   if (!this.ignoreAcceptHeader) {
     String acceptHeader = request.getHeader(ACCEPT_HEADER);
     if (StringUtils.hasText(acceptHeader)) {
       try {
         List<MediaType> acceptableMediaTypes = MediaType.parseMediaTypes(acceptHeader);
         List<MediaType> producibleMediaTypes = getProducibleMediaTypes(request);
         Set<MediaType> compatibleMediaTypes = new LinkedHashSet<MediaType>();
         for (MediaType acceptable : acceptableMediaTypes) {
           for (MediaType producible : producibleMediaTypes) {
             if (acceptable.isCompatibleWith(producible)) {
               compatibleMediaTypes.add(getMostSpecificMediaType(acceptable, producible));
             }
           }
         }
         List<MediaType> mediaTypes = new ArrayList<MediaType>(compatibleMediaTypes);
         MediaType.sortByQualityValue(mediaTypes);
         if (logger.isDebugEnabled()) {
           logger.debug(
               "Requested media types are "
                   + mediaTypes
                   + " based on Accept header types "
                   + "and producible media types "
                   + producibleMediaTypes
                   + ")");
         }
         return mediaTypes;
       } catch (IllegalArgumentException ex) {
         if (logger.isDebugEnabled()) {
           logger.debug(
               "Could not parse accept header [" + acceptHeader + "]: " + ex.getMessage());
         }
         return null;
       }
     }
   }
   if (this.defaultContentType != null) {
     if (logger.isDebugEnabled()) {
       logger.debug(
           "Requested media types is "
               + this.defaultContentType
               + " (based on defaultContentType property)");
     }
     return Collections.singletonList(this.defaultContentType);
   } else {
     return Collections.emptyList();
   }
 }
 static {
   urlPathHelper.setUrlDecode(false);
 }
 static {
   PATH_HELPER.setUrlDecode(false);
 }