Spring Boot 安全认证与授权核心解析

默认情况下，Spring Security 会自动拦截所有请求并强制要求登录。为了自定义安全策略，我们需要创建一个配置类继承 WebSecurityConfigurerAdapter（注：新版 Spring Security 推荐使用 SecurityFilterChain Bean，但此处沿用经典配置以适配现有逻辑）。

import org.springframework.context.annotation.Configuration;
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.crypto.password.NoOpPasswordEncoder;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 内存认证示例，生产环境建议使用 BCrypt
        auth.inMemoryAuthentication()
            .passwordEncoder(NoOpPasswordEncoder.getInstance())
            .withUser("admin").password("admin123").roles("ADMIN")
            .and()
            .withUser("user").password("user123").roles("USER");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/admin/**").hasRole("ADMIN")
            .antMatchers("/user/**").hasRole("USER")
            .antMatchers("/").permitAll()
            .and()
            .formLogin().loginPage("/login").permitAll()
            .and()
            .logout().permitAll();
    }
}

这里我们定义了简单的用户数据，并设置了访问规则：首页公开，用户路径需要 USER 角色，管理员路径需要 ADMIN 角色。

认证方式详解

基于内存的认证

对于快速原型或测试环境，内存认证是最便捷的方式。它直接将用户信息硬编码在配置类中。上面的 configure 方法演示了如何创建两个用户：admin 和 user。

注意：NoOpPasswordEncoder 表示密码不加密，这在生产环境中极其危险，实际开发请务必使用 BCryptPasswordEncoder。

基于数据库的认证

当用户量增长后，我们需要将用户信息持久化到数据库中。这需要引入 JPA 和数据库驱动。

1. 准备依赖

<dependencies>
    <!-- ... 其他依赖 ...
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

2. 定义实体与仓库

我们需要一个 User 实体来映射数据库表，以及一个 Repository 接口来查询用户。

import javax.persistence.*;

@Entity
@Table(name = "user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;
    private String password;
    private String role;

    // Getter 和 Setter 省略...
    public String getUsername() { return username; }
    public String getPassword() { return password; }
    public String getRole() { return role; }
}

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    User findByUsername(String username);
}

3. 实现 UserDetailsService

Spring Security 通过 UserDetailsService 接口加载用户详情。我们需要实现该接口，从数据库读取用户并转换为 UserDetails 对象。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
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;
import java.util.ArrayList;
import java.util.List;

@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Autowired
    private UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("用户不存在：" + username);
        }
        List<GrantedAuthority> authorities = new ArrayList<>();
        authorities.add(new SimpleGrantedAuthority("ROLE_" + user.getRole()));
        return org.springframework.security.core.userdetails.User.builder()
                .username(user.getUsername())
                .password(user.getPassword())
                .authorities(authorities)
                .build();
    }
}

4. 更新配置类

现在配置类不再直接定义内存用户，而是注入 UserDetailsService。

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.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private UserDetailsServiceImpl userDetailsService;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService);
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance(); // 实际请替换为 BCrypt
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/admin/**").hasRole("ADMIN")
            .antMatchers("/user/**").hasRole("USER")
            .antMatchers("/").permitAll()
            .and()
            .formLogin().loginPage("/login").permitAll()
            .and()
            .logout().permitAll();
    }
}

授权策略

认证通过后，接下来就是控制权限。Spring Security 支持多种授权方式。

基于角色的授权

这是最常用的方式。我们在配置中指定 URL 路径对应的角色要求，例如 /admin/** 必须拥有 ADMIN 角色。前端页面可以根据当前用户的角色动态显示菜单或按钮。

基于权限的授权

如果需要更细粒度的控制（如'编辑文章'、'删除评论'），可以使用 hasPermission 或自定义注解配合 MethodSecurity。但在大多数业务场景中，基于角色的授权已足够覆盖需求。

实际应用场景

在实际开发中，我们通常会结合注册功能一起使用。用户在前端填写用户名、密码和角色，后端保存至数据库，随后即可通过上述配置的表单登录。

一个简单的控制器示例如下：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;

@Controller
public class SecurityController {
    @Autowired
    private UserRepository userRepository;

    @GetMapping("/")
    public String index() { return "index"; }

    @GetMapping("/login")
    public String login() { return "login"; }

    @PostMapping("/register")
    public String registerUser(String username, String password, String role) {
        User user = new User(username, password, role);
        userRepository.save(user);
        return "redirect:/login";
    }
}

总结

Spring Boot 与 Spring Security 的结合非常紧密，通过简单的依赖引入和配置类编写，就能快速构建起一套完整的认证授权体系。无论是内存测试还是数据库持久化，核心都在于正确配置 AuthenticationManager 和 HttpSecurity。记住，生产环境务必开启密码加密，并根据业务需求灵活调整授权规则。