16. Spring Boot如何集成Spring Security？如何实现自定义认证和授权？

PangHu大约 4 分钟

在 Spring Boot 中集成 Spring Security 非常方便，并且可以通过多种方式实现自定义的认证和授权逻辑。以下是集成 Spring Security 的步骤以及实现自定义认证和授权的方法。

1. Spring Boot 集成 Spring Security

1.1 添加依赖

首先，在 Spring Boot 项目中添加 spring-boot-starter-security 依赖，这个依赖包含了 Spring Security 的核心功能。

Maven 配置：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Gradle 配置：

implementation 'org.springframework.boot:spring-boot-starter-security'

添加依赖后，Spring Security 会自动应用到项目中，并且会启用默认的安全配置。

1.2 默认配置

在没有任何额外配置的情况下，Spring Security 默认会为所有 HTTP 请求启用基本认证，并且会自动生成一个用户（用户名是 user）和一个随机生成的密码。这个默认密码会在应用启动时打印到控制台。

2. 自定义认证和授权

自定义认证和授权涉及以下几个步骤：

自定义用户详细信息服务（UserDetailsService）
配置安全过滤链（SecurityFilterChain）
自定义认证提供者（可选）
配置授权规则

2.1 自定义 `UserDetailsService`

UserDetailsService 是 Spring Security 用于获取用户信息的核心接口。你可以实现这个接口，并提供自定义的用户加载逻辑。

示例：

import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
public class MyUserDetailsService implements UserDetailsService {

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 在实际应用中，这里可以从数据库或其他数据源加载用户信息
        if ("user".equals(username)) {
            return User.withUsername("user")
                    .password("{noop}password") // {noop}表示不进行加密
                    .roles("USER")
                    .build();
        } else if ("admin".equals(username)) {
            return User.withUsername("admin")
                    .password("{noop}admin")
                    .roles("ADMIN")
                    .build();
        } else {
            throw new UsernameNotFoundException("User not found");
        }
    }
}

2.2 配置 `SecurityFilterChain`

SecurityFilterChain 是 Spring Security 用于配置 HTTP 安全的核心组件。在 Spring Boot 中，你可以通过配置类来定制安全配置。

示例：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/user/**").hasRole("USER")
                .antMatchers("/", "/home").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login") // 自定义登录页面
                .permitAll()
                .and()
            .logout()
                .permitAll();

        return http.build();
    }

    @Bean
    public UserDetailsService userDetailsService() {
        return new MyUserDetailsService();
    }
}

authorizeRequests()：配置请求的访问规则。上面的例子中，/admin/** 只能由拥有 ADMIN 角色的用户访问，/user/** 只能由拥有 USER 角色的用户访问，/ 和 /home 对所有用户开放，其他请求需要认证。
formLogin()：启用表单登录，并自定义登录页面。
logout()：启用注销功能。

2.3 自定义认证提供者（可选）

如果需要更灵活的认证机制，可以自定义认证提供者（AuthenticationProvider）。

示例：

import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.stereotype.Component;

@Component
public class MyAuthenticationProvider implements AuthenticationProvider {

    private final UserDetailsService userDetailsService;

    public MyAuthenticationProvider(UserDetailsService userDetailsService) {
        this.userDetailsService = userDetailsService;
    }

    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        String username = authentication.getName();
        String password = authentication.getCredentials().toString();

        // 从自定义的 UserDetailsService 加载用户
        var userDetails = userDetailsService.loadUserByUsername(username);

        // 自定义的认证逻辑，例如验证密码、检查账户状态等
        if (userDetails.getPassword().equals(password)) {
            return new UsernamePasswordAuthenticationToken(username, password, userDetails.getAuthorities());
        } else {
            throw new AuthenticationException("Authentication failed") {};
        }
    }

    @Override
    public boolean supports(Class<?> authentication) {
        return authentication.equals(UsernamePasswordAuthenticationToken.class);
    }
}

然后在 SecurityConfig 中注册这个认证提供者：

import org.springframework.context.annotation.Bean;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;

@Configuration
public class SecurityConfig {

    private final AuthenticationProvider authenticationProvider;

    public SecurityConfig(AuthenticationProvider authenticationProvider) {
        this.authenticationProvider = authenticationProvider;
    }

    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration authenticationConfiguration) throws Exception {
        return authenticationConfiguration.getAuthenticationManager();
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authenticationProvider(authenticationProvider) // 使用自定义认证提供者
            .authorizeRequests()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/user/**").hasRole("USER")
                .antMatchers("/", "/home").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .logout()
                .permitAll();

        return http.build();
    }
}

2.4 配置授权规则

授权规则的配置通常包括哪些用户可以访问哪些资源。在 SecurityFilterChain 中，你可以通过 authorizeRequests 方法配置这些规则。

antMatchers("/admin/\**").hasRole("ADMIN")：指定 /admin/** 路径只能被拥有 ADMIN 角色的用户访问。
anyRequest().authenticated()：其他所有请求都需要认证。

3. 完整示例

完整示例包含了用户自定义认证、授权配置、自定义登录页面等。

项目结构：

src
└── main
    ├── java
    │   └── com.example.security
    │       ├── MyApplication.java
    │       ├── MyUserDetailsService.java
    │       ├── MyAuthenticationProvider.java
    │       └── SecurityConfig.java
    └── resources
        ├── static
        │   └── login.html
        └── application.properties

MyUserDetailsService.java：自定义用户加载逻辑。
MyAuthenticationProvider.java：可选的自定义认证提供者。
SecurityConfig.java：配置 HTTP 安全和授权规则。
login.html：自定义登录页面。

login.html 示例：

<!DOCTYPE html>
<html>
<head>
    <title>Login</title>
</head>
<body>
    <h2>Login</h2>
    <form method="post" action="/login">
        <div>
            <label for="username">Username:</label>
            <input type="text" id="username" name="username">
        </div>
        <div>
            <label for="password">Password:</label>
            <input type="password" id="password" name="password">
        </div>
        <div>
            <button type="submit">Login</button>
        </div>
    </form>
</body>
</html>

总结

集成 Spring Security：通过引入 spring-boot-starter-security，可以快速为 Spring Boot 应用添加安全功能。
自定义认证和授权：通过实现 UserDetailsService、配置 SecurityFilterChain、以及可选的自定义 AuthenticationProvider，可以灵活地定制认证和授权逻辑。
自定义登录页面：可以使用 formLogin().loginPage() 方法指定自定义的登录页面。

通过这些配置，Spring Boot 应用可以轻松地实现复杂的安全需求，确保应用的认证和授权逻辑符合业务需求。