spring-cloud2023/spring-boot3.x接入spring-security

已于 2024-11-26 16:14:25 修改
阅读量1.2k 收藏 27
点赞数 16
分类专栏： 微服务 springboot java 文章标签： spring cloud spring boot spring security spring java
于 2024-11-26 04:47:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mzjmc123/article/details/144043352
版权

好家伙,好久没用spring-security 今天接起来差点都不认识了，在最新的版本中变化还是蛮大的 在这里记录一下

关于接口文档请看我Spring-boot3.4最新版整合swagger和Mybatis-plus
我是在cloud中使用的,做了路由转发,所以有个auth的前缀 其实和在spring boot中使用时一样的 下面是版本信息
spring cloudspring cloud alibabaspring bootspring securityjdk
2023.0.12023.0.1.03.2.46.2.317

现在开发基本上都是前后端分离,网上的教程也都是基于表单登录的,今天给大家讲解一下禁用表单如何登录的逻辑，我们也返回个token给前端，今天时间有限只做怎么用spring-security 给认证登录，并处理一下各种奇怪的异常，授权抽空我们再给做上

1.怎么使用呢?我们直接开始

  • 像开发简单的web项目一样创建controller,service,serviceImpl

controller

@Tag(name = "用户服务")
@RestController
@RequestMapping("/account")
@RequiredArgsConstructor
public class AccountController {

   private final UsersService usersService;

   /**
    * 登录
    * @param request
    * @return
    */
   @Operation(summary = "登录")
   @PostMapping("/login")
   public Result<String> login(@RequestBody UserRequest request){
       return Result.success(usersService.login(request));
   }
}

service和serviceimpl

public interface UsersService extends IService<Users> {
    /**
     * 登录接口
     * @param request
     * @return
     */
    String login(UserRequest request);

}

@Service
@RequiredArgsConstructor
public class UsersServiceImpl extends ServiceImpl<UsersMapper, Users>implements UsersService{
	
	public String login(UserRequest request) {
        String userName = request.getUserName();
        String password = request.getPassword();
        //在这里登录成功生成token这是我们最简单的做法
        return token;
    }




}

上面这是我们最简单的做法那用security 该怎么实现呢?也很简单我们只需要加入AuthenticationManager 就可以实现security 的登录认证了,修改后的代码如下:

@Service
@RequiredArgsConstructor
public class UsersServiceImpl extends ServiceImpl<UsersMapper, Users>
    implements UsersService{
	
	//注入AuthenticationManager
    private final AuthenticationManager authenticationManager;

    /**
     * 登录接口
     *
     * @param request
     * @return
     */
    @Override
    public String login(UserRequest request) {
        String userName = request.getUserName();
        String password = request.getPassword();
        UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(userName, password);
        authenticationManager.authenticate(authenticationToken);
        return "success";
    }

现在解释一下为什么这么写 以及 UsernamePasswordAuthenticationToken是干什么用的,通俗的讲就一句话: 根据用户名和密码生成一个身份认证令牌,然后在把令牌传到 AuthenticationManager 进行验证,也就是我们上面写的代码,它其实是个接口，我们看到有5个实现类,springsecurity会提供许多AuthenticationProvider，而ProviderManager这个类就处理这些AuthenticationProvider，

在这里插入图片描述
在这里插入图片描述

在容器启动时，springsecurity已经初始化了一些provider，其中就有DaoAuthenticationProvider，其主要是用户名和密码验证的，DaoAuthenticationProvider又继承了AbstractUserDetailsAuthenticationProvider抽象类,在这个抽象类中又干了:
  • 调用实现类的DaoAuthenticationProvider的retrieveUser，获取到保存在内存中的用户信息，如密码，账号状态等
  • 判断用户状态是否有效
  • 获取的密码跟提交过来的密码是否一致
太麻烦了… 要解释起来说一天都说不完上面的这些逻辑一直走最终会走到大家非常熟悉的一个类UserDetailsService的loadUserByUsername方法,直接写代码，源码大家有时间自己去研究吧,我们直接实现这个方法

2. 实现UserDetailsService

@Service
@RequiredArgsConstructor
public class CustomUserDetailsServiceImpl implements UserDetailsService {

    private final UsersMapper usersMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
		//这里是查询数据库中信息
        Users users = usersMapper.loadUserByUsername(username);
        if (users == null) {
            throw new UsernameNotFoundException("用户不存在");
        }
		//在这里查询权限角色信息/比如后台的动态菜单等等
        return new org.springframework.security.core.userdetails.User(
                users.getUserName(),
                users.getPassword(),
                AuthorityUtils.createAuthorityList("ROLE_USER")
        );
    }
}

