Java SimpleUrlAuthenticationFailureHandler类代码示例

import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler; //导入依赖的package包/类
@SuppressWarnings("PMD.SignatureDeclareThrowsException")
private RequestHeaderAuthenticationFilter requestHeaderAuthenticationFilter() throws Exception {
    RequestHeaderAuthenticationFilter f = new RequestHeaderAuthenticationFilter();
    f.setPrincipalRequestHeader("X-Forwarded-User");
    f.setCredentialsRequestHeader("X-Forwarded-Access-Token");
    f.setAuthenticationManager(authenticationManager());
    f.setAuthenticationDetailsSource(
        (AuthenticationDetailsSource<HttpServletRequest, PreAuthenticatedGrantedAuthoritiesWebAuthenticationDetails>)
            (request) ->new PreAuthenticatedGrantedAuthoritiesWebAuthenticationDetails(
                request,
                AuthorityUtils.createAuthorityList("ROLE_AUTHENTICATED")
            )
    );
    f.setAuthenticationFailureHandler(new SimpleUrlAuthenticationFailureHandler());
    f.setExceptionIfHeaderMissing(false);
    return f;
}
 

import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler; //导入依赖的package包/类
/**
 *
 * @return
 * @throws Exception
 */
@Bean
public DomainUsernamePasswordAuthenticationFilter domainUsernamePasswordAuthenticationFilter()
        throws Exception {
    DomainUsernamePasswordAuthenticationFilter dupaf = new DomainUsernamePasswordAuthenticationFilter(
                                                            super.authenticationManagerBean());
    dupaf.setFilterProcessesUrl("/login");
    dupaf.setUsernameParameter("username");
    dupaf.setPasswordParameter("password");

    dupaf.setAuthenticationSuccessHandler(
            new SavedRequestAwareAuthenticationSuccessHandler(){{
                setDefaultTargetUrl("/default");
            }}
    );

    dupaf.setAuthenticationFailureHandler(
            new SimpleUrlAuthenticationFailureHandler(){{
                setDefaultFailureUrl("/login/form?error");
            }}
    );

    dupaf.afterPropertiesSet();

    return dupaf;
}
 

import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler; //导入依赖的package包/类
public GoogleAuthenticationProcessingFilter(GooglePublicKeysManager googlePublicKeysManager,
		DataService dataService, UserDetailsService userDetailsService,
		AuthenticationSettings authenticationSettings, UserFactory userFactory,
		GroupMemberFactory groupMemberFactory)
{
	super(new AntPathRequestMatcher(GOOGLE_AUTHENTICATION_URL, POST.toString()));
	this.userFactory = requireNonNull(userFactory);
	this.groupMemberFactory = requireNonNull(groupMemberFactory);

	setAuthenticationFailureHandler(new SimpleUrlAuthenticationFailureHandler("/login?error"));

	this.googlePublicKeysManager = requireNonNull(googlePublicKeysManager);
	this.dataService = requireNonNull(dataService);
	this.userDetailsService = requireNonNull(userDetailsService);
	this.authenticationSettings = requireNonNull(authenticationSettings);
}
 

import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler; //导入依赖的package包/类
public void init() {
	System.err.println(" ---------------AuthenticationFilter init--------------- ");
	this.setUsernameParameter(USERNAME);
	this.setPasswordParameter(PASSWORD);
	// 验证成功，跳转的页面
	SavedRequestAwareAuthenticationSuccessHandler successHandler = new SavedRequestAwareAuthenticationSuccessHandler();
	successHandler.setDefaultTargetUrl(successUrl);
	this.setAuthenticationSuccessHandler(successHandler);

	// 验证失败，跳转的页面
	SimpleUrlAuthenticationFailureHandler failureHandler = new SimpleUrlAuthenticationFailureHandler();
	failureHandler.setDefaultFailureUrl(errorUrl);
	this.setAuthenticationFailureHandler(failureHandler);
}
 

import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler; //导入依赖的package包/类
/**
 * Create a simple authentication filter for REST logins that reads user-credentials from a json-parameter and returns
 * status 200 instead of redirect after login.
 *
 * @return the {@link JsonUsernamePasswordAuthenticationFilter}.
 * @throws Exception if something goes wrong.
 */
protected JsonUsernamePasswordAuthenticationFilter getSimpleRestAuthenticationFilter() throws Exception {

  JsonUsernamePasswordAuthenticationFilter jsonFilter =
      new JsonUsernamePasswordAuthenticationFilter(new AntPathRequestMatcher("/services/rest/login"));
  jsonFilter.setPasswordParameter("j_password");
  jsonFilter.setUsernameParameter("j_username");
  jsonFilter.setAuthenticationManager(authenticationManager());
  // set failurehandler that uses no redirect in case of login failure; just HTTP-status: 401
  jsonFilter.setAuthenticationManager(authenticationManagerBean());
  jsonFilter.setAuthenticationFailureHandler(new SimpleUrlAuthenticationFailureHandler());
  // set successhandler that uses no redirect in case of login success; just HTTP-status: 200
  jsonFilter.setAuthenticationSuccessHandler(new AuthenticationSuccessHandlerSendingOkHttpStatusCode());
  return jsonFilter;
}
 

