构建安全稳定的应用：Spring Security 实用指南

已于 2024-07-04 07:55:09 修改
阅读量1.4k 收藏 24
点赞数 24
分类专栏： SpringBoot 文章标签： 安全 spring java spring security spring boot
于 2024-07-03 20:47:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/learnerdl/article/details/140161802
版权

文章目录

前言

在现代 Web 应用程序中，安全性是至关重要的一个方面。Spring Security 作为一个功能强大且广泛使用的安全框架，为 Java 应用程序提供了全面的安全解决方案。本文将深入介绍 Spring Security 的基本概念、核心功能以及如何在应用程序中使用它来实现认证和授权。

一、Spring Security

Spring Security 是一个基于 Spring 的安全性框架，用于提供身份验证、授权、攻击防护等安全服务。它构建在 Spring 框架之上，利用依赖注入和 AOP 等功能，使得集成到现有的 Spring 应用程序中非常简单。

在开始深入了解 Spring Security 之前，我们需要了解几个核心概念：

  1. Authentication（认证）：验证用户的身份，通常是通过用户名和密码进行。
  2. Authorization（授权）：确定用户是否有权限执行特定操作或访问特定资源。
  3. Principal（主体）：代表当前用户的抽象概念，通常是一个实现了 UserDetails 接口的对象。
  4. Granted Authority（授权权限）：表示用户具有的权限，通常是角色或权限的集合。
  5. Access Control（访问控制）：定义了哪些用户可以访问应用程序的哪些部分以及如何限制对资源的访问。

二、快速入门

  1. 添加 Spring Security 依赖项：首先，在 Spring Boot 项目中添加 Spring Security 的依赖项。

    <dependencies>
  <!-- Spring Boot Web Starter 依赖，包含了开发 web 应用所需的所有基础依赖 -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>

  <!-- Spring Boot Security Starter 依赖，包含了开发安全应用所需的所有基础依赖 -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
  </dependency>
</dependencies>

<dependencyManagement>
  <dependencies>
    <!-- Spring Boot Dependencies POM，用于管理 Spring Boot 项目的所有依赖的版本 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-dependencies</artifactId>
      <version>2.7.5</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

  2. 配置安全策略：创建一个配置类来配置 Spring Security 的行为。

    @Configuration
@EnableWebSecurity // 注解启用 Spring Security 的 web 安全支持
public class SecurityConfig {
}

  3. 定义一个访问端点：定义一个测试使用的访问端点

    @RestController
@RequestMapping("/test")
public class TestController {

    @RequestMapping("/hello")
    public String hello() {
        return "hello spring security";
    }
}

  4. 运行应用程序：运行 Spring Boot 应用程序，并尝试访问端点 localhost:8080/test/hello。
    image.png

    默认账号是 user，密码如下图所示：

    image.png

    输入默认账号、密码之后：

    image.png

三、核心功能

3.1 身份验证（Authentication）

Spring Security 提供多种身份验证机制，包括基本认证、表单认证、OAuth、LDAP 等。支持自定义身份验证流程，可以根据应用程序的需求进行定制。开发人员可以根据需要配置请求路径是否需要认证才能访问。例如：

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.authorizeRequests()
        .requestMatchers(new AntPathRequestMatcher("/test/hello")).permitAll() // 允许所有用户访问 "/test/hello" 路径
        .anyRequest().authenticated(); // 表示所有其他的请求都需要经过认证

        return http.build();
    }
}

3.2 授权（Authorization）

Spring Security 可以基于角色（Role-Based Access Control）和权限（Permission-Based Access Control）的访问控制。

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.authorizeRequests()
        // 只有具有 "add" 权限的用户才能访问 "/test/hello" 路径
        .requestMatchers(new AntPathRequestMatcher("/test/hello")).hasAuthority("add");

        return http.build();
    }
}

3.3 漏洞防护（Protection Against Exploits）

Spring Security 可以防范常见的攻击，如跨站点请求伪造（CSRF）、点击劫持等。例如，通过如下配置可开启 CSRF 保护：

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        // 配置跨站请求伪造（CSRF）的保护
        http.csrf();
        return http.build();
    }
}