就这么简单，然后这中间会有各种异常比如上面的UsernameNotFoundException我们只需要定义一个handler 来处理就好了

哈哈哈是不是饶了,其实前面的都没鸟用,只是给大家说下上面的这种做法适合开启表单登录的逻辑，真正的禁用表单连controller都不需要登录根本不会走到这里来,只是让大家理解一下逻辑，开始我们今天的正文,自定义登录过滤器

3.自定义登录过滤器

3.1登录认证过滤器
@Component
@RequiredArgsConstructor
public class LoginAuthenticationFilter extends OncePerRequestFilter {

    private final AuthenticationManager authenticationManager;

    private final AuthenticationSuccessHandler successHandler;

    private final AuthenticationFailureHandler failureHandler;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
            //这个就是登录的地址/account/login
        if ("/account/login".equals(request.getRequestURI()) && "POST".equalsIgnoreCase(request.getMethod())) {
            try {
                // 解析 JSON 格式的请求体
                StringBuilder requestBody = new StringBuilder();
                try (BufferedReader reader = request.getReader()) {
                    String line;
                    while ((line = reader.readLine()) != null) {
                        requestBody.append(line);
                    }
                }
                Map bean = JSONUtil.toBean(requestBody.toString(), Map.class);
                String username = (String) bean.get("username");
                String password = (String) bean.get("password");

                if (username == null || password == null) {
                    throw new AuthenticationServiceException("Username or password is missing");
                }

                // 创建认证请求
                UsernamePasswordAuthenticationToken authRequest =
                        new UsernamePasswordAuthenticationToken(username, password);

                // 执行认证
                Authentication authentication = authenticationManager.authenticate(authRequest);

                // 登录成功处理
                successHandler.onAuthenticationSuccess(request, response, authentication);
            } catch (AuthenticationException e) {
                // 登录失败处理
                failureHandler.onAuthenticationFailure(request, response, e);
            }
            return; // 终止过滤链
        }

        // 继续其他过滤器
        filterChain.doFilter(request, response);
    }

}
3.2 登录认证失败处理器
**
- @package com.aihe.customer.auth.handler
- @description 登录失败处理器
*/
@Component
public class CustomerAuthenticationFailureHandler implements AuthenticationFailureHandler {

   /**
    * 一旦登录是被会走到这里
    * @param request the request during which the authentication attempt occurred.
    * @param response the response.
    * @param e the exception which was thrown to reject the authentication
    * request.
    * @throws IOException
    */
   @Override
   public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException e) throws IOException, ServletException {

       //修改编码格式
       response.setCharacterEncoding("utf-8");
       response.setContentType("application/json");
       String msg = null;
       if (e instanceof BadCredentialsException){
           msg = "用户名或密码错误";
       } else if (e instanceof UsernameNotFoundException) {
           msg = e.getMessage();
       }else if (e instanceof AuthenticationServiceException){
           msg = e.getMessage();
       }
       response.getWriter().println(JSONUtil.toJsonStr(Result.error(e.getMessage())));
       response.getWriter().flush();
   }
}
3.3 登录认证成功处理器
@Component
public class CustomerAuthenticationSuccessHandler implements AuthenticationSuccessHandler {

   /**
    * 一旦登录成功就会走到这里
    * @param request
    * @param response
    * @param authentication
    * @throws IOException
    * @throws ServletException
    */
   @Override
   public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
       response.setCharacterEncoding("utf-8");
       response.setContentType("application/json");

       // 获取用户名
       String userName = authentication.getName();

