title: How to disable spring security for particular url
body: <p>I am using stateless spring security,but in case of signup i want to disable spring security.I disabled  using </p>
  
  <pre><code>antMatchers("/api/v1/signup").permitAll().
  </code></pre>
  
  <p>but it is not working,i am getting error below: </p>
  
  <pre><code> message=An Authentication object was not found in the SecurityContext, type=org.springframework.security.authentication.AuthenticationCredentialsNotFoundException
  </code></pre>
  
  <p>I think this means spring security filters are working</p>
  
  <p>My url's order always will be "/api/v1"</p>
  
  <p>My spring config is</p>
  
  <pre><code>@Override
      protected void configure(HttpSecurity http) throws Exception {
  
           http.
           csrf().disable().
           sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).
           and().
           authorizeRequests().
           antMatchers("/api/v1/signup").permitAll().
           anyRequest().authenticated().
           and().
           anonymous().disable();
          http.addFilterBefore(new AuthenticationFilter(authenticationManager()), BasicAuthenticationFilter.class);
      }
  </code></pre>
  
  <p>My authentication filter is</p>
  
  <pre><code>@Override
      public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
          HttpServletRequest httpRequest = asHttp(request);
          HttpServletResponse httpResponse = asHttp(response);
  
          String username = httpRequest.getHeader("X-Auth-Username");
          String password = httpRequest.getHeader("X-Auth-Password");
          String token = httpRequest.getHeader("X-Auth-Token");
  
          String resourcePath = new UrlPathHelper().getPathWithinApplication(httpRequest);
  
          try {
  
              if (postToAuthenticate(httpRequest, resourcePath)) {            
                  processUsernamePasswordAuthentication(httpResponse, username, password);
                  return;
              }
  
              if(token != null){
                  processTokenAuthentication(token);
              }
              chain.doFilter(request, response);
          } catch (InternalAuthenticationServiceException internalAuthenticationServiceException) {
              SecurityContextHolder.clearContext();
              logger.error("Internal authentication service exception", internalAuthenticationServiceException);
              httpResponse.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
          } catch (AuthenticationException authenticationException) {
              SecurityContextHolder.clearContext();
              httpResponse.sendError(HttpServletResponse.SC_UNAUTHORIZED, authenticationException.getMessage());
          } finally {
          }
      }
  
       private HttpServletRequest asHttp(ServletRequest request) {
              return (HttpServletRequest) request;
          }
  
          private HttpServletResponse asHttp(ServletResponse response) {
              return (HttpServletResponse) response;
          }
  
          private boolean postToAuthenticate(HttpServletRequest httpRequest, String resourcePath) {
              return Constant.AUTHENTICATE_URL.equalsIgnoreCase(resourcePath) &amp;&amp; httpRequest.getMethod().equals("POST");
          }
  
          private void processUsernamePasswordAuthentication(HttpServletResponse httpResponse,String username, String password) throws IOException {
              Authentication resultOfAuthentication = tryToAuthenticateWithUsernameAndPassword(username, password);
              SecurityContextHolder.getContext().setAuthentication(resultOfAuthentication);
              httpResponse.setStatus(HttpServletResponse.SC_OK);
              httpResponse.addHeader("Content-Type", "application/json");
              httpResponse.addHeader("X-Auth-Token", resultOfAuthentication.getDetails().toString());
          }
  
          private Authentication tryToAuthenticateWithUsernameAndPassword(String username,String password) {
              UsernamePasswordAuthenticationToken requestAuthentication = new UsernamePasswordAuthenticationToken(username, password);
              return tryToAuthenticate(requestAuthentication);
          }
  
          private void processTokenAuthentication(String token) {
              Authentication resultOfAuthentication = tryToAuthenticateWithToken(token);
              SecurityContextHolder.getContext().setAuthentication(resultOfAuthentication);
          }
  
          private Authentication tryToAuthenticateWithToken(String token) {
              PreAuthenticatedAuthenticationToken requestAuthentication = new PreAuthenticatedAuthenticationToken(token, null);
              return tryToAuthenticate(requestAuthentication);
          }
  
          private Authentication tryToAuthenticate(Authentication requestAuthentication) {
              Authentication responseAuthentication = authenticationManager.authenticate(requestAuthentication);
              if (responseAuthentication == null || !responseAuthentication.isAuthenticated()) {
                  throw new InternalAuthenticationServiceException("Unable to authenticate Domain User for provided credentials");
              }
              logger.debug("User successfully authenticated");
              return responseAuthentication;
          }
  </code></pre>
  
  <p>My controller is </p>
  
  <pre><code>@RestController
  public class UserController {
  
      @Autowired
      UserService userService;
  
      /**
       * to pass user info to service
       */
      @RequestMapping(value = "api/v1/signup",method = RequestMethod.POST)
      public String saveUser(@RequestBody User user) {
          userService.saveUser(user);
          return "User registerted successfully";
      }
  }
  </code></pre>
  
  <p>I am totally new to spring,please help me how to do it ?</p>