76-SpringSecurity介绍

在前面博客中（上一个项目，具体在72章博客）

我们发现，若我们自己解决权限操作（或者说身份的验证，虽然并不明显）的话

是非常困难的，于是接下来我们说明一下如何更加简单的解决权限问题

SpringSecurity入门：

Spring Security简介：

Spring Security是一个功能强大且高度可定制的身份验证和访问控制框架，它是用于保护基于Spring的应用程序的实际标准

Spring Security是一个框架，致力于为Java应用程序提供身份验证和授权

与所有Spring项目一样，Spring Security的真正强大之处在于可以轻松扩展以满足自定义要求

安全技术方案对比：

目前在整个Java开发的系统中，需要用于身份验证和访问控制框架的框架除了Spring Security，还有一个就是Apache shiro框架

Shiro：

Shiro是一个强大而灵活的开源安全框架，能够非常清晰的处理认证、授权、管理会话以及密码加密

如下是它所具有的特点：

易于理解的 Java Security API

简单的身份认证（登录），支持多种数据源（LDAP，JDBC，Kerberos，ActiveDirectory 等）

对角色的简单的鉴权（访问控制），支持细粒度的鉴权

支持一级缓存，以提升应用程序的性能

内置的基于 POJO 企业会话管理，适用于 Web 以及非 Web 的环境

异构客户端会话访问

非常简单的加密 API

不跟任何的框架或者容器捆绑，可以独立运行

Spring Security：

除了不能脱离Spring，shiro的功能它都有，而且Spring Security对Oauth、OpenID也有支持

Shiro则需要自己手动实现，Spring Security的权限细粒度更高

Spring Security框架功能简介 ：

认证：用户登录，解决的是"你是谁?"

授权：判断用户拥有什么权限，可以访问什么资源，解决的是"你能干什么?"

安全防护，防止跨站请求，session 攻击等

SpringSecurity应用场景：

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

用户授权，在系统中用户拥有哪些操作权限

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

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

集成oauth2，做登录授权，可以用于app登录和第三方登录（QQ，微信等），也可以实现cas的功能

SpringSecurity入门案例：

快速体验SpringSecurity功能：

创建Spring Boot 工程（若不知道什么是spring boot，可以看看88章博客）：

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

一般来说，现在选择不了2.3.5（因为上面是以前的操作，可能一般是因为老的版本的idea或者以前的默认地址的原因，一般是默认地址造成的，借鉴学习时的图片）

现在根据我使用的如下（我的是有点新版的idea）：

那么我们就选择2.7.2，只要不选择后面括号里的快照版即可，基本可以操作，这是最稳定的

至此，对应的目录如下（记得删除没有必要的文件）：

现在我们在securitydemo包下创建controller包，并创建HelloSecurityController类：

package com.lagou.securitydemo.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 *
 */
@RestController
public class HelloSecurityController {


    @RequestMapping("/hello")
    public String hello() {

        return "hello";

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

当然如果你没有学习spring boot，没有关系，可以到88章博客里面去学习，就知道为什么这样的操作了

接下来我们运行启动类，访问http://localhost:8080/hello，即可得到返回的数据

接下来整合SpringSecurity：

添加SpringSecurity依赖

<dependency>    
    <groupId>org.springframework.bootgroupId>     
    <artifactId>spring-boot-starter-securityartifactId>
dependency>
1
2
3
4
5

重启Spring Boot启动类，再次访问http://localhost:8080/hello：

出现如下：

默认有访问/login，该/login会优先于写的controller的/login，即自己写的/login

所以这时候也最好不要在对应的控制层上加上/login了，因为基本没有什么作用

实际上过滤器产生的页面基本都会优先（SpringSecurity操作过滤器链），因为访问时，需要先经过过滤器

我们发现，引入该依赖后，有对应的表单（一般是代码操作的页面，很少是自带的生成，除非自己配置）

spring boot整合他时，会有的，当然里面的底层操作自然也是通过他们之间的整合方式进行

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

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

表单的提交方式和路径：post，/login，与原来一样，使得可以证明操作是否成功，并随时判断是否返回当前页面

input输入项的name值：username password

隐藏域input的name值为：_csrf，value值为：d4329889-796a-447a-9d08-69e56bc7c296

该value值，一般是不同的，每次认证过，都是不同的，当然，若是浏览器有缓存（一般与sessionid对应）

在没有认证过之前，就会使用缓存的，若没有缓存，自然使用自己生成的

所以刷新（其中一般是带有参数的访问，即表单的参数，但因为缓存，所以不变，一般会有来源）或者重新访问一般是不会变的

SpringSecurity一般需要对应的这些value，即账号，密码，_csrf的值，都需要，且对应的值要正确，才会认证成功

_csrf的不正确一般会出现错误页面

默认d4329889-796a-447a-9d08-69e56bc7c296在生成时，是正确的，所以不需要修改

上面的操作，使得提交时，去进行验证（post，/login），从而决定是否通过认证

一般情况下，查看页面源代码是本身的页面信息，而不是去访问得到的，但有些时候，会去访问得到，且不经过浏览器的操作

而不是当前的元素页面内容，所以页面的源代码并不一定与当前页面代码相同

比如这里（当然，可能是因为查看源代码也会操作变量值的原因，所以导致又访问了）

这里可以看看对应的_csrf改变后，即提交后改变（提交要输入后面对应的用户名和密码）

在另外一个窗口查看元素（该窗口在认证界面），然后查看页面源代码，发现，页面源代码的 _csrf是改变的

而元素的 _csrf没有改变，我们试着进行提交，发现，使用是元素的，这是自然的，所以也就会出现报错，到错误页面

通过测试，只要我们认证成功，那么页面的源代码就会去访问一次

或者说，认证操作的参数（可能是sessionid变化造成的）可能会使得浏览器做出了某些操作使得页面源代码进行了重新的访问

但元素却没有，因为使用本身的，不操作访问

SpringBoot已经为SpringSecurity（实际上他自己提供）提供了默认配置，默认所有资源都必须认证通过才能访问

那么问题来了，此刻并没有连接数据库，也并未在内存中指定认证用户，如何认证呢：

其实SpringBoot（他们自己结合的依赖，Spring Boot只是负责装配罢了，所以实际上还是SpringSecurity提供）已经提供了默认用户名user，密码在项目启动时随机生成，如图：

认证通过后（输入用户名和密码），就访问了处理器资源（没拦截了），即返回了对应的hello：

也就是说，对应的登录实际上是因为SpringSecurity给出的拦截（或者说过滤器的操作），使得访问时需要认证等等

一般来说对应的页面是代码生成的，可能也是自带的（上面已经说明了一次，当然这并不需要考虑）

SpringSecurity认证：

案例介绍：

现在为了操作该SpringSecurity认证，现在给出一个半成品的项目

地址如下（包含数据库文件）：

链接：https://pan.baidu.com/s/13769wUhvlos9WdBwf1jv0A

提取码：alsk

在这之前，先看看对应的配置文件里的数据库的配置是否正确

当然，若有乱码，自己将对应文件的编码修改成当前idea显示的编码即可

如我这里：

一般这修改对应的编码为gbk（因为我的idea显示的就是gbk），当然该编码问题并不需要解决，因为基本只是显示而已

在执行sql语句之前，需要执行如下sql：

CREATE DATABASE security_management CHARACTER SET utf8
1

因为对应的语句，并没有创建数据库来操作，所以需要自己创建，否则一般会默认第一个数据库

至此，执行对应的sql语句，运行启动类，访问如下地址，可以看到如下

下面一般验证码的右边会出现一个图片的标志（因为没有找到，会显示一个对应的标志）

如：

我们将这个简称为没图标志，后面操作图形验证码时，对多次的讲到

但可能是因为程序关闭导致点击后使得没有出现（一般会出现），具体看自己的显示：

启动项目进入首页（直接访问根目录即可，因为是半成品的）：

系统管理界面：

基础数据界面（也就是商品管理）：

项目最终目录结构：

工程导入：

注意检查: maven仓库配置

一般情况下，这个并不需要操作

pom文件：

<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.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.3.4.RELEASEversion>
        <relativePath/> 
    parent>
    <groupId>com.lagougroupId>
    <artifactId>lagou-security-managementartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>lagou-security-managementname>
    <description>lagou-security-managementdescription>

    <properties>
        <java.version>11java.version>
    properties>

    <dependencies>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-thymeleafartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <scope>runtimescope>
            <optional>trueoptional>
        dependency>
        
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>
        
        <dependency>
            <groupId>com.baomidougroupId>
            <artifactId>mybatis-plus-boot-starterartifactId>
            <version>3.3.2version>
        dependency>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>5.1.21version>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
        dependency>
    dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
        plugins>
    build>

project>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

至此，该项目的结构大致了解清楚了

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

在已导入的工程中添加Spring Security的依赖：

<dependency>     
    <groupId>org.springframework.bootgroupId>     
    <artifactId>spring-boot-starter-securityartifactId>
dependency>
1
2
3
4
5

在使用SpringSecurity框架，该框架会默认自动地替我们将系统中的资源进行保护

每次访问资源的时候都必须经过一层身份的校验，如果通过了则重定向到我们输入的url中，否则访问是要被拒绝的

这时我们再次进行登录，发现，在外面确定可以进入后

对应从数据库得到的信息或者是说对应的页面连接被拒绝访问了，这个后面进行解决

那么SpringSecurity框架是如何实现的呢：

Spring Security功能的实现主要是由一系列过滤器相互配合完成，也称之为过滤器链

过滤器链介绍：

过滤器可以看成是一种典型的AOP思想，因为在访问之前，中间进行了操作

下面简单了解下这些过滤器链，后续再源码剖析中在涉及到过滤器链在仔细讲解

在对应的日志中，可以找到如下：

可以找到如下15个过滤器类：

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

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

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

SecurityContextPersistenceFilter主要是使用SecurityContextRepository在session中保存 或更新一个SecurityContext

SecurityContext：Security的上下文对象，一般保存对应的认证信息和权限信息等等

并将SecurityContext给以后的过滤器使用，来为后续filter建立所需的上下文

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为/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个过滤器，但是随着配置可以增加一些过滤器（比如记住我）或者删除一些过滤器

通常一些配置会进行删除（如上面的CsrfFilter，DefaultLoginPageGeneratingFilter，DefaultLogoutPageGeneratingFilter）

当然也可以说有些会替换，等等，如DefaultLoginPageGeneratingFilter，DefaultLogoutPageGeneratingFilter

但他们的出现，却主要是因为对应没有使用了我们操作的访问认证页面而出现的

当然，若这时没有操作自定义的登录页面或者退出登录，那么实际上也会使用默认，因为他们只是覆盖而已（覆盖一样的）

有些配置会进行增加（但通常需要自己增加，如后面的图形验证）

这里就不做说明了，因为并没有什么意义

认证方式：

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的加密算法是可逆的，想要破解并不难

所以说他是一种简陋的验证模式，比如说如下（对应的页面或者提示并不是一成不变的，一般是版本的问题）

formLogin登录认证模式（简称为表单认证）：

Spring Security的HttpBasic模式，该模式比较简单，只是进行了通过携带Http的Header进行简单的登录验证

而且没有定制的登录页面，所以使用场景比较窄

对于一个完整的应用系统，与登录验证相关的页面都是高度定制化的，非常美观而且提供多种登录方式

甚至可以自己操作加密算法等

这就需要Spring Security支持我们自己定制登录页面，即操作表单认证模式（formLogin登录认证模式）

spring boot2.0以上版本（依赖Security是5.X版本或者以上）默认会生成一个登录页面

通常是这样的形式，就如前面的登录认证需要的页面类似的

Spring Security一般默认操作/login，且对应的页面也基本是代码生成，当然也会与版本有关

表单认证：

自定义表单登录页面：

一般情况下，对应Spring Security操作认证的/login路径，他会默认访问到对应的templates目录下的login.html文件

在lagou包下，创建config包，并编写SecurityConfiguration配置类并继承WebSecurityConfigurerAdapter类

主要是对应的WebSecurityConfigurerAdapter类的作用，使得我们可以进行操作设置：

package com.lagou.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.
    builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

/**
 * Security配置类
 */
@Configuration
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
    //这里只需要对应的三个方法即可，并不需要都进行重写，配置类的注解是核心
    //使得可以从ioc里得到，并进行注入操作（一般只能是得到WebSecurityConfigurerAdapter类型或者其子类）
    //所以需要继承WebSecurityConfigurerAdapter类，从而操作如下的方法，当然这是底层的缘故
    //若没有注入，自然对应的变量一般会设置为null了，实际上可能以前也有过说明，没有注入，就是null
    //在正常情况下，没有注入是会报错的，但是却可以进行判断，然后赋值，具体方式，可以百度进行查找
    //大体思路是，我们得到容器（当然这是很简单，一般底层都可以得到，要不然怎么操作注入呢）
    //然后循环，判断是否是WebSecurityConfigurerAdapter类的父类，然后就决定是否赋值为null了
    //所以我们在特殊情况下，我们也认为没有注入则是null
    //当然，大多数都是报错的
    //可能以前或者以后的博客并没有说明，但一般不会，注意即可，因为总不能不会忘记吧，或者出错吧
    //当为null时，那么对应的方法也就操作不了，也就不会进行设置，或者使得初始化的信息等等
    //如使得不操作默认认证（或者说认证页面）了
    
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        super.configure(auth); //一般来说，重写父类的方法，一般会执行父类的方法
    }