       // 生成 token
       String token = JWT.create()
               .setPayload("username", userName)
               .setKey("123456".getBytes(StandardCharsets.UTF_8))
               .sign();
       // 构造响应体
       String result = JSONUtil.toJsonStr(Result.success(token));
       response.getWriter().println(result);
       response.getWriter().flush();
       // //拿到登录用户信息
       // UserDto userDetails = (UserDto)authentication.getPrincipal();
       // //生成token
       // Map<String, Object> map = new HashMap<>();
       // map.put("userId", userDetails.getUser().getId());
       // String accessToken = JwtUtils.createToken(IdUtil.simpleUUID(), JSONUtil.toJsonStr(map), null);
       // //将用户信息存到缓存中
       // RedisUtils.put(RedisConstant.ADMIN_USER_INFO + userDetails.getUser().getId(), JSONUtil.toJsonStr(userDetails));
       // //将token存到缓存中
       // RedisUtils.put(RedisConstant.ADMIN_TOKEN + userDetails.getUser().getId(), accessToken);
       // //输出结果
       // response.setCharacterEncoding("utf-8");
       // response.setContentType("application/json");
       // response.getWriter().write(JSONUtil.toJsonStr(Result.success(new LoginVo(userDetails.getUser().getUserName(), userDetails.getUser().getId(), accessToken))));
   }
3.4 受保护的资源(拒接访问)处理器
@Component
public class CustomerAuthenticationEntryPointHandler implements AuthenticationEntryPoint {
   @Override
   public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
       response.setCharacterEncoding("UTF-8");
       response.setContentType("application/json");
       response.getWriter().println(JSONUtil.toJsonStr(Result.error(HttpStatus.UNAUTHORIZED.value(), "认证失败，请重新登录")));
       response.getWriter().flush();
   }
}
3.5权限认证过滤
@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {

   @Override
   protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {

       String token = request.getHeader("Authorization");
       if (token != null && token.startsWith("Bearer ")) {
           token = token.substring(7); // 去掉 "Bearer " 前缀

           try {
               // 解析 Token（用你的 JWT 工具库解析）
               String username = JWT.of(token).getPayload("username").toString();
               // 获取权限信息（可选）
               // String roles = JWT.of(token).getPayload("roles").toString();
               System.out.println("username = " + username);
               // System.out.println("roles = " + roles);
               // 创建用户认证信息
               UsernamePasswordAuthenticationToken authentication =
                       new UsernamePasswordAuthenticationToken(username, null,
                               AuthorityUtils.commaSeparatedStringToAuthorityList(null));

               // 设置认证信息到 Spring Security 上下文
               SecurityContextHolder.getContext().setAuthentication(authentication);

           } catch (Exception e) {
               System.out.println("e.getMessage() = " + e.getMessage());
               // Token 解析失败，可能是无效或过期
               response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
               response.getWriter().write("Invalid or expired token");
               return;
           }
       }

       // 放行其他过滤器
       filterChain.doFilter(request, response);
   }
}

4 SecurityConfig的配置,网上大多都是老的，下面是最新的方法

@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class WebSecurityConfig {

    private final CustomerAuthenticationFailureHandler customerAuthenticationFailureHandler;

    private final CustomerAuthenticationSuccessHandler customerAuthenticationSuccessHandler;

    private final JwtAuthenticationFilter jwtAuthenticationFilter;

    private final CustomerAuthenticationEntryPointHandler customerAuthenticationEntryPointHandler;



    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http,
                                           LoginAuthenticationFilter loginAuthenticationFilter) throws Exception {

        http
                // 基于 token，所以不需要 CSRF 防护
                .csrf(AbstractHttpConfigurer::disable)
                // 基于 token，所以不需要 session
                .sessionManagement(AbstractHttpConfigurer::disable)
                // 禁用基本身份验证
                .httpBasic(AbstractHttpConfigurer::disable)
                // 禁用表单登录
                .formLogin(AbstractHttpConfigurer::disable)
                // 禁用缓存
                .headers(AbstractHttpConfigurer::disable)
                // 放行接口
                .authorizeHttpRequests(authorize -> authorize
                        // 允许访问登录和注册接口
                        .requestMatchers(
                                "/account/login",
                                "/account/register",
                                "/swagger-resources/**",
                                "/webjars/**",
                                "/v3/**",
                                "/doc.html",
                                "/favicon.ico"
                        ).permitAll()
                        // 其他请求需要身份验证
                        .anyRequest().authenticated()
                )
                // 添加自定义登录过滤器
                .addFilterAt(loginAuthenticationFilter, UsernamePasswordAuthenticationFilter.class)
                // 验证JWT
                .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class)
                //添加 授权失败处理Handler
                .exceptionHandling(exceptionHandling ->
                        exceptionHandling.authenticationEntryPoint(customerAuthenticationEntryPointHandler)
                )
                ;


        return http.build();
    }

    @Bean
    public LoginAuthenticationFilter loginAuthenticationFilter(AuthenticationManager authenticationManager) {
        return new LoginAuthenticationFilter(authenticationManager,
                customerAuthenticationSuccessHandler,
                customerAuthenticationFailureHandler);
    }

    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration configuration) throws Exception {
        return configuration.getAuthenticationManager();
    }

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

