Fork me on GitHub

学习Spring Boot:(十六)使用Shiro与JWT 实现认证服务

前言

需要把Web应用做成无状态的,即服务器端无状态,就是说服务器端不会存储像会话这种东西,而是每次请求时access_token进行资源访问。这里我们将使用 JWT [1],基于散列的消息认证码,使用一个密钥和一个消息作为输入,生成它们的消息摘要。该密钥只有服务端知道。访问时使用该消息摘要进行传播,服务端然后对该消息摘要进行验证。

认证步骤

  1. 客户端第一次使用用户名密码访问认证服务器,服务器验证用户名和密码,认证成功,使用用户密钥生成JWT并返回
  2. 之后每次请求客户端带上JWT
  3. 服务器对JWT进行验证

自定义 jwt 拦截器

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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
/**
* oauth2拦截器,现在改为 JWT 认证
*/
public class OAuth2Filter extends FormAuthenticationFilter {
/**
* 设置 request 的键,用来保存 认证的 userID,
*/
private final static String USER_ID = "USER_ID";
@Resource
private JwtUtils jwtUtils;

/**
* logger
*/
private static final Logger LOGGER = LoggerFactory.getLogger(OAuth2Filter.class);


/**
* shiro权限拦截核心方法 返回true允许访问resource,
*
* @param request
* @param response
* @param mappedValue
* @return
*/
@Override
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
String token = getRequestToken((HttpServletRequest) request);
try {
// 检查 token 有效性
//ExpiredJwtException JWT已过期
//SignatureException JWT可能被篡改
Jwts.parser().setSigningKey(jwtUtils.getSecret()).parseClaimsJws(token).getBody();
} catch (Exception e) {
// 身份验证失败,返回 false 将进入onAccessDenied 判断是否登陆。
onLoginFail(response);
return false;
}
Long userId = getUserIdFromToken(token);
// 存入到 request 中,在后面的业务处理中可以使用
request.setAttribute(USER_ID, userId);
return true;
}

/**
* 当访问拒绝时是否已经处理了;
* 如果返回true表示需要继续处理;
* 如果返回false表示该拦截器实例已经处理完成了,将直接返回即可。
*
* @param request
* @param response
* @return
* @throws Exception
*/
@Override
protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
if (isLoginRequest(request, response)) {
if (isLoginSubmission(request, response)) {
return executeLogin(request, response);
} else {
return true;
}
} else {
onLoginFail(response);
return false;
}
}

/**
* 鉴定失败,返回错误信息
* @param token
* @param e
* @param request
* @param response
* @return
*/
@Override
protected boolean onLoginFailure(AuthenticationToken token, AuthenticationException e, ServletRequest request, ServletResponse response) {
try {
((HttpServletResponse) response).setStatus(HttpStatus.BAD_REQUEST.value());
response.getWriter().print("账号活密码错误");
} catch (IOException e1) {
LOGGER.error(e1.getMessage(), e1);
}
return false;
}

/**
* token 认证失败
*
* @param response
*/
private void onLoginFail(ServletResponse response) {
HttpServletResponse httpResponse = (HttpServletResponse) response;
((HttpServletResponse) response).setStatus(HttpStatus.UNAUTHORIZED.value());
try {
response.getWriter().print("没有权限,请联系管理员授权");
} catch (IOException e) {
LOGGER.error(e.getMessage(), e);
}
}

/**
* 获取请求的token
*/
private String getRequestToken(HttpServletRequest httpRequest) {
//从header中获取token
String token = httpRequest.getHeader(jwtUtils.getHeader());
//如果header中不存在token,则从参数中获取token
if (StringUtils.isBlank(token)) {
return httpRequest.getParameter(jwtUtils.getHeader());
}
if (StringUtils.isBlank(token)) {
// 从 cookie 获取 token
Cookie[] cookies = httpRequest.getCookies();
if (null == cookies || cookies.length == 0) {
return null;
}
for (Cookie cookie : cookies) {
if (cookie.getName().equals(jwtUtils.getHeader())) {
token = cookie.getValue();
break;
}
}
}
return token;
}

