SpringSecurity安全框架 ——认证与授权_服务器

AuthenticationManager
：管理身份验证，可以从多种身份验证方案中选择一种。
Authentication
：用于验证用户的身份。
SecurityContextHolder
：用于管理
SecurityContext
的
ThreadLocal
，以便在整个请求上下文中进行访问，方便用户访问。
AccessDecisionManager
：负责对访问受保护的资源的请求进行决策（即决定是否允许用户访问资源）
AccessDecisionVoter
：是AccessDecisionManager的实现组件之一，它用于对用户请求的访问受保护的资源所需要的角色或权限进行投票。
ConfigAttribute
：用于表示受保护资源或URL需要的访问权限，它可以理解为是访问控制策略的一部分

1.3 为什么选择Spring Security

SpringBoot 没有发布之前，Shiro 应用更加广泛，因为 Shiro 是一个强大且易用的 Java 安全框架，能够非常清晰的处理身份验证、授权、管理会话以及密码加密。利用其易于理解的API，可以快速、轻松地获得任何应用程序，从最小的移动应用程序到最大的网络和企业应用程序。但是 Shiro 只是一个框架而已，其中的内容需要自己的去构建，前后是自己的，中间是Shiro帮我们去搭建和配置好的。

SpringBoot

发布后，随着其快速发展，

Spring Security

（前身叫做

Acegi Security

）重新进入人们的视野。

SpringBoot

解决了

Spring Security

各种复杂的配置，

Spring Security

在我们进行用户认证以及授予权限的时候，通过各种各样的拦截器来控制权限的访问，从而实现安全，也就是说

Spring Security

除了不能脱离

Spring

，

Shiro

的功能它都有。

在用户认证方面，
Spring Security
框架支持主流的认证方式，包括 HTTP 基本认证、HTTP 表单验证、HTTP 摘要认证、
OpenID
和
LDAP
等。
在用户授权方面，
Spring Security
提供了基于角色的访问控制和访问控制列表（
Access Control List，ACL
），可以对应用中的领域对象进行细粒度的控制。

Shiro
在这个环境下实际已经不具备优势了。因为Spring这个生态链现在是太强大了。

1.4 HttpSecurity 介绍

HttpSecurity

是

Spring Security

的一个核心类，用于配置应用程序的安全策略。

HttpSecurity

类通常包含许多方法，可以用于配置以下内容：

HTTP 请求的安全策略，例如访问控制、跨站点请求伪造 (CSRF) 防护等。
HTTP 验证的安全策略，例如基于表单、HTTP 基本身份验证、OAuth 等。
访问受保护资源时所需的身份验证和授权方式。

方法	说明
authorizeRequests()	用于配置如何处理请求的授权，默认情况下所有的请求都需要进行认证和授权才能访问受保护的资源
formLogin()	用于配置基于表单的身份验证，包括自定义登录页面、登录请求路径、用户名和密码的参数名称、登录成功和失败的跳转等。
httpBasic()	用于配置基于 HTTP Basic 身份验证，包括定义使用的用户名和密码、 realm 名称等。
logout()	用于配置退出登录功能，包括定义退出登录请求的URL、注销成功后的跳转URL、清除会话、删除 Remember-Me 令牌等。
csrf()	用于配置跨站请求伪造保护，包括定义 CSRF Token 的名称、保存方式、忽略某些请求等。
sessionManagement()	用于配置会话管理，包括定义并发控制、会话失效、禁用URL重定向、会话固定保护等。
rememberMe()	用于配置 Remember-Me 功能，包括定义 Remember-Me 令牌的名称、有效期、加密方法、登录成功后的处理方式等。
exceptionHandling()	用于配置自定义的异常处理，包括定义异常处理器和异常处理页面等。
headers()	用于配置HTTP响应头信息，包括定义 X-Content-Type-Options、X-XSS-Protection、Strict-Transport-Security 等头信息。
cors()	用于配置跨域资源共享，包括定义可访问的来源、 Headers 等。
addFilter()	用于向当前 HttpSecurity 中添加自定义的 Filter 。
and()	用于在配置中添加另一个安全规则，并将两个规则合并。

匹配规则：

URL匹配

方法	说明
requestMatchers()	配置一个 request Mather 数组，参数为 RequestMatcher 对象，其 match 规则自定义,需要的时候放在最前面，对需要匹配的的规则进行自定义与过滤
authorizeRequests()	URL权限配置
antMatchers()	配置一个 request Mather 的 string 数组，参数为 ant 路径格式，直接匹配 url
anyRequest()	匹配任意 url ，无参 ,最好放在最后面

