Shiro整合JWT：实现用户认证和授权
文章目录
- Shiro+JWT实现认证和授权
- 1. JWT的简单介绍
- 1.1 为什么使用JWT？
- 1.2 JWT的结构
- 2. 封装JWT工具类
- 2.1 jwt属性注入的配置文件
- 2.2 JwtTokenUtil
- 3. Shiro框架整合JWT
- 3.1 封装JWT替换shiro的 UsernamePasswordToken
- 3.2 自定义访问控制拦截器
- 3.3 自定义Realm
- 3.4 自定义认证方式
- 3.5 ShiroConfig
Shiro+JWT实现认证和授权
1. JWT的简单介绍
1.1 为什么使用JWT？
通过session管理用户登录状态会出现一些弊端，因此慢慢发展成为token的方式做登录身份校验，然后通过token去取redis中的缓存的用户信息，随着之后jwt的出现，校验方式更加简单便捷化，无需通过redis缓存，而是直接根据token取出保存的用户信息，以及对token可用性校验，单点登录更为简单。（关于这个可以参考我的博文https://hengheng.blog.csdn.net/article/details/107153309）
1.2 JWT的结构
一个JWT实际上就是一个字符串，它由三部分组成，头部、载荷与签名。
头部（header) 是一个 JSON 对象
载荷（payload) 是一个 JSON 对象，用来存放实际需要传递的数据
签名（signature) 对header和payload使用密钥进行签名，防止数据篡改
① 头部：type和加密算法，然后对头部使用base64编码：
{"typ":"JWT","alg":"HS256"}
② 载荷：用来存放有效信息，需要对这部分信息使用base64加密
iss: jwt签发者
sub: jwt所面向的用户
aud: 接收jwt的一方
exp: jwt的过期时间，这个过期时间必须要大于签发时间
nbf: 定义在什么时间之前，该jwt都是不可用的.
iat: jwt的签发时间
jti: jwt的唯一身份标识，主要用来作为一次性token。
{"sub":"1234567890","name":"John Doe","admin":true}
③ 签名：Signature部分是对前两部分的防篡改签名。将Header和Payload用Base64URL编码后，再用点(.)连接起来。然后使用签名算法和密钥对这个字符串进行签名
signature = HMACSHA256(header + "." + payload, secret);
secret是保存在服务器端的，jwt的签发生成也是在服务器端的，secret就是用来进行jwt的签发和jwt的验证，所以，它就是你服务端的私钥，在任何场景都不应该流露出去。
头部，有效载荷和签名哈希的三个部分组合成一个字符串，每个部分用"."分隔，就构成整个JWT对象。 以上三部分都是在服务器定义，当用户登陆成功后，根据用户信息，按照jwt规则生成token返回给客户端。
④ 使用时的注意事项：
JWT默认是不加密的，但也可以加密，不加密时不宜在jwt中存放敏感信息
不要泄露签名密钥(secret)
jwt签发后无法撤回，有效期不宜太长
JWT 泄露会被人冒用身份，为防止盗用，JWT应尽量使用 https 协议传输
2. 封装JWT工具类
2.1 jwt属性注入的配置文件
#JWT 密钥
jwt.secretKey=78944878877848fg)
# token过期时间
jwt.accessTokenExpireTime=PT2H
# 刷新token的过期时间
jwt.refreshTokenExpireTime=PT8H
#小程序中token过期时间
jwt.refreshTokenExpireAppTime=P30D
jwt.issuer=yingxue.org.cn
@ConfigurationProperties：告诉springboot将本类中的所有属性和配置文件中相关的配置进行绑定
2.2 JwtTokenUtil
这个工具类非常重要：签发token，解析token，判断token是否过期，获取token的剩余过期时间
@Slf4j
@ConfigurationProperties(prefix = "jwt")
public class JwtTokenUtil {
//token的秘钥
private static String securityKey;
private static Duration accessTokenExpireTime;
private static Duration refreshTokenExpireTime;
private static Duration refreshTokenExpireAppTime;
private static String issuer;
/**
* 签发token
*
* @param issuer 签发人
* @param subject 代表这个JWT的主体，即它的所有人 一般是用户id
* @param claims 存储在JWT里面的信息 一般放些用户的权限/角色信息
* @param ttlMillis 有效时间(毫秒)
*/
public static String generateToken(String issuer, String subject, Map<String, Object> claims, long ttlMillis, String secret) {
JwtBuilder builder = Jwts.builder()
.setHeaderParam("typ", "JWT")
.setSubject(subject)
.setIssuer(issuer)
.setIssuedAt(System.currentTimeMillis())
.setClaims(claims)
.signWith(SignatureAlgorithm.HS256, DatatypeConverter.parseBase64Binary(secret));
if (ttlMillis >= 0) {
//过期时间=当前时间+过期时长
long nowMillis = System.currentTimeMillis();
long expMillis = nowMillis + ttlMillis;
Date exp = new Date(expMillis);
builder.setExpiration(exp);
}
return builder.compact();
}
/**
* 生成 access_token：这个过期时间比较短，,access_token过期则用refresh_token换取access_token
*/
public static String getAccessToken(String subject, Map<String, Object> claims) {
return generateToken(issuer, subject, claims, accessTokenExpireTime.toMillis(), securityKey);
}
/**
* 生成 PC refresh_token
*/
public static String getRefreshToken(String subject, Map<String, Object> claims) {
return generateToken(issuer, subject, claims, refreshTokenExpireTime.toMillis(), securityKey);
}
/**
* 生成 App端 refresh_token
*/
public static String getRefreshAppToken(String subject, Map<String, Object> claims) {
return generateToken(issuer, subject, claims, refreshTokenExpireAppTime.toMillis(), securityKey);
}
/**
* 解析token：从token中获取claims
*/
public static Claims getClaimsFromToken(String token) {
Claims claims = null;
try {
claims = Jwts.parser()
.setSigningKey(DatatypeConverter.parseBase64Binary(securityKey))
.parseClaimsJws(token)
.getBody();
} catch (Exception e) {
if (e instanceof ClaimJwtException) {
claims = ((ClaimJwtException) e).getClaims();
}
}
return claims;
}
/**
* 获取用户id
*/
public static String getUserId(String token) {
String userId = null;
try {
Claims claims = getClaimsFromToken(token);
userId = claims.getSubject();
} catch (Exception e) {
log.error("eror={}", e);
}
return userId;
}
/**
* 获取用户名
*/
public static String getUserName(String token) {
String username = null;
try {
Claims claims = getClaimsFromToken(token);
username = (String) claims.get(Constant.JWT_USER_NAME);
} catch (Exception e) {
log.error("eror={}", e);
}
return username;
}
/**
* 验证token 是否过期(true:已过期 false:未过期)
*/
public static Boolean isTokenExpired(String token) {
try {
Claims claims = getClaimsFromToken(token);
//token的过期时间 = 签发token时的时间 + 过期时长
Date expiration = claims.getExpiration();
return expiration.before(new Date());
} catch (Exception e) {
log.error("error={}", e);
return true;
}
}
/**
* 验证token是否有效 (true：验证通过 false：验证失败)
*/
public static Boolean validateToken(String token) {
Claims claimsFromToken = getClaimsFromToken(token);
return (claimsFromToken ！= null && !isTokenExpired(token));
}
/**
* 获取token的剩余过期时间
*/
public static long getRemainingTime(String token) {
long result = 0;
try {
long nowMillis = System.currentTimeMillis();
//剩余过期时间 = token的过期时间-当前时间
result = getClaimsFromToken(token).getExpiration().getTime() - nowMillis;
} catch (Exception e) {
log.error("error={}", e);
}
return result;
}
}
3. Shiro框架整合JWT
其实使用普通的拦截器，拦截请求也可以实现jwt的认证和授权功能，但是Shiro已经帮我们做好了相应的封装，为什么不用呢？下面我们来看看Shiro如何整合JWT？
3.1 封装JWT替换shiro的 UsernamePasswordToken
通过用户名和密码进行认证，Shiro会将其封装为 UsernamePasswordToken进行认证，而使用jwt进行认证，不再是用户名和密码，需要自定义一个CustomUsernamePasswordToken，进而认证jwt；
public class CustomUsernamePasswordToken extends UsernamePasswordToken {
//定义一个token
private String jwtToken;
//返回token
public CustomUsernamePasswordToken(String jwtToken) {
this.jwtToken = jwtToken;
}
//用户的身份信息是jwtToken（之前是数据库中的用户名）
@Override
public Object getPrincipal() {
return jwtToken;
}
//用户的凭证信息是jwtToken（之前是数据库中的密码）
@Override
public Object getCredentials() {
return jwtToken;
}
}
3.2 自定义访问控制拦截器
AccessControlFilter抽象类里面有两个必须要实现的方法：isAccessAllowed()方法和onAccessDenied()方法；
在执行登录的时候会调用AccessControlFilter类里面的onPreHandle方法，所有的请求经过过滤器都会来到onPreHandle方法，该方法会自动调用下面两个两个方法决定是否继续处理：
onPreHandle()方法：
- isAccessAllowed：判断是否登录，在登录的情况下会走此方法
- onAccessDenied：是否是拒绝登录，没有登录的情况下会走此方法
如果isAccessAllowed方法返回True，则不会再调用onAccessDenied方法，代表已经登录；如果isAccessAllowed方法返回Flase，则会继续调用onAccessDenied方法。而onAccessDenied方法里面则是具体执行登陆的地方。
需要注意：自定义拦截器需要在ShiroConfig中配置，并配置拦截的请求路径
@Slf4j
public class CustomAccessControlFilter extends AccessControlFilter {
//方法返回false时代表没有登录，会继续访问onAccessDenied()方法
@Override
protected boolean isAccessAllowed(ServletRequest servletRequest, ServletResponse servletResponse, Object o) throws Exception {
return false;
}
//这个方法用户执行登录认证
@Override
protected boolean onAccessDenied(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {
HttpServletRequest request = (HttpServletRequest) servletRequest;
//从请求头中获取token
String accessToken = request.getHeader(Constant.ACCESS_TOKEN);
try {
//如果token为空，抛出异常
if (StringUtils.isEmpty(accessToken)) {
throw new BusinessException(BaseResponseCode.TOKEN_NOT_NULL);
}
//将这个token封装为CustomUsernamePasswordToken
CustomUsernamePasswordToken customUsernamePasswordToken
= new CustomUsernamePasswordToken(accessToken);
//执行登录认证
getSubject(servletRequest, servletResponse).login(customUsernamePasswordToken);
//在认证的过程中会抛出各种异常，这里只写一种
} catch (Exception e) {
//将异常回写
customResponse(servletResponse, e.getCode(), e.getMsg());
return false;
}
return true;
}
}
3.3 自定义Realm
我们先来看看源码：
public class SimpleAccountRealm extends AuthorizingRealm {
//实现认证的方法
public final AuthenticationInfo getAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
AuthenticationInfo info = getCachedAuthenticationInfo(token);
if (info == null) {
//如果用户信息为null，就去认证用户名是否正确
info = doGetAuthenticationInfo(token);
log.debug("Looked up AuthenticationInfo [{}] from doGetAuthenticationInfo", info);
if (token != null && info != null) {
cacheAuthenticationInfoIfPossible(token, info);
}
}
if (info != null) {
//如果用户信息不为null，就去认证密码是否正确,这个逻辑不需要我们实现，但是主要指明认证方式
assertCredentialsMatch(token, info);
}
return info;
}
// 实现授权的方法
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
String username = getUsername(principals);
USERS_LOCK.readLock().lock();
try {
return this.users.get(username);
} finally {
USERS_LOCK.readLock().unlock();
}
}
}
也就是说我们只需要判断用户不为null，或者token不为null即可治愈认证shiro会帮助我们去做，但是需要指明认证方式，比如密码认证时需要指明密码的加密算法：
public class CustomRealm extends AuthorizingRealm {
// 自定义realm时，必须重写这个方法，不然会报错
@Override
public boolean supports(AuthenticationToken token) {
return token instanceof CustomUsernamePasswordToken;
}
//用户认证，并返回认证信息
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
CustomUsernamePasswordToken customUsernamePasswordToken
= (CustomUsernamePasswordToken) token;
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(
//标识与此AuthenticationInfo实例关联的用户主体。
customUsernamePasswordToken.getPrincipal(),
//验证用户主体的凭证
customUsernamePasswordToken.getCredentials(),
//自定义realm的名称
this.getName());
return info;
}
//到数据库中获取用户的角色和权限信息
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
String accessToken = (String) principals.getPrimaryPrincipal();
//获取token中携带的信息
Claims claimsFromToken = JwtTokenUtil.getClaimsFromToken(accessToken);
//用户权限信息
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
if (claimsFromToken.get(Constant.PERMISSIONS_INFOS_KEY) != null) {
info.addStringPermissions((Collection<String>) claimsFromToken.get(Constant.PERMISSIONS_INFOS_KEY));
}
//用户角色信息
if (claimsFromToken.get(Constant.ROLES_INFOS_KEY) != null) {
info.addRoles((Collection<String>) claimsFromToken.get(Constant.ROLES_INFOS_KEY));
}
return info;
}
}
3.4 自定义认证方式
之前我们使用用户名和密码认证时，需要指明用户在注册时密码的加密方式然后交给realm执行认证，而现在我们需要认证token，因此因为需要自定义token的认证方式：
@Slf4j
public class CustomHashedCredentialsMatcher extends HashedCredentialsMatcher {
@Autowired
private RedisService redisService;
@Override
public boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) {
CustomUsernamePasswordToken customUsernamePasswordToken
= (CustomUsernamePasswordToken) token;
String accessToken = (String) customUsernamePasswordToken.getCredentials();
String userId = JwtTokenUtil.getUserId(accessToken);
//判断用户是否被删除
if (redisService.hasKey(Constant.DELETED_USER_KEY + userId)) {
throw new BusinessException(BaseResponseCode.ACCOUNT_HAS_DELETED_ERROR);
}
//判断是否被锁定
if (redisService.hasKey(Constant.ACCOUNT_LOCK_KEY + userId)) {
throw new BusinessException(BaseResponseCode.ACCOUNT_LOCK);
}
//校验token
if (!JwtTokenUtil.validateToken(accessToken)) {
throw new BusinessException(BaseResponseCode.TOKEN_PAST_DUE);
}
return true;
}
}
3.5 ShiroConfig
@Configuration
public class ShiroConfig {
//配置自定义realm，相当于一个数据源
@Bean
public CustomRealm customRealm() {
CustomRealm customRealm = new CustomRealm();
customRealm.setCredentialsMatcher(customHashedCredentialsMatcher());
return customRealm;
}
//配置安全管理器
@Bean
public SecurityManager securityManager() {
DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
defaultWebSecurityManager.setRealm(customRealm());
return defaultWebSecurityManager;
}
@Bean
public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
shiroFilterFactoryBean.setSecurityManager(securityManager);
//添加自定义的过滤器
LinkedHashMap<String, Filter> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("token", new CustomAccessControlFilter());
shiroFilterFactoryBean.setFilters(linkedHashMap);
LinkedHashMap<String, String> hashMap = new LinkedHashMap<>();
hashMap.put("/api/user/login", "anon");
//添加放行地址
hashMap.put("/swagger/**", "anon");
hashMap.put("/v2/api-docs", "anon");
hashMap.put("/swagger-ui.html", "anon");
hashMap.put("/swagger-resources/**", "anon");
hashMap.put("/webjars/**", "anon");
hashMap.put("/favicon.ico", "anon");
hashMap.put("/captcha.jpg", "anon");
hashMap.put("/druid/**", "anon");
//所有的请求都要经过自定义的拦截器进行登录认证
hashMap.put("/**", "token");
//所有的请求都要经过授权认证
hashMap.put("/**", "authc");
shiroFilterFactoryBean.setFilterChainDefinitionMap(hashMap);
return shiroFilterFactoryBean;
}
}