SpringSecurity之认证

时间 2020-11-21

标签 javascript css html 前端 java jquery web ajax spring 数据库栏目 Spring 繁體版

原文原文链接

SpringSecurity之认证

SpringSecurity之认证

1. 盐值加密

1. 原理概述

SpringSecurity使用的是随机盐值加密javascript

随机盐是在对密码摘要以前随机生成一个盐,而且会把这个盐的明文和摘要拼接一块儿保存css

举个例子:密码是pwd,随机盐是abc,pwd+abc摘要后的信息是xyz,最后保存的密码就是abcxyzhtml

随机盐同一个密码,每次摘要后的结果都不一样,可是能够根据摘要里保存的盐来校验摘要和明文密码是否匹配前端

在hashpw函数中, 咱们能够看到如下这句java

real_salt = salt.substring(off + 3, off + 25);

说明咱们真正用于盐值加密的是real_salt, 从而保证了咱们生成随机盐值也能再校验时经过相同的规则获得须要的结果jquery

2. 使用说明

1. 加密

首先咱们要在SpringSecurity的配置文件中配置密码的加密方式

/密码使用盐值加密 BCryptPasswordEncoder
//BCrypt.hashpw() ==> 加密
//BCrypt.checkpw() ==> 密码比较
//咱们在数据库中存储的都是加密后的密码, 只有在网页上输入时是明文的
@Bean
public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
}

而后在咱们的用户管理实现类中实现向数据库添加新用户(注册功能) 时对密码加密

@Override
public Integer addUser(UserDTO user) {
    //先查看要添加的用户是否在数据库中
    String username = user.getUsername();
    UserDTO userByUsername = getUserByUsername(username);
    //若是待插入的用户存在在数据库中, 插入0条
    if (null != userByUsername) {
        return 0;
    } else {
        //不存在, 则插入用户
        //先对密码进行盐值加密, SpringSecurity中使用的是随机盐值加密
        String hashpw = passwordEncoder.encode(user.getPassword());
        user.setPassword(hashpw);
        return userMapper.addUser(user);
    }
}

在咱们提交用户名和密码的表单以后, 在数据库中差看咱们存储的用户名和密码

能够看到, 密码与咱们明文输入的 123456 彻底不一样web

这里要注意一点, 设计数据库时密码不要少于60位!

2. 认证

讲在前面的话:ajax

认证的配置类的 setFilterProcessesUrl("/login") (这里是自定义过滤器的配置, form方式与其一致)中, url只是咱们提交表单或者ajax请求的地址, 不须要在Controller中注册, 注册了PostMapping也不会走, 可是会走Get方式, 此时SpringSecurity不会帮咱们认证(认为是不安全的提交方式)spring

1. 页面成功跳转的坑

页面成功跳转有两个方法数据库

defaultSuccessUrl
successForwardUrl

前者是重定向, 后者是转发, 因为转发地址栏不会变化, 而咱们SpringSecurity要求提交表单的方法必须为post(此处也是大坑!切记!), 所以请求类型后者依然为post

此时, 若是咱们在addViewControllers中配置了首页的路径映射, 同时咱们成功后要跳转到首页, 使用后一种方法就会报405错误, 提示咱们请求类型错误

有两种解决方法

使用第一种方法, 能够接受一个get请求的url
配置一个Controller进行Post方式的页面跳转

2. 使用验证码校验的坑

验证码校验我在以前的文章中提到过, 这里就再也不赘述

主要说说验证码随认证一块儿提交的坑

设置提交的url和咱们login的form url一致, 注意此时必定要用GET请求提交表单!

若是咱们使用相同的url在controller层试图进行校验并重定向跳转, 能够发现根本就不会走咱们的controller!

同时, 咱们试图用拦截器拦截响应的url, 并在表单提交以前拦截来下进行校验, 也失败了

说明SpringSecurity本身的校验的优先级至关的高

此时, 咱们只能实现一个认证成功的处理器来处理咱们的验证码

实现AuthenticationSuccessHandler接口并用SpringBoot托管

