Spring Boot 中的认证与授权实践

安全配置这块，新版 Spring Security 更推荐 SecurityFilterChain，不过很多项目里还是能看到 WebSecurityConfigurerAdapter。下面这个写法虽然偏老，但读起来直接，尤其适合先把认证流程跑通。

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();
    }
}

这里有个现实取舍：内存认证上手快，适合开发和验证配置；一旦上线，就别继续用明文密码和代码里硬编码用户了，重启丢数据只是表面问题，真正的问题是它根本不该出现在生产里。

认证怎么做

内存认证

这是最省事的方式。用户名、密码、角色都写在配置里，启动就能用。调接口、看登录页、验证拦截规则时很方便，但它不负责持久化，也不适合保存真实用户信息。

数据库认证

生产环境里更常见的是把用户信息放到数据库，再通过 UserDetailsService 去加载。

先补上依赖：

<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>

实体类可以先简单一点：

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 省略
}

然后自己实现 UserDetailsService，把数据库里的用户映射成 Spring Security 能识别的对象：

import org.springframework.beans.factory.annotation.Autowired;
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();
    }
}

配置里把这个 Service 接上就行：

@Autowired
private UserDetailsServiceImpl userDetailsService;

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

这类实现没什么花活，重点在于数据库里存的密码必须是加密后的值。Spring Security 不关心你怎么存，它只关心拿到的密码能不能和登录时输入的内容对上。

授权怎么控

Spring Security 最常用的是基于角色的访问控制，也就是 RBAC。

• 角色控制：hasRole("ADMIN") 这类写法，适合页面、接口按身份分组。
• 权限控制：hasAnyAuthority("READ", "WRITE")，粒度更细，适合接口级别的操作限制。

在 HttpSecurity 里通常是按 URL 做拦截：公开接口放开，管理接口收紧。这个思路很朴素，但好维护。规则写得越直白，后面排查越省时间。

常见业务入口

实际项目里，安全模块一般会接登录、登出、注册这些入口。控制器通常不会承担太多安全逻辑，更多是页面跳转和表单提交。

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

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

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

    @PostMapping("/register")
    public String registerUser(String username, String password, String role) {
        // 保存用户逻辑
        return "redirect:/login";
    }
}

如果前端用的是 Thymeleaf，登录表单提交到 /login，登出走 /logout 就够了。具体页面怎么跳，Spring Security 会接管大部分流程，不用自己再手写一套重定向逻辑。

结论

Spring Boot 接 Spring Security，核心不是记配置项，而是先把认证和授权这两条线分清楚。开发阶段用内存认证能快速验证流程，真正上线还是要切到数据库认证，并把密码加密、角色映射和 URL 拦截规则一起理顺。WebSecurityConfigurerAdapter 在老项目里还能见到，新项目更建议直接按当前版本的配置方式来写，少踩兼容性坑。