四、高级功能

4.1 会话管理（Session Management）

Spring Security 提供了会话管理的功能，包括会话超时、并发登录限制、会话固定攻击防护等功能。例如，可以通过如下配置开启并发登录限制：

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.formLogin() // 启用了表单登录
        .and()
        .authorizeRequests().anyRequest().authenticated() // 所有请求都需要经过认证
        .and()
        .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS)) // 设置会话创建策略为无状态，即 Spring Security 不会创建会话
        .sessionManagement().maximumSessions(1).maxSessionsPreventsLogin(true); // 设置每个用户的最大并发会话数为 1，并且当达到最大并发会话数时，阻止新的登录请求

        return http.build();
    }
}

4.2 密码编码（Password Encoding）

Spring Security 提供密码加密和验证机制，确保用户密码的安全性。例如，要使用 BCrypt 加密，只需进行如下配置即可：

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

4.3 基于注解的方法级安全控制

Spring Security 允许在方法上使用注解的方式进行访问控制。

@Secured("ROLE_ADMIN")
public void secureMethod() {
    // 只有具有 ROLE_ADMIN 角色的用户可以访问
}

@PreAuthorize("hasRole('ADMIN')")
public void preAuthorizeMethod() {
    // 在方法调用之前进行授权检查
}

要使用注解的方式，需要使用 @EnableMethodSecurity 注解开启这一功能

@Configuration
@EnableWebSecurity
@EnableMethodSecurity // 开启基于注解的方法级安全控制
public class SecurityConfig {}

除此之外，Spring Security 支持使用表达式语言 (SpEL) 来定义复杂的访问控制规则。

@PreAuthorize("hasRole('ROLE_USER') and #id == principal.id")
public void updateUser(Long id) {
    // 只有具有 ROLE_USER 角色且 id 等于当前用户的 principal.id 的用户可以访问
}

4.4 事件监听

Spring Security 允许监听安全事件，例如登录成功、失败、登出等，以便记录日志或执行其他操作。

@Component
public class AuthenticationEventListener implements ApplicationListener<AuthenticationSuccessEvent> {

    @Override
    public void onApplicationEvent(AuthenticationSuccessEvent event) {
        // 处理认证成功事件
    }
}

五、工作原理

Spring Security 的设计有那么亿点复杂，我们通过分开描述其核心工作流程、认证工作流程、鉴权工作流程来阐述其工作原理。

5.1 核心工作流程

Spring Security 的核心工作流程如下：

  1. 用户发送请求：用户通过浏览器或客户端发送请求到应用程序。
  2. 请求进入过滤器链代理（FilterChainProxy）：所有请求首先进入 FilterChainProxy，它是一个标准的 Servlet 过滤器 (javax.servlet.Filter)。FilterChainProxy 的作用是根据请求的路径（URL）匹配合适的 SecurityFilterChain。
  3. 请求进入安全过滤器链（SecurityFilterChain）：匹配到相应的 SecurityFilterChain 后，请求进入该安全过滤器链。SecurityFilterChain 是由多个安全过滤器（SecurityFilter）组成的序列，每个安全过滤器按顺序处理请求。
  4. 执行安全过滤器（SecurityFilter）：每个安全过滤器 (SecurityFilter) 负责执行特定的安全操作和策略，例如身份认证、授权、会话管理等。
  5. 调用认证管理器（AuthenticationManager）：AuthenticationManager 是 Spring Security 的核心接口之一，负责处理认证请求。在认证过程中，AuthenticationManager 通常会使用 AuthenticationProvider 来进行具体的认证操作。
  6. 返回认证结果：AuthenticationManager 返回认证结果给 SecurityFilter。
  7. 返回过滤器链：认证完成后，SecurityFilter 可能会进行一些额外的安全处理，并将请求继续传递给下一个安全过滤器或者返回给 SecurityFilterChain。
  8. 返回过滤器链代理：处理完所有安全过滤器后，请求最终返回到 FilterChainProxy。
  9. 返回响应：FilterChainProxy 将最终的响应返回给用户，完成整个请求-响应周期。

