Spring Security是如何实现自定义认证的

Spring Security 允许通过自定义认证机制来处理各种身份验证场景。下面是一个简单的示例：

1. 定义自定义认证的流程

在Spring Security中，认证流程通常涉及以下组件：

• Authentication 对象: 代表用户的认证请求和结果。
• AuthenticationManager 接口: 认证请求的主要入口，负责委派给合适的 AuthenticationProvider。
• AuthenticationProvider 接口: 实际执行身份验证逻辑的组件。 它可以针对特定类型的认证请求 (如用户名/密码、OAuth 2.0 等) 提供验证。
• UserDetailsService 接口: (可选) 用于从数据源 (如数据库) 加载用户信息。 通常用于用户名/密码认证。
• UserDetails 接口: 代表加载的用户信息，包含用户名、密码、权限等。

2. 实现自定义 Authentication 对象

定义两个 Authentication 对象：一个用于认证 请求，一个用于认证 成功后 的结果。

// 认证请求对象
public class CustomAuthenticationToken implements Authentication {

    private final Object principal; // 用户名/标识
    private Object credentials; // 密码/凭据
    private Collection<? extends GrantedAuthority> authorities; // 权限
    private boolean authenticated; // 认证状态

    public CustomAuthenticationToken(Object principal, Object credentials) {
        this.principal = principal;
        this.credentials = credentials;
        this.authenticated = false; // 初始状态：未认证
    }

    public CustomAuthenticationToken(Object principal, Object credentials, Collection<? extends GrantedAuthority> authorities) {
        this.principal = principal;
        this.credentials = credentials;
        this.authorities = authorities;
        this.authenticated = true; // 认证成功，设置已认证
    }



    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return authorities;
    }

    @Override
    public Object getCredentials() {
        return credentials;
    }

    @Override
    public Object getDetails() {
        return null; // 可选，用于存放附加信息
    }

    @Override
    public Object getPrincipal() {
        return principal;
    }

    @Override
    public boolean isAuthenticated() {
        return authenticated;
    }

    @Override
    public void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException {
        this.authenticated = isAuthenticated;
    }

    @Override
    public String getName() {
        return principal != null ? principal.toString() : null;
    }

    @Override
    public String toString() {
        return "CustomAuthenticationToken{" +
                "principal=" + principal +
                ", authenticated=" + authenticated +
                ", authorities=" + authorities +
                '}';
    }
}

3. 实现自定义 AuthenticationProvider

这是认证逻辑的核心。

import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.AuthenticationServiceException;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

@Component
public class CustomAuthenticationProvider implements AuthenticationProvider {

    // 模拟用户数据
    private static final String VALID_USERNAME = "testUser";
    private static final String VALID_PASSWORD = "password";

    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        System.out.println("CustomAuthenticationProvider.authenticate() called");

        String username = (String) authentication.getPrincipal();
        String password = (String) authentication.getCredentials();

        System.out.println("Attempting authentication for user: " + username);

        if (VALID_USERNAME.equals(username) && VALID_PASSWORD.equals(password)) {
            System.out.println("Authentication successful for user: " + username);
            List<GrantedAuthority> authorities = new ArrayList<>();
            authorities.add(new SimpleGrantedAuthority("ROLE_USER")); // 添加用户角色

            // 创建认证成功后的 Authentication 对象
            CustomAuthenticationToken authenticationResult = new CustomAuthenticationToken(username, password, authorities);
            System.out.println("Authentication Result: " + authenticationResult);
            return authenticationResult;

        } else {
            System.out.println("Authentication failed for user: " + username);
            throw new AuthenticationServiceException("Invalid username or password");
        }
    }

    @Override
    public boolean supports(Class<?> authentication) {
        // 声明此 Provider 支持哪种 Authentication 类型
        return CustomAuthenticationToken.class.isAssignableFrom(authentication);
    }
}

要点：

• authenticate() 方法: 接收 Authentication 请求对象，执行身份验证逻辑。 如果验证成功，返回一个 已认证 的 Authentication 对象 (通常包含用户权限)。 如果验证失败，抛出一个 AuthenticationException。
• supports() 方法: 指示此 AuthenticationProvider 是否支持给定的 Authentication 类型。 必须实现。
• 异常处理：在身份验证失败时，抛出适当的 AuthenticationException 子类。
• 打印日志：在身份验证的不同阶段打印日志，以便调试和跟踪。

4. 配置 Spring Security

使用 Spring Security 配置类来启用自定义认证。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Autowired
    private CustomAuthenticationProvider customAuthenticationProvider;

    @Bean
    public AuthenticationManager authenticationManager(HttpSecurity http) throws Exception {
        AuthenticationManagerBuilder authenticationManagerBuilder = http.getSharedObject(AuthenticationManagerBuilder.class);
        authenticationManagerBuilder.authenticationProvider(customAuthenticationProvider);
        return authenticationManagerBuilder.build();
    }


    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .antMatchers("/public/**").permitAll() // 允许访问公共资源
                .anyRequest().authenticated() // 其他所有请求需要认证
                .and()
                .formLogin() // 使用表单登录
                .permitAll()
                .and()
                .logout()
                .permitAll();

        return http.build();
    }

}

关键配置：

• @EnableWebSecurity: 启用 Spring Security。
• AuthenticationManagerBuilder: 用于配置 AuthenticationManager。 在这里，将自定义 AuthenticationProvider 添加到构建器中。

5. 创建一个简单的Controller测试

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/public/hello")
    public String helloPublic() {
        return "Hello, Public!";
    }

    @GetMapping("/hello")
    public String helloAuthenticated() {
        return "Hello, Authenticated User!";
    }
}

6. 测试

1. 启动你的 Spring Boot 应用程序。
2. 访问 /public/hello。 应该可以直接访问，因为配置允许匿名访问。
3. 访问 /hello。 你会被重定向到登录页面。
4. 使用用户名 testUser 和密码 password 登录。
5. 如果登录成功，你应该能够看到 “Hello, Authenticated User!”。

控制台输出示例

当尝试登录时，你会在控制台中看到类似以下的输出：

CustomAuthenticationProvider.authenticate() called
Attempting authentication for user: testUser
Authentication successful for user: testUser
Authentication Result: CustomAuthenticationToken{principal=testUser, authenticated=true, authorities=[ROLE_USER]}

调试技巧

• 断点: 在 authenticate() 方法中设置断点，逐步调试认证流程。

• 日志级别: 调整 Spring Security 的日志级别 (例如，设置为 DEBUG)，以获取更详细的输出。 可以在 application.properties 或 application.yml 中设置：

  logging.level.org.springframework.security=DEBUG
  

• HTTP Tracing: 使用浏览器开发者工具或 HTTP 客户端 (如 Postman) 查看 HTTP 请求和响应，以诊断认证问题。

扩展

• 密码编码: 强烈建议使用 PasswordEncoder 对密码进行编码，而不是直接存储明文密码。 Spring Security 提供了多种 PasswordEncoder 实现 (如 BCryptPasswordEncoder)。
• UserDetailsService: 使用 UserDetailsService 从数据库或其他数据源加载用户信息。
• OAuth 2.0 和 JWT: 如果需要更高级的认证机制，可以集成 OAuth 2.0 或 JWT (JSON Web Token)。
• 自定义异常处理: 创建自定义的 AuthenticationException 子类，以便更精确地处理不同类型的认证错误。
• 权限模型: 设计灵活的权限模型，以便控制用户对资源的访问。