这样就配置成功了 这里很奇怪 formLogin(AbstractHttpConfigurer::disable) 这是禁用表单登录,如果使用的话又需要另一种方式了，待会我们后面会写到,现在我们开启文档就可以访问了

6.接口测试

  • 添加用户数据,初始化一个密码,添加到数据库中
    在这里插入图片描述
    在这里插入图片描述
  • 访问接口文档开始测试
    错误的用户名和密码记住这里了一个是密码错误一个是用户错误，为什么返回的错误信息都是一样的 后面给你解释
    在这里插入图片描述
    在这里插入图片描述
    正确的用户名和密码
    在这里插入图片描述
    3.权限判断,咋验证呢,还记得我们的配置文件吗
    在这里插入图片描述
    我们新增一个account/test接口，上面没放行肯定就是受保护的就返回success一句话
@Tag(name = "用户服务")
@RestController
@RequestMapping("/account")
@RequiredArgsConstructor
public class AccountController {

    private final UsersService usersService;

    /**
     * 登录
     * @param request
     * @return
     */
    @Operation(summary = "登录")
    @PostMapping("/login")
    public Result<String> login(@RequestBody UserRequest request){
        return Result.success(usersService.login(request));
    }

	@GetMapping("/test")
    public Result<String> test() {
        return Result.success("success");
    }
}

无token请求返回401
在这里插入图片描述
有token返回成功
在这里插入图片描述
你是不是还有好多疑问,用户不存在和密码错误都是相同的返回结果

  • Spring Security 在处理身份验证失败时，会对异常进行一定程度的包装，因此原始抛出的异常可能会被替换为一个通用的异常类型，比如 BadCredentialsException。以下是具体原因和解决方案
  • DaoAuthenticationProvider 的异常包装Spring Security 使用 DaoAuthenticationProvider 来处理用户名和密码的验证。在 DaoAuthenticationProvider 的 authenticate 方法中，会调UserDetailsService.loadUserByUsername 加载用户信息。
  • 如果 loadUserByUsername 抛出 UsernameNotFoundException，DaoAuthenticationProvider 会捕获这个异常，并转换为 BadCredentialsException，以防止泄露过多的认证信息（如用户名是否存在

所以上面的登录失败的代码可以直接改为

@Component
public class CustomerAuthenticationFailureHandler implements AuthenticationFailureHandler {

   /**
    * 一旦登录失败会走到这里
    * @param request the request during which the authentication attempt occurred.
    * @param response the response.
    * @param e the exception which was thrown to reject the authentication
    * request.
    * @throws IOException
    */
   @Override
   public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException e) throws IOException, ServletException {

       //修改编码格式
       response.setCharacterEncoding("utf-8");
       response.setContentType("application/json");
       response.getWriter().println(JSONUtil.toJsonStr(Result.error(e.getMessage())));
       response.getWriter().flush();
   }
}

你是不是更奇怪,我都没有校验密码,为什么会通过或者失败呢,是在哪里校验的呢