在这里插入图片描述

FilterChainProxy：

  • 作用：FilterChainProxy 是 Spring Security 中的一个核心组件，它负责管理 Spring Security 中的各种过滤器链。当一个 HTTP 请求到达应用程序时，FilterChainProxy 会将该请求传递给一个或多个 SecurityFilterChain 实例进行处理。如果需要，FilterChainProxy 还可以重定向请求或返回错误信息。
  • 设计目的：FilterChainProxy 的设计目的是提供一个统一的入口点，用于管理和协调 Spring Security 中的所有过滤器链。
  • 例子：假设我们正在开发一个 Web 应用程序，该应用程序有多个端点，如 /public、/user 和 /admin。我们可能希望 /public 端点对所有人开放，/user 端点只对已登录用户开放，而 /admin 端点只对管理员开放。在这种情况下，你可以使用 FilterChainProxy 来管理三个不同的过滤器链，每个过滤器链负责一个特定的端点。

SecurityFilterChain：

  • 作用：SecurityFilterChain 是一个顶层接口。SecurityFilterChain 和 Servlet 中的 FilterChain 一样，同样维护了很多 Filter，这些 Filter 由 Spring Security 提供，每个 Filter 具有不同的职能。
  • 设计目的：SecurityFilterChain 的设计目的是为了支持添加一个或多个 SecurityFilterChain，每个SecurityFilterChain 负责不同的请求（比如依据请求地址进行区分），这样可以为不同的请求设置不同的认证规则。
  • 例子：继续上面的例子，我们可能会为 /public 端点创建一个 SecurityFilterChain，该过滤器链包含一个检查请求是否为 GET 的过滤器。对于 /user 和 /admin 端点，我们可能会创建包含身份验证过滤器的 SecurityFilterChain，该过滤器检查用户是否已登录，并根据用户的角色（用户或管理员）授予相应的权限。

SecurityFilter：

  • 作用：SecurityFilter 是 Spring Security 的过滤器，每个过滤器负责处理特定的安全任务。当请求到达应用程序时，它会依次通过过滤器链中的每个过滤器，直到到达目标资源。在过滤器链中，每个过滤器都可以对请求进行拦截、修改或执行其他操作，以确保应用程序的安全性。
  • 设计目的：SecurityFilter 的设计目的是为了提高 Web 应用程序的安全性、可维护性和可扩展性。
  • 例子：在上述 SecurityFilterChain 中，我们可能会使用多个 SecurityFilter。例如，一个 SecurityFilter 可能会检查请求是否为 GET，另一个 SecurityFilter 可能会检查用户是否已登录，还有一个 SecurityFilter 可能会根据用户的角色授予相应的权限。

AuthenticationManager：

  • 作用：AuthenticationManager 是 Spring Security 中的认证管理器，用来对登录请求进行处理。当处理用户的登录请求时，例如在使用表单登录时，AuthenticationManager 的 authenticate 方法会被调用来处理请求。
  • 设计目的：AuthenticationManager 这个接口的设计目的是对用户的未授信凭据进行认证，认证通过则返回授信状态的凭据，否则将抛出认证异常 AuthenticationException。
  • 例子：当用户尝试登录时，在登录表单中输入用户名和密码，这些凭据将被传递给 AuthenticationManager。AuthenticationManager 会检查这些凭据是否有效。如果凭据有效，AuthenticationManager 将创建一个已认证的 Authentication 对象，该对象包含用户的详细信息和授权。如果凭据无效，AuthenticationManager 将抛出一个异常。

在这里插入图片描述

5.2 认证工作流程

认证是验证用户身份的过程，通常通过用户名和密码、数字证书或生物特征等手段进行。通过 Spring Security 的核心工作流程我们可以知道：Spring Security 具体的认证工作是交由 AuthenticationManager 执行的。