package com.wang.spring_security_framework.config.SpringSecurityConfig;

import com.wang.spring_security_framework.service.CaptchaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.stereotype.Component;

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

//登陆成功处理, 用于比对验证码
@Component
public class LoginSuccessHandler implements AuthenticationSuccessHandler {
    @Autowired
    CaptchaService captchaService;

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        //校验验证码
        Boolean verifyResult = captchaService.versifyCaptcha(request.getParameter("token"),
                request.getParameter("inputCode"));
        if (verifyResult) {
            response.sendRedirect("/index");
        } else {
            response.sendRedirect("/toLoginPage");
        }
    }
}

在SpringSecurity的配置类中使用咱们本身定义的处理类

@Override
protected void configure(HttpSecurity http) throws Exception {
    //指定自定义的登陆页面, 表单提交的url, 以及成功后的处理器
    http.formLogin()
            .usernameParameter("username")
            .passwordParameter("password")
            .loginPage("/toLoginPage")
            .loginProcessingUrl("/login")
            .successHandler(loginSuccessHandler)
            .and()
            .csrf()
            .disable();
}

此处有个大坑, 若是设置了成功的处理类, 咱们就千万不要在配置类中写成功跳转的方法了, 这样会覆盖掉咱们的成功处理器!

3. 前端用ajax请求并附加验证码校验

此处为天坑! 足足费了我快一天半才爬出来! 简直处处都是坑, 还有一个问题没解决...

总之不推荐这么干, 主要指用AJAX请求再用后台跳转

首先, 咱们要明确一点, AJAX会刷新局部页面, 这就形成了重定向请求没问题, 可是页面不跳转, 看请求头咱们会发现url仍是当前页面
其次, SpringSecurity的认证是用request.getparameter()读出的, 所以没法解析AJAX请求传来的JSON, 咱们要本身写过滤器解析
最后, SpringSecurity在认证过滤器结束后会关闭request的Stream, 致使咱们没法取出前端发来的数据, 须要咱们再添加一个request, 再在成功的处理器中得到request中的对象

好了, 让咱们来看看这个坑吧!

前端代码

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>登陆界面</title>
    <link th:href="@{css/default.css}" rel="stylesheet" type="text/css"/>
    <!--必要样式-->
    <link th:href="@{css/styles.css}" rel="stylesheet" type="text/css"/>
    <link th:href="@{css/demo.css}" rel="stylesheet" type="text/css"/>
    <link th:href="@{css/loaders.css}" rel="stylesheet" type="text/css"/>
</head>
<body>
<div class='login'>
    <div class='login_title'>
        <span>登陆</span>
    </div>
    <div class='login_fields'>
        <!--        <form action="/login" method="post">-->
        <div class='login_fields__user'>
            <div class='icon'>
                <img alt="" src='img/user_icon_copy.png'>
            </div>
            <input name="username" placeholder='用户名' maxlength="16" type='text' autocomplete="off"/>
            <div class='validation'>
                <img alt="" src='img/tick.png'>
            </div>
        </div>
        <div class='login_fields__password'>
            <div class='icon'>
                <img alt="" src='img/lock_icon_copy.png'>
            </div>
            <input name="password" placeholder='密码' maxlength="16" type='text' autocomplete="off">
            <div class='validation'>
                <img alt="" src='img/tick.png'>
            </div>
        </div>
        <div class='login_fields__password'>
            <div class='icon'>
                <img alt="" src='img/key.png'>
            </div>
            <input name="inputCode" placeholder='验证码' maxlength="4" type='text' autocomplete="off">
            <div class='validation' style="opacity: 1; top: -3px;">
                <!-- 当用户连接时，void(0)计算为0,用户点击不会发生任何效果 -->
                <a href="javascript:void(0);" title="点击更换验证码">
                    <!--this参数, 返回当前的DOM元素-->
                    <img src="" alt="更换验证码" id="imgVerify" onclick="getVerify(this)">
                </a>
            </div>
        </div>
        <div class='login_fields__submit'>
            <input type='button' value='登陆'>
        </div>
        <div>
            <!--经过隐藏域传递值, 在下面的验证码点击事件中, 将值绑定过来, 这样就能够得到最新的验证码对应的值了!-->
            <input name="token" value="" type="hidden" id="token">
        </div>
        <!--        </form>-->
    </div>
