org.springframework.security.web.authentication.AuthenticationSuccessHandler Java Examples

@SuppressWarnings("ProhibitedExceptionDeclared")
@Override
public void customize(final HttpSecurity http, final AuthenticationManager authenticationManager) throws Exception {
    final AuthenticationSuccessHandler successHandler = new IdolLoginSuccessHandler(
            FindController.CONFIG_PATH,
            FindController.APP_PATH,
            FindRole.CONFIG.toString(),
            authenticationInformationRetriever
    );

    http.formLogin()
            .loginPage(FindController.DEFAULT_LOGIN_PAGE)
            .loginProcessingUrl("/authenticate")
            .successHandler(successHandler)
            .failureUrl(FindController.DEFAULT_LOGIN_PAGE + "?error=auth");
}
 

/**
 * 登陆成功后的处理
 *
 * @return
 */
@Bean
public AuthenticationSuccessHandler successHandler(){
    return new AuthenticationSuccessHandler(){
        @Override
        public void onAuthenticationSuccess( HttpServletRequest _request, HttpServletResponse _response, Authentication _auth ) throws IOException, ServletException{
            log.debug( "--登陆成功" );

            _request.getSession().setAttribute( ISupportEL.Session_User_EL, _auth.getPrincipal() );
            sessionRegistry().registerNewSession( _request.getSession().getId(), _auth.getPrincipal() );

            RequestCache requestCache = new HttpSessionRequestCache();

            SavedRequest savedRequest = requestCache.getRequest( _request, _response );
            String       url          = null;
            if( savedRequest != null ) url = savedRequest.getRedirectUrl();
            log.debug( "--登陆后转向：" + url );

            if( url == null ) redirectStrategy().sendRedirect( _request, _response, "/" );
            else _response.sendRedirect( url );
        }
    };
}
 

/**
 * 登陆成功，返回Token 装配此bean不支持授权码模式
 * 
 * @return
 */
@Bean
public AuthenticationSuccessHandler loginSuccessHandler() {
	return new SavedRequestAwareAuthenticationSuccessHandler() {

		private RequestCache requestCache = new HttpSessionRequestCache();

		@Override
		public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
				Authentication authentication) throws IOException, ServletException {

			super.onAuthenticationSuccess(request, response, authentication);
			return;

		}
	};
}
 

public SmsSecurityConfig(BootSmsUserDetailService userDetailsService,
                         StringRedisTemplate redisTemplate,
                         @Autowired(required = false)
                                 BootLoginFailureHandler failureHandler,
                         @Autowired(required = false)
                                 AuthenticationSuccessHandler successHandler,
                         BootSecurityProperties properties) {


    this.authenticationFilter = new SmsCodeAuthenticationFilter(properties.getSmsLogin().getLoginProcessUrl());
    this.authenticationFilter.setAuthenticationFailureHandler(failureHandler);
    if (successHandler!=null) {
        this.authenticationFilter.setAuthenticationSuccessHandler(successHandler);
    }

    this.authenticationProvider = new SmsAuthenticationProvider();
    this.authenticationProvider.setUserDetailsService(userDetailsService);

    this.codeCheckFilter = new SmsCodeCheckFilter(properties);
    this.codeCheckFilter.setFailureHandler(failureHandler);
    this.codeCheckFilter.setTemplate(redisTemplate);
    this.codeCheckFilter.setSuccessHandler(successHandler);


}
 

@Bean
public AuthenticationSuccessHandler authenticationSuccessHandler() {
    return new AuthenticationSuccessHandler() {
        /**
         * 处理登入成功的请求
         *
         * @param httpServletRequest
         * @param httpServletResponse
         * @param authentication
         * @throws IOException
         * @throws ServletException
         */
        @Override
        public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
            httpServletResponse.setContentType("application/json;charset=utf-8");
            PrintWriter out = httpServletResponse.getWriter();
            out.write("{\"status\":\"success\",\"msg\":\"登录成功\"}");
            out.flush();
            out.close();
        }
    };
}
 