AuthenticationManager 的认证流程如下：

  1. 用户提交凭证：用户向系统提交用户名和密码等凭证信息。
  2. 认证管理器 (AuthenticationManager)：接收到凭证后，AuthenticationManager 负责进行认证。
  3. 认证提供者 (AuthenticationProvider)：AuthenticationManager 调用认证方法，该方法会委托给配置的 AuthenticationProvider（认证提供者）。
  4. 用户详情服务 (UserDetailsService)：认证提供者通过调用 UserDetailsService 加载用户的详细信息，通常是根据用户名加载用户对象。
  5. 用户详情 (UserDetails)：UserDetailsService 返回一个实现了 UserDetails 接口的用户详情对象，其中包含了用户的详细信息和权限。
  6. 创建认证信息 (Authentication)：认证提供者使用 UserDetails 对象创建一个 Authentication 对象，表示成功的认证。
  7. 安全上下文持有者 (SecurityContextHolder)：创建的 Authentication 对象被存储到 SecurityContextHolder 中，以便后续的访问控制和安全操作使用。
  8. 返回认证结果：最终，认证结果以 Authentication 对象的形式返回给用户，表示用户已经成功通过认证。

在这里插入图片描述

Spring Security 的认证流程看似蛮复杂的。其实，它的认证流程和我们常规的认证方式是类似的。

  • AuthenticationManager：不进行具体的认证处理，负责管理多个 AuthenticatonProvider，具体的认证交由能够处理当前认证的 AuthenticationProvider。
  • AuthenticationProvider：进行具体认证，通过调用 UserDetailService 从数据库或者其他地方加载用户信息。之后通过与用户提交的凭证信息进行匹配，若成功则生成 Authentication 对象，表示认证成功，反之，返回认证失败信息。
  • UserDetailsService：它的主要作用是根据用户名加载用户的详细信息。加载的具体逻辑一般由开发人员实现。
  • UserDetails：用于表示用户的基本身份和授权信息（代表一个用户）。
  • Authentication：用于表示用户在系统中的身份认证信息。具体来说，Authentication 接口主要用于封装认证过程中的关键信息，如认证的主体（Principal）、凭证（Credentials）、授权信息（Authorities）等。
  • SecurityContextHolder：主要用于存储和访问当前用户的 Authentication 对象，即表示当前用户身份认证信息的实例。

在这里插入图片描述

5.3 鉴权工作流程

鉴权是在确认用户身份后，决定用户是否有权访问特定资源或执行特定操作的过程。Spring Security 鉴权流程通常是在认证完成之后，即生成了 Authentication 对象之后进行的。其具体流程如下：

  1. AuthorizationFilter 授权过滤器：通过认证的请求被送到 AuthorizationFilter，它是 Spring Security 中的一个过滤器，负责处理所有的请求，并开启鉴权过程。
  2. 获取 Authentication 认证信息：通过 SecurityContextHolder 从当前的安全上下文中获取用户的认证信息 (Authentication)，这包括用户的身份凭证和权限信息。
  3. 调用 AccessDecisionManager 访问决策管理器：AuthorizationFilter 调用 AccessDecisionManager 进行实际的访问决策。AccessDecisionManager 是一个核心组件，负责确定是否允许用户访问请求的资源或操作。AccessDecisionManager 可能会使用多个 AccessDecisionVoter 进行投票。AccessDecisionVoter 是决策的实际执行者，根据用户的认证信息和访问请求，投票是否允许访问资源或执行操作。
  4. 返回投票结果：每个 AccessDecisionVoter 根据自身的逻辑判断是否允许访问。投票结果将汇总给 AccessDecisionManager。
  5. 返回访问决策结果：AccessDecisionManager 将所有 AccessDecisionVoter 的投票结果综合起来，最终决定是否允许用户访问请求的资源或操作。
  6. 返回响应：AuthorizationFilter 将处理的结果返回给用户，响应用户的请求，这可能包括成功的访问授权或者拒绝访问的信息。

在这里插入图片描述

其实，鉴权的逻辑还是比较简单的，只是流程比较多，可以概括为：

  1. 首先，AuthorizationFilter 获取登录用户的认证信息（Authentication）
  2. 然后，AuthorizationFilter 调用 AccessDecisionManager 判断权限

