SpringSecutiry从入门到精通详解

最新推荐文章于 2024-04-29 15:10:45 发布
最新推荐文章于 2024-04-29 15:10:45 发布
阅读量1.4k 收藏 6
点赞数 2
分类专栏： SpringSecutiry 文章标签： java 后端 SpringSecutiry
吉首大学20级新生唐**
本文链接：https://blog.csdn.net/qq_50629351/article/details/127449417
版权

SpringSecutiry

SpringSecurity的流程示意图：

image-20221019164424442

Security的过滤链

image-20221019165618994

image-20221019172228843

AbstractAuthenticationProcessionFilter

image-20221019172056650

从前端传递token发送请求，可以定义一个Jwt认证过滤器

这个过滤器的作用：1. 获取token 2. 解析token 3. 获取userId 4.封装Authentication对象存入SecurityContextHolder

思路分析

登录

  1. 自定义登录接口 替换掉 抽象类AbstractAuthenticationProcessingFilter的实现类 AbstractAuthenticationProcessingFilter 去自定义一个实现类 然后通过调用ProviderManager的authenticate方法进行认证 ， 如果认证通过生成jwt 并且把用户信息存入redis中
  2. 自定义UserDetailService 在这个实现类中去数据库查询数据

校验:

  1. 定义jwt认证过滤器

    获取token

    解析token获取userId

    使用userId从redis中获取用户信息

    存入SecurityContextHolder

定义一个实现UserDetailsService接口的类来替换它 并从数据库中查询数据
@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //根据用户名查询用户信息
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(User::getUserName,username);
        User user = userMapper.selectOne(wrapper);
        //如果查询不到数据就通过抛出异常来给出提示
        if(Objects.isNull(user)){
            throw new RuntimeException("用户名或密码错误");
        }
        //TODO 根据用户查询权限信息 添加到LoginUser中
        
        //封装成UserDetails对象返回 
        return new LoginUser(user);
    }
}

因为UserDetailsService方法的返回值是UserDetails类型，所以需要定义一个类，实现该接口，把用户信息封装在其中。

@Data
@NoArgsConstructor
@AllArgsConstructor
public class LoginUser implements UserDetails {

    private User user;


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

    @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;
    }
}

image-20221020002732441

概念速查:

Authentication接口: 它的实现类，表示当前访问系统的用户，封装了用户相关信息。

AuthenticationManager接口：定义了认证Authentication的方法

UserDetailsService接口：加载用户特定数据的核心接口。里面定义了一个根据用户名查询用户信息的方法。

UserDetails接口：提供核心用户信息。通过UserDetailsService根据用户名获取处理的用户信息要封装成UserDetails对象返回。然后将这些信息封装到Authentication对象中。

​ 在接口中我们通过AuthenticationManager的authenticate方法来进行用户认证,所以需要在SecurityConfig中配置把AuthenticationManager注入容器。 （这样我们注入过后就能拿到实例 调用方法）

在我们调用 authenticationManager.authenticate()的时候需要一个 Authentication 接口参数 所以我们找到一个实现类来作为参数

我们可以查看实现类

image-20221020004552178

可以使用 UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(), user.getPassword());来作为参数 也就是说 AuthenticationManager authenticate 进行用户认证 这里调用实现类封装成 Authentication对象作为参数，而后

authenticationManager.authenticate(usernamePasswordAuthenticationToken); 这个会经过过滤器会去调用

UserDetailsService的loadUserByUsername 进行校验

以下可以根据 AuthenticationManager.authenticate 的返回值 Authentication authenticate 中的 getPrincipal 属性得出去调用了 UserDetailsServiceImpl implements UserDetailsService 这个接口实现类的login方法 以为可以看它的返回值 UserDetails 实则是我们用LoginUser实现了的

image-20221020010608880

认证过滤器

​ 我们需要自定义一个过滤器，这个过滤器会去获取请求头中的token，对token进行解析取出其中的userid。

​ 使用userid去redis中获取对应的LoginUser对象。

​ 然后封装Authentication对象存入SecurityContextHolder, 并且在过滤器链的FilterSecurityInterceptor中会去获取Authenticate对象判断对象是否已经认证。

