Spring Security源码剖析从入门到精通.跟学尚硅谷(一)

学习目标

1. SpringSecurity 框架简介

1.1 概要

Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方案。

正如你可能知道的关于安全方面的两个主要区域是“认证”和“授权”（或者访问控制），一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权（Authorization）两个部分，这两点也是 Spring Security 重要核心功能。

（1）用户认证指的是：验证某个用户是否为系统中的合法主体，也就是说用户能否访问该系统。用户认证一般要求用户提供用户名和密码。系统通过校验用户名和密码来完成认证过程。通俗点说就是系统认为用户是否能登录。
（2）用户授权指的是验证某个用户是否有权限执行某个操作。在一个系统中，不同用户所具有的权限是不同的。比如对一个文件来说，有的用户只能进行读取，而有的用户可以进行修改。一般来说，系统会为不同的用户分配不同的角色，而每个角色则对应一系列的权限。通俗点讲就是系统判断用户是否有权限去做某些事情。

1.2 历史

“Spring Security 开始于 2003 年年底,““spring 的 acegi 安全系统”。 起因是 Spring开发者邮件列表中的一个问题,有人提问是否考虑提供一个基于 spring 的安全实现。

Spring Security 以“The Acegi Secutity System for Spring” 的名字始于 2013 年晚些时候。一个问题提交到 Spring 开发者的邮件列表，询问是否已经有考虑一个机遇 Spring 的安全性社区实现。那时候 Spring 的社区相对较小（相对现在）。实际上 Spring 自己在2013 年只是一个存在于 ScourseForge 的项目，这个问题的回答是一个值得研究的领域，虽然目前时间的缺乏组织了我们对它的探索。

考虑到这一点，一个简单的安全实现建成但是并没有发布。几周后，Spring 社区的其他成员询问了安全性，这次这个代码被发送给他们。其他几个请求也跟随而来。到 2014 年一月大约有 20 万人使用了这个代码。这些创业者的人提出一个 SourceForge 项目，并且在 2004年三月正式成立。

在早些时候，这个项目没有任何自己的验证模块，身份验证过程依赖于容器管理的安全性和 Acegi 安全性。而不是专注于授权。开始的时候这很适合，但是越来越多的用户请求额外的容器支持。容器特定的认证领域接口的基本限制变得清晰。还有一个相关的问题增加新的容器的路径，这是最终用户的困惑和错误配置的常见问题。

Acegi 安全特定的认证服务介绍。大约一年后，Acegi 安全正式成为了 Spring 框架的子项目。1.0.0 最终版本是出版于 2006 ，在超过两年半的大量生产的软件项目和数以百计的改进和积极利用社区的贡献。

Acegi 安全 2007 年底正式成为了 Spring 组合项目，更名为"Spring Security"。

1.3 同款产品对比

1.3.1 Spring Security

Spring 技术栈的组成部分。

通过提供完整可扩展的认证和授权支持保护你的应用程序。
Spring Security官网文档

SpringSecurity 特点：

• 和 Spring 无缝整合。
• 全面的权限控制。
• 专门为 Web 开发而设计。
  • 旧版本不能脱离 Web 环境使用。
  • 新版本对整个框架进行了分层抽取，分成了核心模块和 Web 模块。单独引入核心模块就可以脱离 Web 环境。
• 重量级。

1.3.2 Shiro

Apache 旗下的轻量级权限控制框架。

特点：

• 轻量级。Shiro 主张的理念是把复杂的事情变简单。针对对性能有更高要求的互联网应用有更好表现。
• 通用性。
  • 好处：不局限于 Web 环境，可以脱离 Web 环境使用。
  • 缺陷：在 Web 环境下一些特定的需求需要手动编写代码定制。

Spring Security 是 Spring 家族中的一个安全管理框架，实际上，在 Spring Boot 出现之前，Spring Security 就已经发展了多年了，但是使用的并不多，安全管理这个领域，一直是 Shiro 的天下。

相对于 Shiro，在 SSM 中整合 Spring Security 都是比较麻烦的操作，所以，Spring Security 虽然功能比 Shiro 强大，但是使用反而没有 Shiro 多（Shiro 虽然功能没有Spring Security 多，但是对于大部分项目而言，Shiro 也够用了）。

自从有了 Spring Boot 之后，Spring Boot 对于 Spring Security 提供了自动化配置方案，可以使用更少的配置来使用 Spring Security。

因此，一般来说，常见的安全管理技术栈的组合是这样的：

• SSM + Shiro
• Spring Boot/Spring Cloud + Spring Security

以上只是一个推荐的组合而已，如果单纯从技术上来说，无论怎么组合，都是可以运行的。

1.4 模块划分

2. SpringSecurity 入门案例

2.1 创建一个项目

(1).创建Spring Boot项目

Group:com.atguigu
Artifact:securitydemo1

版本随便选一个，后续调整

(2).更改项目依赖文件

更改pom.xml，更改版本

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

更改配置文件如下：
1.后缀加上-web
2.添加如下依赖

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