    @Override
    public void configure(WebSecurity web) throws Exception {
        super.configure(web);
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //选择（开启）HttpBasic认证模式
        //注意：分开的话（其他行的分开，不能是一行，否则在注释"//"后面的也会认为是注释内容）
        //是可以使用注释的，不会影响运行，大多数的语言都可以
        http.httpBasic() //开启HttpBasic认证
                .and().authorizeRequests().anyRequest().authenticated();
        //and()进行拼接作用
        //authorizeRequests()授权我们的请求
        //anyRequest()所有的请求（自然也包括静态资源的请求等等）
        //authenticated()都需要认证
        //即所有请求，都需要认证之后才可访问（即认证后进行授权，就可访问了，这时基本所有的请求都授权了）
    }
}

//最后注意：这些方法的运行，在启动类还没启动完毕时进行初始化的，即，那时候进行执行，可以使用断点进行验证
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

一般情况下，默认是formLogin登录认证模式，当你加上上面的代码时，则使用对应方法的结果，而不会使用默认

那么当对应的方法没有任何操作时，那么也就没有任何认证

我们可以观测，对应继承了WebSecurityConfigurerAdapter类，在15个过滤器中，并不能找到对应的是该类的过滤器

实际上spring Security操作的认证会由WebSecurityConfigurerAdapter来决定

即他也是一个过滤器，对应的方法configure（HttpSecurity http）会执行

只是我们加上的，所以HttpSecurity是可以用来决定认证的

至此我们重新的运行启动类，最好清除浏览器的缓存

因为大多数的情况下，只要浏览器有对应的信息存在，就不需要认证，无论密码是否正确

这也就使得，接下来无论怎么访问，都不会出现对应的认证界面

因为在实际情况下，我们的认证方式基本是不会变的，所以也就使得，存在信息，就不需要认证

然后访问，就会出现如下（在不同的浏览器中，对应的页面弹框一般是显示不同的结果，你可以试一试）：

至此你可以试着这样做：将对应的类的配置删除（配置类的配置），不让他是配置类，那么会发现，访问时使用默认的认证

若让他是配置类，但对应configure（HttpSecurity http）方法

什么都没操作，那么会发现，访问时没有认证，若有操作，就使用有操作的

接下来试验，不同的浏览器是否是真的不同页面弹框的显示，上面的是试验360浏览器的，当然也可以操作其他浏览器

接下来我们试验谷歌浏览器：

我们发现，的确，页面弹框的显示不同

但是我们也知道，对应的HttpBasic认证模式是简陋的，所以我们需要修改对应的代码，回到SecurityConfiguration类进行修改：

首先将对应的configure（HttpSecurity http）方法的内容都进行注释，加上如下代码：

 http.formLogin() //开启表单认证
                .and().authorizeRequests().anyRequest().authenticated();
        //我们发现，除了认证的代码，后面都是一样的，当然了，对应的操作本来就是符合认证的，一样的也是正确的

1
2
3
4

清除浏览器缓存（即浏览器数据，简称为浏览器缓存，后面就这样说了）

发现，表单认证的结果就是之前的认证，也更加的证明了默认操作的就是表单认证：

但是我们说过，需要使用自定义的页面，实际上在没有操作时，大概是默认使用代码显示的页面

现在我们进行指定，那么就会使用指定的页面了

configure（HttpSecurity http）方法的内容代码进行改变，改变如下：

 http.formLogin().loginPage("/login.html") //开启表单认证
                .and().authorizeRequests().anyRequest().authenticated();
        //我们发现，除了认证的代码，后面都是一样的，当然了，对应的操作本来就是符合认证的，一样的也是正确的

//其中loginPage("/login.html")将默认使用代码生成的页面（一般是这样），变成我们自己的页面
1
2
3
4
5

再次运行启动类，清除浏览器缓存，我们会发现如下（谷歌浏览器里面测试，其他浏览器可能没有具体提示，很难找到提示）：

为什么会这样呢：

因为设置登录页面为login.html时，首先要知道，我们肯定是需要访问这个页面的

具体如何的访问，一般是重定向（而不是代码操作的页面了，因为设置的）

但是在重定向后，由于对应的配置过滤，是所有的请求

那么我们在访问途中，又需要过滤，然而这个过滤又回到了这个访问（又重定向了，因为设置为这个页面的）

所以说，就进行了多次的重定向

当然，实际上他并没有放行，所以虽然对应的资源不在静态文件夹下，即一般并不会出现没有页面的提示

总体来说，后面配置的是所有请求都登录认证（使得包括了自己的页面）

即陷入了死循环，所以需要将login.html放行不需要登录认证

这样重定向自己时，不会经过过滤：

具体的configure（HttpSecurity http）方法的内容代码如下：

     http.formLogin().loginPage("/login.html") //开启表单认证
                .and().authorizeRequests().
                antMatchers("/login.html").permitAll() //放行对应的页面，而不经过验证过滤
                .anyRequest().authenticated();
1
2
3
4

至此我们再次访问，但由于对应的进行了放行，那么就需要考虑对应的资源是否在静态资源文件夹下了

很明显，项目中并没有对应的资源文件，所以一般会出现如下（再次运行启动类，清除浏览器缓存）：

即这里的spring boot整合thymeleaf 之后 所有的静态页面以放在resources/templates下面

所以得通过请求访问到模板页面，将/login.html修改为/toLoginPage，代码如下：

   http.formLogin().loginPage("/toLoginPage") //开启表单认证，记得在对应的LoginController类里面进行操作
                .and().authorizeRequests().
                antMatchers("/toLoginPage").permitAll() 
       //放行对应的页面，而不经过验证过滤，基本操作所有放行
                .anyRequest().authenticated();

//其中记得都变成toLoginPage，因为放行需要对应，不对应的怎么会放行呢，是吧
1
2
3
4
5
6
7

但是这时候，我们发现，对应的样式却没有，如下（再次运行启动类，清除浏览器缓存）：

因为访问login.html需要一些js , css , image等静态资源信息，正是因为我们只放行了对应的一个请求，但资源的请求没有放行

所以需要将静态资源放行，不需要认证，具体代码如下（另外一个方法了）：

@Override
    public void configure(WebSecurity web) throws Exception {

        //解决静态资源被拦截的问题，基本只能操作认证的放行
        web.ignoring().antMatchers("/css/**","/images/**","/js/**");
    }


1
2
3
4
5
6
7
8

实际上也可以如下：

 http.formLogin().loginPage("/toLoginPage") //开启表单认证
                .and().authorizeRequests().
                antMatchers("/toLoginPage","/css/**","/images/**","/js/**").permitAll() 
     //放行对应的页面，而不经过验证过滤
                .anyRequest().authenticated();
1
2
3
4
5

甚至可以这样：

 @Override
    public void configure(WebSecurity web) throws Exception {

        //解决静态资源被拦截的问题
        web.ignoring().antMatchers("/toLoginPage","/css/**","/images/**","/js/**");
    }
    
     @Override
    protected void configure(HttpSecurity http) throws Exception {

        http.formLogin().loginPage("/toLoginPage") //开启表单认证
                .and().authorizeRequests()
            //当然，对应的"."也可以放在这里（后面），只是不整齐而已，或者所有的点写后面，只是不美观
            //这里就都写在前面了，后续也是如此
                 //放行对应的页面，而不经过验证过滤
                .anyRequest().authenticated();

    }

//也就是说，将放行都给configure(WebSecurity web)方法
//实际上该方法也可以用来操作资源的放行的（容易一点），且也可以操作某些安全控制（只是难一点而已）
//下面的configure(HttpSecurity http)方法也可以操作放行（容易一点）
//因为存在permitAll()方法，且必须要这个（难一点），否则后面的方法延续不能进行，会报错
//所以总体来说，WebSecurity web大于HttpSecurity http
//根据难易程度来说，操作安全控制，一般由HttpSecurity http来操作，放行，由WebSecurity web来操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

最后注意：对应的放行后面，需要以"/"开头

否则一般不会操作放行（因为不会加"/"来进行判断，使用的是静态资源文件夹的样式）

至此我们再次运行启动类，清除浏览器缓存，发现，对应的界面如下：

也就是说，使用了该页面，那么是不是所有的页面都可以，是的，只要你有，那么就会返回

因为认证的操作，主要是对应的字段提交的操作，只要对应的name是需要操作的提交字段即可

访问的对象也是，那么就可以操作认证，可以看看前面的源代码的地方就知道了

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

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