@Component
// 继承 OncePerRequestFilter 只会执行这个过滤器一次 如果实现Filter可能会执行多次
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {

    @Autowired
    private RedisCache redisCache;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        //获取token
        String token = request.getHeader("token");
        if (!StringUtils.hasText(token)) {
            //放行  
            filterChain.doFilter(request, response);
            // 这里之所以return是因为当过滤器链执行了api然后响应的时候防止死循环调用
            return;
        }
        //解析token
        String userid;
        try {
            Claims claims = JwtUtil.parseJWT(token);
            userid = claims.getSubject();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("token非法");
        }
        //从redis中获取用户信息
        String redisKey = "login:" + userid;
        LoginUser loginUser = redisCache.getCacheObject(redisKey);
        if(Objects.isNull(loginUser)){
            throw new RuntimeException("用户未登录");
        }
        //存入SecurityContextHolder
        //TODO 获取权限信息封装到Authentication中
      // 这里UsernamePasswordAuthenticationToken的参数之所以有三个是因为调用的方法有一个已认证，在后面的过滤器就不需要认证
        UsernamePasswordAuthenticationToken authenticationToken =
                new UsernamePasswordAuthenticationToken(loginUser,null,null);
      
        SecurityContextHolder.getContext().setAuthentication(authenticationToken);
        //放行
        filterChain.doFilter(request, response);
    }
}

JwtAuthenticationTokenFilter 认证示意图：

image-20221020162612378

上面的代码我们只是添加了一个 JwtAuthenticationTokenFilter 并添加到Spring容器中了，但事实上 不会自动帮我们配置到SpringSecurity过滤器链中，所以我们需要自己来配置： 在SecurityConfig 中添加 http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {


    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

  

    @Autowired
    JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                //关闭csrf
                .csrf().disable()
                //不通过Session获取SecurityContext
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                // 对于登录接口 允许匿名访问
                .antMatchers("/user/login").anonymous()
                // 除上面外的所有请求全部需要鉴权认证
                .anyRequest().authenticated();

        //把token校验过滤器添加到过滤器链中
        http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
    }

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

当我们发送一个请求 未带token的请求

image-20221020170128190

它会进入到我们的 JwtAuthenticationTokenFilter 端点中

image-20221020170148594

这个请求我们没有带token ，那么它会返回403权限不足 即没有被认证

image-20221020170229776

可以看到报403

image-20221020170306353

即当我们携带token，那么会去redis中查询数据 并且会进行权限认证 并且将认证信息存入 SecurityContextHolder 中，但是这个SecurityContextHolder 是线程隔离的 并且只会在每次请求链中存在认证 ，当你下一次请求（即另外一次请求）它便会又重新进入 JwtAuthenticationTokenFilter 进行重新认证。

// 这里UsernamePasswordAuthenticationToken的参数之所以有三个是因为调用的方法有一个已认证，在后面的过滤器就不需要认证
  UsernamePasswordAuthenticationToken authenticationToken =
          new UsernamePasswordAuthenticationToken(loginUser,null,null);

  SecurityContextHolder.getContext().setAuthentication(authenticationToken);

退出登录

​ 我们只需要定义一个登陆接口，然后获取SecurityContextHolder中的认证信息，删除redis中对应的数据即可。

当我们删除了redis中的信息 ， 那么下次请求过来的时候会去Redis中查询用户信息，查询不到就会抛出用户未登录的异常。那么这样就实现了用户登录。

@PostMapping("logout")
public String logout(){
    Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
    LoginUser loginUser =    (LoginUser)authentication.getPrincipal();
    Long id = loginUser.getUser().getId();
    redisCache.deleteObject("login:" + id);
    return "logout successful";
}
认证配置参数
  @Override
  protected void configure(HttpSecurity http) throws Exception {
      http
              //关闭csrf
              .csrf().disable()
              //不通过Session获取SecurityContext
              .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
              .and()
              .authorizeRequests()
              // 对于登录接口 允许匿名访问 匿名就是有无token可以请求 有token就无法请求
              .antMatchers("/login").anonymous()
              // permitAll 是无论登录还是未登录都可以访问的
              .antMatchers("/hello").permitAll()
              // 除上面外的所有请求全部需要鉴权认证
              .anyRequest().authenticated();

// 手动配置 jwtAuthenticationTokenFilter 到过滤器链中
      http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
  }

3. 权限

​

3.1授权基本流程

​ 在SpringSecurity中，会使用默认的FilterSecurityInterceptor来进行权限校验。在FilterSecurityInterceptor中会从SecurityContextHolder获取其中的Authentication，然后获取其中的权限信息。当前用户是否拥有访问当前资源所需的权限。