(3).添加Controller

@RestController
@RequestMapping("/test")
public class TestController {
    
    
    @GetMapping("hello")
    public String add() {
    
    
        return "hello security";
    }
}

更改端口号：

server.port=8111

2.2 运行这个项目

访问

http://localhost:8111/login

界面是这样，说明spring security接入成功

默认的用户名：user

密码在项目启动的时候在控制台会打印，注意每次启动的时候密码都回发生变化！

输入账号和密码后，点击sign in,发现这才是我们想看到的入门案例界面。

2.3 权限管理中的相关概念

2.3.1 主体

英文单词：principal
使用系统的用户或设备或从其他系统远程登录的用户等等。简单说就是谁使用系统谁就是主体。

2.3.2 认证

英文单词：authentication
权限管理系统确认一个主体的身份，允许主体进入系统。简单说就是“主体”证明自己是谁。
笼统的认为就是以前所做的登录操作。

2.3.3 授权

英文单词：authorization
将操作系统的“权力”“授予”“主体”，这样主体就具备了操作系统中特定功能的能力。
所以简单来说，授权就是给用户分配权限。

2.4 添加一个控制器进行访问

新建类IndexController.java

@Controller
public class IndexController {
    
    
    @GetMapping("index")
    @ResponseBody
    public String index() {
    
    
        return "success";
    }
}

访问：

http://localhost:8111/index

2.5 SpringSecurity 基本原理

SpringSecurity 本质是一个过滤器链：
从启动时可以获取到过滤器链：

org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFil
ter
org.springframework.security.web.context.SecurityContextPersistenceFilter 
org.springframework.security.web.header.HeaderWriterFilter
org.springframework.security.web.csrf.CsrfFilter
org.springframework.security.web.authentication.logout.LogoutFilter 
org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter 
org.springframework.security.web.authentication.ui.DefaultLoginPageGeneratingFilter 
org.springframework.security.web.authentication.ui.DefaultLogoutPageGeneratingFilter
org.springframework.security.web.savedrequest.RequestCacheAwareFilter
org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter
org.springframework.security.web.authentication.AnonymousAuthenticationFilter 
org.springframework.security.web.session.SessionManagementFilter 
org.springframework.security.web.access.ExceptionTranslationFilter 
org.springframework.security.web.access.intercept.FilterSecurityInterceptor

2.5.1 三个基本过滤器

代码底层流程：重点看三个过滤器：

FilterSecurityInterceptor：是一个方法级的权限过滤器, 基本位于过滤链的最底部。

super.beforeInvocation(fi) 表示查看之前的 filter 是否通过。
fi.getChain().doFilter(fi.getRequest(), fi.getResponse());表示真正的调用后台的服务。

ExceptionTranslationFilter：是个**异常过滤器，**用来处理在认证授权过程中抛出的异常

UsernamePasswordAuthenticationFilter ：对/login 的 POST 请求做拦截，校验表单中用户名，密码。

2.5.2 过滤器链的加载过程

这里我们用了Spring Boot整合，底层帮我们进行了自动化配置，如果不是Spring Boot 那我们需要基于DelegatingFilterProxy
doFilter方法

initDelegate方法

FilterChainProxy类的doFilter方法

FilterChainProxy类的doFilterInternal方法

2.6 UserDetailsService 接口讲解

当什么也没有配置的时候，账号和密码是由 Spring Security 定义生成的。而在实际项目中账号和密码都是从数据库中查询出来的。 所以我们要通过自定义逻辑控制认证逻辑。
通俗来说，就是查询数据库的用户名和密码需要重写该接口

查询数据库的用户名和密码:
1.创建类继承UsernamePasswordAuthenticationFilter，重写successfulAuthentication、unsuccessfulAuthentication、attemptAuthentication
2.创建类实现UserDetailsService 接口，编写查询数据的过程，返回User对象，这个User对象是安全框架提供的对象

如果需要自定义逻辑时，只需要实现 UserDetailsService 接口即可。接口定义如下：

• 返回值 UserDetails

这个类是系统默认的用户“主体”

// 表示获取登录用户所有权限
Collection<? extends GrantedAuthority> getAuthorities();
// 表示获取密码
String getPassword();
// 表示获取用户名
String getUsername();
// 表示判断账户是否过期
boolean isAccountNonExpired();
// 表示判断账户是否被锁定
boolean isAccountNonLocked();
// 表示凭证{密码}是否过期
boolean isCredentialsNonExpired();
// 表示当前用户是否可用
boolean isEnabled();

以下是 UserDetails 实现类
org.springframework.security.core.userdetails.User
org.springframework.security.provisioning.MutableUser

以后我们只需要使用 User 这个实体类即可！

• 方法参数 username
  表示用户名。此值是客户端表单传递过来的数据。默认情况下必须叫 username，否则无法接收。

2.7 PasswordEncoder 接口讲解

