微服务个人项目3--SpringSecurity认证鉴权全过程

Cunxing.Liu

已于 2023-09-16 20:32:36 修改

阅读量385

点赞数

文章标签：微服务架构云原生

于 2023-09-16 18:53:08 首次发布

本文链接：https://blog.csdn.net/m0_59113805/article/details/132917832

版权

这里使用SpringSecurity授权，因为其本身工作流程就是一套过滤器链，所以之前自定义的过滤器就不再使用

搭建过程是根据bili三更老师的视频来的。在个人项目加以改造

一。导入SpringSecurity依赖

后面存user信息到Redis中，这里把redis依赖也导入。使用redis需要导入commons-pools依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
            <version>3.0.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.3.12.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.11.0</version>
        </dependency>

此时启动项目访问任一接口，或swagger页面，会显示默认的登录页

Username：root Password：控制台输出

登录后才可跳转接口访问

二。SpringSecurity过滤流程

UsernamePasswordAuthenticationFilter:处理登录页面填写用户名密码后的登陆请求，上图的填写用户名密码就是由它拦截

ExceptionTranslationFilter：处理过滤器链中抛出的任何Auth/Access异常

FilterSecurityInterceptor：负责权限校验的过滤器

UsernamePasswordAuthenticationFilter过滤器执行流程

Authentication接口:它的实现类，表示当前访问系统的用户，封装了用户相关信息。AuthenticationManager接口:定义了认证Authentication的方法
UserDetailsService接口:加载用户特定数据的核心接口。里面定义了一个根据用户名查询用户信息的方法。
UserDetails接口:提供核心用户信息。通过UserDetailService根据用户名获取处理的用户信息要封装成UserDetails对象返回。然后将这些信息封装到Authentication对象中。

这里我们要将提交的用户名密码传给自定义的login接口，包括最后是从数据库查用户而不是内存，所以整个流程替换如下

登录
①自定义登录接口
调用ProviderManager的方法进行认证如果认证通过生成jwt
把用户信息存入redis中
②自定义UserDetailsService
在这个实现列中去查询数据库
校验:
①定义Jwt认证过滤器
获取token
解析token获取其中的userid从redis中获取用户信息

三。自定义MyUserDetailsServiceImpl继承UserDetailService，从数据库查用户返回UserDetail

package com.base.service.Impl;

/**
 * 自定义userDetails
 */

@Service
public class MyUserDetailsServiceImpl implements UserDetailsService {
    @Autowired
    private IUserService userService;
    @Autowired
    private IMenuService menuService;
    @Override
    public UserDetails loadUserByUsername(String name) throws UsernameNotFoundException {
        //查询用户信息        
        User user = userService.getUser(name);
        if(user == null){
            throw new UsernameNotFoundException("用户不存在");
        }
        //查询对应的权限信息
        //List<String> list = menuService.getMenuPerms(Long.valueOf(user.getId()));
        return new LoginUser(user);
    }


}

因为要返回的是UserDetails点进去发现是interface接口，所以定义一个实现类对象

LoginUser实现UserDetails封装User信息返回。

package com.base.filter;


@Data
@NoArgsConstructor
@JsonIgnoreProperties(ignoreUnknown = true)
public class LoginUser implements UserDetails {
    private User user;

    public LoginUser(User user){
        this.user = user;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return null}

    @Override
    public String getPassword() {
        return user.getPassword();
    }

    @Override
    public String getUsername() {
        return user.getName();
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

此时如果在默认用户名密码页输入数据库存在的用户名密码，正常应该可以验证通过，但后台报错

实际项目中我们不会把密码明文存储在数据库中。
默认使用的PasswordEncoder要求数据库中的密码格式为: {id})password。它会根据id去判断密码的加密方式。但是我们一般不会采用这种方式。所以就需要替换PasswordEncoder。
我们一般使用SpringSecurity为我们提供的BCryptPasswordEncoder。
我们只需要使用把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验。我们可以定义一个SpringSecurity的配置类，SpringSecurity要求这个配置类要继承WebSecurityConfigurerAdapter。

package com.base.config;


@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Bean
    BCryptPasswordEncoder bCryptPasswordEncoder(){
        return new BCryptPasswordEncoder();
    }

}

我们在注册向数据库保存用户密码时也要使用BCrypt加密

使用时直接注入就可以

@Autowired
private PasswordEncoder passwordEncoder;

