前面两篇文章的过滤器和拦截器，我们都提到过可以做诸如权限验证的事情。http/https是无状态的协议，当用户访问一个后端接口时，如何判断该用户有没有权限？当然，可以使用账号+密码去验证。但是，如果使用账号和密码，需要频繁访问数据库，很明显，会带来一些额外的开销。本篇介绍下使用jwt和拦截器实现token权限验证。
如果你是新手，且没看过我之前的一系列SpringBoot文章，建议至少看一下这一篇：
SpringBoot（四）SpringBoot搭建简单服务端_springboot做成服务_heart荼毒的博客-CSDN博客
如果你想从头到尾系统地学习，欢迎关注我的专栏，持续更新：
https://blog.csdn.net/qq_21154101/category_12359403.html
目录
一、服务端生成token
1、添加token依赖
2、token工具类
二、客户端携带token
1、注册时获取token
2、 请求时携带token
三、请求后验证token
1、token拦截器
2、注册token拦截器
3、客户端请求和验证
四、token的构成
一、服务端生成token
如何生成token，我们可以使用jwt来生成token。什么是jwt，JWT即Json Web Token， JWT是目前最流行的跨域认证解决方案, 是一个开放式标准(RFC 7519), 用于在各方之间以JSON对象安全传输信息。
1、添加token依赖
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
<version>3.4.1</version>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.1</version>
</dependency>2、token工具类
写一个工具类，用来生成和校验token
package com.zhaojun.server.util;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
public class JwtUtil {
private static final String secret = "hand2020";
private static final Long expiration = 1209600L;
/**
* 生成用户token,设置token超时时间
*/
public static String createToken(String name) {
//过期时间
Date expireDate = new Date(System.currentTimeMillis() + expiration * 1000);
Map<String, Object> map = new HashMap<>();
map.put("alg", "HS256");
map.put("typ", "JWT");
String token = JWT.create()
// 添加头部
.withHeader(map)
//可以将基本信息放到claims中
//userName
.withClaim("userName", name)
//超时设置,设置过期的日期
.withExpiresAt(expireDate)
//签发时间
.withIssuedAt(new Date())
//SECRET加密
.sign(Algorithm.HMAC256(secret));
System.out.println(token);
return token;
}
/**
* 校验token并解析token
*/
public static boolean verifyToken(String token) {
DecodedJWT jwt;
try {
JWTVerifier verifier = JWT.require(Algorithm.HMAC256(secret)).build();
jwt = verifier.verify(token);
if (jwt.getExpiresAt().before(new Date())) {
System.out.println("token过期");
return false;
}
} catch (Exception e) {
//解码异常则抛出异常
System.out.println("token解析异常:" + e.getMessage());
return false;
}
return true;
}
}
二、客户端携带token
因为一般token是放在header中的，直接在浏览器去访问是不能添加header的，当然可以借助postman等工具。我本身是做Android的，我直接基于okhttp快速写几个请求和简单的页面，包括之前的register和login。要实现的逻辑如下：
- 注册新用户时生成token告诉客户端，客户端收到token后保存到本地
- 客户端后续的所有请求，都在header中携带token
- 服务端收到请求后，先校验token，token合法则放行
1、注册时获取token
首先，我先注册个账号，账号为test，密码为123456，手机号为123456。如下示例代码，我使用okhttp写了一个注册请求。
private void doRegister() {
String name = mNameEditText.getText().toString();
String password = mPasswordEditText.getText().toString();
String phone = mPhoneEditText.getText().toString();
if (TextUtils.isEmpty(name) || TextUtils.isEmpty(password) || TextUtils.isEmpty(phone)) {
Toast.makeText(this, "用户名、手机号或密码为空", Toast.LENGTH_SHORT).show();
}
String url = URL + "name=" + name + "&password=" + password + "&phone=" + phone;
new Thread(new Runnable() {
@Override
public void run() {
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url(url)
.build();
try {
Response response = client.newCall(request).execute();
ResponseBody body = response.body();
if (body != null) {
String result = body.string();
Log.d("TTTT",result);
Gson gson = new Gson();
TypeToken<RegisterResult> typeToken = new TypeToken<RegisterResult>() {
};
RegisterResult registerResult = gson.fromJson(result, typeToken);
if (registerResult != null) {
String token = registerResult.getToken();
SPUtils.getInstance().put("token", token);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
}注册成功后，可以看到后端返回了如下的json：
2、 请求时携带token
如下示例代码，我使用okhttp写了一个header带token的请求，这个token就是之前注册时返回保存到本地的。
private void tokenLogin() {
new Thread(new Runnable() {
@Override
public void run() {
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url(url)
.addHeader("token", SPUtils.getInstance().getString("token"))
.build();
try {
Response response = client.newCall(request).execute();
ResponseBody body = response.body();
if (body != null) {
String result = body.string();
Log.d("TTTT", result);
Gson gson = new Gson();
TypeToken<LoginResult> typeToken = new TypeToken<LoginResult>() {
};
LoginResult loginResult = gson.fromJson(result, typeToken);
if (loginResult != null) {
int code = loginResult.getCode();
if (code != 0) {
runOnUiThread(new Runnable() {
@Override
public void run() {
startLoginActivity();
}
});
}
}
}
} catch (Exception e) {
Log.d("TTTT",e.getMessage());
}
}
}).start();
}三、请求后验证token
万事俱备，生成和请求携带token都做好了。接下来，需要在后端实现一个token拦截器，拦截除注册接口以外的任何请求。如果token校验通过则直接放行，否则拦截并返回错误信息。在这里定义了两种：token为空和token不合法。
1、token拦截器
package com.zhaojun.server.interceptor;
import com.zhaojun.server.util.JwtUtil;
import com.zhaojun.server.util.TextUtils;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
public class TokenInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
HttpServletResponseWrapper wrapper = new HttpServletResponseWrapper(response);
String token = request.getHeader("token");
if (TextUtils.isEmpty(token)) {
wrapper.sendRedirect("fail/token/null");
System.out.println("null token");
return false;
}
if (!JwtUtil.verifyToken(token)) {
wrapper.sendRedirect("fail/token/invalid");
System.out.println("invalid token");
return false;
}
System.out.println("valid token");
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("拦截器处理结束...");
HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("请求结束...");
HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
}
}
2、注册token拦截器
非常不建议直接对所有的url都进行拦截，仅拦截需要的请求就好了。
package com.zhaojun.server.interceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class MyWebMvcConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new TokenInterceptor())
.addPathPatterns("/login")
.excludePathPatterns("/register");
}
}
3、客户端请求和验证
客户端发起header携带token的请求后，可以看到，验证成功：
使用浏览器进行不带token的请求后，重定向：
四、token的构成
接下来，我们来看下token的构成。这是我访问我之前的注册接口http://localhost:8080/register?name=abc&phone=13456789123&password=123456，使用jwt生成的一个token
如下这一坨xx.xx.xx的就是token了：
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyTmFtZSI6ImFiYyIsImV4cCI6MTY5MjAxMjcwOCwiaWF0IjoxNjkwODAzMTA4fQ.rmUx9SCSR_5NI9-BTc6T4UxDTge2ZPTqhEvnEgS5OvMtoken的组成是这样的：header（头）.payload（负载）.signature（签名），header和payload都是base64编码，可以直接使用base64工具解析。当然，也可以去如下网站解析token开发工具箱 - JWT 在线解密
signature是签名部分，直接使用base64解析是不行的。需要通过密钥进行解密，密钥也就是我上面jwtUtils代码中的secret。
注意：payload是可以被解析的，因此，withClaim方法不要放关键信息，例如密码等，否则就直接暴露给别人了。
本篇介绍了如何使用jwt生成和验证token，以及通过Android端发起header带token的请求去验证了token拦截器的执行过程。在最后，也简单介绍了token的构成，尤其需要注意的是，token的前两段是明文，里面不要放用户密码等隐私的信息。