// 表示把参数按照特定的解析规则进行解析
String encode(CharSequence rawPassword);
// 表示验证从存储中获取的编码密码与编码后提交的原始密码是否匹配。如果密码匹配，则返回 true；如果不匹配，则返回 false。第一个参数表示需要被解析的密码。第二个参数表示存储的密码。
boolean matches(CharSequence rawPassword, String encodedPassword);
// 表示如果解析的密码能够再次进行解析且达到更安全的结果则返回 true，否则返回
false。默认返回 false。
default boolean upgradeEncoding(String encodedPassword) {
    
    
return false;
}

接口实现类

BCryptPasswordEncoder 是 Spring Security 官方推荐的密码解析器，平时多使用这个解析器。
BCryptPasswordEncoder 是对 bcrypt 强散列方法的具体实现。是基于 Hash 算法实现的单向加密。可以通过 strength 控制加密强度，默认 10。

• 常用方法演示

@Test
public void test01(){
    
    
// 创建密码解析器
BCryptPasswordEncoder bCryptPasswordEncoder = new 
BCryptPasswordEncoder();
// 对密码进行加密
String atguigu = bCryptPasswordEncoder.encode("atguigu");
// 打印加密之后的数据
System.out.println("加密之后数据：\t"+atguigu);
//判断原字符加密后和加密之前是否匹配
boolean result = bCryptPasswordEncoder.matches("atguigu", atguigu);
// 打印比较结果
System.out.println("比较结果：\t"+result);
}

输出结果:

加密之后数据：	$2a$10$HnfETFGYndTq05fxZDIK9uxm7tpPKPEZautjgDIseR0Suk6yeKQ2O
比较结果：	true

2.8 SpringBoot 对 Security 的自动配置

3. SpringSecurity Web 权限方案

3.1 设置登录系统的账号、密码

方式一：在 application.properties

spring.security.user.name=atguigu
spring.security.user.password=atguigu

此时IDEA控制台不会生成账号和密码，这里就可以直接用配置文件中的账号和密码登录了

方式二：编写配置类

新增类SecurityConfig.java

代码如下：SecurityConfig

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    
    // 注入 PasswordEncoder 类到 spring 容器中
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    
    
        BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
        String password = bCryptPasswordEncoder.encode("123");
        auth.inMemoryAuthentication().withUser("hsp").password(password).roles("");
    }

}

只是这样写的话，登录会报错

我们需要添加Bean

SecurityConfig完整代码如下

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    
    // 注入 PasswordEncoder 类到 spring 容器中
    @Bean
    PasswordEncoder passwordEncoder() {
    
    
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    
    
        BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
        String password = bCryptPasswordEncoder.encode("123");
        auth.inMemoryAuthentication().withUser("hsp").password(password).roles("");
    }

}

这次就登录成功了

方式三：自定义编写实现类

自定义实现类设置：
第一步创建配置类，设置使用哪个userDetailsService实现类
第二步编写实现类，返回User对象，User对 象有用户名密码和操作权限

新建类SecurityConfigCustomize.java

@Configuration
public class SecurityConfigCustomize extends WebSecurityConfigurerAdapter {
    
    
    // 注入 PasswordEncoder 类到 spring 容器中
    @Bean
    PasswordEncoder password() {
    
    
        return new BCryptPasswordEncoder();
    }

    @Autowired
    private UserDetailsService userDetailsService;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    
    
        auth.userDetailsService(userDetailsService).passwordEncoder(password());
    }

}

新建MyUserNameDetailsService类

@Service("UserDetailsService")
public class MyUserNameDetailsService implements UserDetailsService {
    
    
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    
    
        BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
        // 设置密码
        String password = bCryptPasswordEncoder.encode("123");
        List<GrantedAuthority> role = AuthorityUtils.commaSeparatedStringToAuthorityList("role");
        // 返回用户
        return new User("heima", password, role);
    }
}

尝试一下，发现登录成功

3.2 实现数据库认证来完成用户登录

完成自定义登录

3.2.1 准备 sql

CREATE DATABASE spring_security;
USE spring_security;

CREATE TABLE users (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  username VARCHAR (20) UNIQUE NOT NULL,
  PASSWORD VARCHAR (100)
) ;

INSERT INTO users VALUES(3,'lucy','123');
INSERT INTO users VALUES(4,'mary','456');

3.2.2 添加依赖

添加依赖

<!--mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--lombok 用来简化实体类-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

3.2.3 制作实体类

Users

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Users {
    
    
    private Integer id;
    private String username;
    private String password;
}

3.2.4 整合 MybatisPlus 制作 mapper

UserMapper

@Mapper
public interface UserMapper extends BaseMapper<Users> {
    
    
}

3.2.5 制作登录实现类

修改MyUserNameDetailsService.java

@Service("UserDetailsService")
public class MyUserNameDetailsService implements UserDetailsService {
    
    
    @Autowired
    private UserMapper userMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    
    
