springSecurity自定义处理器基本配置

最新推荐文章于 2024-05-28 11:28:22 发布
最新推荐文章于 2024-05-28 11:28:22 发布
阅读量388 收藏 1
点赞数 1
分类专栏： 笔记 web安全 文章标签： java springSecurity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lc257/article/details/127914765
版权
加密方式
public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
}

获得一个加密后的密码存进数据库，用于第一次登录
在这里插入图片描述

设置一些角色

在这里插入图片描述

分配给这个用户系统管理员的角色

在这里插入图片描述

接着需要一个springSecurity能识别的用户类，即一个实体实现UserDetails接口
@Getter
@Setter
@ApiModel(value = "User对象", description = "")
@Builder
public class User implements UserDetails {
      @TableId(value = "id", type = IdType.AUTO)
      private Integer id;
      @ApiModelProperty("账号")
      private String account;
      private String password;
      @ApiModelProperty("姓名")
      private String name;
      @ApiModelProperty("是否禁用")
      private Boolean disable;
      @ApiModelProperty("邮箱")
      private String mail;
      private Set<String> roles;//用户一登陆会初始化这些参数
      @Override
      public Collection<? extends GrantedAuthority> getAuthorities() {
            return this.roles.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toSet());
      }
      @Override
      public String getUsername() {
            return this.account;
      }
      @Override
      public boolean isAccountNonExpired() {//账号是否没过期
            return true;
      }
      @Override
      public boolean isAccountNonLocked() {//账号是否没有被锁定
            return true;
      }
      @Override
      public boolean isCredentialsNonExpired() {//凭证是否没有过期
            return true;
      }
      @Override
      public boolean isEnabled() {//账号是否能用
            return !this.disable;
      }
}
然后需要一个Service类实现UserDetailsService接口，来重写方法，使SpringSecurity获得登陆人账号密码并校验的能力
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService, UserDetailsService {

    @Autowired
    UserMapper userMapper;
    @Autowired
    UserRoleMapper userRoleMapper;
    @Autowired
    RoleMapper roleMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        if (StringUtils.isBlank(username)) {//null,""," "都会返回true
            throw new BizException("用户名不能为空！");
        }
        User user = userMapper.selectOne(new LambdaQueryWrapper<User>()
                .select(User::getId, User::getAccount, User::getName, User::getPassword, User::getDisable, User::getMail)
                .eq(User::getAccount, username));
        if(Objects.isNull(user)){
            throw new BizException("用户名不存在");
        }
        return convertUserDetail(user);
    }

    private UserDetails convertUserDetail(User user) {//封装登录信息
        List<Object> objectList = userRoleMapper.selectObjs(new LambdaQueryWrapper<UserRole>().select(UserRole::getRoleId).eq(UserRole::getUserId,user.getId()));
        List<Object> roleNamesObject = roleMapper.selectObjs(new LambdaQueryWrapper<Role>().select(Role::getName).in(Role::getId, objectList));
        Set<String> roleNames = roleNamesObject.stream().map(Object::toString).collect(Collectors.toSet());
        user.setRoles(roleNames);
        return user;
    }
}

当前端调用登录接口时，就会调用loadUserByUsername方法，返回的UserDetails封装了用户的个人信息。

