Java SavedRequestAwareAuthenticationSuccessHandler类代码示例

import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler; //导入依赖的package包/类
@Override
protected void configure(HttpSecurity http) throws Exception {
	SavedRequestAwareAuthenticationSuccessHandler successHandler = new SavedRequestAwareAuthenticationSuccessHandler();
	successHandler.setTargetUrlParameter("continue");

	// @formatter:off
	http
		.requestMatchers()
			.antMatchers(LoginFormController.PATH_MAPPING, LOGOUT_URL, AuthorizationEndpoint.PATH_MAPPING,
					EndSessionEndpoint.PATH_MAPPING)
			.and()
		.authorizeRequests()
			.anyRequest().permitAll()
			.and()
		.formLogin()
			.loginPage(LoginFormController.PATH_MAPPING)
			.successHandler(successHandler)
			.and()
		.logout()
			.logoutSuccessHandler(new ForwardLogoutSuccessHandler(EndSessionEndpoint.PATH_MAPPING))
			.and()
		.sessionManagement()
			.sessionFixation().migrateSession();
	// @formatter:on
}
 

import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler; //导入依赖的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.SavedRequestAwareAuthenticationSuccessHandler; //导入依赖的package包/类
private Filter ssoFilter(final String path) {
    final OAuth2ClientAuthenticationProcessingFilter oAuth2ClientAuthenticationFilter = new OAuth2ClientAuthenticationProcessingFilter(
            path);
    final SavedRequestAwareAuthenticationSuccessHandler successHandler = new SavedRequestAwareAuthenticationSuccessHandler();
    oAuth2ClientAuthenticationFilter.setAuthenticationSuccessHandler(successHandler);
    successHandler.setAlwaysUseDefaultTargetUrl(true);
    successHandler.setDefaultTargetUrl("/UI");
    final OAuth2RestTemplate oAuth2RestTemplate = new OAuth2RestTemplate(uaaClientResources.getClient(),
            oauth2ClientContext);
    oAuth2ClientAuthenticationFilter.setRestTemplate(oAuth2RestTemplate);
    final UserPrincipalInfoTokenServices tokenServices = new UserPrincipalInfoTokenServices(
            uaaClientResources.getResource().getUserInfoUri(), uaaClientResources.getClient().getClientId(),
            oauth2ClientContext);
    tokenServices.setRestTemplate(oAuth2RestTemplate);
    tokenServices.setAuthoritiesExtractor(tokenServices);
    oAuth2ClientAuthenticationFilter.setTokenServices(tokenServices);
    return oAuth2ClientAuthenticationFilter;
}
 

import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler; //导入依赖的package包/类
@Override
protected void configure(HttpSecurity http) throws Exception {
    // @formatter:off
    SavedRequestAwareAuthenticationSuccessHandler successHandler = new SavedRequestAwareAuthenticationSuccessHandler();
    successHandler.setTargetUrlParameter("redirectTo");

    http.authorizeRequests()
        .antMatchers(adminContextPath + "/assets/**").permitAll()
        .antMatchers(adminContextPath + "/login").permitAll()
        .anyRequest().authenticated()
        .and()
    .formLogin().loginPage(adminContextPath + "/login").successHandler(successHandler).and()
    .logout().logoutUrl(adminContextPath + "/logout").and()
    .httpBasic().and()
    .csrf().disable();
    // @formatter:on
}
 

import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler; //导入依赖的package包/类
private Filter ssoFilter() {
    OAuth2ClientAuthenticationProcessingFilter facebookFilter = new OAuth2ClientAuthenticationProcessingFilter("/login");
    OAuth2RestTemplate facebookTemplate = new OAuth2RestTemplate(facebook(), oauth2ClientContext);
    facebookFilter.setRestTemplate(facebookTemplate);
    UserInfoTokenServices tokenServices = new UserInfoTokenServices(facebookResource().getUserInfoUri(), facebook().getClientId());
    tokenServices.setRestTemplate(facebookTemplate);
    facebookFilter.setTokenServices(tokenServices);
    SavedRequestAwareAuthenticationSuccessHandler authenticationSuccessHandler = new SavedRequestAwareAuthenticationSuccessHandler();
    authenticationSuccessHandler.setUseReferer(true);
    authenticationSuccessHandler.setTargetUrlParameter("continue");
    facebookFilter.setAuthenticationSuccessHandler(authenticationSuccessHandler);
    return facebookFilter;
}
 