        // 调用userMapper方法查询数据库的密码
        QueryWrapper<Users> usersQueryWrapper = new QueryWrapper<>();
        usersQueryWrapper.lambda().eq(Users::getUsername, username);
        // 查询到users对象
        Users users = userMapper.selectOne(usersQueryWrapper);
        // 判断
        if (null == users) {
    
    
            // 表示数据库没有用户名，认证失败
            throw new UsernameNotFoundException("用户名不存在!");
        }

        BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
        // 设置密码
        String password = bCryptPasswordEncoder.encode(users.getPassword());
        List<GrantedAuthority> role = AuthorityUtils.commaSeparatedStringToAuthorityList("role");
        // 返回用户
        return new User(username, password, role);
    }
}

3.2.6 启动类加上注解

Securitydemo1Application.java加上@MapperScan注解

@SpringBootApplication
@MapperScan(basePackages = "com.atguigu.securitydemo1.mapper")
public class Securitydemo1Application {
    
    

    public static void main(String[] args) {
    
    
        SpringApplication.run(Securitydemo1Application.class, args);
    }

}

3.2.7 配置文件中配置数据库

application.properties

#mysql 数据库连接
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver 
spring.datasource.url=jdbc:mysql://localhost:3306/spring_security?serverTimezone=GMT%2B8 
spring.datasource.username=root 
spring.datasource.password=root

3.2.8 测试访问

输入用户名:lucy，密码:123

3.3 未认证请求跳转到登录页

3.3.1 引入前端模板依赖

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

3.3.2 引入登录页面

将准备好的登录页面导入项目中
手写一个即可

login.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="/user/login" method="post">
    用户名: <input type="text" name="username"/>
    <br/>
    密码: <input type="password" name="password"/>
    <br/>
    <input type="submit" value="登录"/>
</form>
</body>
</html>

注意：页面提交方式必须为 post 请求
注意：用户名，密码必须为username,password
原因：
在执行登录的时候会走一个过滤器UsernamePasswordAuthenticationFilter。

3.3.3 编写控制器

修改TestController.java添加

@GetMapping("index")
    public String index() {
    
    
        return "hello index";
    }

3.3.4 编写配置类放行登录页面以及静态资源

主要思路:重写WebSecurityConfigurerAdapter.java中的configure(HttpSecurity http)方法

SecurityConfigCustomize.java

@Override
    protected void configure(HttpSecurity http) throws Exception {
    
    
        // 自定义自己登录的表单页面
        http.formLogin()
                .loginPage("/login.html")
                .loginProcessingUrl("/user/login")// 登录访问的路径
                .defaultSuccessUrl("/test/index") // 登录成功后要跳转的路径
                .permitAll()
                .and().authorizeRequests()
                .antMatchers("/", "/test/hello", "/user/login").permitAll() // 访问以下路径后无需登录认证
                .anyRequest().authenticated() // 所有请求都可以访问
                .and().csrf().disable() // 关闭csrf的防护
        ;
    }

3.3.5 测试

访问

http://localhost:8111/test/hello

可以直接访问

访问

http://localhost:8111/test/index

登录后

3.3.6 设置未授权的请求跳转到登录页

上面，如果登录界面的参数不同，不是username和password
修改配置可以调用 usernameParameter()和 passwordParameter()方法。
修改
SecurityConfigCustomize.java

    @Override
    protected void configure(HttpSecurity http) throws Exception {
    
    
        // 自定义自己登录的表单页面
        http.formLogin()
                .loginPage("/login.html")
                .loginProcessingUrl("/user/login")// 登录访问的路径
                .defaultSuccessUrl("/test/index") // 登录成功后要跳转的路径
                .permitAll()
                .usernameParameter("loginAcct")
                .passwordParameter("userPswd")
                .and().authorizeRequests()
                .antMatchers("/", "/test/hello", "/user/login").permitAll() // 访问以下路径后无需登录认证
                .anyRequest().authenticated() // 所有请求都可以访问
                .and().csrf().disable() // 关闭csrf的防护
        ;
    }

修改login.html
把用户名和密码的name更改一下

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="/user/login" method="post">
    用户名: <input type="text" name="loginAcct"/>
    <br/>
    密码: <input type="password" name="userPswd"/>
    <br/>
    <input type="submit" value="登录"/>
</form>
</body>
</html>

发现可以成功登录

http://localhost:8111/test/index

3.4 基于角色或权限进行访问控制

3.4.1 hasAuthority 方法

如果当前的主体具有指定的权限，则返回 true,否则返回 false
只针对一个角色，或者一个权限分配

• 修改配置类
  SecurityConfigCustomize.jav添加
  

               .antMatchers("/test/index").hasAuthority("admins") // 当前路径具有admins权限才可以访问

• 给用户登录主体赋予权限
  修改MyUserNameDetailsService.java
  
  MyUserNameDetailsService.java

        List<GrantedAuthority> role = AuthorityUtils.commaSeparatedStringToAuthorityList("admins");

• 测试：
  访问

http://localhost:8111/test/index

认证完成之后返回登录成功

3.4.2 hasAnyAuthority 方法