import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler; //导入依赖的package包/类
@Override
protected void configure(HttpSecurity http) throws Exception {

    http
            .csrf()
            .disable();
    http
            .addFilterBefore(metadataGeneratorFilter(), ChannelProcessingFilter.class)
            .addFilterAfter(samlFilter(), BasicAuthenticationFilter.class);
    http
            .authorizeRequests()
            .antMatchers("/").permitAll()
            .antMatchers("/error").permitAll()
            .antMatchers("/saml/**").permitAll()
            .antMatchers("/css/**").permitAll()
            .anyRequest().authenticated();

    http
            .exceptionHandling().accessDeniedHandler(new AccessDeniedHandlerImpl())
            .authenticationEntryPoint(getAuthEntryPoint())
            .and()
            .formLogin()
            .loginProcessingUrl("/authenticate")
            .usernameParameter("username")
            .passwordParameter("password")
            .successHandler(new FormAuthSuccessHandler())
            .failureHandler(new SimpleUrlAuthenticationFailureHandler())
            .and()
            .logout()
            .logoutUrl("/logout")
            .logoutSuccessUrl("/")
            .permitAll();
}
 

import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler; //导入依赖的package包/类
@Bean
public SimpleUrlAuthenticationFailureHandler authenticationFailureHandler() {
    SimpleUrlAuthenticationFailureHandler failureHandler =
            new SimpleUrlAuthenticationFailureHandler();
    failureHandler.setUseForward(true);
    failureHandler.setDefaultFailureUrl("/login");
    return failureHandler;
}
 

import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler; //导入依赖的package包/类
@Bean
public SimpleUrlAuthenticationFailureHandler failureRedirectHandler() {
    SimpleUrlAuthenticationFailureHandler failureHandler = new SimpleUrlAuthenticationFailureHandler();

    // The precondition on `setDefaultFailureUrl(..)` will cause an exception if the value is null.
    // So, only set this value if it is not null
    if (!samlConfigBean().getFailedLoginDefaultUrl().isEmpty()) {
        failureHandler.setDefaultFailureUrl(samlConfigBean().getFailedLoginDefaultUrl());
    }

    return failureHandler;
}
 

import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler; //导入依赖的package包/类
/**
 * Failed login handler, returning a 401 code instead of a login page
 *
 * @return
 */
@Bean
public AuthenticationFailureHandler failureHandler() {
	return new SimpleUrlAuthenticationFailureHandler() {
		@Override
		public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
			LOG.warn("LOGIN >>> authentication failure");
			response.sendError(HttpServletResponse.SC_UNAUTHORIZED, exception.getMessage());
		}
	};
}
 

import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler; //导入依赖的package包/类
@Bean
public SimpleUrlAuthenticationFailureHandler authenticationFailureHandler() {
	SimpleUrlAuthenticationFailureHandler failureHandler =
        new SimpleUrlAuthenticationFailureHandler();
	failureHandler.setUseForward(true);
	failureHandler.setDefaultFailureUrl("/error");
	return failureHandler;
}
 

import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler; //导入依赖的package包/类
@Bean
public SimpleUrlAuthenticationFailureHandler authenticationFailureHandler() {
    SimpleUrlAuthenticationFailureHandler handler = new SimpleUrlAuthenticationFailureHandler();
    handler.setUseForward(false);
    //handler.setDefaultFailureUrl("/error");
    return handler;
}
 

import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler; //导入依赖的package包/类
@Override
protected void configure(HttpSecurity http) throws Exception {
	http
	.csrf().disable()
	.exceptionHandling()
	.authenticationEntryPoint(entryPoint)
	.and().authorizeRequests()
	.antMatchers("/api/1/**").authenticated()
	.and().formLogin()
	.successHandler(successHandler)
	.failureHandler(new SimpleUrlAuthenticationFailureHandler())
	.and().logout();
}
 

import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler; //导入依赖的package包/类
@Before
public void setUp() {
    SuperflySelectRoleAuthenticationProcessingFilter procFilter = new SuperflySelectRoleAuthenticationProcessingFilter();
    procFilter.setAuthenticationManager(authenticationManager);
    procFilter.setAuthenticationFailureHandler(new SimpleUrlAuthenticationFailureHandler("/login-failed"));
    procFilter.afterPropertiesSet();
    filter = procFilter;
}
 

import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler; //导入依赖的package包/类
@Before
public void setUp() {
    SuperflyUsernamePasswordAuthenticationProcessingFilter procFilter = new SuperflyUsernamePasswordAuthenticationProcessingFilter();
    procFilter.setAuthenticationManager(authenticationManager);
    procFilter.setAuthenticationFailureHandler(new SimpleUrlAuthenticationFailureHandler("/login-failed"));
    procFilter.setSubsystemIdentifier("my-subsystem");
    procFilter.afterPropertiesSet();
    filter = procFilter;
}
 

import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler; //导入依赖的package包/类
@Before
public void setUp() {
    SuperflySSOAuthenticationProcessingFilter procFilter = new SuperflySSOAuthenticationProcessingFilter();
    procFilter.setAuthenticationManager(authenticationManager);
    procFilter.setAuthenticationFailureHandler(new SimpleUrlAuthenticationFailureHandler("/login-failed"));
    procFilter.afterPropertiesSet();
    filter = procFilter;
}