配置类
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private AuthenticationEntryPointImpl authenticationEntryPoint;//未登录处理
    @Autowired
    private AccessDeniedHandlerImpl accessDeniedHandler;//权限不足处理
    @Autowired
    private AuthenticationSuccessHandlerImpl authenticationSuccessHandler;//登录成功处理
    @Autowired
    private AuthenticationFailHandlerImpl authenticationFailHandler;//登录失败处理
    @Autowired
    private LogoutSuccessHandlerImpl logoutSuccessHandler;//登出成功处理
    @Bean
    public FilterInvocationSecurityMetadataSource securityMetadataSource() {
        return new FilterInvocationSecurityMetadataSourceImpl();//接口拦截规则
    }
    @Bean
    public AccessDecisionManager accessDecisionManager() {
        return new AccessDecisionManagerImpl();//访问决策管理器
    }
    @Bean
    public SessionRegistry sessionRegistry() {
        return new SessionRegistryImpl();
    }
    @Bean
    public HttpSessionEventPublisher httpSessionEventPublisher() {
        return new HttpSessionEventPublisher();
    }
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 配置登录注销路径
        http.formLogin()
                .loginProcessingUrl("/login")
                .successHandler(authenticationSuccessHandler)
                .failureHandler(authenticationFailHandler)
                .and()
                .logout()
                .logoutUrl("/logout")
                .logoutSuccessHandler(logoutSuccessHandler);
        // 配置路由权限信息
        http.authorizeRequests()
                .withObjectPostProcessor(new ObjectPostProcessor<FilterSecurityInterceptor>() {
                    @Override
                    public <O extends FilterSecurityInterceptor> O postProcess(O fsi) {
                        fsi.setSecurityMetadataSource(securityMetadataSource());//接口拦截规则
                        fsi.setAccessDecisionManager(accessDecisionManager());//访问决策管理器
                        return fsi;
                    }
                })
                .anyRequest()
                .permitAll()
                .and()
                // 关闭跨站请求防护
                .csrf().disable().exceptionHandling()
                // 未登录处理
                .authenticationEntryPoint(authenticationEntryPoint)
                // 权限不足处理
                .accessDeniedHandler(accessDeniedHandler)
                .and()
                .sessionManagement()
                .maximumSessions(20)
                .sessionRegistry(sessionRegistry());
    }
}
这里可以设置7个自定义的处理器：
/**
 * 接口拦截规则
 *
 * @author chengzige
 * @date 2022/11/19
 */
@Component
public class FilterInvocationSecurityMetadataSourceImpl implements FilterInvocationSecurityMetadataSource {

    /**
     * 资源角色列表
     */
    private static List<Operation> resourceRoleList;//静态

    @Autowired
    private OperationMapper operationMapper;

    /**
     * 加载资源角色信息
     */
    @PostConstruct
    private void loadDataSource() {
        resourceRoleList = operationMapper.listResourceRoles();//listResourceRoles已经排除了允许匿名的接口
    }

    /**
     * 清空接口角色信息
     */
    public void clearDataSource() {
        resourceRoleList = null;
    }

    @Override
    public Collection<ConfigAttribute> getAttributes(Object object) throws IllegalArgumentException {
        // 修改接口角色关系后重新加载
        if (CollectionUtils.isEmpty(resourceRoleList)) {
            this.loadDataSource();
        }
        FilterInvocation fi = (FilterInvocation) object;
        // 获取用户请求方式
        String method = fi.getRequest().getMethod();
        // 获取用户请求Url
        String url = fi.getRequest().getRequestURI();
        AntPathMatcher antPathMatcher = new AntPathMatcher();
        // 获取接口角色信息，若为匿名接口则放行，若无对应角色则禁止
        for (Operation operation : resourceRoleList) {
            if (antPathMatcher.match(operation.getUrl(), url) && operation.getRequestMethod().equals(method)) {
                List<String> roleList = operation.getRoles();
                if (CollectionUtils.isEmpty(roleList)) {
                    return SecurityConfig.createList("disable");
                }
                return SecurityConfig.createList(roleList.toArray(new String[]{}));
            }
        }
        return null;//return null就不会经过访问决策管理器了，即跳过AccessDecisionManagerImpl，放行
    }

    @Override
    public Collection<ConfigAttribute> getAllConfigAttributes() {
        return null;
    }

    @Override
    public boolean supports(Class<?> aClass) {
        return FilterInvocation.class.isAssignableFrom(aClass);
    }
}

/**
 * 访问决策管理器
 *
 * @author chengzige
 * @date 2022/11/19
 */