如果当前的主体有任何提供的角色（给定的作为一个逗号分隔的字符串列表）的话，返回true
只针对多个角色，或者多个权限分配

假如我们还按照hasAuthority，增加多个角色

代码如下：

@Override
    protected void configure(HttpSecurity http) throws Exception {
    
    
        // 自定义自己登录的表单页面
        http.formLogin()
                .loginPage("/login.html")
                .loginProcessingUrl("/user/login")// 登录访问的路径
                .defaultSuccessUrl("/test/index") // 登录成功后要跳转的路径
                .permitAll()
                //.usernameParameter("loginAcct")
                //.passwordParameter("userPswd")
                .and().authorizeRequests()
                .antMatchers("/", "/test/hello", "/user/login").permitAll() // 访问以下路径后无需登录认证
                //.antMatchers("/test/index").hasAnyAuthority("admins") // 当前路径具有admins权限才可以访问
                .antMatchers("/test/index").hasAuthority("admins,manager") // 当前路径具有admins、manage权限才可以访问
                .anyRequest().authenticated() // 所有请求都可以访问
                .and().csrf().disable() // 关闭csrf的防护
        ;
    }

访问

http://localhost:8111/test/index

发现报错403

我们更改SecurityConfigCustomize.java

                .antMatchers("/test/index").hasAnyAuthority("admins,manager") // 当前路径具有admins、manage权限才可以访问

再此访问

http://localhost:8111/test/index

无误

3.4.3 hasRole 方法

如果用户具备给定角色就允许访问,否则出现 403。
如果当前主体具有指定的角色，则返回 true。
底层源码：

修改SecurityConfigCustomize.java

.antMatchers("/test/index").hasRole("sale") // 当前路径只有sale该角色，才能访问

给用户添加角色：
修改MyUserNameDetailsService.java

        List<GrantedAuthority> role = AuthorityUtils.commaSeparatedStringToAuthorityList("admins,ROLE_sale");

修改配置文件：
注意配置文件中不需要添加”ROLE_“，因为上述的底层代码会自动添加与之进行匹配。

访问

http://localhost:8111/test/index

无误

3.4.4 hasAnyRole

表示用户具备任何一个条件都可以访问。
修改MyUserNameDetailsService.java
给用户添加角色：

        List<GrantedAuthority> role = AuthorityUtils.commaSeparatedStringToAuthorityList("admins,ROLE_sale,ROLE_random");

修改SecurityConfigCustomize.java

                .antMatchers("/test/index").hasAnyRole("sale") // 当前路径中满足括号内任意角色，都能访问

访问

http://localhost:8111/test/index

访问成功

3.5 基于数据库实现权限认证

首先我们引用了mybatis-plus的依赖，这里无需再引用mybatis的依赖了

3.5.1 执行数据库脚本

CREATE TABLE menu(
id BIGINT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(20),
url VARCHAR(100),
parentid BIGINT,
permission VARCHAR(20)
);

INSERT INTO menu VALUES(1,'系统管理','',0,'menu:system');
INSERT INTO menu VALUES(2,'用户管理','',0,'menu:user');

CREATE TABLE role(
id BIGINT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(20)
);

INSERT INTO role VALUES(1,'admin');
INSERT INTO role VALUES(2,'common');

CREATE TABLE role_user(
uid BIGINT,
rid BIGINT
);

INSERT INTO role_user VALUES(1,1);
INSERT INTO role_user VALUES(2,2);

CREATE TABLE role_menu(
MID BIGINT,
rid BIGINT
);

INSERT INTO role_menu VALUES(1,1);
INSERT INTO role_menu VALUES(2,1);
INSERT INTO role_menu VALUES(2,2);

3.5.2 添加实体类

Menu.java

代码如下：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Menu {
    
    
    private Long id;
    private String name;
    private String url;
    private Long parentId;
    private String permission;
}

添加实体类Role

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Role {
    
    
    private Long id;
    private String name;
}

3.5.3 编写接口与实现类

UsersMapper.java

@Mapper
public interface UsersMapper extends BaseMapper<Users> {
    
    
    /**
     * 根据用户Id查询用户角色
     *
     * @param userId
     * @return
     */
    List<Role> selectRoleByUserid(Long userId);

    /**
     * 根据用户Id查询菜单
     *
     * @param userId
     * @return
     */
    List<Menu> selectMenuByUserid(Long userId);
}

