一.首先用户登录成功之后关联jwt，并返回jwt 1.实现AuthenticationSuccessHandler 2.在AuthenticationSuccessHandler的handle方法中生成令牌并且把user信息写入jwt中，写入缓存以供前端传过来时通过令牌获取用户（这里不使用前端传过来的jwt里的用户信息，仅仅是用令牌来比对是否已存在该令牌并通过缓存获取用户和权限），这里最好给个有效时间，然后把jwt放入header中返回给前端，以后前端就用它来调用接口 代码： public class JwtAuthenticationSuccessHandler implements AuthenticationSuccessHandler {
//private final RequestCache requestCache = new HttpSessionRequestCache();
private final ObjectMapper jacksonObjectMapper;
private final RedisTemplate redisTemplate;
public JwtAuthenticationSuccessHandler(ObjectMapper jacksonObjectMapper, RedisTemplate redisTemplate) {
this.jacksonObjectMapper = jacksonObjectMapper;
this.redisTemplate = redisTemplate;
}
@Override
public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException {
log.info("JwtAuthenticationSuccessHandler=success");
clearAuthenticationAttributes(request);
handle(response,authentication);
}
protected final void clearAuthenticationAttributes(HttpServletRequest request) {
HttpSession session = request.getSession(false);
if (session == null) return;
session.removeAttribute(WebAttributes.AUTHENTICATION_EXCEPTION);
}
protected void handle(HttpServletResponse response, Authentication authentication) throws IOException {
if (response.isCommitted()) {
log.debug("Response has already been committed.");
return;
}
User sysUser=(User)authentication.getPrincipal();
sysUser.setClazz(authentication.getClass());
//AuthenticationAdapter authenticationAdapter=AuthenticationAdapter.authentication2AuthenticationAdapter(authentication);
String authOfjson=jacksonObjectMapper.writevalueAsString(sysUser);
String subject= UUID.randomUUID().toString();
String authOfjwt= JWTHS256.buildJWT(subject,authOfjson);
response.addHeader("jwt",authOfjwt);
//跨域时允许header携带jwt
response.addHeader("Access-Control-Expose-Headers" ,"jwt");
redisTemplate.boundValueOps(SecurityConstants.getJwtKey(subject)).set("w",60, TimeUnit.MINUTES);
response.setContentType("application/json;charset=utf-8");
PrintWriter out = response.getWriter();
User returnSysUser=new User();
returnSysUser
.setName(sysUser.getName())
.setCurrentOrg(sysUser.getCurrentOrg())
.setOrgIdMapRoleList(sysUser.getOrgIdMapRoleList());
out.write(jacksonObjectMapper.writevalueAsString(new ReturnObject<>(this.getClass().getName(),ConstantOfReturnCode.GLOBAL_RESULT_SUCESS,"登录成功",returnSysUser)));
out.flush();
out.close();
}
@Slf4j public class JwtSecurityContextRepository implements SecurityContextRepository { protected final Log logger = LogFactory.getLog(this.getClass());
private final RedisTemplate redisTemplate;
private final ObjectMapper jacksonObjectMapper;
public JwtSecurityContextRepository(RedisTemplate redisTemplate, ObjectMapper jacksonObjectMapper) {
this.redisTemplate = redisTemplate;
this.jacksonObjectMapper = jacksonObjectMapper;
}
@Override
public SecurityContext loadContext(HttpRequestResponseHolder requestResponseHolder) {
HttpServletRequest request = requestResponseHolder.getRequest();
return readSecurityContextFromJWT(request);
}
@Override
public void saveContext(SecurityContext context, HttpServletRequest request, HttpServletResponse response) {
}
@Override
public boolean containsContext(HttpServletRequest request) {
return false;
}
private SecurityContext readSecurityContextFromJWT(HttpServletRequest request) {
SecurityContext context=generateNewContext();
String authenticationOfjwt=request.getHeader("jwt");
if(StringUtils.isNotBlank(authenticationOfjwt)){
try{
Map map= JWTHS256.vaildToken(authenticationOfjwt);
if(Objects.nonNull(map)&&map.size()==2){
String subject=(String)map.get("subject");
Boolean isExp=redisTemplate.hasKey(SecurityConstants.getJwtKey(subject));
if(Objects.nonNull(isExp)&&isExp){//redis key 未过期
redisTemplate.expire(SecurityConstants.getJwtKey(subject),60, TimeUnit.MINUTES);//延期
String obj=(String)map.get("claim");
//AuthenticationAdapter authenticationAdapter=jacksonObjectMapper.readValue(obj, new TypeReference<>(){});
//Authentication authentication=AuthenticationAdapter.authenticationAdapter2Authentication(authenticationAdapter);
//Authentication authentication=jacksonObjectMapper.readValue(obj, new TypeReference<>(){});
//Authentication authentication=jacksonObjectMapper.readValue(obj,Authentication.class);
User sysUser=jacksonObjectMapper.readValue(obj, new TypeReference(){});
Authentication authentication=new UsernamePasswordAuthenticationToken(sysUser,null,sysUser.getAuthorities());
context.setAuthentication(authentication);
//if(obj instanceof Authentication){
//context.setAuthentication((Authentication)obj);
//}else log.error("jwt包含authentication的数据非法");
}else log.error("jwt数据过期");
}else log.error("jwt数据非法");
}catch (Exception e){
e.printStackTrace();
logger.error(e.getLocalizedMessage());
}
}else{
if (logger.isDebugEnabled()) {
logger.debug("No JWT was available from the HttpServletRequestHeader!");
}
}
return context;
}
protected SecurityContext generateNewContext() {
return SecurityContextHolder.createEmptyContext();
}