</div>

<link th:href="@{layui/css/layui.css}" rel="stylesheet" type="text/css"/>

<script type="text/javascript" th:src="@{js/jquery.min.js}"></script>
<script type="text/javascript" th:src="@{js/jquery-ui.min.js}"></script>
<script type="text/javascript" th:src="@{layui/layui.js}"></script>
<script type="text/javascript" th:src="@{js/Particleground.js}"></script>
<script type="text/javascript" th:src="@{js/Treatment.js}"></script>
<script type="text/javascript" th:src="@{js/jquery.mockjax.js}"></script>
<script type="text/javascript">
    $(document).keypress(function (e) {
        // 回车键事件 ascii 13
        if (e.which === 13) {
            $('input[type="button"]').click();
        }
    });

    //粒子背景特效
    $('body').particleground({
        dotColor: '#39db24',
        lineColor: '#133b88'
    });
    $('input[name="password"]').focus(function () {
        $(this).attr('type', 'password');
    });
    $('input[type="text"]').focus(function () {
        $(this).prev().animate({'opacity': '1'}, 200);
    });
    $('input[type="text"],input[type="password"]').blur(function () {
        $(this).prev().animate({'opacity': '.5'}, 200);
    });
    $('input[name="username"],input[name="password"]').keyup(function () {
        var Len = $(this).val().length;
        if (!$(this).val() === '' && Len >= 5) {
            $(this).next().animate({
                'opacity': '1',
                'right': '30'
            }, 200);
        } else {
            $(this).next().animate({
                'opacity': '0',
                'right': '20'
            }, 200);
        }
    });

    layui.use('layer', function () {
        //非空验证
        $('input[type="button"]').click(function () {
            let login = $('input[name="username"]').val();
            let pwd = $('input[name="password"]').val();
            let code = $('input[name="inputCode"]').val();
            let token = $('input[name="token"]').val();
            let JsonData = {"username": login, "password": pwd, "inputCode": code, "token": token};
            if (login === '') {
                ErroAlert('请输入您的帐号');
            } else if (pwd === '') {
                ErroAlert('请输入密码');
            } else if (code === '' || code.length !== 4) {
                ErroAlert('输入验证码');
            } else {
                let url = "/login";
                $.ajaxSetup({
                    url: url,
                    type: "post",
                    dataType: "json",
                    contentType: "application/json;charset=utf-8",
                    complete: function (XMLHttpRequest, textStatus) {
                        console.log(XMLHttpRequest.status);
                        //经过XMLHttpRequest获取响应头
                        let redirect = XMLHttpRequest.getResponseHeader("REDIRECT");
                        console.log(redirect);
                        if (redirect === "REDIRECT") {
                            let win = window;
                            while (win != win.top) {
                                win = win.top;
                            }
                            win.location.href = XMLHttpRequest.getResponseHeader("CONTEXTPATH");
                        }
                    }
                });
                $.ajax({
                    data: JSON.stringify(JsonData),
                    success: function () {
                        console.log("进入回调函数了!");
                    },
                    error: function (xhr, textStatus, errorThrown) {
                        alert("进入error---");
                        alert("状态码："+xhr.status);
                        alert("状态:"+xhr.readyState); //当前状态,0-未初始化，1-正在载入，2-已经载入，3-数据进行交互，4-完成。
                        alert("错误信息:"+xhr.statusText );
                        alert("返回响应信息："+xhr.responseText );//这里是详细的信息
                        alert("请求状态："+textStatus);
                        alert(errorThrown);
                        alert("请求失败");
                    }
                });
            }
        });
    });
    //得到img对象
    let imgVerify = $("#imgVerify").get(0);
    //$(function())等同于$(document).ready(function()) ==> 页面加载完毕以后, 才执行函数
    $(function () {
        getVerify(imgVerify);
    });

    //onclick时间绑定的getVerify函数
    function getVerify(obj) {
        $.ajax({
            type: "POST",
            url: "/captcha",
            success: function (result) {
                obj.src = "data:image/jpeg;base64," + result.img;
                $("#token").val(result.token);
            }
        });
    }