密码的比较是在 AuthenticationManager 的 authenticate 方法中进行的，具体是通过一个 密码验证器 来执行的。Spring Security 会自动处理密码验证的过程，使用的是 PasswordEncoder 接口。PasswordEncoder 用来对用户输入的密码和数据库中存储的加密密码进行比较,密码校验流程如下:

  • UsernamePasswordAuthenticationToken 被创建： 在登录过程中，UsernamePasswordAuthenticationToken 被创建，它包含了用户输入的用户名和密码。这时密码是明文的。
UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(userName, password);
  • AuthenticationManager 处理认证： AuthenticationManager 的 authenticate 方法会将 UsernamePasswordAuthenticationToken 传递给一个 AuthenticationProvider。Spring Security 默认使用 DaoAuthenticationProvider 作为默认的 AuthenticationProvider
  • DaoAuthenticationProvider 处理认证： DaoAuthenticationProvider 是一个用于处理基于数据库的身份验证的认证提供者。在 DaoAuthenticationProvider 中，密码的比较是由 PasswordEncoder 来完成的。DaoAuthenticationProvider 会调用 UserDetailsService 的 loadUserByUsername 方法获取 UserDetails，然后比较输入的密码和从数据库中加载的密码
  • 密码比较： DaoAuthenticationProvider 会通过 PasswordEncoder 比较 UsernamePasswordAuthenticationToken 中的明文密码和 UserDetails 中的加密密码（例如，BCryptPasswordEncoder）。这里是比较的关键部分：
@Override
public Authentication authenticate(Authentication authentication) throws AuthenticationException {
    UsernamePasswordAuthenticationToken token = (UsernamePasswordAuthenticationToken) authentication;

    // 获取数据库中的用户信息
    UserDetails userDetails = this.getUserDetailsService().loadUserByUsername(token.getName());

    // 获取存储在数据库中的密码（加密后的）
    String password = userDetails.getPassword();

    // 获取输入的密码
    String presentedPassword = (String) token.getCredentials();

    // 使用 PasswordEncoder 进行密码比较
    if (!passwordEncoder.matches(presentedPassword, password)) {
        throw new BadCredentialsException("密码不正确");
    }

    return new UsernamePasswordAuthenticationToken(userDetails, password, userDetails.getAuthorities());
}
  • 认证成功： 如果密码验证通过，DaoAuthenticationProvider 会将认证通过的 Authentication 对象返回，并且认证流程继续执行，最终进入 AuthenticationSuccessHandler。
那如何配置密码加解密方式了就是配置文件中的下面这个:
@Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder(); // 配置加密算法
    }

上面的这种是禁用表单登录的方式 开启表单的方式也很简单

package com.aihe.customer.auth.config;

import com.aihe.customer.auth.handler.CustomerAuthenticationFailureHandler;
import com.aihe.customer.auth.handler.CustomerAuthenticationSuccessHandler;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

/**
 * @author 在下陈某
 * @package com.aihe.customer.auth.config
 * @description TODO
 * @date 2024/11/25 19:59
 */
@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class WebSecurityConfig {

    private final CustomerAuthenticationFailureHandler customerAuthenticationFailureHandler;

    private final CustomerAuthenticationSuccessHandler customerAuthenticationSuccessHandler;

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {

        http
                // 基于 token，所以不需要 CSRF 防护
                .csrf(AbstractHttpConfigurer::disable)
                // 基于 token，所以不需要 session
                .sessionManagement(AbstractHttpConfigurer::disable)
                // 禁用基本身份验证
                .httpBasic(AbstractHttpConfigurer::disable)
          
                 .formLogin(formLogin -> formLogin
                         .loginProcessingUrl("/account/login") // 登录请求接口
                         .failureHandler(customerAuthenticationFailureHandler) // 自定义失败处理器
                         .successHandler(customerAuthenticationSuccessHandler) // 自定义成功处理器
                         .permitAll()
                 )
                // 禁用缓存
                .headers(AbstractHttpConfigurer::disable)
                .addFilterBefore(new JwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class)
                // 登录
                .authorizeHttpRequests(authorize -> authorize
                        // 允许访问登录和注册接口
                        .requestMatchers(
                                "/account/login",
                                "/account/register",
                                "/swagger-resources/**",
                                "/webjars/**",
                                "/v3/**",
                                "/doc.html",
                                "/favicon.ico"
                        ).permitAll()
                        // 其他请求需要身份验证
                        .anyRequest().authenticated()
                );
        return http.build();
    }

    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration configuration) throws Exception {
        return configuration.getAuthenticationManager();
    }

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

