Spring Security结合JWT的方法教程

2023-09-19 10:41:10 154

概述

众所周知使用JWT做权限验证，相比Session的优点是，Session需要占用大量服务器内存，并且在多服务器时就会涉及到共享Session问题，在手机等移动端访问时比较麻烦

而JWT无需存储在服务器，不占用服务器资源（也就是无状态的），用户在登录后拿到Token后，访问需要权限的请求时附上Token（一般设置在Http请求头），JWT不存在多服务器共享的问题，也没有手机移动端访问问题，若为了提高安全，可将Token与用户的IP地址绑定起来

前端流程

用户通过AJAX进行登录得到一个Token

之后访问需要权限请求时附上Token进行访问





Title


varheader="";
functionlogin(){
$.post("http://localhost:8080/auth/login",{
username:$("#username").val(),
password:$("#password").val()
},function(data){
console.log(data);
header=data;
})
}
functiontoUserPageBtn(){
$.ajax({
type:"get",
url:"http://localhost:8080/userpage",
beforeSend:function(request){
request.setRequestHeader("Authorization",header);
},
success:function(data){
console.log(data);
}
});
}




PleaseLogin
UserName
Password


访问UserPage

后端流程（SpringBoot+SpringSecurity+JJWT）

思路：

创建用户、权限实体类与数据传输对象
编写Dao层接口，用于获取用户信息
实现UserDetails（Security支持的用户实体对象，包含权限信息）
实现UserDetailsSevice（从数据库中获取用户信息，并包装成UserDetails）
编写JWTToken生成工具，用于生成、验证、解析Token
配置Security，配置请求处理与设置UserDetails获取方式为自定义的UserDetailsSevice
编写LoginController，接收用户登录名密码并进行验证，若验证成功返回Token给用户
编写过滤器，若用户请求头或参数中包含Token则解析，并生成Authentication，绑定到SecurityContext，供Security使用
用户访问了需要权限的页面，却没附上正确的Token，在过滤器处理时则没有生成Authentication，也就不存在访问权限，则无法访问，否之访问成功

编写用户实体类，并插入一条数据

User（用户）实体类

@Data
@Entity
publicclassUser{
@Id
@GeneratedValue
privateintid;
privateStringname;
privateStringpassword;
@ManyToMany(cascade={CascadeType.REFRESH},fetch=FetchType.EAGER)
@JoinTable(name="user_role",joinColumns={@JoinColumn(name="uid",referencedColumnName="id")},inverseJoinColumns={@JoinColumn(name="rid",referencedColumnName="id")})
privateListroles;
}

Role（权限）实体类

@Data
@Entity
publicclassRole{
@Id
@GeneratedValue
privateintid;
privateStringname;
@ManyToMany(mappedBy="roles")
privateListusers;
}

插入数据

User表

id	name	password
1	linyuan	123

Role表

id	name
1	USER

User_ROLE表

uid	rid
1	1

Dao层接口，通过用户名获取数据，返回值为Java8的Optional对象

publicinterfaceUserRepositoryextendsRepository{
OptionalfindByName(Stringname);
}

编写LoginDTO，用于与前端之间数据传输

@Data
publicclassLoginDTOimplementsSerializable{
@NotBlank(message="用户名不能为空")
privateStringusername;
@NotBlank(message="密码不能为空")
privateStringpassword;
}

编写Token生成工具，利用JJWT库创建，一共三个方法：生成Token（返回String）、解析Token（返回Authentication认证对象）、验证Token（返回布尔值）

