乐趣区

关于java:深入理解Spring-Security

jiezi

第 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 服务替换获取拜访令牌，最终容许用户拜访申请的资源。

退出移动版