保护URL

方法	说明
authenticated()	保护 Url ，需要用户登录
permitAll()	指定URL无需保护，一般应用与静态资源文件
hasRole(String role)	限制单个角色访问
hasAnyRole(String… roles)	允许多个角色访问
access(String attribute)	该方法使用 SPEL , 所以可以创建复杂的限制
hasIpAddress(String ipaddressExpression)	限制 IP 地址或子网

登录formLogin

方法	说明
loginPage()	设置登录页面的 URL
defaultSuccessUrl()	设置登录成功后的默认跳转页面
failuerHandler()	登录失败之后的处理器
successHandler()	登录成功之后的处理器
failuerUrl()	登录失败之后系统转向的 url ，默认是 this.loginPage + “?error”
loginProcessingUrl()	设置登录请求的 URL，即表单提交的 URL
usernameParameter()	设置登录表单中用户名字段的参数名，默认为 username
passwordParameter()	设置登录表单中密码字段的参数名，默认为 password

登出logout

方法	说明
logoutUrl()	登出 url ，默认是 /logout l
logoutSuccessUrl()	登出成功后跳转的 url 默认是 /login?logout
logoutSuccessHandler()	登出成功处理器，设置后会把 logoutSuccessUrl 置为null

方法

说明

logoutUrl()

登出

url

，默认是

/logout

logoutSuccessUrl()

登出成功后跳转的

url

默认是

/login?logout

logoutSuccessHandler()

登出成功处理器，设置后会把

logoutSuccessUrl

置为null

二、用户认证

2.1 导入依赖与配置

基于

Spring Initializr

创建

SpringBoot

项目（本次案例采用Spring Boot 2.7.12版本为例），导入基本依赖：

        <!--Spring Security-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <!--spring web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- freemarker -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!--mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.32</version>
        </dependency>
        <!--MYSQL 依赖-->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>

spring-boot-starter-security

包含了以下几个主要的依赖：

spring-security-core：
Spring Security
的核心模块，提供了基于权限的访问控制以及其他安全相关功能。
spring-security-config：提供了
Spring Security
的配置实现，例如通过Java配置创建安全策略和配置Token存储等。
spring-security-web：提供了
Spring Security Web
的基本功能，例如
Servlet
集成和通过
HttpSecurity
配置应用程序安全策略。

配置

application.yml

文件：

spring: datasource: type: com.zaxxer.hikari.HikariDataSource driver-class-name: com.mysql.jdbc.Driver username: root password: 123456 url: jdbc:mysql://localhost:3306/bookshop?useUnicode=true&characterEncoding=utf8&useSSL=false freemarker: enabled: true suffix: .ftl template-loader-path: classpath:/templates/ mybatis-plus: # Mybatis Mapper所对应的XML位置 mapper-locations: classpath:mapper/*.xml # 别名包扫描路径 type-aliases-package: com.ycxw.springsecurity.entity # 是否开启自动驼峰命名规则（camel case）映射 configuration: map-underscore-to-camel-case: true global-config: db-config: logic-delete-field: deleted # 全局逻辑删除的实体字段名 logic-delete-value: 1 # 逻辑已删除值(默认为 1) logic-not-delete-value: 0 # 逻辑未删除值(默认为 0) logging: level: com.jun.security01.mapper: debug

2.2 用户对象UserDetails

首先准备一张用户表，通过mybatis-plus生成代码后修改

User类

并实现

UserDetails接口

。

package com.ycxw.springsecurity.entity;import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.Setter;
import lombok.experimental.Accessors;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.List;/**
 * 用户信息表（继承UserDetails类）
 *
 * @author 云村小威
 * @since 2023-12-21
 */