上述接口需要进行多表管理查询：
需要在 resource/mapper 目录下自定义 UsersMapper.xml
二者名称要一致

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.atguigu.securitydemo1.mapper.UsersMapper">
    <!--
        mapper接口和映射文件要保证两个一致
        1.mapper接口的权和类名和映射文件的namespace一致
        2.mapper接口中的方法的方法名要和映射文件中的sql的id保持一致
     -->

    <!--    List<Role> selectRoleByUserid(Long userId);-->
    <select id="selectRoleByUserid" resultType="Role">
        SELECT b.`id`,
               b.`name`
        FROM role_user a
                 LEFT JOIN role b
                           ON a.`rid` = b.`id`
        WHERE a.`uid` = #{userId}

    </select>

    <!--    List<Menu> selectMenuByUserid(Long userId);-->
    <select id="selectMenuByUserid" resultType="Menu">
        SELECT m.id,
               m.name,
               m.url,
               m.parentid,
               m.permission
        FROM menu m
                 INNER JOIN role_menu rm
                            ON m.id = rm.mid
                 INNER JOIN role r
                            ON r.id = rm.rid
                 INNER JOIN role_user ru
                            ON r.id = ru.rid
        WHERE ru.uid = #{userId}
    </select>
</mapper>

MyUserNameDetailsService.java

@Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    
    
        // 调用userMapper方法查询数据库的密码
        QueryWrapper<Users> usersQueryWrapper = new QueryWrapper<>();
        usersQueryWrapper.lambda().eq(Users::getUsername, username);
        // 查询到users对象
        Users users = usersMapper.selectOne(usersQueryWrapper);
        // 判断
        if (null == users) {
    
    
            // 表示数据库没有用户名，认证失败
            throw new UsernameNotFoundException("用户名不存在!");
        }
        // 给该用户设置密码
        BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
        // 设置密码
        String password = bCryptPasswordEncoder.encode(users.getPassword());

        // 获取到用户角色，菜单列表
        List<Role> roleList = usersMapper.selectRoleByUserid((long) users.getId());
        List<Menu> menuList = usersMapper.selectMenuByUserid((long) users.getId());

        // 声明一个集合List
        ArrayList<GrantedAuthority> grantedAuthoritiesList = new ArrayList<>();

        // 处理角色
        for (Role role : roleList) {
    
    
            SimpleGrantedAuthority simpleGrantedAuthority = new SimpleGrantedAuthority("ROLE_" + role.getName());
            grantedAuthoritiesList.add(simpleGrantedAuthority);
        }

        // 处理权限
        for (Menu menu : menuList) {
    
    
            grantedAuthoritiesList.add(new SimpleGrantedAuthority(menu.getPermission()));
        }


        // 返回用户
        return new User(username, password, grantedAuthoritiesList);
    }

3.5.4 在配置文件中添加映射

在配置文件中 application.properties 添加