@Component
publicclassJWTTokenUtils{
privatefinalLoggerlog=LoggerFactory.getLogger(JWTTokenUtils.class);
privatestaticfinalStringAUTHORITIES_KEY="auth";
privateStringsecretKey;//签名密钥
privatelongtokenValidityInMilliseconds;//失效日期
privatelongtokenValidityInMillisecondsForRememberMe;//（记住我）失效日期
@PostConstruct
publicvoidinit(){
this.secretKey="Linyuanmima";
intsecondIn1day=1000*60*60*24;
this.tokenValidityInMilliseconds=secondIn1day*2L;this.tokenValidityInMillisecondsForRememberMe=secondIn1day*7L;
}
privatefinalstaticlongEXPIRATIONTIME=432_000_000;
//创建Token
publicStringcreateToken(Authenticationauthentication,BooleanrememberMe){
Stringauthorities=authentication.getAuthorities().stream()//获取用户的权限字符串，如USER,ADMIN
.map(GrantedAuthority::getAuthority)
.collect(Collectors.joining(","));
longnow=(newDate()).getTime();//获取当前时间戳
Datevalidity;//存放过期时间
if(rememberMe){
validity=newDate(now+this.tokenValidityInMilliseconds);
}else{
validity=newDate(now+this.tokenValidityInMillisecondsForRememberMe);
}
returnJwts.builder()//创建Token令牌
.setSubject(authentication.getName())//设置面向用户
.claim(AUTHORITIES_KEY,authorities)//添加权限属性
.setExpiration(validity)//设置失效时间
.signWith(SignatureAlgorithm.HS512,secretKey)//生成签名
.compact();
}
//获取用户权限
publicAuthenticationgetAuthentication(Stringtoken){
System.out.println("token:"+token);
Claimsclaims=Jwts.parser()//解析Token的payload
.setSigningKey(secretKey)
.parseClaimsJws(token)
.getBody();
Collectionauthorities=
Arrays.stream(claims.get(AUTHORITIES_KEY).toString().split(","))//获取用户权限字符串
.map(SimpleGrantedAuthority::new)
.collect(Collectors.toList());//将元素转换为GrantedAuthority接口集合
Userprincipal=newUser(claims.getSubject(),"",authorities);
returnnewUsernamePasswordAuthenticationToken(principal,"",authorities);
}
//验证Token是否正确
publicbooleanvalidateToken(Stringtoken){
try{
Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token);//通过密钥验证Token
returntrue;
}catch(SignatureExceptione){//签名异常
log.info("InvalidJWTsignature.");
log.trace("InvalidJWTsignaturetrace:{}",e);
}catch(MalformedJwtExceptione){//JWT格式错误
log.info("InvalidJWTtoken.");
log.trace("InvalidJWTtokentrace:{}",e);
}catch(ExpiredJwtExceptione){//JWT过期
log.info("ExpiredJWTtoken.");
log.trace("ExpiredJWTtokentrace:{}",e);
}catch(UnsupportedJwtExceptione){//不支持该JWT
log.info("UnsupportedJWTtoken.");
log.trace("UnsupportedJWTtokentrace:{}",e);
}catch(IllegalArgumentExceptione){//参数错误异常
log.info("JWTtokencompactofhandlerareinvalid.");
log.trace("JWTtokencompactofhandlerareinvalidtrace:{}",e);
}
returnfalse;
}
}

实现UserDetails接口，代表用户实体类，在我们的User对象上在进行包装，包含了权限等性质，可以供SpringSecurity使用

publicclassMyUserDetailsimplementsUserDetails{
privateUseruser;
publicMyUserDetails(Useruser){
this.user=user;
}
@Override
publicCollectiongetAuthorities(){
Listroles=user.getRoles();
Listauthorities=newArrayList<>();
StringBuildersb=newStringBuilder();
if(roles.size()>=1){
for(Rolerole:roles){
authorities.add(newSimpleGrantedAuthority(role.getName()));
}
returnauthorities;
}
returnAuthorityUtils.commaSeparatedStringToAuthorityList("");
}
@Override
publicStringgetPassword(){
returnuser.getPassword();
}
@Override
publicStringgetUsername(){
returnuser.getName();
}
@Override
publicbooleanisAccountNonExpired(){
returntrue;
}
@Override
publicbooleanisAccountNonLocked(){
returntrue;
}
@Override
publicbooleanisCredentialsNonExpired(){
returntrue;
}
@Override
publicbooleanisEnabled(){
returntrue;
}
}

实现UserDetailsService接口，该接口仅有一个方法，用来获取UserDetails，我们可以从数据库中获取User对象，然后将其包装成UserDetails并返回

@Service
publicclassMyUserDetailsServiceimplementsUserDetailsService{
@Autowired
UserRepositoryuserRepository;
@Override
publicUserDetailsloadUserByUsername(Strings)throwsUsernameNotFoundException{
//从数据库中加载用户对象
Optionaluser=userRepository.findByName(s);
//调试用，如果值存在则输出下用户名与密码
user.ifPresent((value)->System.out.println("用户名:"+value.getName()+"用户密码："+value.getPassword()));
//若值不再则返回null
returnnewMyUserDetails(user.orElse(null));
}
}

编写过滤器，用户如果携带Token则获取Token，并根据Token生成Authentication认证对象，并存放到SecurityContext中，供SpringSecurity进行权限控制

publicclassJwtAuthenticationTokenFilterextendsGenericFilterBean{
privatefinalLoggerlog=LoggerFactory.getLogger(JwtAuthenticationTokenFilter.class);
@Autowired
privateJWTTokenUtilstokenProvider;
@Override
publicvoiddoFilter(ServletRequestservletRequest,ServletResponseservletResponse,FilterChainfilterChain)throwsIOException,ServletException{
System.out.println("JwtAuthenticationTokenFilter");
try{
HttpServletRequesthttpReq=(HttpServletRequest)servletRequest;
Stringjwt=resolveToken(httpReq);
if(StringUtils.hasText(jwt)&&this.tokenProvider.validateToken(jwt)){//验证JWT是否正确
Authenticationauthentication=this.tokenProvider.getAuthentication(jwt);//获取用户认证信息
SecurityContextHolder.getContext().setAuthentication(authentication);//将用户保存到SecurityContext
}
filterChain.doFilter(servletRequest,servletResponse);
}catch(ExpiredJwtExceptione){//JWT失效
log.info("Securityexceptionforuser{}-{}",
e.getClaims().getSubject(),e.getMessage());
log.trace("Securityexceptiontrace:{}",e);
((HttpServletResponse)servletResponse).setStatus(HttpServletResponse.SC_UNAUTHORIZED);
}
}
privateStringresolveToken(HttpServletRequestrequest){
StringbearerToken=request.getHeader(WebSecurityConfig.AUTHORIZATION_HEADER);//从HTTP头部获取TOKEN
if(StringUtils.hasText(bearerToken)&&bearerToken.startsWith("Bearer")){
returnbearerToken.substring(7,bearerToken.length());//返回Token字符串，去除Bearer
}
Stringjwt=request.getParameter(WebSecurityConfig.AUTHORIZATION_TOKEN);//从请求参数中获取TOKEN
if(StringUtils.hasText(jwt)){
returnjwt;
}
returnnull;
}
}