@Component
public class AccessDecisionManagerImpl implements AccessDecisionManager {
    @Override
    public void decide(Authentication authentication, Object o, Collection<ConfigAttribute> collection) throws AccessDeniedException, InsufficientAuthenticationException {
        // 获取用户拥有的角色列表
        List<String> permissionList = authentication.getAuthorities()
                .stream()
                .map(GrantedAuthority::getAuthority)
                .collect(Collectors.toList());
        for (ConfigAttribute item : collection) {//collection存储了访问应该具备的角色列表
            if (permissionList.contains(item.getAttribute())) {
                return;//有权限就直接return，
            }
        }
        throw new AccessDeniedException("没有操作权限");//没有权限就抛出异常
    }
    @Override
    public boolean supports(ConfigAttribute configAttribute) {
        return true;
    }
    @Override
    public boolean supports(Class<?> aClass) {
        return true;
    }
}

/**
 * 用户权限不足处理
 *
 * @author chengzige
 * @date 2022/11/19
 */
@Component
public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
    @Autowired
    ObjectMapper objectMapper;
    @Override
    public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AccessDeniedException e) throws IOException {
        httpServletResponse.setContentType("application/json;charset=utf-8");
        httpServletResponse.getWriter().write(objectMapper.writeValueAsString(Result.fail("权限不足")));
    }
}

/**
 * 用户未登录处理
 *
 * @author chengzige
 * @date 2022/11/19
 */
@Component
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
    @Autowired
    ObjectMapper objectMapper;
    @Override
    public void commence(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException {
        httpServletResponse.setContentType("application/json;charset=utf-8");
        httpServletResponse.getWriter().write(objectMapper.writeValueAsString(Result.fail("用户未登录")));
    }
}

/**
 * 登录失败处理
 *
 * @author chengzige
 * @date 2022/11/19
 */
@Component
public class AuthenticationFailHandlerImpl implements AuthenticationFailureHandler {
    @Autowired
    ObjectMapper objectMapper;
    @Override
    public void onAuthenticationFailure(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException {
        httpServletResponse.setContentType("application/json;charset=UTF-8");
        httpServletResponse.getWriter().write(objectMapper.writeValueAsString(Result.fail(e.getMessage())));
    }

}

/**
 * 登录成功处理
 *
 * @author chengzige
 * @date 2022/11/19
 */
@Component
public class AuthenticationSuccessHandlerImpl implements AuthenticationSuccessHandler {

    @Autowired
    ObjectMapper objectMapper;
    @Override
    public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException {
        // 返回登录信息

        httpServletResponse.setContentType("application/json;charset=UTF-8");
        httpServletResponse.getWriter().write(objectMapper.writeValueAsString(UserUtils.getLoginUser()));
    }
}

/**
 * 登出成功处理
 *
 * @author chengzige
 * @date 2022/11/19
 */
@Component
public class LogoutSuccessHandlerImpl implements LogoutSuccessHandler {