mybatis-plus.type-aliases-package=com.atguigu.securitydemo1.pojo
mybatis-plus.mapper-locations=classpath:com/atguigu/securitydemo1/mapper/*.xml

3.5.5 修改访问配置类

                .antMatchers("/test/index").hasAnyRole("admin") // 当前路径中满足括号内任意角色，都能访问

3.5.6 使用管理员与非管理员进行测试

使用管理员登录

http://localhost:8111/test/index

登录如下

如果非管理员测试会提示 403 没有权限

3.6 自定义 403 页面

3.6.1 修改访问配置类

修改SecurityConfigCustomize.java

http.exceptionHandling().accessDeniedPage("/unauth.html");

3.6.2 添加对应控制器

这里直接跳转到了静态界面，就不用加控制器了

3.6.3 添加对应静态页面

新增静态界面

unauth.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Unauth</title>
</head>
<body>
<h1>没有访问权限!</h1>

</body>
</html>

3.6.4 测试

测试的话，可以去掉权限

访问

http://localhost:8111/test/index

跳转成功

3.7 注解使用

3.7.1 @Secured

判断用户是否具有角色，是否能访问方法。另外需要注意的是这里匹配的字符串需要添加前缀“ROLE_“。使用注解先要开启注解功能！
@EnableGlobalMethodSecurity(securedEnabled=true)

Securitydemo1Application.java

@SpringBootApplication
@MapperScan(basePackages = "com.atguigu.securitydemo1.mapper")
@EnableGlobalMethodSecurity(securedEnabled = true)
public class Securitydemo1Application {
    
    

    public static void main(String[] args) {
    
    
        SpringApplication.run(Securitydemo1Application.class, args);
    }

}

在控制器方法上添加注解
TestController.java

@GetMapping("update")
    @Secured({
    
    "ROLE_sale", "ROLE_manager"})
    public String update() {
    
    
        return "hello update";
    }

修改MyUserNameDetailsService.java，增加ROLE_sale角色

登录之后直接访问：控制器

http://localhost:8111/test/update

将上述的角色改为 @Secured({“ROLE_normal”,“ROLE_manager”})就不能访问了

3.7.2 @PreAuthorize

先开启注解功能：
@EnableGlobalMethodSecurity(prePostEnabled = true)
@PreAuthorize：注解适合进入方法前的权限验证， @PreAuthorize 可以将登录用户的 roles/permissions 参数传到方法中。

Securitydemo1Application.java

@SpringBootApplication
@MapperScan(basePackages = "com.atguigu.securitydemo1.mapper")
@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)
public class Securitydemo1Application {
    
    

    public static void main(String[] args) {
    
    
        SpringApplication.run(Securitydemo1Application.class, args);
    }

}

修改TestController.java

@GetMapping("update")
    @PreAuthorize("hasAnyAuthority('admin')")
    public String update() {
    
    
        return "hello update";
    }

保证MyUserNameDetailsService.java有admin角色

保证

使用lucy登录测试：

3.7.3 @PostAuthorize

先开启注解功能：
@EnableGlobalMethodSecurity(prePostEnabled = true)
之前开启过了

@PostAuthorize 注解使用并不多，在方法执行后再进行权限验证，适合验证带有返回值的权限。

修改TestController.java

    @GetMapping("update")
    @PostAuthorize("hasAnyAuthority('admin')")
    public String update() {
    
    
        System.out.println("update……");
        return "hello update";
    }

修改MyUserNameDetailsService.java

使用lucy登录测试：

发现是没有访问权限的，但是IDEA后台输出了，说明是方法执行后，才校验的。

3.7.4 @PostFilter

@PostFilter ：权限验证之后对数据进行过滤，留下用户名是 admin1 的数据
表达式中的 filterObject 引用的是方法返回值 List 中的某一个元素。
修改TestController.java

@GetMapping("getAll")
    @PreAuthorize("hasAnyAuthority('admin')")
    @PostFilter("filterObject.username == 'lucy'")
    @ResponseBody
    public List<Users> getAllUser() {
    
    
        ArrayList<Users> list = new ArrayList<>();
        list.add(new Users(1, "lucy", "123"));
        list.add(new Users(2, "admin2", "888"));
        System.out.println("list:" + list);
        return list;
    }

访问

http://localhost:8111/test/getAll

用户名lucy

IDEA后台打印

list:[Users(id=1, username=lucy, password=123), 
Users(id=2, username=admin2, password=888)]

3.7.5 @PreFilter

@PreFilter: 进入控制器之前对数据进行过滤
修改TestController.java

 @GetMapping("getTestPreFilter")
    @PreAuthorize("hasAnyAuthority('admin')")
    @PreFilter(value = "filterObject.id%2==0")
    @ResponseBody
    public List<Users> getTestPreFilter(@RequestBody List<Users> list) {
    
    
        list.forEach(t -> {
    
    
            System.out.println(t.getId() + "\t" + t.getUsername());
        });
        return list;
    }

先登录，然后使用 postman 进行测试

http://localhost:8111/test/getTestPreFilter

测试的 Json 数据：

[{
    
    
"id": "1",
"username": "lucy",
"password": "123"
},
{
    
    
"id": "2",
"username": "mary",
"password": "456"
},
{
    
    
"id": "3",
"username": "admins11",
"password": "11888"
},
{
    
    
"id": "4",
"username": "admins22",
"password": "22888"
}]

我这边点击send后，跳转到登录页，我很疑惑，这里如果大家测试出效果，可以讲解一下如何测试

我这边SecurityConfigCustomize.java，刻意加上了无需登录验证也没有效果。

3.7.6 权限表达式

这里不做掌握。可以查看官网：
权限表达式

3.8 登录时记住账号和密码(基于数据库)

基于cookie的方式

基于Spring Security

原理：
UsernamePasswordAuthenticationFilter的父类

successfulAuthentication方法rememberMeServices类

AbstractRememberMeServices中的loginSuccess中的onLoginSuccess

PersistentTokenBasedRememberMeServices类中的onLoginSuccess

创建表，并且写入逻辑，将Token写入Cookie
这个类是创建表并且写入的过程
JdbcTokenRepositoryImpl.java

RememberMeAuthenticationFilter的doFilter方法

AbstractRememberMeServices.java类的autoLogin方法

3.8.1 创建表

这里不要创建，由Spring Security自己创建，名为persistent_logins的表
具体创建过程在JdbcTokenRepositoryImpl中。

3.8.2 添加数据库的配置文件

这一部之前添加过了

3.8.3 编写配置类

创建配置类

BrowserSecurityConfig

这段代码，第一次启动后开启，之后注释掉这段代码jdbcTokenRepository.setCreateTableOnStartup(true);

@Configuration
public class BrowserSecurityConfig {
    
    
    @Autowired
    private DataSource dataSource;

    @Bean
    public PersistentTokenRepository persistentTokenRepository() {
    
    
        JdbcTokenRepositoryImpl jdbcTokenRepository = new
                JdbcTokenRepositoryImpl();
        // 赋值数据源
        jdbcTokenRepository.setDataSource(dataSource);
        // 自动创建表,第一次执行会创建，以后要执行就要删除掉！
        jdbcTokenRepository.setCreateTableOnStartup(true);
        return jdbcTokenRepository;
    }
}

3.8.4 修改安全配置类

SecurityConfigCustomize.java添加

@Autowired
    private PersistentTokenRepository tokenRepository;

// 开启记住我功能
        http.rememberMe()
                .tokenRepository(tokenRepository)
                .userDetailsService(userDetailsService);

3.8.5 页面添加记住我复选框

login.html添加

记住我：<input type="checkbox" name="remember-me" title="记住密码"/>

此处：name 属性值必须是 remember-me.不能改为其他值

3.8.6 登录测试

访问：

http://localhost:8111/test/index

按F12开发者模式

登录成功

登录成功之后，关闭浏览器再次访问 ，发现依然可以使用！

这里注意，最好用goole浏览器，可以看到效果

3.8.7 设置有效期

默认 2 周时间。但是可以通过设置状态有效时间，即使项目重新启动下次也可以正常登录。
在配置文件中设置
SecurityConfigCustomize.java

 // 开启记住我功能
        http.rememberMe()
                .tokenRepository(tokenRepository)
                .userDetailsService(myUserNameDetailsService)
                .tokenValiditySeconds(1800) // 单位是秒
        ;

3.9 用户注销

3.9.1 在登录页面添加一个退出连接

success.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
登录成功!
<a href="/logout">退出</a>
</body>
</html>

3.9.2 在配置类中添加退出映射地址

SecurityConfigCustomize.java
增加

// 退出
        http.logout().logoutUrl("/logout").logoutSuccessUrl("/test/quit").permitAll();

修改

.defaultSuccessUrl("/success.html") // 登录成功后要跳转的路径

修改TestController.java
增加退出方法

@GetMapping("quit")
    public String quit() {
    
    
        return "quit";
    }

3.9.3 测试

访问

http://localhost:8111/login.html

登陆后跳转到了success.html

点击退出

退出之后，是无法访问需要登录时才能访问的控制器！
比如我们访问:

http://localhost:8111/test/index

需要再次登录

3.10 CSRF

3.10.1 CSRF 理解

跨站请求伪造（英语：Cross-site request forgery），也被称为 one-click attack 或者 session riding，通常缩写为 CSRF 或者 XSRF， 是一种挟制用户在当前已登录的 Web 应用程序上执行非本意的操作的攻击方法。跟跨网站脚本（XSS）相比，XSS利用的是用户对指定网站的信任，CSRF 利用的是网站对用户网页浏览器的信任。

跨站请求攻击，简单地说，是攻击者通过一些技术手段欺骗用户的浏览器去访问一个自己曾经认证过的网站并运行一些操作（如发邮件，发消息，甚至财产操作如转账和购买商品）。由于浏览器曾经认证过，所以被访问的网站会认为是真正的用户操作而去运行。这利用了 web 中用户身份验证的一个漏洞：简单的身份验证只能保证请求发自某个用户的浏览器，却不能保证请求本身是用户自愿发出的。

从 Spring Security 4.0 开始，默认情况下会启用 CSRF 保护，以防止 CSRF 攻击应用程序，Spring Security CSRF 会针对 PATCH，POST，PUT 和 DELETE 方法进行防护。

3.10.2 案例

在登录页面添加一个隐藏域：

login.html

<input type="hidden" th:if="${_csrf}!=null" th:value="${_csrf.token}" name="_csrf"/>

关闭安全配置的类中的 csrf
SecurityConfigCustomize.java

// http.csrf().disable();

pom.xml中添加依赖

<!-- 对Thymeleaf添加Spring Security标签支持 -->
        <dependency>
            <groupId>org.thymeleaf.extras</groupId>
            <artifactId>thymeleaf-extras-springsecurity5</artifactId>
        </dependency>

这里简述一下实现的原理和配置即可，具体实现，用这种方式不行，需要跳转，我们直接用老师提供的资料看一下即可。
导入课程案例：
修改SecurityConfig.java，关闭csrf保护

修改csrfTest.html，注释CSRF逻辑

修改csrf_token.html，注释CSRF逻辑

启动服务，访问

http://localhost:8112/toupdate

点击修改后(其实是登录),正确访问

然后，我们注释
SecurityConfig.java，意思就是开启CSRF防护

// http.csrf().disable();

重启服务后再次访问

http://localhost:8112/toupdate

点击登录后发现跳转到了

原因是SecurityConfig.java类中配置了失败跳转

解决方案：我们把csrfTest.html和csrf_token.html的注释去掉

重启后再次访问

http://localhost:8112/toupdate

登录后如下:

我们通过F12开发者选型，看一下页面元素，这里已经带过来token了

3.10.3 Spring Security 实现 CSRF 的原理：

简单原理图:

1. 生成 csrfToken 保存到 HttpSession 或者 Cookie 中。
   类图如下：
   
   SaveOnAccessCsrfToken 类有个接口 CsrfTokenRepository
   
   当前接口实现类：HttpSessionCsrfTokenRepository，CookieCsrfTokenRepository
   
   

2. 请求到来时，从请求中提取 csrfToken，和保存的 csrfToken 做比较，进而判断当前请求是否合法。主要通过 CsrfFilter 过滤器来完成。

CsrfFilter.java类的doFilterInternal方法

其中requireCsrfProtectionMatcher.matches方法

查看DefaultRequiresCsrfMatcher方法
其中这些请求"GET", “HEAD”, “TRACE”, "OPTIONS"CSRF不做防护