目录
抛砖引玉
登录
授权实践
RBAC权限控制
自定义失败处理
跨域问题的解决
源码
自定义权限校验
基于配置类配置资源权限
CSRF
登录成功以及失败自定义处理
注销处理
抛砖引玉
首先授权的话,我们可以在之前自定义JwtAuthenticationTokenFilter发现:
先回顾一下,利用JwtAuthenticationTokenFilter对请求进行token过滤,通过token得到的userid,然后作为键得到redis中的值,如果不为空说明已经登录可以访问,那么我要加权限,我们可以在Authentication用户信息的封装中+权限
package com.wyh.game.filter;
@Component
//一个基于Jwt认证的过滤器
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
@Autowired
private RedisCache redisCache;
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
//1.先获取token
String token = request.getHeader("token");
if(!StringUtils.hasText(token)){
//放行到下面过滤器
filterChain.doFilter(request,response);
//因为过滤,它有个返回,所以我们要return,不然返回流程会执行下面的流程
return;
}
//2.解析token得到userid
String userid;
try {
Claims claims = JwtUtil.parseJWT(token);
userid = claims.getSubject();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("token非法");
}
//然后从redis根据userid得到LoginUser用户信息
String redisKey="login:"+userid;
LoginUser loginUser = redisCache.getCacheObject(redisKey);
if(Objects.isNull(loginUser)){
throw new RuntimeException("用户未登录");
}
//将信息封装到SecurityContextHolder中
//需要先封装到Authentication中
UsernamePasswordAuthenticationToken authenticationToken =
new UsernamePasswordAuthenticationToken(loginUser, null, loginUser.getAuthorities());
SecurityContextHolder.getContext().setAuthentication(authenticationToken);
//放行
filterChain.doFilter(request,response);
}
}
问题来了,这个权限怎么加呢?
了解Security流程就知道,我们用户登录,利用的是AuthenticationManager调用authenticate()方法进行认证->参数为Authentication类型,封装用户名密码->进而得到Authentication
然后通过Authentication得到Principal转为LoginUser,因为authenticate()实际上是ProvideManager一个方法,只是说ProvideManager是AuthenticationManager实现类(而我们Security默认也是ProvideManager进行处理)——>这样处理的目的:将用户信息传给UserDetailService,通过loadByUsername()对用户名进行验证还有密码——>就这样一层层套娃得到Authentication
得到用户信息后,得到里面的userid进行jwt生成存入map集合中为token;
并且将LoginUser传入redis中;
所以最关键两点:LoginUser和Jwt过滤器
登录
@Override
public JsonResult Slogin(String username, String password) {
UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(username,password);
Authentication authenticate = authenticationManager.authenticate(authenticationToken);
if(Objects.isNull(authenticate)){
throw new RuntimeException("登录失败");
}
LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
String userid = loginUser.getUser().getId().toString();
String jwt = JwtUtil.createJWT(userid);
HashMap map = new HashMap<>();
map.put("token",jwt);
redisCache.setCacheObject("login:"+userid,loginUser);
return new JsonResult(200,"登录成功",map);
}
授权实践
这里要注意permissions:是我们要传入的权限,里面包含所有权限
注意:但是我们Security对于权限调用是利用的getAuthorities()这个方法 ,因为你实现了UserDetails,所以默认是这个——>我们利用这个方法将我们的权限permissions转为SimpleGrantedAuthority即可;
而这个方法权限参数用的GrantedAuthority类型,我们用它实现类SimpleGrantedAuthority,只需要传入权限即可;
注意:SimpleGrantedAuthority是不能被redis是别的,但是没有关系,在登录的时候,LoginUser里面是含有权限信息的也就是permissions;
当我们访问其他接口时间过Jwt过滤器——>会再次调用getAuthorities()方法,将permissions转为需要的类型权限;
package com.wyh.game.entity;
import com.alibaba.fastjson.annotation.JSONField;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
//用户认证
@Data
@NoArgsConstructor
@JsonIgnoreProperties(ignoreUnknown = true)
public class LoginUser implements UserDetails {
private User user;
//自定义用户权限,但是我们这里因为实现了接口,所以是调用接口的权限方法getAuthorities
private List permissions;
//SimpleGrantedAuthority不会被redis识别,所以需要忽略
@JSONField(serialize = false)
private List authorities;
public LoginUser(User user, List permissions) {
this.user = user;
this.permissions = permissions;
}
@Override
public Collection extends GrantedAuthority> getAuthorities() {
if(authorities!=null){
return authorities;
}
ArrayList authorities = new ArrayList();
for (String permission : permissions) {
SimpleGrantedAuthority authority = new SimpleGrantedAuthority(permission);
authorities.add(authority);
}
return authorities;
}
//获取密码
@Override
public String getPassword() {
return user.getPassword();
}
//获取用户名
@Override
public String getUsername() {
return user.getUsername();
}
@Override
public boolean isAccountNonExpired() {
return true;
}
@Override
public boolean isAccountNonLocked() {
return true;
}
@Override
public boolean isCredentialsNonExpired() {
return true;
}
@Override
public boolean isEnabled() {
return true;
}
}
Jwt过滤器中修改
核心就是:将LoginUser封装到UserNamePasswordAuthenticationToken中,我们还需要封装权限,调用loginUser的getAuthorities()——>这里会将permissions权限转换为所需类型
//1.先获取token
String token = request.getHeader("token");
if(!StringUtils.hasText(token)){
//放行到下面过滤器
filterChain.doFilter(request,response);
//因为过滤,它有个返回,所以我们要return,不然返回流程会执行下面的流程
return;
}
//2.解析token得到userid
String userid;
try {
Claims claims = JwtUtil.parseJWT(token);
userid = claims.getSubject();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("token非法");
}
//然后从redis根据userid得到LoginUser用户信息
String redisKey="login:"+userid;
LoginUser loginUser = redisCache.getCacheObject(redisKey);
if(Objects.isNull(loginUser)){
throw new RuntimeException("用户未登录");
}
//将信息封装到SecurityContextHolder中
//需要先封装到Authentication中
UsernamePasswordAuthenticationToken authenticationToken =
new UsernamePasswordAuthenticationToken(loginUser, null, loginUser.getAuthorities());
SecurityContextHolder.getContext().setAuthentication(authenticationToken);
//放行
filterChain.doFilter(request,response);
RBAC权限控制
我们利用数据库,创建角色表用户表以及权限表,然后联表查询得到权限信息
每个用户有自己的权限,但是可能一个用户含有多个权限,并且权限重复也是很有可能的
角色表
封装多个权限
因为多对多关系,我们还需要建立用户角色关联表还有角色权限管理表,里面每行为唯一——>绑定用户与角色关系+角色与权限关系;
根据权限表查询用户权限;
在Jwt过滤器中得到LoginUser中权限信息
自定义失败处理
由上分析可知:
1.认证或者授权出现异常会被ExceptionTranslationFilter捕捉到——>在ExceptionTranslationFilter中会去判断是认证失败还是授权失败,然后进行封装;
2.对于认证出现异常处理需要实现AuthenticationEntryPoint
3.对于授权处理异常需要实现AccessDeniedHandler
package com.wyh.game.handler;
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
@Override
public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
JsonResult
package com.wyh.game.handler;
public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
@Override
public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
JsonResult
4.然后需要配置异常处理器,因为需要被Security识别
package com.wyh.game.config;
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
private MyUserDetailServiceImpl userDetailService;
@Autowired
private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
@Autowired
private AuthenticationEntryPointImpl authenticationEntryPoint;
@Autowired
private AccessDeniedHandlerImpl accessDeniedHandler;
@Override
protected void configure(HttpSecurity http) throws Exception {
http //禁止跨站请求,解决POST403
.csrf().disable()
//不通过Session获取SecurityContext
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
//请求认证
.authorizeRequests()
//对登录接口运行匿名访问(携带token就不能访问了)
.antMatchers("/user/login").anonymous()
.antMatchers("/user/hello").permitAll()
//任意用户认证后可进行访问
.anyRequest().authenticated();
//在xx之前拦截
http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
//配置异常处理器
http.exceptionHandling()
//配置认证授权失败处理器
.authenticationEntryPoint(authenticationEntryPoint)
.accessDeniedHandler(accessDeniedHandler);
}
@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
//创建BCryptPasswordEncoder注入容器
@Bean
public PasswordEncoder encoder(){
return new BCryptPasswordEncoder();
}
// @Override
// protected void configure(AuthenticationManagerBuilder auth) throws Exception {
// auth.userDetailsService(userDetailService).passwordEncoder(encoder());
// }
}
认证失败:
授权失败:
跨域问题的解决
1.在SpringBoot中通过实现WebMvcConfigurer设置跨域请求
2.再在Security配置类中配置跨域允许,允许跨域访问
3.如果不开启跨域访问,那么你访问就会报错(注意:SpringBoot+Security跨域处理会请求两次处理,至于原因我也不晓得,先留着)
4.开启跨域访问,请求资源成功,后台进行响应,结果为这个token
5. 然后我们测试其他接口,看是否携带token
响应成功,请求头中携带了token
源码
1.先debug,登录之后访问其他接口,发现用户有两权限
2.然后封装LoginUser,与用户的权限(调用getAuthorities()方法,后面会说为啥一定要这个方法)——>封装到Authentication中,存入SecurityContextHolder
3.看controller中权限判断源码
4. 得到用户权限和接口所需要的权限,判断是否包含我们接口所需要的权限,true:访问成功
getRoleWithDefaultprefix():与前缀进行拼接
5 .这里的getAuthoritySet()非常关键:得到了LoginUser中的权限信息,也就是当前用户的权限信息
private SetgetAuthoritySet() { if (this.roles == null) { //可以看到这里返回的是GrantedAuthority类型——> //就正好与为什么LoginUser将权限信息封装Simplexxx进行呼应,这里Authentication调用的getAuthorities方法就是LoginUser里那个 Collection extends GrantedAuthority> userAuthorities = this.authentication.getAuthorities(); if (this.roleHierarchy != null) { userAuthorities = this.roleHierarchy.getReachableGrantedAuthorities(userAuthorities); } this.roles = AuthorityUtils.authorityListToSet(userAuthorities); } return this.roles; }
自定义权限校验
在@PreAuthorize里面自定义权限校验
package com.wyh.game.expression;
import com.wyh.game.entity.LoginUser;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import java.util.List;
@Component("ex")
public class SGExpressionRoot {
public boolean hasAuthority(String authority){
//1.获取当前用户的权限
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
LoginUser loginUser = (LoginUser) authentication.getPrincipal();
List permissions = loginUser.getPermissions();
//2.判断用户权限集合中是否含有authority
return permissions.contains(authority);
}
}
在SPEL表达式中使用@ex相当于获取容器bean的名字,然后再利用这个对象的hasAuthority方法即可;
基于配置类配置资源权限
package com.wyh.game.config;
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
private MyUserDetailServiceImpl userDetailService;
@Autowired
private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
@Autowired
private AuthenticationEntryPointImpl authenticationEntryPoint;
@Autowired
private AccessDeniedHandlerImpl accessDeniedHandler;
// @Autowired
// private DataSource dataSource;
//
// //配置对象
// @Bean
// public PersistentTokenRepository persistentTokenRepository(){
// JdbcTokenRepositoryImpl jdbcTokenRepository = new JdbcTokenRepositoryImpl();
// jdbcTokenRepository.setDataSource(dataSource);
// return jdbcTokenRepository;
// }
//
// @Override
// public void configure(WebSecurity web) throws Exception {
// web.ignoring().antMatchers("/Captcha
@Override
protected void configure(HttpSecurity http) throws Exception {
http //禁止跨站请求,解决POST403
.csrf().disable()
//不通过Session获取SecurityContext
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
//请求认证
.authorizeRequests()
//对登录接口运行匿名访问(携带token就不能访问了)
.antMatchers("/user/login").anonymous()
.antMatchers("/user/hello").permitAll()
.antMatchers("/user/ToEnd").hasAuthority("test02")
//任意用户认证后可进行访问
.anyRequest().authenticated();
//在xx之前拦截
http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
//配置异常处理器
http.exceptionHandling()
//配置认证授权失败处理器
.authenticationEntryPoint(authenticationEntryPoint)
.accessDeniedHandler(accessDeniedHandler);
//允许跨域
http.cors();
}
@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
//创建BCryptPasswordEncoder注入容器
@Bean
public PasswordEncoder encoder(){
return new BCryptPasswordEncoder();
}
// @Override
// protected void configure(AuthenticationManagerBuilder auth) throws Exception {
// auth.userDetailsService(userDetailService).passwordEncoder(encoder());
// }
}
CSRF
场景:一般用于前后端不分离项目的攻击,当用户浏览器进行请求,登录之后验证通过返回一个Cookie,里面有SessionId验证信息给到客户端,在没有登出A情况下,然后客户端登录b网站被诱导登录到了A网站,通过浏览器的Cookie——>A验证成功,从而达到B模拟用户的目的;
解决:前后端分离,像我们的Security,通过csrf_token的方式进行校验,你登录成功之后会给你创建一个token,客户端访问其他接口时必须要携带这个csrf_token,从而达到一个校验的功能;
就跟我们之前的token一样;
登录成功以及失败自定义处理
1. AbstractAuthenticationProcessingFilter是UsernamePasswordAuthenticationFilter的父类,里面定义了doFilter()方法;
认证成功后的处理:
这个successHandler就是AuthenticationSuccessHandler类
这里补充一下:之前访问其他接口时,之前的jwt过滤器走了之后,就直接跳过usernamePasswordFilter了,dochain其他过滤器,然后 走controller;
2.可以发现我们configure()方法默认配置了表单登录,里面有UsernamePasswordFilter过滤
3.自定义登录成功的处理
对父类的configure进行重写
3.2需要重写父类的方法,因为我们自定义是没有调用父类的;
认证成功处理器写法:
认证失败写法:
package com.wyh.game.handler;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
//认证成功处理器
public class SuccessHandler implements AuthenticationSuccessHandler {
@Override
public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
System.out.println("认证成功了");
}
}
然后再在SecurityConfig下配置,将认证失败处理器注入即可
注销处理
UsernamePasswordAuthenticationFilter是跟登录页面相关的,如果Security调用了formLogin()方法,就会默认将这两个红框内的过滤器注入容器中;
package com.wyh.game.handler;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.logout.LogoutHandler;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
//注销处理器
public class LoginOutHandler implements LogoutHandler {
@Override
public void logout(HttpServletRequest request, HttpServletResponse response, Authentication authentication) {
System.out.println("注销成功");
}
}
和上述一样的;
结束
UsernamePasswordAuthenticationFilter:是基于表单检验的,而且没有验证码啥的,要+的话我们可以利用AOP思想,动态代理在前面加一个Filter去处理;