六、前后端分离

在之前的快速入门中，我们发现 Spring Security 默认情况下是采用前后端不分离的方式进行认证，而现在我们的项目一般都是前后端分离的方式（即： 前端通过 RESTful API 与后端进行通信，后端负责处理认证和授权，而前端则通过获取后端返回的 JWT（JSON Web Token）来管理用户的身份验证和授权状态）。要实现这一需求，我们可以参考如下步骤：

  1. 添加依赖：首先，在 pom.xml 文件中添加 Spring Security 和 JWT 的依赖：

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

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

  <!-- JWT 依赖 -->
  <dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version> <!-- 根据需要选择合适的版本 -->
  </dependency>
</dependencies>

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-dependencies</artifactId>
      <version>2.7.5</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

  2. 创建用户服务实现类：创建一个实现 UserDetailsService 接口的服务类，用于从数据库加载用户信息，并将其返回给 Spring Security 进行认证和授权。

    @Service
public class UserDetailsServiceImpl implements UserDetailsService {

    // 模拟从数据库中查找用户
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 检查传入的用户名是否为"zs"
        if (!"zs".equals(username)) {
            // 如果用户名不是"zs"，返回 null，表示没有找到对应的用户
            return null;
        }

        // 创建并返回一个 UserDetails 对象，表示用户的详细信息
        return User.builder()
                .username("zs") // 设置用户名为"zs"
                .password("$2a$16$RBoXNEqVxxtZ5l1QrJaMPub32Z8Q/e01tIG1Irs9ThxfXgeWxV1jq") // 设置加密后的密码
                .authorities("add") // 设置用户的权限为"add"
                .build();
    }
}

  3. 创建 JWT 工具类： 创建一个 JWT 工具类来生成和验证 JWT。

    @Component
public class JwtUtil {

    @Value("${jwt.secret}")
    private String secret;

    @Value("${jwt.expiration}")
    private long expiration;

    // 从令牌中提取用户名
    public String extractUsername(String token) {
        return extractClaim(token, Claims::getSubject);
    }

    // 从令牌中提取过期时间
    public Date extractExpiration(String token) {
        return extractClaim(token, Claims::getExpiration);
    }

    // 提取令牌中的声明
    public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = extractAllClaims(token);
        return claimsResolver.apply(claims);
    }

    // 解析令牌
    private Claims extractAllClaims(String token) {
        return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
    }

    // 验证令牌是否过期
    private Boolean isTokenExpired(String token) {
        return extractExpiration(token).before(new Date());
    }

    // 生成令牌
    public String generateToken(UserDetails userDetails) {
        return Jwts.builder()
        .setSubject(userDetails.getUsername())
        .setIssuedAt(new Date())
        .setExpiration(new Date(System.currentTimeMillis() + expiration * 1000))
        .signWith(SignatureAlgorithm.HS256, secret)
        .compact();
    }

    // 验证令牌
    public Boolean validateToken(String token, UserDetails userDetails) {
        final String username = extractUsername(token);
        return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
    }
}

  4. 配置 JWT 相关属性：在 application.properties 或 application.yml 中配置 JWT 的密钥和过期时间：

    jwt: # 配置JWT相关的属性
  secret: secretKey # 用于签名和验证JWT令牌的密钥
  expiration: 86400 # JWT令牌的有效期，以秒为单位。这里设置为86400秒（即24小时）

  5. 创建 JWT 认证过滤器：创建一个 JWT 认证过滤器来拦截每个请求，并验证 JWT。

    // 这个类继承自 OncePerRequestFilter，确保在每次请求时只调用一次过滤器
@Component
public class JwtRequestFilter extends OncePerRequestFilter {

    // 注入JwtUtil工具类
    @Resource
    private JwtUtil jwtUtil;

    // 注入UserDetailsServiceImpl类，用于加载用户详细信息
    @Resource
    private UserDetailsServiceImpl userDetailsService;