​ 所以我们在项目中只需要把当前登录用户的权限信息也存入Authentication。

​ 然后设置我们的资源所需要的权限即可。

3.1.1使用注解的权限控制方案

在使用注解权限控制方案的时候我们需要先开启相关配置

@EnableGlobalMethodSecurity(prePostEnabled = true)

image-20221020194428751

当开启注解权限配置的时候我们便可以使用注解来进行权限控制了

@RestController
public class HelloController {

    @GetMapping("hello")
    @PreAuthorize("hasAnyAuthority('test')") // 表示该请求方法需要拥有test权限才能访问
    public String hello(){
        return "hello....";
    }
}
demo

在这里我让login匿名访问，于是在Security中配置了

// 对于登录接口 允许匿名访问 匿名就是有无token可以请求 有token就无法请求
.antMatchers("/login").anonymous()

①因此login请求可以跳过JwtAuthenticationTokenFilter 这一层过滤器 去执行 UserDetailsServiceImpl#loadUserByUsername方法，再次查询数据库 并且设置改用户的权限 ，具体代码如下：

@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    //根据用户名查询用户信息
    LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
    wrapper.eq(User::getUserName,username);
    User user = userMapper.selectOne(wrapper);
    //如果查询不到数据就通过抛出异常来给出提示
    if(Objects.isNull(user)){
        throw new RuntimeException("用户名或密码错误");
    }
    //TODO 根据用户查询权限信息 添加到LoginUser中  创建该用户权限集合
    List<String> list = new ArrayList<>(Arrays.asList("test","admin"));

    //封装成UserDetails对象返回 
    return new LoginUser(user,list);
}

②继而会执行我们正则的login登录方法 ，创建token并且存入到Redis中

 @Override
    public ResponseResult login(User user) {
//        AuthenticationManager  authenticate 进行用户认证   这里调用实现类封装成 Authentication对象
        UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
            Authentication authenticate = authenticationManager.authenticate(usernamePasswordAuthenticationToken);

        // authenticate 为空就是认证失败
        if (Objects.isNull(authenticate)){
            throw  new RuntimeException("登录失败");
        }
        // 如果认证通过了 使用userId生成一个jwt  jwt存入响应中
       LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
        String userId = loginUser.getUser().getId().toString();
        String jwt = JwtUtil.createJWT(userId);
        // 将信息存入redis userId 作为key
        redisCache.setCacheObject("login:"+userId,jwt);
        Map map = new HashMap();
        map.put("token",jwt);
        return  new ResponseResult(200,"登录成功",map);
    }

当我发送hello请求 并且 需要test权限流程

@RestController
public class HelloController {

    @GetMapping("hello")
    @PreAuthorize("hasAnyAuthority('test')")
    public String hello(){
        return "hello....";
    }
}

当请求发起的时候会经过jwt过滤链, 它首先会检验token 是否存在，如果存在就从redis中查询数据

并且封装权限信息new UsernamePasswordAuthenticationToken(loginUser,null,loginUser.getAuthorities()); 且封装到authenticationToken中 然后存储到 SecurityContextHolder中 SecurityContextHolder.getContext().setAuthentication(authenticationToken);

@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
    //获取token
    String token = request.getHeader("token");
    if (!StringUtils.hasText(token)) {
        //放行
        filterChain.doFilter(request, response);
        // 这里之所以return是因为当过滤器链执行了api然后响应的时候防止死循环调用
        return;
    }
    //解析token
    String userid;
    try {
        Claims claims = JwtUtil.parseJWT(token);
        userid = claims.getSubject();
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException("token非法");
    }
    //从redis中获取用户信息
    String redisKey = "login:" + userid;
    LoginUser loginUser = (LoginUser) redisCache.getCacheObject(redisKey);
    if(Objects.isNull(loginUser)){

        throw new RuntimeException("用户未登录");
    }
    //存入SecurityContextHolder
    //TODO 获取权限信息封装到Authentication中
  // 这里UsernamePasswordAuthenticationToken的参数之所以有三个是因为调用的方法有一个已认证，在后面的过滤器就不需要认证
    UsernamePasswordAuthenticationToken authenticationToken =
            new UsernamePasswordAuthenticationToken(loginUser,null,loginUser.getAuthorities());
  
    SecurityContextHolder.getContext().setAuthentication(authenticationToken);
    //放行
    filterChain.doFilter(request, response);
}

