这是我参与11月更文挑战的第1天，活动详情查看：2021最后一次更文挑战
前言
前一篇文章中，我记录了这次整合遇到的问题。而这篇文章就是整合的过程。全文3千字，预计阅读5分钟，话不多说，咱们开始吧。前后端分离的开发模式中，接口的认证与授权是重中之重。由于接口都是无状态的，那势必就需要一套认证和授权框架来解决“你是谁”以及“你能干什么”的问题，所以，这篇文章就来聊一聊如何整合SpringSecurity和JWT实现登录认证和授权。 源码传送门：https://gitee.com/huoqstudy/xiliu-admin.git
一、SpringSecurity是什么？
SpringSecurity是一个强大的可高度定制的认证和授权框架，对于Spring应用来说它是一套Web安全标准。SpringSecurity注重于为Java应用提供认证和授权功能，像所有的Spring项目一样，它对自定义需求具有强大的扩展性。
其核心就是一组过滤器链，在spring security中一种过滤器处理一种认证方式，项目启动后将会自动配置
二、JWT是什么？
JWT是JSON WEB TOKEN的缩写，它是基于 RFC 7519 标准定义的一种可以安全传输的的JSON对象，由于使用了数字签名，所以是可信任和安全的。总结来说，JWT只是一个生成token的机制。
1. JWT的组成
JWT token的格式：header.payload.signature
可以在该网站上获得解析结果：jwt.io/
-
header中用于存放签名的生成算法
-
payload中用于存放用户名、token的生成时间和过期时间
-
signature为以header和payload生成的签名，一旦header和payload被篡改，验证将失败
2. JWT实现认证和授权的原理
- 用户调用登录接口，登录成功后获取到JWT的token；
- 之后用户每次调用接口都在http的header中添加一个叫Authorization的头，值为JWT的token；
- 后台程序通过对Authorization头中信息的解码及数字签名校验来获取其中的用户信息，从而实现认证和授权。
三、整合步骤
1. 引入相关依赖
代码如下：
<!--SpringSecurity依赖配置-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!--JWT(Json Web Token)登录支持-->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.0</version>
</dependency>
2. yml配置中加入jwt配置信息
jwt:
tokenHeader: X-Token #JWT存储的请求头
tokenHead: Bearer #令牌前缀
secret: yz-admin-secret #JWT加解密使用的密钥
expiration: 604800 #JWT的超期限时间秒(60*60*24)
3. 添加JWT token的工具类
用于生成和解析JWT token的工具类：
@Slf4j
@Component
public class JwtTokenUtil {
private static final String CLAIM_KEY_USERNAME = "sub";
private static final String CLAIM_KEY_CREATED = "created";
@Value("${jwt.secret}")
private String secret;
@Value("${jwt.expiration}")
private Long expire;
/**
* 从token中获取登录用户名
*/
public String getUserNameFromToken(String token) {
String username;
try {
Claims claims = getClaimsFromToken(token);
username = claims.getSubject();
} catch (Exception e) {
username = null;
}
return username;
}
/**
* 校验token
*/
public boolean validateToken(String token, UserDetails userDetails) {
String username = getUserNameFromToken(token);
return username.equals(userDetails.getUsername()) && !isTokenExpired(token);
}
/**
* 根据用户信息生成token
*/
public String generateToken(UserDetails userDetails) {
Map<String, Object> claims = new HashMap<>();
claims.put(CLAIM_KEY_USERNAME, userDetails.getUsername());
claims.put(CLAIM_KEY_CREATED, new Date());
return generateToken(claims);
}
/**
* 判断token是否已经失效
*/
private boolean isTokenExpired(String token) {
Date expiredDate = getClaimsFromToken(token).getExpiration();
return expiredDate.before(new Date());
}
private String generateToken(Map<String, Object> claims) {
return Jwts.builder()
.setClaims(claims)
.setExpiration(generateExpirationDate())
//签名算法
.signWith(SignatureAlgorithm.HS512, secret)
.compact();
}
/**
* 生成token的过期时间
*/
private Date generateExpirationDate() {
return new Date(System.currentTimeMillis() + expire * 1000);
}
private Claims getClaimsFromToken(String token) {
Claims claims = null;
try {
claims = Jwts.parser()
.setSigningKey(secret)
.parseClaimsJws(token)
.getBody();
} catch (Exception e) {
log.info("JWT格式验证失败:{}",token);
}
return claims;
}
}
4. 添加SpringSecurity的配置类
spring security和spring mvc做了很好的集成，一共只需要做两件事，给web配置类加上@EanbleWebSecurity，继承WebSecurityConfigurerAdapter定义个性化配置。 这里我们在加上一个全局的注解@EnableGlobalMethodSecurity(prePostEnabled=true)，该注解会在方法执行前进行验证。
configure(HttpSecurity httpSecurity)：用于配置需要拦截的url路径、jwt过滤器及出异常后的处理器； configure(AuthenticationManagerBuilder auth)：用于配置UserDetailsService及PasswordEncoder； UserDetailsService: SpringSecurity定义的核心接口，用于根据用户名获取用户信息，需要自行实现； UserDetails：SpringSecurity定义用于封装用户信息的类（主要是用户信息和权限），需要自行实现； PasswordEncoder：SpringSecurity定义的用于对密码进行编码及比对的接口，目前使用的是BCryptPasswordEncoder； JwtAuthenticationTokenFilter：在用户名和密码校验前添加的过滤器，如果有jwt的token，会自行根据token信息进行登录。
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled=true)
public class SpringSecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
private CustomAccessDeniedHandler customAccessDeniedHandler;
@Autowired
private CustomAuthenticationEntryPoint customAuthenticationEntryPoint;
@Autowired
private XlUserService xlUserService;
@Override
protected void configure(HttpSecurity httpSecurity) throws Exception {
httpSecurity.csrf().disable()// 由于使用的是JWT，我们这里不需要csrf
.sessionManagement()// 基于token，所以不需要session
.sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.authorizeRequests()
// 允许对于网站静态资源的无授权访问
.antMatchers(HttpMethod.GET,
"/",
"/*.html",
"/favicon.ico",
"/**/*.html",
"/**/*.css",
"/**/*.js",
"/swagger-resources/**",
"/v2/api-docs/**"
)
.permitAll()
// 对登录注册要允许匿名访问
.antMatchers("/ucenter/xl-user/login", "/ucenter/xl-user/register")
.permitAll()
//跨域请求会先进行一次options请求
.antMatchers(HttpMethod.OPTIONS)
.permitAll()
.anyRequest()// 除上面外的所有请求全部需要鉴权认证
.authenticated();
// 禁用缓存
httpSecurity.headers().cacheControl();
// 添加JWT filter
httpSecurity.addFilterBefore(jwtAuthenticationTokenFilter(), UsernamePasswordAuthenticationFilter.class);
//添加自定义未授权和未登录结果返回
httpSecurity.exceptionHandling()
.accessDeniedHandler(customAccessDeniedHandler)
.authenticationEntryPoint(customAuthenticationEntryPoint);
}
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.userDetailsService(userDetailsService())
.passwordEncoder(passwordEncoder());
}
@Bean
@Override
public UserDetailsService userDetailsService() {
//获取登录用户信息
return username -> {
XlUser user = xlUserService.getUserByCode(username);
if (user != null) {
List<XlResource> permissionList = xlUserService.getResourceList(user.getUserId());
return new JwtUser(user,permissionList);
}
throw new UsernameNotFoundException("用户名或密码错误");
};
}
/**
* 装载BCrypt密码编码器
*/
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
/**
* JWT filter
*/
@Bean
public JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter(){
return new JwtAuthenticationTokenFilter();
}
}
5. 添加自定义结果处理类
5.1 添加CustomAccessDeniedHandler
当用户没有访问权限时的处理器，用于返回JSON格式的处理结果（若配置了全局异常的需要注意，会导致该处理类失效。需要在全局异常类里面在单独处理AccessDeniedException异常 ）；
@Component
public class CustomAccessDeniedHandler implements AccessDeniedHandler {
@Override
public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AccessDeniedException e) throws IOException, ServletException {
httpServletResponse.setCharacterEncoding("UTF-8");
httpServletResponse.setContentType("application/json");
httpServletResponse.getWriter().println(JSONUtil.parse(R.error(ResultCodeEnum.FORBIDDEN.getCode(),ResultCodeEnum.FORBIDDEN.getMessage())));
httpServletResponse.getWriter().flush();
}
}
5.2 添加CustomAuthenticationEntryPoint
当未登录或token失效时，返回JSON格式的结果。
@Component
public class CustomAuthenticationEntryPoint implements AuthenticationEntryPoint {
@Override
public void commence(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
httpServletResponse.setCharacterEncoding("UTF-8");
httpServletResponse.setContentType("application/json");
httpServletResponse.getWriter().println(JSONUtil.parse(R.error(ResultCodeEnum.UNAUTHORIZED.getCode(),ResultCodeEnum.UNAUTHORIZED.getMessage())));
httpServletResponse.getWriter().flush();
}
}
6. 添加JwtUser类
Spring Security需要我们实现几个东西，第一个是UserDetails：这个接口中规定了用户的几个必须要有的方法，所以我们创建一个JwtUser类来实现这个接口。为什么不直接使用User类？因为这个UserDetails完全是为了安全服务的，它和我们的领域类可能有部分属性重叠，但很多的接口其实是安全定制的，所以最好新建一个类：
public class JwtUser implements UserDetails {
private XlUser user;
private List<XlResource> resourceList;
public JwtUser(XlUser user, List<XlResource> resourceList) {
this.user = user;
this.resourceList = resourceList;
}
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
//返回当前用户的权限
return resourceList.stream()
.map(resource ->new SimpleGrantedAuthority(resource.getResourceId()+":"+resource.getResourceName()))
.collect(Collectors.toList());
}
@Override
public String getPassword() {
return user.getPassWord();
}
@Override
public String getUsername() {
return user.getUserCode();
}
/**
* 账户是否未过期
**/
@Override
public boolean isAccountNonExpired() {
return true;
}
/**
* 账户是否未锁定
**/
@Override
public boolean isAccountNonLocked() {
return true;
}
/**
* 密码是否未过期
**/
@Override
public boolean isCredentialsNonExpired() {
return true;
}
/**
* 账户是否激活
**/
@Override
public boolean isEnabled() {
return user.getStatus().equals(1);
}
}
7. 添加过滤器JwtAuthenticationTokenFilter
用户除登录之外的请求，都要求必须携带JWT Token。所以我们需要另外一个Filter对这些请求做一个拦截。这个拦截器主要是提取header中的token，进行校验。
@Slf4j
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
@Value("${jwt.tokenHeader}")
private String tokenHeader;
@Value("${jwt.tokenHead}")
private String tokenHead;
@Autowired
private JwtTokenUtil jwtTokenUtil;
@Autowired
private UserDetailsService userDetailsService;
@Override
protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
String authHeader = httpServletRequest.getHeader(this.tokenHeader);
if (StringUtils.isNotBlank(authHeader) && authHeader.startsWith(this.tokenHead)) {
String authToken = authHeader.substring(this.tokenHead.length());
String username = jwtTokenUtil.getUserNameFromToken(authToken);
log.info("checking authentication " + username);
if (StringUtils.isNotBlank(username) && SecurityContextHolder.getContext().getAuthentication() == null) {
UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
// 校验token
if (jwtTokenUtil.validateToken(authToken, userDetails)) {
UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
userDetails, null, userDetails.getAuthorities());
authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(
httpServletRequest));
log.info("authenticated user " + username + ", setting security context");
SecurityContextHolder.getContext().setAuthentication(authentication);
}
}
}
filterChain.doFilter(httpServletRequest, httpServletResponse);
}
}
四、编写注册、登录方法
1. 编写controller
@Api(tags = "后台用户管理")
@RestController
@RequestMapping("/ucenter/xl-user")
public class XlUserController {
@Autowired
private XlUserService xlUserService;
@Value("${jwt.tokenHead}")
private String tokenHead;
@ApiOperation(value = "注册用户")
@PostMapping(value = "register")
public R register(@RequestBody XlUser user) {
XlUser xlUser = xlUserService.register(user);
if (xlUser == null) {
return R.error("注册失败,用户名已存在");
}
return R.ok(xlUser);
}
@ApiOperation(value = "登录")
@PostMapping(value = "login")
public R login(@RequestBody LoginVo loginVo) {
String token = xlUserService.login(loginVo.getUserName(), loginVo.getPassWord());
if (StringUtils.isBlank(token)) {
return R.error("用户名或密码错误");
}
Map<String, String> tokenMap = new HashMap<>();
tokenMap.put("token", token);
tokenMap.put("tokenHead", tokenHead);
return R.ok(tokenMap);
}
@ApiOperation("获取用户所有可访问的资源")
@GetMapping(value = "/resource/{userId}")
public R getResourceList(@PathVariable Long userId) {
List<XlResource> permissionList = xlUserService.getResourceList(userId);
return R.ok(permissionList);
}
}
2. 编写service
public interface XlUserService extends IService<XlUser> {
/**
* 注册功能
* @param user
* @return XlUser
*/
XlUser register(XlUser user);
/**
* 登录功能
* @param username 用户名
* @param password 密码
* @return 生成的JWT的token
*/
String login(String username, String password);
/**
* 获取用户所有可访问的资源
* @param userId 用户id
* @return list
*/
List<XlResource> getResourceList(Long userId);
3. 编写service实现
@Slf4j
@Service
public class XlUserServiceImpl extends ServiceImpl<XlUserMapper, XlUser> implements XlUserService {
@Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserDetailsService userDetailsService;
@Autowired
private JwtTokenUtil jwtTokenUtil;
@Override
public XlUser register(XlUser user) {
XlUser newXlUser = new XlUser();
BeanUtils.copyProperties(user, newXlUser);
//查询是否有相同用户名的用户
List<XlUser> xlUsers = this.baseMapper.selectList(new LambdaQueryWrapper<XlUser>().eq(XlUser::getUserCode,newXlUser.getUserCode()));
if (CollectionUtil.isNotEmpty(xlUsers)) {
return null;
}
//将密码进行加密操作
String encodePassword = passwordEncoder.encode(user.getPassWord());
newXlUser.setPassWord(encodePassword);
this.baseMapper.insert(newXlUser);
return newXlUser;
}
@Override
public String login(String username, String password) {
String token = null;
try {
UserDetails userDetails = userDetailsService.loadUserByUsername(username);
if (!passwordEncoder.matches(password, userDetails.getPassword())) {
throw new BadCredentialsException("密码不正确");
}
UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
SecurityContextHolder.getContext().setAuthentication(authentication);
token = jwtTokenUtil.generateToken(userDetails);
} catch (AuthenticationException e) {
log.warn("登录异常:{}", e.getMessage());
}
return token;
}
@Override
public List<XlResource> getResourceList(Long userId) {
return this.baseMapper.getResourceList(userId);
}
4. 测试
编写好相关代码后，重启项目进行测试。注册和登录接口因为配置了允许匿名访问，所以可以直接访问。而其他接口则做了登录认证，所以访问的时候会校验。
4.1 测试注册用户接口
注册成功
4.2 测试登录接口
登录成功
4.3 测试其它接口
测试需要登录的接口，未登录前访问接口，提示未登录
若已登录，则需要在请求头添加token参数，添加好之后再次请求，则请求成功。（ps：若knife4j 在线文档调试没有请求头部设置，则需要在 文档管理-》个性化设置 开启动态请求参数，刷新即可。）
4.4 测试访问需要权限的接口
在接口上增加一个权限配置，由于登录的账号没有配置任何的权限，访问该接口时，即时登录了也访问不了，提示无权限，如下图所示：