    // 重写OncePerRequestFilter的doFilterInternal方法，用于处理每个HTTP请求
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
    throws ServletException, IOException {

        // 从请求头中获取Authorization信息
        final String authorizationHeader = request.getHeader("Authorization");

        // 初始化用户名和JWT令牌变量
        String username = null;
        String jwt = null;

        // 检查Authorization头是否以"Bearer "开头
        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            // 提取JWT令牌（去掉"Bearer "部分）
            jwt = authorizationHeader.substring(7);
            // 使用jwtUtil从令牌中提取用户名
            username = jwtUtil.extractUsername(jwt);
        }

        // 如果用户名存在且当前没有已认证的用户
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            // 加载用户详细信息
            UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);

            // 验证JWT令牌
            if (jwtUtil.validateToken(jwt, userDetails)) {
                // 创建UsernamePasswordAuthenticationToken对象，包含用户详细信息和权限
                UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken =
                new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                // 将认证信息设置到SecurityContextHolder中
                SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
            }
        }

        // 继续过滤链，处理下一个过滤器或目标资源
        chain.doFilter(request, response);
    }
}

  6. 配置 Spring Security：开启 Spring Security 验证，配置 SecurityFilterChain。

    @Configuration
@EnableWebSecurity
public class SecurityConfig {

    // 注入JwtRequestFilter对象，用于处理JWT认证
    @Resource
    private JwtRequestFilter jwtRequestFilter;

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.csrf().disable() // 禁用CSRF保护
                .authorizeRequests() // 配置请求授权
                .antMatchers("/login").permitAll() // 对于"/login"路径，允许所有请求（无需认证）
                .anyRequest().authenticated() // 对于所有其他请求，需要认证
                .and()
                // 在UsernamePasswordAuthenticationFilter之前添加JwtRequestFilter
                .addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);

        return http.build();
    }

    @Bean
    public AuthenticationManager authenticationManager(
            UserDetailsService userDetailsService,
            PasswordEncoder passwordEncoder) {

        // 创建一个DaoAuthenticationProvider
        DaoAuthenticationProvider authenticationProvider = new DaoAuthenticationProvider();
       
        // 设置UserDetailsService
        authenticationProvider.setUserDetailsService(userDetailsService);
        
        // 设置PasswordEncoder
        authenticationProvider.setPasswordEncoder(passwordEncoder);

        // 返回包含这个认证提供者的ProviderManager
        return new ProviderManager(authenticationProvider);
    }

    @Bean
    public BCryptPasswordEncoder passwordEncoder() {
        // 创建一个强度为16的BCryptPasswordEncoder
        return new BCryptPasswordEncoder(16);
    }
}

  7. 创建认证接口和控制器：创建一个认证控制器来处理用户登录请求，并返回 JWT 给前端。

    @RestController
public class AuthController {

    @Resource
    private AuthenticationManager authenticationManager;

    @Resource
    private JwtUtil jwtUtil;

    @Resource
    private UserDetailsServiceImpl userDetailsService;

    @PostMapping("/login")
    public ResponseEntity<String> createAuthenticationToken(@RequestBody LoginRequest loginRequest) {
        // 创建一个未认证的UsernamePasswordAuthenticationToken对象
        UsernamePasswordAuthenticationToken authenticationToken =
                UsernamePasswordAuthenticationToken.unauthenticated(loginRequest.getUsername(), loginRequest.getPassword());

        // 调用AuthenticationManager的authenticate方法进行用户认证
        authenticationManager.authenticate(authenticationToken);

        // 加载用户详细信息
        UserDetails userDetails = userDetailsService.loadUserByUsername(loginRequest.getUsername());

        // 生成JWT令牌
        String jwt = jwtUtil.generateToken(userDetails);

        // 返回包含JWT令牌的响应
        return ResponseEntity.ok(jwt);
    }
}

  8. 测试效果

    首先，访问 localhost:8080/login 获取到 token

    image.png

    然后，使用 token 访问 localhost:8080/test/hello

    image.png

七、小结

Spring Security 提供了强大而灵活的安全解决方案，可以轻松集成到 Spring 应用程序中。但是我们不难发现 Spring Security 设计得确实复杂了那么亿点点 (¬‿¬)。Spring Security 的使用门槛虽然较高，但是如果明白了它的原理便可以无缝与 Spring 结合使用，在日常的开发中可以极大的提高开发效率，增强应用的安全性。