4.从数据库中查询权限信息

4.1 RBAC权限模型

image-20221020215702283

创建RBAC相关权限表：

image-20221021102245822

Sql语句如下：

SELECT 
    DISTINCT m.perms
FROM
         sys_user_role ur
         LEFT  JOIN sys_role r ON ur.`role_id` = r.`id` 
         LEFT JOIN  sys_role_menu rm ON ur.`role_id` = rm.`role_id`
         LEFT JOIN  sys_menu m ON m.id = rm.menu_id
        
         WHERE 
         user_id = 2
         AND r.`status` = 0
         AND m.status = 0

我们在登录的时候过滤链调用UserDetailsService的实现类 UserDetailsServiceImpl #loadUserByUsername中将用户的权限查询出来并封装到LoginUser中

@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    //根据用户名查询用户信息
    LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
    wrapper.eq(User::getUserName,username);
    User user = userMapper.selectOne(wrapper);
    //如果查询不到数据就通过抛出异常来给出提示
    if(Objects.isNull(user)){
        throw new RuntimeException("用户名或密码错误");
    }
    //TODO 根据用户查询权限信息 添加到LoginUser中  创建该用户权限集合
    List<String> Permislist = menuMapper.selectPermsByUserId(user.getId());
    List<String> list = new ArrayList<>(Permislist);

    //封装成UserDetails对象返回 
    return new LoginUser(user,list);
}

5.自定义失败处理

我们还希望在认证失败或者是授权失败的情况下也能和我们的接口一样返回相同结构的json，这样可以让前端能对响应进行统一的处理。要实现这个功能我们需要知道SpringSecurity的异常处理机制。

​ 在SpringSecurity中，如果我们在认证或者授权的过程中出现了异常会被ExceptionTranslationFilter捕获到。在ExceptionTranslationFilter中会去判断是认证失败还是授权失败出现的异常。

​ 如果是认证过程中出现的异常会被封装成AuthenticationException然后调用AuthenticationEntryPoint对象的方法去进行异常处理。

​ 如果是授权过程中出现的异常会被封装成AccessDeniedException然后调用AccessDeniedHandler对象的方法去进行异常处理。

​ 所以如果我们需要自定义异常处理，我们只需要自定义AuthenticationEntryPoint和AccessDeniedHandler然后配置给SpringSecurity即可。

/**
 * @Author Tang
 **/
 // 授权异常
public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AccessDeniedException e) throws IOException, ServletException {
                                 // Spring自带 HttpStatus
        ResponseResult result = new ResponseResult(HttpStatus.FORBIDDEN.value(), "权限不足");
        String json = JSON.toJSONString(result);
        WebUtils.renderString(httpServletResponse,json);
    }
}

// 认证
@Component
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        ResponseResult result = new ResponseResult(HttpStatus.UNAUTHORIZED.value(), "认证失败请重新登录");
        String json = JSON.toJSONString(result);
        WebUtils.renderString(response,json);
    }
}

手动配置异常到springSecurity中

// 因为需要一个AuthenticationManager 的 authenticate方法来认证 所以我们只需要注入就能拿来用
@Override
@Bean
public AuthenticationManager authenticationManagerBean() throws Exception {
    return super.authenticationManagerBean();
}

其它权限校验方法

​ 我们前面都是使用@PreAuthorize注解，然后在在其中使用的是hasAuthority方法进行校验。SpringSecurity还为我们提供了其它方法例如：hasAnyAuthority，hasRole，hasAnyRole等。

​ hasAuthority方法实际是执行到了SecurityExpressionRoot的hasAuthority，大家只要断点调试既可知道它内部的校验原理。

​ 它内部其实是调用authentication的getAuthorities方法获取用户的权限列表。然后判断我们存入的方法参数数据在权限列表中。

​ hasAnyAuthority方法可以传入多个权限，只有用户有其中任意一个权限都可以访问对应资源。

@PreAuthorize("hasAnyAuthority('admin','test','system:dept:list')")
    public String hello(){
        return "hello";
    }

​ hasRole要求有对应的角色才可以访问，但是它内部会把我们传入的参数拼接上 ROLE_ 后再去比较。所以这种情况下要用用户对应的权限也要有 ROLE_ 这个前缀才可以。