编写LoginController，用户通过用户名、密码访问/auth/login，通过LoginDTO对象接收，创建一个Authentication对象，代码中为UsernamePasswordAuthenticationToken，判断对象是否存在，通过AuthenticationManager的authenticate方法对认证对象进行验证，AuthenticationManager的实现类ProviderManager会通过AuthentionProvider（认证处理）进行验证，默认ProviderManager调用DaoAuthenticationProvider进行认证处理，DaoAuthenticationProvider中会通过UserDetailsService（认证信息来源）获取UserDetails，若认证成功则返回一个包含权限的Authention，然后通过SecurityContextHolder.getContext().setAuthentication()设置到SecurityContext中，根据Authentication生成Token，并返回给用户

@RestController
publicclassLoginController{
@Autowired
privateUserRepositoryuserRepository;
@Autowired
privateAuthenticationManagerauthenticationManager;
@Autowired
privateJWTTokenUtilsjwtTokenUtils;
@RequestMapping(value="/auth/login",method=RequestMethod.POST)
publicStringlogin(@ValidLoginDTOloginDTO,HttpServletResponsehttpResponse)throwsException{
//通过用户名和密码创建一个Authentication认证对象，实现类为UsernamePasswordAuthenticationToken
UsernamePasswordAuthenticationTokenauthenticationToken=newUsernamePasswordAuthenticationToken(loginDTO.getUsername(),loginDTO.getPassword());
//如果认证对象不为空
if(Objects.nonNull(authenticationToken)){
userRepository.findByName(authenticationToken.getPrincipal().toString())
.orElseThrow(()->newException("用户不存在"));
}
try{
//通过AuthenticationManager（默认实现为ProviderManager）的authenticate方法验证Authentication对象
Authenticationauthentication=authenticationManager.authenticate(authenticationToken);
//将Authentication绑定到SecurityContext
SecurityContextHolder.getContext().setAuthentication(authentication);
//生成Token
Stringtoken=jwtTokenUtils.createToken(authentication,false);
//将Token写入到Http头部
httpResponse.addHeader(WebSecurityConfig.AUTHORIZATION_HEADER,"Bearer"+token);
return"Bearer"+token;
}catch(BadCredentialsExceptionauthentication){
thrownewException("密码错误");
}
}
}

编写Security配置类，继承WebSecurityConfigurerAdapter，重写configure方法

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled=true)
publicclassWebSecurityConfigextendsWebSecurityConfigurerAdapter{
publicstaticfinalStringAUTHORIZATION_HEADER="Authorization";
publicstaticfinalStringAUTHORIZATION_TOKEN="access_token";
@Autowired
privateUserDetailsServiceuserDetailsService;
@Override
protectedvoidconfigure(AuthenticationManagerBuilderauth)throwsException{
auth
//自定义获取用户信息
.userDetailsService(userDetailsService)
//设置密码加密
.passwordEncoder(passwordEncoder());
}
@Override
protectedvoidconfigure(HttpSecurityhttp)throwsException{
//配置请求访问策略
http
//关闭CSRF、CORS
.cors().disable()
.csrf().disable()
//由于使用Token，所以不需要Session
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
//验证Http请求
.authorizeRequests()
//允许所有用户访问首页与登录
.antMatchers("/","/auth/login").permitAll()
//其它任何请求都要经过认证通过
.anyRequest().authenticated()
//用户页面需要用户权限
.antMatchers("/userpage").hasAnyRole("USER")
.and()
//设置登出
.logout().permitAll();
//添加JWTfilter在
http
.addFilterBefore(genericFilterBean(),UsernamePasswordAuthenticationFilter.class);
}
@Bean
publicPasswordEncoderpasswordEncoder(){
returnnewBCryptPasswordEncoder();
}
@Bean
publicGenericFilterBeangenericFilterBean(){
returnnewJwtAuthenticationTokenFilter();
}
}

编写用于测试的Controller

@RestController
publicclassUserController{
@PostMapping("/login")
publicStringlogin(){
return"login";
}
@GetMapping("/")
publicStringindex(){
return"hello";
}
@GetMapping("/userpage")
publicStringhttpApi(){
System.out.println(SecurityContextHolder.getContext().getAuthentication().getPrincipal());
return"userpage";
}
@GetMapping("/adminpage")
publicStringhttpSuite(){
return"userpage";
}
}

案例源码下载（本地下载）

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对毛票票的支持。

Spring Security结合JWT的方法教程

热门推荐

随机推荐