Spring Security新版配置

已于 2022-06-05 01:16:26 修改
阅读量2.8k 收藏 9
点赞数 2
文章标签： spring 前端 java
于 2022-06-04 23:02:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/howeres/article/details/125126918
版权

配置

需要多少配置?

  1. UserDetailsService、UserDetailsPasswordService
  2. Filter (AbstractAuthenticationProcessingFilter)
    1. Paramter
    2. FilterProcessesUrl(“/login”)
    3. RememberMe
    4. AuthenticationManager
    5. AuthenticationSuccess/FailureHandler
  3. HttpSecurity
    1. authorizeRequests // antMathers / mvcMathers().permitAll() anyRequest.authenticated()
    2. formLogin()
    3. Logout()
    4. RememberMe // RememberMeService always paramter
    5. csrf() // csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse())); // 将令牌保存到 cookie 中（并允许前端获取）
    6. addFilterAt()
    7. exceptionHandling() // authenticationEntryPoint / accessDeniedHandler
    8. sessionManagement() // expiredSessionStrategy maximumSessions maxSessionsPreventsLogin
    9. authenticationManager
    10. authenticationProvider
  4. WebSecurityCustomizer // web.ignoring().antMatchers
  5. AuthenticationManagerBuilder.userDetailsService(xxService)
  6. @Autowired authenticationManagerBean()
package com.armin.security.config;

import com.armin.security.security.CaptchaAuthenticationProvider;
import com.armin.security.security.filter.CaptchaAuthenticationFilter;
import com.armin.security.service.CaptchaService;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.RegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.security.authentication.ProviderManager;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityCustomizer;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.security.web.csrf.CookieCsrfTokenRepository;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.CorsConfigurationSource;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;

import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

/**
 * Security 配置类
 *
 * @see <a href="https://felord.cn/captchaAuthenticationFilter.html">验证码登录</a>
 * @see <a href="https://felord.cn/authenticationConfiguration.html">其它登录不兼容，出现No Provider异常</a>
 * @author zy
 * @version 2022/5/26
 */
@Slf4j
@Configuration
@AllArgsConstructor
public class SecurityConfiguration {

    final CaptchaService captchaService;

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.antMatcher("/**") // 不同的 SecurityFilterChain 是互斥而且平等的，它们之间不是上下游关系。可通过 /api 区分
                .authorizeRequests(
                        authorize ->
                                authorize
                                        .antMatchers("/withdraw")
                                        .permitAll()
                                        // .hasAnyRole("ADMIN", "ACCOUNTANT")
                                        .anyRequest()
                                        .authenticated());
        http.formLogin().and().logout();
        // http.rememberMe()
        //         .rememberMeServices(null)
        //         .tokenRepository(new JdbcTokenRepositoryImpl(){{
        //             this.setDataSource(dataSource); // 得引入 jdbc
        //             setCreateTableOnStartup(true); // 启动时创建表结构
        //         }})
        //         .alwaysRemember(true)
        //         .rememberMeParameter("rememberMe");
        http.exceptionHandling(
                exception ->
                        exception
                                .authenticationEntryPoint(
                                        (req, res, auth) -> {
                                            res.setContentType(MediaType.APPLICATION_JSON_VALUE);
                                            res.setStatus(HttpStatus.UNAUTHORIZED.value());
                                            res.getWriter().println("请认证后处理！");
                                        })
                                .accessDeniedHandler(
                                        (req, res, auth) -> {
                                            res.setContentType(MediaType.APPLICATION_JSON_VALUE);
                                            res.setStatus(HttpServletResponse.SC_FORBIDDEN);
                                            res.getWriter().println("权限不足，请联系管理员!");
                                        }));