@PreAuthorize("hasRole('system:dept:list')")
public String hello(){
    return "hello";
}

image-20221021141635354

​ hasAnyRole 有任意的角色就可以访问。它内部也会把我们传入的参数拼接上 ROLE_ 后再去比较。所以这种情况下要用用户对应的权限也要有 ROLE_ 这个前缀才可以。

@PreAuthorize("hasAnyRole('admin','system:dept:list')")
public String hello(){
    return "hello";
}

自定义权限校验方法

​ 我们也可以定义自己的权限校验方法，在@PreAuthorize注解中使用我们的方法。

我们也可以定义自己的权限校验方法，在@PreAuthorize注解中使用我们的方法。

@Component("ex")
public class SGExpressionRoot {

    public boolean hasAuthority(String authority){
        //获取当前用户的权限
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        LoginUser loginUser = (LoginUser) authentication.getPrincipal();
        List<String> permissions = loginUser.getPermissions();
        //判断用户权限集合中是否存在authority
        return permissions.contains(authority);
    }
}

​ 在SPEL表达式中使用 @ex相当于获取容器中bean的名字未ex的对象。然后再调用这个对象的hasAuthority方法

@RequestMapping("/hello")
@PreAuthorize("@ex.hasAuthority('system:dept:list')")
public String hello(){
    return "hello";
}

​

当然我也可以使用基于配置的权限控制，我们在配置类中对资源进行控制

@Override
protected void configure(HttpSecurity http) throws Exception {
    http
            //关闭csrf
            .csrf().disable()
            //不通过Session获取SecurityContext
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and()
            .authorizeRequests()
            // 对于登录接口 允许匿名访问
            .antMatchers("/user/login").anonymous()
            .antMatchers("/testCors").hasAuthority("system:dept:list222")
            // 除上面外的所有请求全部需要鉴权认证
            .anyRequest().authenticated();

    //添加过滤器
    http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);

    //配置异常处理器
    http.exceptionHandling()
            //配置认证失败处理器
            .authenticationEntryPoint(authenticationEntryPoint)
            .accessDeniedHandler(accessDeniedHandler);

    //允许跨域
    http.cors();
}

认证成功处理器

​ 实际上在UsernamePasswordAuthenticationFilter进行登录认证的时候，如果登录成功了是会调用AuthenticationSuccessHandler的方法进行认证成功后的处理的。AuthenticationSuccessHandler就是登录成功处理器。

​ 我们也可以自己去自定义成功处理器进行成功后的相应处理。

@Component
public class SGSuccessHandler implements AuthenticationSuccessHandler {

  // 实现了抽象类  onAuthenticationSuccess 并自定义成功认证的逻辑
    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        System.out.println("认证成功了");
    }
}

将自定义认证成功处理器配置到SpringSecurity中去

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private AuthenticationSuccessHandler successHandler;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
      
      // 配置认证成功处理器为我们自定义的处理器
        http.formLogin().successHandler(successHandler);

        http.authorizeRequests().anyRequest().authenticated();
    }
}

JwtAuthenticationTokenFilter 过滤器没有登录成功、退出成功 也就是 UsernamePasswordAuthenticationFilter 这个过滤器了， 原因如下：

image-20221021163101509

当我们重写configure方法它会默认去调用父类的方法，而父类方法http.formLogin()则会去生成一个表单里面就有UsernamePasswordAuthenticationFilter ，在自定义的jwt过滤器链中 我们重写了configure方法 所以不会再有这个过滤器。

而使用认证成功处理器就必须要有这个表单，所以得重写父类的方法并且调用父类中的http.formLogin()方法 如下：

@Override
protected void configure(HttpSecurity http) throws Exception {
  
  // 配置认证成功处理器为我们自定义的处理器
    http.formLogin().successHandler(successHandler);
   // 配置 任意接口都需要认证才能访问 收到保护
    http.authorizeRequests().anyRequest().authenticated();
}
认证成功的处理器必须要使用formLogin（）的配置才能用，jwt过滤器的没有配置所以不能用认证成功处理器

同理，我们接下来配置认证失败处理器和登录成功处理器

认证失败处理器

​ 实际上在UsernamePasswordAuthenticationFilter进行登录认证的时候，如果认证失败了是会调用AuthenticationFailureHandler的方法进行认证失败后的处理的。AuthenticationFailureHandler就是登录失败处理器。

​ 我们也可以自己去自定义失败处理器进行失败后的相应处理。