推荐阅读

  1. 深入探究 Spring Boot Starter：从概念到实践
  2. 深入理解 Java 中的 volatile 关键字
  3. OAuth 2.0：现代应用程序的授权标准
  4. Spring 三级缓存
  5. 深入了解 MyBatis 插件：定制化你的持久层框架
DC1020
关注
  • 24
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
okta-spring-boot-authz-server-example：Spring Security OAuth 2.0指南
01-31
Spring Security OAuth 2.0指南本示例显示了如何使用Spring Security和OAuth 2.0创建授权服务器。 请阅读获取指导教程，向您展示如何在此存储库中构建应用程序。 先决条件： 。 具有身份验证和用户管理API，可通过...
Spring Security 基本介绍及基础项目搭建
一个菜鸡的博客
05-16 1万+
Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的 成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方 案。正如你可能知道的关于安全方面的两个主要区域是“认证”和“授权”（或者访问控 制），一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权 （Authorization）两个部分，这两点也是 Spring Security 重要核心功能。
Spring Security详解
JAVA_KX的博客
05-15 2万+
AuthenticationManager进行认证时，将该认证管理器中的所有认证提供器遍历一遍，遍历过程中，首先检测认证提供器是否支持认证的票据类型，如果支持，则认证提供器开始进行认证。用于处理基于表单的登录请求，从表单中获取用户名和密码，默认情况下处理来自/login的请求，从表单中获取用户名和密码， 默认使用表单name值为username和password，这两个值可以通过这个过滤器的usernaemparamter个passwordParameter连个参数的值进行修改。
SpringSecurity详细解读与应用
最新发布
CTZL123456的博客
06-19 569
执行完loadUserByUsername后会返回数据库的用户密码，此信息会经过PasswordEncode类，和用户输入的密码来进行校验，但是原生的PasswordEncode比较糟糕(略)，所以我们在配置中修改一下PasswordEncode的校验方式，使用 BCrypt。通常，我们习惯于将原生的用户认证修改为基于数据库字段的(例如username和password)进行登录校验的业务逻辑，这就需要我们进入Secuirty的认证流程中，修改源代码来解决。二、代码实现-用户认证。
Spring Security 详解
热门推荐
qq_22075913的博客
06-06 11万+
​ Spring Security 是 Spring家族中的一个安全管理框架。相比与另外一个安全框架Shiro，它提供了更丰富的功能，社区资源也比Shiro丰富。一般来说中大型的项目都是使用SpringSecurity来做安全框架。小项目有Shiro的比较多，因为相比与SpringSecurity，Shiro的上手更加的简单。​ 一般Web应用的需要进行认证和授权。​ 而认证和授权也是SpringSecurity作为安全框架的核心功能。视频地址：​ 我们先要搭建一个简单的SpringBoot工程① 设置父工
SpringSecurity 微服务权限方案
qq_45834459的博客
11-19 4005
1.什么是微服务 1.1微服务由来： 微服务最早由 Martin Fowler 与 James Lewis 于 2014 年共同提出，微服务架构风格是一种使用一套小服务来开发单个应用的方式途径，每个服务运行在自己的进程中，并使用轻量级机制通信，通常是 HTTP API，这些服务基于业务能力构建，并能够通过自动化部署机制来独立部署，这些服务使用不同的编程语言实现，以及不同数据存储技术，并保持最低限度的集中式管理。 1.2微服务优势： （1）微服务每个模块就相当于一个单独的项目，代码量明显减少，遇到问题也相对来
跟着燕青学Spring Security认证授权05--Spring Security快速入门
传智燕青
10-09 1213
1 Spring Security介绍 Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。由于它是Spring生态系统中的一员，因此它伴随着整个Spring生态系统不断修正、升级，在spring boot项目中加入spring security更是十分简单，使用Spring Security 减少了为企业系统安全控制编写大量重复代码...
SpringSecurity超详细入门介绍
波波烤鸭的博客
12-02 2万+
  权限管理是我们项目中必不可少的一环，实际项目中我们可以自己设计权限管理模块，也可以使用市面上成熟的权限管理框架，比如 shiro或者 SpringSecurity等，前面已经详细的介绍过了 shiro 的使用，本文开始就给大家详细的来介绍下SpringSecurity的使用。 内容包括 spring+springmvc基于配置的方式详细介绍SpringSecurity springboot整...