import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler; //导入依赖的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.SavedRequestAwareAuthenticationSuccessHandler; //导入依赖的package包/类
/**
 * Success login hander, adding cookie auth
 *
 * @return
 */
@Bean
public AuthenticationSuccessHandler successHandler() {
	return new SavedRequestAwareAuthenticationSuccessHandler() {
		@Override
		public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
			LOG.info("LOGIN >>> " + authentication.getPrincipal());
			UserAuth userAuth = (UserAuth) authentication.getPrincipal();
			apiAuth.put(userAuth, response);
			PrintWriter writer = response.getWriter();
			mapper.writeValue(writer, userAuth);
			writer.flush();
		}
	};
}
 

import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler; //导入依赖的package包/类
@Override
protected void configure(HttpSecurity http) throws Exception {
    LoginDecisionFilter loginDecisionFilter = new LoginDecisionFilter();
    loginDecisionFilter.setAuthenticationManager(authenticationManagerBean());
    SavedRequestAwareAuthenticationSuccessHandler successHandler =
            new SavedRequestAwareAuthenticationSuccessHandler();
    successHandler.setAlwaysUseDefaultTargetUrl(false);
    loginDecisionFilter.setAuthenticationSuccessHandler(successHandler);
    loginDecisionFilter.setAuthenticationFailureHandler(
            new OsiamCachingAuthenticationFailureHandler("/login/error")
    );

    // @formatter:off
    http.requestMatchers()
            .antMatchers("/login/**", "/error", "/oauth/**")
            .and()
        .authorizeRequests()
            .antMatchers("/login", "/login/error", "/error").permitAll()
            .anyRequest().authenticated()
            .and()
        .csrf()
            // TODO: This is a bad idea! We need CSRF at least for the `/oauth/authorize` endpoint
            // see also: https://github.com/spring-projects/spring-security-oauth/blob/2.0.8.RELEASE/samples/oauth2/sparklr/src/main/java/org/springframework/security/oauth/examples/sparklr/config/SecurityConfiguration.java#L48
            .disable()
        .exceptionHandling()
            .accessDeniedPage("/login/error")
            .and()
        .sessionManagement()
            .sessionCreationPolicy(SessionCreationPolicy.ALWAYS)
            .and()
        .formLogin()
            .loginProcessingUrl("/login/check")
            .failureUrl("/login/error")
            .loginPage("/login")
            .and()
        .addFilterBefore(loginDecisionFilter, UsernamePasswordAuthenticationFilter.class);
    // @formatter:on
}
 

import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler; //导入依赖的package包/类
@Bean
public SavedRequestAwareAuthenticationSuccessHandler
savedRequestAwareAuthenticationSuccessHandler() {
    SavedRequestAwareAuthenticationSuccessHandler auth
            = new SavedRequestAwareAuthenticationSuccessHandler();
    auth.setTargetUrlParameter("targetUrl");
    return auth;
}
 

import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler; //导入依赖的package包/类
@Override
public void afterPropertiesSet() {
	super.afterPropertiesSet();

	((SavedRequestAwareAuthenticationSuccessHandler) getSuccessHandler()).setAlwaysUseDefaultTargetUrl(false);

	setAuthenticationFailureHandler(new AuthenticationFailureHandler() {
		public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
			requestCache.saveRequest(request, response);
			authenticationEntryPoint.commence(request, response, exception);
		}
	});
}
 

import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler; //导入依赖的package包/类
@PostConstruct
public void init(){
	if (defaultAuthenticationSuccessUrl != null && !defaultAuthenticationSuccessUrl.isEmpty()){
		SavedRequestAwareAuthenticationSuccessHandler savedRequestAwareAuthenticationSuccessHandler = new SavedRequestAwareAuthenticationSuccessHandler();
		savedRequestAwareAuthenticationSuccessHandler.setDefaultTargetUrl(defaultAuthenticationSuccessUrl);		
		setAuthenticationSuccessHandler(savedRequestAwareAuthenticationSuccessHandler);
	}
}
 

import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler; //导入依赖的package包/类
protected Filter authenticationFilter() {

            AbstractAuthenticationProcessingFilter filter =
                    new SecurityContextAuthenticationFilter(SIGNIN_SUCCESS_PATH);
            SavedRequestAwareAuthenticationSuccessHandler successHandler =
                    new SavedRequestAwareAuthenticationSuccessHandler();
            successHandler.setDefaultTargetUrl("/admin");
            filter.setAuthenticationSuccessHandler(successHandler);
            return filter;
        }
 