@Getter
@Setter
@Accessors(chain = true)
@TableName("sys_user")
@ApiModel(value = "User对象", description = "用户信息表")
public class User implements Serializable, UserDetails {    private static final long serialVersionUID = 1L;    @ApiModelProperty("唯一标识")
    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;    @ApiModelProperty("用户账号")
    @TableField("username")
    private String username;    @ApiModelProperty("用户密码")
    @TableField("password")
    private String password;    @ApiModelProperty("真实姓名")
    @TableField("real_name")
    private String realName;    @ApiModelProperty("身份z号")
    @TableField("id_card")
    private String idCard;    @ApiModelProperty("性别，男或女")
    @TableField("gender")
    private String gender;    @ApiModelProperty("家庭住址")
    @TableField("address")
    private String address;    @ApiModelProperty("联系电话")
    @TableField("phone")
    private String phone;    @ApiModelProperty("创建时间")
    @TableField("create_date")
    private LocalDateTime createDate;    /**
     * 是否过期
     */
    @TableField("account_non_expired")
    private boolean accountNonExpired;    /**
     * 存放用户的权限（不存放在数据库中）
     */
    @TableField(exist = false)
    private List<GrantedAuthority> authorities;    /**
     * 是否锁定
     */
    @TableField("account_non_locked")
    private boolean accountNonLocked;    /**
     * 是否过期
     */
    @TableField("credentials_non_expired")
    private boolean credentialsNonExpired;    /**
     * 是否启用
     */
    @TableField("enabled")
    private boolean enabled;
}

实现UserDatails接口会重写它的五个方法，如该类最后的五个属性，除authorities属性以外，请将其他四个属性加入数据库表中（原用户表未有该字段，通过实现UserDatails后需要身份验证和授权则要添加）

UserDetails

是Spring Security框架中的一个接口，它代表了应用程序中的用户信息。
UserDetails
接口定义了一组方法，用于获取用户的用户名、密码、角色和权限等信息，以便Spring Security可以使用这些信息进行身份验证和授权。

以下是

UserDetails

接口中定义的方法：

getUsername()
：获取用户的用户名。
getPassword()
：获取用户的密码。
getAuthorities()
：获取用户的角色和权限信息。
isEnabled()
：判断用户是否可用。
isAccountNonExpired()
：判断用户的账号是否过期。
isAccountNonLocked()
：判断用户的账号是否被锁定。
isCredentialsNonExpired()
：判断用户的凭证是否过期。

自定义用户信息时，可以实现

UserDetails

接口并覆盖其中的方法来提供自己的用户信息。

2.3 业务对象UserDetailsService

修改

UserServiceImpl

并实现

UserDetailsService

，重写

loadUserByUsername(String username)

方法。

package com.ycxw.springsecurity.service.impl;import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ycxw.springsecurity.entity.User;
import com.ycxw.springsecurity.mapper.UserMapper;
import com.ycxw.springsecurity.service.IUserService;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;import java.util.Objects;/**
 * 用户信息表 服务实现类
 *
 * @author 云村小威
 * @since 2023-12-21
 */
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService, UserDetailsService {
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 根据用户名查询用户
        User user = getOne(new QueryWrapper<User>().eq("username", username));
        //判断用户是否存在
        if (Objects.isNull(user))
            throw new UsernameNotFoundException("用户不存在");
        return user;
    }}

UserDetailsService

是Spring Security中的一个接口，它用于从特定数据源（如数据库）中获取用户详细信息，以进行身份验证和授权。实现该接口的类需要实现

loadUserByUsername

方法，该方法根据给定的用户名返回一个

UserDetails

对象，该对象包含有关用户的详细信息，例如密码、角色和权限等。在Spring Security中，

UserDetailsService

通常与

DaoAuthenticationProvider

一起使用，后者是一个身份验证提供程序，用于验证用户的凭据。

2.4 SecurityConfig配置

2.4.1 BCryptPasswordEncoder密码编码器

Spring Security提供了多种密码加密方式，大致可以归类于以下几种：

对密码进行明文处理，即不采用任何加密方式；
采用MD5加密方式；
采用哈希算法加密方式；

BCryptPasswordEncoder

是

Spring Security

中一种基于

bcrypt

算法的密码加密方式。

bcrypt

算法是一种密码哈希函数，具有防止彩虹表攻击的优点，因此安全性较高。

使用

BCryptPasswordEncoder

进行密码加密时，可以指定一个随机生成的

salt

值（俗称：加盐），将其与原始密码一起进行哈希计算。salt值可以增加密码的安全性，因为即使两个用户使用相同的密码，由于使用不同的

salt

值进行哈希计算，得到的哈希值也是不同的。

在

Spring Security

中，可以通过在

SecurityConfig

配置类中添加以下代码来使用

BCryptPasswordEncoder

进行密码加密：

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

这样就可以在Spring Security中使用

BCryptPasswordEncoder

进行密码加密了。

相比BCryptPasswordEncoder密码编码器之下明文和MD5加密的缺点是？

明文的缺点：