2：HttpSecurity仅用于定义需要安全控制的请求（当然HttpSecurity也可以指定某些请求不需要安全控制）

3：可以认为HttpSecurity是WebSecurity的一部分，的一个概念

4：构建目标不同

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

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

表单登录：

通过讲解过滤器链中我们知道有个过滤器UsernamePasswordAuthenticationFilter是处理表单登录的，操作post请求的/login的

那么下面我们来通过源码观察下这个过滤器：

在idea里使用ctrl+n，复制粘贴UsernamePasswordAuthenticationFilter进行搜索

点击对应的类（一般是唯一的，若不是唯一，看看前面的过滤器的总名称）：

在源码中可以观察到，表单中的input的name值是username和password

并且表单提交的路径为/login，表单提交方式method为post，这些可以修改为自定义的值

代码如下：

 @Override
    protected void configure(HttpSecurity http) throws Exception {

        //可以理解为UsernamePasswordAuthenticationFilter就是操作formLogin()，后面的都是进行设置
        http.formLogin().loginPage("/toLoginPage")
                .loginProcessingUrl("/login1") //设置表单提交的路径，而不是默认的/login了
            //这样也可以访问/login1到对应的页面里面
                .usernameParameter("username1") //设置对应用户名的name
                .passwordParameter("password1") //设置对应密码的name
                //上面的设置，使得前端的对应字段需要按照他这样的格式即可
                //当然，若没有按照，那么自然后端返回的是null了
                //也就不会认证成功了
                .successForwardUrl("/")
                //登录成功后，跳转的路径，一般情况下，我们访问时
            //后端会得到对应的访问路径，使得跳转到对应的路径
                //当然，我们可以指定路径的跳转，上面就是指定路径跳转到"/"下，这个项目就是index.html了
                .and().authorizeRequests().anyRequest().authenticated();



    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

对应的部分前端（对应的login.html）：

需要按照后端的操作进行修改

运行启动类，访问，会发现，并没有认证成功，这时因为对应的name为_csrf的值并没有，自然后端得到的是null值

当然，你可以复制对应的值，即复制前面源代码的，如：

  <input name="_csrf" type="hidden" value="4ac3b39d-7cc3-42bd-ac6c-51b5da93e454" />


1
2
3
4
5
6
7
8

所以也要记得，要在认证之前或者清除缓存之前操作，因为认证之后或者清除缓存之后，对应的值也就变化了

在他们之前操作，基本会使得认证成功，之前并没有说明他是干什么的，接下来说明一下他的作用：

name为_csrf的值主要是用来操作跨站请求的，主要是用来进行csrf防护

后面会进行说明，因为后面会说明对应的具体作用，先不要着急

那么如何不让Spring Security操作该作用呢，加上如下代码即可：

  @Override
    protected void configure(HttpSecurity http) throws Exception {

        http.formLogin().loginPage("/toLoginPage")
                .loginProcessingUrl("/login1") 
            //设置表单提交的路径，而不是默认的/login了，但是却不能直接的访问了
            //默认操作post，所以操作get会访问失败，自然的又会回到该页面
                .usernameParameter("username1") //设置对应用户名的name
                .passwordParameter("password1") //设置对应密码的name
                //上面的设置，使得前端的对应字段需要按照他这样的格式即可
                //当然，若没有按照，那么自然后端返回的是null了
                //也就不会认证成功了
                .successForwardUrl("/")
                //登录成功后，跳转的路径（是转发的操作，而不是重定向），一般情况下，我们访问时
                //后端会得到对应的访问路径，使得跳转到对应的路径
                //当然，我们可以指定路径的跳转，上面就是指定路径跳转到"/"下，这个项目就是index.html了
                .and().authorizeRequests().anyRequest().authenticated();

        //这下面就是加上的代码
                //关闭csrf防护，会使得不会生成对应的_csrf值，所以前端得到值会出现报错，当然这是后面的操作
        //即他并不是只有全部不防护的意思，而有直接的不操作_csrf值，使得基本不进行防护
        http.csrf().disable();
        
        //在没有其他的操作时，他一般会使得对应的过滤器删除，若有其他操作
        //比如
        //
        //http.csrf().ignoringAntMatchers("/user/saveOrUpdate"); 后面会操作到
        //那么不会删除对应的过滤器，即这时无论你是否关闭，即是否添加http.csrf().disable();，都不会删除
        //当然，若什么都不写，对应的过滤器自然是存在的，即不会删除
        //因为是默认的配置，或者说默认的添加上的（本来是0，最后是15个默认，那不就是添加吗）
        //所以说，基本只有单独的http.csrf().disable();才会进行删除


    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

至此我们就可以不需要name为_csrf的值，就可以认证了，可以试着运行启动类，访问即可，发现，的确认证成功，且进行了跳转

至此，总结一下，在没有配置之前

Spring Security默认的操作：

自带的代码操作的页面，使用/login可以访问到

对应默认认证路径是/login，其中该路径有代码生成页面的操作，看看是不是/login而给出页面

如果认证后，再次访问/login，进行认证，若失败了，则就使得认证重置（重定向，表单的认证失败），需要重新认证了

除非成功，一般成功后默认到自己进入的认证页面之前的路径（重定向，而不是转发）

默认post，默认username，默认password

可以直接的访问/login到对应自带的代码操作的页面

我们进行了设置：

自己写的页面，使用/toLoginPage可以访问到

对应默认认证路径是/login1，认证页面的访问变成了/toLoginPage（相当于/login，变成了/toLoginPage）

也就是说，设置后，就没有代码生成页面的操作了，而是自己的

即/login不能操作了（变成了/toLoginPage，即访问时，浏览器一般会提示没有该页面），没有该代码的生成，即访问什么就是什么

当然也要防止缓存，比如缓存在时，访问/login1会操作转发，因为我们认证成功了

即默认是认证成功的，但他只对当前窗口有效，在没有指定当前窗口有效的，一般认为对所有的窗口有效

之所以只对他一个窗口有效

前面的_csrf值的说明也是类似，但是他的单纯的访问，却因为正好存在，所以可以访问到，也刚好是一样的

主要是因为他（不是上面的说明）进行了有参数（表单的参数）的请求导致

并不是单纯的访问/login1，所以说是缓存的作用也是不为过的

当然，若再次回到/toLoginPage进行认证，若失败了，则就使得认证重置（重定向，表单的认证失败），需要重新认证了

默认post，默认username1，默认password1

可以直接的访问/toLoginPage到对应自己的页面

当然对应的代码生成页面，并不是绝对，可能是spring Security自带的页面，暂时规定是代码生成的

总结完毕，但是却又有一个问题，前面我说过，认证进入后，对应从数据库得到的信息或者是说对应的页面连接被拒绝访问了

如图，点击用户管理或者商品管理，鼠标到对应的中间的这个页面，就会出现如下

只有鼠标到了，才会有对应的提示"localhost拒绝了我们的连接请求"：

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

找到该整体界面的html（就是项目里的index.html），对应的部分代码如下：

<li><a href="/user/findAll" target="right"><span class="icon-caret-right">span>用户管理a>li>
<li><a href="/product/findAll" target="right"><span class="icon-caret-right">span>商品管理a>li>
1
2

我们发现，对应的target指向的是right，找到对应的代码：

<iframe scrolling="auto" rameborder="0" src="images/bg.jpg" name="right" width="100%" height="100%">iframe>
1

发现，指向上面的iframe，即发现行内框架iframe这里出现问题了

Spring Security下，X-Frame-Options默认为DENY，这也使得认证后，不会进行连接访问

非Spring Security环境下，X-Frame-Options的默认大多也是DENY

但这里可以试着将Spring Security依赖删除，发现可以连接访问，即是SAMEORIGIN情况，不属于大多数的

在DENY这种情况下，浏览器拒绝当前页面加载任何Frame页面

对应的设置含义如下：

DENY：浏览器拒绝当前页面加载任何Frame页面，此选择是默认的

SAMEORIGIN：frame页面的地址只能为同源域名下的页面（即不跨域的）

一般的iframe都不能操作跨域的页面，除非有特殊的操作，具体可以百度

允许iframe加载：

          //关闭csrf防护
        http.csrf().disable();

//加上下面的代码即可
        //加载同源域名下的iframe页面
        http.headers().frameOptions().sameOrigin();
1
2
3
4
5
6

这是，我们再次进行运行启动类，访问，可以看到对应的页面如下：

至此操作成功

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

之前我们所使用的用户名和密码是来源于框架自动生成的，那么我们如何实现基于数据库中的用户名和密码功能呢

换言之就是如何使用我们自己的用户名和密码呢：

要实现这个得需要实现security的一个UserDetailsService接口，重写这个接口里面的loadUserByUsername方法即可

在项目的service包下面的impl包下

编写MyUserDetailsService类并实现UserDetailsService接口，然后重写loadUserByUsername方法：

package com.lagou.service.impl;

import com.lagou.domain.User;
import com.lagou.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.Collection;

/**
 *基于数据库完成认证
 */
@Service
//只有实现了他，才可以使得注入后当成参数传递，因为参数一般需要对应的UserDetailsService类型或者其子类
public class MyUserDetailsService implements UserDetailsService {

    @Autowired
    private UserService userService;

    /**
     * 根据用户名查询用户
     * @param username 前端传入的用户名
     * @return
     * @throws UsernameNotFoundException
     */
    //只有该一个接口
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //查询数据库得到信息，具体如何得到的，并不需要知道
        //因为我们只需要学习对应的spring security，而不是学习该项目
        User byUsername = userService.findByUsername(username);
        if(byUsername == null){
            throw new UsernameNotFoundException("用户没有找到，"+username);
        }

        //权限的集合，现在我们并不需要操作权限，所以设置为空的集合，但不要设置成null，否则报错
        Collection<? extends GrantedAuthority> authorities = new ArrayList<>();
        UserDetails userDetails =
                new org.springframework.security.core.userdetails.User(
                        username //用户名
                        ,"{noop}"+byUsername.getPassword() //密码
                        ,true //用户是否启用，true代表启用，false代表未启用
                        ,true //用户是否过期，true代表没有过期，false代表过期
                        ,true //用户凭证是否过期，true代表没有过期，false代表过期
                        ,true //用户是否锁定，true代表未锁定，false代表锁定
                        ,authorities //权限的集合
                );
        //"{noop}"+byUsername.getPassword()代表不使用密码加密
        //实际上是{noop}代表了不使用的意思，而该参数正好是密码的参数，所以是不使用密码加密
        return userDetails;
    }
}

//注意：在认证时，该方法才会进行运行，使得操作密码的方式，当然，用户名需要自己进行验证
//比如说，我们将username修改成"username"，会发现，还是可以认证成功
//所以用户名需要我们自己进行验证，对应的认证基本只会认证密码

//至此，如果我们重新运行启动类，没有清除缓存，即认为认证的，那么对应的UserDetails会根据缓存得到
//而不会执行该方法，所以这时该值不变，也就使得后面的得到用户名操作的值不会变
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

编写好后，对应的方法是如何执行呢，看如下

对应的SecurityConfiguration类的configure（AuthenticationManagerBuilder auth）方法以及对应的注入：

 @Autowired
    private UserDetailsService userDetailsService;
    /**
     * 身份安全管理器
     * @param auth
     * @throws Exception
     */
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService) //交给其管理，使得认证时，操作对应的方法
            //我们输入用户名和密码时，当成参数提交，当然
            //实际上对应的判断，只会判断密码，所以我们需要自己判断用户名）数据库判断）
            //可以执行对应的方法，得到对应的数据库信息的返回结果进行处理（处理密码）
            //总体使得只要用户名和密码可以被数据库里进行找到，那么对应的结果自然可以使得认证成功
            //那么这个时候，就不会操作默认的用户名和密码了
            //那么原来的默认用户名和密码是怎么来的呢：
            //是对应的super.configure(auth)操作得到的（得到的也是默认）
            //当我们有UserDetailsService的实例（前面的实现）
            //那么就不会使得操作默认的用户名和密码，无是否有super.configure(auth)和是否有配置类
            //而是操作对应的userDetailsService结果，即看看是否有对应的返回数据，从而完成认证
            //当然，若也没有对应的auth.userDetailsService(userDetailsService)操作，对应的实例有无
            //也是没有默认的操作
            //那么基本不可能能够认证成功的，若没有配置类，且没有对应的实例，则操作默认的，否则什么都没有
            
            //具体自己进行测试

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