/**
* 根据 token 获取 userID
*
* @param token token
* @return userId
*/
private Long getUserIdFromToken(String token) {
if (StringUtils.isBlank(token)) {
throw new KCException("无效 token", HttpStatus.UNAUTHORIZED.value());
}
Claims claims = jwtUtils.getClaimByToken(token);
if (claims == null || jwtUtils.isTokenExpired(claims.getExpiration())) {
throw new KCException(jwtUtils.getHeader() + "失效,请重新登录", HttpStatus.UNAUTHORIZED.value());
}
return Long.parseLong(claims.getSubject());
}

}

将自定义shiro拦截器,设置到 ShiroFilterFactoryBean 中,然后将需要进行权限验证的 path 进行设置拦截过滤。

登陆

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@PostMapping("/login")
@ApiOperation("系统登陆")
public ResponseEntity<String> login(@RequestBody SysUserLoginForm userForm) {
String kaptcha = ShiroUtils.getKaptcha(Constants.KAPTCHA_SESSION_KEY);
if (!userForm.getCaptcha().equalsIgnoreCase(kaptcha)) {
throw new KCException("验证码不正确!");
}
UsernamePasswordToken token = new UsernamePasswordToken(userForm.getUsername(), userForm.getPassword());
Subject currentUser = SecurityUtils.getSubject();
currentUser.login(token);

//账号锁定
if (getUser().getStatus() == SysConstant.SysUserStatus.LOCK) {
throw new KCException("账号已被锁定,请联系管理员");
}
// 登陆成功后直接返回 token ,然后后续放到 header 中认证
return ResponseEntity.status(HttpStatus.OK).body(jwtUtils.generateToken(getUserId()));
}

JwtUtils

我前面给 jwt 设置了三个参数

1
2
3
4
5
6
7
8
# jwt 配置
jwt:
# 加密密钥
secret: 61D73234C4F93E03074D74D74D1E39D9 #blog.wuwii.com
# token有效时长
expire: 7 # 7天,单位天
# token 存在 header 中的参数
header: token

jwt 工具类的编写

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
@ConfigurationProperties(prefix = "jwt")
@Component
public class JwtUtils {
/**
* logger
*/
private Logger logger = LoggerFactory.getLogger(JwtUtils.class);

/**
* 密钥
*/
private String secret;
/**
* 有效期限
*/
private int expire;
/**
* 存储 token
*/
private String header;

/**
* 生成jwt token
*
* @param userId 用户ID
* @return token
*/
public String generateToken(long userId) {
Date nowDate = new Date();

return Jwts.builder()
.setHeaderParam("typ", "JWT")
// 后续获取 subject 是 userid
.setSubject(userId + "")
.setIssuedAt(nowDate)
.setExpiration(DateUtils.addDays(nowDate, expire))
// 这里我采用的是 HS512 算法
.signWith(SignatureAlgorithm.HS512, secret)
.compact();
}

/**
* 解析 token,
* 利用 jjwt 提供的parser传入秘钥,
*
* @param token token
* @return 数据声明 Map<String, Object>
*/
public Claims getClaimByToken(String token) {
try {
return Jwts.parser()
.setSigningKey(secret)
.parseClaimsJws(token)
.getBody();
} catch (Exception e) {
return null;
}
}

/**
* token是否过期
*
* @return true:过期
*/
public boolean isTokenExpired(Date expiration) {
return expiration.before(new Date());
}

public String getSecret() {
return secret;
}

public void setSecret(String secret) {
this.secret = secret;
}

public int getExpire() {
return expire;
}

public void setExpire(int expire) {
this.expire = expire;
}

public String getHeader() {
return header;
}

public void setHeader(String header) {
this.header = header;
}
}

总结

由于 JWT 这种方式,服务端不需要保存任何状态,所以服务端不需要使用 session 保存用户信息,单元测试也比较方便,虽然中间转码解码会消耗一些性能,但是影响不大,还比较方便的应用在 SSO [2]


  1. 1.JSON WEB Token
  2. 2.Single Sign On
------本文结束 🖐 感谢阅读------
0%