@Bean
public AuthenticationSuccessHandler authenticationSuccessHandler() {
    return new AuthenticationSuccessHandler() {
        /**
         * 处理登入成功的请求
         *
         * @param httpServletRequest
         * @param httpServletResponse
         * @param authentication
         * @throws IOException
         * @throws ServletException
         */
        @Override
        public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
            httpServletResponse.setContentType("application/json;charset=utf-8");
            PrintWriter out = httpServletResponse.getWriter();
            out.write("{\"status\":\"success\",\"msg\":\"登录成功\"}");
            out.flush();
            out.close();
        }
    };
}
 

public QueryFilter(
    String authEndpoint,
    AuthenticationSuccessHandler successHandler,
    AuthenticationFailureHandler failureHandler,
    AuthenticationService authenticationService,
    HttpMethod httpMethod,
    boolean protectedByCertificate,
    AuthenticationManager authenticationManager) {
    super(authEndpoint);
    this.successHandler = successHandler;
    this.failureHandler = failureHandler;
    this.authenticationService = authenticationService;
    this.httpMethod = httpMethod;
    this.protectedByCertificate = protectedByCertificate;
    this.setAuthenticationManager(authenticationManager);
}
 

public LoginFilter(
    String authEndpoint,
    AuthenticationSuccessHandler successHandler,
    AuthenticationFailureHandler failureHandler,
    ObjectMapper mapper,
    AuthenticationManager authenticationManager,
    ResourceAccessExceptionHandler resourceAccessExceptionHandler) {
    super(authEndpoint);
    this.successHandler = successHandler;
    this.failureHandler = failureHandler;
    this.mapper = mapper;
    this.resourceAccessExceptionHandler = resourceAccessExceptionHandler;
    this.setAuthenticationManager(authenticationManager);
}
 

public WechatAuthenticationConfigurer(WxMpService wxMpService, UserDetailsService userDetailsService,
                                      AuthenticationFailureHandler authenticationFailureHandler,
                                      AuthenticationSuccessHandler authenticationSuccessHandler) {
    this.wxMpService = wxMpService;
    this.userDetailsService = userDetailsService;
    this.authenticationFailureHandler = authenticationFailureHandler;
    this.authenticationSuccessHandler = authenticationSuccessHandler;
}
 

/**
 * Define a success handler to proceed after a crowd authentication, if it has been successful
 *
 * @return
 */
@Bean
public AuthenticationSuccessHandler authenticationSuccessHandler() {
  SavedRequestAwareAuthenticationSuccessHandler successHandler =
      new SavedRequestAwareAuthenticationSuccessHandler();
  successHandler.setDefaultTargetUrl("/home");
  successHandler.setUseReferer(true);
  successHandler.setAlwaysUseDefaultTargetUrl(true);
  return successHandler;
}
 

@SuppressWarnings("ProhibitedExceptionDeclared")
@Override
protected void configure(final HttpSecurity http) throws Exception {
    final AuthenticationSuccessHandler loginSuccessHandler = new LoginSuccessHandler(FindRole.CONFIG.toString(), FindController.CONFIG_PATH, "/p/");
    final HttpSessionRequestCache requestCache = new HttpSessionRequestCache();

    requestCache.setRequestMatcher(new OrRequestMatcher(
            new AntPathRequestMatcher("/p/**"),
            new AntPathRequestMatcher(FindController.CONFIG_PATH)
    ));

    http.regexMatcher("/p/.*|/config/.*|/authenticate|/logout")
        .authorizeRequests()
            .antMatchers("/p/**").hasRole(FindRole.ADMIN.name())
            .antMatchers(FindController.CONFIG_PATH).hasRole(FindRole.CONFIG.name())
            .and()
        .requestCache()
            .requestCache(requestCache)
            .and()
        .formLogin()
            .loginPage(FindController.DEFAULT_LOGIN_PAGE)
            .loginProcessingUrl("/authenticate")
            .successHandler(loginSuccessHandler)
            .failureUrl(FindController.DEFAULT_LOGIN_PAGE + "?error=auth")
            .and()
        .logout()
            .logoutSuccessHandler(new HodLogoutSuccessHandler(new HodTokenLogoutSuccessHandler(SsoController.SSO_LOGOUT_PAGE, tokenRepository), FindController.APP_PATH))
            .and()
        .csrf()
            .disable();
}
 

