Springboot之登录模块探索（含Token，验证码，网络安全等知识）

简介
登录模块很简单，前端发送账号密码的表单，后端接收验证后即可~
淦！可是我想多了，于是有了以下几个问题（里面还包含网络安全问题）：
1.登录时的验证码
2.自动登录的实现
3.怎么维护前后端登录状态
在这和大家分享下我实现此功能的过程，包括一些技术和心得
1.登录时的验证码
为什么要验证码，原因很简单，防止脚本无限次重复登录，来暴力破解用户密码或者攻击服务器
验证码的出现，使得每次登录都有个动态变量需要输入，无法用脚本写死代码
具体可以参考：滑动验证码的设计和理解
2.自动登录的实现
所谓自动登录，指的是当用户登录网站时勾选了自动登录，那么下次再访问网站就不需要输入账号密码直接登录了
这说明，账号密码信息是必须保存在用户这边的，因此自动登录都是不安全的！（方便的代价呀）
尽管不安全，但是我们也必须要尽力让它安全一点，有以下常用方法：
1.账号密码加密保存
2.降低自动登录后用户的权限（如果用户自动登录想改密码，想给我转钱等操作的话，就必须输入账号密码再登录一次！）
3.进行ip检测（之前登录的ip小本本记着），如果发现和上次不一致，则不允许自动登录
数据存储在前端哪里呢
浏览器有3个经常保存数据的地方
1.Cookie （我用这个）
2.LocalStorage
3.SessionStorage
各位可以按F12直接观看

如果你在多个大型网站下都按按F12，会发现SessionStorage基本没数据
为啥，因为真的不好用，它并不是后台的session那样，生命周期是一个会话，这个SessionStorage存储的数据只限于该标签的页面
意思是标签1和标签2即使是同个URL的网址，里面的数据都是不互通的（这有个毛用）
那么LocalStorage存储的数据如何呢，答案是无限期本地存储
不过后台无法操作这里的数据，只能由js代码操作（至于操作结果，完全看js，后端无法感知，不太可靠），我认为这里不适合保存敏感点的信息，因为前端的功能是展示，状态性的数据应该由后端直接掌控（后端能直接操作Cookie，保证完成任务）
你看英雄所见略同，CSDN网站的用户密码也是存在Cookie的

Token就是登录后的令牌（下一点会讲）
所以用Cookie就对啦，具体实现都很简单，前端多个自动登录的选择，选择后多个参数传给后端，后端根据参数往Cookie里设置加密后的账号密码
等下次访问时，用拦截器Interceptor进行拦截，检测是否要自动登录即可~
3.如何维护前后端登录状态
大家最先想到是用Session来维护，登录后在Session中存放用户信息，不过对分布式很不友好（什么，你说你用不到分布式，我也没用到，可是梦想还是要有的嘛），需要维护个分布式数据库来进行数据同步才行
于是我用Token实现的，Token就是一串字符串，最适合API鉴权（例如SSO单点登录这种），俗称令牌
好处就是账号密码用户输入一次就够了，特别是多个系统之间（一张身份的凭证都通用）
当用户登录后，服务器就会生成一个Token放在Cookie中，之后用户的所有操作都带这个Token访问（将Token放入http头部）
为什么要将Token放入头部
1.能抵挡下简单的CSRF攻击
2.浏览器跨域问题
什么是CSRF攻击
举个例子：我登录了A网站，A网站给我返回了一些Cookie信息，然后我再同一浏览器的另外标签访问了B网站，谁知这个B网站返回了一些攻击代码（向A网站发起一些请求，比如转钱给你，这时候由于是访问A网站，会附带A网站的Cookie，让一切都好像是我在访问一样），这个就是CSRF攻击
但B网站并不知道A网站这么鸡贼，会在头部放了Token，所以这次攻击请求是的头部是没Token的，因此检测后发现非法，所以没得逞
当然，这并不可靠，哪天B网站知道你头部放了Token，它研究A网站的js代码，清楚逻辑之后也加上，那就防不住了（所以说前端的东西一切都不可靠）
正确做法应该是后端检测头部的Referer字段，每个网页里发起请求，请求的头部都会带有此字段，如

