1. 第一部分 SpringSecurity入门

1.1 Spring Security简介

​ Spring Security是一个功能强大且高度可定制的身份验证和访问控制框架。它是用于保护基于Spring的应用程序的实际标准。Spring Security是一个框架，致力于为Java应用程序提供身份验证和授权。与所有Spring项目一样，Spring Security的真正强大之处在于可以轻松扩展以满足自定义要求.

1.2 Spring Security框架功能简介

1. 认证: 用户登录, 解决的是"你是谁?"
2. 授权: 判断用户拥有什么权限，可以访问什么资源. 解决的是"你能干什么?"
3. 安全防护，防止跨站请求，session 攻击等

1.3 SpringSecurity应用场景

1. 用户登录, 传统基于web开发的项目的登录功能.

2. 用户授权, 在系统中用户拥有哪些操作权限

3. 单一登录, 一个账号只能在同一时间只能在一个地方进行登录, 如果在其他地方进行第二次登录,则剔除之前登录操作

4. 集成cas,做单点登录,即多个系统只需登录一次，无需重复登录

   

5. 集成oauth2 ,做登录授权, 可以用于app登录和第三方登录(QQ,微信等), 也可以实现cas的功能.

1.5 SpringSecurity入门案例

​ 快速体验SpringSecurity功能

1. 创建Spring Boot 工程

   使用Spring Initializr 快速过构建Spring Boot工程

   Spring Boot版本选择2.3.5 , 并选中Spring Web 模块

2. 编写Controller

   package com.boxuegu.controller;
   import org.springframework.web.bind.annotation.RequestMapping;
   import org.springframework.web.bind.annotation.RestController;
   /**
    * security入门案例
    */
   @RestController
   public class HelloSecurityController {
       @RequestMapping("/hello")
       public String hello() {
           return "hello security";
       }
   }
   

3. 访问http://localhost:8080/hello

   

4. 添加SpringSecurity依赖

   
   
        org.springframework.boot
        spring-boot-starter-security
   
   

5. 重启Spring Boot启动类,再次访问http://localhost:8080/hello

   

   我们来观察下帮我们生成的表单页面

   

   咱们先看看这个页面源代码，这里有三点需要大家注意下:

   • 表单的提交方式和路径: post /login
   • input输入项的name值: username password
   • 隐藏域input的name: 值为:_csrf value值为d4329889-796a-447a-9d08-69e56bc7c296

     SpringBoot已经为SpringSecurity提供了默认配置，默认所有资源都必须认证通过才能访问。那么问题来了！此刻并没有连接数据库，也并未在内存中指定认证用户，如何认证呢？

     其实SpringBoot已经提供了默认用户名user，密码在项目启动时随机生成

     认证通过后可以继续访问处理器资源：

     

2. 第二部分 SpringSecurity认证

2.1建表语句

