当前位置:   article > 正文

初探 Spring Boot Starter Security:构建更安全的Spring Boot应用_spring-boot-starter-security 版本

spring-boot-starter-security 版本

引言

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

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

目录

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

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>
  • 1
  • 2
  • 3
  • 4

基本配置

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

@SpringBootApplication
public class SecurityApplication {
    public static void main(String[] args) {
        SpringApplication.run(SecurityApplication.class, args);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

此时,运行应用后,您会看到 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();
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

在上面的配置中,我们创建了两个用户(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>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

WebSecurityConfig 中,我们需要指定这个自定义登录页面:

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.authorizeRequests()
        .antMatchers("/admin/**").hasRole("ADMIN")
        .antMatchers("/user/**").hasRole("USER")
        .and()
        .formLogin().loginPage("/login").permitAll();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

基于角色的访问控制

上述配置已经体现了基于角色的基本访问控制。我们规定了 /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())
        );
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

自定义 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();
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

使用 JWT 进行身份验证

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

  1. 添加 jwt 相关的依赖;
  2. 创建 token 提供者;
  3. 创建过滤器来验证 token ;
添加 JWT 依赖

pom.xml 中添加以下依赖:

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>
  • 1
  • 2
  • 3
  • 4
  • 5
创建 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;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
创建 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;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
调整 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);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

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

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

项目结构

src
 └── main
     ├── java
     │    └── com.example.security
     │         ├── controller
     │         ├── model
     │         ├── repository
     │         ├── security
     │         ├── service
     │         └── SecurityApplication.java
     └── resources
          ├── templates
          └── application.yml
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

代码实现

模型类
@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
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
Repository
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    User findByUsername(String username);
}
  • 1
  • 2
  • 3
  • 4
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())
        );
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
安全配置
@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);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
控制器
@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"));
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

测试和验证

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

  1. 启动应用
  2. 通过 /signup 端点进行用户注册
  3. 通过 /login 端点进行用户登录,并获取 JWT token
  4. 使用获取的 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 的深入了解和实践,我们不仅增强了应用的安全性,还为用户提供了更为可靠的使用体验。继续学习和实践,你将在开发和维护安全应用的道路上走得更远。

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/知新_RL/article/detail/625417
推荐阅读
相关标签
  

闽ICP备14008679号