关于java:深入理解Spring-Security

50次阅读

共计 13335 个字符，预计需要花费 34 分钟才能阅读完成。

第 1 章：Spring Security 简介

大家好，我是小黑，在谈到网站平安的时候，Spring Security 是个避不开的话题。它就像是个守门员，决定谁能进入咱们的网站，又能在网站的哪些角落里走动。简略来说，Spring Security 负责两大块：认证（Authentication）和受权（Authorization）。认证是确认咱们的身份，受权则是决定咱们能做什么、不能做什么。

设想一下，小黑正在尝试进入一个只有 VIP 成员能力拜访的网站区域。Spring Security 首先会查看小黑是不是网站的注册用户，这就是认证。一旦确认小黑的确是谁他说的那个人，接下来就要看看小黑有没有 VIP 的权限，这就是受权的过程了。

这套机制听起来是不是很像生存中的例子？比方，咱们进入一家公司，须要先通过门卫的身份验证，而后能力依据本人的身份证进入相应的办公区域。Spring Security 就是在软件里，为应用程序提供这样一道爱护屏障。

Spring Security 的弱小之处还在于它的灵活性和扩展性。不论是对于简略的集体博客，还是简单的企业零碎，它都能提供强有力的平安保障。而且，Spring Security 反对多种认证形式，比方表单登录、LDAP、OAuth2 等，简直能够满足所有的平安需要。

第 2 章：认证与受权根底

谈到 Spring Security，咱们不能不提它的两大外围：认证和受权。这两者听起来很简略，但要做好，细节是要害。

认证，就是确认请求者的身份。在 Spring Security 中，这个过程通常是通过 AuthenticationManager 来实现的。它会应用一系列的 AuthenticationProvider，每个 Provider 都尝试认证用户提交的信息。如果认证胜利，用户的详情就会被保留在SecurityContextHolder 中，不便后续操作应用。

import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;

// 创立一个用户的认证令牌
Authentication request = new UsernamePasswordAuthenticationToken("小黑的用户名", "小黑的明码");
// 通过 AuthenticationManager 验证用户的认证信息
Authentication result = authenticationManager.authenticate(request);
// 认证胜利后，将用户信息保留到 SecurityContextHolder
SecurityContextHolder.getContext().setAuthentication(result);

受权，则是决定认证通过的用户能做什么。在 Spring Security 中，这通常是通过定义一系列的权限规定来实现的。比方，咱们能够定义某个 API 接口只容许领有 ADMIN 角色的用户拜访。

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;