/*
 Navicat Premium Data Transfer
 Source Server         : localhost
 Source Server Type    : MySQL
 Source Server Version : 50540
 Source Host           : localhost:3306
 Source Schema         : security_management
 Target Server Type    : MySQL
 Target Server Version : 50540
 File Encoding         : 65001
 Date: 31/10/2020 14:35:33
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for t_permission
-- ----------------------------
DROP TABLE IF EXISTS `t_permission`;
CREATE TABLE `t_permission`  (
  `ID` int(11) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `permission_name` varchar(30) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '权限名称',
  `permission_tag` varchar(30) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '权限标签',
  `permission_url` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '权限地址',
  PRIMARY KEY (`ID`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 9 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
-- ----------------------------
-- Records of t_permission
-- ----------------------------
INSERT INTO `t_permission` VALUES (1, '查询所有用户', 'user:findAll', 'https://blog.csdn.net/user/findAll');
INSERT INTO `t_permission` VALUES (2, '用户添加或修改', 'user:saveOrUpdate', '/user/saveOrUpadate');
INSERT INTO `t_permission` VALUES (3, '用户删除', 'user:delete', '/delete/{id}');
INSERT INTO `t_permission` VALUES (4, '根据ID查询用户', 'user:getById', '/user/{id}');
INSERT INTO `t_permission` VALUES (5, '查询所有商品', 'product:findAll', 'https://blog.csdn.net/product/findAll');
INSERT INTO `t_permission` VALUES (6, '商品添加或修改', 'product:saveOrUpdate', '/product/saveOrUpadate');
INSERT INTO `t_permission` VALUES (7, '商品删除', 'product:delete', '/product//delete/{id}');
INSERT INTO `t_permission` VALUES (8, '商品是否显示', 'product:show', '/product/show/{id}/{isShow}');
-- ----------------------------
-- Table structure for t_role
-- ----------------------------
DROP TABLE IF EXISTS `t_role`;
CREATE TABLE `t_role`  (
  `ID` int(11) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `ROLE_NAME` varchar(30) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '角色名称',
  `ROLE_DESC` varchar(60) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '角色描述',
  PRIMARY KEY (`ID`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 6 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
-- ----------------------------
-- Records of t_role
-- ----------------------------
INSERT INTO `t_role` VALUES (1, 'ADMIN', '超级管理员');
INSERT INTO `t_role` VALUES (2, 'USER', '用户管理');
INSERT INTO `t_role` VALUES (3, 'PRODUCT', '商品管理员');
INSERT INTO `t_role` VALUES (4, 'PRODUCT_INPUT', '商品录入员');
INSERT INTO `t_role` VALUES (5, 'PRODUCT_SHOW', '商品审核员');
-- ----------------------------
-- Table structure for t_role_permission
-- ----------------------------
DROP TABLE IF EXISTS `t_role_permission`;
CREATE TABLE `t_role_permission`  (
  `RID` int(11) NOT NULL COMMENT '角色编号',
  `PID` int(11) NOT NULL COMMENT '权限编号',
  PRIMARY KEY (`RID`, `PID`) USING BTREE,
  INDEX `FK_Reference_12`(`PID`) USING BTREE,
  CONSTRAINT `FK_Reference_11` FOREIGN KEY (`RID`) REFERENCES `t_role` (`ID`) ON DELETE RESTRICT ON UPDATE RESTRICT,
  CONSTRAINT `FK_Reference_12` FOREIGN KEY (`PID`) REFERENCES `t_permission` (`ID`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
-- ----------------------------
-- Records of t_role_permission
-- ----------------------------
INSERT INTO `t_role_permission` VALUES (1, 1);
INSERT INTO `t_role_permission` VALUES (2, 1);
INSERT INTO `t_role_permission` VALUES (1, 2);
INSERT INTO `t_role_permission` VALUES (2, 2);
INSERT INTO `t_role_permission` VALUES (1, 3);
INSERT INTO `t_role_permission` VALUES (2, 3);
INSERT INTO `t_role_permission` VALUES (1, 4);
INSERT INTO `t_role_permission` VALUES (2, 4);
INSERT INTO `t_role_permission` VALUES (1, 5);
INSERT INTO `t_role_permission` VALUES (3, 5);
INSERT INTO `t_role_permission` VALUES (4, 5);
INSERT INTO `t_role_permission` VALUES (5, 5);
INSERT INTO `t_role_permission` VALUES (1, 6);
INSERT INTO `t_role_permission` VALUES (3, 6);
INSERT INTO `t_role_permission` VALUES (4, 6);
INSERT INTO `t_role_permission` VALUES (1, 7);
INSERT INTO `t_role_permission` VALUES (3, 7);
INSERT INTO `t_role_permission` VALUES (4, 7);
INSERT INTO `t_role_permission` VALUES (1, 8);
INSERT INTO `t_role_permission` VALUES (3, 8);
INSERT INTO `t_role_permission` VALUES (5, 8);
-- ----------------------------
-- Table structure for t_user
-- ----------------------------
DROP TABLE IF EXISTS `t_user`;
CREATE TABLE `t_user`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL,
  `password` varchar(100) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL,
  `status` int(1) NULL DEFAULT NULL COMMENT '用户状态1-启用 0-关闭',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 6 CHARACTER SET = utf8 COLLATE = utf8_bin ROW_FORMAT = Compact;
-- ----------------------------
-- Records of t_user
-- ----------------------------
INSERT INTO `t_user` VALUES (1, 'admin', 'a$m8WqgTzr0TO.XG.aR91.jegJJmDnGSvWs69aMWPR.WNvCzemHpLum', 1);
INSERT INTO `t_user` VALUES (2, 'zhaoyang', 'a$m8WqgTzr0TO.XG.aR91.jegJJmDnGSvWs69aMWPR.WNvCzemHpLum', 1);
INSERT INTO `t_user` VALUES (3, 'user1', 'a$m8WqgTzr0TO.XG.aR91.jegJJmDnGSvWs69aMWPR.WNvCzemHpLum', 1);
INSERT INTO `t_user` VALUES (4, 'user2', 'a$m8WqgTzr0TO.XG.aR91.jegJJmDnGSvWs69aMWPR.WNvCzemHpLum', 1);
INSERT INTO `t_user` VALUES (5, 'user3', 'a$Wk1jWJPoMQ5s7UIp0S/tu.WTcUZUspUUQH6K3BQpa8uHXWRUQc3/a', 1);
-- ----------------------------
-- Table structure for t_user_role
-- ----------------------------
DROP TABLE IF EXISTS `t_user_role`;
CREATE TABLE `t_user_role`  (
  `UID` int(11) NOT NULL COMMENT '用户编号',
  `RID` int(11) NOT NULL COMMENT '角色编号',
  PRIMARY KEY (`UID`, `RID`) USING BTREE,
  INDEX `FK_Reference_10`(`RID`) USING BTREE,
  CONSTRAINT `FK_Reference_10` FOREIGN KEY (`RID`) REFERENCES `t_role` (`ID`) ON DELETE RESTRICT ON UPDATE RESTRICT,
  CONSTRAINT `FK_Reference_9` FOREIGN KEY (`UID`) REFERENCES `t_user` (`id`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
-- ----------------------------
-- Records of t_user_role
-- ----------------------------
INSERT INTO `t_user_role` VALUES (1, 1);
INSERT INTO `t_user_role` VALUES (2, 2);
INSERT INTO `t_user_role` VALUES (3, 4);
INSERT INTO `t_user_role` VALUES (4, 5);
SET FOREIGN_KEY_CHECKS = 1;

2.2 SpringSecurity认证基本原理与认证2种方式

在工程中添加Spring Security的依赖

     org.springframework.boot
     spring-boot-starter-security

​ 在使用SpringSecurity框架，该框架会默认自动地替我们将系统中的资源进行保护，每次访问资源的时候都必须经过一层身份的校验，如果通过了则重定向到我们输入的url中，否则访问是要被拒绝的。那么SpringSecurity框架是如何实现的呢? Spring Security功能的实现主要是由一系列过滤器相互配合完成。也称之为过滤器链

2.2.1 过滤器链介绍

过滤器是一种典型的AOP思想，下面简单了解下这些过滤器链,后续再源码剖析中在涉及到过滤器链在仔细讲解.

1. org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFilter

   根据请求封装获取WebAsyncManager，从WebAsyncManager获取/注册的安全上下文可调用处理拦截器

2. org.springframework.security.web.context.SecurityContextPersistenceFilter

   SecurityContextPersistenceFilter主要是使用SecurityContextRepository在session中保存或更新一个SecurityContext，并将SecurityContext给以后的过滤器使用，来为后续fifilter建立所需的上下文。SecurityContext中存储了当前用户的认证以及权限信息。

3. org.springframework.security.web.header.HeaderWriterFilter

   向请求的Header中添加相应的信息,可在http标签内部使用security:headers来控制

4. org.springframework.security.web.csrf.CsrfFilter

   csrf又称跨域请求伪造，SpringSecurity会对所有post请求验证是否包含系统生成的csrf的token信息，如果不包含，则报错。起到防止csrf攻击的效果。

5. org.springframework.security.web.authentication.logout.LogoutFilter

   匹配URL为https://blog.csdn.net/logout的请求，实现用户退出,清除认证信息。

6. org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter

   表单认证操作全靠这个过滤器，默认匹配URL为/login且必须为POST请求。

7. org.springframework.security.web.authentication.ui.DefaultLoginPageGeneratingFilter

   如果没有在配置文件中指定认证页面，则由该过滤器生成一个默认认证页面。

8. org.springframework.security.web.authentication.ui.DefaultLogoutPageGeneratingFilter

   由此过滤器可以生产一个默认的退出登录页面

9. org.springframework.security.web.authentication.www.BasicAuthenticationFilter

   此过滤器会自动解析HTTP请求中头部名字为Authentication，且以Basic开头的头信息。

10. org.springframework.security.web.savedrequest.RequestCacheAwareFilter

    通过HttpSessionRequestCache内部维护了一个RequestCache，用于缓存HttpServletRequest

11. org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter

    针对ServletRequest进行了一次包装，使得request具有更加丰富的API

12. org.springframework.security.web.authentication.AnonymousAuthenticationFilter

    当SecurityContextHolder中认证信息为空,则会创建一个匿名用户存入到SecurityContextHolder中。spring security为了兼容未登录的访问，也走了一套认证流程，只不过是一个匿名的身份。

13. org.springframework.security.web.session.SessionManagementFilter

    securityContextRepository限制同一用户开启多个会话的数量

14. org.springframework.security.web.access.ExceptionTranslationFilter

    异常转换过滤器位于整个springSecurityFilterChain的后方，用来转换整个链路中出现的异常

15. org.springframework.security.web.access.intercept.FilterSecurityInterceptor

    获取所配置资源访问的授权信息，根据SecurityContextHolder中存储的用户信息来决定其是否有权限。

    Spring Security默认加载15个过滤器, 但是随着配置可以增加或者删除一些过滤器.

2.2.2 认证方式

1. HttpBasic认证

   ​ HttpBasic登录验证模式是Spring Security实现登录验证最简单的一种方式，也可以说是最简陋的一种方式。它的目的并不是保障登录验证的绝对安全，而是提供一种“防君子不防小人”的登录验证。

   ​ 在使用的Spring Boot早期版本为1.X版本,依赖的Security 4.X版本，那么就无需任何配置，启动项目访问则会弹出默认的httpbasic认证。现在使用的是spring boot2.0以上版本（依赖Security 5.X版本），HttpBasic不再是默认的验证模式，在spring security 5.x默认的验证模式已经是表单模式。

   ​ HttpBasic模式要求传输的用户名密码使用Base64模式进行加密。如果用户名是 “admin” ，密码是“ admin”，则将字符串"admin:admin" 使用Base64编码算法加密。加密结果可能是：YWtaW46YWRtaW4=。HttpBasic模式真的是非常简单又简陋的验证模式，Base64的加密算法是可逆的,想要破解并不难.

   

2. formLogin登录认证模式

   ​ Spring Security的HttpBasic模式，该模式比较简单，只是进行了通过携带Http的Header进行简单的登录验证，而且没有定制的登录页面，所以使用场景比较窄。对于一个完整的应用系统，与登录验证相关的页面都是高度定制化的，非常美观而且提供多种登录方式。这就需要Spring Security支持我们自己定制登录页面, spring boot2.0以上版本（依赖Security 5.X版本）默认会生成一个登录页面.

   

2.3 表单认证

2.3.1 自定义表单登录页面

• 在config包下编写SecurityConfiguration配置类

  package com.boxuegu.config;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  /**
   * Security配置类
   */
  @Configuration
  public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
      /**
       * http请求处理方法
       *
       * @param http
       * @throws Exception
       */
      @Override
      protected void configure(HttpSecurity http) throws Exception {
          /*http.httpBasic()//开启httpbasic认证
                  .and().authorizeRequests().
                  anyRequest().authenticated();//所有请求都需要登录认证才能访问*/
          http.formLogin()//开启表单认证
                  .and().authorizeRequests().
                  .anyRequest().authenticated();//所有请求都需要登录认证才能访问;
      }
  }
  

  问题一: localhost将您重定向次数过多

  

  因为设置登录页面为login.html 后面配置的是所有请求都登录认证,陷入了死循环. 所以需要将login.html放行不需要登录认证

  http.formLogin().loginPage("/login.html")//开启表单认证
                  .and().authorizeRequests().
                  antMatchers("/login.html").permitAll()//放行登录页面
                  .anyRequest().authenticated();//所有请求都需要登录认证才能访问;
  

  问题二: 访问login.html 报404错误

  

  spring boot整合thymeleaf 之后 所有的静态页面以放在resources/templates下面,所以得通过请求访问到模板页面, 将/login.html修改为/toLoginPage

  http.formLogin().loginPage("/toLoginPage")//开启表单认证
                  .and().authorizeRequests().
                  antMatchers("/toLoginPage").permitAll()//放行登录页面
                  .anyRequest().authenticated();//所有请求都需要登录认证才能访问;
  

  问题三: 访问login.html 后发现页面没有相关样式

  

  因为访问login.html需要一些js , css , image等静态资源信息, 所以需要将静态资源放行, 不需要认证

  /**
       * WebSecurity
       *
       * @param web
       * @throws Exception
       */
      @Override
      public void configure(WebSecurity web) throws Exception {
          //解决静态资源被拦截的问题
          web.ignoring().antMatchers("/css/**", "/images/**", "/js/**", "/favicon.ico");
      }
  

  Spring Security中，安全构建器HttpSecurity和WebSecurity的区别是 :

  1. WebSecurity不仅通过HttpSecurity定义某些请求的安全控制，也通过其他方式定义其他某些请求可以忽略安全控制;

  2. HttpSecurity仅用于定义需要安全控制的请求(当然HttpSecurity也可以指定某些请求不需要安全控制);

  3. 可以认为HttpSecurity是WebSecurity的一部分，WebSecurity是包含HttpSecurity的更大的一个概念;

  4. 构建目标不同

     • WebSecurity构建目标是整个Spring Security安全过滤器FilterChainProxy`,

     • HttpSecurity的构建目标仅仅是FilterChainProxy中的一个SecurityFilterChain。

  2.3.2 表单登录

  ​ 通过讲解过滤器链中我们知道有个过滤器UsernamePasswordAuthenticationFilter是处理表单登录的. 那么下面我们来通过源码观察下这个过滤器.

  

  ​ 在源码中可以观察到, 表单中的input的name值是username和password, 并且表单提交的路径为/login, 表单提交方式method为post, 这些可以修改为自定义的值.

  代码如下:

  /**
       * http请求处理方法
       *
       * @param http
       * @throws Exception
       */
      @Override
      protected void configure(HttpSecurity http) throws Exception {
          /*http.httpBasic()//开启httpbasic认证
                  .and().authorizeRequests().
                  anyRequest().authenticated();//所有请求都需要登录认证才能访问*/
          http.formLogin()//开启表单认证
                  .loginPage("/toLoginPage")//自定义登录页面
                  .loginProcessingUrl("/login")// 登录处理Url
               .usernameParameter("username").passwordParameter("password"). //修改自定义表单name值.
                  .successForwardUrl("/")// 登录成功后跳转路径
                  .and().authorizeRequests().
                  antMatchers("/toLoginPage").permitAll()//放行登录页面
                  .anyRequest().authenticated();//所有请求都需要登录认证才能访问;
          // 关闭csrf防护
  		http..csrf().disable();
      }
  

  页面代码:

  

  代码修改后重启完成登录:

  

  这个时候又出现新的问题了. 这个是什么原因呢? 我们来看出现问题的具体是哪里?

  

  发现行内框架iframe这里出现问题了. Spring Security下，X-Frame-Options默认为DENY,非Spring Security环境下，X-Frame-Options的默认大多也是DENY，这种情况下，浏览器拒绝当前页面加载任何Frame页面，设置含义如下：

  • DENY：浏览器拒绝当前页面加载任何Frame页面 此选择是默认的.
  • SAMEORIGIN：frame页面的地址只能为同源域名下的页面

    允许iframe加载

    http.formLogin()//开启表单认证
                    .loginPage("/toLoginPage")//自定义登录页面
                    .loginProcessingUrl("/login")// 登录处理Url
        			.usernameParameter("username").passwordParameter("password"). //修改自定义表单name值.
                    .successForwardUrl("/")// 登录成功后跳转路径
                    .and().authorizeRequests().
                    antMatchers("/toLoginPage").permitAll()//放行登录页面与静态资源
                    .anyRequest().authenticated();//所有请求都需要登录认证才能访问;       
    		// 关闭csrf防护
    		http.csrf().disable();
    		// 允许iframe加载页面
            http.headers().frameOptions().sameOrigin();	
    

    2.3.3 基于数据库实现认证功能

    之前我们所使用的用户名和密码是来源于框架自动生成的, 那么我们如何实现基于数据库中的用户名和密码功能呢? 要实现这个得需要实现security的一个UserDetailsService接口, 重写这个接口里面loadUserByUsername即可

    • 编写MyUserDetailsService并实现UserDetailsService接口,重写loadUserByUsername方法

      package com.boxuegu.service.impl;
      import com.boxuegu.domain.User;
      import com.boxuegu.service.UserService;
      import org.springframework.beans.factory.annotation.Autowired;
      import org.springframework.security.core.GrantedAuthority;
      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.ArrayList;
      import java.util.Collection;
      /**
       * 基于数据库中完成认证
       */
      @Service
      public class MyUserDetailsService implements UserDetailsService {
          @Autowired
          UserService userService;
          /**
           * 根据username查询用户实体
           *
           * @param username
           * @return
           * @throws UsernameNotFoundException
           */
          @Override
          public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
              User user = userService.findByUsername(username);
              if (user == null) {
                  throw new UsernameNotFoundException(username);// 用户名没有找到
              }
              // 先声明一个权限集合, 因为构造方法里面不能传入null
              Collection authorities = new ArrayList<>();
              // 需要返回一个SpringSecurity的UserDetails对象
              UserDetails userDetails =
                      new org.springframework.security.core.userdetails.User(user.getUsername(),
                              "{noop}" + user.getPassword(),// {noop}表示不加密认证。
                              true, // 用户是否启用 true 代表启用
                              true,// 用户是否过期 true 代表未过期
                              true,// 用户凭据是否过期 true 代表未过期
                              true,// 用户是否锁定 true 代表未锁定
                              authorities);
              return userDetails;
          }
      }
      

    • 在SecurityConfiguration配置类中指定自定义用户认证

       /**
           * 身份验证管理器
           *
           * @param auth
           * @throws Exception
           */
          @Override
          protected void configure(AuthenticationManagerBuilder auth) throws Exception {
              auth.userDetailsService(myUserDetailsService);// 使用自定义用户认证
          }	
      

      2.3.4 密码加密认证

      ​ 在基于数据库完成用户登录的过程中,我们所是使用的密码是明文的，规则是通过对密码明文添加{noop}前缀。那么下面 Spring Security 中的密码编码进行一些探讨。

      ​ Spring Security 中PasswordEncoder就是我们对密码进行编码的工具接口。该接口只有两个功能： 一个是匹配验证。另一个是密码编码。

      

      • BCrypt算法介绍

        ​ 任何应用考虑到安全，绝不能明文的方式保存密码。密码应该通过哈希算法进行加密。 有很多标准的算法比如SHA或者MD5，结合salt(盐)是一个不错的选择。 Spring Security 提供了BCryptPasswordEncoder类,实现Spring的PasswordEncoder接口使用BCrypt强哈希方法来加密密码。BCrypt强哈希方法 每次加密的结果都不一样,所以更加的安全。

        ​ bcrypt算法相对来说是运算比较慢的算法，在密码学界有句常话：越慢的算法越安全。黑客破解成本越高.通过salt和const这两个值来减缓加密过程，它的加密时间（百ms级）远远超过md5（大概1ms左右）。对于计算机来说，Bcrypt 的计算速度很慢，但是对于用户来说，这个过程不算慢。bcrypt是单向的，而且经过salt和cost的处理，使其受攻击破解的概率大大降低，同时破解的难度也提升不少，相对于MD5等加密方式更加安全，而且使用也比较简单

        bcrypt加密后的字符串形如：$2a$10$wouq9P/HNgvYj2jKtUN8rOJJNRVCWvn1XoWy55N3sCkEHZPo3lyWq

        其中$是分割符，无意义；2a是bcrypt加密版本号；10是const的值；而后的前22位是salt值；再然后的字符串就是密码的密文了；这里的const值即生成salt的迭代次数，默认值是10，推荐值12。

        • 在项目中使用BCrypt

          首先看下PasswordEncoderFactories 密码器工厂

          

          之前我们在项目中密码使用的是明文的是noop , 代表不加密使用明文密码, 现在用BCrypt只需要将noop换成bcrypt即可

          @Override
              public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
                  User user = userService.findByUsername(username);
                  if (user == null) {
                      throw new UsernameNotFoundException(username);// 用户名没有找到
                  }
                  // 先声明一个权限集合, 因为构造方法里面不能传入null
                  Collection authorities = new ArrayList<>();
                  // 需要返回一个SpringSecurity的UserDetails对象
                  UserDetails userDetails =
                          new org.springframework.security.core.userdetails.User(user.getUsername(),
                                  "{bcrypt}" + user.getPassword(),// {noop}表示不加密认证。{bcrypt} 加密认证
                                  true, // 用户是否启用 true 代表启用
                                  true,// 用户是否过期 true 代表未过期
                                  true,// 用户凭据是否过期 true 代表未过期
                                  true,// 用户是否锁定 true 代表未锁定
                                  authorities);
                  return userDetails;
              }
          

          同时需要将数据库中的明文密码修改为加密密码

          

          选择一个放入数据库即可.

          

          2.3.5 获取当前登录用户

          ​ 在传统web系统中, 我们将登录成功的用户放入session中, 在需要的时候可以从session中获取用户, 那么Spring Security中我们如何获取当前已经登录的用户呢?

          • SecurityContextHolder

            保留系统当前的安全上下文SecurityContext，其中就包括当前使用系统的用户的信息。

          • SecurityContext

            安全上下文,获取当前经过身份验证的主体或身份验证请求令牌

            代码实现:

            /**
                 * 获取当前登录用户
                 *
                 * @return
                 */
                @RequestMapping("/loginUser")
                @ResponseBody
                public UserDetails getCurrentUser() {
                    UserDetails userDetails = (UserDetails)
                            SecurityContextHolder.getContext().getAuthentication().getPrincipal();
                    return userDetails;
                }
            

            除了上述方法, Spring Security 还提供了2种方式可以获取.

            /**
                 * 获取当前登录用户
                 *
                 * @return
                 */
                @RequestMapping("/loginUser1")
                @ResponseBody
                public UserDetails getCurrentUser() {
                    UserDetails userDetails = (UserDetails)
                            SecurityContextHolder.getContext().getAuthentication().getPrincipal();
                    return userDetails;
                }
                /**
                 * 获取当前登录用户
                 *
                 * @return
                 */
                @RequestMapping("/loginUser2")
                @ResponseBody
                public UserDetails getCurrentUser(Authentication authentication) {
                    UserDetails userDetails = (UserDetails) authentication.getPrincipal();
                    return userDetails;
                }
                /**
                 * 获取当前登录用户
                 *
                 * @return
                 */
                @RequestMapping("/loginUser3")
                @ResponseBody
                public UserDetails getCurrentUser(@AuthenticationPrincipal UserDetails userDetails) {
                    return userDetails;
                }
            

            2.3.5 remember me 记住我

            ​ 在大多数网站中，都会实现RememberMe这个功能，方便用户在下一次登录时直接登录，避免再次输入用户名以及密码去登录,Spring Security针对这个功能已经帮助我们实现, 下面我们来看下他的原理图.

            • 简单的Token生成方法

              

              ​ Token=MD5(username+分隔符+expiryTime+分隔符+password)

              注意: 这种方式不推荐使用, 有严重的安全问题. 就是密码信息在前端浏览器cookie中存放. 如果cookie被盗取很容易破解.

              代码实现:

              1. 前端页面需要增加remember-me的复选框

                  
                 
                          
                 
                             
                             记住我
                          
                 
                 

              2. 后台代码开启remember-me功能

                 .and().rememberMe()//开启记住我功能
                                 .tokenValiditySeconds(1209600)// token失效时间默认2周
                                 .rememberMeParameter("remember-me")// 自定义表单name值
                 

              3. 登录成功后前台cookie

                 

              • 持久化的Token生成方法

                

                ​ 存入数据库Token包含:

                ​ token: 随机生成策略,每次访问都会重新生成

                ​ series: 登录序列号，随机生成策略。用户输入用户名和密码登录时，该值重新生成。使用remember-me功能，该值保持不变

                ​ expiryTime: token过期时间。

                ​ CookieValue=encode(series+token)

                ​

                代码实现:

                1. 后台代码

                   /**
                        * http请求处理方法
                        *
                        * @param http
                        * @throws Exception
                        */
                       @Override
                       protected void configure(HttpSecurity http) throws Exception {
                           /*http.httpBasic()//开启httpbasic认证
                                   .and().authorizeRequests().
                                   anyRequest().authenticated();//所有请求都需要登录认证才能访问*/
                           http.formLogin()//开启表单认证
                                   .loginPage("/toLoginPage")//自定义登录页面
                                   .loginProcessingUrl("/login")// 登录处理Url
                                   //.usernameParameter().passwordParameter(). 修改自定义表单name值.
                                   .successForwardUrl("/")// 登录成功后跳转路径
                                   .and().authorizeRequests().
                                   antMatchers("/toLoginPage").permitAll()//放行登录页面与静态资源
                                   .anyRequest().authenticated()//所有请求都需要登录认证才能访问;
                                   .and().rememberMe()//开启记住我功能
                                   .tokenValiditySeconds(1209600)// token失效时间默认2周
                                   .rememberMeParameter("remember-me")// 自定义表单name值
                                   .tokenRepository(getPersistentTokenRepository());// 设置tokenRepository
                           // 关闭csrf防护
                           http.csrf().disable();
                           // 允许iframe加载页面
                           http.headers().frameOptions().sameOrigin();
                           
                       }
                       @Autowired
                       DataSource dataSource;
                       /**
                        * 持久化token,负责token与数据库之间的相关操作
                        *
                        * @return
                        */
                       @Bean
                       public PersistentTokenRepository getPersistentTokenRepository() {
                           JdbcTokenRepositoryImpl tokenRepository = new JdbcTokenRepositoryImpl();
                           tokenRepository.setDataSource(dataSource);//设置数据源
                           // 启动时创建一张表, 第一次启动的时候创建, 第二次启动的时候需要注释掉, 否则会报错
                           tokenRepository.setCreateTableOnStartup(true);
                         return tokenRepository;
                       }
                   

                   项目启动成功后,观察数据库,会帮助我们创建persistent_logins表

                

                2. 再次完成登录功能.

                   观察数据库,会插入一条记录.说明持久化token方式已经生效

                   

                   再观察cookie值

                   

                3. Cookie窃取伪造演示

                   • 使用网页登录系统,记录remember-me的值

                   • 使用postman 伪造cookie

                     

                   • 安全验证

                       /**
                          * 根据用户ID查询用户
                          *
                          * @return
                          */
                         @GetMapping("/{id}")
                         @ResponseBody
                         public User getById(@PathVariable Integer id) {
                             //获取认证信息
                             Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
                             // 判断认证信息是否来源于RememberMe
                             if (RememberMeAuthenticationToken.class.isAssignableFrom(authentication.getClass())) {
                                 throw new RememberMeAuthenticationException("认证信息来源于RememberMe,请重新登录");
                             }
                             User user = userService.getById(id);
                             return user;
                         }
                     

                 
                 在重要操作步骤可以加以验证, true代表自动登录,则引导用户重新表单登录,  false正常进行
                #### 2.3.6 自定义登录成功处理和失败处理
                ​		  在某些场景下,用户登录成功或失败的情况下用户需要执行一些后续操作,比如登录日志的搜集, 或者在现在目前前后端分离的情况下用户登录成功和失败后需要给前台页面返回对应的错误信息, 有前台主导登录成功或者失败的页面跳转. 这个时候需要要到用到AuthenticationSuccessHandler与AnthenticationFailureHandler.
                **自定义成功处理：**
                ​        实现AuthenticationSuccessHandler接口，并重写onAnthenticationSuccesss()方法.
                **自定义失败处理：**
                ​		实现AuthenticationFailureHandler接口，并重写onAuthenticationFailure()方法；
                 
                1. 代码实现登录成功或失败的自定义处理
                 - SecurityConfiguration类
                   ```java
                   .successHandler(myAuthenticationService)//自定义登录成功处理
                                   .failureHandler(myAuthenticationService)//自定义登录失败处理
                

                • MyAuthenticationService类

                  package com.boxuegu.service.impl;
                  import org.springframework.security.core.Authentication;
                  import org.springframework.security.core.AuthenticationException;
                  import org.springframework.security.web.DefaultRedirectStrategy;
                  import org.springframework.security.web.RedirectStrategy;
                  import org.springframework.security.web.authentication.AuthenticationFailureHandler;
                  import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
                  import org.springframework.stereotype.Component;
                  import org.springframework.stereotype.Service;
                  import javax.servlet.FilterChain;
                  import javax.servlet.ServletException;
                  import javax.servlet.http.HttpServletRequest;
                  import javax.servlet.http.HttpServletResponse;
                  import java.io.IOException;
                  import java.util.HashMap;
                  import java.util.Map;
                  /**
                   * 自定义登录成功或失败处理类
                   */
                  @Service
                  public class MyAuthenticationService implements AuthenticationSuccessHandler, AuthenticationFailureHandler {
                      private RedirectStrategy redirectStrategy = new DefaultRedirectStrategy();
                   @Override
                      public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authentication) throws IOException, ServletException {
                     
                      }
                      @Override
                      public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
                          System.out.println("登录成功后续处理....");
                          //重定向到index页
                          redirectStrategy.sendRedirect(request, response, "/");
                      }
                      @Override
                      public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
                          System.out.println("登录失败后续处理....");
                           //重定向到login页
                          redirectStrategy.sendRedirect(request, response, "/toLoginPage");
                      }
                  }
                  

                  2. 异步用户登录实现

                     • 前端页面改造

                       
                                       
                       
                                          .....