我们知道这个配置类会被调用进行执行方法，那么对应的注入也自然可以进行注入

接下来我们看看数据库的信息：

我们将对应的密码加密的密码进行修改，直接修改成123456

因为我们现在并没有操作加密（不使用密码加密，上面设置的"{noop}"）

这时运行启动类，清除浏览器缓存，可以发现日志并没有密码出现了，使用表里面的数据，对应的加密的密码也可以

因为在不使用加密操作时，对应的密码就是数据库的，而不会操作加密

若认证成功，即到达了对应的首页，则操作成功

密码加密认证：

在基于数据库完成用户登录的过程中，我们所是使用的密码是明文的，规则是通过对密码明文添加{noop}前缀

那么下面 Spring Security 中的密码编码进行一些探讨：

Spring Security 中PasswordEncoder就是我们对密码进行编码的工具接口，该接口只有两个功能：

一个是匹配验证，另一个是密码编码：

idea中，使用ctrl+n搜索PasswordEncoder，得到如下：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.springframework.security.crypto.password;

public interface PasswordEncoder {
    String encode(CharSequence var1);

    boolean matches(CharSequence var1, String var2);

    default boolean upgradeEncoding(String encodedPassword) {
        return false;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

对应的实现类有很多个，其他主要的两个操作密码的如下：

BCryptPasswordEncoder（加密操作）和NoOpPasswordEncoder（不使用加密操作，相当于操作了"{noop}"）：

BCrypt算法介绍：

任何应用考虑到安全，绝不能明文的方式保存密码，密码应该通过哈希算法进行加密

有很多标准的算法比如SHA或者MD5，结合salt（盐，加上随机数，比如操作UUID等等）是一个不错的选择

Spring Security 提供了BCryptPasswordEncoder类，实现Spring的PasswordEncoder接口使用BCrypt强哈希方法来加密密码

BCrypt强哈希方法，每次加密的结果都不一样，所以更加的安全

bcrypt算法相对来说是运算比较慢的算法，在密码学界有句常话：越慢的算法越安全

黑客破解成本越高，通过salt和cost这两个值来减缓加密过程，它的加密时间（百ms级）远远超过md5（大概1 ms左右）

对于计算机来说， Bcrypt 的计算速度很慢，但是对于用户来说，这个过程不算慢

bcrypt是单向的，而且经过salt和cost的处理，使其受攻击破解的概率大大降低，同时破解的难度也提升不少

相对于MD5等加密方式更加安全，而且使用也比较简单

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

其中$是分割符，无意义，2a是bcrypt加密版本号，10是cost的值，而后的前22位是salt值，再然后的字符串就是密码的密文了

这里的cost值即生成salt的迭代次数，默认值是10，推荐值12

那么分开来说就是：

$2a $10 $wouq9P/HNgvYj2jKtUN8rO JJNRVCWvn1XoWy55N3sCkEHZPo3lyWq
1

在项目中使用BCrypt

首先看下PasswordEncoderFactories 密码器工厂（idea中，使用ctrl+n搜索PasswordEncoderFactories 即可找到）：

部分代码：

  public static PasswordEncoder createDelegatingPasswordEncoder() {
        String encodingId = "bcrypt";
        Map<String, PasswordEncoder> encoders = new HashMap();
        encoders.put(encodingId, new BCryptPasswordEncoder());
        encoders.put("ldap", new LdapShaPasswordEncoder());
        encoders.put("MD4", new Md4PasswordEncoder());
        encoders.put("MD5", new MessageDigestPasswordEncoder("MD5"));
        encoders.put("noop", NoOpPasswordEncoder.getInstance());
        encoders.put("pbkdf2", new Pbkdf2PasswordEncoder());
        encoders.put("scrypt", new SCryptPasswordEncoder());
        encoders.put("SHA-1", new MessageDigestPasswordEncoder("SHA-1"));
        encoders.put("SHA-256", new MessageDigestPasswordEncoder("SHA-256"));
        encoders.put("sha256", new StandardPasswordEncoder());
        encoders.put("argon2", new Argon2PasswordEncoder());
        return new DelegatingPasswordEncoder(encodingId, encoders);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

上面是对应的前缀的作用，使得操作加密或者不加密的方式，在运行启动类时，会进行初始化，可以试着打断点进行查看

可以发现，在还没有启动完毕时，会执行

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

修改后，如下：

 UserDetails userDetails =
                new org.springframework.security.core.userdetails.User(
                        username //用户名
                        ,"{bcrypt}"+byUsername.getPassword() //密码
                        ,true //用户是否启用，true代表启用，false代表未启用
                        ,true //用户是否过期，true代表没有过期，false代表过期
                        ,true //用户凭证是否过期，true代表没有过期，false代表过期
                        ,true //用户是否锁定，true代表未锁定，false代表锁定
                        ,authorities //权限的集合
                );
//"{bcrypt}"+byUsername.getPassword()代表使用密码加密

//当然，他并不是对他自己进行加密，而是使得他操作我们输入的值进行加密
//即该前缀是携带操作我们输入密码的加密方式的意思
1
2
3
4
5
6
7
8
9
10
11
12
13
14

为了得到一个加密的值，我们在对应的MyUserDetailsService类里进行测试，代码如下：

  public static void main(String[] args) {
        //使用加密的类，进行加密
        BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
        //得到123456加密后的值
        String code = bCryptPasswordEncoder.encode("123456");

        System.out.println(code); //$2a$10$qbhLCxg43v7bv0oPk1dNz.vXCL.qT4.kEmMRdTJlh/CFY9v.OwAtq

      //注意：对应的值，多次的运行并不是一样的，因为有随机的存在
      //每个随机数Spring Security会进行保存的，使得可以解密
      //当然并不是一定会进行保存，因为解密的操作可能也是需要对应加密后的字符串的，使得得到值
      //当然这里并不需要我们进行理解，只需要知道他能这样做即可
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

我们将生成的加密后的密码赋值到数据库里进行后续的运行操作

接下来，运行启动类，清除浏览器缓存，再次的输入用户名和密码进行操作，如果认证成功，则操作完毕

这里需要思考个问题，那么对应的"{noop}“和”{bcrypt}"，可以不加吗，或者说有没有默认的：

通过试验发现，必须加上对应的值，否则会报错

即我们需要在前面加上对应的PasswordEncoderFactories类里面的createDelegatingPasswordEncoder方法里面的map集合的key的值

基本是这样，否则会报错

获取当前登录用户：

在传统web系统中，我们将登录成功的用户放入session中，在需要的时候可以从session中获取用户

那么Spring Security中我们如何获取当前已经登录的用户呢：

SecurityContextHolder：

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

SecurityContext：

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

代码实现：

找到UserController类，加上如下方法：

  /**
     * 获取当前登录的用户
     */

    @GetMapping("/loginUser1")
    @ResponseBody
    public UserDetails getCurrentUser1(){
        UserDetails principal = 
            (UserDetails)SecurityContextHolder.getContext().getAuthentication().getPrincipal();

        System.out.println(principal);
        return principal;

    }

    /**
     * 获取当前登录的用户
     */

    @GetMapping("/loginUser2")
    @ResponseBody
    public UserDetails getCurrentUser2(Authentication authentication){
        UserDetails principal = (UserDetails)authentication.getPrincipal();
        System.out.println(principal);
        return principal;

    }

    /**
     * 获取当前登录的用户
     */

    @GetMapping("/loginUser3")
    @ResponseBody
    //@AuthenticationPrincipal注解必须加上，否则报错
    public UserDetails getCurrentUser3(@AuthenticationPrincipal UserDetails userDetails){
        System.out.println(userDetails.getUsername());
        System.out.println(userDetails.getPassword());
        System.out.println(userDetails);
        return userDetails;

    }

//上面是三种方式获取用户名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

可以得到对应数据库的用户名，但是密码不会给出，这是肯定的

remember me 记住我：

在大多数网站中，都会实现RememberMe这个功能，使得前端，方便用户在下一次登录时直接登录

避免再次输入用户名以及密码去登录，Spring Security针对这个功能已经帮助我们实现，下面我们来看下他的原理图：

简单的Token生成方法：

下面的RememberMeAuthenticationFilter主要是操作对应的remember me的过滤器，中间的是对应的底层操作，这些作用知道即可

并不需要死磕

Token=MD5（username+分隔符+expiryTime+分隔符+password，进行加密得到值），比如操作得到的值是：

YWRtaW46MTY2MTI0MDQzODEwNjpjMmZlZDdkZDY0YWNkNmJhZTZmNThjYjg2ZGY3MDE1YQ（举个例子）

注意：这种方式不推荐使用，有严重的安全问题，就是密码信息在前端浏览器cookie中存放

如果cookie被盗取很容易破解（MD5现在并不是很安全）

代码实现：

首先开启记住我（remember me）的功能：

 http.formLogin().loginPage("/toLoginPage")
                .loginProcessingUrl("/login1") 
                .usernameParameter("username1") 
                .passwordParameter("password1") 
                .successForwardUrl("/")
                .and().rememberMe() //这里加上该代码，代表开启记住我功能
                .tokenValiditySeconds(1209600) //token失效时间，默认设置为2周（1209600秒）
                .rememberMeParameter("remember-mer") 
     //代表表单里对应的input的name值，一般默认设置为remember-me，这里就设置成remember-mer了  
     //基本是随便设置的
                .and().authorizeRequests().anyRequest().authenticated();
1
2
3
4
5
6
7
8
9
10
11

前端页面需要增加remember-me的复选框（在对应的login.html下可以看到如下代码）：

  <div class="form-group">
                            <div>
                                
                                <input type="checkbox" name="remember-mer" value="true"/>记住我
                            div>
                        div>

1
2
3
4
5
6
7
8
9
10
11
12

这时我们运行启动类，并清除浏览器缓存，访问根目录，即http://localhost:8080/，这时需要我们认证

先不点击"记住我"这个按钮，登录，然后退出浏览器，继续进入浏览器，访问根目录，即http://localhost:8080/

发现，还是需要认证，这时，我们点击记住我，登录后，退出浏览器，访问根目录，即http://localhost:8080/，这时不需要认证了

即我们直接的跳过了认证，查看对应的cookie，会发现，多出了一个cookie，名称是remember-me，可以发现

我们在设置表单名称时也最好设置为remember-me，虽然这里设置成了remember-mer，但也是为了规范

最好也是设置成remember-me，我之所以设置成remember-mer，是为了让后面的解释更加清楚，有异常的变化，好观察

我们仔细看看该cookie，看到对应的基本操作我们的根目录，即在当前根目录下可以使用该cookie

所以其他的窗口也是如此（虽然cookie在路径基本一致的情况下，会共享），如果忘记了cookie的基础，可以看看50章博客

至此可以知道，我们去访问时，该cookie会给服务器，由于对应的值中，保存了用户名和密码，通过反向的解密

然后进行认证，也就是对比，也就是密码的对比，即UserDetails里面的参数

通过前面的三个方式，不难得到，当然这是底层的操作

当然，一般都会认证成功的，因为我们并没有进行改变

当然他并不会操作设置的认证成功后的地址，而是自己的当前访问的地址

也就相当于我们输入了用户名和密码，从而使得认证成功

这时，我们设置退出浏览器关闭cookie时，会发现对应的访问根目录，即http://localhost:8080/，又需要认证了

即他是操作cookie来进行的，即每次的重新访问，会根据cookie而使得不用外面认证，且是我们之前操作的用户名

那么该cookie的值，如何而来，在外面传递对应的name为remember-mer时（当然也包括其他信息）

若对应的设置表单也是remember-mer，那么就会准备cookie返回给浏览器

否则不会准备返回给浏览器，也就相当于不操作"记住我"，即也相当于没有点击"记住我"

即不同时，无论你是否点击"记住我"，也没有对应的cookie，既然没有对应的cookie

那么就相当于对应的值是不对的，也就是对比失败，会使得没有认证

自然会重定向到认证页面，除非已经认证的缓存还在，当操作了该cookie时

要注意：操作这个cookie时，对应的用户名（对比UserDetails里面的）需要与你传递的用户名一致

否则会报错，使得认证不了，没有操作之前不会

之所以要这样，是防止用户名不一致的情况，因为他是帮我们跳过认证

所以对应的用户名会进行判断一次，防止不同，即严谨了些

但是，这个时候，虽然我们有对应的cookie，如果重新启动的话，还会自动认证吗：

通过试验，若你重新启动，那么对应的cookie认证是一般也可以成功，因为对应的对比会根据缓存创建（重新启动了）

会使得可以认证，缓存也可以说是cookie数据

当然若操作那个有参数（表单的参数）请求的（自然在这里通常是包括认证的）

则也是自然还是会到当前页面（对应的请求页面，也就是当前页面，刷新的当前页面，而不会重定向到认证）

但是若是没有缓存（退出浏览器）的其他的请求，则需要认证了，因为不是有参数（表单的参数）请求和有对应的对比

至此该操作我们进行完毕

最后注意一下：一些扩展基本与cookie是无关的

如保存网站的用户名和密码的操作，使得下次可以自动帮我们输入，一般浏览器都会自带的

是否退出浏览器或者是否清除缓存与他们无关

且没有使用remember-me时，对应的关闭浏览器后

再次的打开由于使得sessionid变化了（当然清除缓存，自然也会使得得到新的sessionid，一般也叫做sessionid值）

所以默认不会使得认证成功（判断使得），然后重定向到认证页面

而操作remember-me时，则会解析他的值，从而使得认证，从而得到信息

但是只要认证后，那么基本就不会操作remember-me了，因为已经认证了

使得有对应的信息，绑定对应的sessionid

基本只有sessionid的值改变了（该sessionid与认证的信息有关的，比如后面的账号在线数）

其他的cookie基本没有

可以自己查看认证成功后的sessionid的值，一般都会进行改变（自然对应的其他相同请求路径也会改变，刷新即可，这是cookie的原因）

即就可以相当于直接的访问了

当然清除缓存的话，自然也需要继续认证

总体来说就是：通过用户名和密码以及其他条件生成的token，当成cookie进行验证

只要对应的token存在，那么就基本不需要我们输入用户名和密码了

但是上面的我们基本只要关闭删除对应的cookie，那么就不会自动的认证了，如使得持久化呢：

持久化的Token生成方法：

存入数据库Token包含：

token：随机生成策略，每次访问都会重新生成

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

expiryTime：token过期时间

CookieValue（cookie的值）=encode（series+token）

代码实现：

在配置类SecurityConfiguration里面加上如下代码：

@Autowired
    private DataSource dataSource;
    /**
     * 负责token与数据库之间的相关操作
     * @return
     */
    @Bean
    public PersistentTokenRepository getpersistentTokenRepository(){
        JdbcTokenRepositoryImpl tokenRepository = new JdbcTokenRepositoryImpl();
        tokenRepository.setDataSource(dataSource); //设置数据源
        //启动时帮助我们创建一张表，主要用来存放token的信息
        //第一次启动设置为true，第二次启动设置为false，或者注释掉
        //true代表创建表，false代表不创建，当然，注释的话，自然不会操作表
        //因为若有对应的表的话，设置为true时，启动时会报错，说明表已经存在
        //或者说，只要数据库里有表存在，就需要设置为false或者注释
        tokenRepository.setCreateTableOnStartup(true);
        return tokenRepository;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

修改配置类的部分configure（HttpSecurity http）方法：

 http.formLogin().loginPage("/toLoginPage")
                .loginProcessingUrl("/login1")
                .usernameParameter("username1") 
                .passwordParameter("password1") 
                .successForwardUrl("/")
                .and().rememberMe()
                .tokenValiditySeconds(1209600) 
                .rememberMeParameter("remember-mer")
                .tokenRepository(getpersistentTokenRepository()) //这里是添加的代码
                .and().authorizeRequests().anyRequest().authenticated();
1
2
3
4
5
6
7
8
9
10

也就是说，在启动之前，即初始化之前，我们会进行创建一个对应存放token的表

接下来我们先观察数据库的表（删除掉对应的persistent_logins表，否则启动时会报错，说明表已存在）

然后运行启动类，看看数据库是否有对应的表创建，即该persistent_logins表是否创建，若创建则表示操作成功

对应的表信息如下：

创建好后，注释掉对应的代码，重新运行启动类，并清除浏览器缓存，点击"记住我"，然后认证登录，查看数据库的数据

会发现，多了一条数据，注意：必须要点击"记住我"，否则不会添加数据

因为他需要判断是否有携带设置的remember-me的字段，当然我们这里设置的是remember-mer

当然不一致的话，自然也不会操作"记住我"，即也相当于没有点击"记住我"，也使得不会操作持久化

总体来说就是：在前面操作的remember-me基础上，保存token的信息到数据库，实现持久化，每次的remember-me解析认证

都会使得数据库的信息发生变化，即我们关掉浏览器，再次访问（解析认证）

查看数据库，发现对应的token字段值和token过期时间值发生变化了，那么该值有什么作用呢：

接下来进行测试：

我们首先清空对应的数据库，重启启动类，清除浏览器缓存，进行登录认证，查看数据库是否创建

发现已经创建了，退出浏览器，方法根目录（http://localhost:8080/）

那么他是操作remember-me使得对比，还是操作数据库信息使得对比呢，在这之前，先看如下的试验数据：

接下来我们修改token字段的值，随便怎么修改，退出浏览器，继续访问根目录，发现需要你登录了

这时我们查看数据库的信息，发现

对应的那条数据被删除（且使得remember-me的cookie被删除，比如设置过期时间，使得当场失效）

这时我们再次认证登录，查看数据库的信息，又多出一条

那么修改过期时间怎么样，通过我的试验，对应的过期时间的修改并不会影响当时的认证（大概主要是给我们看的吧）

可能在某些时候有点作用

那么对应的series字段呢，通过我的试验，当我们修改他的值时，无论其他字段是否修改，都不会删除该数据

但也要重新认证，且remember-me的cookie也被删除，对应的用户名不同也是如此

从以上的试验可以得出结论，series和用户名是唯一的（不会删除），token是不唯一的（会删除），过期时间不用考虑

我们通过观察浏览器的token和数据库的信息，可以发现，并没有可以直观的看到联系

那么可以这样的理解（可能不对），浏览器得到的token虽然用来解析进行对比

解析的一般是操作密码的信息，因为用户名是保存的，然后进行对比信息

认证的对比，不是数据库对比，实际上用户名主要是帮我们得到对比信息，后面的源码会说明

虽然也会操作认证对比，测试即可，将对比的用户名修改成与原来的用户名不同，会发现，重定向到认证页面，没有后缀

但是在这之前，解析的值也需要与数据库进行对比查看，首先查询的是series值

如果series值存在，且对应的token值也正好正确，以及用户名对比成功（大概会检查是否改变，对比的检查）

那么才进行对比认证，如果token值不正确，则对比认证不成功，相当于使得没有认证，且删除该条数据

重新进行认证（相当于重定向到认证页面）

如果series值和用户名不存在，则直接对比不成功，那么就相当于没有认证过

重新认证（相当于重定向到认证页面），但不会进行删除

对比之后，解析为密码，这时用户名和密码都有了，那么就可以对比（认证的对比）了

由此可见，对应数据库的作用，是为了进一步的提高安全，实际上也可以说浏览器上的token是他们进行合并加密的

至此，也提高了安全的作用，因为需要多次的解密

也完成了保存（持久化）的作用，保存解密的在数据库里（虽然可能还是需要解密变成密码进行对比）

实际上也算是一种永久的身份令牌（要看如何使用）

而这样的令牌可以操作很多种情况，在生活中我们也可以知道，在某些应用中，可以使用微信进行登录

而不需要我们自己输入用户名和密码，只要你登录过了即可，这就是一种类似的情况

在以后，我们可以交给用户这个令牌，那么他就可以不需要用户名和密码登录了

虽然这里是cookie的形式，但这只是一种比喻而已

Cookie窃取伪造演示：

前面说过，放在cookie里容易被获取，无论是否持久化都是如此，接下来我们来进行演示

在postman里，运行如下：

我们可以发现，返回的是页面，自然，我们试验postman时相当于操作一个浏览器的

所以自然也是需要认证，即会返回页面

接下来清空persistent_logins表数据，清除浏览器缓存，重新认证，点击"记住我"，然后查看对应的remember-me的cookie的值

假装这个值被窃取（容易被窃取的）

回到postman点击如下：

点击Cookies，到如下：

点击这个Add Cookie加上一个cookie，左边的remember-me就是如下的（这是保存后的）

否则一般显示"Cookie_对应的第几个创建"

一般重启postman会重置这些操作，如第几个创建的数字变为1，添加的删除等等

添加后并保存

至此我们再次去访问该路径，发现，并不需要认证了，因为对应的数据进行对比成功了，也就不会给出重新认证的页面了

如：

只要该值的解析可以对比成功，那么以后都可以对比成功，甚至可以有多个这样的值（只要解析可以对比成功）

那么如何避免这样的方式呢：

安全验证：

找到对应的UserController类的getById方法，我们假设他是重要的方法，即我们对重要的方法进行安全验证

虽然也可以对不重要的方法验证，但并不完全需要

进行修改：

 /**
     * 根据用户ID查询用户
     *
     * @return
     */
    @GetMapping("/{id}")
    @ResponseBody
    public User getById(@PathVariable Integer id) {
        //获取认证的信息，相当于可以得到org.springframework.security.core.userdetails.User的信息一样
        //只是需要再次获取
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        System.out.println(authentication);
        System.out.println(RememberMeAuthenticationToken.class.isAssignableFrom(
            authentication.getClass()) == true);
        //如果返回true，代表这个登录认证的信息，来源于自动登录
        if(RememberMeAuthenticationToken.class.isAssignableFrom(authentication.getClass()) == true){
            //一般来说，spring security在操作异常时，会重定向到认证页面，一般并不会打印异常的信息
            //但是，这是交给spring security进行操作的异常
            //如果我们自己进行捕获，如使用try，则不会重定向到认证页面
           throw new RememberMeAuthenticationException("认证来源于RememberMe");
            //使用throw自然是直接的操作异常，而没有什么抛出以及捕获的操作
            //到最终的抛出和不是最终的捕获的了
            //但这是对他自己，直接的操作异常可以被捕获（只要是异常就可以被捕获，基本没有最终的捕获）
            //所以他本身也是可以被捕获（try）的
            //而抛出则会指向到他这样的格式，所以并不会在抛出了（最终的抛出）
        }
        User user = userService.getById(id);
        return user;
        //注意：使用表单登录时，对应的authentication值类型是如下：
        //org.springframework.security.authentication.UsernamePasswordAuthenticationToken@fa794fef
        //而自动登录，即使用rememberme时，对应的值，如下：
        //org.springframework.security.authentication.RememberMeAuthenticationToken@487ac513
        //也就是说，对应的操作是有不同的，主要是Authentication认证的信息不同
        //虽然他保存了认证信息，但是使用什么方式认证，决定了他的值的类型（是子类或者其本身，则返回true）
        //这样就可以使得进行安全的认证，使得有些必须只能够操作表单认证才可
        //否则认证的类型不会相同（因为认证后，就不需要认证了）
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

这时，我们重新启动项目，清除浏览器缓存，通过试验可以知道，对应的当不是表单时，对应的会跳转到认证页面

在重要操作步骤可以加以验证，true代表自动登录，则引导用户重新表单登录，false正常进行

自定义登录成功处理和失败处理：

在某些场景下，用户登录成功或失败的情况下用户需要执行一些后续操作，比如登录日志的搜集

或者在现在目前前后端分离的情况下，用户登录成功和失败后需要给前台页面返回对应的错误信息

由前台主导登录成功或者失败的页面跳转，因为在前后端分离的时候

对应的后端基本只有接口，没有页面，所以需要有错误的信息，虽然可以重定向使得前端进行访问

但这种耦合，即联系是最好不要存在的，不符合前后端分离，容易出现一个地方失败，使得多个地方失败

这个时候需要要到用到AuthenticationSuccessHandler接口与AnthenticationFailureHandler接口

自定义成功处理：

实现AuthenticationSuccessHandler接口，并重写onAnthenticationSuccesss()方法

自定义失败处理：

实现AuthenticationFailureHandler接口，并重写onAuthenticationFailure()方法

在这之前，我们首先看如下的解释：

/*
在配置类中，我们可以知道有如下的操作loginPage("/toLoginPage")和successForwardUrl("/")
接下来我们看看对应的loginPage("/toLoginPage")，点击进去

public FormLoginConfigurer loginPage(String loginPage) {
        return (FormLoginConfigurer)super.loginPage(loginPage);
    }
    
    再次点击loginPage(loginPage);进去
    
    protected T loginPage(String loginPage) {
        this.setLoginPage(loginPage);
        this.updateAuthenticationDefaults();
        this.customLoginPage = true;
        return this.getSelf();
    }
    
    点击this.updateAuthenticationDefaults();进去
    
     protected final void updateAuthenticationDefaults() {
        if (this.loginProcessingUrl == null) {
            this.loginProcessingUrl(this.loginPage); 
            这里是操作没有认证或者是除了表单的认证失败的其他情况，就需要到这里，代表重定向到认证页面
        }

        if (this.failureHandler == null) {
            this.failureUrl(this.loginPage + "?error"); //当表单失败认证时，操作这个，有后缀
        }

        LogoutConfigurer logoutConfigurer = (LogoutConfigurer)
        ((HttpSecurityBuilder)this.getBuilder()).getConfigurer(LogoutConfigurer.class);
        if (logoutConfigurer != null && !logoutConfigurer.isCustomLogoutSuccess()) {
            logoutConfigurer.logoutSuccessUrl(this.loginPage + "?logout");
        }
        当退出认证时，操作这个，一般是退出登录，有后缀，基本是重定向

    }
    
    上面的后缀，只是用来看的，实际上并不会有什么作用
    你可以试着在后面随便怎么操作，如赋值，或者多加，结果都是认证页面，说明并没有什么作用
    
    我们点击this.failureUrl(this.loginPage + "?error");进去
    
    public final T failureUrl(String authenticationFailureUrl) {
        T result = this.failureHandler(new 
        SimpleUrlAuthenticationFailureHandler(authenticationFailureUrl));
        this.failureUrl = authenticationFailureUrl;
        return result;
    }
    
    点击new SimpleUrlAuthenticationFailureHandler(authenticationFailureUrl)进去
    会发现SimpleUrlAuthenticationFailureHandler实现了AuthenticationFailureHandler接口
    代表操作认证失败的，查看对应的方法，可以知道是重定向
    
    由于该new SimpleUrlAuthenticationFailureHandler(authenticationFailureUrl)的当作参数
    所以回到上一级（上一级表示，就是我们进入之前的地方），若是多个上一级，我会说明回到某某地方，并标识写出来
    当然，并不会都会标识上一级，注意即可，总有漏网之鱼吧
    找到this.failureHandler(new SimpleUrlAuthenticationFailureHandler(authenticationFailureUrl));
    点击failureHandler进去
    找到如下
     public final T failureHandler(AuthenticationFailureHandler authenticationFailureHandler) {
        this.failureUrl = null;
        this.failureHandler = authenticationFailureHandler;
        return this.getSelf();
    }
    
    说明failureHandler是操作认证失败的
    
    至此，可以得出认证失败，的确是重定向
    
    那么认证成功呢，点击successForwardUrl("/")进去
    
    public FormLoginConfigurer successForwardUrl(String forwardUrl) {
        this.successHandler(new ForwardAuthenticationSuccessHandler(forwardUrl));
        return this;
    }
    
    点击new ForwardAuthenticationSuccessHandler(forwardUrl)进去
    会发现ForwardAuthenticationSuccessHandler实现类AuthenticationSuccessHandler接口
    说明是操作认证成功的，看看对应的方法
      public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, 
      Authentication authentication) throws IOException, ServletException {
        request.getRequestDispatcher(this.forwardUrl).forward(request, response);
    }
    
    发现是转发操作，至此对应的认证成功也的确是转发，回到上一级
    由于new ForwardAuthenticationSuccessHandler(forwardUrl)是当成参数，我们点击如下
    this.successHandler(new ForwardAuthenticationSuccessHandler(forwardUrl));
    点击successHandler进去
    
     public final T successHandler(AuthenticationSuccessHandler successHandler) {
        this.successHandler = successHandler;
        return this.getSelf();
    }
    
    可以发现successHandler是操作认证成功的
    
    至此可以得出结论，failureHandler操作认证失败，successHandler操作认证成功
    但是他们却都是操作表单的认证或者是对应的提交认证
    只要提交就会，当然，如HttpBasic认证也有这样的设置，自然也是一样的操作
    只是一般没有，所以我们通常操作表单认证
    
    而没有认证，或者不是表单认证失败的（如对比失败），基本都会重定向到认证页面，一般没有后缀
  

*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

package com.lagou.service.impl;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
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.Service;

import javax.servlet.FilterChain;
import javax.servlet.RequestDispatcher;
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{


    //用来得到可以操作响应的response，可以用它来操作重定向（转发好像操作不了）
    //虽然单纯的使用response也可以操作（也可以操作转发），但对于ajax来说
    //重定向和转发并不会起作用，因为接收者不是浏览器，而是ajax，所以一般会使得报错
    RedirectStrategy redirectStrategy = new DefaultRedirectStrategy();


    @Autowired
    private ObjectMapper objectMapper; //可以将map转换成json
    /**
     * 登录成功后处理的逻辑
     * @param httpServletRequest
     * @param httpServletResponse
     * @param authentication
     * @throws IOException
     * @throws ServletException
     */
    @Override
    public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse 
                                        httpServletResponse, Authentication authentication) throws 
        IOException, ServletException {
        System.out.println("登录成功后继续处理");

        redirectStrategy.sendRedirect(httpServletRequest,httpServletResponse,"/");

        //httpServletResponse.sendRedirect("/");
                //RequestDispatcher requestDispatcher = httpServletRequest.getRequestDispatcher("/");

        //requestDispatcher.forward(httpServletRequest, httpServletResponse);
     

    }

    /**
     * 登录失败的处理逻辑
     * @param httpServletRequest
     * @param httpServletResponse
     * @param e
     * @throws IOException
     * @throws ServletException
     */
    @Override
    public void onAuthenticationFailure(HttpServletRequest httpServletRequest, HttpServletResponse 
                                        httpServletResponse, AuthenticationException e) throws 
        IOException, ServletException {
        System.out.println("登录失败后进行处理");

        redirectStrategy.sendRedirect(httpServletRequest,httpServletResponse,"/toLoginPage");
        
        //httpServletResponse.sendRedirect("/toLoginPage");
    //RequestDispatcher requestDispatcher = httpServletRequest.getRequestDispatcher("/toLoginPage");

        //requestDispatcher.forward(httpServletRequest, httpServletResponse);
     
    }
}



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

 
@Autowired
    private MyAuthenticationService myAuthenticationService;
//这里进行注入，由于需要当成参数，且参数是对应的两个接口类型，所以该类需要实现对应的两个接口，使得当成总体参数

@Override
    protected void configure(HttpSecurity http) throws Exception {

        http.formLogin().loginPage("/toLoginPage")
                .loginProcessingUrl("/login1") 
                .usernameParameter("username1") 
                .passwordParameter("password1")
                .successForwardUrl("/")
                .successHandler(myAuthenticationService) //登录成功的处理
                .failureHandler(myAuthenticationService) //登录失败的处理
                .and().rememberMe()
                .tokenValiditySeconds(1209600) 
                .rememberMeParameter("remember-mer")
              
                .tokenRepository(getpersistentTokenRepository())
                .and().authorizeRequests().anyRequest().authenticated();

        http.csrf().disable();


        http.headers().frameOptions().sameOrigin();

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package com.lagou.service.impl;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
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.Service;

import javax.servlet.FilterChain;
import javax.servlet.RequestDispatcher;
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{


    //用来得到可以操作响应的response，可以用它来操作重定向（转发好像操作不了）
    //虽然单纯的使用response也可以操作，也可以使用request操作转发，但对于ajax来说
    //无论重定向还是转发并不会起作用，因为接收者不是浏览器，而是ajax
    RedirectStrategy redirectStrategy = new DefaultRedirectStrategy();


    @Autowired
    private ObjectMapper objectMapper; //可以将map转换成json
    /**
     * 登录成功后处理的逻辑
     * @param httpServletRequest
     * @param httpServletResponse
     * @param authentication
     * @throws IOException
     * @throws ServletException
     */
    @Override
    public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse 
                                        httpServletResponse, Authentication authentication) throws 
        IOException, ServletException {
        System.out.println("登录成功后继续处理");

        //redirectStrategy.sendRedirect(httpServletRequest,httpServletResponse,"/");
        //httpServletResponse.sendRedirect("/");
        //RequestDispatcher requestDispatcher = httpServletRequest.getRequestDispatcher("/");

        //requestDispatcher.forward(httpServletRequest, httpServletResponse);

        Map result = new HashMap();
        result.put("code", HttpStatus.OK.value()); //对应的value一般返回的是200
        result.put("message","登录成功");

        httpServletResponse.setContentType("application/json;charset=UTF-8");

        httpServletResponse.getWriter().write(objectMapper.writeValueAsString(result));

    }

    /**
     * 登录失败的处理逻辑
     * @param httpServletRequest
     * @param httpServletResponse
     * @param e
     * @throws IOException
     * @throws ServletException
     */
    @Override
    public void onAuthenticationFailure(HttpServletRequest httpServletRequest, HttpServletResponse 
                                        httpServletResponse, AuthenticationException e) throws 
        IOException, ServletException {
        System.out.println("登录失败后进行处理");

        //redirectStrategy.sendRedirect(httpServletRequest,httpServletResponse,"/toLoginPage");
        //httpServletResponse.sendRedirect("/toLoginPage");
   //RequestDispatcher requestDispatcher = httpServletRequest.getRequestDispatcher("/toLoginPage");

        //requestDispatcher.forward(httpServletRequest, httpServletResponse);
        
        Map result = new HashMap();
        result.put("code", HttpStatus.UNAUTHORIZED.value()); //对应的value一般返回的是401
        result.put("message","登录失败");

        httpServletResponse.setContentType("application/json;charset=UTF-8");

        httpServletResponse.getWriter().write(objectMapper.writeValueAsString(result));
    }
}


//当然，这里你可以先不进行打印数据，而是先操作重定向来进行验证是否跳转
//虽然一般会进行跳转（虽然前面验证过了）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

  <div style="padding:30px;">
                        <input type="button" onclick="login()"
                               class="button button-block bg-main text-big input-big" value="登录">
                    div>


<script>
    
    //注意：使用这里的ajax会导致验证码不填写也会进行提交(点击框框返回的时候会提示），而没有对应的阻拦
    function login(){
        $.ajax({
            type:"POST", //请求类型
            dataType:"json", //服务器返回数据的类型
            url:"/login1", //请求路径
            data:$("#formLogin").serialize(), //将表单数据转化成json
            success:function(data){
                //alert(data)
                //这里可以先将弹出框进行查看，而不用先执行下面的，即将下面注释掉进行测试，防止你出现了问题
                if(data.code == 200){
                    //因为返回200，就说明了是认证成功，那么就可以直接的访问了
                    window.location.href = "/";

                }else{
                    alert(data.message)
                }
            }
        })
    }

script>



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

/*
我们先看看对应的两个方法
.successHandler(myAuthenticationService) //登录成功的处理
.failureHandler(myAuthenticationService) //登录失败的处理

点击.successHandler(myAuthenticationService) 进去	
  public final T successHandler(AuthenticationSuccessHandler successHandler) {
        this.successHandler = successHandler;
        return this.getSelf();
    }
    
    看到这个successHandler应该知道，在前面说过，他是操作认证成功的，所以原来的设置是被他覆盖了
    
    点击.failureHandler(myAuthenticationService)进去
    
      public final T failureHandler(AuthenticationFailureHandler authenticationFailureHandler) {
        this.failureUrl = null;
        this.failureHandler = authenticationFailureHandler;
        return this.getSelf();
    }
    
    同样也是如此failureHandler也是覆盖原来的设置，这就是为什么使用我们自己的配置的原因
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

 http.formLogin().loginPage("/toLoginPage")
                .loginProcessingUrl("/login1") 
                .usernameParameter("username1")
                .passwordParameter("password1") 
                .successForwardUrl("/")
                .successHandler(myAuthenticationService)
                .failureHandler(myAuthenticationService)
                .and().rememberMe()
                .tokenValiditySeconds(1209600)
                .rememberMeParameter("remember-mer")
                .tokenRepository(getpersistentTokenRepository())
                .and().authorizeRequests().anyRequest().authenticated();
//通过测试，上面的顺序基本是不能改变的，也就是说，的确会覆盖之前的认证成功和认证失败的结果（因为后执行）

        http.csrf().disable();

        http.headers().frameOptions().sameOrigin();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

    <div class="head-l">
        <a class="button button-little bg-red" href="/logout">
            <span class="icon-power-off">span>退出登录a>div>
1
2
3

   @Override
    protected void configure(HttpSecurity http) throws Exception {

        http.formLogin().loginPage("/toLoginPage")
                .loginProcessingUrl("/login1") 
                .usernameParameter("username1") 
                .passwordParameter("password1") 
                .successForwardUrl("/")
                .successHandler(myAuthenticationService) 
                .failureHandler(myAuthenticationService)
                .and().logout().logoutUrl("/out") //设置对应的退出请求为"/out"
                .and().rememberMe()
                .tokenValiditySeconds(1209600) 
                .rememberMeParameter("remember-mer")
         
                .tokenRepository(getpersistentTokenRepository())
                .and().authorizeRequests().anyRequest().authenticated();


        http.csrf().disable();


        http.headers().frameOptions().sameOrigin();

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

    <div class="head-l">
        <a class="button button-little bg-red" href="/out">
            <span class="icon-power-off">span>退出登录a>
            div>

1
2
3
4
5
6
7
8
9
10

package com.lagou.service.impl;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
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.security.web.authentication.logout.LogoutSuccessHandler;
import org.springframework.stereotype.Service;

import javax.servlet.FilterChain;
import javax.servlet.RequestDispatcher;
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, LogoutSuccessHandler {


    //用来得到可以操作响应的response，可以用它来操作重定向
    RedirectStrategy redirectStrategy = new DefaultRedirectStrategy();


    @Autowired
    private ObjectMapper objectMapper; //可以将map转换成json
    /**
     * 登录成功后处理的逻辑
     * @param httpServletRequest
     * @param httpServletResponse
     * @param authentication
     * @throws IOException
     * @throws ServletException
     */
    @Override
    public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse 
                                        httpServletResponse, Authentication authentication) throws 
        IOException, ServletException {
        System.out.println("登录成功后继续处理");
        //redirectStrategy.sendRedirect(httpServletRequest,httpServletResponse,"/");

        Map result = new HashMap();
        result.put("code", HttpStatus.OK.value()); //对应的value一般返回的是200
        result.put("message","登录成功");

        httpServletResponse.setContentType("application/json;charset=UTF-8");

        httpServletResponse.getWriter().write(objectMapper.writeValueAsString(result));

    }

    /**
     * 登录失败的处理逻辑
     * @param httpServletRequest
     * @param httpServletResponse
     * @param e
     * @throws IOException
     * @throws ServletException
     */
    @Override
    public void onAuthenticationFailure(HttpServletRequest httpServletRequest, HttpServletResponse 
                                        httpServletResponse, AuthenticationException e) throws 
        IOException, ServletException {
        System.out.println("登录失败后进行处理");
        //redirectStrategy.sendRedirect(httpServletRequest,httpServletResponse,"/toLoginPage");
        Map result = new HashMap();
        result.put("code", HttpStatus.UNAUTHORIZED.value()); //对应的value一般返回的是401
        result.put("message","登录失败");

        httpServletResponse.setContentType("application/json;charset=UTF-8");

        httpServletResponse.getWriter().write(objectMapper.writeValueAsString(result));
    }

    @Override
    public void onLogoutSuccess(HttpServletRequest httpServletRequest, HttpServletResponse 
                                httpServletResponse, Authentication authentication) throws 
        IOException, ServletException {
        System.out.println("退出之后进行处理");

        redirectStrategy.sendRedirect(httpServletRequest,httpServletResponse,"/totoLoginPage");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

                .successHandler(myAuthenticationService) //登录成功的处理
                .failureHandler(myAuthenticationService) //登录失败的处理
                .and().logout().logoutUrl("/out")
			   .logoutSuccessHandler(myAuthenticationService) 
                    //这里进行覆盖原来的退出方法，使用我们自己配置的
                .and().rememberMe()
                .tokenValiditySeconds(1209600) 
                .rememberMeParameter("remember-mer")
1
2
3
4
5
6
7
8
9

    @Override
    public void configure(WebSecurity web) throws Exception {

        //解决静态资源被拦截的问题
        web.ignoring().antMatchers("/toLoginPage","/css/**","/images/**","/js/**","/code/**");
        
        //加上了"/code/**"
    }
1
2
3
4
5
6
7
8

## redis相关配置
# Redis数据库索引（默认为0）
#spring.redis.database=0
# Redis服务器地址
spring.redis.host=192.168.164.128
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
#spring.redis.password=
#将对应的ip和端口的注释解除即可（端口也可以不用解除，因为默认也是6379）
#对应由于默认0数据库，所以可以不用解除，且我们也并没有操作密码
1
2
3
4
5
6
7
8
9
10
11

<img src="/code/image" alt="" width="100" height="32" class="passcode"
                                     style="height:43px;cursor:pointer;" 
     onclick="this.src=this.src+'?'">


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

package com.lagou.filter;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * 验证码过滤器 OncePerRequestFilter 一次请求只会经过一次过滤器
 */
@Component
//这里为什么需要继承OncePerRequestFilter，主要是为了操作对应的类，后面会继续说明为什么
public class ValidateCodeFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse 
                                    httpServletResponse, FilterChain filterChain) throws 
        ServletException, IOException {

        //判断是否是登录请求
        //equalsIgnoreCase不考虑大小写
        if(httpServletRequest.getRequestURI().equals("/login1")&&
                httpServletRequest.getMethod().equalsIgnoreCase("post")){
            //imageCode是输入的图形验证码的name
            String imageCode = httpServletRequest.getParameter("imageCode");
            System.out.println(imageCode);

            //具体的验证流程，后面会进行补充
        }

        //如果不是登录请求直接放行
        filterChain.doFilter(httpServletRequest,httpServletResponse);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

    @Override
    protected void configure(HttpSecurity http) throws Exception {

      //将我们的验证过滤器加入到用户名密码验证过滤器的前面
        //正是因为有这样的操作，使得spring security不止只操作默认的15个过滤器
        http.addFilterBefore(validateCodeFilter,UsernamePasswordAuthenticationFilter.class);
        //只需要传递Filter接口及其子类即可（两个都是）
        //validateCodeFilter父辈中有Filter接口
        //第二个UsernamePasswordAuthenticationFilter.class他所在的参数类型是Class）
        //所以说两个都是

        http.formLogin().loginPage("/toLoginPage")
                .loginProcessingUrl("/login1") 
                .usernameParameter("username1") 
                .passwordParameter("password1") 
                .successForwardUrl("/")
                .successHandler(myAuthenticationService) 
                .failureHandler(myAuthenticationService) 
                .and().logout().logoutUrl("/out")
                .logoutSuccessHandler(myAuthenticationService)
                .and().rememberMe()
                .tokenValiditySeconds(1209600) 
                .rememberMeParameter("remember-mer")
                .tokenRepository(getpersistentTokenRepository())
                .and().authorizeRequests().anyRequest().authenticated();

        http.csrf().disable();

        http.headers().frameOptions().sameOrigin();

        //http.addFilterBefore(validateCodeFilter,UsernamePasswordAuthenticationFilter.class);
        /*
        那么可以写在后面吗，答：可以，因为这里只是进行设置，也就是顺序
        只要指定了在谁的过滤器前面无论是先执行还是后执行，都会有标记的，使得在前面
        那么可以执行两次吗，答可以但先标记的在后标记的前面，所以加载时会出现两个过滤器
        只是后标记的会覆盖先标记的，所以只会执行一次的方法验证
        */

      
        //这里我们回到前面的一个问题，为什么要继承OncePerRequestFilter类，而不直接的实现Filter接口呢：
        //主要是对应的方便，虽然我们也可以实现Filter接口来进行意一样的操作
        //但继承继承对应的OncePerRequestFilter类（他的父辈，有Filter接口）
        //方便一些，不用进行强制转换了
        //实现Filter接口操作HttpServletRequest和HttpServletResponse需要如下操作：
        /*
         HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
        HttpServletResponse httpServletResponse = (HttpServletResponse) servletResponse;
        
        接口的强制，编译期不会识别，因为该接口对应的实现类可能是强制转换的类的子类，虽然编译期一般不识别
        //当然直接的类自然会识别，虽然不会识别接口，但运行期自然会识别，不对就会报错
        */
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

package com.lagou.execption;


import org.springframework.security.core.AuthenticationException;

/**
 * 验证码异常类
 */
public class ValidateCodeException extends AuthenticationException {
    public ValidateCodeException(String msg) {
        super(msg);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

package com.lagou.filter;

import com.lagou.controller.ValidateCodeController;
import com.lagou.execption.ValidateCodeException;
import com.lagou.service.impl.MyAuthenticationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * 验证码过滤器 OncePerRequestFilter 一次请求只会经过一次过滤器
 */
@Component
public class ValidateCodeFilter extends OncePerRequestFilter {

    @Autowired
    private MyAuthenticationService myAuthenticationService;

    @Override
    protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse 
                                    httpServletResponse, FilterChain filterChain) throws 
        ServletException, IOException {

        //判断是否是登录请求
        //equalsIgnoreCase不考虑大小写
        if(httpServletRequest.getRequestURI().equals("/login1")&&
                httpServletRequest.getMethod().equalsIgnoreCase("post")){
            //imageCode是输入的图形验证码的name
            String imageCode = httpServletRequest.getParameter("imageCode");
            System.out.println(imageCode);

            //具体的验证流程

            try {
                validate(httpServletRequest, imageCode);
                //只要这个方法出现了异常，就代表，对应的验证码操作失败，自然需要有对应的错误信息
            }catch (ValidateCodeException e){
                e.printStackTrace();
                myAuthenticationService.onAuthenticationFailure(
                    httpServletRequest,httpServletResponse,e);

                return;
            }
        }

        //如果不是登录请求直接放行
        filterChain.doFilter(httpServletRequest,httpServletResponse);
    }

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    public void validate(HttpServletRequest request,String imageCode){
        //由于对应的验证码信息存在redis里面，所以我们需要取出redis的信息进行对比，使得验证成功
        //因为过期时间，所以验证码也通常需要在一定的时间里进行验证，这也是redis的一个作用

        String redisKey = ValidateCodeController.REDIS_KEY_IMAGE_CODE+"-"+request.getRemoteAddr();

        String s = stringRedisTemplate.boundValueOps(redisKey).get();
        //实际上也就是操作stringRedisTemplate.opsForValue().get(redisKey);,可以看对应的源码就知道了

        //验证码的判断
        if(!StringUtils.hasText(imageCode)){
            throw new ValidateCodeException("验证码的值不能为空");
        }
        if(s==null){
            throw new ValidateCodeException("验证码已过期");
        }
        if(!s.equals(imageCode)){
            throw new ValidateCodeException("验证码不正确");
        }

        //从redis中删除验证码信息
        stringRedisTemplate.delete(redisKey);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

  /**
     * 登录失败的处理逻辑
     * @param httpServletRequest
     * @param httpServletResponse
     * @param e
     * @throws IOException
     * @throws ServletException
     */ 
@Override
    public void onAuthenticationFailure(HttpServletRequest httpServletRequest, HttpServletResponse 
                                        httpServletResponse, AuthenticationException e) throws 
        IOException, ServletException {
        System.out.println("登录失败后进行处理");
        //redirectStrategy.sendRedirect(httpServletRequest,httpServletResponse,"/toLoginPage");
        Map result = new HashMap();
        result.put("code", HttpStatus.UNAUTHORIZED.value()); //对应的value一般返回的是401
        result.put("message",e.getMessage()); //这里进行了改变

        httpServletResponse.setContentType("application/json;charset=UTF-8");

        httpServletResponse.getWriter().write(objectMapper.writeValueAsString(result));
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#session设置
#配置session超时时间
server.servlet.session.timeout=60
1
2
3

 http.sessionManagement() //设置session管理
                .invalidSessionUrl("/toLoginPage") //session失效后跳转的页面，默认是自己设置的登录页面
        //这里还是设置成对应的/toLoginPage
                .maximumSessions(1);//session最大的会话数量
                //1：代表同一时间，只能有一个用户可以登录，一般有个专业术语：互踢
        //.expiredUrl("/toLoginPage"); //被踢出时，进行跳转的页面
//实际上只要你被踢，那么相当于没有认证，而没有认证，就会重定向到认证页面
//只是对应的默认页面（转发的），是不需要经过认证的，也就是说，他是例外（设置的例外），使得不需要认证也可以访问
//所以不会默认重定向到登录页面，但他也只是操作一次，也就是说，只有第一次是例外，其他时候会进行重定向到认证页面
//我们可以发现，大多数都是重定向
//这也是为了防止前面操作什么路径认证后就会到什么路径的设置的原因，虽然并不会操作
1
2
3
4
5
6
7
8
9
10
11

 http.sessionManagement() //设置session管理
                .invalidSessionUrl("/toLoginPage") //session失效后跳转的页面，默认是自己设置的登录页面
        //这里还是设置成对应的/toLoginPage
                .maximumSessions(1)//session最大的会话数量
                //1：代表同一时间，只能有一个用户可以登录，一般有个专业术语：互踢
        .expiredUrl("/toLoginPage"); //被踢出时，进行跳转的页面
//实际上只要你被踢，那么相当于没有认证，而没有认证，就会重定向到认证页面
//只是对应的默认页面（转发的），是不需要经过认证的，也就是说，他是例外（设置的例外），使得不需要认证也可以访问
//所以不会默认重定向到登录页面，但他也只是操作一次，也就是说，只有第一次是例外，其他时候会进行重定向到认证页面
//我们可以发现，大多数都是重定向
//这也是为了防止前面操作什么路径认证后就会到什么路径的设置的原因，虽然并不会操作
1
2
3
4
5
6
7
8
9
10
11

   http.sessionManagement() //设置session管理
                .invalidSessionUrl("/toLoginPage") //session失效后跳转的页面，默认是自己设置的登录页面
        //这里还是设置成对应的/toLoginPage
                .maximumSessions(1)//session最大的会话数量
                //1：代表同一时间，只能有一个用户可以登录，一般有个专业术语：互踢
        .expiredUrl("/toLoginPage")//被踢出时，进行跳转的页面实际上只要你被踢
        // 那么相当于没有认证，只是对应的默认页面，是不经过认证的，所以不会默认重定向到登录页面
        .maxSessionsPreventsLogin(true); //如果达到最大会话数量，就阻止登录

//只要加上了maxSessionsPreventsLogin(true)，那么对应的expiredUrl("/toLoginPage")也就没有作用了
//那么这里的顺序可以随便写吗，答：不可以随便写，但部分可以
//因为对应的返回都是一样的（一般表单的配置是通过and分开的，其他的基本可以互换）

//也就是说可以这样：
/*
        http.sessionManagement() //设置session管理
                .invalidSessionUrl("/toLoginPage") //session失效后跳转的页面，默认是自己设置的登录页面
        //这里还是设置成对应的/toLoginPage
                .maximumSessions(1)//session最大的会话数量
                //1：代表同一时间，只能有一个用户可以登录，一般有个专业术语：互踢
                .maxSessionsPreventsLogin(true)        //如果达到最大会话数量，就阻止登录
        .expiredUrl("/toLoginPage");//被踢出时，进行跳转的页面实际上只要你被踢
        // 那么相当于没有认证，只是对应的默认页面，是不经过认证的，所以不会默认重定向到登录页面
  
         
         */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

<dependency>    
    <groupId>org.springframework.sessiongroupId>   
    <artifactId>spring-session-data-redisartifactId>
dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13

#使用redis共享session
spring.session.store-type=redis
#好像Spring Security对应会检查库依赖，在没有配置指定使用哪个库时，一般有顺序，通常是redis优先
#所以这个配置可以不用写，但最好写上，防止优先级的判断操作
#且也防止被其他人优先（虽然redis优先级别很高，基本是第一）
1
2
3
4
5