public AjaxLoginProcessingFilter(String defaultProcessUrl, AuthenticationSuccessHandler successHandler, 
        AuthenticationFailureHandler failureHandler, ObjectMapper mapper) {
    super(defaultProcessUrl);
    this.successHandler = successHandler;
    this.failureHandler = failureHandler;
    this.objectMapper = mapper;
}
 

public RefreshTokenProcessingFilter(String defaultProcessUrl, AuthenticationSuccessHandler successHandler,
                                    AuthenticationFailureHandler failureHandler, ObjectMapper mapper) {
    super(defaultProcessUrl);
    this.successHandler = successHandler;
    this.failureHandler = failureHandler;
    this.objectMapper = mapper;
}
 

public RestPublicLoginProcessingFilter(String defaultProcessUrl, AuthenticationSuccessHandler successHandler,
                                       AuthenticationFailureHandler failureHandler, ObjectMapper mapper) {
    super(defaultProcessUrl);
    this.successHandler = successHandler;
    this.failureHandler = failureHandler;
    this.objectMapper = mapper;
}
 

public RestLoginProcessingFilter(String defaultProcessUrl, AuthenticationSuccessHandler successHandler,
                                 AuthenticationFailureHandler failureHandler, ObjectMapper mapper) {
    super(defaultProcessUrl);
    this.successHandler = successHandler;
    this.failureHandler = failureHandler;
    this.objectMapper = mapper;
}
 

@Bean
public AuthenticationSuccessHandler mobileLoginSuccessHandler() {
	return MobileLoginSuccessHandler.builder()
		.objectMapper(objectMapper)
		.clientDetailsService(clientDetailsService)
		.passwordEncoder(passwordEncoder())
		.defaultAuthorizationServerTokenServices(defaultAuthorizationServerTokenServices).build();
}
 

@Autowired
public OpenIdAuthenticationSecurityConfig(AuthenticationSuccessHandler pcAuthenticationSuccessHandler, AuthenticationFailureHandler pcAuthenticationFailureHandler, SocialUserDetailsService userDetailsService, UsersConnectionRepository usersConnectionRepository) {
	this.pcAuthenticationSuccessHandler = pcAuthenticationSuccessHandler;
	this.pcAuthenticationFailureHandler = pcAuthenticationFailureHandler;
	this.userDetailsService = userDetailsService;
	this.usersConnectionRepository = usersConnectionRepository;
}
 

public RestLoginProcessingFilter(String defaultProcessUrl, AuthenticationSuccessHandler successHandler,
    AuthenticationFailureHandler failureHandler, ObjectMapper mapper) {
  super(defaultProcessUrl);
  this.successHandler = successHandler;
  this.failureHandler = failureHandler;
  this.objectMapper = mapper;
}
 

public RestPublicLoginProcessingFilter(String defaultProcessUrl, AuthenticationSuccessHandler successHandler,
    AuthenticationFailureHandler failureHandler, ObjectMapper mapper) {
  super(defaultProcessUrl);
  this.successHandler = successHandler;
  this.failureHandler = failureHandler;
  this.objectMapper = mapper;
}
 

public RefreshTokenProcessingFilter(String defaultProcessUrl, AuthenticationSuccessHandler successHandler,
    AuthenticationFailureHandler failureHandler, ObjectMapper mapper) {
  super(defaultProcessUrl);
  this.successHandler = successHandler;
  this.failureHandler = failureHandler;
  this.objectMapper = mapper;
}
 

public LoginProcessingFilter(
    String loginUrl,
    AuthenticationSuccessHandler successHandler,
    AuthenticationFailureHandler failureHandler,
    ObjectMapper mapper) {
  super(loginUrl);
  log.info("Initializing Login processing filter for " + loginUrl);
  this.successHandler = successHandler;
  this.failureHandler = failureHandler;
  this.mapper = mapper;
}
 

public AjaxLoginProcessingFilter(String defaultProcessUrl, AuthenticationSuccessHandler successHandler, 
        AuthenticationFailureHandler failureHandler, ObjectMapper mapper) {
    super(defaultProcessUrl);
    this.successHandler = successHandler;
    this.failureHandler = failureHandler;
    this.objectMapper = mapper;
}
 

public AdminUserProcessingFilter(String defaultProcessUrl, AuthenticationSuccessHandler successHandler,
    AuthenticationFailureHandler failureHandler, ObjectMapper mapper) {
  super(defaultProcessUrl);
  this.successHandler = successHandler;
  this.failureHandler = failureHandler;
  this.objectMapper = mapper;
}
 