        http.addFilterBefore(loginFilter(), UsernamePasswordAuthenticationFilter.class);
        http.sessionManagement(
                session ->
                        session.maximumSessions(1)
                                .maxSessionsPreventsLogin(true)
                                .expiredSessionStrategy(
                                        event -> {
                                            HttpServletResponse response = event.getResponse();
                                            response.setContentType(
                                                    MediaType.APPLICATION_JSON_VALUE);
                                            String json =
                                                    "{\"success\":false,\"message\":\"SESSION_INVALID\",\"code\":401}";
                                            response.getWriter().println(json);
                                        }));
        // .sessionRegistry(sessionRegistry()) // session 共享
        http.csrf(
                csrf -> // 将令牌保存到cookie中（并允许前端获取）
                csrf.csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse()));
        // http.authenticationManager(
        //         new ProviderManager(Collections.singletonList(captchaAuthenticationProvider())));
        // http.authenticationProvider(); // 加入到当前 CustomAuthenticationManager 中，不推荐，应该在自定义 Filter
        // 中设置

        // cors security 解决方案
        http.cors().configurationSource(corsConfigurationSource());
        return http.build();
    }

    /**
     * 验证码认证过滤器.
     *
     * @return the captcha authentication filter
     */
    @Bean
    public AbstractAuthenticationProcessingFilter loginFilter() {
        // final LoginFilter loginFilter = new LoginFilter(); // 配置无关
        // loginFilter.setUsernameParameter("uname"); // 配置无关
        // loginFilter.setPasswordParameter("passwd"); // 配置无关
        final CaptchaAuthenticationFilter loginFilter =
                new CaptchaAuthenticationFilter(); // 配置 authenticationManager
        // loginFilter.setFilterProcessesUrl("/doLogin"); // 这里设置会进行顶替
        // loginFilter.setRememberMeServices(
        //         rememberMeServices()); // 前后端分离后，更改了获取方式后，存放也需要同步设置(2/2)
        // 指定认证管理器
        loginFilter.setAuthenticationManager(
                new ProviderManager(Collections.singletonList(captchaAuthenticationProvider())));
        // 指定成功时处理
        loginFilter.setAuthenticationSuccessHandler(
                (request, response, authentication) -> {
                    response.setContentType(MediaType.APPLICATION_JSON_VALUE);
                    response.setStatus(HttpStatus.OK.value());
                    Map<String, Object> data = new HashMap<>();
                    data.put("userInfo", authentication.getPrincipal());
                    data.put("msg", "登陆成功");
                    PrintWriter out = response.getWriter();
                    ObjectMapper objectMapper = new ObjectMapper();
                    out.write(objectMapper.writeValueAsString(data));
                    out.flush();
                    out.close();
                });
        // 指定失败时处理
        loginFilter.setAuthenticationFailureHandler(
                (request, response, exception) -> {
                    response.setContentType(MediaType.APPLICATION_JSON_VALUE);
                    Map<String, Object> data = new HashMap<>();
                    data.put("msg", "登陆失败：" + exception.getMessage());
                    response.setStatus(HttpStatus.UNAUTHORIZED.value());
                    PrintWriter out = response.getWriter();
                    ObjectMapper objectMapper = new ObjectMapper();
                    out.write(objectMapper.writeValueAsString(data));
                    out.flush();
                    out.close();
                });
        return loginFilter;
    }

    @Bean
    public WebSecurityCustomizer webSecurityCustomizer() {
        // 仅仅作为演示
        return (web) ->
                web.ignoring().antMatchers("/withdraw/info", "/withdraw/hello", "/captcha/**");
    }

    /**
     * 默认提供一个用户, 供登陆成功后展示. 注意该接口可能出现多态。所以最好加上注解 @Qualifier
     *
     * @return the user details service
     */
    @Bean(name = "captchaUserDetailsService")
    public UserDetailsService captchaUserDetailsService() {
        // 验证码登陆后密码无意义了但是需要填充一下
        return username ->
                User.withUsername(username)
                        .password("TEMP")
                        // todo  这里权限 你需要自己注入
                        .authorities(AuthorityUtils.createAuthorityList("ROLE_ADMIN", "ROLE_APP"))
                        .build();
    }

    /**
     * 验证码认证器.
     *
     * @return the captcha authentication provider
     */
    @Bean
    CaptchaAuthenticationProvider captchaAuthenticationProvider() {
        // 一个 Provider 需要配置一个 userDetailsService. 验证 service 这里使用到就放入
        return new CaptchaAuthenticationProvider(captchaUserDetailsService(), captchaService);
    }

    /**
     * 原有方式：得考虑优先级问题
     * 
     * @return Registration Bean
     */
    @Bean
    RegistrationBean corsFilter() {
        FilterRegistrationBean<CorsFilter> registrationBean = new FilterRegistrationBean<>();
        CorsConfiguration configuration = new CorsConfiguration();
        configuration.setAllowedHeaders(Collections.singletonList("*"));
        configuration.setAllowedMethods(Collections.singletonList("*"));
        configuration.setAllowedOrigins(Collections.singletonList("*"));
        configuration.setMaxAge(3600L);
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", configuration);
        registrationBean.setFilter(new CorsFilter(source));
        registrationBean.setOrder(-1);
        return registrationBean;
    }

    /**
     * 新方式：加入security中的corsFilter
     * 得调用 http.cors().configurationSource(corsConfigurationSource());
     * 
     * @return Registration Bean
     */
    CorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration configuration = new CorsConfiguration();
        configuration.setAllowedHeaders(Collections.singletonList("*"));
        configuration.setAllowedMethods(Collections.singletonList("*"));
        configuration.setAllowedOrigins(Collections.singletonList("*"));
        configuration.setMaxAge(3600L);
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", configuration);
        return source;
    }
}