安全性低： 明文存储密码非常不安全，因为任何有权访问数据库的人都能够看到用户的密码。
容易受到攻击： 明文存储密码很容易受到攻击，例如暴力破解攻击和彩虹表攻击。

MD5 加密的缺点：

安全性低： MD5 算法是一种弱加密算法，很容易被破解。
不可逆： MD5 加密是不可逆的，这意味着无法从哈希值中恢复明文密码。
容易受到碰撞攻击： MD5 算法容易受到碰撞攻击，这意味着可以找到两个不同的输入，它们产生相同的哈希值。（可根据相同加密后的密码找出明文密码）

因此，明文和 MD5 加密都不适合用于保护用户密码。

2.4.2 RememberMe 记住登录信息

在实际开发中，为了用户登录方便常常会启用记住我（

Remember-Me

）功能。如果用户登录时勾选了“记住我”选项，那么在一段有效时间内，会默认自动登录，免去再次输入用户名、密码等登录 *** 作。该功能的实现机理是根据用户登录信息生成

Token

并保存在用户浏览器的

中，当用户需要再次登录时，自动实现校验并建立登录态的一种机制。

Spring Security

提供了两种

Remember-Me

的实现方式：

简单加密
Token
：用散列算法加密用户必要的登录系信息并生成
Token
令牌。
持久化
Token
：数据库等持久性数据存储机制用的持久化
Token
令牌。

rememberMe

主要方法介绍：

方法	说明
rememberMeParameter()	指定在登录时“记住我”的 HTTP 参数，默认为 remember-me
tokenValiditySeconds()	设置 Token 有效期为 200s，默认时长为 2 星期
tokenRepository()	指定 rememberMe 的 token 存储方式，可以使用默认的 PersistentTokenRepository 或自定义的实现
userDetailsService()	指定 UserDetailsService 对象
rememberMeCookieName()	指定 rememberMe 的 cookie 名称

基于持久化Token配置：

Remember-Me

功能的开启需要在

configure(HttpSecurity http)

方法中通过

http.rememberMe()

配置，该配置主要会在过滤器链中添加

RememberMeAuthenticationFilter

过滤器，通过该过滤器实现自动登录。

    // 注入用户服务
    @Autowired
    private UserDetailsService userDetailsService;    @Autowired
    private ObjectMapper objectMapper;    // 注入数据源（spring自带）
    @Resource
    public DataSource dataSource;    // 创建持久令牌存储库
    @Bean
    public PersistentTokenRepository persistentTokenRepository() {
        // 创建一个JdbcTokenRepositoryImpl实例
        JdbcTokenRepositoryImpl tokenRepository = new JdbcTokenRepositoryImpl();
        // 设置数据源
        tokenRepository.setDataSource(dataSource);
        // 设置启动时创建表
        tokenRepository.setCreateTableOnStartup(false);
        // 返回tokenRepository
        return tokenRepository;
    }    /*
     * 安全过滤器链
     * */
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.authorizeRequests().antMatchers("/").permitAll()
                // 设置角色权限
                //.antMatchers("/admin/**").hasRole("ADMIN").antMatchers("/user/**").hasAnyRole("ADMIN", "USER")
                //其他所有请求都需要用户进行身份验证。
                .anyRequest().authenticated()
                .and().formLogin()
                // 设置登录页面的 URL
                .loginPage("/")
                // 设置登录请求的 URL，即表单提交的 URL
                .loginProcessingUrl("/userLogin")
                // 设置登录表单中用户名字段的参数名，默认为username
                .usernameParameter("username")
                // 设置登录表单中密码字段的参数名，默认为password
                .passwordParameter("password")
                // 登录成功后返回的数据
                .successHandler((res, resp, ex) -> {
                    Object user = ex.getPrincipal();
                    objectMapper
                            .writeValue(resp.getOutputStream(), JsonResponseBody.success(user));
                })
                .and()
                /*配置注销*/
                .logout()
                // 设置安全退出的URL路径
                .logoutUrl("/logout")
                // 设置退出成功后跳转的路径
                .logoutSuccessUrl("/").and()
                /*配置 rememberMe 功能*/
                .rememberMe()
                // 指定 rememberMe 的参数名，用于在表单中携带 rememberMe 的值。
                .rememberMeParameter("remember-me")
                // 指定 rememberMe 的有效期，单位为秒，默认2周。
                .tokenValiditySeconds(60)
                // 指定 rememberMe 的 cookie 名称。
                .rememberMeCookieName("remember-me-cookie")
                // 指定 rememberMe 的 token 存储方式，可以使用默认的 PersistentTokenRepository 或自定义的实现。
                .tokenRepository(persistentTokenRepository())
                // 指定 rememberMe 的认证方式，需要实现 UserDetailsService 接口，并在其中查询用户信息。
                .userDetailsService(userDetailsService)
        return http.build();
    }