四。登录接口实现

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
    @Autowired
    private PasswordEncoder passwordEncoder;
    @Autowired
    private AuthenticationManager authenticationManager;
    @Autowired
    private RedisUtils redisUtils;

    @Override
    public ResponseResult login(loginDto dto) {
        if (StringUtils.isNotBlank(dto.getTelNumber()) && StringUtils.isNotBlank(dto.getPassword())) {
            //首先进行Authenticate方法认证，根据过滤器流程，当调用该方法后，会向后调用                    
            //UserDetailService中的查询用户，并进行密码比对
            UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(dto.getName(),dto.getPassword());
            Authentication authenticate = authenticationManager.authenticate(authenticationToken);
            if(Objects.isNull(authenticate)){
                return ResponseResult.error("登陆失败");
            }
         //比对成功后会返回loginUser（UserDetail实现类）对象，里面封装了user的全部信息
            LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
            //认证通过生成jwt，并把用户信息存入redis
            Integer id = loginUser.getUser().getId();
            Map<String, String> claims = new HashMap<>();
            claims.put("userId", id.toString());
            claims.put("userName", loginUser.getUser().getName());
            String token = JwtUtils.createJwt(claims);
            String key = "userId:"+id;
            redisUtils.set(key,loginUser);
            Map<String, String> resMap = new HashMap<>();
            resMap.put("token", token);
            return ResponseResult.success("登录成功", resMap);
        }
        return ResponseResult.error("请输入验证信息");
    }

这里要对登录接口放行，以及从容器中获取使用AuthenticationManager，所以改写SecurityConfig，将AuthenticationManager以bean的形式注入到容器

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private MyUserDetailsServiceImpl myUserDetailsService;
    @Autowired
    private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;

    private static final String URL_WHITRLIST[] = {
            "/api/user/login", "/login", "/logout", "/css/**", "/js/**", "/index.html", "favicon.ico", "/doc.html",
            "/webjars/**", "/swagger-resources/**", "/v2/api-docs/**", "/swagger-ui.html", "configuration/ui","/api/user/getPerms"
    };
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(myUserDetailsService);
    }
    @Bean
    BCryptPasswordEncoder bCryptPasswordEncoder(){
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //开启跨域  以及csrf攻击 关闭
        http
        .cors()
        .and()
        .csrf()
        .disable()
        //session禁用
        .sessionManagement()
        .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
        //拦截规则
        .and()
        .authorizeRequests()
        .antMatchers(URL_WHITRLIST)
        .permitAll()
        .anyRequest()
        .authenticated();
        //添加过滤器
        http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
    }

    @Override
    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}

五。定义jwt过滤器

原理流程：我们要在请求进入（UserName过滤器）前进行jwt过滤，当是已登录状态，就不进行这里的过滤，将user信息通过redis查出存入SecurityHolder中，因为后面的过滤器如授权中取的信息都是从SecurityHolder中获取的。

最后在SecurityConfig中添加了该过滤器，表名其在UsernamePasswordAuthenticationFilter前生效
http.addFilterBefore(jwtAuthenticationTokenFilter,UsernamePasswordAuthenticationFilter.class);

这里没有直接继承Filter接口，而是使用OncePerRequestFilter，因为不同的Servlet版本可能导致一个请求过来，过滤器被多次调用（不理解，三更老师说的）

package com.base.filter;


@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
    @Autowired
    private RedisTemplate<String,Object> redisTemplate;
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        //获取token，因为在swagger中配置token存在名为Authorization的请求头中
        String token = request.getHeader("Authorization");
        if (!StringUtils.hasText(token)) {
            filterChain.doFilter(request, response);
            return;
        }
        //解析token
        String userId;
        try {
            Claims claims = JwtUtils.parseJwtToClaims(token);
            userId = (String) claims.get("userId");
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("token非法");
        }
        //从redis获取用户
        String redisKey = "userId:" + userId;
        LoginUser loginUser = (LoginUser) redisTemplate.opsForValue().get(redisKey);
        if(Objects.isNull(loginUser)){
            throw new RuntimeException("用户未登录");
        }
        //存入SecurityContextHolder
        UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(loginUser,null,null);
        //setAuthentication需要一个AuthenticationToken类型，所以上面new一个传入loginuser封装
        SecurityContextHolder.getContext().setAuthentication(authenticationToken);
        filterChain.doFilter(request,response);
    }
}

六。退出登录

在UserService中定义logout接口

退出登录通过SecurityContextHolder中获取userId 通过userId删除Redis存的值

注意：这里并不需要删除SecurityContextHolder的值，因为新的请求进来会重新走jwt过滤器

而此时redis已经获取不到值了，就会提示用户重新登录，不会运行底下的存入Se..Holder

@Override
    public ResponseResult logout() {
        //获取SecurityContextHolder信息中的id
        Authentication authentication = (UsernamePasswordAuthenticationToken)SecurityContextHolder.getContext().getAuthentication();
        LoginUser loginUser = (LoginUser) authentication.getPrincipal();
        Integer id = loginUser.getUser().getId();
        //删除redis的值
        redisUtils.delete("userId:"+id);
        return ResponseResult.success("注销成功");
    }