模仿 Filter

package com.armin.security.security.filter;

import com.armin.security.security.CaptchaAuthenticationToken;
import org.springframework.lang.Nullable;
import org.springframework.security.authentication.AuthenticationServiceException;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 模仿 UsernamePasswordAuthenticationFilter 100% 还原度
 *
 * @author armin
 */
public class CaptchaAuthenticationFilter extends AbstractAuthenticationProcessingFilter {

    public static final String SPRING_SECURITY_FORM_PHONE_KEY = "phone";
    public static final String SPRING_SECURITY_FORM_CAPTCHA_KEY = "captcha";
    private static final AntPathRequestMatcher DEFAULT_ANT_PATH_REQUEST_MATCHER =
            new AntPathRequestMatcher("/captchaLogin", "POST");

    public CaptchaAuthenticationFilter() {
        super(DEFAULT_ANT_PATH_REQUEST_MATCHER);
    }

    public Authentication attemptAuthentication(
            HttpServletRequest request, HttpServletResponse response)
            throws AuthenticationException {
        if (!request.getMethod().equals("POST")) {
            throw new AuthenticationServiceException(
                    "Authentication method not supported: " + request.getMethod());
        }
        String phone = obtainPhone(request);
        phone = (phone != null) ? phone : "";
        phone = phone.trim();
        String captcha = obtainCaptcha(request);
        captcha = (captcha != null) ? captcha : "";
        CaptchaAuthenticationToken authRequest = new CaptchaAuthenticationToken(phone, captcha);
        // Allow subclasses to set the "details" property
        setDetails(request, authRequest);
        return this.getAuthenticationManager().authenticate(authRequest);
    }

    @Nullable
    protected String obtainCaptcha(HttpServletRequest request) {
        return request.getParameter(SPRING_SECURITY_FORM_CAPTCHA_KEY);
    }

    @Nullable
    protected String obtainPhone(HttpServletRequest request) {
        return request.getParameter(SPRING_SECURITY_FORM_PHONE_KEY);
    }

