SpringBoot Security实现单点登出并清除所有token

要实现Spring Boot Security的单点登出并清除所有token，可以遵循以下步骤：

1. 配置SecurityConfig

在Spring Security的配置类中，可以使用logout()方法来设置单点登出和清除所有token的相关配置。示例代码如下：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/login/**", "/logout/**").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .successHandler(successHandler())
                .permitAll()
                .and()
            .logout()
                .logoutUrl("/logout")
                .invalidateHttpSession(true)
                .logoutSuccessHandler(logoutSuccessHandler())
                .deleteCookies("JSESSIONID")
                .and()
            .csrf()
                .disable();
    }

    @Bean
    public AuthenticationSuccessHandler successHandler() {
        return new CustomAuthenticationSuccessHandler();
    }

    @Bean
    public LogoutSuccessHandler logoutSuccessHandler() {
        return new CustomLogoutSuccessHandler();
    }

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user")
                .password("{noop}password")
                .roles("USER");
    }
}

在上面的代码中，logout()方法中的参数设置如下：

• logoutUrl()：设置登出的URL，客户端访问这个URL即表示要登出。
• invalidateHttpSession(true)：设置是否清除HttpSession，默认是true，表示清除。
• logoutSuccessHandler()：设置登出成功后的处理器，这里使用了自定义的CustomLogoutSuccessHandler。

• deleteCookies("JSESSIONID")：设置要删除的cookie名称，这里删除了JSESSIONID，这是Spring Security默认使用的Session Cookie的名称。

• 实现LogoutSuccessHandler接口

为了在单点登出完成后进行一些处理，需要实现Spring Security的LogoutSuccessHandler接口。示例代码如下：

public class CustomLogoutSuccessHandler implements LogoutSuccessHandler {
    @Override
    public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        // 实现相关处理，比如通知其他服务注销
        String redirectUrl = "http://example.com/login?logout";
        response.sendRedirect(redirectUrl);
    }
}

在上面的代码中，onLogoutSuccess()方法中的参数如下：

• HttpServletRequest request：客户端发来的请求对象。
• HttpServletResponse response：向客户端返回的响应对象。
• Authentication authentication：表示已经认证过的用户信息，即已经登录的用户信息。

在这个方法中，可以实现一些自定义的处理，比如通知其他服务注销，然后跳转到登录页面。在这个示例中，登出后会重定向到"http://example.com/login?logout"页面。

1. 实现CasAuthenticationFilter

如果要与CAS服务器实现单点登出，需要自定义一个CasAuthenticationFilter，并覆盖它的doFilter()方法，并在这个方法中监听CAS服务器发送的注销请求，然后清除本地的token和HttpSession。示例代码如下：

public class CustomCasAuthenticationFilter extends CasAuthenticationFilter {
    private static final Log logger = LogFactory.getLog(CustomCasAuthenticationFilter.class);

    @Override
    protected void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String logoutRequest = request.getParameter("logoutRequest");
        if (StringUtils.isNotBlank(logoutRequest)) {
            logger.info("Received CAS logout request.\n" + logoutRequest);
            // 清除token和HttpSession
            request.getSession().invalidate();
            response.sendRedirect("/login?logout");
            return;
        }
        super.doFilter(request, response, filterChain);
    }
}

在上面的代码中，覆盖了doFilter()方法，进行了以下操作：

• 判断是否接收到CAS服务器的注销请求。
• 如果收到注销请求，则清除token和HttpSession，然后重定向到登录页面。

• 如果没有收到注销请求，则调用父类的doFilter()方法。

• 配置SecurityConfig

将自定义的CustomCasAuthenticationFilter配置到Spring Security中，示例代码如下：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.addFilter(casAuthenticationFilter());
    }

    @Bean
    public CasAuthenticationFilter casAuthenticationFilter() throws Exception {
        CasAuthenticationFilter casFilter = new CustomCasAuthenticationFilter();
        casFilter.setAuthenticationManager(authenticationManager());
        casFilter.setFilterProcessesUrl("/login/cas");
        return casFilter;
    }

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        auth.authenticationProvider(casAuthenticationProvider());
    }

    @Bean
    public CasAuthenticationProvider casAuthenticationProvider() {
        CasAuthenticationProvider casAuthenticationProvider = new CasAuthenticationProvider();
        casAuthenticationProvider.setUserDetailsService(userDetailsService());
        casAuthenticationProvider.setServiceProperties(serviceProperties());
        casAuthenticationProvider.setTicketValidator(new Cas30ServiceTicketValidator(casUrl()));
        casAuthenticationProvider.setKey("casAuthProviderKey");
        return casAuthenticationProvider;
    }

    @Bean
    public UserDetailsService userDetailsService() {
        InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
        manager.createUser(User.withUsername("sso").password("{noop}sso").roles("USER").build());
        return manager;
    }

    @Bean
    public ServiceProperties serviceProperties() {
        ServiceProperties serviceProperties = new ServiceProperties();
        serviceProperties.setService("http://localhost:8080/login/cas");
        serviceProperties.setSendRenew(false);
        return serviceProperties;
    }

    @Bean
    public CasAuthenticationEntryPoint casAuthenticationEntryPoint() {
        CasAuthenticationEntryPoint casAuthenticationEntryPoint = new CasAuthenticationEntryPoint();
        casAuthenticationEntryPoint.setLoginUrl(casUrl() + "/login");
        casAuthenticationEntryPoint.setServiceProperties(serviceProperties());
        return casAuthenticationEntryPoint;
    }

    @Bean
    public SingleLogoutFilter singleLogoutFilter() {
        LogoutHandler[] handlers = {logoutHandler()};
        return new SingleLogoutFilter(casUrl() + "/logout", handlers, new SecurityContextLogoutHandler());
    }

    @Bean
    public LogoutFilter logoutFilter() {
        return new LogoutFilter("/logout", logoutHandler());
    }

    @Bean
    public LogoutHandler logoutHandler() {
        CompositeLogoutHandler composite = new CompositeLogoutHandler();
        composite.addHandler(new SecurityContextLogoutHandler());
        composite.addHandler(new CasLogoutHandler(casUrl()));
        return composite;
    }

    @Bean
    public CasAuthenticationFilter casFilter() throws Exception {
        CasAuthenticationFilter filter = new CasAuthenticationFilter();
        filter.setServiceProperties(serviceProperties());
        filter.setAuthenticationManager(authenticationManager());
        return filter;
    }

    @Bean
    public CasAuthenticationProvider casAuthProvider() {
        CasAuthenticationProvider provider = new CasAuthenticationProvider();
        provider.setServiceProperties(serviceProperties());
        provider.setTicketValidator(new Cas30ServiceTicketValidator(casUrl()));
        provider.setKey("my_sso_key");
        return provider;
    }

    @Bean
    public ProxyTicketResolver proxyTicketResolver() {
        return new Cas30ProxyTicketResolver(casUrl());
    }

    private String casUrl() {
        return "http://localhost:8888/cas";
    }
}

在上面的代码中，addFilter()方法添加了上面自定义的CustomCasAuthenticationFilter，并使用了setFilterProcessesUrl()方法定义了过滤器的URL。同时配置了相关的服务和处理器，实现了与CAS服务器的单点登出。