</script>

</body>
</html>

这里主要是$.ajaxSetup()方法, 能够定义全局的(同一个函数中的)ajax的一些参数, 尤为是里面的complete方法, 是在所有执行完以后调用的, 为了能强行跳转AJAX, 咱们要天剑请求头, 咱们在后面的后端代码中能够看到
咱们还须要写$.ajax()传递数据, 注意, json数据就算咱们用json的格式写了, 仍是要用JSON.stringify()方法转一下, 不然传到后端的不是JSON!
此处有一个没有解决的问题, 不知道为何不会走成功的回调函数, 只会走失败的回调函数

自定义认证过滤器

package com.wang.spring_security_framework.config.SpringSecurityConfig;

import com.alibaba.fastjson.JSON;
import org.springframework.http.MediaType;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.util.Map;

//默认的提取用户名和密码是经过 request.getParameter() 方法来提取的, 因此经过form咱们能够提取到
//可是若是咱们用ajax传递的话, 就提取不到了, 须要本身写过滤器!
//这里不能写 @Component, 由于咱们要在SpringSecurity配置类中注册 myCustomAuthenticationFilter 并配置
//不然会爆出重名的Bean!
public class MyCustomAuthenticationFilter extends UsernamePasswordAuthenticationFilter {
    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        //若是request请求是一个json同时编码方式为UTF-8
        if (request.getContentType().equals(MediaType.APPLICATION_JSON_VALUE)
                || request.getContentType().equals(MediaType.APPLICATION_JSON_UTF8_VALUE)) {
            UsernamePasswordAuthenticationToken authRequest = null;
            
            Map<String, String> authenticationBean = null;
            try (InputStream inputStream = request.getInputStream()) {
                //将JSON转为map
                authenticationBean = JSON.parseObject(inputStream, Map.class);
                //将用户名和密码放入 authRequest
                authRequest = new UsernamePasswordAuthenticationToken(
                        authenticationBean.get("username"), authenticationBean.get("password"));
                System.out.println(authenticationBean);
            } catch (IOException e) {
                e.printStackTrace();
                //出现IO异常, 放空的用户信息
                authRequest = new UsernamePasswordAuthenticationToken("", "");
            } finally {
                //将请求 request 和解析后的用户信息 authRequest 放入userDetails中
                setDetails(request, authRequest);
                //将咱们前端传递的JSON对象继续放在request里传递, 这样咱们就能够在认证成功的处理器中拿到它了!
                request.setAttribute("authInfo", authenticationBean);

                return this.getAuthenticationManager().authenticate(authRequest);
            }
        } else {
            return super.attemptAuthentication(request, response);
        }
    }
}

这里仍是要强调一点, @Component会自动注册内部的所有的方法, 若是咱们在别的地方@Bean了方法, 会报一些奇怪的错误, 本质上是冲突了!
此处咱们是用FastJSON将JSON转为了Map

认证成功处理器

package com.wang.spring_security_framework.config.SpringSecurityConfig;

import com.alibaba.fastjson.JSON;
import com.wang.spring_security_framework.service.CaptchaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.stereotype.Component;

import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