    @Autowired
    ObjectMapper objectMapper;
    @Override
    public void onLogoutSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException {
        httpServletResponse.setContentType("application/json;charset=UTF-8");
        httpServletResponse.getWriter().write(objectMapper.writeValueAsString(Result.ok()));
    }
}
配置之后swagger不会检查到login和logout接口，再定义一个处理器处理swagger文档
@Component
public class SwaggerHandler implements ApiListingScannerPlugin {
    @Override
    public List<ApiDescription> apply(DocumentationContext documentationContext) {
        //登录接口
        //1.定义参数
        Parameter username = new ParameterBuilder()
                .name("username")
                .description("用户名")
                .type(new TypeResolver().resolve(String.class))
                .modelRef(new ModelRef("string"))
                .parameterType("form")
                .required(true)
                .defaultValue("admin")
                .build();
        Parameter password = new ParameterBuilder()
                .name("password")
                .description("密码")
                .type(new TypeResolver().resolve(String.class))
                .modelRef(new ModelRef("string"))
                .parameterType("form")
                .required(true)
                .defaultValue("123456")
                .build();
        //2.接口的每种请求方式(GET/POST...)为一个 Operation
        Operation loginOperation = new OperationBuilder(new CachingOperationNameGenerator())
                .method(HttpMethod.POST)
                .summary("登录")
                .tags(Sets.newHashSet("用户模块"))
                .responseMessages(Sets.newHashSet(new ResponseMessageBuilder().code(200).message("OK").build()))
                .consumes(Sets.newHashSet(MediaType.MULTIPART_FORM_DATA_VALUE))
                .produces(Sets.newHashSet(MediaType.APPLICATION_JSON_VALUE))
                .parameters(Arrays.asList(username, password))
                .build();
        //3.每个接口路径对应一个 ApiDescription
        ApiDescription loginDesc = new ApiDescription(null, "/login", "登录", Collections.singletonList(loginOperation), false);

        //登出接口
        Operation logoutOperation = new OperationBuilder(new CachingOperationNameGenerator())
                .method(HttpMethod.GET)
                .summary("登出")
                .notes("退出登录")
                .tags(Sets.newHashSet("用户模块"))
                .responseMessages(Sets.newHashSet(new ResponseMessageBuilder().code(200).message("OK").build()))
                .build();
        ApiDescription logoutDesc = new ApiDescription(null, "/logout", "注销", Collections.singletonList(logoutOperation), false);

        documentationContext.getTags().add(new Tag("用户模块", "User Controller"));

        return new ArrayList<>(Arrays.asList(loginDesc, logoutDesc));
    }
    @Override
    public boolean supports(@NotNull DocumentationType documentationType) {
        return DocumentationType.SWAGGER_2.equals(documentationType);
    }

}
天外飞鲜橙子哥
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringSecurity自定义成功失败处理器的示例代码
09-07
通过以上步骤，我们就完成了Spring Security自定义登录成功处理器的配置。在`onAuthenticationSuccess`方法中，你可以添加任何需要的业务逻辑，如记录日志、发送通知、更新用户状态等。同样，你也可以自定义登录失败...
Spring Security自定义登录原理及实现详解
09-07
在本文中，我们将深入探讨Spring Security的自定义登录原理和实现，这对于理解和构建安全的Web应用程序至关重要。Spring Security是一个强大的安全框架，提供了丰富的功能来保护我们的应用程序，包括用户认证、授权...
Spring Security(4)：自定义配置
weixin_30407099的博客
06-03 242
接着上节的讲，在添加了@EnableWebSecurity注解后，如果需要自定义一些配置，则需要和继承WebSecurityConfigurerAdapter后，覆盖某些方法。 我们来看一下WebSecurityConfigurerAdapter中哪些方法可以重写，需要重写。 （1）WebSecurity 默认是一个空方法，一般也不会再重写。 public void confi...
SpringSecurity自定义 配置类
invincible_yj的博客
05-14 432
SpringSecurity自定义 配置类 在项目中有可能需要使用SpringSecurity来进行项目权限的管理，可以使用配置类的形式进行SpringSecutiry的配置 import com.example.demo.security.MyAuthenctiationFailureHandler; import com.example.demo.security.MyAuthenctiationSuccessHandler; import com.example.demo.security.MyUse
SecurityConfig配置
最新发布
ZYH_CKA的博客
05-28 719
【代码】SecurityConfig配置。
[自用留档]SpringSecurity配置
qq_61603262的博客
10-18 344
spring security配置
spring-security的简单配置
qq_43352316的博客
07-27 663
简单配置
SpringMVC处理器配置详解
hzl529的博客
11-19 289
HandlerMapping是处理器映射器 HandlerAdapter是处理器适配器 处理器就是Controller控制类 HandlerMapping：找到匹配的处理器（Controller），返回给中央处理器（DispatcherServlet） HandlerAdapter：执行HandlerMapping找到的处理器，将得到的结果（ModelAndView）返回给中央处理器（Dispat...
spring mvc 和spring security自定义登录
05-14
综上所述，结合Spring MVC和Spring Security实现自定义登录，需要理解两者的基本原理，配置合适的过滤器、认证提供者和授权规则。通过这种方式，我们可以创建一个既安全又易于维护的Web应用程序，为用户提供安全的...
spring security 项目配置源码
01-13
- 通过源码分析，了解Spring Security的拦截器如何工作，以及如何自定义安全规则。 - 查看`SecurityConfig`类，这是Spring Security的核心配置，它扩展了`WebSecurityConfigurerAdapter`并覆盖了一些关键方法。 -...
SpringSecurity权限控制实现原理解析
08-24
配置文件是指在 SpringSecurity 中使用的配置文件，例如 spring-security.xml，用于配置安全域、权限等信息。 SpringSecurity 中的权限控制机制包括以下几个方面： 1. 身份验证：身份验证是指确认用户的身份，...
Spring：后处理器（配置器）&零配置（注解）
燕双嘤
01-28 1894
1，两种后处理器 Spring框架提供了很好的扩展，除了可以与各种第三方框架良好整合外，其IoC容器也允许开发者进行扩展，这种扩展甚至无须实现BeanFactory或ApplicationContext接口，而是允许通过两个后处理器对IoC容器进行扩展。 Bean后处理器：这种后处理器会对容器中的Bean进行后处理，对Bean进行额外加强。 容器后处理器：这种后处理器对IoC容器进行后处理，用于增强容器功能。 Bean的生命周期：https://shao12138.blog.csdn.net/art
security配置
asscwf的博客
05-16 155
【代码】security配置。
SpringBoot2.6 + SpringSecurity 分离版
普通人一枚
03-10 2355
SpringBoot2.6+SpringSecurity（前后端分离版）
Springboot整合SpringSecurity实现登录认证和鉴权
weixin_44068320的博客
08-12 9764
springboot整合springsecurity实现用户登录认证和鉴权
Spring Security Java Config 浅析
carl.zhao的专栏
03-08 1066
在之前的项目中使用接触过 xml 配置使用 Spring Security。但是最近比较流行 java config。并且对它的 builder 模式比较感兴趣，就会查看了它的源码实现。下面就把自己的分析结果记录下来，希望对阅读这篇博客的你也有帮助。在 Spring Security 里面有两个非常重要的概念认证与授权。 - 认证：是确认某主体在某系统中是否合法、可用的过程。这里的主体既可以是登陆系统的用户也可以是接入 的设备或者其他系统 - 授权：是指当前主体通过认证之后，是否允许其执行某项操作的过程
SpringSecurity------Session Management（十二）
豢龙先生
06-21 2363
有时，总是创建会话是很有价值的，我们可以通过配置ForceEagerSessionCreationFilter来完成： 二、Detecting Timeouts 可以配置Spring Security来检测无效会话ID的提交，并将用户重定向到适当的URL，这是通过会话管理（session-management）实现的： 使用上面的配置来检测会话超时，如果用户在登出之后没有关闭浏览器的情况下重新登录，可能会报告一个错误。这是因为执行了登出，会话失效时存储在浏览器的Cookie不会被清除，而且会随着后续请求重新
Spring Security Config : HttpSecurity安全配置器 ExpressionUrlAuthorizationConfigurer
ywb201314的专栏
04-06 1270
这里每组RequestMatcher表示一组调用者想设定成相同权限控制的Http method/URL pattern,这里所设置的权限属性其实是基于SpEL的权限表达式。// 安全配置器指定一个安全表达式处理器 SecurityExpressionHandler，// 添加一组需要共同权限设置的 RequestMatcher,并对这组 RequestMatcher 设置相同的权限控制。
权限控制策略
m0_58466443的博客
02-17 479
50-52
springsecurity自定义登录处理
07-29
- *2* *3* [SpringSecurity自定义登录成功处理器](https://blog.csdn.net/weixin_46278059/article/details/128276544)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值