import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler; //导入依赖的package包/类
public AuthenticationSuccessHandler authenticationSuccessHandler() {
    SavedRequestAwareAuthenticationSuccessHandler successHandler = new SavedRequestAwareAuthenticationSuccessHandler();
    successHandler.setRedirectStrategy(new XForwardedAwareRedirectStrategy());
    return successHandler;
}
 

import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler; //导入依赖的package包/类
@Override
public void configure(ServiceProviderBuilder builder) throws Exception {
    if (successHandler == null) {
        SavedRequestAwareAuthenticationSuccessHandler successRedirectHandler = createDefaultSuccessHandler();
        successRedirectHandler.setDefaultTargetUrl(Optional.ofNullable(defaultSuccessURL).orElseGet(config::getDefaultSuccessUrl));
        successHandler = postProcess(successRedirectHandler);
    }

    defaultFailureURL = Optional.ofNullable(defaultFailureURL).orElseGet(config::getDefaultFailureUrl);
    if (failureHandler == null) {
        SimpleUrlAuthenticationFailureHandler authenticationFailureHandler = createDefaultFailureHandler();
        authenticationFailureHandler.setDefaultFailureUrl(defaultFailureURL);
        failureHandler = postProcess(authenticationFailureHandler);
    }
    endpoints.setDefaultFailureURL(defaultFailureURL);


    SAMLProcessingFilter ssoFilter = createDefaultSamlProcessingFilter();
    ssoFilter.setAuthenticationManager(authenticationManager);
    ssoFilter.setAuthenticationSuccessHandler(successHandler);
    ssoFilter.setAuthenticationFailureHandler(failureHandler);
    ssoProcessingURL = Optional.ofNullable(ssoProcessingURL).orElseGet(config::getSsoProcessingUrl);
    endpoints.setSsoProcessingURL(ssoProcessingURL);
    ssoFilter.setFilterProcessesUrl(ssoProcessingURL);

    SAMLWebSSOHoKProcessingFilter ssoHoKFilter = null;
    if (Optional.ofNullable(enableSsoHoK).orElseGet(config::isEnableSsoHok)) {
        ssoHoKFilter = createDefaultSamlHoKProcessingFilter();
        ssoHoKFilter.setAuthenticationSuccessHandler(successHandler);
        ssoHoKFilter.setAuthenticationManager(authenticationManager);
        ssoHoKFilter.setAuthenticationFailureHandler(failureHandler);
        ssoHoKProcessingURL = Optional.ofNullable(ssoHoKProcessingURL).orElseGet(config::getSsoHokProcessingUrl);
        endpoints.setSsoHoKProcessingURL(ssoHoKProcessingURL);
        ssoHoKFilter.setFilterProcessesUrl(ssoHoKProcessingURL);
    }

    SAMLDiscovery discoveryFilter = createDefaultSamlDiscoveryFilter();
    discoveryProcessingURL = Optional.ofNullable(discoveryProcessingURL).orElseGet(config::getDiscoveryProcessingUrl);
    endpoints.setDiscoveryProcessingURL(discoveryProcessingURL);
    discoveryFilter.setFilterProcessesUrl(discoveryProcessingURL);
    idpSelectionPageURL = Optional.ofNullable(idpSelectionPageURL).orElseGet(config::getIdpSelectionPageUrl);
    endpoints.setIdpSelectionPageURL(idpSelectionPageURL);
    discoveryFilter.setIdpSelectionPath(idpSelectionPageURL);

    SAMLEntryPoint entryPoint = Optional.ofNullable(samlEntryPointBean).orElseGet(this::createDefaultSamlEntryPoint);
    entryPoint.setDefaultProfileOptions(Optional.ofNullable(profileOptions).orElseGet(this::getProfileOptions));
    ssoLoginURL = Optional.ofNullable(ssoLoginURL).orElseGet(config::getSsoLoginUrl);
    endpoints.setSsoLoginURL(ssoLoginURL);
    entryPoint.setFilterProcessesUrl(ssoLoginURL);

    builder.setSharedObject(SAMLProcessingFilter.class, ssoFilter);
    builder.setSharedObject(SAMLWebSSOHoKProcessingFilter.class, ssoHoKFilter);
    builder.setSharedObject(SAMLDiscovery.class, discoveryFilter);
    builder.setSharedObject(SAMLEntryPoint.class, entryPoint);
}
 

import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler; //导入依赖的package包/类
@VisibleForTesting
protected SavedRequestAwareAuthenticationSuccessHandler createDefaultSuccessHandler() {
    return new SavedRequestAwareAuthenticationSuccessHandler();
}