//登陆成功处理
//咱们不能在这里得到request了, 由于咱们已经在前面自定义了认证过滤器, 作完后SpringSecurity会关闭inputStream流
@Component
public class LoginSuccessHandler implements AuthenticationSuccessHandler {
    @Autowired
    CaptchaService captchaService;

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request,
                                        HttpServletResponse response,
                                        Authentication authentication) throws IOException, ServletException {
        //咱们从自定义的认证过滤器中拿到的authInfo, 接下来作验证码校验和跳转
        Map<String, String> authInfo = (Map<String, String>) request.getAttribute("authInfo");
        System.out.println(authInfo);
        System.out.println("success!");
        String token = authInfo.get("token");
        String inputCode = authInfo.get("inputCode");

        //校验验证码
        Boolean verifyResult = captchaService.versifyCaptcha(token, inputCode);
        System.out.println(verifyResult);
        if (verifyResult) {
            HashMap<String, String> map = new HashMap<>();
            map.put("url", "/index");
            System.out.println(map);
            String VerifySuccessUrl = "/index";
            response.setHeader("Content-Type", "application/json;charset=utf-8");
//            response.setContentType("application/json;charset=utf-8");
            response.addHeader("REDIRECT", "REDIRECT");
            response.addHeader("CONTEXTPATH", VerifySuccessUrl);
        } else {
            String VerifyFailedUrl = "/toRegisterPage";
            response.setHeader("Content-Type", "application/json;charset=utf-8");
//            response.setContentType("application/json;charset=utf-8");
            response.addHeader("REDIRECT", "REDIRECT");
            response.addHeader("CONTEXTPATH", VerifyFailedUrl);
//            response.sendRedirect("/toRegisterPage");
        }
    }
}

这里须要注意一点, 咱们须要从前面的Request拿到对象
addHeader里面咱们为了重定向, 添加了响应头, 能够和前端的ajaxSetup对应着看

SpringSecurity配置类

package com.wang.spring_security_framework.config;

import com.wang.spring_security_framework.config.SpringSecurityConfig.LoginSuccessHandler;
import com.wang.spring_security_framework.config.SpringSecurityConfig.MyCustomAuthenticationFilter;
import com.wang.spring_security_framework.service.UserService;
import com.wang.spring_security_framework.service.serviceImpl.UserDetailServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

//SpringSecurity设置
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    UserService userService;
    @Autowired
    UserDetailServiceImpl userDetailServiceImpl;
    @Autowired
    LoginSuccessHandler loginSuccessHandler;

    //受权
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //指定自定义的登陆页面, 表单提交的url, 以及成功后的处理器
        http.formLogin()
                .loginPage("/toLoginPage")
                .failureForwardUrl("/index")
                .and()
                .csrf()
                .disable();
//        .failureForwardUrl();
        //注销

        //设置过滤器链, 添加自定义过滤器
        http.addFilterAt(
                myCustomAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class
        );
        //容许iframe
//        http.headers().frameOptions().sameOrigin();
    }

    //注册自定义过滤器
    @Bean
    MyCustomAuthenticationFilter myCustomAuthenticationFilter() throws Exception {
        MyCustomAuthenticationFilter filter = new MyCustomAuthenticationFilter();
        //设置过滤器认证管理
        filter.setAuthenticationManager(super.authenticationManagerBean());
        //设置filter的url
        filter.setFilterProcessesUrl("/login");
        //设置登陆成功处理器
        filter.setAuthenticationSuccessHandler(loginSuccessHandler);
        //TODO 设置登陆失败处理器

        return filter;
    }

    //密码使用盐值加密 BCryptPasswordEncoder
    //BCrypt.hashpw() ==> 加密
    //BCrypt.checkpw() ==> 密码比较
    //咱们在数据库中存储的都是加密后的密码, 只有在网页上输入时是明文的
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

}

这里主要干了两件事
- 注册了咱们自定义的过滤器
- 在过滤器链中注册咱们的过滤器

4. 后端只提供JSON让前端进行跳转

这里主要修改了两处, 咱们的成功处理器返回的是一个封装好的JSON, 同时咱们在ajax的回调函数中写了页面跳转的逻辑

成功处理器

package com.wang.spring_security_framework.config.SpringSecurityConfig;

import com.alibaba.fastjson.JSON;
import com.wang.spring_security_framework.service.CaptchaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.stereotype.Component;

import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;

