初探 Spring Boot Starter Security：构建更安全的Spring Boot应用

一休哥助手

于 2024-05-18 09:00:00 发布

阅读量1.1k

点赞数 11

分类专栏： java 文章标签： spring boot 安全后端

本文链接：https://blog.csdn.net/fudaihb/article/details/139003528

版权

java 专栏收录该内容

89 篇文章 0 订阅

订阅专栏

引言

Spring Boot 作为 Java 生态系统下的热门框架，以其简洁和易上手著称。而在构建 Web 应用程序时，安全性始终是开发者必须重视的一个方面。Spring Boot Starter Security 为开发者提供了一个简单但功能强大的安全框架，使得实现身份验证和授权变得相对容易。

本文将带你深入了解如何使用 Spring Boot Starter Security 来构建一个安全的 Spring Boot 应用，包括基本配置、常见用例以及一些技巧和最佳实践。

什么是 Spring Boot Starter Security？
初始设置
- 添加依赖
- 基本配置
基本概念
- 认证与授权
- Filter 和 SecurityContext
示例：创建一个简单的安全应用
- 设定用户角色
- 自定义登录页面
- 基于角色的访问控制
高级配置
- 自定义 UserDetailsService
- 自定义 Security Configuration
- 使用 JWT 进行身份验证
综合示例：构建一个完整的安全应用
- 项目结构
- 代码实现
- 测试和验证
最佳实践与常见问题
- 安全最佳实践
- 常见问题及解决方案
结论

1. 什么是 Spring Boot Starter Security？

Spring Boot Starter Security 是一个简化的 Spring Security 集成包，使得我们可以非常容易地在 Spring Boot 应用中添加强大的安全功能。它提供了一套灵活的工具和配置，用于实现认证和授权，使得应用程序更加安全。

2. 初始设置

添加依赖

首先，我们需要在 pom.xml 文件中添加 Spring Boot Starter Security 的依赖：

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

基本配置

在添加依赖后，Spring Security 会自动为我们的应用添加一些默认的安全配置，例如 HTTP Basic Authentication（基于 HTTP 的基础身份验证）。这意味着，我们可以立即看到应用要求用户进行身份验证。

@SpringBootApplication
public class SecurityApplication {
    public static void main(String[] args) {
        SpringApplication.run(SecurityApplication.class, args);
    }
}

此时，运行应用后，您会看到 Spring Boot 自动生成了一个密码，并在控制台输出。

3. 基本概念

认证与授权

认证（Authentication）：验证用户的身份。
授权（Authorization）：确定用户是否有权访问某个资源。

Filter 和 SecurityContext

Spring Security 通过一系列的过滤器（Filters）来处理安全逻辑。这些过滤器会拦截每个请求，并应用相应的认证和授权逻辑。所有安全相关的信息都会被存储在 SecurityContext 中，从而使得后续的请求处理可以基于这些信息进行访问控制。

4. 示例：创建一个简单的安全应用

设定用户角色