2.4.3 CSRF防御（跨站请求伪造）

CSRF

（

Cross-Site Request Forgery

，跨站请求伪造）是一种利用用户已登录的身份在用户不知情的情况下发送恶意请求的攻击方式。攻击者可以通过构造恶意链接或者伪造表单提交等方式，让用户在不知情的情况下执行某些 *** 作，例如修改密码、转账、发表评论等。

为了防范

CSRF

攻击，常见的做法是在请求中添加一个

CSRF Token

（也叫做同步令牌、防伪标志），并在服务器端进行验证。

CSRF Token

是一个随机生成的字符串，每次请求都会随着请求一起发送到服务器端，服务器端会对这个

Token

进行验证，如果

Token

不正确，则拒绝执行请求。

在
Spring Security
中，防范
CSRF
攻击可以通过启用
CSRF
保护来实现。启用
CSRF
保护后，
Spring Security
会自动在每个表单中添加一个隐藏的
CSRF Token
字段，并在服务器端进行验证。如果
Token
验证失败，则会抛出异常，从而拒绝执行请求。启用
CSRF
保护的方式是在
Spring Security
配置文件中添加
.csrf()
方法，例如：
http
    .csrf()
        .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse());
在上面的配置中，我们使用了
CookieCsrfTokenRepository
作为
CSRF Token
的存储方式，并设置了
httpOnly
为
false
，以便在客户端可以访问到该
Token
。

在表单中添加：
 <input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}"/>

.csrf()

主要方法介绍：

方法	说明
disable()	关闭 CSRF 防御
csrfTokenRepository()	设置 CookieCsrfTokenRepository 实例，用于存储和检索 CSRF 令牌。与 HttpSessionCsrfTokenRepository 不同， CookieCsrfTokenRepository 将 CSRF 令牌存储在 cookie 中，而不是在会话中。
ignoringAntMatchers()	设置一组Ant模式，用于忽略某些请求的 CSRF 保护。例如，如果您想要忽略所有以 /api/ 开头的请求，可以使用 .ignoringAntMatchers("/api/**") 。
csrfTokenManager()	设置 CsrfTokenManager 实例，用于管理 CSRF 令牌的生成和验证。默认情况下， Spring Security 使用 DefaultCsrfTokenManager 实例来生成和验证 CSRF 令牌。
requireCsrfProtectionMatcher()	设置 RequestMatcher 实例，用于确定哪些请求需要进行 CSRF 保护。默认情况下， Spring Security 将对所有非 GET、HEAD、OPTIONS和TRACE 请求进行 CSRF 保护。

如果针对一些特定的请求接口，不需要进行
CSRF
防御，可以通过以下配置忽略：
http.csrf().ignoringAntMatchers("/upload"); // 禁用/upload接口的CSRF防御

三、用户授权

3.1 授权介绍

Spring Security 中的授权分为两种类型：

基于角色的授权：以用户所属角色为基础进行授权，如管理员、普通用户等，通过为用户分配角色来控制其对资源的访问权限。
基于资源的授权：以资源为基础进行授权，如 URL、方法等，通过定义资源所需的权限，来控制对该资源的访问权限。

Spring Security 提供了多种实现授权的机制，最常用的是使用基于注解的方式，建立起访问资源和权限之间的映射关系。

其中最常用的两个注解是

@Secured

和

@PreAuthorize

。

@Secured

注解是更早的注解，基于角色的授权比较适用，

@PreAuthorize

基于

SpEL

表达式的方式，可灵活定义所需的权限，通常用于基于资源的授权。

3.2 构建 UserDetails 对象

3.2.1 准备数据表

sys_user - 用户信息表
sys_role - 角色信息表
sys_user_role - 用户角色表
sys_module - 模块信息表
sys_role_module - 角色权限表

3.2.2 设置用户权限