//登陆成功处理
//咱们不能在这里得到request了, 由于咱们已经在前面自定义了认证过滤器, 作完后SpringSecurity会关闭inputStream流
@Component
public class LoginSuccessHandler implements AuthenticationSuccessHandler {
    @Autowired
    CaptchaService captchaService;

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request,
                                        HttpServletResponse response,
                                        Authentication authentication) throws IOException, ServletException {
        //咱们从自定义的认证过滤器中拿到的authInfo, 接下来作验证码校验和跳转
        Map<String, String> authInfo = (Map<String, String>) request.getAttribute("authInfo");
        System.out.println(authInfo);
        System.out.println("success!");
        String token = authInfo.get("token");
        String inputCode = authInfo.get("inputCode");

        //校验验证码
        Boolean verifyResult = captchaService.versifyCaptcha(token, inputCode);
        System.out.println(verifyResult);

        Map<String, String> result = new HashMap<>();
        if (verifyResult) {
            HashMap<String, String> map = new HashMap<>();
            map.put("url", "/index");
            System.out.println(map);
            String VerifySuccessUrl = "/index";
            response.setHeader("Content-Type", "application/json;charset=utf-8");
            result.put("code", "200");
            result.put("msg", "认证成功!");
            result.put("url", VerifySuccessUrl);
            PrintWriter writer = response.getWriter();
            writer.write(JSON.toJSONString(result));
        } else {
            String VerifyFailedUrl = "/toLoginPage";
            response.setHeader("Content-Type", "application/json;charset=utf-8");
            result.put("code", "201");
            result.put("msg", "验证码输入错误!");
            result.put("url", VerifyFailedUrl);
            PrintWriter writer = response.getWriter();
            writer.write(JSON.toJSONString(result));
        }
    }
}

这里只须要注意一点, 及时ContentType必定要加上, 防止出现奇怪的响应头的问题

前端修改, 这里删除了complete方法, 添加了回调函数, 所以咱们只放出ajax

$.ajax({
    data: JSON.stringify(JsonData),
    success: function (data) {
        alert("进入success---");
        let code = data.code;
        let url = data.url;
        let msg = data.msg;
        if (code == 200) {
            alert(msg);
            window.location.href = url;
        } else if (code == 201) {
            alert(msg);
            window.location.href = url;
        } else {
            alert("未知错误!")
        }
    },
    error: function (xhr, textStatus, errorThrown) {
        alert("进入error---");
        alert("状态码：" + xhr.status);
        alert("状态:" + xhr.readyState); //当前状态,0-未初始化，1-正在载入，2-已经载入，3-数据进行交互，4-完成。
        alert("错误信息:" + xhr.statusText);
        alert("返回响应信息：" + xhr.responseText);//这里是详细的信息
        alert("请求状态：" + textStatus);
        alert(errorThrown);
        alert("请求失败");
    }
});

5. 失败处理器

认证失败的处理器, 主要是三个部分, 失败处理器, 配置类中自定义过滤器添加失败处理器, 以及前端添加回调函数的失败处理器的跳转逻辑

其中配置类和前端都很是简单, 咱们这里只贴出失败处理器供你们参考

package com.wang.spring_security_framework.config.SpringSecurityConfig;

import com.alibaba.fastjson.JSON;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.stereotype.Component;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;

//认证失败的处理器
@Component
public class LoginFailHandler implements AuthenticationFailureHandler {
    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
        HashMap<String, String> result = new HashMap<>();
        String AuthenticationFailUrl = "/toRegisterPage";
        response.setHeader("Content-Type", "application/json;charset=utf-8");
        result.put("code", "202");
        result.put("msg", "认证失败!密码或用户名错误!即将跳转到注册页面!");
        result.put("url", AuthenticationFailUrl);
        PrintWriter writer = response.getWriter();
        writer.write(JSON.toJSONString(result));
    }
}

3. 写在最后的话

本文其实不算是教程, 只是我的在练习SpringSecurity进行认证的踩坑以及总结
固然, 附加验证码校验应该写在token的自定义类中, 这里我偷懒了...有机会再补上吧
请忽视我丑陋的AJAX回调信息, 这里的标准作法是定义返回的信息类