如果这样就要按照前面所说的那样来操作了… 搞完收工 是不是很简单
一款免费的在线文档格式转换工具在线文档转换

spring-cloud-security
weixin_39370859的博客
04-12 4738
基于webflux的spring security,即spring-cloud-security
全新版本Spring Security使用
BUG指挥课堂
07-11 1952
SpringBoot实战电商项目mall（50k+star）地址：github.com/macrozheng/…首先修改项目的文件，把Spring Boot版本升级至版本。 旧用法 在Spring Boot 2.7.0 之前的版本中，我们需要写个配置类继承，然后重写Adapter中的三个方法进行配置； 如果你在SpringBoot 2.7.0版本中进行使用的话，你就会发现已经被弃用了，看样子Spring Security要坚决放弃这种用法了！ 新用法非常简单，无需再继承，只需直接声明配置类，再配置
SpringCloud2023最新版本该如何进行组件选型？
欢迎关注公众号“雨林寻北”，添加个人微信codetrend（备注技术）。
03-05 1331
开发分布式系统具有挑战性。复杂性从应用程序层转移到网络层，并要求各个服务之间更密切的交互。将代码设计为“云原生”意味着要处理12要素（12-factor）的问题，例如外部配置、无状态性、日志记录以及与后端服务的连接。Spring Cloud项目套件中包含了许多服务，可以使应用程序在云环境中运行。
SpringCloud2023集成Nacos2.4.3
最新发布
m0_74825565的博客
03-22 273
基本都是最新版，踩了两天的坑终于集成上了，实现了多环境配置。
springcloud集成Spring Security
youxmm的博客
07-21 3785
1.自定义配置类继承WebSecurityConfigurerAdapter配置类2.通过重写方法来定义安全规则和访问控制。通常用于测试或者开发环境中，因为它并不会对密码进行任何加密，而是将密码以明文的形式存储和验证。存在严重的安全风险，因为密码可以很容易地被窃取和滥用。建议不要在生产环境中使用类似的明文密码存储方式。@Bean//这里配置用户信息,这里暂时使用这种方式将用户存储在内存中//获取一个密码编码器对象@Bean//密码为明文方式//配置安全拦截机制@Override。
SpringBoot3集成Spring Authorization Server和Spring Cloud Gateway实现网关统一认证
liu320yj的博客
09-01 2269
在微服务开发过程中，通常都会使用Spring Cloud Gateway构建统一的API网关，在访问微服务之前都会先校验访问者是否有权限访问资源，实现方式有很多，这里主要介绍Spring Cloud Gateway集成OAuth2.1如何实现网关统一认证。
springsecurity OAuth2.0（springboot集成springsecurity 以及springcloud集成springsecurity ）
qq_73182976的博客
03-12 2551
用户认证通过后，为了避免用户的每次操作都进行认证，将用户的信息保存在会话中。会话就是系统为了保持当前登录的用户的登录状态锁提供的机制。
SpringCloud（part11） Spring Security详解
javazht的博客
06-03 1433
1.Spring Security简介 什么是Spring Security Spring Security采用安全层的概念，使得controller，Service，dao层等以注解的方式来保护应用程序的安全。Spring Security提供了细粒度的权限控制，可以精细到每一个API接口，每一个业务方法，或者每一个操作数据库的DAO层方法。Spring Security提供的是应用程序层的安...
SpringCloud——安全认证（Security）
热门推荐
默存
09-28 6万+
一、SpringCloud Security简介 Spring Cloud Security提供了一组原语，用于构建安全的应用程序和服务，而且操作简便。可以在外部（或集中）进行大量配置的声明性模型有助于实现大型协作的远程组件系统，通常具有中央身份管理服务。它也非常易于在Cloud Foundry等服务平台中使用。在Spring Boot和Spring Security OAu...
Spring Cloud Security
Flying_Fish_roe的博客
07-30 1339
Spring Cloud Security是一款基于Spring Cloud的安全框架，用于在微服务架构中提供身份验证和授权功能。它集成了Spring Security，通过添加各种过滤器和拦截器来保护微服务的安全性。身份验证：通过集成Spring Security，可以使用各种身份验证机制来验证用户的身份，如基于用户名和密码的认证、基于令牌的认证、OAuth2等。授权管理：可以通过配置角色和权限来管理用户的访问权限，控制用户可以访问的服务和资源。
Spring Security 新版本配置
weixin_46073538的博客
06-30 3656
Springsecurity最新版配置
SpringSecurity最新版本使用总结
very_Coolpad的博客
12-28 3018
​ https://spring.io/blog/2022/02/21/spring-security-without-the-websecurityconfigureradapter官方文档说的是：To assist with the transition to this new style of configuration, we have compiled a list of common use-cases and the suggested alternatives going forward.I
SpringCloud - Spring Cloud 之 Security服务安全机制（二十）
MinggeQingchun的博客
07-07 2373
微服务的Rest服务都是基于http请求的，因此很有可能暴露在公网上，任何人都可能调用访问，如果Rest服务有一些私密信息，就会导致信息的泄露，因此我们需要给微服务增加安全机制。如：Spring SecuritySpring Security 是 Spring Resource 社区的一个安全组件, Spring Security 为 JavaEE 企业开发提供了全面的安全防护。Spring Security 采用“安全层”的概念,使每一层都尽可能安全,连续的安全层可以达到全面的防护Spring Seeur
Spring Cloud 完整整合 Security + Oauth2 + jwt实现权限认证
m0_74824091的博客
12-08 1768
OAuth2是一个开放的标准，协议。即允许用户让第三方应用访问某一个网站上存储的用户私密资源(照片，头像等)。这个过程中无需将用户名和密码提供给第三方应用。在互联网中，我们最常见的OAuth2的应用就是各种第三方通过QQ授权，微信授权，微博授权等登录了。OAuth2协议一共支持4中不同的授权模式。授权码模式：常见的第三方平台登录功能基本上都使用这种模式。简化模式：简化模式不想要客户端服务器(第三方应用服务器)参与，直接在浏览器中向授权服务器申请令牌。
深入理解MQTT
RuiKe的博客
11-10 4236
轻量级物联网消息传输协议，采用发布/订阅模式，允许客户端通过代理服务器。
Spring Cloud 2024 正式发布，详细解读本次更新
bjzhang75的博客
01-04 1428
Spring Cloud 2024 正式发布，详细解读本次更新
别再用过时的方式了！全新版本Spring Security，这样用才够优雅！
weixin_42907150的博客
01-26 2071
Spring Security的升级用法确实够优雅，够简单，而且对之前用法的兼容性也比较好！个人感觉一个成熟的框架不太会在升级过程中大改用法，即使改了也会对之前的用法做兼容，所以对于绝大多数框架来说旧版本会用，新版本照样会用！
【SpringCloud】史上最强最细整理笔记！2025最新！手把手教你学会SpringCloud！
m0_67226963的博客
12-03 892
史上最全的SpringCVoud微服务架构学习笔记，手把手教你学会SpringCloud。基于Javajdk17版本的SpringCloud学习笔记整理。认识微服务、微服务拆分和远程调用、远程调用案例、Ereuka注册中心配置测试、Ribbon实现负载均衡、饥饿加载配置、Nacos注册中心、安装Nacos、Nacos的分级存储模型介绍、测试集群、权重配置、环境隔离、Nacos与Ereuka的区别......
SpringCloud基础使用(2024最全、最新)
YZG ' BLOG
04-09 3158
目前常用的组件：业务图模拟订单支付的简单业务 1.1 环境搭建 版本要求搭建Maven父工程一些Setting字符编码注解生效Java编译版本POM 1.2 Mapper4一键生成 创建一个名称为 的Maven工程引入 ： 创建配置文件properties： generatorConfig.xml 一切就绪之后，双击插件即可：新建一个支付模块POM yaml配置文件 PayService PayServiceImpl PayController 主启动类 PayDTO 1.4 解决时间格式、同一返回结
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值