什么是认证

进入移动互联网时代，大家每天都在刷手机，常用的软件有微信、支付宝、头条等，下边拿微信来举例子说明认证

相关的基本概念，在初次使用微信前需要注册成为微信用户，然后输入账号和密码即可登录微信，输入账号和密码

登录微信的过程就是认证。

系统为什么要认证？

认证是为了保护系统的隐私数据与资源，用户的身份合法方可访问该系统的资源。

认证 ：用户认证就是判断一个用户的身份是否合法的过程，用户去访问系统资源时系统要求验证用户的身份信息，身份合法方可继续访问，不合法则拒绝访问。常见的用户身份认证方式有：用户名密码登录，二维码登录，手机短信登录，指纹认证等方式。

什么是授权

还拿微信来举例子，微信登录成功后用户即可使用微信的功能，比如，发红包、发朋友圈、添加好友等，没有绑定 银行卡的用户是无法发送红包的，绑定银行卡的用户才可以发红包，发红包功能、发朋友圈功能都是微信的资源即 功能资源，用户拥有发红包功能的权限才可以正常使用发送红包功能，拥有发朋友圈功能的权限才可以使用发朋友 圈功能，这个根据用户的权限来控制用户使用资源的过程就是授权。

认证是为了保证用户身份的合法性，授权则是为了更细粒度的对隐私数据进行划分，授权是在认证通过后发生的，

控制不同的用户能够访问不同的资源。

授权 ： 授权是用户认证通过根据用户的权限来控制用户访问资源的过程，拥有资源的访问权限则正常访问，没有

权限则拒绝访问。

什么是会话

用户认证通过后，为了避免用户的每次操作都进行认证可将用户的信息保证在会话中。会话就是系统为了保持当前 用户的登录状态所提供的机制，常见的有基于session方式、基于token方式等。

基于session的认证方式如下图 ：

它的交互流程是，用户认证成功后，在服务端生成用户相关的数据保存在session(当前会话)中，发给客户端的 sesssion_id 存放到 cookie 中，这样用户客户端请求时带上 session_id 就可以验证服务器端是否存在 session 数 据，以此完成用户的合法校验，当用户退出系统或session过期销毁时,客户端的session_id也就无效了。

基于token方式如下图 ：

它的交互流程是，用户认证成功后，服务端生成一个token发给客户端，客户端可以放到 cookie 或 localStorage

等存储中，每次请求时带上 token，服务端收到token通过验证后即可确认用户身份。

基于session的认证方式由Servlet规范定制，服务端要存储session信息需要占用内存资源，客户端需要支持

cookie；基于token的方式则一般不需要服务端存储token，并且不限制客户端的存储方式。如今移动互联网时代

更多类型的客户端需要接入系统，系统多是采用前后端分离的架构进行实现，所以基于token的方式更适合。

授权的数据模型

如何进行授权即如何对用户访问资源进行控制，首先需要学习授权相关的数据模型。 授权可简单理解为Who对What(which)进行How操作，包括如下： Who，即主体（Subject），主体一般是指用户，也可以是程序，需要访问系统中的资源。 What，即资源 （Resource），如系统菜单、页面、按钮、代码方法、系统商品信息、系统订单信息等。系统菜单、页面、按 钮、代码方法都属于系统功能资源，对于web系统每个功能资源通常对应一个URL；系统商品信息、系统订单信息 都属于实体资源（数据资源），实体资源由资源类型和资源实例组成，比如商品信息为资源类型，商品编号 为001 的商品为资源实例。 How，权限/许可（Permission），规定了用户对资源的操作许可，权限离开资源没有意义， 如用户查询权限、用户添加权限、某个代码方法的调用权限、编号为001的用户的修改权限等，通过权限可知用户 对哪些资源都有哪些操作许可。

主体、资源、权限关系如下图：

主体、资源、权限相关的数据模型如下：

主体（用户id、账号、密码、...）

资源（资源id、资源名称、访问地址、...）

权限（权限id、权限标识、权限名称、资源id、...）

角色（角色id、角色名称、...）

角色和权限关系（角色id、权限id、...）

主体（用户）和角色关系（用户id、角色id、...）

主体（用户）、资源、权限关系如下图：

通常企业开发中将资源和权限表合并为一张权限表，如下：

资源（资源id、资源名称、访问地址、...）

权限（权限id、权限标识、权限名称、资源id、...）

权限（权限id、权限标识、权限名称、资源名称、资源访问地址、...）

修改后数据模型之间的关系如下图：

如何实现授权？业界通常基于RBAC实现授权。

基于角色的访问控制

RBAC基于角色的访问控制（Role-Based Access Control）是按角色进行授权，比如：主体的角色为总经理可以查

询企业运营报表，查询员工工资信息等，访问控制流程如下：

根据上图中的判断逻辑，授权代码可表示如下：

if(主体.hasRole("总经理角色id")){ 查询工资 }
如果上图中查询工资所需要的角色变化为总经理和部门经理，此时就需要修改判断逻辑为“判断用户的角色是否是
总经理或部门经理”，修改代码如下：
if(主体.hasRole("总经理角色id") || 主体.hasRole("部门经理角色id")){ 查询工资 }
根据上边的例子发现，当需要修改角色的权限时就需要修改授权的相关代码，系统可扩展性差。
SpringSecurity
SpringSecurity简介
安全框架概述
　什么是安全框架？ 解决系统安全问题的框架。如果没有安全框架，我们需要手动处理每个资源的访问控制，非常麻烦。使用安全框架，我们可以通过配置的方式实现对资源的访问限制。
常用安全框架
Spring Security：Spring家族一员。是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC，DI（控制反转Inversion of Control,DI:Dependency Injection 依赖注入）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码的工作。
Apache Shiro：一个功能强大且易于使用的Java安全框架,提供了认证,授权,加密,和会话管理。
Spring Security简介
　Spring Security是一个高度自定义的安全框架。利用 Spring IoC/DI和AOP功能，为系统提供了声明式安全访问控制功能，减少了为系统安全而编写大量重复代码的工作。使用 Spring Secruity 的原因有很多，但大部分都是发现了 javaEE的 Servlet 规范或 EJB 规范中的安全功能缺乏典型企业应用场景。同时认识到他们在 WAR 或 EAR 级别无法移植。因此如果你更换服务器环境，还有大量工作去重新配置你的应用程序。使用 Spring Security解决了这些问题，也为你提供许多其他有用的、可定制的安全功能。正如你可能知道的两个应用程序的两个主要区域是“认证”和“授权”（或者访问控制）。这两点也是 Spring Security 重要核心功能。“认证”，是建立一个他声明的主体的过程（一个“主体”一般是指用户，设备或一些可以在你的应用程序中执行动作的其他系统），通俗点说就是系统认为用户是否能登录。“授权”指确定一个主体是否允许在你的应用程序执行一个动作的过程。通俗点讲就是系统判断用户是否有权限去做某些事情。
　Spring Security 以“The Acegi Secutity System for Spring”的名字始于2003年年底。其前身为 acegi 项目。起因是 Spring 开发者邮件列表中一个问题，有人提问是否考虑提供一个基于 Spring 的安全实现。限制于时间问题，开发出了一个简单的安全实现，但是并没有深入研究。几周后，Spring 社区中其他成员同样询问了安全问题，代码提供给了这些人。2004 年 1 月份已经有 20 人左右使用这个项目。随着更多人的加入，在 2004 年 3 月左右在 sourceforge 中建立了一个项目。在最开始并没有认证模块，所有的认证功能都是依赖容器完成的，而 acegi 则注重授权。但是随着更多人的使用，基于容器的认证就显现出了不足。acegi 中也加入了认证功能。大约 1 年后 acegi 成为 Spring子项目。在 2006 年 5 月发布了 acegi 1.0.0 版本。2007 年底 acegi 更名为Spring Security。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.2.2.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>
   <groupId>com.yjxxt</groupId>
   <artifactId>springsecurity-demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>springsecurity-demo</name>
   <description>Demo project for Spring Boot</description>
   <properties>
      <java.version>1.8</java.version>
   </properties>
   <dependencies>
      <!--spring security 组件-->
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-security</artifactId>
      </dependency>
      <!--web 组件-->
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <!-- test 组件-->
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
         <exclusions>
            <exclusion>
               <groupId>org.junit.vintage</groupId>
               <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
         </exclusions>
      </dependency>
      <dependency>
         <groupId>org.springframework.security</groupId>
         <artifactId>spring-security-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>