我们可以通过创建一个配置类来设定用户角色：

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password(passwordEncoder().encode("password")).roles("USER")
            .and()
            .withUser("admin").password(passwordEncoder().encode("admin")).roles("ADMIN");
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/admin/**").hasRole("ADMIN")
            .antMatchers("/user/**").hasRole("USER")
            .and()
            .formLogin();
    }
}

在上面的配置中，我们创建了两个用户（user 和 admin），并且设置了不同的角色（USER 和 ADMIN）。此外，我们还定义了不同 URL 路径对应的访问权限。

自定义登录页面

我们可以自定义一个登录页面，以增强用户体验：

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

在 WebSecurityConfig 中，我们需要指定这个自定义登录页面：

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

基于角色的访问控制

上述配置已经体现了基于角色的基本访问控制。我们规定了 /admin/** 路径只能由拥有 ADMIN 角色的用户访问，而 /user/** 路径只能由拥有 USER 角色的用户访问。

5. 高级配置

自定义 UserDetailsService

有时候，我们需要从数据库加载用户信息。我们可以通过实现 UserDetailsService 接口来自定义加载用户的逻辑：

@Service
public class CustomUserDetailsService 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("User not found.");
        }
        return new org.springframework.security.core.userdetails.User(
            user.getUsername(), 
            user.getPassword(), 
            AuthorityUtils.commaSeparatedStringToAuthorityList(user.getRoles())
        );
    }
}

自定义 Security Configuration

除了基本配置外，有些时候我们需要更灵活的配置。例如，我们可以完全覆盖默认的 Spring Security 配置：

@Configuration
@EnableWebSecurity
public class CustomSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private CustomUserDetailsService userDetailsService;

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

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests()
            .anyRequest().authenticated()
            .and()
            .formLogin().loginPage("/login").permitAll()
            .and()
            .logout().permitAll();
    }
}

使用 JWT 进行身份验证

JWT（JSON Web Token）是一种更加轻便的授权机制，我们可以采用它来替代 Session Cookie 进行身份验证。实现 JWT 需要进行以下几步：

添加 jwt 相关的依赖；
创建 token 提供者；
创建过滤器来验证 token ；

添加 JWT 依赖

在 pom.xml 中添加以下依赖：

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

创建 TokenProvider

@Component
public class TokenProvider {
    private final String jwtSecret = "yourSecretKey";
    private final long jwtExpirationMs = 3600000;

    public String generateToken(Authentication authentication) {
        String username = authentication.getName();
        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + jwtExpirationMs);

        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(now)
                .setExpiration(expiryDate)
                .signWith(SignatureAlgorithm.HS512, jwtSecret)
                .compact();
    }

    public String getUsernameFromToken(String token) {
        return Jwts.parser()
                .setSigningKey(jwtSecret)
                .parseClaimsJws(token)
                .getBody().getSubject();
    }

    public boolean validateToken(String authToken) {
        try {
            Jwts.parser().setSigningKey(jwtSecret).parseClaimsJws(authToken);
            return true;
        } catch (SignatureException | MalformedJwtException | ExpiredJwtException | UnsupportedJwtException | IllegalArgumentException e) {
            e.printStackTrace();
        }
        return false;
    }
}

创建 JWT 过滤器

@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    @Autowired
    private TokenProvider tokenProvider;

    @Autowired
    private CustomUserDetailsService customUserDetailsService;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        try {
            String jwt = getJwtFromRequest(request);

            if (StringUtils.hasText(jwt) && tokenProvider.validateToken(jwt)) {
                String username = tokenProvider.getUsernameFromToken(jwt);

                UserDetails userDetails = customUserDetailsService.loadUserByUsername(username);
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));

                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        } catch (Exception ex) {
            logger.error("Could not set user authentication in security context", ex);
        }

        filterChain.doFilter(request, response);
    }

    private String getJwtFromRequest(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}

调整 Security Configuration

@EnableWebSecurity
@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private JwtAuthenticationFilter jwtAuthenticationFilter;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.cors().and().csrf().disable()
                .authorizeRequests().antMatchers("/login", "/signup").permitAll()
                .anyRequest().authenticated();

        http.addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
    }
}

6. 综合示例：构建一个完整的安全应用

接下里，我们将创建一个功能更全的示例应用，结合之前介绍的各种配置，实现用户注册、登录、基于角色的访问控制和 JWT 身份验证。

项目结构

src
 └── main
     ├── java
     │    └── com.example.security
     │         ├── controller
     │         ├── model
     │         ├── repository
     │         ├── security
     │         ├── service
     │         └── SecurityApplication.java
     └── resources
          ├── templates
          └── application.yml

代码实现

模型类

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;
    private String password;
    private String roles;  // e.g., "USER, ADMIN"

    // getters and setters
}

Repository

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

UserDetailsService 实现

@Service
public class CustomUserDetailsService 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("User not found.");
        }
        return new org.springframework.security.core.userdetails.User(
            user.getUsername(), 
            user.getPassword(), 
            AuthorityUtils.commaSeparatedStringToAuthorityList(user.getRoles())
        );
    }
}

安全配置

@EnableWebSecurity
@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private JwtAuthenticationFilter jwtAuthenticationFilter;

    @Autowired
    private CustomUserDetailsService customUserDetailsService;

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

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.cors().and().csrf().disable()
            .authorizeRequests().antMatchers("/login", "/signup").permitAll()
            .anyRequest().authenticated();

        http.addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
    }
}

控制器

@RestController
public class AuthController {

    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private CustomUserDetailsService userDetailsService;

    @Autowired
    private TokenProvider tokenProvider;

    @PostMapping("/login")
    public ResponseEntity<?> authenticateUser(@RequestBody LoginRequest loginRequest) {
        Authentication authentication = authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(
                        loginRequest.getUsername(),
                        loginRequest.getPassword()
                )
        );

        SecurityContextHolder.getContext().setAuthentication(authentication);

        String jwt = tokenProvider.generateToken(authentication);
        return ResponseEntity.ok(new JwtAuthenticationResponse(jwt));
    }

    @PostMapping("/signup")
    public ResponseEntity<?> registerUser(@RequestBody SignUpRequest signUpRequest) {
        if(userRepository.existsByUsername(signUpRequest.getUsername())) {
            return new ResponseEntity<>(new ApiResponse(false, "Username is already taken!"), HttpStatus.BAD_REQUEST);
        }

        // Creating user's account
        User user = new User();
        user.setUsername(signUpRequest.getUsername());
        user.setPassword(passwordEncoder.encode(signUpRequest.getPassword()));
        user.setRoles("USER");

        userRepository.save(user);

        return ResponseEntity.ok(new ApiResponse(true, "User registered successfully"));
    }
}

测试和验证

我们已经完成了一个简单但是功能齐全的 Spring Boot 安全应用。可以通过以下步骤进行测试和验证：

启动应用
通过 /signup 端点进行用户注册
通过 /login 端点进行用户登录，并获取 JWT token
使用获取的 JWT token 访问其他受保护的端点

7. 最佳实践和常见问题

安全最佳实践

使用强加密算法：如 BCryptPasswordEncoder 对密码进行加密存储。
避免硬编码密码或密钥：将敏感信息存储在安全的配置文件或环境变量中。
启用 CSRF 保护：对于需要借助表单提交的应用保持 CSRF 保护。
定期更新依赖：检查依赖库的安全更新，避免使用有已知漏洞的库。
输入验证：在用户输入点进行严格的输入验证，防止XSS和SQL注入等攻击。

常见问题及解决方案

问题1：为什么自定义登录页面不显示？

解决方案：确保在 WebSecurityConfig 中设置了 .loginPage("/login").permitAll(); 并且路径正确。

问题2：身份验证失败，显示 “Bad credentials”。

解决方案：确认用户名和密码是否正确，以及整体加密方式一致。

问题3：为什么 JWT 从请求中提取失败？

解决方案：确认请求头格式是否正确，Authorization: Bearer <token>，并且确保 JWT 过滤器在安全配置中正确添加。

结论

Spring Boot Starter Security 为开发者提供了丰富且灵活的安全配置选项，使得安全性实现变得相对简单。在本文中，我们探讨了基本概念和常见用例，并通过构建一个完整的示例应用，展示了其强大的功能。希望这些内容能帮助你在构建安全的 Spring Boot 应用时游刃有余。

通过对 Spring Boot Starter Security 的深入了解和实践，我们不仅增强了应用的安全性，还为用户提供了更为可靠的使用体验。继续学习和实践，你将在开发和维护安全应用的道路上走得更远。

一休哥助手

关注

11
点赞
踩
28

收藏

觉得还不错? 一键收藏
打赏
0
评论
初探 Spring Boot Starter Security：构建更安全的Spring Boot应用

Spring Boot 作为 Java 生态系统下的热门框架，以其简洁和易上手著称。而在构建 Web 应用程序时，安全性始终是开发者必须重视的一个方面。Spring Boot Starter Security 为开发者提供了一个简单但功能强大的安全框架，使得实现身份验证和授权变得相对容易。本文将带你深入了解如何使用 Spring Boot Starter Security 来构建一个安全的 Spring Boot 应用，包括基本配置、常见用例以及一些技巧和最佳实践。
复制链接

扫一扫