这说明这个请求是从 http://localhost:8099/swr 中发出的
B网站如果返回攻击代码，这里显示的事B网站的网址，判断出不是自家网站发出，就可以禁止访问
浏览器跨域访问会发生什么
说到跨域（自家网站去请求别人家的网站），得先了解什么是同源策略：
同源策略（Same origin policy）是一种约定，它是浏览器最核心也最基本的安全功能，如果缺少了同源策略，则浏览器的正常功能可能都会受到影响。可以说 Web 是构建在同源策略基础之上的，浏览器只是针对同源策略的一种实现。
它的核心就在于它认为自任何站点装载的信赖内容是不安全的。当被浏览器半信半疑的脚本运行在沙箱时，它们应该只被允许访问来自同一站点的资源，而不是那些来自其它站点可能怀有恶意的资源。
所谓同源是指：域名、协议、端口相同。
下表是相对于 http://www.laixiangran.cn/home/index.html 的同源检测结果：

另外，同源策略又分为以下两种：
DOM 同源策略：禁止对不同源页面 DOM 进行操作。这里主要场景是 iframe 跨域的情况，不同域名的 iframe 是限制互相访问的。XMLHttpRequest 同源策略：禁止使用 XHR 对象向不同源的服务器地址发起 HTTP 请求。（就是ajax）咳咳，这里要说下第二种，其实设置一些参数之后，ajax访问时允许跨域请求的，甚至允许跨域时带上自身cookie
但是，带上自己的Cookie多不安全，明明里面只有1,2个信息要传给对方，现在被人全看见了（不好不好），所以要将Token放入头部
你说为啥不放到参数里，因为这会跟业务用的参数混淆，造成逻辑混乱（就好像你上学时要扔家里的垃圾，你不会放到书包里吧，都是手里提着的）
每个请求都放token，所以要封装起来，例如我是将ajax封装起一个新的对象，然后在这个对象使用时添加Token
当然啦，封装了ajax后还有其他好处（例如统一的成功，失败回调函数，统一的数据解析，统一的等待框等等），有兴趣的同学可以看下