@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/admin/**").hasRole("ADMIN") // 只有 ADMIN 角色的用户能力拜访 /admin/** 门路
            .anyRequest().authenticated(); // 其余所有申请都须要认证
    }
}

通过这两段代码，咱们能够看到 Spring Security 在认证和受权上的根本应用。但真正的魅力在于它的灵活性和扩展性，无论是简略的身份验证，还是简单的权限管制，Spring Security 都能轻松应答。

第 3 章：配置 Spring Security

配置 Spring Security 可能听起来有点儿头疼，但别放心，小黑来带咱们一步步搞定它。要让 Spring Security 为咱们的利用站岗放哨，首先得让它晓得咱们的规定。这就像是通知守门员，哪些人能够进来，哪些人须要验证，哪些区域是禁止进入的。

引入 Spring Security

在开始配置之前，确保咱们的我的项目中曾经退出了 Spring Security 的依赖。如果是用 Spring Boot，那几乎不能更简略，只须要在 pom.xml 文件中退出上面这段：

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

这行代码就像是给咱们的我的项目装上了一个平安套件，Spring Boot 会主动配置很多货色，但咱们还须要依据本人的需要做一些调整。

根本的 HTTP 平安配置

Spring Security 的魅力之一就在于它的灵活性，咱们能够轻松定义哪些门路须要认证，哪些不须要。来看看上面这段根底配置：

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;

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests() // 开始定义哪些 URL 须要被爱护、哪些不须要
            .antMatchers("/", "/home").permitAll() // 定义不须要认证就能够拜访的门路
            .anyRequest().authenticated() // 任何申请, 登录后能够拜访
            .and()
            .formLogin() // 定义当须要用户登录时候，转到的登录页面
            .loginPage("/login") // 设置登录页面
            .permitAll() // 登录页面用户任意拜访
            .and()
            .logout() // 默认登记行为为 logout，能够通过 logoutUrl()定制
            .permitAll(); // 登记行为任意拜访}
}

这段代码其实就是在说：“听着，Spring Security，首页和 home 页面谁都能够轻易进，但如果想要拜访其余页面，用户得登录。哦，对了，登录页面设置在 /login 这里，别忘了所有人都能够拜访登录和登记页面。”

自定义用户认证

默认状况下，Spring Security 会提供一个用户进行认证，但这通常不符合实际需要。咱们通常须要从数据库或其余中央读取用户信息。这时，就须要自定义 UserDetailsService 了：

import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.stereotype.Service;

import java.util.Collections;

@Service
public class MyUserDetailsService implements UserDetailsService {

    @Override
    public User loadUserByUsername(String username) throws UsernameNotFoundException {
        // 假如这里调用数据库，依据用户名找到用户
        // 为了示例简略，间接创立一个用户
        return new User("小黑", "{noop}password", Collections.singletonList(new SimpleGrantedAuthority("ROLE_USER")));
    }
}

这段代码就是自定义的用户服务，它通知 Spring Security 应用咱们提供的形式来加载用户信息。留神这里的 {noop} 前缀，它是通知 Spring Security 这个明码没有加密，这样做只是为了示例简略，在理论我的项目中强烈建议应用明码加密。

第 4 章：深刻了解 Spring Security 认证流程

了解 Spring Security 的认证流程就像是拆解一个精细的时钟，看看外面的齿轮是如何协同工作的。这个过程可能有点简单，但别放心，小黑在这里帮咱们一步步拆解，让这个简单的机制变得简略易懂。

认证流程概览

在深刻代码之前，咱们先来理解一下 Spring Security 认证流程的大抵轮廓。用户提交用户名和明码后，这个信息首先会被一个叫做 AuthenticationFilter 的货色拦挡。这个过滤器的工作就是收集认证信息并将其传递给AuthenticationManager，后者则是真正的认证大脑，负责查看这个用户是否真的是他宣称的那个人。

如果认证胜利，AuthenticationManager就会返回一个充斥用户详情和权限信息的 Authentication 对象，标记着用户胜利登录。但如果失败，则会抛出异样，告知用户认证失败的起因。

代码实现认证流程

接下来，让咱们看看这个过程在代码层面是如何实现的。假如咱们想要自定义一个认证过滤器来解决 JSON 格局的登录申请：

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import javax.servlet.FilterChain;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.util.Collections;

public class CustomAuthenticationFilter extends UsernamePasswordAuthenticationFilter {

    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        try {
            // 从申请中读取用户名和明码
            BufferedReader reader = request.getReader();
            StringBuilder sb = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {sb.append(line);
            }
            LoginRequest loginRequest = new ObjectMapper().readValue(sb.toString(), LoginRequest.class);
            UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(loginRequest.getUsername(), loginRequest.getPassword(), Collections.emptyList());
            // 容许子类设置具体属性
            setDetails(request, authRequest);
            // 运行 AuthenticationManager 认证用户
            return this.getAuthenticationManager().authenticate(authRequest);
        } catch (Exception e) {throw new RuntimeException(e);
        }
    }
    
    // 须要定义一个 LoginRequest 类来匹配 JSON 中的字段
    static class LoginRequest {
        private String username;
        private String password;
        // getter 和 setter 省略
    }
}

这段代码定义了一个自定义的认证过滤器 CustomAuthenticationFilter，它继承自UsernamePasswordAuthenticationFilter，次要改写了attemptAuthentication 办法，使其可能解决 JSON 格局的登录申请。这个办法首先从 HTTP 申请中解析出用户名和明码，而后创立一个 UsernamePasswordAuthenticationToken 对象，并通过 AuthenticationManager 进行认证。

认证胜利与失败的解决

认证胜利后，通常须要将一些信息返回给用户，比方 JWT 令牌或者其余的认证信息。同样，如果认证失败，咱们也须要正当解决，比方返回一个谬误音讯。

在 CustomAuthenticationFilter 中，咱们能够重写 successfulAuthentication 和unsuccessfulAuthentication办法来自定义这些行为：

@Override
protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) {// 认证胜利后的逻辑，比方生成 JWT 令牌，返回给客户端}

@Override
protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed) throws IOException, ServletException {
    // 认证失败的逻辑，比方返回一个谬误音讯
    response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
    response.getWriter().write("认证失败，起因：" + failed.getMessage());
}

通过这些自定义的逻辑，咱们能够管制认证胜利或失败后的行为，进步用户体验。

了解和实现 Spring Security 的认证流程是爱护咱们利用平安的关键步骤。通过自定义认证过滤器和成功失败解决逻辑，咱们能够依据利用的特定需要灵便地实现认证机制。心愿通过本章的解说，咱们对 Spring Security 的认证流程有了更深刻的了解。

第 5 章：摸索 Spring Security 受权过程

受权流程概览

受权，简略来说，就是确定一个已认证的用户是否有权限进行某个操作。在 Spring Security 中，这通常波及到两个要害概念：角色（Roles）和权限（Authorities）。角色通常代表了用户的身份，比方 ” 管理员 ” 或 ” 普通用户 ”，而权限则更细粒度，示意用户能执行的具体操作，比方 ” 读取数据 ” 或 ” 批改数据 ”。

当申请达到利用时，Spring Security 会查看与申请相干的平安配置，确定执行该申请须要哪些权限。而后，它会查看以后用户是否具备这些权限，如果满足条件，则容许操作；如果不满足，则回绝拜访。

代码实现受权配置

让咱们看看如何在 Spring Security 中配置这些规定。假如小黑想要创立一个简略的 Web 利用，其中蕴含三个局部：首页（所有人可见）、用户信息页（仅登录用户可见）和管理员页面（仅管理员可见）。

import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/").permitAll() // 首页所有人都能够拜访
            .antMatchers("/user/**").hasRole("USER") // 用户信息页仅限角色为 USER 的用户拜访
            .antMatchers("/admin/**").hasAuthority("ROLE_ADMIN") // 管理员页面仅限领有 ADMIN 权限的用户拜访
            .anyRequest().authenticated(); // 除了上述门路外，其余所有申请都须要认证
    }
}

在这段代码中，小黑通过 authorizeRequests() 办法和一系列的 antMatchers() 办法调用，定义了不同 URL 模式所需的权限。这样，Spring Security 就能依据配置，管制对不同局部的拜访。

深刻了解权限查看

当一个申请达到时，Spring Security 会评估与该申请相干的所有配置规定，决定是否容许拜访。这个过程不仅波及到了用户的角色和权限，还可能包含其余的平安束缚，比方申请的起源 IP 地址。

为了更深刻地了解这个过程，咱们能够看一个更简单的例子，比方基于办法的安全性：

import org.springframework.security.access.prepost.PreAuthorize;

public class UserService {@PreAuthorize("hasRole('ADMIN')")
    public void deleteUser(Long userId) {// 删除用户的代码逻辑}
}

在这个例子中，deleteUser办法被 @PreAuthorize 注解润饰，这意味着只有领有 ADMIN 角色的用户能力调用此办法。Spring Security 会在办法调用之前查看以后用户是否合乎给定的条件。

第 6 章：深刻 JWT 与 Spring Security 整合

在明天的网络里，爱护咱们的利用平安变得越来越重要。好在，有了像 JSON Web Token（JWT）这样的技术，能帮忙咱们在客户端和服务器之间平安地传递信息。这一章节，小黑要带咱们深刻理解 JWT 是什么，以及如何在 Spring Security 中应用 JWT 来实现无状态的认证机制。

JWT 简介

JWT 是一个凋谢规范（RFC 7519），它定义了一种紧凑且自蕴含的形式，用于在各方之间平安地传输信息。一个 JWT 实际上就是一个被编码的 JSON 对象，蕴含了一系列申明。这些申明能够被用来传递用户身份信息，或者任何其余数据。

JWT 通常由三局部组成：头部（Header）、载荷（Payload）和签名（Signature）。头部蕴含了令牌的类型和所应用的算法；载荷蕴含了一系列申明；签名则用于验证音讯的真实性和完整性。

在 Spring Security 中应用 JWT

要在 Spring Security 中应用 JWT，咱们须要进行几个步骤的配置。首先，咱们要增加一个过滤器来解析每个申请中的 JWT，而后创立一个自定义的认证令牌，并将其传递给 Spring Security 的认证管理器。

让咱们通过代码来具体看看这个过程：

import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.filter.GenericFilterBean;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.IOException;

public class JwtTokenFilter extends GenericFilterBean {

    private JwtTokenProvider jwtTokenProvider;

    // 构造函数
    public JwtTokenFilter(JwtTokenProvider jwtTokenProvider) {this.jwtTokenProvider = jwtTokenProvider;}

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {String token = jwtTokenProvider.resolveToken((HttpServletRequest) request);
        if (token != null && jwtTokenProvider.validateToken(token)) {Authentication auth = jwtTokenProvider.getAuthentication(token);
            SecurityContextHolder.getContext().setAuthentication(auth);
        }
        chain.doFilter(request, response);
    }
}

在这段代码里，小黑创立了一个 JwtTokenFilter，它继承自GenericFilterBean。这个过滤器的工作是解析申请中的 JWT，验证它，而后创立一个UsernamePasswordAuthenticationToken，最初将其设置到SecurityContextHolder 中。这样，Spring Security 就能应用这个令牌来实现认证过程。

JWT 的验证和生成

为了生成和验证 JWT，咱们须要一个 JwtTokenProvider 类。这个类会解决 JWT 的生成、验证以及从申请中解析 JWT 的逻辑。

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

public class JwtTokenProvider {

    private String secretKey = "秘钥"; // 理论利用中应该更简单，且存储在平安的中央

    // 生成 JWT
    public String createToken(String username, List<String> roles) {Claims claims = Jwts.claims().setSubject(username);
        claims.put("roles", roles);

        Date now = new Date();
        Date validity = new Date(now.getTime() + 3600000); // 设置过期工夫为 1 小时

        return Jwts.builder()
                .setClaims(claims)
                .setIssuedAt(now)
                .setExpiration(validity)
                .signWith(SignatureAlgorithm.HS256, secretKey)
                .compact();}

    // 从申请中获取 JWT
    public String resolveToken(HttpServletRequest request) {String bearerToken = request.getHeader("Authorization");
        if (bearerToken != null && bearerToken.startsWith("Bearer")) {return bearerToken.substring(7);
        }
        return null;
    }

    // 验证 JWT 的有效性
    public boolean validateToken(String token) {
        try {Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token);
            return true;
        } catch (JwtException | IllegalArgumentException e) {throw new CustomException("Expired or invalid JWT token", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
}

在这个类中，createToken办法用于生成 JWT，resolveToken从 HTTP 申请中解析出 JWT，而 validateToken 则负责验证 JWT 的有效性。通过这些办法，小黑可能在 Spring Security 中灵便地应用 JWT 进行认证。

第 7 章：OAuth 2.0 与 Spring Security 的完满搭档

在古代应用程序中，OAuth 2.0 已成为实现受权和认证的金规范。这一章节，小黑将带咱们一探到底，看看 OAuth 2.0 是如何在 Spring Security 中发挥作用的，以及如何通过一个理论的例子来实现它。

OAuth 2.0 概述

OAuth 2.0 是一个受权框架，容许应用程序获取无限的拜访权限。它次要用于受权第三方利用拜访用户数据，而无需将用户的登录信息裸露给第三方利用。OAuth 2.0 定义了四种受权模式：受权码模式、简化模式、明码模式和客户端凭据模式。在 Spring Security 中，最罕用的是受权码模式，特地是在须要对第三方利用进行平安受权时。

Spring Security 中的 OAuth 2.0

在 Spring Security 中整合 OAuth 2.0，意味着咱们能够让用户通过第三方服务（如 Google、Facebook 等）来认证，而无需在本人的零碎中解决登录逻辑。这不仅进步了安全性，还为用户提供了便当。

让咱们看看如何通过 Spring Boot 和 Spring Security 来实现 OAuth 2.0 认证：

  1. 依赖配置

首先，确保咱们的 pom.xml 中蕴含了 Spring Security 和 OAuth2 客户端的依赖。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-oauth2-client</artifactId>
    </dependency>
</dependencies>
  1. 配置 OAuth 2.0

接下来，在application.yml（或application.properties）中配置 OAuth 2.0 客户端。

spring:
  security:
    oauth2:
      client:
        registration:
          google:
            clientId: 你的 Google 客户端 ID
            clientSecret: 你的 Google 客户端秘钥
            redirectUri: "{baseUrl}/login/oauth2/code/{registrationId}"
            scope: profile, email

这段配置定义了一个 Google OAuth 2.0 客户端，包含客户端 ID、秘钥以及重定向 URI。这些信息须要从 Google Cloud Console 获取。

  1. 平安配置

在 Spring Security 配置类中，咱们须要配置哪些门路须要平安爱护，哪些不须要。同时，还要配置 OAuth 2.0 登录。

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests(authorizeRequests ->
                authorizeRequests
                    .antMatchers("/", "/home").permitAll() // 容许所有人拜访首页和 /home 门路
                    .anyRequest().authenticated() // 其余所有门路都须要认证
            )
            .oauth2Login(); // 启用 OAuth 2.0 登录}
}

通过这段配置，小黑通知 Spring Security 哪些申请是公开的，哪些须要通过 OAuth 2.0 登录后能力拜访。

应用 OAuth 2.0 进行认证

一旦配置实现，咱们的利用就可能解决通过 Google 等提供的 OAuth 2.0 服务进行认证的申请了。用户在拜访受爱护的资源时会被重定向到第三方服务（如 Google）的登录页面，实现认证后，会重定向回咱们的利用，并携带一个受权码。Spring Security 会解决这个受权码，与 OAuth 2.0 服务替换获取拜访令牌，最终容许用户拜访申请的资源。

正文完
java
发表至： java
2024-02-28
 0
关于java:领域驱动实践总结基本理论总结与分析架构分析与代码设计具体应用设计分析V
关于java:字节跳动大牛最佳整理582页Android-NDK七大模块学习宝典理论与实践
小师妹学JavaIO之目录还是文件
关于java:Nginx-实现-10w-并发之-Linux-内核优化