    protected void setDetails(HttpServletRequest request, CaptchaAuthenticationToken authRequest) {
        authRequest.setDetails(authenticationDetailsSource.buildDetails(request));
    }
}
howeres
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Spring Security基本配置方法解析
08-25
在Security配置中，我们需要使用@Configuration和@EnableWebSecurity注解来启用Web安全功能，然后我们可以在SecurityConfig类中配置身份验证和授权规则。 Spring Security提供了多种身份验证方式，例如...
详解Spring Security 简单配置
08-30
在本篇文章中，我们详细介绍了 Spring Security 的简单配置，包括开发环境、配置 Spring MVC + Spring Security、spring-mvc-servlet.xml 配置和 Spring Security 配置。通过这些配置，我们可以实现基本的安全功能，...
Spring Security 新版本配置
weixin_46073538的博客
06-30 3469
Springsecurity最新版配置
Spring Boot整合新版Spring Security：Lambda表达式配置优雅安全
学IT，找陈寒
02-06 4889
在实际项目中，我们通常需要实现自定义的身份验证逻辑。通过lambda表达式，我们可以更清晰地定义自己的和。@Autowired@Override@Overridehttp.and().and().logout()@Bean@Bean在上述配置中，我们注入了一个自定义的，并通过lambda表达式配置了。这样我们可以更灵活地定义用户信息的获取和身份验证逻辑。
SpringBoot最新版本Security配置(2023年)，亲测成功
ns3405453840的博客
05-12 3147
application.properties SecurityConfig: 配置默认登录用户(即用数据库的用户和密码登录)： 1:UserDetailsServiceImpl 2：UserDetailsImpl: 3:配置完，记得更改SecurityConfig配置,添加前端密码加密验证， 这里就可以使用security自带登录对数据库信息进行验证登录了通过该工具类根据用户id生成jwt
springsecurity配置
qq_41820986的博客
08-15 258
yml配置 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> 新建一个SecurityConfig配置类 import org.springframework
别再用过时的方式了！全新版本Spring Security，这样用才够优雅！
BASK2312的博客
12-21 784
Spring Security的升级用法确实够优雅，够简单，而且对之前用法的兼容性也比较好！个人感觉一个成熟的框架不太会在升级过程中大改用法，即使改了也会对之前的用法做兼容，所以对于绝大多数框架来说旧版本会用，新版本照样会用！
详解spring security 配置多个AuthenticationProvider
08-30
Spring Security 配置多个 AuthenticationProvider 详解 Spring Security 是一个功能强大且灵活的安全框架，提供了多种身份验证机制和访问控制机制。在实际开发中，我们经常需要配置多个身份验证提供程序...
详解springSecurity之java配置篇
08-18
Spring Security 之 Java 配置篇 Spring Security 是一个功能强大且灵活的安全框架，用于保护基于 Java 的 Web 应用程序。Spring Security 的 Java 配置是指使用 Java 代码来配置 Spring Security，以便更好地控制...
Spring Security XML配置模板.docx
最新发布
07-05
Spring Security XML配置模板
关于spring security没有调用UserDetailsService接口实现类的解决办法
m0_52459437的博客
03-15 518
过程太心酸，也没有报错，security只是拒绝了请求，真是脑袋大，debug了一天，也没看出来哪里出问题了，最后一行一行的看代码找了出来，多了一个重载方法的重写，没有删除，之前以为删除函数内容就行了，却耽搁了一天的时间。把第一个空方法删除就行了。
UserDetails类中loaduserByUsername中获取不到用户名
qq164425443的博客
05-15 2971
使用Spring Security框架中的UserDetails类方法要注意的事项 最近在新项目中使用了SpringSecurity中的UserDetails类中loaduserbyUsername方法，在数据库和对应的映射文件中username字段使用的account代替，json中的登录接口账号也是 { "account":xxx, "password":xxx } 的方式，后来发现在验证token的时候，获取不到username， 原来loadUserByUsername方法调用后，获取到的用户信息
springSecurity双模认证
xiejx618的专栏
06-16 1187
这里的双模意思是同时支持基于客户端证书和表单登录的认证.大概思路,如果用户提供了客户端证书,优先认证客户端证书,如果认证失败就跳转到基于表单的认证.1.tomcat或jetty开启客户端认证配置可以看前面的文章.可能要调节客户端认证参数,如tomcat应将clientAuth设为want, 2.配置:package com.berchina.uums.config;import org.sprin
Spring Security 5.7 最新配置细节（直接就能用），WebSecurityConfigurerAdapter 已废弃
江帅帅
06-06 3万+
Spring Security 5.7.1 最新配置细节，WebSecurityConfigurerAdapter 已废弃
Spring Security（新版本）实现权限认证与授权
热门推荐
weixin_46073538的博客
02-02 3万+
Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方案。正如你可能知道的关于安全方面的两个核心功能是认证和授权，一般来说，Web 应用的安全性包括**用户认证（Authentication）和用户授权（Authorization）**两个部分，这两点也是 SpringSecurity 重要核心功能。
新版 Spring Security 配置的变化
在计算机领域混战了5年的java开发工程师，正在向全栈奋斗的路上。目前在学习和分享：Java，springboot，spring，vue，系统开发，服务器运维（可做毕业设计）等相关知识。
04-10 4996
现在过滤器链的配置，我们通过提供一个 SecurityFilterChain Bean 来配置过滤器链，SecurityFilterChain 是一个接口，这个接口只有一个实现类 DefaultSecurityFilterChain，构建 DefaultSecurityFilterChain 的第一个参数是拦截规则，也就是哪些路径需要拦截，第二个参数则是过滤器链，这里我给了一个空集合，也就是我们的 Spring Security 会拦截下所有的请求，然后在一个空集合中走一圈就结束了，相当于不拦截任何请求。
Spring boot 2.7.3 配置用户认证
m0_52325708的博客
08-28 947
由于现在Spring Security 废除了WebSecurityConfigurerAdapter接口，导致之前的AuthenticationManagerBuilder来配置用户认证的方法被不推荐使用了，新版本需要通过自动装配的 UserDetailsService类来实现。值得注意的是，现在在users中的passwordEncoder方法需要的是一个encode方法而不是整个对象，从源码中得到的信息。不配置的话spring boot使用默认的密码编码器，而你的用户中使用的却是BCrypt编码器。.
Spring Security的基本使用及注意事项
weixin_53294082的博客
11-05 429
Spring Security是Spring家族中的权限验证框架，主要可用于后台系统的认证与授权。
新版spring security6配置
07-13
对于Spring Security 6，以下是一个基本的配置示例： 1. 添加Spring Security依赖： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-security ``` 2. 创建一个配置类，继承自`...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值