1/** 2 * 访问后台的对象，为ajax封装 3 * @param url 后台资源路径 4 * @param param Map参数 5 * @param contentType 传输类型 6 * @param success 成功回调函数 7 * @param error 失败回调函数 8 * @param requestType 请求类型（get.post,put,delete） 9 * @constructor 10*/ 11var Query = function (url, param, contentType, successFunc, errorFunc, requestType) { 12this.url = url; 13 14//先确认参数存在 15if (param) { 16//如果是get请求类型，则将参数拼接到url后面 17if (requestType == Query.GET_TYPE) { 18this.param = this._concatParamToURL(param, url); 19 } else { 20//其他请求类型，要根据不同的传输格式来确定传输的值的类型 21if (contentType == Query.NOMAL_TYPE) { 22this.param = JSON.parse(this._convertParamToJson(param)); 23 } else { 24this.param = this._convertParamToJson(param); 25 } 26 } 27 } else { 28this.param = null; 29 } 30 31 32this.contentType = contentType; 33this.successFunc = successFunc; 34this.errorFunc = errorFunc; 35//请求超时，默认10秒 36this.timeout = 10000; 37//是否异步请求，默认异步 38this.async = true; 39this.requestType = requestType; 40} 41 42 Query.JSON_TYPE = "application/json"; 43 Query.NOMAL_TYPE = "application/x-www-form-urlencoded"; 44 45/** 46 * ajax请求的访问 47 * 默认是post 48 * @param url 要访问的地址 49 * @param paramMap 传给后台的Map参数，key为字符串类型 50 * @param callback 回调函数 51 * @param contentType 传输数据的格式 默认传输application/x-www-form-urlencoded格式 52*/ 53 Query.create = function (url, paramMap, successFunc, errorFunc) { 54returnnew Query(url, paramMap, Query.NOMAL_TYPE, successFunc, errorFunc, Query.GET_TYPE); 55} 56 57//-----------------------以下为RESTFul方法--------------------------- 58//ajax请求类型 59 Query.GET_TYPE = "get"; 60 Query.POST_TYPE = "post"; 61 Query.PUT_TYPE = "put"; 62 Query.DELETE_TYPE = "delete"; 63 64//get方法默认是Query.NOMAL_TYPE 65 Query.createGetType = function (url, paramMap, successFunc, errorFunc) { 66returnnew Query(url, paramMap, Query.NOMAL_TYPE, successFunc, errorFunc, Query.GET_TYPE); 67} 68 Query.createPostType = function (url, paramMap, successFunc, errorFunc) { 69returnnew Query(url, paramMap, Query.JSON_TYPE, successFunc, errorFunc, Query.POST_TYPE); 70} 71 Query.createPutType = function (url, paramMap, successFunc, errorFunc) { 72returnnew Query(url, paramMap, Query.JSON_TYPE, successFunc, errorFunc, Query.PUT_TYPE); 73} 74 Query.createDeleteType = function (url, paramMap, successFunc, errorFunc) { 75returnnew Query(url, paramMap, Query.JSON_TYPE, successFunc, errorFunc, Query.DELETE_TYPE); 76} 77 78/** 79 * 将paramMap参数转为json格式 80 * @param paramMap 81 * @private 82*/ 83 Query.prototype._convertParamToJson = function (paramMap) { 84 85return window.tool.strMap2Json(paramMap); 86 87} 88 89/** 90 * 将参数拼接至URL尾部 91 * @param paramMap 92 * @param url 93 * @private 94*/ 95 Query.prototype._concatParamToURL = function (paramMap, url) { 96 let size = paramMap.size; 97 98if (size > 0) { 99 let count = 0;100 url = url "?";101 let urlParam = "";102103for (let [k, v] of paramMap) {104 urlParam = urlParam encodeURIComponent(k) "=" encodeURIComponent(v);105if (count < size-1) {106 urlParam = urlParam " && ";107 count ;108 }109 }110 url = url urlParam;111 }112return url;113}114115//ajax需要跳转的界面116 Query.REDIRECT_URL = "REDIRECT_URL";117118/**119 * ajax成功返回时调用的方法120 * 会根据ajax的ContentType类型，转换Response对象的data给回调的成功函数121 * 如application/json格式类型，data会转成json类型传递122 * @param queryResult 返回的值，通常为后台的Response对象123 * @private124*/125 Query.prototype._successFunc = function (queryResult) {126var data = this.__afterSuccessComplete(queryResult);127if (this.successFunc) {128this.successFunc(data);129 }130131//如果有需要跳转的页面，则自动跳转132if (data && data.REDIRECT_URL != null) {133 window.location = data.REDIRECT_URL;134 }135}136137/**138 * 会根据ajax的ContentType类型，转换Response对象的data给回调的失败函数139 * 如application/json格式类型，data会转成json类型传递140 * 如果对获得的参数不满意，可以用this.getMsg或this.getJsonMsg来进行获取（this指Query对象）141 *142 * 这里错误分3种143 * 1.是Web容器出错144 * 2.是Filter过滤器主动报错（如一些校验失败后主动抛出，会有错误提示）145 * 3.是Spring抛出，Spring异常会全局捕捉进行封装146 * @param queryResult 返回的值，通常为后台的Response对象147 * @private148*/149 Query.prototype._errorFunc = function (queryResult) {150151//返回的信息152var data = this.__afterErrorComplete(queryResult);153//如果data里面没东西154if (!data) {155 data = queryResult.statusText;156 }157158//是否调用者自身已解决了错误159var handleError = false;160161//调用回调函数，如果返回结果为true，则不会默认错误处理162if (this.errorFunc instanceof Function) {163 handleError = this.errorFunc(data);164 }165166//错误编号167var code;168//错误信息169var msg;170171//没有取消对错误的后续处理，那么进行跳转172if (!handleError) {173174//如果data成功转为Json对象175if (data) {176//Filter过滤器主动报错（如一些校验失败后主动抛出，会有错误提示）177if (data.status) {178 code = data.status;179 }180if (data.message) {181 msg = data.message;182 }183 }184185//最终跳转至错误页面186var path = "/system/error";187if (code && msg) {188 path = path "/" error.code "/" error.msg;189 }190 window.location.href = path;191 }192}193194 Query.SUCCESS_TYPE = "SUCCESS_TYPE";195 Query.ERROR_TYPE = "ERROR_TYPE";196/**197 * 当一个请求完成时，无论成功或失败，都要调用此函数做一些处理198 * @param queryResult 服务端返回的数据199 * @returns {*}200 * @private201*/202 Query.prototype._afterComplete = function (queryResult) {203this._cancleLoadDom();204}205206/**207 * 成功的返回处理，会将data部分转为对象208 * 默认application/json会进行单引号转双引号209 * @param queryResult 服务端返回的数据210 * @param queryResult211 * @returns {*}212 * @private213*/214 Query.prototype.__afterSuccessComplete = function (queryResult) {215this._afterComplete();216this.response = queryResult;217218var data = queryResult.data;219//data必须要有内容，且不是对象才有转换的意义220if (data && !(data instanceof Object)) {221 data = this.getJsonMsg();222 }223return data;224}225226/**227 * 失败的返回处理228 * 最终会根据ajax的contentType来进行data相应类型转换229 * 默认application/json会进行单引号转双引号230 * @param queryResult 服务端返回的数据231 * @private232*/233 Query.prototype.__afterErrorComplete = function (queryResult) {234this._afterComplete();235this.response = queryResult;236var data = queryResult.responseJSON;237if (!data) {238 data = queryResult.responseText;239 }240241return data;242}243244/**245 * 取消请求时的等待框246 * @private247*/248 Query.prototype._cancleLoadDom = function () {249//取消加载框250if (this.loadDom) {251 $(this.loadDom).remove("#loadingDiv");252 }253}254255/**256 * 正式发送ajax257 * @private258*/259 Query.prototype.sendMessage = function () {260var self = this;261var xhr = $.ajax(262 {263 url: this.url,264 type: this.requestType,265 contentType: this.contentType,266 data: this.param,267// ajax发送前调用的方法，初始化等待动画268// @param XHR XMLHttpRequest对象269 beforeSend: function (XHR) {270//试图从Cookie中获得token放入http头部271var token = window.tool.getCookieMap().get(window.commonStaticValue.TOKEN);272if(token){273 XHR.setRequestHeader(window.commonStaticValue.TOKEN,token);274 }275276//绑定本次请求的queryObj277 XHR.queryObj = self;278if (self.beforeSendFunc instanceof Function) {279 self.beforeSendFunc(XHR);280 }281282if (self.loadDom instanceof HTMLElement) {283 self.loadDom.innerText = "";284 $(self.loadDom).append("<div id="loadingDiv" class="loading"><img src="/image/loading.gif"/></div>");285 } elseif (self.loadDom instanceof jQuery) {286 self.loadDom.empty();287 self.loadDom.append("<div id="loadingDiv" class="loading"><img src="/image/loading.gif"/></div>");288 }289 },290//将QueryObj设置为上下文291 context: self,292 success: this._successFunc,293 error: this._errorFunc,294 complete:function(){295 console.log("ajax完成");296 },297 timeout: this.timeout,298 async: this.async299 }300 );301}302303//-----------------------------------下面提供了获取后台返回信息方法（帮忙封装了）304/**305 * 获取返回信息Response的Meta头306*/307 Query.prototype.getMeta = function () {308returnthis.response.meta;309}310311/**312 * 获得返回值里的data部分313 * @returns {*}314*/315 Query.prototype.getMsg = function () {316returnthis.response.data;317}318319/**320 * 获得返回值里的data部分，尝试将其转为Json对象321*/322 Query.prototype.getJsonMsg = function () {323var data = this.response.data;324if (data) {325//先将字符串里的&quot;转为双引号326var data = window.tool.replaceAll(data, "&quot;", """);327try{328var jsonData = JSON.parse(data);329return jsonData;330 }catch (e) {331return data;332 }333 }334}335336//------------------------以下为对Query的参数设置---------------------------337/**338 * 在ajax发送前设置参数，可以有加载的动画，并且请求完成后会自动取消339 * @param loadDom 需要显示动画的dom节点340 * @param beforeSendFunc ajax发送前的自定义函数341*/342 Query.prototype.setBeforeSend = function (loadDom, beforeSendFunc) {343this.loadDom = loadDom;344this.beforeSendFunc = beforeSendFunc;345}346347/**348 * 设置超时时间349 * @param timeout350*/351 Query.prototype.setTimeOut = function (timeout) {352this.timeout = timeout;353}354355 Query.prototype.setAsync = function (async) {356this.async = async;357 }
View Code
预防XSS攻击，Filter知识讲解
网上有些文章说，后端设置HttpOnly，让Cookie无法让js读写，可以防止XSS攻击。
(⊙o⊙)…简直就是乱写，首先要了解下什么是XSS攻击
Xss攻击是什么
举个简单的例子，假设你前端有个地方可以输入，然后保存的数据库的地方
用户A输入了以下东西
<script>alert(123)</script>
然后这东西就到了后台，当作一串字符串保存了起来
刚好你网站的html代码里，有个地方是显示用户输入过的东西的（例如评论区），然后上面的东西就被加载到html里面，如
<!DOCTYPE html><html><head><meta charset="utf-8"/><title></title><p><script>alert(123)</script></p></head><body></body></html>
接下来每个人打开你的网站，都会弹出123的对话框，这就是XSS攻击
怎么预防呢，在后端设置过滤器，对输入进行过滤，先上代码
1/** 2 * @auther: NiceBin 3 * @description: 系统的拦截器，注册在FilterConfig类中进行 4 * 不能使用@WebFilter，因为Filter要排序 5 * 1.对ServletRequest进行封装 6 * 2.防止CSRF，检查http头的Referer字段 7 * @date: 2020/12/15 15:32 8*/ 9@Component10publicclass SystemFilter implements Filter {11privatefinal Logger logger = LoggerFactory.getLogger(SystemFilter.class);12 @Autowired13private Environment environment;1415 @Override16publicvoid init(FilterConfig filterConfig) throws ServletException {17 logger.info("系统拦截器SystemFilter开始加载");18 }1920 @Override21publicvoid doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {22 SystemHttpServletRequestWrapper requestWrapper = new SystemHttpServletRequestWrapper((HttpServletRequest) request);2324//检测http的Referer字段，不允许跨域访问25 String hostPath = environment.getProperty("server.host-path");26 String referer = requestWrapper.getHeader("Referer");27if(!Tool.isNull(referer)){28if(referer.lastIndexOf(hostPath)!=0){29 ((HttpServletResponse)response).setStatus(HttpStatus.FORBIDDEN.value()); //设置错误状态码30return;31 }32 }33 chain.doFilter(requestWrapper,response);34 }3536 @Override37publicvoid destroy() {3839 }40 }
乍一看，是不是没发现哪里预防了XSS，其实正在的关键点在22行和33行代码，里面的SystemHttpServletRequestWrapper类才是关键，这个类是包装类，是替换参数里的ServletRequest类的，为的就是重写里面的方法，来达到预防XSS的目的，因为Spring也是根据ServletRequest类来进行前端参数读取的，所以它就是后端获得数据的源头
1/** 2 * @auther: NiceBin 3 * @description: 包装的httpServlet，进行以下增强 4 * 1.将流数据取出保存，方便多次读出 5 * 2.防止XSS攻击，修改读取数据的方法，过滤敏感字符 6 * @date: 2020/4/23 19:50 7*/ 8publicclass SystemHttpServletRequestWrapper extends HttpServletRequestWrapper { 9privatefinalbyte[] body;10private HttpServletRequest request;1112public SystemHttpServletRequestWrapper(HttpServletRequest request) throws IOException {13super(request);14//打印属性15//printRequestAll(request);16 body = HttpHelper.getBodyString(request).getBytes(Charset.forName("UTF-8")); //HttpHelper是我自己写的工具类17this.request = request;18 }1920 @Override21public BufferedReader getReader() throws IOException {22returnnew BufferedReader(new InputStreamReader(getInputStream()));23 }2425 @Override26public ServletInputStream getInputStream() throws IOException {27final ByteArrayInputStream bais = new ByteArrayInputStream(body);28returnnew ServletInputStream() {29 @Override30publicboolean isFinished() {31returnfalse;32 }3334 @Override35publicboolean isReady() {36returnfalse;37 }3839 @Override40publicvoid setReadListener(ReadListener readListener) {4142 }4344 @Override45publicint read() throws IOException {46return bais.read();47 }48 };49 }5051/**52 * 可以打印出HttpServletRequest里属性的值53 * @param request54*/55publicvoid printRequestAll(HttpServletRequest request){56 Enumeration e = request.getHeaderNames();57while (e.hasMoreElements()) {58 String name = (String) e.nextElement();59 String value = request.getHeader(name);60 System.out.println(name " = " value);61 }62 }6364//以下为XSS预防65 @Override66public String getParameter(String name) {67 String value = request.getParameter(name);68if (!StringUtils.isEmpty(value)) {69 value = StringEscapeUtils.escapeHtml4(value);70 }71return value;72 }7374 @Override75public String[] getParameterValues(String name) {76 String[] parameterValues = super.getParameterValues(name);77if (parameterValues == null) {78returnnull;79 }80for (int i = 0; i < parameterValues.length; i ) {81 String value = parameterValues[i];82 parameterValues[i] = StringEscapeUtils.escapeHtml4(value);83 }84return parameterValues;85 }86 }
HttpHelper工具类：

1publicclass HttpHelper { 2/** 3 * 获取请求中的Body内容 4 * @param request 5 * @return 6*/ 7publicstatic String getBodyString(ServletRequest request) { 8 StringBuilder sb = new StringBuilder(); 9 InputStream inputStream = null;10 BufferedReader reader = null;11try {12 inputStream = request.getInputStream();13 reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")));14 String line = "";15while ((line = reader.readLine()) != null) {16 sb.append(line);17 }18 } catch (IOException e) {19 e.printStackTrace();20 } finally {21if (inputStream != null) {22try {23 inputStream.close();24 } catch (IOException e) {25 e.printStackTrace();26 }27 }28if (reader != null) {29try {30 reader.close();31 } catch (IOException e) {32 e.printStackTrace();33 }34 }35 }36return sb.toString();37 }38 }
View Code
可以看到SystemHttpServletRequestWrapper的64行开始，重写了两个获取参数的方法，在获取参数的时候进行过滤即可~
那64行往上是干啥的咧，这个是将ServletRequest里的数据读出来保存一份，因为ServletRequest里的数据流只能读取一次，很不方便
啥意思呢，就是你在这个Filter里
inputStream = request.getInputStream();reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")));String line = "";while ((line = reader.readLine()) != null) { sb.append(line);}
把数据读完，下个Filter再执行这些代码，就没数据了（从而导致Spring也接收不到数据）
所以要保存起来，让后面的过滤器Filter和拦截器Interceptor快乐的读数据，没有后顾之忧（例如上面提到的验证码设计，如果你想用拦截器拦截，然后进行验证，则势必会读数据），既然封装ServletRequest这么重要，那必须得保证这个Filter第一个加载啊
在Springboot中，Filter的排序用@Order是没用的，必须要用FilterRegistrationBean进行注册才能排序，如：
1/** 2 * @auther: NiceBin 3 * @description: 为了排序Filter，如果Filter有顺序要求 4 * 那么需要在此注册，设置order（值越低优先级越高） 5 * 其他没顺序需要的，可以@WebFilter注册 6 * 如@WebFilter(filterName = "SecurityFilter", urlPatterns = "/*", asyncSupported = true) 7 * @date: 2020/12/15 15:48 8*/ 9@Configuration10publicclass FilterConfig {1112 @Autowired13 SystemFilter systemFilter;14/**15 * 注册SystemFilter，顺序为1，任何其他filter不能比他优先16 * @return17*/18 @Bean19public FilterRegistrationBean filterRegist(){20 FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();21 filterRegistrationBean.setFilter(systemFilter);22 filterRegistrationBean.setName("SystemFilter");23 filterRegistrationBean.addUrlPatterns("/*");24 filterRegistrationBean.setAsyncSupported(true);25 filterRegistrationBean.setOrder(1);26return filterRegistrationBean;27 }28 }
当然了，如果你没用Springboot，那web.xml中定义的顺序就是Filter加载的顺序
知识点提问：在我们之后的Filter或者Interceptor中，需要
1 SystemHttpServletRequestWrapper requestWrapper = (SystemHttpServletRequestWrapper) request
这样强制转换才能用吗？
答案是不用的，你可以想想Spring也用了这个东西的，它怎么知道你定义的类叫什么名字，怎么强制转换，那么这设计到Java什么知识呢
没错，就是Java的多态性，我们看以下代码
publicclass Father { publicvoid sayName(){ System.out.println("我是爸爸"); }}publicclass Son extends Father{ publicvoid sayName(){ System.out.println("我是儿子"); }}publicclass Test { @org.junit.Test publicvoid test() throws Exception { Father father = new Son(); otherMethod(father); } publicvoid otherMethod(Father father){ father.sayName(); }}
输出：我是儿子
答错了的留言，看看有多少小伙子~~ 接下来言归正传
选择JWT生成Token
JWT全称JSON Web Tokens 是一种规范化的 token（别人想的挺多挺全面的了，比你自己想的token要好一点）
一个 JWT token 是一个字符串，它由三部分组成，头部、载荷与签名，中间用 . 分隔，例如：xxxxx.yyyyy.zzzzz
头部（header）
头部通常由两部分组成：令牌的类型（即 JWT）和正在使用的签名算法（如 HMAC SHA256 或 RSA.）。
例如：
{ "alg": "HS256", "typ": "JWT"}
然后用 Base64Url 编码得到头部，即 xxxxx。Base64Url编码后，才能在URL中正常传输（因为有人会把Token放在URL里.....）
载荷（Payload）
载荷中放置了 token 的一些基本信息，以帮助接受它的服务器来理解这个 token。同时还可以包含一些自定义的信息，用户信息交换，如:
{ "sub": "1", "iss": "http://localhost:8000/auth/login", "iat": 1451888119, "exp": 1454516119, "nbf": 1451888119, "jti": "37c107e4609ddbcc9c096ea5ee76c667", "aud": "dev"}
可以将载荷用别的方式加密一遍，这样别人得到了token也看不懂
签名（Signature）
签名时需要用到前面编码过的两个字符串，如果以 HMACSHA256 加密，就如下：
HMACSHA256( base64UrlEncode(header) "." base64UrlEncode(payload), secret)
加密后再进行 base64url 编码最后得到的字符串就是 token 的第三部分 zzzzz。
组合便可以得到 token：xxxxx.yyyyy.zzzzz。
签名的作用：保证 JWT 没有被篡改过，原理如下：
HMAC 算法是不可逆算法，类似 MD5 和 hash ，但多一个密钥，密钥（即上面的 secret）由服务端持有，客户端把 token 发给服务端后，服务端可以把其中的头部和载荷再加上事先共享的 secret 再进行一次 HMAC 加密，得到的结果和 token 的第三段进行对比，如果一样则表明数据没有被篡改。
具体Java使用：
<dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.10.2</version> </dependency> <!--jwt一些工具类--> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.9.1</version></dependency>
1 ** 2 * @auther: NiceBin 3 * @description: Jwt构造器，创建Token来进行身份记录 4 * jwt由3个部分构成：jwt头，有效载荷（主体,payLoad），签名 5 * @date: 2020/5/7 22:40 6 */ 7publicclass JwtTool { 8 9//以下为JwtTool生成时的主题 10//登录是否还有效 11publicstaticfinal String SUBJECT_ONLINE_STATE = "online_state"; 12 13//以下为载荷固定的Key值 14//主题 15publicstaticfinal String SUBJECT = "subject"; 16//发布时间 17publicstaticfinal String TIME_ISSUED = "timeIssued"; 18//过期时间 19publicstaticfinal String EXPIRATION = "expiration"; 20 21/** 22 * 生成token，参数都是载荷（自定义内容） 23 * 其中Map里为非必要数据，而其他参数为必要参数 24 * 25 * @param subject 主题，token生成干啥用的，用上面的常量作为参数 26 * @param liveTime 存活时间(秒单位)，建议使用TimeUnit方便转换 27 * 如TimeUnit.HOURS.toSeconds(1);将1小时转为秒 = 3600 28 * @param claimMap 自定义荷载，可以为空 29 * @return 30*/ 31publicstatic String createToken(String subject, long liveTime, HashMap<String, String> claimMap) throws Exception { 32 33 SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256; 34 35//毫秒要转为秒 36long now = System.currentTimeMillis() / 1000; 37 38// byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(EncrypRSA.keyString); 39// 40// Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName()); 41 42 JwtBuilder jwtBuilder = Jwts.builder() 43//加密算法 44 .setHeaderParam("alg", "HS256") 45//jwt签名 46 .signWith(signatureAlgorithm, EncrypRSA.convertSecretKey); //这个Key是我自个的密码，你们自己设个字符串也成，这个得保密 47 48 HashMap<String,String> payLoadMap = new HashMap<>(); 49 payLoadMap.put(SUBJECT,subject); 50 payLoadMap.put(TIME_ISSUED,String.valueOf(now)); 51//设置Token的过期时间 52if (liveTime >= 0) { 53long expiration = now liveTime; 54 payLoadMap.put(EXPIRATION,String.valueOf(expiration)); 55 } else { 56thrownew SystemException(SystemStaticValue.TOOL_PARAMETER_EXCEPTION_CODE, "liveTime参数异常"); 57 } 58 59 StringBuilder payLoad = new StringBuilder(); 60 61 62 63if (!Collections.isEmpty(claimMap)) { 64 payLoadMap.putAll(claimMap); 65 } 66 67//拼接主题payLoad，采用 key1,value1,key2,value2的格式 68for (Map.Entry<String, String> entry : payLoadMap.entrySet()) { 69 payLoad.append(entry.getKey()).append(",").append(entry.getValue()).append(","); 70 } 71 72//对payLoad进行加密，这样别人Base64URL解密后也不是明文 73 String encrypPayLoad = EncrypRSA.encrypt(payLoad.toString()); 74 75 jwtBuilder.setPayload(encrypPayLoad); 76 77//会自己生成签名，组装 78return jwtBuilder.compact(); 79 } 80 81/** 82 * 私钥解密token信息 83 * 84 * @param token 85 * @return 存有之前定义的Key, value的Map，解析失败则返回null 86*/ 87publicstatic HashMap getMap(String token) { 88if (!Tool.isNull(token)) { 89try { 90 String encrypPayLoad = Jwts.parser() 91 .setSigningKey(EncrypRSA.convertSecretKey) 92 .parsePlaintextJws(token).getBody(); 93 94 String payLoad = EncrypRSA.decrypt(encrypPayLoad); 95 96 String[] payLoads = payLoad.split(","); 97 HashMap<String, String> map = new HashMap<>(); 98for (int i = 0; i < payLoads.length - 1; i=i 2) { 99 map.put(payLoads[i], payLoads[i 1]);100 }101return map;102 } catch (Exception e) {103 System.out.println("Token解析失败");104returnnull;105 }106 } else {107returnnull;108 }109 }110111/**112 * 判断token是否有效113 *114 * @param map 已经解析过token的map115 * @return true 为有效116*/117publicstaticboolean isAlive(HashMap<String, String> map) {118119if (!Collections.isEmpty(map)) {120 String tokenString = map.get(EXPIRATION);121122if (!Tool.isNull(tokenString)) {123long expiration = Long.valueOf(tokenString) / 1000;124long now = System.currentTimeMillis();125if (expiration > now) {126returntrue;127 } else {128returnfalse;129 }130 }131 }132returnfalse;133 }134135/**136 * 判断token是否有效137 * @param token 还未被解析的token138 * @return139*/140publicstaticboolean isAlive(String token) {141return JwtTool.isAlive(JwtTool.getMap(token));142 }143 }
至此，Token的生成和使用就介绍完了，大家有没兴趣了解下重放攻击（淦，我也是在某个博文看到的，又得花时间研究）
Https防止半路被截和重放攻击
前面提到了Token就是身份令牌，可以相当于已登录一样进入系统，那么半路被人截了那就不好了
所以要用Https协议，具体怎么设置大家自行百度吧（直接在tomcat操作的，不需要更改代码，证书也有免费的~）
这里说下Https建立连接的过程，来看看为什么就不会被人截获了
1.服务器先向CA（证书颁布机构）申请一个证书（证书里有自己的ip等等消息），然后在自己服务器设置好
2.浏览器向服务器发送HTTPS请求，服务器将自己的证书发给浏览器
3.浏览器拿到证书后，查看证书是否过期啊，ip是不是跟服务器的一样啊，跟检查身份证跟你长得像不像一样，检查没问题后，跟自己系统里的CA列表比对，看看是谁发的（找不到就报错，说证书不可信），比对成功后从列表里拿出对应的CA公钥解密证书（具体方法跟JWT的很像，浏览器用相同的算法和公钥对证书部分进行加密，看得到的值和证书的签名是否一致），得到服务器的公钥
4.然后生成一个传输私钥，用服务器的公钥加密，发给服务器
5.服务器用服务器的私钥解密，得到了传输秘钥，然后用传输秘钥进行加密要传送的信息发给浏览器
6.浏览器用秘钥解密，然后用传输秘钥进行加密要传送的信息发给服务器（对称加密）
7.重复5,6步骤直到结束
以上哪个步骤黑客得到数据都看不懂
至于为什么能防重放攻击，是因为Https通信自带序列号，如果黑客截取了浏览器的请求，重复发送一遍，那么序列号会一样，会被直接丢弃
至此分享完啦，喜欢的小伙伴给个赞呀~~
参考：https://learnku.com/articles/17883
https://www.cnblogs.com/laixiangran/p/9064769.html
ServletRequest