public MiniAppAuthenticationConfigurer(UserDetailsService userDetailsService,
                                       AuthenticationFailureHandler authenticationFailureHandler,
                                       AuthenticationSuccessHandler authenticationSuccessHandler) {
    this.userDetailsService = userDetailsService;
    this.authenticationFailureHandler = authenticationFailureHandler;
    this.authenticationSuccessHandler = authenticationSuccessHandler;
}
 

@Bean
public SmsLoginConfigurer<HttpSecurity> smsLoginConfigurer(AuthenticationSuccessHandler successHandler,
														   AuthenticationFailureHandler failureHandler) {
	SmsLoginConfigurer<HttpSecurity> configurer = new SmsLoginConfigurer<>();
	configurer.successHandler(successHandler)
			.failureHandler(failureHandler)
			.eventPublisher(applicationEventPublisher)
			.permitAll();
	return configurer;
}
 

@Bean
public AcLoginConfigurer<HttpSecurity> acLoginConfigurer(AuthenticationSuccessHandler successHandler,
														 AuthenticationFailureHandler failureHandler) {
	AcLoginConfigurer<HttpSecurity> configurer = new AcLoginConfigurer<>();
	configurer.successHandler(successHandler)
			.failureHandler(failureHandler)
			.eventPublisher(applicationEventPublisher)
			.permitAll();
	return configurer;
}
 

@Bean
public OpenIdLoginConfigurer<HttpSecurity> openIDLoginConfigurer(AuthenticationSuccessHandler successHandler,
																 AuthenticationFailureHandler failureHandler) {
	OpenIdLoginConfigurer<HttpSecurity> configurer = new OpenIdLoginConfigurer<>();
	configurer.successHandler(successHandler)
			.failureHandler(failureHandler)
			.eventPublisher(applicationEventPublisher)
			.permitAll();
	return configurer;
}
 

@Override
public void setAuthenticationSuccessHandler(AuthenticationSuccessHandler successHandler) {
    if (!LoginFailuresClearingHandler.class.isAssignableFrom(successHandler.getClass())) {
        throw new IllegalArgumentException("Invalid login success handler. Handler must be an instance of " + LoginFailuresClearingHandler.class.getName() + " but is " + successHandler);
    }
    super.setAuthenticationSuccessHandler(successHandler);
}
 

@Bean
public AuthenticationSuccessHandler authenticationSuccessHandler() {
    return new AuthenticationSuccessHandler() {
        /**
         * 处理登入成功的请求
         *
         * @param httpServletRequest
         * @param httpServletResponse
         * @param authentication
         * @throws IOException
         * @throws ServletException
         */
        @Override
        public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
            Response result = new Response();
            CustomUserDetails userDetails = (CustomUserDetails) authentication.getPrincipal();
            //将用户信息存入 SecurityContext
            SecurityContextHolder.getContext().setAuthentication(authentication);
            //生成token
            String token = jwtTokenUtil.generateToken(userDetails);
            //将 token 保存到redis
            redisUtil.hset(userDetails.getUsername(), token, JSON.toJSONString(userDetails), jwtProperties.getExpiration());
            //处理登录结果
            result.buildSuccessResponse("已登录");
            result.setData(token);
            httpServletResponse.setContentType("application/json;charset=utf-8");
            PrintWriter out = httpServletResponse.getWriter();
            out.write(JSON.toJSONString(result));
            out.flush();
            out.close();
        }
    };
}
 

/**
 * 手机登录成功后的处理
 *
 * @return AuthenticationSuccessHandler
 */
@Bean
public AuthenticationSuccessHandler mobileLoginSuccessHandler(PasswordEncoder encoder, ClientDetailsService clientDetailsService, ObjectMapper objectMapper,
                                                              AuthorizationServerTokenServices defaultAuthorizationServerTokenServices) {
    return MobileLoginSuccessHandler.builder()
            .objectMapper(objectMapper)
            .clientDetailsService(clientDetailsService)
            .passwordEncoder(encoder)
            .defaultAuthorizationServerTokenServices(defaultAuthorizationServerTokenServices).build();
}