package com.ycxw.springsecurity.config;import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ycxw.springsecurity.entity.*;
import com.ycxw.springsecurity.service.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Component;import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;@Component
public class MyUserDetailsService implements UserDetailsService {    @Autowired
    private IUserService userService;
    @Autowired
    private IUserRoleService userRoleService;
    @Autowired
    private IRoleService roleService;
    @Autowired
    private IRoleModuleService roleModuleService;
    @Autowired
    private IModuleService moduleService;    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        /*查询当前用户*/
        User user = userService
                .getOne(new QueryWrapper<User>().eq("username", username));
        if (user == null) {
            throw new UsernameNotFoundException("用户名无效");
        }        /*
         * map 遍历所有的对象,返回新的数据会放到一个新流中
         * collect 将流中的元素变成一个集合
         * */        //先查询出所有的身份id
        List<Integer> role_ids = userRoleService
                .list(new QueryWrapper<UserRole>().eq("user_id", user.getId()))
                .stream().map(UserRole::getRoleId)
                .collect(Collectors.toList());        //查询角色对应的权限
        List<String> roles = roleService.list(new QueryWrapper<Role>().in("role_id", role_ids))
                .stream().map(Role::getRoleName)
                .collect(Collectors.toList());        // 查询权限对应的模块
        List<Integer> module_ids = roleModuleService.list(new QueryWrapper<RoleModule>().in("role_id", role_ids))
                .stream().map(RoleModule::getModuleId)
                .collect(Collectors.toList());        /// 查询模块对应的 URL
        List<String> modules = moduleService.list(new QueryWrapper<Module>().in("id", module_ids))
                .stream().map(Module::getUrl)
                /* filter 过滤流中的内容(对象不为空)*/
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
        /*
         * roles -> [管理员,普通用户]
         * +
         * modules -> [book:manager:add,book:manager:list]
         */
        // 将角色和模块合并为一个集合
        roles.addAll(modules);
        // roles [管理员,普通用户,book:manager:add,book:manager:list]
        // 构建 SimpleGrantedAuthority 对象
        List<SimpleGrantedAuthority> authorities = roles.stream()
                .map(SimpleGrantedAuthority::new)
                .collect(Collectors.toList());
        // 设置用户的权限
        user.setAuthorities(authorities);        // 返回 UserDetails 对象
        return user;
    }}

根据用户名查询用户信息并构建 UserDetails 对象，以便 Spring Security 进行身份验证。

3.3 修改SpringSecurity配置类

当我们想要开启

spring

方法级安全时，只需要在任何

@Configuration

实例上使用

@EnableGlobalMethodSecurity

注解就能达到此目的。同时这个注解为我们提供了

prePostEnabled

、

securedEnabled

和

jsr250Enabled

三种不同的机制来实现同一种功能。

