/**     * Gets a property from the configuration.     *     * @param key property to retrieve     * @return value as object. Will return user value if exists,     *        if not then default value if exists, otherwise null     */    public Object getProperty(String key) {        // first, try to get from the 'user value' store        Object obj = this.get(key);
        if (obj == null) {            // if there isn't a value there, get it from the            // defaults if we have them            if (defaults != null) {                obj = defaults.get(key);            }        }
        return obj;    }
// org.apache.commons.collections.ExtendedProperties

public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {    RelaxedPropertyResolver resolver = new RelaxedPropertyResolver(        event.getEnvironment(), "spring.");    if (resolver.containsProperty("mandatoryFileEncoding")) {      String encoding = System.getProperty("file.encoding");      String desired = resolver.getProperty("mandatoryFileEncoding");      if (encoding != null && !desired.equalsIgnoreCase(encoding)) {        logger.error("System property 'file.encoding' is currently '" + encoding            + "'. It should be '" + desired            + "' (as defined in 'spring.mandatoryFileEncoding').");        logger.error("Environment variable LANG is '" + System.getenv("LANG")            + "'. You could use a locale setting that matches encoding='"            + desired + "'.");        logger.error("Environment variable LC_ALL is '" + System.getenv("LC_ALL")            + "'. You could use a locale setting that matches encoding='"            + desired + "'.");        throw new IllegalStateException(            "The Java Virtual Machine has not been configured to use the "                + "desired default character encoding (" + desired                + ").");      }    }  }
// org.springframework.boot.context.FileEncodingApplicationListener

  public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)      throws IOException, ServletException {    HttpServletRequest request = (HttpServletRequest) req;    HttpServletResponse response = (HttpServletResponse) res;
    try {      chain.doFilter(request, response);
      logger.debug("Chain processed normally");    }    catch (IOException ex) {      throw ex;    }    catch (Exception ex) {      // Try to extract a SpringSecurityException from the stacktrace      Throwable[] causeChain = throwableAnalyzer.determineCauseChain(ex);      RuntimeException ase = (AuthenticationException) throwableAnalyzer          .getFirstThrowableOfType(AuthenticationException.class, causeChain);
      if (ase == null) {        ase = (AccessDeniedException) throwableAnalyzer.getFirstThrowableOfType(            AccessDeniedException.class, causeChain);      }
      if (ase != null) {        handleSpringSecurityException(request, response, chain, ase);      }      else {        // Rethrow ServletExceptions and RuntimeExceptions as-is        if (ex instanceof ServletException) {          throw (ServletException) ex;        }        else if (ex instanceof RuntimeException) {          throw (RuntimeException) ex;        }
        // Wrap other Exceptions. This shouldn't actually happen        // as we've already covered all the possibilities for doFilter        throw new RuntimeException(ex);      }    }  }
  private void handleSpringSecurityException(HttpServletRequest request,      HttpServletResponse response, FilterChain chain, RuntimeException exception)      throws IOException, ServletException {    if (exception instanceof AuthenticationException) {      logger.debug(          "Authentication exception occurred; redirecting to authentication entry point",          exception);
      sendStartAuthentication(request, response, chain,          (AuthenticationException) exception);    }    else if (exception instanceof AccessDeniedException) {      Authentication authentication = SecurityContextHolder.getContext().getAuthentication();      if (authenticationTrustResolver.isAnonymous(authentication) || authenticationTrustResolver.isRememberMe(authentication)) {        logger.debug(            "Access is denied (user is " + (authenticationTrustResolver.isAnonymous(authentication) ? "anonymous" : "not fully authenticated") + "); redirecting to authentication entry point",            exception);
        sendStartAuthentication(            request,            response,            chain,            new InsufficientAuthenticationException(                "Full authentication is required to access this resource"));      }      else {        logger.debug(            "Access is denied (user is not anonymous); delegating to AccessDeniedHandler",            exception);
        accessDeniedHandler.handle(request, response,            (AccessDeniedException) exception);      }    }  }
  protected void sendStartAuthentication(HttpServletRequest request,      HttpServletResponse response, FilterChain chain,      AuthenticationException reason) throws ServletException, IOException {    // SEC-112: Clear the SecurityContextHolder's Authentication, as the    // existing Authentication is no longer considered valid    SecurityContextHolder.getContext().setAuthentication(null);    requestCache.saveRequest(request, response);    logger.debug("Calling Authentication entry point.");    authenticationEntryPoint.commence(request, response, reason);  }
// org.springframework.security.web.access.ExceptionTranslationFilter