top-spring-security-architecture:Spring安全架构
05-13
标签专案安全Spring安全了解Spring安全性目录本指南是Spring Security的入门，它提供了对该框架的设计和基本构建块的见解。 我们仅介绍应用程序安全性的最基础知识。 但是，这样做可以消除使用Spring Security的开发...
spring-security-xml:Spring安全演示
05-11
《Spring Security XML：深入解析与实战指南》 Spring Security是一个强大的、高度可配置的安全框架，专为Java应用程序设计，提供...在实际项目中，根据需求调整和优化这些配置，能够构建出强大且安全的Spring应用。
ssc-brewery:Spring安全核心啤酒厂
03-12
总的来说，"ssc-brewery"项目是一个综合性的学习资源，它通过一个实际的应用场景展示了如何使用Spring MVC、Spring Boot和Spring Security等技术来构建安全、高效的Web应用。通过分析和实践这个项目，开发者可以深入...
springsecurity详解
baidu_37366055的博客
11-23 9万+
1.springsecurity springsecurity底层实现为一条过滤器链，就是用户请求进来，判断有没有请求的权限，抛出异常，重定向跳转。 2.登录页 springsecurity自带一个登录页。 从登陆入手，登录页替换成我们自己的，对输入的账号密码进行验证 /** * 表单登陆security * 安全 = 认证 + 授权 */ @Configuration public class SecurityConfig extends WebSecurityConfigur
SpringSecurity
iiiis的博客
08-31 1078
::: tip SpringSecurity是什么Spring Security是一个功能强大且高度可定制的身份验证和访问控制框架。Spring Security致力于为Java应用程序提供身份验证和授权的能力。像所有Spring项目一样，Spring Security的真正强大之处在于它可以轻松扩展以满足定制需求的能力。::: 2.创建接口 3.访问接口 ​ 2.通过创建配置类实现设置 3.编写自定义实现类（常用） 第一步：编写UserDetailsService实现类，可以从数据库中获取用户
spring security详解
wumingdu1234的博客
07-15 6992
1.概要 Spring是非常流行和成功的Java应用开发框架，SpringSecurity正是Spring家族中的成员。SpringSecurity基于Spring框架，提供了一套Web应用安全性的完整解决方案。正如你可能知道的关于安全方面的两个主要区域是“认证”和“授权”（或者访问控制），一般来说，Web应用的安全性包括用户认证（Authentication）和用户授权（Authorization）两个部分，这两点也是SpringSecurity重要核心功能。 （1）用户认证指的是：验证某个用户是否为系统
SpringSecurity详解
m0_71012114的博客
10-19 4992
本文详解介绍了security原理、多种方式配置登录、角色和权限访问控制、常用注解、用户注销。
SpringSecurity 总结
qq_45525848的博客
06-10 4760
Spring Security 总结
SpringSecurity安全框架学习笔记
清茶淡粥的博客
12-31 588
Spring Security Spring Security简介 Spring Security 是一种高度自定义的安全框架，利用（基于）SpringIOC/DI和AOP功能，为系统提供了声明式安全访问控制功能，减少了为系统安全而编写大量重复代码的工作。 核心功能：认证和授权 Spring Security 认证流程 Spring Security 项目搭建 导入依赖 Spring Security已经被Spring boot进行集成，使用时直接引入启动器即可 <dependency>
狂神说SpringBoot18：集成SpringSecurity
狂神说
03-29 1万+
狂神说SpringBoot系列连载课程，通俗易懂，基于SpringBoot2.2.5版本，欢迎各位狂粉转发关注学习。未经作者授权，禁止转载SpringSecurity安全简介在 Web ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值