package com.ycxw.springsecurity.config;import com.fasterxml.jackson.databind.ObjectMapper;
import com.ycxw.springsecurity.resp.JsonResponseBody;
import com.ycxw.springsecurity.resp.JsonResponseStatus;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.ProviderManager;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.rememberme.JdbcTokenRepositoryImpl;
import org.springframework.security.web.authentication.rememberme.PersistentTokenRepository;
import org.springframework.security.web.csrf.CookieCsrfTokenRepository;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;import javax.annotation.Resource;
import javax.sql.DataSource;@Configuration
@EnableWebSecurity //前置权限验证
@EnableGlobalMethodSecurity(prePostEnabled = true) //后置权限验证
public class WebSecurityConfig {    // 注入数据源（spring自带）
    @Resource
    public DataSource dataSource;    @Autowired
    private ObjectMapper objectMapper;    /*自定义处理身份验证失败的接口*/
    @Autowired
    private MyAuthenticationFailureHandler myAuthenticationFailureHandler;    // 注入用户服务
    @Autowired
    private UserDetailsService userDetailsService;    /*
     * 密码编码器: 用于对密码进行加密
     * */
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }    // 创建持久令牌存储库
    @Bean
    public PersistentTokenRepository persistentTokenRepository() {
        // 创建一个JdbcTokenRepositoryImpl实例
        JdbcTokenRepositoryImpl tokenRepository = new JdbcTokenRepositoryImpl();
        // 设置数据源
        tokenRepository.setDataSource(dataSource);
        // 设置启动时创建表
        tokenRepository.setCreateTableOnStartup(false);
        // 返回tokenRepository
        return tokenRepository;
    }    // 创建认证管理器
    @Bean
    public AuthenticationManager authenticationManager() throws Exception {
        // 创建一个DAO认证提供者
        DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
        // 设置用户详情服务和密码编码器
        provider.setUserDetailsService(userDetailsService);
        provider.setPasswordEncoder(passwordEncoder());
        // 返回一个提供者管理器
        return new ProviderManager(provider);
    }    /*
     * 安全过滤器链
     * */
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.authorizeRequests().antMatchers("/").permitAll()
                //其他所有请求都需要用户进行身份验证。
                .anyRequest().authenticated()
                .and().formLogin()
                // 设置登录页面的 URL
                .loginPage("/")
                // 设置登录请求的 URL，即表单提交的 URL
                .loginProcessingUrl("/userLogin")
                // 设置登录表单中用户名字段的参数名，默认为username
                .usernameParameter("username")
                // 设置登录表单中密码字段的参数名，默认为password
                .passwordParameter("password")
                // 登录成功后返回的数据
                .successHandler((res, resp, ex) -> {
                    Object user = ex.getPrincipal();
                    objectMapper
                            .writeValue(resp.getOutputStream(), JsonResponseBody.success(user));
                })
                /*登录失败后的处理器*/
                .failureHandler(myAuthenticationFailureHandler)
                .and()
                .exceptionHandling()
                //权限不足
                .accessDeniedHandler((req, resp, ex) -> {
                    objectMapper
                            .writeValue(resp.getOutputStream(), JsonResponseBody.other(JsonResponseStatus.NO_ACCESS));
                })
                //没有认证
                .authenticationEntryPoint((req, resp, ex) -> {
                    objectMapper
                            .writeValue(resp.getOutputStream(), JsonResponseBody.other(JsonResponseStatus.NO_LOGIN));
                })
                .and()
                /*配置注销*/
                .logout()
                // 设置安全退出的URL路径
                .logoutUrl("/logout")
                // 设置退出成功后跳转的路径
                .logoutSuccessUrl("/").and()
                /*配置 rememberMe 功能*/
                .rememberMe()
                // 指定 rememberMe 的参数名，用于在表单中携带 rememberMe 的值。
                .rememberMeParameter("remember-me")
                // 指定 rememberMe 的有效期，单位为秒，默认2周。
                .tokenValiditySeconds(60)
                // 指定 rememberMe 的 cookie 名称。
                .rememberMeCookieName("remember-me-cookie")
                // 指定 rememberMe 的 token 存储方式，可以使用默认的 PersistentTokenRepository 或自定义的实现。
                .tokenRepository(persistentTokenRepository())
                // 指定 rememberMe 的认证方式，需要实现 UserDetailsService 接口，并在其中查询用户信息。
                .userDetailsService(userDetailsService).and()
                /*使用`POST`请求退出登陆，并携带`CRSF`令牌*/
                .logout().logoutRequestMatcher(new AntPathRequestMatcher("/logout"))
                .logoutSuccessUrl("/")
                .permitAll().and()
                /*CSRF防御配置*/
                .csrf().csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse());
        return http.build();
    }}

@EnableGlobalMethodSecurity
是Spring Security提供的一个注解，用于启用方法级别的安全性。它可以在任何@Configuration类上使用，以启用Spring Security的方法级别的安全性功能。它接受一个或多个参数，用于指定要使用的安全注解类型和其他选项。以下是一些常用的参数：

prePostEnabled
：如果设置为
true
，则启用
@PreAuthorize
和
@PostAuthorize
注解。默认值为
false
。

securedEnabled
：如果设置为
true
，则启用
@Secured
注解。默认值为
false
。

jsr250Enabled
：如果设置为
true
，则启用
@RolesAllowed
注解。默认值为
false
。

proxyTargetClass
：如果设置为
true
，则使用CGLIB代理而不是标准的JDK动态代理。默认值为
false
。

使用
@EnableGlobalMethodSecurity
注解后，可以在应用程序中使用Spring Security提供的各种注解来保护方法，例如
@Secured
、
@PreAuthorize
、
@PostAuthorize
和
@RolesAllowed
。这些注解允许您在方法级别上定义安全规则，以控制哪些用户可以访问哪些方法。
注解介绍：

注解说明
@PreAuthorize
用于在方法执行之前对访问进行权限验证
@PostAuthorize
用于在方法执行之后对返回结果进行权限验证
@Secured
用于在方法执行之前对访问进行权限验证
@RolesAllowed
是Java标准的注解之一，用于在方法执行之前对访问进行权限验证

