Spring Boot 安全认证与授权实战

添加依赖后，Spring Boot 会自动启用安全配置。默认情况下，所有请求都需要登录，且密码会随机生成并打印到控制台。为了自定义行为，我们需要创建一个配置类。

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 {
        // 配置内存用户：admin/admin123 (ADMIN), user/user123 (USER)
        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();
    }
}

这里我们定义了两个角色：ADMIN 和 USER。/admin/** 路径仅允许管理员访问，而首页对所有用户开放。formLogin() 启用了默认的表单登录功能。

二、认证方式详解

1. 基于内存的认证

上面的示例就是典型的基于内存的认证。它适合开发环境或原型验证，因为用户数据硬编码在代码里。优点是简单直接，缺点是重启服务后数据丢失，不适合生产环境。

2. 基于数据库的认证

实际项目中，用户信息通常存储在数据库中。这需要引入 JPA 和数据库驱动（如 H2 用于演示）。

依赖补充：

<!-- Data JPA 依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!-- H2 数据库依赖 -->
<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 方法省略...
}

Repository 接口：

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

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

核心服务层： Spring Security 通过 UserDetailsService 加载用户详情。我们需要实现这个接口来从数据库查询用户。

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

配置更新： 在 SecurityConfig 中注入这个服务，替换掉内存配置。

@Autowired
private UserDetailsServiceImpl userDetailsService;

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

此时，系统会从数据库读取用户名和密码进行校验。记得在 application.properties 中配置好数据库连接信息。

三、授权策略

认证通过后，接下来要解决'能做什么'的问题。Spring Security 主要提供两种授权方式：基于角色和基于权限。

1. 基于角色的授权

这是最常用的方式，通过 hasRole("ROLE_NAME") 来控制 URL 访问。注意，Spring Security 会自动在角色前加 ROLE_ 前缀。

http.authorizeRequests()
    .antMatchers("/admin/**").hasRole("ADMIN")
    .antMatchers("/user/**").hasRole("USER");

2. 基于权限的授权

如果需要更细粒度的控制（例如某个按钮可见），可以使用 hasAuthority("PERMISSION_NAME")。这通常需要结合方法级注解或更复杂的表达式来实现。

四、前端视图与测试

为了让体验更完整，我们可以准备简单的 HTML 模板。使用 Thymeleaf 引擎可以方便地嵌入 Spring Security 标签。

登录页 (login.html)

<!DOCTYPE html>
<html lang="zh-CN">
<head><meta charset="UTF-8"><title>登录</title></head>
<body>
<div class="container">
    <h1>登录</h1>
    <form th:action="@{/login}" method="post">
        <label for="username">用户名：</label>
        <input type="text" id="username" name="username" required>
        <label for="password">密码：</label>
        <input type="password" id="password" name="password" required>
        <button type="submit">登录</button>
    </form>
    <a href="/">返回首页</a>
</div>
</body>
</html>

注册页 (register.html)

<!DOCTYPE html>
<html lang="zh-CN">
<head><meta charset="UTF-8"><title>注册</title></head>
<body>
<div class="container">
    <h1>注册</h1>
    <form th:action="@{/register}" method="post">
        <label for="username">用户名：</label>
        <input type="text" id="username" name="username" required>
        <label for="password">密码：</label>
        <input type="password" id="password" name="password" required>
        <label for="role">角色：</label>
        <select id="role" name="role" required>
            <option value="USER">用户</option>
            <option value="ADMIN">管理员</option>
        </select>
        <button type="submit">注册</button>
    </form>
    <a href="/">返回首页</a>
</div>
</body>
</html>

控制器逻辑：

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";
    }
}

自动化测试： 最后，别忘了写单元测试来验证安全逻辑是否生效。下面是一个整合测试类的示例，模拟了未登录和已登录状态下的访问情况。

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import java.util.Base64;
import static org.assertj.core.api.Assertions.assertThat;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class SecurityApplicationTests {
    @LocalServerPort
    private int port;

    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    void testIndexPage() {
        String response = restTemplate.getForObject("http://localhost:" + port + "/", String.class);
        assertThat(response).contains("首页");
    }

    @Test
    void testUserPageWithUserAuthentication() {
        String credentials = "user:user123";
        String base64Credentials = Base64.getEncoder().encodeToString(credentials.getBytes());
        HttpHeaders headers = new HttpHeaders();
        headers.add("Authorization", "Basic " + base64Credentials);
        HttpEntity<String> entity = new HttpEntity<>(headers);
        ResponseEntity<String> response = restTemplate.exchange(
            "http://localhost:" + port + "/user", HttpMethod.GET, entity, String.class
        );
        assertThat(response.getStatusCodeValue()).isEqualTo(200);
    }
}

五、总结

通过本文，我们完成了 Spring Boot 与 Spring Security 的全流程集成。从依赖引入到内存/数据库认证切换，再到基于角色的权限拦截，每一步都是构建安全应用的基础。记住，安全不是一蹴而就的，随着业务复杂度的增加，你可能还需要引入 OAuth2、JWT 等更高级的方案。但在起步阶段，掌握这些核心概念足以应对大多数场景。

在实际开发中，建议始终开启 HTTPS，并对密码进行加密存储（如 BCrypt），避免使用 NoOpPasswordEncoder 这样的明文编码器。希望这些经验能帮助你在项目中少走弯路。