@Component
public class SGFailureHandler implements AuthenticationFailureHandler {
    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
        System.out.println("认证失败了");
    }
}

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private AuthenticationSuccessHandler successHandler;

    @Autowired
    private AuthenticationFailureHandler failureHandler;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.formLogin()
//                配置认证成功处理器
                .successHandler(successHandler)
//                配置认证失败处理器
                .failureHandler(failureHandler);

        http.authorizeRequests().anyRequest().authenticated();
    }
}

登出成功处理器

@Component
public class SGLogoutSuccessHandler implements LogoutSuccessHandler {
    @Override
    public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        System.out.println("注销成功");
    }
}


@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private AuthenticationSuccessHandler successHandler;

    @Autowired
    private AuthenticationFailureHandler failureHandler;

    @Autowired
    private LogoutSuccessHandler logoutSuccessHandler;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.formLogin()
//                配置认证成功处理器
                .successHandler(successHandler)
//                配置认证失败处理器
                .failureHandler(failureHandler);

        http.logout()
                //配置注销成功处理器
                .logoutSuccessHandler(logoutSuccessHandler);

        http.authorizeRequests().anyRequest().authenticated();
    }
}

我们的方案

我们的认证方案：没有使用UsernamePasswordAuthenticationFilter去进行验证，直接使用ProviderManage调用authenticate方法进行认证，然后去调用实现了UserDetails接口 去从数据库中进行查询