login.html
<!DOCTYPE html>
<html lang="en">
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<form action="/login" method="post">
    用户名：<input type="text" name="username" /><br/>
    密码：<input type="password" name="password" /><br/>
    <input type="submit" value="登录" />
</form>
</body>
</html>
　导入spring-boot-starter-security 启动器后，Spring Security 已经生效，默认拦截全部请求，如果用户没有登录，跳转到内置登录页面。
默认的 username 为 user，password 打印在控制台中。
在浏览器中输入账号和密码后会显示 login.html 页面内容。
UserDetailsService详解
　当什么也没有配置的时候，账号和密码是由 Spring Security 定义生成的。而在实际项目中账号和密码都是从数据库中查询出来的。所以我们要通过自定义逻辑控制认证逻辑。如果需要自定义逻辑时，只需要实现 UserDetailsService 接口即可。接口定义如下：
返回值 UserDetails 是一个接口，定义如下
要想返回 UserDetails 的实例就只能返回接口的实现类。SpringSecurity 中提供了如下的实例。对于我们只需要使用里面的 User 类即可。注意 User 的全限定路径是：
org.springframework.security.core.userdetails.User此处经常和系统中自己开发的 User 类弄混。
在 User 类中提供了很多方法和属性。
其中构造方法有两个，调用其中任何一个都可以实例化
UserDetails 实现类 User 类的实例。而三个参数的构造方法实际上也是调用 7 个参数的构造方法。
username:用户名
password:密码
authorities：用户具有的权限。此处不允许为 null
　此处的用户名应该是客户端传递过来的用户名。而密码应该是从数据库中查询出来的密码。Spring Security 会根据 User 中的 password和客户端传递过来的 password 进行比较。如果相同则表示认证通过，如果不相同表示认证失败。
　authorities 里面的权限对于后面学习授权是很有必要的，包含的所有内容为此用户具有的权限，如有里面没有包含某个权限，而在做某个事情时必须包含某个权限则会出现 403。通常都是通过AuthorityUtils.commaSeparatedStringToAuthorityList(“”) 来创建authorities 集合对象的。参数是一个字符串，多个权限使用逗号分隔。
方法参数表示用户名。此值是客户端表单传递过来的数据。默认情况下必须叫 username，否则无法接收。
　UsernameNotFoundException 用户名没有发现异常。在loadUserByUsername中是需要通过自己的逻辑从数据库中取值的。如果通过用户名没有查询到对应的数据，应该抛出UsernameNotFoundException，系统就知道用户名没有查询到。
PasswordEncoder 密码解析器详解
　Spring Security 要求容器中必须有PasswordEncoder实例。所以当自定义登录逻辑时要求必须给容器注入PaswordEncoder的bean对象。
encode()：把参数按照特定的解析规则进行解析。
matches() ：验证从存储中获取的编码密码与编码后提交的原始密码是否匹配。如果密码匹配，则返回 true；如果不匹配，则返回 false。第一个参数表示需要被解析的密码。第二个参数表示存储的密码。
upgradeEncoding()：如果解析的密码能够再次进行解析且达到更安全的结果则返回 true，否则返回 false。默认返回 false。
内置解析器介绍
在 Spring Security 中内置了很多解析器。
BCryptPasswordEncoder 简介
　BCryptPasswordEncoder 是 Spring Security 官方推荐的密码解析器，平时多使用这个解析器。
　BCryptPasswordEncoder 是对 bcrypt 强散列方法的具体实现。是基于Hash算法实现的单向加密。可以通过strength控制加密强度，默认 10.
新建测试方法BCryptPasswordEncoder 用法。
package com.yjxxt.springsecuritydemo;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
 * @author zhoubin
 * @since 1.0.0