注解	说明
@PreAuthorize	用于在方法执行之前对访问进行权限验证
@PostAuthorize	用于在方法执行之后对返回结果进行权限验证
@Secured	用于在方法执行之前对访问进行权限验证
@RolesAllowed	是Java标准的注解之一，用于在方法执行之前对访问进行权限验证

3.4 控制Controller层接口权限

package com.ycxw.springsecurity.controller;import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;@Controller
public class IndexController {    @RequestMapping("/")
    public String toLogin() {
        return "login";
    }    @RequestMapping("/index")
    public String toIndex() {
        return "index";
    }    @ResponseBody
    @RequestMapping("/order_add")
    @PreAuthorize("hasAuthority('order:manager:list')") /*设置权限字段*/
    public String order_add() {
        return "订单列表";
    }    @ResponseBody
    @PreAuthorize("hasAuthority('book:manager:add')")
    @RequestMapping("/book_add")
    public String book_add() {
        return "书本新增";
    }}

3.5 相关页面模版与工具类

1、login.ftl

<!DOCTYPE html>
<html lang="zh">
<head>
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
<h1>用户登录</h1>
<form action="/userLogin" method="post">
    <#--添加 CSRF（跨站请求伪造）令牌-->
    <input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}"/>
    <p>
        <label>用户：<input type="text" name="username"/></label>
    </p>
    <p>
        <label>密码：<input type="password" name="password"/></label>
    </p>
    <input type="checkbox" name="remember-me"/>记住我<br/>    <input type="submit" value="登录"/>
</form>
</body>
</html>

2、自定义数据返回类

SpringSecurity安全框架 ——认证与授权,第4张

例：

JSON 响应的状态码和状态信息：

package com.ycxw.springsecurity.resp;import lombok.Getter;@Getter
public enum JsonResponseStatus {    OK(200, "OK"),
    UN_KNOWN(500, "未知错误"),
    RESULT_EMPTY(1000, "查询结果为空"),
    NO_ACCESS(3001, "没有权限"),
    NO_LOGIN(4001, "没有登录"),
    LOGIN_FAILURE(5001, "登录失败"),
    ;    private final Integer code;
    private final String msg;    JsonResponseStatus(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }}

3、处理身份验证失败封类

package com.ycxw.springsecurity.config;import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ycxw.springsecurity.entity.User;
import com.ycxw.springsecurity.resp.JsonResponseBody;
import com.ycxw.springsecurity.resp.JsonResponseStatus;
import com.ycxw.springsecurity.service.IUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.stereotype.Component;import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;/*
    实现处理身份验证失败的接口
*/
@Component
public class MyAuthenticationFailureHandler implements AuthenticationFailureHandler {    @Autowired
    private ObjectMapper objectMapper;    @Autowired
    private IUserService userService;    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
       /*
       利用锁：
       判断当前用户登录超过3次进行锁定
       */
        if (1 == 2) {
            User user = userService.getOne(new QueryWrapper<User>().eq("username", request.getParameter("username")));
            user.setAccountNonLocked(false);
            userService.updateById(user);
        }
        objectMapper.writeValue(response.getOutputStream(), JsonResponseBody.other(JsonResponseStatus.LOGIN_FAILURE));
    }}

3.6 权限测试

1、普通用户权限

只拥有两个路径的权限

SpringSecurity安全框架 ——认证与授权,第5张

测试接口：没有book_add权限将不能访问

2、管理员权限

拥有六个路径的权限

SpringSecurity安全框架 ——认证与授权,第8张

测试接口：管理员能访问所有接口

欢迎分享，转载请注明来源：内存溢出

原文地址: https://outofmemory.cn/zz/13518214.html

SpringSecurity安全框架 ——认证与授权

一、简介

1.1 什么是Spring Security

1.2 工作原理

1.3 为什么选择Spring Security

1.4 HttpSecurity 介绍

二、用户认证

2.1 导入依赖与配置

2.2 用户对象UserDetails

2.3 业务对象UserDetailsService

2.4 SecurityConfig配置

2.4.1 BCryptPasswordEncoder密码编码器

2.4.2 RememberMe 记住登录信息

2.4.3 CSRF防御（跨站请求伪造）

三、用户授权

3.1 授权介绍

3.2 构建 UserDetails 对象

3.2.1 准备数据表

3.2.2 设置用户权限

3.3 修改SpringSecurity配置类

3.4 控制Controller层接口权限

3.5 相关页面模版与工具类

3.6 权限测试

发表评论

评论列表（0条）