云深n不知处
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Spring-从入门到精通.ppt
11-19
Spring框架详解 Spring是轻量级容器框架，提供了控制反转（IoC）和面向切面编程（AOP）的支持，用于软件开发提供全方位支持的应用程序框架。Spring框架的主要思想是控制反转和依赖注入，使用容器来管理对象之间的...
Python从入门到精通PPT详解
05-09
包含了python各方面的知识，从第一章到第八章，完整的PPT，适合自己学习，也可以当作教学PPT，内容丰富包括了案例
spring security 实现匿名访问接口
zhaosheng的博客
04-23 9087
就如同静态资源一样，我们不希望请求时需要认证，而是直接返回结果。 接下来我使用自定义注解完成匿名访问（以@AnonymousGetMapping举例） 第一步：我们需要写一个匿名访问的注解@AnonymousGetMapping，其中我们需要此注解也注解上@AnonymousAccess，保证在后续过程中获取匿名访问的url。 @AnonymousAccess @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documente
Spring Security 如何允许对同一地址进行匿名和身份验证访问
m13012606980的专栏
09-28 2526
场景描述 可能在开发过程中设置了一个匿名访问地址，但这个地址我们同时也想让它能够进行身份验证访问。就比如一个地址你把它分享出去就可以匿名访问，但如果这个地址如果没有被分享出去在系统内部或者在app中就可以进行身份验证访问。 遇到的问题 Spring Security 版本：4.1.0.RELEASE。现在版本到 5.5.2 为啥不用最新的，我只能说我也想。 Spring Security中默认对匿名访问的设置是如果你当前请求的地址为匿名访问设置，并且没有携带token的话，Spring Security会在
Spring Security（一）用户认证
最新发布
m0_74232531的博客
04-29 810
Spring Security
springsecurity详解
baidu_37366055的博客
11-23 9万+
1.springsecurity springsecurity底层实现为一条过滤器链，就是用户请求进来，判断有没有请求的权限，抛出异常，重定向跳转。 2.登录页 springsecurity自带一个登录页。 从登陆入手，登录页替换成我们自己的，对输入的账号密码进行验证 /** * 表单登陆security * 安全 = 认证 + 授权 */ @Configuration public class SecurityConfig extends WebSecurityConfigur
Spring Security进阶
IAHEAD的博客
06-15 349
Spring Security进阶一、配置可匿名访问的资源二、使用指定的登录页面1. 提供login.html作为项目的登录页2. 指定登录页面3. 配置表单登录信息4. 关闭CsrfFilter过滤器三、从数据库查询用户信息1. 定义UserService类，实现UserDetailsService接口2. 在spring-security.xml中配置认证管理四、对密码进行加密五、配置多种校验规则（对访问的页面做权限控制）六、注解方式权限控制（对访问的Controller类做权限控制）七、退出登录
Spring Security OAuth 匿名认证的使用
m13012606980的专栏
09-14 2973
Spring Security OAuth 匿名认证的使用AnonymousAuthenticationFilter配置匿名访问的资源路径自定义匿名访问注解自定义注解AnonymousAccess动态获取匿名访问路径获取@AnonymousAccess标注的接口为空问题反射获取@AnonymousAccess标注的接口 AnonymousAuthenticationFilter spring security 默认提供了一个匿名身份验证的过滤器AnonymousAuthenticationFilter，默认
SpringSecurity 笔记
爱折腾的技术人
10-25 1921
SpringSecurity 笔记...
Linux从入门到精通精华版详解.pdf
03-24
Linux从入门到精通精华版详解
Spring Security详细介绍使用
书启鸿蒙知秋枫
03-08 4465
Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方案。正如你可能知道的关于安全方面的两个核心功能是“
security登录流程
weixin_48100716的博客
12-15 1104
用户发起登陆请求AdminController,然后调用我们自己的登录业务实现类AdminServiceImpl的登录方法去处理,调用security框架的核心接口方法authenticate开始认证,他会自动去调用我们实现security框架的UserDetailsService接口的登录认证方法,若是认证成功则向前端返回JWT数据,注:AuthenticationManager(接口是认证的核心接口),也是认证的出发点.我们通过security框架认证登录信息,若登陆成功,最终返回的是JWT数据。
SpringSecurity学习笔记（一）
KO123789的博客
10-26 162
new UsernamePasswordAuthenticationToken(username, null , authorities); authorities是该用的权限标识。
springsecurity配置登录接口匿名访问无效，出现403Forbidden
weixin_42260782的博客
01-13 6631
在复习springsecurity的时候，出现一个奇怪的现象，登录接口已经设置为匿名访问了，但是通过postman测试的时候，出现了403禁止访问的情况 security配置类已经关闭了csrf，并且/user/login已经设置为匿名访问： 后来发现，原来是我入参写错了，传进来的User对象，实体类里面的用户名称是userName，而不是username， 改为userName,正常登录 但是数据库里面的用户名字段是user_name,这个不匹配，难道不会出现Unknown column 的错误吗
注解方式实现放行SpringSecurity匿名端口和遇到的坑
weixin_46630782的博客
04-26 721
利用下班时间搞了几天，总算把搞的差不多了（虽然原来还不是很熟，但能跑了）。整合到倒是挺简单的，就是对一些接口放行的时候总是有问题。网上的教程大多是版本之前的，而我为了尝鲜，技术基本都是用的最新的。这就导致走了很多坑 Σ( ￣д￣；！！因为博客就我一个人使用，就一个用户就够了，也不需要什么权限控制，就一切随简了。
怎么实现对登录用户访问权限的拦截
qq_49195366的博客
10-26 344
*** 自定义注解}
Spring Security：从入门到精通，全方位指南
weixin_44831330的博客
12-21 596
我们还希望在认证失败或者是授权失败的情况下也能和我们的接口一样返回相同结构的json，这样可以让前端能对响应进行统一的处理。要实现这个功能我们需要知道SpringSecurity的异常处理机制。在SpringSecurity中，如果我们在认证或者授权的过程中出现了异常会被ExceptionTranslationFilter捕获到。在ExceptionTranslationFilter中会去判断是认证失败还是授权失败出现的异常。
springboot中自定义过滤器
clonetx的博客
01-04 1004
过滤器是Servlet的规范，是基于函数回调的，需要实现javax.servlet.Filter接口，依赖于Tomcat等容器，一般用于过滤请求的URL。 1自定义过滤器 自定义filter的实现，本质上只有一种方式，就是实现Filter接口。但是在spring中我们有时候也会通过继承框架提供的XXXFilter，例如OncePerRequestFilter、 AbstractAuthenticationProcessingFilter（Spring Security使用...
spring security——基本介绍（一）
热门推荐
随笔记
01-16 40万+
一、spring security 简介 spring security 的核心功能主要包括： 认证 （你是谁） 授权 （你能干什么） 攻击防护 （防止伪造身份） 其核心就是一组过滤器链，项目启动后将会自动配置。最核心的就是 Basic Authentication Filter 用来认证用户的身份，一个在spring security中一种过滤器处理一种认证方式...
《MySQL-5.7从入门到精通》第18章-MySQL-Replication完整.pptx
11-14
《MySQL-5.7从入门到精通》第18章-MySQL-Replication完整.pptx

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值