栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

SpringSecurity前后端分离02(授权)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

SpringSecurity前后端分离02(授权)

目录

抛砖引玉

登录

授权实践

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 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 result = new JsonResult<>(HttpStatus.UNAUTHORIZED.value(), "用户认证失败请查询登录");
        String json = JSON.toJSONString(result);
        //处理异常,进行响应
        WebUtils.renderString(response,json);
    }
}
 
package com.wyh.game.handler;


public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
        JsonResult result = new JsonResult<>(HttpStatus.FORBIDDEN.value(), "您的权限不足");
        String json = JSON.toJSONString(result);
        //处理异常
        WebUtils.renderString(response,json);
    }
}
 

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 Set getAuthoritySet() {
        if (this.roles == null) {
//可以看到这里返回的是GrantedAuthority类型——>
//就正好与为什么LoginUser将权限信息封装Simplexxx进行呼应,这里Authentication调用的getAuthorities方法就是LoginUser里那个
            Collection 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去处理;

 

转载请注明:文章转载自 www.mshxw.com
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号