七。权限认证

在SpringSecurity中，会使用默认的FilterSecurityInterceptor来进行权限校验。在FilterSecurityInterceptor中会从SecurityContextHolder获取其中的Authentication，然后获取其中的权限信息。当前用户是否拥有访问当前资源所需的权限。所以我们在项目中只需要把当前登录用户的权限信息也存入Authentication。（也就是设置UserDetails的user对象时存入权限）

7.1首先在SecurityConfig开启权限

7.2在需要授权的接口添加PreAuthorize注解，只有hasAuthority(perm)中perm权限的可以访问接口

7.3在LoginUser(自定义的UserDetail)中添加permissions属性用于表示权限列表并重写getAuthorities()方法

public class LoginUser implements UserDetails {
    private User user;
    private List<String> permissions;
    public LoginUser(User user, List<String> permissions){
        this.user = user;
        this.permissions = permissions;
    }
//单例模式，每次调用getAuthorize方法时都会创建List<SimpleGrantedAuthority>，所以把他提到方法
//外面。只需创建一次，再次调用判断if（!=null）,就可以直接返回
    @JSONField(serialize = false)
    @JsonIgnore
    private  List<SimpleGrantedAuthority> authorities;
    @Override
//GrantedAuthority是个接口，要返回它的其中一个实现类SimpleGrantedAuthority，这个类中只
//要传入String类型的权限即可创建
    public Collection<? extends GrantedAuthority> getAuthorities() {
        if(authorities!=null){
            return authorities;
        }
        //把permissions中String类型的权限信息封装成SimpleGrantedAuthority对象
//        List<GrantedAuthority> authorities = new ArrayList<>();
//        for (String p: permissions) {
//            SimpleGrantedAuthority authority = new SimpleGrantedAuthority(p);
//            authorities.add(authority);
//        }
        authorities = permissions.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList());
        return authorities;
    }

注意：因为redis会存入整loginUser信息，而redis默认存储json要求是字符串。所以authorities在存入redis时会报错，但这里不需要存它，只需要permissions这个String列表就可以，所以加入JsonIgnore注解

7.4 在UserDetailService返回UserDetails（LoginUser）对象时将权限列表一起返回。

menuServie.getMenuPerms就是通过userId查出该user对应的menu(权限)列表

7.5最后再jwtFilter中将权限信息也封装进SecurityContextHolder中，因为权限过滤器时在最后，所以这里存入，当到达权限过滤器时会从SecurityContextHolder取出验证是否有权

八。拦截异常处理

到这里认证授权功能就完成了，当授权或用户密码等出现异常时，SpringSecurity会有自己的异常过滤器拦截并在控制台输出信息，但并不会以我们自定义的ResponseResult的Json字符串返回给前端，所以在全局异常中定义当密码错误和授权错误的拦截器

状态码使用SpringSecurity自带的枚举类HTTPSTATUS即可

@ControllerAdvice  //控制器增强类
@Slf4j
public class ExceptionCatch {
    @ExceptionHandler(AccessDeniedException.class)
    @ResponseBody
    public ResponseResult exception(AccessDeniedException e){
        e.printStackTrace();
        log.error("catch exception:{}",e.getMessage());
        return ResponseResult.success(HttpStatus.FORBIDDEN.value(),"您的权限不足");
    }
    @ExceptionHandler(BadCredentialsException.class)
    @ResponseBody
    public ResponseResult exception(BadCredentialsException e){
        e.printStackTrace();
        log.error("catch exception:{}",e.getMessage());
        return ResponseResult.success(HttpStatus.UNAUTHORIZED.value(),"用户信息验证失败，请重新登录");
    }
}

大功告成！！！

最后再次感谢三更老师的教学视频。要搞清楚SpringSecurity这些过滤器之间是如何调用，靠什么传递信息到下一个过滤器，就可以理解整个SpringSecurity的执行流程了。

更新！！！

目前的流程在用户输入密码，或者权限不足时都会抛出异常，所以直接使用全局异常捕获处理

但当用户没有登录也就是请求头中没有token时，过滤器内部会直接响应403，无法捕获（控制台未输出异常）也无法修改response内容。这好像是未登录时，security会触发AuthenticationEntryPoint（认证）响应403

重写AuthenticationEntryPoint

在SecurityConfig声明使用重写的未登录处理

@Component
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException e) throws IOException, ServletException {
            ResponseResult res = new ResponseResult<>(HttpStatus.UNAUTHORIZED.value(), "用户未登录");
            String json = JSON.toJSONString(res);
            WebUtils.renderString(response,json);
    }
}

http.exceptionHandling().authenticationEntryPoint(authenticationEntryPoint);