@SpringBootTest
public class MyTest {
   @Test
   public void test(){
      //创建解析器
      PasswordEncoder pw = new BCryptPasswordEncoder();
      //对密码加密
      String encode = pw.encode("123");
      System.out.println(encode);
      //判断原字符和加密后内容是否匹配
      boolean matches = pw.matches("1234", encode);
      System.out.println("==================="+matches);
自定义登录逻辑
　当 进 行 自 定 义 登 录 逻 辑 时 需 要 用 到 之 前 讲 解 的UserDetailsService 和 PasswordEncoder。但是 Spring Security 要求：当进行自定义登录逻辑时容器内必须有 PasswordEncoder 实例。所以不能直接 new 对象。
编写配置类
package com.yjxxt.springsecuritydemo.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
 * @author zhoubin
 * @since 1.0.0
@Configuration
public class SecurityConfig {
   @Bean
   public PasswordEncoder getPw(){
      return new BCryptPasswordEncoder();
自定义逻辑
在 Spring Security 中实现 UserDetailService 就表示为用户详情服务。在这个类中编写用户认证逻辑。
package com.yjxxt.springsecuritydemo.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
 * @author zhoubin
 * @since 1.0.0
@Service
public class UserServiceImpl implements UserDetailsService {
   @Autowired
   private PasswordEncoder pw;
   @Override
   public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
      //1.查询数据库判断用户名是否存在，如果不存在抛出UsernameNotFoundException异常
      if (!"admin".equals(username)){
         throw new UsernameNotFoundException("用户名不存在");
      //2.把查询出来的密码（注册时已经加密过）进行解析，或直接把密码放入构造方法中
      String password = pw.encode("123");
      return new User(username,password, AuthorityUtils.commaSeparatedStringToAuthorityList("admin,normal"));
重启项目后，在浏览器中输入账号：admin，密码：123。后可以正确进入到 login.html 页面。
自定义登录页面
　虽然 Spring Security 给我们提供了登录页面，但是对于实际项目中，大多喜欢使用自己的登录页面。所以 Spring Security 中不仅仅提供了登录页面，还支持用户自定义登录页面。实现过程也比较简单，只需要修改配置类即可。
编写登录页面
login.html
<!DOCTYPE html>
<html lang="en">
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<form action="/login" method="post">
    用户名：<input type="text" name="username" /><br/>
    密码：<input type="password" name="password" /><br/>
    <input type="submit" value="登录" />
</form>
</body>
</html>
修改配置类
修改配置类中主要是设置哪个页面是登录页面。配置类需要继承WebSecurityConfigurerAdapter,并重写 configure 方法。
successForwardUrl()：登录成功后跳转地址
loginPage() ：登录页面
loginProcessingUrl ：登录页面表单提交地址，此地址可以不真实存在。
antMatchers()：匹配内容
permitAll()：允许
package com.yjxxt.springsecuritydemo.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
 * @author zhoubin
 * @since 1.0.0
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
   @Override
   protected void configure(HttpSecurity http) throws Exception {
      //表单提交
      http.formLogin()
            //自定义登录页面
            .loginPage("/login.html")
            //当发现/login时认为是登录，必须和表单提交的地址一样。去执行UserServiceImpl
            .loginProcessingUrl("/login")
            //登录成功后跳转页面，POST请求
            .successForwardUrl("/toMain");
      http.authorizeRequests()
            //login.html不需要被认证
            .antMatchers("/login.html").permitAll()
            //所有请求都必须被认证，必须登录后被访问
            .anyRequest().authenticated();
      //关闭csrf防护
      http.csrf().disable();
   @Bean
   public PasswordEncoder getPw(){
      return new BCryptPasswordEncoder();
编写控制器
package com.yjxxt.springsecuritydemo.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
 * @author zhoubin
 * @since 1.0.0
@Controller
public class LoginController {
   //该方法不执行
   // @RequestMapping("/login")
   // public String login(){
   //     System.out.println("登录方法");
   //     return "main.html";
    * 成功后跳转页面
    * @return
   @RequestMapping("/toMain")
   public String toMain(){
      return "redirect:/main.html";
认证过程其他常用配置
表单处理中成功会跳转到一个地址，失败也可以跳转到一个地址。
编写页面error.html
<!DOCTYPE html>
<html lang="en">
    <meta charset="UTF-8">
    <title>Title</title>
</head>
操作失败，请重新登录 <a href= "/login.html">跳转</a>
</body>
</html>
修改表单配置
　在配置方法中表单认证部分添加 failureForwardUrl()方法，表示登录失败跳转的 url。此处依然是 POST 请求，所以跳转到可以接收 POST请求的控制器/error中。
//表单提交
http.formLogin()
      //自定义登录页面
      .loginPage("/login.html")
      //当发现/login时认为是登录，必须和表单提交的地址一样。去执行UserServiceImpl
      .loginProcessingUrl("/login")
      //登录成功后跳转页面，POST请求
      .successForwardUrl("/toMain")
      //登录失败后跳转页面，POST请求
      .failureForwardUrl("/toError");
添加控制器的方法
　在控制器类中添加控制器方法，方法映射路径/error。此处要注意：由于是 POST 请求访问/error。所以如果返回值直接转发到 error.html 中，即使有效果，控制台也会报警告，提示 error.html 不支持 POST 访问方式。
 * 失败后跳转页面
 * @return
@RequestMapping("/toError")
public String toError(){
   return "redirect:/error.html";
设置error.html不需要认证
http.authorizeRequests()
      //login.html不需要被认证
      .antMatchers("/login.html").permitAll()
      //error.html不需要被认证
      .antMatchers("/error.html").permitAll()
      //所有请求都必须被认证，必须登录后被访问
      .anyRequest().authenticated();
设置请求账户和密码的参数名
当进行登录时会执行 UsernamePasswordAuthenticationFilter 过滤器。
usernamePasrameter：账户参数名
passwordParameter：密码参数名
postOnly=true：默认情况下只允许POST请求。
//表单提交
http.formLogin()
      //自定义登录页面
      .loginPage("/login.html")
      //当发现/login时认为是登录，必须和表单提交的地址一样。去执行UserServiceImpl
      .loginProcessingUrl("/login")
      //登录成功后跳转页面，POST请求
      .successForwardUrl("/toMain")
      //登录失败后跳转页面，POST请求
      .failureForwardUrl("/toError")
      .usernameParameter("myusername")
      .passwordParameter("mypassword");
修改login.html
<form action="/login" method="post">
    用户名：<input type="text" name="myusername" /><br/>
    密码：<input type="password" name="mypassword" /><br/>
    <input type="submit" value="登录" />
</form>
自定义登录成功处理器
　使用successForwardUrl()时表示成功后转发请求到地址。内部是通过 successHandler()方法进行控制成功后交给哪个类进行处理
　ForwardAuthenticationSuccessHandler内部就是最简单的请求转发。由于是请求转发，当遇到需要跳转到站外或在前后端分离的项目中就无法使用了。
当需要控制登录成功后去做一些事情时，可以进行自定义认证成功控制器。
新建类 com.yjxxt.handler.MyAuthenticationSuccessHandler 编写如下：
package com.yjxxt.springsecuritydemo.handler;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
 * @author zhoubin
 * @since 1.0.0
public class MyAuthenticationSuccessHandler implements AuthenticationSuccessHandler {
   private String url;
   public MyAuthenticationSuccessHandler(String url) {
      this.url = url;
   @Override
   public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
      //Principal 主体，存放了登录用户的信息
      User user = (User) authentication.getPrincipal();
      System.out.println(user.getUsername());
      //输出null
      System.out.println(user.getPassword());
      System.out.println(user.getAuthorities());
      response.sendRedirect(url);
修改配置项




    

使用 successHandler()方法设置成功后交给哪个对象进行处理
//表单提交
http.formLogin()
      //自定义登录页面
      .loginPage("/login.html")
      //当发现/login时认为是登录，必须和表单提交的地址一样。去执行UserServiceImpl
      .loginProcessingUrl("/login")
      //登录成功后跳转页面，POST请求
      // .successForwardUrl("/toMain")
      //和successForwardUrl不能共存
      .successHandler(new MyAuthenticationSuccessHandler("http://www.baidu.com"))
      //登录失败后跳转页面，POST请求
      .failureForwardUrl("/toError")
      .usernameParameter("myusername")
      .passwordParameter("mypassword");
自定义登录失败处理器
failureForwardUrl()内部调用的是 failureHandler()方法
ForwardAuthenticationFailureHandler 中也是一个请求转发，并在request 作用域中设置 SPRING_SECURITY_LAST_EXCEPTION 的 key，内容为异常对象。
新建控制器
新建 com.yjxxt.handler.MyForwardAuthenticationFailureHandler 实现AuthenticationFailureHandler。在方法中添加重定向语句
package com.yjxxt.springsecuritydemo.handler;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
 * @author zhoubin
 * @since 1.0.0
public class MyForwardAuthenticationFailureHandler implements AuthenticationFailureHandler {
   private String url;
   public MyForwardAuthenticationFailureHandler(String url) {
      this.url = url;
   @Override
   public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
      response.sendRedirect(url);
修改配置类
修改配置类中表单登录部分。设置失败时交给失败处理器进行操作。failureForwardUrl 和 failureHandler 不可共存
//表单提交
http.formLogin()
      //自定义登录页面
      .loginPage("/login.html")
      //当发现/login时认为是登录，必须和表单提交的地址一样。去执行UserServiceImpl
      .loginProcessingUrl("/login")
      //登录成功后跳转页面，POST请求
      // .successForwardUrl("/toMain")
      //和successForwardUrl不能共存
      .successHandler(new MyAuthenticationSuccessHandler("http://www.baidu.com"))
      //登录失败后跳转页面，POST请求
      // .failureForwardUrl("/toError")
      .failureHandler(new MyForwardAuthenticationFailureHandler("/error.html"))
      .usernameParameter("myusername")
      .passwordParameter("mypassword");
访问控制url匹配
　在前面讲解了认证中所有常用配置，主要是对 http.formLogin()进行操作。而在配置类中 http.authorizeRequests()主要是对url进行控制，也就是我们所说的授权（访问控制）。http.authorizeRequests()也支持连缀写法，总体公式为：
url 匹配规则.权限控制方法
　通过上面的公式可以有很多 url 匹配规则和很多权限控制方法。这些内容进行各种组合就形成了Spring Security中的授权。
　在所有匹配规则中取所有规则的交集。配置顺序影响了之后授权效果，越是具体的应该放在前面，越是笼统的应该放到后面。
anyRequest()
　在之前认证过程中我们就已经使用过 anyRequest()，表示匹配所有的请求。一般情况下此方法都会使用，设置全部内容都需要进行认证。
.anyRequest().authenticated();  
antMatcher()
方法定义如下
public C antMatchers(String... antPatterns)  
参数是不定向参数，每个参数是一个 ant 表达式，用于匹配 URL规则。
规则如下：
?： 匹配一个字符
*：匹配 0 个或多个字符
** ：匹配 0 个或多个目录
在实际项目中经常需要放行所有静态资源，下面演示放行 js 文件夹下所有脚本文件。
.antMatchers("/js/**","/css/**").permitAll()  
还有一种配置方式是只要是.js 文件都放行
.antMatchers("/**/*.js").permitAll()
regexMatchers()
　使用正则表达式进行匹配。和 antMatchers()主要的区别就是参数，antMatchers()参数是 ant 表达式，regexMatchers()参数是正则表达式。
　演示所有以.js 结尾的文件都被放行。
.regexMatchers( ".+[.]js").permitAll()
两个参数时使用方式
　无论是 antMatchers()还是 regexMatchers()都具有两个参数的方法，其中第一个参数都是 HttpMethod，表示请求方式，当设置了HttpMethod 后表示只有设定的特定的请求方式才执行对应的权限设置。
枚举类型 HttpMethod 内置属性如下：
mvcMatchers()
　mvcMatchers()适用于配置了 servletPath 的情况。
　servletPath 就是所有的 URL 的统一前缀。在 SpringBoot 整合SpringMVC 的项目中可以在 application.properties 中添加下面内容设置 ServletPath
spring.mvc.servlet.path=/yjxxt
　在 Spring Security 的配置类中配置.servletPath()是 mvcMatchers()返回值特有的方法，antMatchers()和 regexMatchers()没有这个方法。在 servletPath()中配置了servletPath 后，mvcMatchers()直接写 SpringMVC 中@RequestMapping()中设置的路径即可。
.mvcMatchers("/demo").servletPath("/yjxxt").permitAll()
　如果不习惯使用 mvcMatchers()也可以使用 antMatchers()，下面代码和上面代码是等效
.antMatchers("/yjxxt/demo").permitAll()
内置访问控制方法
　Spring Security 匹配了 URL 后调用了 permitAll()表示不需要认证，随意访问。在 Spring Security 中提供了多种内置控制。
permitAll()
permitAll()表示所匹配的 URL 任何人都允许访问。
authenticated()
authenticated()表示所匹配的 URL 都需要被认证才能访问。
anonymous()
anonymous()表示可以匿名访问匹配的URL。和permitAll()效果类似，只是设置为 anonymous()的 url 会执行 filter 链中
denyAll()
denyAll()表示所匹配的 URL 都不允许被访问。
rememberMe()
被“remember me”的用户允许访问
fullyAuthenticated()
如果用户不是被 remember me 的，才可以访问。
角色权限判断
　除了之前讲解的内置权限控制。Spring Security 中还支持很多其他权限控制。这些方法一般都用于用户已经被认证后，判断用户是否具有特定的要求。
hasAuthority(String)
　判断用户是否具有特定的权限，用户的权限是在自定义登录逻辑中创建 User 对象时指定的。下图中 admin和normal 就是用户的权限。admin和normal 严格区分大小写。
在配置类中通过 hasAuthority(“admin”)设置具有 admin 权限时才能访问。
.antMatchers("/main1.html").hasAuthority("admin")
hasAnyAuthority(String ...)
如果用户具备给定权限中某一个，就允许访问。
下面代码中由于大小写和用户的权限不相同，所以用户无权访问
.antMatchers("/main1.html").hasAnyAuthority("adMin","admiN")
hasRole(String)
如果用户具备给定角色就允许访问。否则出现 403。
参数取值来源于自定义登录逻辑 UserDetailsService 实现类中创建 User 对象时给 User 赋予的授权。
　在给用户赋予角色时角色需要以：ROLE_开头，后面添加角色名称。例如：ROLE_abc 其中 abc 是角色名，ROLE_是固定的字符开头。
使用 hasRole()时参数也只写 abc 即可。否则启动报错。
给用户赋予角色：
　在配置类中直接写 abc 即可。
.antMatchers("/main1.html").hasRole("abc")
hasAnyRole(String ...)
如果用户具备给定角色的任意一个，就允许被访问
hasIpAddress(String)
如果请求是指定的 IP 就运行访问。
可以通过 request.getRemoteAddr()获取 ip 地址。
需要注意的是在本机进行测试时 localhost 和 127.0.0.1 输出的 ip地址是不一样的。
当浏览器中通过 localhost 进行访问时控制台打印的内容：
当浏览器中通过 127.0.0.1 访问时控制台打印的内容：
当浏览器中通过具体 ip 进行访问时控制台打印内容：
.antMatchers("/main1.html").hasIpAddress("127.0.0.1")
自定义403处理方案
使用 Spring Security 时经常会看见 403（无权限），默认情况下显示的效果如下：
而在实际项目中可能都是一个异步请求，显示上述效果对于用户就不是特别友好了。Spring Security 支持自定义权限受限。
新建类实现 AccessDeniedHandler
package com.yjxxt.springsecuritydemo.handler;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
 * @author zhoubin
 * @since 1.0.0
@Component
public class MyAccessDeniedHandler implements AccessDeniedHandler {
   @Override
   public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
      response.setStatus(HttpServletResponse.SC_FORBIDDEN);
      response.setHeader("Content-Type", "application/json;charset=utf-8");
      PrintWriter out = response.getWriter();
      out.write("{\"status\":\"error\",\"msg\":\"权限不足，请联系管理员！\"}");
      out.flush();
      out.close();
修改配置类
配置类中重点添加异常处理器。设置访问受限后交给哪个对象进行处理。
myAccessDeniedHandler 是在配置类中进行自动注入的。
//异常处理
http.exceptionHandling()
      .accessDeniedHandler(myAccessDeniedHandler);
基于表达式的访问控制
access()方法使用
之前学习的登录用户权限判断实际上底层实现都是调用access(表达式)
可以通过 access()实现和之前学习的权限控制完成相同的功能。
以 hasRole 和 和 permitAll 举例
使用自定义方法
虽然这里面已经包含了很多的表达式(方法)但是在实际项目中很有可能出现需要自己自定义逻辑的情况。
判断登录用户是否具有访问当前 URL 权限。
新建接口及实现类
MyService.java
package com.yjxxt.springsecuritydemo.service;
import org.springframework.security.core.Authentication;
import javax.servlet.http.HttpServletRequest;
public interface MyService {
   boolean hasPermission(HttpServletRequest request, Authentication authentication);
MyServiceImpl.java
package com.yjxxt.springsecuritydemo.service.impl;
import com.yjxxt.springsecuritydemo.service.MyService;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletRequest;
import java.util.Collection;
 * @author zhoubin
 * @since 1.0.0
@Component
public class MyServiceImpl implements MyService {
   @Override
   public boolean hasPermission(HttpServletRequest request, Authentication authentication) {
      Object obj = authentication.getPrincipal();
      if (obj instanceof UserDetails){
         UserDetails userDetails = (UserDetails) obj;
         Collection<? extends GrantedAuthority> authorities = userDetails.getAuthorities();
         return authorities.contains(new SimpleGrantedAuthority(request.getRequestURI()));
      return false;
修改配置类
在 access 中通过@bean的id名.方法(参数)的形式进行调用配置类中修改如下：
//url拦截
http.authorizeRequests()
      //login.html不需要被认证
      // .antMatchers("/login.html").permitAll()
      .antMatchers("/login.html").access("permitAll")
      // .antMatchers("/main.html").hasRole("abc")
      .antMatchers("/main.html").access("hasRole('abc')")
      .anyRequest().access("@myServiceImpl.hasPermission(request,authentication)")
基于注解的访问控制
在 Spring Security 中提供了一些访问控制的注解。这些注解都是默认是都不可用的，需要通过@EnableGlobalMethodSecurity 进行开启后使用。
如果设置的条件允许，程序正常执行。如果不允许会报 500
这些注解可以写到 Service 接口或方法上，也可以写到 Controller或 Controller 的方法上。通常情况下都是写在控制器方法上的，控制接口URL是否允许被访问。
@Secured
@Secured 是专门用于判断是否具有角色的。能写在方法或类上。参数要以 ROLE_开头。
在 启 动 类 ( 也 可 以 在 配 置 类 等 能 够 扫 描 的 类 上 ) 上 添 加@EnableGlobalMethodSecurity(securedEnabled = true)
@SpringBootApplication
@EnableGlobalMethodSecurity(securedEnabled = true)
public class SpringsecurityDemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(SpringsecurityDemoApplication.class, args);
在控制器方法上添加@Secured 注解
 * 成功后跳转页面
 * @return
@Secured("ROLE_abc")
@RequestMapping("/toMain")
public String toMain(){
   return "redirect:/main.html";
@Override
protected void configure(HttpSecurity http) throws Exception {
   //表单提交
   http.formLogin()
         //自定义登录页面
         .loginPage("/login.html")
         //当发现/login时认为是登录，必须和表单提交的地址一样。去执行UserServiceImpl
         .loginProcessingUrl("/login")
         //登录成功后跳转页面，POST请求
         .successForwardUrl("/toMain")
   //url拦截
   http.authorizeRequests()
         //login.html不需要被认证
         .antMatchers("/login.html").permitAll()
         //所有请求都必须被认证，必须登录后被访问
         .anyRequest().authenticated();
   //关闭csrf防护
   http.csrf().disable();
@PreAuthorize/@PostAuthorize
@PreAuthorize 和@PostAuthorize 都是方法或类级别注解。
@PreAuthorize 表示访问方法或类在执行之前先判断权限，大多情况下都是使用这个注解，注解的参数和access()方法参数取值相同，都是权限表达式。
@PostAuthorize 表示方法或类执行结束后判断权限，此注解很少被使用到。
@SpringBootApplication
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SpringsecurityDemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(SpringsecurityDemoApplication.class, args);
添加@PreAuthorize
在控制器方法上添加@PreAuthorize，参数可以是任何 access()支持的表达式
 * 成功后跳转页面
 * @return
@PreAuthorize("hasRole('ROLE_abc')")
@RequestMapping("/toMain")
public String toMain(){
   return "redirect:/main.html";
RememberMe功能实现
　Spring Security 中 Remember Me 为“记住我”功能，用户只需要在登录时添加 remember-me复选框，取值为true。Spring Security 会自动把用户信息存储到数据源中，以后就可以不登录进行访问
　Spring Security 实 现 Remember Me 功 能 时 底 层 实 现 依 赖Spring-JDBC，所以需要导入 Spring-JDBC。以后多使用 MyBatis 框架而很少直接导入 spring-jdbc，所以此处导入 mybatis 启动器同时还需要添加 MySQL 驱动
<!-- mybatis 依赖 -->
<dependency>
   <groupId>org.mybatis.spring.boot</groupId>
   <artifactId>mybatis-spring-boot-starter</artifactId>
   <version>2.1.1</version>
</dependency>
<!-- mysql 数据库依赖 -->
<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>8.0.18</version>
</dependency>
配置数据源
在 application.properties 中配置数据源。请确保数据库中已经存在shop数据库
spring.datasource.driver-class-name= com.mysql.cj.jdbc.Driver
spring.datasource.url= jdbc:mysql://localhost:3306/security?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
spring.datasource.username= root
spring.datasource.password= root
RememberMeConfig.java
package com.yjxxt.springsecuritydemo.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.web.authentication.rememberme.JdbcTokenRepositoryImpl;
import org.springframework.security.web.authentication.rememberme.PersistentTokenRepository;
import javax.sql.DataSource;
 * @author zhoubin
 * @since 1.0.0
@Configuration
public class RememberMeConfig {
   @Autowired
   private DataSource dataSource;
   @Bean
   public PersistentTokenRepository getPersistentTokenRepository(){
      JdbcTokenRepositoryImpl jdbcTokenRepository = new JdbcTokenRepositoryImpl();
      jdbcTokenRepository.setDataSource(dataSource);
      //自动建表，第一次启动时需要，第二次启动时注释掉
      jdbcTokenRepository.setCreateTableOnStartup(true);
      return jdbcTokenRepository;
修改SecurityConfig.java
在SecurityConfig中添加RememberMeConfig和UserDetailsService实现类对象，并自动注入。
在 configure 中添加下面配置内容。
http.rememberMe()
      //登录逻辑交给哪个对象
      .userDetailsService(userService)
      // 持久层对象
      .tokenRepository(persistentTokenRepository);
在客户端页面添加复选框
在客户端登录页面中添加 remember-me 的复选框，只要用户勾选了复选框下次就不需要进行登录了。
<form action="/login" method="post">
    用户名：<input type="text" name="username" /><br/>
    密码：<input type="password" name="password" /><br/>
    <input type="checkbox" name="remember-me" value="true"/><br/>
    <input type="submit" value="登录" />
</form>
默认情况下重启项目后登录状态失效了。但是可以通过设置状态有效时间，即使项目重新启动下次也可以正常登录。
http.rememberMe()
      //失效时间，单位秒
      .tokenValiditySeconds(120)
      //登录逻辑交给哪个对象
      .userDetailsService(userService)
      // 持久层对象
      .tokenRepository(persistentTokenRepository);
Thymeleaf中SpringSecurity的使用
　Spring Security 可以在一些视图技术中进行控制显示效果。例如：JSP 或 Thymeleaf。在非前后端分离且使用 Spring Boot 的项目中多使用 Thymeleaf 作为视图展示技术。
　Thymeleaf 对 Spring Security 的 支 持 都 放 在thymeleaf-extras-springsecurityX 中，目前最新版本为 5。所以需要在项目中添加此 jar 包的依赖和 thymeleaf 的依赖。。
<!--thymeleaf springsecurity5 依赖-->
<dependency>
   <groupId>org.thymeleaf.extras</groupId>
   <artifactId>thymeleaf-extras-springsecurity5</artifactId>
</dependency>
<!--thymeleaf依赖-->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
在 html 页面中引入 thymeleaf 命名空间和 security 命名空间
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org"
      xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity5">
可以在html页面中通过sec:authentication=""获取
UsernamePasswordAuthenticationToken中所有 getXXX 的内容，包含父类中的 getXXX 的内容。
根据源码得出下面属性：
name：登录账号名称
principal：登录主体，在自定义登录逻辑中是 UserDetails
credentials：凭证
authorities：权限和角色
details：实际上是 WebAuthenticationDetails 的实例。可以获取remoteAddress(客户端 ip)和 sessionId(当前 sessionId)
新建demo.html
在项目 resources 中新建 templates 文件夹，在 templates 中新建demo.html 页面




    

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity5">
    <meta charset="UTF-8">
    <title>Title</title>
</head>
    登录账号:<span sec:authentication="name"></span><br/>
    登录账号:<span sec:authentication="principal.username"></span><br/>
    凭证：<span sec:authentication="credentials"></span><br/>
    权限和角色：<span sec:authentication="authorities"></span><br/>
    客户端地址：<span sec:authentication="details.remoteAddress"></span><br/>
    sessionId：<span sec:authentication="details.sessionId"></span><br/>
</body>
</html>
编写Controller
thymeleaf 页面需要控制转发，在控制器类中编写下面方法
@RequestMapping("/demo")
public String demo(){
   return "demo";
设置用户角色和权限
设定用户具有 admin，/insert，/delete 权限 ROLE_abc 角色。
return new User(username,password, AuthorityUtils.commaSeparatedStringToAuthorityList("admin,ROLE_abc,/insert,/delete"));
控制页面显示效果
在页面中根据用户权限和角色判断页面中显示的内容
通过权限判断：
<button sec:authorize="hasAuthority('/insert')">新增</button>
<button sec:authorize="hasAuthority('/delete')">删除</button>
<button sec:authorize="hasAuthority('/update')">修改</button>
<button sec:authorize="hasAuthority('/select')">查看</button>
通过角色判断：
<button sec:authorize="hasRole('abc')">新增</button>
<button sec:authorize="hasRole('abc')">删除</button>
<button sec:authorize="hasRole('abc')">修改</button>
<button sec:authorize="hasRole('abc')">查看</button>
用户只需要向 Spring Security 项目中发送/logout 退出请求即可。
实现退出非常简单，只要在页面中添加/logout 的超链接即可。
<a href="/logout">退出登录</a>
为了实现更好的效果，通常添加退出的配置。默认的退出 url 为/logout，退出成功后跳转到/login?logout
如果不希望使用默认值，可以通过下面的方法进行修改。
http.logout()
      .logoutUrl("/logout")
      .logoutSuccessUrl("/login.html");
logout其他常用配置源码解读
addLogoutHandler(LogoutHandler)
默认是 contextLogoutHandler
默认实例内容
clearAuthentication(boolean)
是否清除认证状态，默认为 true
invalidateHttpSession(boolean)
是否销毁 HttpSession 对象，默认为 true
logoutSuccessHandler(LogoutSuccessHandler)
退出成功处理器
　也可以自己进行定义退出成功处理器。只要实现了LogoutSuccessHandler 接口。与之前讲解的登录成功处理器和登录失败处理器极其类似。
SpringSecurity中的CSRF
　从刚开始学习Spring Security时，在配置类中一直存在这样一行代码：http.csrf().disable();如果没有这行代码导致用户无法被认证。这行代码的含义是：关闭 csrf 防护。
什么是CSRF
　CSRF（Cross-site request forgery）跨站请求伪造，也被称为“OneClick Attack” 或者 Session Riding。通过伪造用户请求访问受信任站点的非法请求访问。
　跨域：只要网络协议，ip 地址，端口中任何一个不相同就是跨域请求。
　客户端与服务进行交互时，由于 http 协议本身是无状态协议，所以引入了cookie进行记录客户端身份。在cookie中会存放session id用来识别客户端身份的。在跨域的情况下，session id 可能被第三方恶意劫持，通过这个 session id 向服务端发起请求时，服务端会认为这个请求是合法的，可能发生很多意想不到的事情。
2、Spring Security中的CSRF
　从 Spring Security4开始CSRF防护默认开启。默认会拦截请求。进行CSRF处理。CSRF为了保证不是其他第三方网站访问，要求访问时携带参数名为_csrf值为token(token 在服务端产生)的内容，如果token和服务端的token匹配成功，则正常访问。
2.1、编写控制器方法
编写控制器方法，跳转到 templates 中 login.html 页面。
@RequestMapping("/showLogin")
public String showLogin(){
   return "login";
2.2、新建login.html
红色部分是必须存在的否则无法正常登录。
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org"
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<form action="/login" method="post">
    <input type="hidden" th:value="${_csrf.token}" name="_csrf" th:if="${_csrf}"/>
    用户名：<input type="text" name="username" /><br/>
    密码：<input type="password" name="password" /><br/>
    <input type="submit" value="登录" />
</form>
</body>
</html>
修改配置类
在配置类中注释掉 CSRF 防护失效
//关闭csrf防护
// http.csrf().disable();
Spring Security所解决的问题就是安全访问控制，而安全访问控制功能其实就是对所有进入系统的请求进行拦截，
校验每个请求是否能够访问它所期望的资源。根据前边知识的学习，可以通过Filter或AOP等技术来实现，Spring
Security对Web资源的保护是靠Filter实现的，所以从这个Filter来入手，逐步深入Spring Security原理。
当初始化Spring Security时，会创建一个名为 SpringSecurityFilterChain 的Servlet过滤器，类型为
org.springframework.security.web.FilterChainProxy，它实现了javax.servlet.Filter，因此外部的请求会经过此
类，下图是Spring Security过虑器链结构图：
FilterChainProxy是一个代理，真正起作用的是FilterChainProxy中SecurityFilterChain所包含的各个Filter，同时
这些Filter作为Bean被Spring管理，它们是Spring Security核心，各有各的职责，但他们并不直接处理用户的认
证，也不直接处理用户的授权，而是把它们交给了认证管理器（AuthenticationManager）和决策管理器
（AccessDecisionManager）进行处理，下图是FilterChainProxy相关类的UML图示。
spring Security功能的实现主要是由一系列过滤器链相互配合完成。
SecurityContextPersistenceFilter 这个Filter是整个拦截过程的入口和出口（也就是第一个和最后一个拦截
器），会在请求开始时从配置好的 SecurityContextRepository 中获取 SecurityContext，然后把它设置给
SecurityContextHolder。在请求完成后将 SecurityContextHolder 持有的 SecurityContext 再保存到配置好
的 SecurityContextRepository，同时清除 securityContextHolder 所持有的 SecurityContext；
UsernamePasswordAuthenticationFilter 用于处理来自表单提交的认证。该表单必须提供对应的用户名和密
码，其内部还有登录成功或失败后进行处理的 AuthenticationSuccessHandler 和
AuthenticationFailureHandler，这些都可以根据需求做相关改变；
FilterSecurityInterceptor 是用于保护web资源的，使用AccessDecisionManager对当前用户进行授权访问，前
面已经详细介绍过了；
ExceptionTranslationFilter 能够捕获来自 FilterChain 所有的异常，并进行处理。但是它只会处理两类异常：
AuthenticationException 和 AccessDeniedException，其它的异常它会继续抛出。
让我们仔细分析认证过程：
用户提交用户名、密码被SecurityFilterChain中的 UsernamePasswordAuthenticationFilter 过滤器获取到，
封装为请求Authentication，通常情况下是UsernamePasswordAuthenticationToken这个实现类。
然后过滤器将Authentication提交至认证管理器（AuthenticationManager）进行认证
认证成功后， AuthenticationManager 身份管理器返回一个被填充满了信息的（包括上面提到的权限信息，
身份信息，细节信息，但密码通常会被移除） Authentication 实例。
SecurityContextHolder 安全上下文容器将第3步填充了信息的 Authentication ，通过
SecurityContextHolder.getContext().setAuthentication(…)方法，设置到其中。
可以看出AuthenticationManager接口（认证管理器）是认证相关的核心接口，也是发起认证的出发点，它
的实现类为ProviderManager。而Spring Security支持多种认证方式，因此ProviderManager维护着一个
List 列表，存放多种认证方式，最终实际的认证工作是由
AuthenticationProvider完成的。咱们知道web表单的对应的AuthenticationProvider实现类为
DaoAuthenticationProvider，它的内部又维护着一个UserDetailsService负责UserDetails的获取。最终
AuthenticationProvider将UserDetails填充至Authentication。
认证核心组件的大体关系如下：
AuthenticationProvider
通过前面的Spring Security****认证流程我们得知，认证管理器（AuthenticationManager）委托
AuthenticationProvider完成认证工作。
AuthenticationProvider是一个接口，定义如下：
public interface AuthenticationProvider { 
   Authentication authenticate(Authentication authentication) throws AuthenticationException;
    boolean supports(Class<?> var1); }
authenticate()方法定义了认证的实现过程，它的参数是一个Authentication，里面包含了登录用户所提交的用
户、密码等。而返回值也是一个Authentication，这个Authentication则是在认证成功后，将用户的权限及其他信
息重新组装后生成。
Spring Security中维护着一个 List 列表，存放多种认证方式，不同的认证方式使用不
同的AuthenticationProvider。如使用用户名密码登录时，使用AuthenticationProvider1，短信登录时使用
AuthenticationProvider2等等这样的例子很多。
每个AuthenticationProvider需要实现supports****（）方法来表明自己支持的认证方式，如我们使用表单方式认证，
在提交请求时Spring Security会生成UsernamePasswordAuthenticationToken，它是一个Authentication，里面
封装着用户提交的用户名、密码信息。而对应的，哪个AuthenticationProvider来处理它？
我们在DaoAuthenticationProvider的基类AbstractUserDetailsAuthenticationProvider发现以下代码：
public boolean supports(Class<?> authentication) { 
    return UsernamePasswordAuthenticationToken.class.isAssignableFrom(authentication);
也就是说当web表单提交用户名密码时，Spring Security由DaoAuthenticationProvider处理。
最后，我们来看一下Authentication(认证信息)的结构，它是一个接口，我们之前提到的
UsernamePasswordAuthenticationToken就是它的实现之一：
public interface Authentication extends Principal, Serializable { 
    （1） Collection<? extends GrantedAuthority> getAuthorities(); 
    （2） Object getCredentials(); 
    （3） Object getDetails();
    （4） Object getPrincipal(); 
    （5） boolean isAuthenticated(); 
    void setAuthenticated(boolean var1) throws IllegalArgumentException;
（1）Authentication是spring security包中的接口，直接继承自Principal类，而Principal是位于 java.security
包中的。它是表示着一个抽象主体身份，任何主体都有一个名称，因此包含一个getName()方法。
（2）getAuthorities()，权限信息列表，默认是GrantedAuthority接口的一些实现类，通常是代表权限信息的一系
列字符串。
（3）getCredentials()，凭证信息，用户输入的密码字符串，在认证过后通常会被移除，用于保障安全。
（4）getDetails()，细节信息，web应用中的实现接口通常为 WebAuthenticationDetails，它记录了访问者的ip地
址和sessionId的值。
（5）getPrincipal()，身份信息，大部分情况下返回的是UserDetails接口的实现类，UserDetails代表用户的详细
信息，那从Authentication中取出来的UserDetails就是当前登录用户信息，它也是框架中的常用接口之一。
UserDetailsService
1）认识UserDetailsService
现在咱们现在知道DaoAuthenticationProvider处理了web表单的认证逻辑，认证成功后既得到一个
Authentication(UsernamePasswordAuthenticationToken实现)，里面包含了身份信息（Principal）。这个身份
信息就是一个 Object ，大多数情况下它可以被强转为UserDetails对象。
DaoAuthenticationProvider中包含了一个UserDetailsService实例，它负责根据用户名提取用户信息
UserDetails(包含密码)，而后DaoAuthenticationProvider会去对比UserDetailsService提取的用户密码与用户提交
的密码是否匹配作为认证成功的关键依据，因此可以通过将自定义的 UserDetailsService 公开为spring bean来定
义自定义身份验证。
public interface UserDetailsService { 
    UserDetails loadUserByUsername(String username) throws UsernameNotFoundException; 
很多人把DaoAuthenticationProvider和UserDetailsService的职责搞混淆，其实UserDetailsService只负责从特定
的地方（通常是数据库）加载用户信息，仅此而已。而DaoAuthenticationProvider的职责更大，它完成完整的认
证流程，同时会把UserDetails填充至Authentication。
上面一直提到UserDetails是用户信息，咱们看一下它的真面目：
public interface UserDetails extends Serializable { 
Collection<? extends GrantedAuthority> getAuthorities(); 
String getPassword(); 
String getUsername(); 
boolean isAccountNonExpired(); 
boolean isAccountNonLocked(); 
boolean isCredentialsNonExpired(); 
boolean isEnabled(); 
它和Authentication接口很类似，比如它们都拥有username，authorities。Authentication的getCredentials()与
UserDetails中的getPassword()需要被区分对待，前者是用户提交的密码凭证，后者是用户实际存储的密码，认证
其实就是对这两者的比对。Authentication中的getAuthorities()实际是由UserDetails的getAuthorities()传递而形
成的。还记得Authentication接口中的getDetails()方法吗？其中的UserDetails用户详细信息便是经过了
AuthenticationProvider认证之后被填充的。
通过实现UserDetailsService和UserDetails，我们可以完成对用户信息获取方式以及用户信息字段的扩展。
Spring Security提供的InMemoryUserDetailsManager(内存认证)，
JdbcUserDetailsManager(jdbc认证)就是
UserDetailsService的实现类，主要区别无非就是从内存还是从数据库加载用户。
自定义UserDetailsService
@Service public class SpringDataUserDetailsService implements UserDetailsService { 
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //登录账号 
        System.out.println("username="+username); 
        //根据账号去数据库查询... 
        //这里暂时使用静态数据 
        UserDetails userDetails = User.withUsername(username).password("123").authorities("p1").build(); return userDetails; } }
屏蔽安全配置类中UserDetailsService的定义
/* @Bean
public UserDetailsService userDetailsService() { 
InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager(); manager.createUser(User.withUsername("zhangsan").password("123").authorities("p1").build()); manager.createUser(User.withUsername("lisi").password("456").authorities("p2").build()); 
return manager; 
重启工程，请求认证，SpringDataUserDetailsService的loadUserByUsername方法被调用 ，查询用户信息。
PasswordEncoder
认识PasswordEncoder
DaoAuthenticationProvider认证处理器通过UserDetailsService获取到UserDetails后，它是如何与请求
Authentication中的密码做对比呢？
在这里Spring Security为了适应多种多样的加密类型，又做了抽象，DaoAuthenticationProvider通过
PasswordEncoder接口的matches方法进行密码的对比，而具体的密码对比细节取决于实现：
public interface PasswordEncoder {
    String encode(CharSequence var1);
    boolean matches(CharSequence var1, String var2); 
    default boolean upgradeEncoding(String encodedPassword) 
    { return false; } 
而Spring Security提供很多内置的PasswordEncoder，能够开箱即用，使用某种PasswordEncoder只需要进行如
下声明即可，如下：
@Bean 
public PasswordEncoder passwordEncoder() { 
    return NoOpPasswordEncoder.getInstance(); }
NoOpPasswordEncoder采用字符串匹配方法，不对密码进行加密比较处理，密码比较流程如下：
1、用户输入密码（明文 ）
2、DaoAuthenticationProvider获取UserDetails（其中存储了用户的正确密码）
3、DaoAuthenticationProvider使用PasswordEncoder对输入的密码和正确的密码进行校验，密码一致则校验通
过，否则校验失败。
NoOpPasswordEncoder的校验规则拿 输入的密码和UserDetails中的正确密码进行字符串比较，字符串内容一致
则校验通过，否则 校验失败。
实际项目中推荐使用BCryptPasswordEncoder, Pbkdf2PasswordEncoder, SCryptPasswordEncoder等，感兴趣
的大家可以看看这些PasswordEncoder的具体实现。
2）使用BCryptPasswordEncoder
1、配置BCryptPasswordEncoder
在安全配置类中定义：
@Bean 
public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder(); 
测试发现认证失败，提示：Encoded password does not look like BCrypt。
由于UserDetails中存储的是原始密码（比如：123），它不是BCrypt格式。
跟踪 DaoAuthenticationProvider第33行代码查看 userDetails中的内容 ，跟踪第38行代码查看
PasswordEncoder的类型。
2、测试BCrypt
通过下边的代码测试BCrypt加密及校验的方法
添加依赖：
<dependency> 
    <groupId>org.springframework.boot</groupId> <
    artifactId>spring‐boot‐starter‐test</artifactId> 
    <scope>test</scope>
</dependency>
编写测试方法：
@RunWith(SpringRunner.class) 
public class TestBCrypt { 
    @Test public void test1(){
        //对原始密码加密 
        String hashpw = BCrypt.hashpw("123",BCrypt.gensalt());
        System.out.println(hashpw); 
        //校验原始密码和BCrypt密码是否一致
        boolean checkpw = BCrypt.checkpw("123", "$2a$10$NlBC84MVb7F95EXYTXwLneXgCca6/GipyWR5NHm8K0203bSQMLpvm"); System.out.println(checkpw); } }
3、修改安全配置类
将UserDetails中的原始密码修改为BCrypt格式
manager.createUser(User.withUsername("zhangsan").password("$2a$10$1b5mIkehqv5c4KRrX9bUj.A4Y2hug3I GCnMCL5i4RpQrYV12xNKye").authorities("p1").build());
实际项目中存储在数据库中的密码并不是原始密码，都是经过加密处理的密码。
通过快速上手我们知道，Spring Security可以通过 http.authorizeRequests() 对web请求进行授权保护。Spring
Security使用标准Filter建立了对web请求的拦截，最终实现对资源的授权访问。
Spring Security的授权流程如下：
分析授权流程：
拦截请求，已认证用户访问受保护的web资源将被SecurityFilterChain中的 FilterSecurityInterceptor 的子
获取资源访问策略，FilterSecurityInterceptor会从 SecurityMetadataSource 的子类
DefaultFilterInvocationSecurityMetadataSource 获取要访问当前资源所需要的权限
Collection 。
SecurityMetadataSource其实就是读取访问策略的抽象，而读取的内容，其实就是我们配置的访问规则，
取访问策略如：
http.authorizeRequests() 
    .antMatchers("/r/r1").hasAuthority("p1")
    .antMatchers("/r/r2").hasAuthority("p2") ...
最后，FilterSecurityInterceptor会调用 AccessDecisionManager 进行授权决策，若决策通过，则允许访问资
源，否则将禁止访问。
AccessDecisionManager（访问决策管理器）的核心接口如下:
public interface AccessDecisionManager { 
    /** * 通过传递的参数来决定用户是否有访问对应受保护资源的权限 */
    void decide(Authentication authentication , Object object, Collection<ConfigAttribute> configAttributes ) throws AccessDeniedException, InsufficientAuthenticationException; 
    //略.. }
这里着重说明一下decide的参数：
authentication：要访问资源的访问者的身份
object：要访问的受保护资源，web请求对应FilterInvocation
confifigAttributes：是受保护资源的访问策略，通过SecurityMetadataSource获取。
decide****接口就是用来鉴定当前用户是否有访问对应受保护资源的权限。
AccessDecisionManager采用投票的方式来确定是否能够访问受保护资源。

通过上图可以看出，AccessDecisionManager中包含的一系列AccessDecisionVoter将会被用来对Authentication
是否有权访问受保护对象进行投票，AccessDecisionManager根据投票结果，做出最终决策。
AccessDecisionVoter是一个接口，其中定义有三个方法，具体结构如下所示。
public interface AccessDecisionVoter<S> {
    int ACCESS_GRANTED = 1;
    int ACCESS_ABSTAIN = 0; 
    int ACCESS_DENIED = ‐1;
    boolean supports(ConfigAttribute var1);
    boolean supports(Class<?> var1); 
    int vote(Authentication var1, S var2, Collection<ConfigAttribute> var3);
vote()方法的返回结果会是AccessDecisionVoter中定义的三个常量之一。ACCESS_GRANTED表示同意，
ACCESS_DENIED表示拒绝，ACCESS_ABSTAIN表示弃权。如果一个AccessDecisionVoter不能判定当前
Authentication是否拥有访问对应受保护对象的权限，则其vote()方法的返回值应当为弃权ACCESS_ABSTAIN。
Spring Security内置了三个基于投票的AccessDecisionManager实现类如下，它们分别是
AffiffiffirmativeBased、ConsensusBased和UnanimousBased，。
AffiffiffirmativeBased的逻辑是：
（1）只要有AccessDecisionVoter的投票为ACCESS_GRANTED则同意用户进行访问；
（2）如果全部弃权也表示通过；
（3）如果没有一个人投赞成票，但是有人投反对票，则将抛出AccessDeniedException。
Spring security默认使用的是AffiffiffirmativeBased。
ConsensusBased的逻辑是：
（1）如果赞成票多于反对票则表示通过。
（2）反过来，如果反对票多于赞成票则将抛出AccessDeniedException。
（3）如果赞成票与反对票相同且不等于0，并且属性allowIfEqualGrantedDeniedDecisions的值为true，则表
示通过，否则将抛出异常AccessDeniedException。参数allowIfEqualGrantedDeniedDecisions的值默认为true。
（4）如果所有的AccessDecisionVoter都弃权了，则将视参数allowIfAllAbstainDecisions的值而定，如果该值
为true则表示通过，否则将抛出异常AccessDeniedException。参数allowIfAllAbstainDecisions的值默认为false。
UnanimousBased的逻辑与另外两种实现有点不一样，另外两种会一次性把受保护对象的配置属性全部传递
给AccessDecisionVoter进行投票，而UnanimousBased会一次只传递一个ConfifigAttribute给
AccessDecisionVoter进行投票。这也就意味着如果我们的AccessDecisionVoter的逻辑是只要传递进来的
ConfifigAttribute中有一个能够匹配则投赞成票，但是放到UnanimousBased中其投票结果就不一定是赞成了。
UnanimousBased的逻辑具体来说是这样的：
（1）如果受保护对象配置的某一个ConfifigAttribute被任意的AccessDecisionVoter反对了，则将抛出
AccessDeniedException。
（2）如果没有反对票，但是有赞成票，则表示通过。
（3）如果全部弃权了，则将视参数allowIfAllAbstainDecisions的值而定，
true则通过，
false则抛出
AccessDeniedException。
Spring Security也内置一些投票者实现类如RoleVoter、AuthenticatedVoter和WebExpressionVoter等，可以
自行查阅资料进行学习。
Oauth2认证
Oauth2简介
　第三方认证技术方案最主要是解决认证协议的通用标准问题，因为要实现跨系统认证，各系统之间要遵循一定的接口协议。
　OAUTH协议为用户资源的授权提供了一个安全的、开放而又简易的标准。同时，任何第三方都可以使用OAUTH认证服务，任何服务提供商都可以实现自身的OAUTH认证服务，因而OAUTH是开放的。业界提供了OAUTH的多种实现如PHP、JavaScript，Java，Ruby等各种语言开发包，大大节约了程序员的时间，因而OAUTH是简易的。互联网很多服务如Open API，很多大公司如Google，Yahoo，Microsoft等都提供了OAUTH认证服务，这些都足以说明OAUTH标准逐渐成为开放资源授权的标准。
　Oauth协议目前发展到2.0版本，1.0版本过于复杂，2.0版本已得到广泛应用。
参考：https://baike.baidu.com/item/oAuth/7153134?fr=aladdin
Oauth 协议：https://tools.ietf.org/html/rfc6749
下边分析一个Oauth2认证的例子，网站使用微信认证的过程：
用户进入网站的登录页面，点击微信的图标以微信账号登录系统，用户是自己在微信里信息的资源拥有者。
点击“微信”出现一个二维码，此时用户扫描二维码，开始给网站授权。
资源拥有者同意给客户端授权
　资源拥有者扫描二维码表示资源拥有者同意给客户端授权，微信会对资源拥有者的身份进行验证，验证通过后，微信会询问用户是否给授权网站访问自己的微信数据，用户点击“确认登录”表示同意授权，微信认证服务器会颁发一个授权码，并重定向到网站。
客户端获取到授权码，请求认证服务器申请令牌
　此过程用户看不到，客户端应用程序请求认证服务器，请求携带授权码。
认证服务器向客户端响应令牌
　认证服务器验证了客户端请求的授权码，如果合法则给客户端颁发令牌，令牌是客户端访问资源的通行证。此交互过程用户看不到，当客户端拿到令牌后，用户在网站看到已经登录成功。
客户端请求资源服务器的资源
　客户端携带令牌访问资源服务器的资源。网站携带令牌请求访问微信服务器获取用户的基本信息。
资源服务器返回受保护资源
　资源服务器校验令牌的合法性，如果合法则向用户响应资源信息内容。
注意：资源服务器和认证服务器可以是一个服务也可以分开的服务，如果是分开的服务资源服务器通常要请求认证服务器来校验令牌的合法性。
Oauth2.0认证流程如下：
引自Oauth2.0协议rfc6749 https://tools.ietf.org/html/rfc6749
本身不存储资源，需要通过资源拥有者的授权去请求资源服务器的资源，比如：Android客户端、Web客户端（浏览器端）、微信客户端等。
资源拥有者
通常为用户，也可以是应用程序，即该资源的拥有者。
授权服务器（也称认证服务器）
用来对资源拥有的身份进行认证、对访问资源进行授权。客户端要想访问资源需要通过认证服务器由资源拥有者授权后方可访问。
资源服务器
存储资源的服务器，比如，网站用户管理服务器存储了网站用户信息，网站相册服务器存储了用户的相册信息，微信的资源服务存储了微信的用户信息等。客户端最终访问资源服务器获取资源信息。
客户凭证(client Credentials)：客户端的clientId和密码用于认证客户
令牌(tokens)：授权服务器在接收到客户请求后，颁发的访问令牌
作用域(scopes)：客户请求访问令牌时，由资源拥有者额外指定的细分权限(permission)
授权码：仅用于授权码授权类型，用于交换获取访问令牌和刷新令牌
访问令牌：用于代表一个用户或服务直接去访问受保护的资源
刷新令牌：用于去授权服务器获取一个刷新访问令牌
BearerToken：不管谁拿到Token都可以访问资源，类似现金
Proof of Possession(PoP) Token：可以校验client是否对Token有明确的拥有权
​     更安全，客户端不接触用户密码，服务器端更易集中保护
​     广泛传播并被持续采用
​     短寿命和封装的token
​     资源服务器和授权服务器解耦
​     集中式授权，简化客户端
​     HTTP/JSON友好，易于请求和传递token
​     考虑多种客户端架构场景
​     客户可以具有不同的信任级别
​     协议框架太宽泛，造成各种实现的兼容性和互操作性差
​     不是一个认证协议，本身并不能告诉你任何用户信息。
授权码模式（Authorization Code）
简化授权模式（Implicit）
密码模式（Resource Owner PasswordCredentials）
客户端模式（Client Credentials）