Spring Security 用户认证和授权管理

已于 2024-09-02 16:51:01 修改
阅读量694 收藏 7
点赞数 19
文章标签： spring java 后端 spring boot mybatis
于 2024-09-02 16:47:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44876263/article/details/141817822
版权

文章目录

一、介绍

1、简介

Spring Security 是一个强大的安全框架，旨在保护基于 Spring 的应用程序。它提供了一整套全面的安全功能，包括认证、授权、以及防护常见安全攻击的机制。

2、核心概念

  • 认证（Authentication）

    认证是验证用户身份的过程。在 Spring Security 中，用户在登录时提交凭证（如用户名和密码）。这些凭证会通过一系列过滤器进行处理和验证。如果凭证正确，系统会确认用户的身份并授予相应的权限。

  • 授权（Authorization）

    授权是确定已认证用户是否有权限执行特定操作或访问特定资源的过程。Spring Security 通过配置访问控制规则来实现授权。授权通常基于角色（Role）和权限（Authority）。例如，只有具有管理员角色的用户才能访问管理页面。

  • 过滤器（Filter）

    Spring Security 使用一系列过滤器来拦截 HTTP 请求，并在请求到达应用程序之前执行安全逻辑。每个过滤器都有特定的职责，例如处理认证、授权和会话管理。这些过滤器由 FilterChainProxy 管理，并按顺序执行，确保所有安全检查在请求处理前完成。

  • 安全上下文（Security Context）

    安全上下文包含当前用户的安全信息，包括用户的认证信息和权限。Spring Security 使用 SecurityContextHolder 来存储和访问安全上下文。每次请求到达服务器时，安全上下文会被加载并在整个请求期间保持有效，以确保所有的安全检查都基于最新的用户信息。

3、主要功能

  • 表单登录（Form-based Authentication）

    提供自定义登录页面和登录处理机制。
    处理用户提交的登录表单，并进行身份验证。

  • HTTP 基础认证（HTTP Basic Authentication）

    使用 HTTP 基础认证头（Authorization）来进行身份验证。
    常用于简单的 RESTful API 安全。

  • LDAP 支持

    集成 LDAP（轻量目录访问协议）进行用户认证和授权。

  • 方法级别安全（Method Level Security）

    使用注解（如 @PreAuthorize, @Secured）在方法级别进行权限控制。
    允许对服务层方法进行细粒度的安全控制。

  • CSRF 防护（Cross-Site Request Forgery Protection）

    防护跨站请求伪造攻击。
    默认启用，可以根据需要进行配置。

  • 会话管理（Session Management）

    控制用户会话，包括会话超时和并发会话控制。
    提供防止会话固定攻击的机制。

  • 安全事件和监听器（Security Events and Listeners）

    处理并记录安全相关的事件，如登录成功、登录失败等。
    提供监听器机制，允许开发者自定义处理这些事件。

4、处理流程

Spring Security 的处理流程主要包括以下几个步骤：

  • （1）请求进入过滤器链

    用户发起一个 HTTP 请求，首先被 Spring Security 的过滤器链拦截。

  • （2）安全上下文初始化

    SecurityContextPersistenceFilter 过滤器加载或创建一个新的安全上下文，确保请求期间的安全信息可用。

  • （3）认证过程

    例如，UsernamePasswordAuthenticationFilter 处理登录请求，提取用户名和密码，并将其传递给 AuthenticationManager 进行验证。
    AuthenticationManager 会使用一个或多个 AuthenticationProvider 验证用户凭证。如果认证成功，用户信息会存储在安全上下文中。

  • （4）授权过程

    请求经过 FilterSecurityInterceptor，该过滤器会检查用户是否有权限访问请求的资源。如果没有权限，系统会拒绝访问并返回相应的错误信息。

  • （5）会话管理

    SessionManagementFilter 负责管理用户会话，防止会话固定攻击和控制并发会话数。

  • （6）请求处理

    如果认证和授权都通过，过滤器链将请求传递给应用程序的控制器进行正常的业务处理。

  • （7）响应处理

    在响应返回之前，过滤器链会执行一些清理工作（如保存安全上下文），确保会话和安全上下文的一致性。

通过以上流程，Spring Security 确保每个 HTTP 请求都经过严格的安全检查，从而保护应用程序的安全。

二、Spring Security实现权限

Spring Security进行认证和鉴权的时候,就是利用的一系列的Filter来进行拦截的。
在这里插入图片描述

如图所示，一个请求想要访问到API就会从左到右经过蓝线框里的过滤器，其中绿色部分是负责认证的过滤器，蓝色部分是负责异常处理，橙色部分则是负责授权。进过一系列拦截最终访问到我们的API。

这里面我们只需要重点关注两个过滤器即可：UsernamePasswordAuthenticationFilter负责登录认证，FilterSecurityInterceptor负责权限授权。

1、添加依赖

	 <!--   spring security    -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>

2、执行顺序和代码执行流程

（1）用户登录

SpringSecurityConf

在 SpringSecurityConf 配置中，添加了自定义的过滤器 PostJsonAuthenticationFilter 和 TokenAuthorizationFilter。

/**
     * @description: TODO 定义了一系列安全策略，包括禁用 CSRF 保护、配置会话管理策略、配置白名单、添加自定义过滤器等
     *
     * @author: LLong
     * @date: 2024/03/29 17:54:41
     * @param http
     * @return: void
     **/
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //配置了异常处理，指定了身份验证失败时的处理方式，即当用户未经身份验证访问受保护的资源时，会调用 authenticationEntryPoint 来处理
        http.exceptionHandling().authenticationEntryPoint(authenticationEntryPoint);
//                .accessDeniedHandler(accessDeniedHandler);
        //禁用了 CSRF 保护，并启用了 HTTP Basic 认证
        http.csrf().disable().httpBasic()
                //设置会话管理策略为无状态，即不创建会话
                .and().sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                //配置一组 URL 的白名单，这些 URL（AUTH_WHITELIST） 不需要身份验证即可访问
                .and().authorizeRequests().antMatchers(AUTH_WHITELIST).permitAll()
                //获取标有注解 AnonymousAccess 的访问路径，不需要身份验证即可访问
                .and().authorizeRequests().antMatchers(getAnonymousUrls()).permitAll()
                .anyRequest().authenticated();
        //添加登陆过滤器，用来处理基于令牌的身份验证
        http.addFilterBefore(createTokenAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);
        //添加权限鉴定过滤器 authorizationFilter，用于进行授权验证。
        http.addFilterBefore(authorizationFilter, UsernamePasswordAuthenticationFilter.class);

    }
}


	/**
     * @description: TODO 登陆过滤器
     * @author: LLong
     * @date: 2024/03/29 18:00:31
     * @param
     * @return: PostJsonAuthenticationFilter
     **/
    private PostJsonAuthenticationFilter createTokenAuthenticationFilter() throws Exception {
        // 创建PostJsonAuthenticationFilter实例，传入AuthenticationManager和ObjectMapper
        PostJsonAuthenticationFilter postJsonAuthenticationFilter =
                new PostJsonAuthenticationFilter(authenticationManagerBean(), objectMapper);

        // 设置身份验证成功处理器
        postJsonAuthenticationFilter.setAuthenticationSuccessHandler(postJsonAuthenticationSuccessHandler);

        // 设置身份验证失败处理器
        postJsonAuthenticationFilter.setAuthenticationFailureHandler(postJsonAuthenticationFailureHandler);

        return postJsonAuthenticationFilter;
    }

 	/**
     * @description: TODO 配置身份验证管理器，用于验证用户的身份
     * @author: LLong
     * @date: 2024/03/29 18:01:38
     * @param auth
     * @return: void
     **/
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
                // 设置使用自己实现的userDetailsService（loadUserByusername）
                .userDetailsService(userDetailsService)
                // 设置密码加密方式（自定义）
                .passwordEncoder(ssha512PasswordEncoder());
    }

PostJsonAuthenticationFilter

PostJsonAuthenticationFilter 负责处理登录请求。其主要方法 attemptAuthentication 会被调用：

/**
     * @description: TODO 处理用户身份验证
     * @author: LLong
     * @date: 2024/03/29 18:16:35
     * @param request
     * @param response
     * @return: Authentication
     **/
    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
          // 从请求体中读取JSON数据并映射到UserEntity对象
          AuthLoginVO authLoginVO = objectMapper.readValue(request.getInputStream(), AuthLoginVO.class);

          // 创建一个UsernamePasswordAuthenticationToken用于进行身份验证
          UsernamePasswordAuthenticationToken authenticationToken =
                  new UsernamePasswordAuthenticationToken(authLoginVO.getUsername(), authLoginVO.getPassword());

          // 进行身份验证
          return authenticationManager.authenticate(authenticationToken);
        }
    }
}

UserDetailsServiceImpl
在 attemptAuthentication 方法中，AuthenticationManager 调用 UserDetailsServiceImpl 的 loadUserByUsername 方法来加载用户的详细信息：（该方法是自定义的校验逻辑）

@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    // 创建查询条件，用于根据用户名查询用户信息
    LambdaQueryWrapper<MailUserEntity> lqw = new LambdaQueryWrapper<>();
    lqw.eq(MailUserEntity::getUsername, username);

    // 使用查询条件从数据库中查询用户信息
    MailUserEntity user = mailUserMapper.selectOne(lqw);
    if (user == null) {
        // 如果用户不存在，抛出 UsernameNotFoundException 异常
        throw new UsernameNotFoundException("用户不存在");
    }

    // 获取用户的权限集合
    Collection<GrantedAuthority> authList = getAuthorities();

    // 创建自定义的 AuthLoginVO 实例，包含用户名、密码、姓名和权限集合
    AuthLoginVO authLoginVO = new AuthLoginVO(user.getUsername(), user.getPassword(), user.getName(), authList);

    // 返回包含用户信息和权限的 AuthLoginVO 对象
    return authLoginVO;
}

PostJsonAuthenticationSuccessHandler
如果登录成功，PostJsonAuthenticationFilter 将调用 PostJsonAuthenticationSuccessHandler 的 onAuthenticationSuccess 方法：

@Override
public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
                                    Authentication authentication) throws IOException {
    // 从 authentication 对象中获取已认证的用户信息
    Object principal = authentication.getPrincipal();
    
    // 检查 principal 是否为 AuthLoginVO 实例
    if (principal instanceof AuthLoginVO) {
        AuthLoginVO user = (AuthLoginVO) authentication.getPrincipal(); // 将 principal 强制转换为 AuthLoginVO 类型

        // 从 Redis 中获取与用户名关联的 uuid
        String uuid = redisTemplate.opsForValue().get(USER_USERNAME_PRE + user.getUsername());

        // 如果 uuid 不存在，则生成一个新的 uuid
        if (StringUtils.isEmpty(uuid)) {
            uuid = UUID.fastUUID().toString(true);
        }

        // 将用户名和 uuid 存储到 Redis 中，并设置过期时间为 12 小时
        redisTemplate.opsForValue().set(USER_USERNAME_PRE + user.getUsername(), uuid, EXPIRE_TIME_12_HOURS, TimeUnit.SECONDS);

        // 将 uuid 和用户信息存储到 Redis 中，并设置过期时间为 12 小时
        redisTemplate.opsForValue().set(USER_TOKEN_PRE + uuid, objectMapper.writeValueAsString(user), EXPIRE_TIME_12_HOURS, TimeUnit.SECONDS);

        // 设置 HTTP 响应状态为 200
        response.setStatus(200);

        // 设置响应内容类型为 JSON，字符集为 UTF-8
        response.setContentType("application/json;charset=UTF-8");

        // 创建一个新的 AuthLoginVO 对象，用于响应
        AuthLoginVO authLoginVO = new AuthLoginVO();
        authLoginVO.setId(user.getId()); // 设置用户 ID
        authLoginVO.setUsername(user.getUsername()); // 设置用户名
        authLoginVO.setToken(uuid); // 设置用户 token

        // 将用户权限信息转换为 Set 并设置到 authLoginVO 中（此代码被注释掉）
        // authLoginVO.setPermissions(AuthorityUtils.authorityListToSet(authentication.getAuthorities()));

        // 将 authLoginVO 对象转换为 JSON 并写入响应
        response.getWriter().print(objectMapper.writeValueAsString(new Result<>(authLoginVO)));

        // 刷新缓冲区，确保所有数据被写入
        response.flushBuffer();
    }
}

PostJsonAuthenticationFailureHandler
如果登录失败，PostJsonAuthenticationFilter 将调用 PostJsonAuthenticationFailureHandler 的 onAuthenticationFailure 方法：

@Override
public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
                                    AuthenticationException exception) throws IOException {
    // 设置 HTTP 响应状态码为 200（OK）
    response.setStatus(200);

    // 设置响应内容类型为 JSON，字符集为 UTF-8
    response.setContentType("application/json;charset=UTF-8");

    // 将登录失败的结果转换为 JSON 并写入响应
    response.getWriter().print(JSONUtil.toJsonStr(new Result<>(LOGIN_FAIL)));

    // 刷新缓冲区，确保所有数据被写入
    response.flushBuffer();
}

（2）访问受保护资源

TokenAuthorizationFilter
在请求访问受保护资源时，TokenAuthorizationFilter 会被调用：


    /**
     * @description: TODO 过滤器 基于令牌设置用户的认证信息
     * 自定义的过滤器（Filter），用于在请求中提取令牌（token），然后基于令牌设置用户的认证信息
     * @author: LLong
     * @date: 2024/03/29 18:06:38
     * @param request
     * @param response
     * @param chain
     * @return: void
     **/
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 从请求头中获取名为 "token" 的令牌
        String token = request.getHeader("token");
        if (!StringUtils.isEmpty(token)) {
            // 从redis中获取用户名
            String user = redisTemplate.opsForValue().get(USER_TOKEN_PRE + token);
            //从 Redis 中获取到的用户信息 JSON 字符串反序列化为 AuthLoginVO 对象
            AuthLoginVO authUser = objectMapper.readValue(user, AuthLoginVO.class);
            if (SecurityContextHolder.getContext().getAuthentication() == null && Objects.nonNull(authUser)) {
                // 创建一个 UsernamePasswordAuthenticationToken 对象，用于表示用户的认证信息。
                // 其中 authUser 是从 Redis 中获取到的用户信息对象，authUser.getAuthorities() 返回用户的权限集合
                UsernamePasswordAuthenticationToken authentication =
                        new UsernamePasswordAuthenticationToken(authUser, null, authUser.getAuthorities());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                //将创建的认证信息对象设置到当前的安全上下文中
                SecurityContextHolder.getContext().setAuthentication(authentication);
                //刷新token
                redisTemplate.expire(USER_USERNAME_PRE + authUser.getUsername(), EXPIRE_TIME_12_HOURS,
                        TimeUnit.SECONDS);
                redisTemplate.expire(USER_TOKEN_PRE + token, EXPIRE_TIME_12_HOURS, TimeUnit.SECONDS);
            }
        }
        //调用 chain.doFilter(request, response) 继续执行过滤器链中的下一个过滤器
        chain.doFilter(request, response);
    }

TokenAuthenticationEntryPoint

如果请求没有进行身份验证或令牌无效，TokenAuthenticationEntryPoint 会被调用，返回未授权的响应：

@Override
public void commence(HttpServletRequest request, HttpServletResponse response,
                     AuthenticationException authException) throws IOException {
    // 设置 HTTP 响应状态码为 200（OK）
    response.setStatus(200);

    // 设置响应内容类型为 JSON，字符集为 UTF-8
    response.setContentType("application/json;charset=UTF-8");

    // 将未授权的结果转换为 JSON 并写入响应
    response.getWriter().print(JSONUtil.toJsonStr(new Result<>(UNAUTHORIZED)));

    // 刷新缓冲区，确保所有数据被写入
    response.flushBuffer();
}

总结

1、用户登录

  • 用户提交登录表单，PostJsonAuthenticationFilter 处理请求，提取用户名和密码，进行身份验证。
  • UserDetailsServiceImpl 加载用户详细信息，并验证用户的合法性。
  • 登录成功后，PostJsonAuthenticationSuccessHandler 生成令牌，存储到 Redis 中，并返回用户信息和令牌。
  • 登录失败后，PostJsonAuthenticationFailureHandler 返回失败消息。

2、访问受保护资源

  • 用户请求受保护资源，TokenAuthorizationFilter 验证请求中的令牌，确保用户身份有效。
  • 如果令牌无效或未提供，TokenAuthenticationEntryPoint 返回未授权消息。

完整源码

1、SpringSecurityConf

package com.cx.cxBasic.common.config.authorization;

import com.cx.cxBasic.common.config.authorization.handler.PostJsonAuthenticationFailureHandler;
import com.cx.cxBasic.common.config.authorization.handler.PostJsonAuthenticationSuccessHandler;
import com.cx.cxBasic.common.config.authorization.handler.TokenAuthenticationEntryPoint;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
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.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

import javax.annotation.Resource;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * @Author: LLong
 * @CreateTime: 2023-12-12  18:36
 * @Description: TODO Spring Security权限配置类
 * @Version: 1.0
 */
@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
@EnableWebSecurity
public class SpringSecurityConf extends WebSecurityConfigurerAdapter  {
    private static final String[] AUTH_WHITELIST =
            {"/login"};

    @Resource
    private UserDetailsService userDetailsService;

    @Resource
    private ObjectMapper objectMapper;

    /**
     * 权限鉴定过滤器
     */
    @Resource
    private TokenAuthorizationFilter authorizationFilter;

//    /**
//     * 权限不足结果处理
//     */
//    @Resource
//    private TokenAccessDeniedHandler accessDeniedHandler;

    /**
     * 未登录结果处理
     */
    @Resource
    private TokenAuthenticationEntryPoint authenticationEntryPoint;

    /**
     * 登陆成功处理
     */
    @Resource
    private PostJsonAuthenticationSuccessHandler postJsonAuthenticationSuccessHandler;

    /**
     * 登陆失败处理
     */
    @Resource
    private PostJsonAuthenticationFailureHandler postJsonAuthenticationFailureHandler;

    @Resource
    private RequestMappingHandlerMapping requestMappingHandlerMapping;

    /**
     * @description: TODO 定义了一系列安全策略，包括禁用 CSRF 保护、配置会话管理策略、配置白名单、添加自定义过滤器等
     *
     * @author: LLong
     * @date: 2024/03/29 17:54:41
     * @param http
     * @return: void
     **/
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //配置了异常处理，指定了身份验证失败时的处理方式，即当用户未经身份验证访问受保护的资源时，会调用 authenticationEntryPoint 来处理
        http.exceptionHandling().authenticationEntryPoint(authenticationEntryPoint);
//                .accessDeniedHandler(accessDeniedHandler);
        //禁用了 CSRF 保护，并启用了 HTTP Basic 认证
        http.csrf().disable().httpBasic()
                //设置会话管理策略为无状态，即不创建会话
                .and().sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                //配置一组 URL 的白名单，这些 URL（AUTH_WHITELIST） 不需要身份验证即可访问
                .and().authorizeRequests().antMatchers(AUTH_WHITELIST).permitAll()
                //获取标有注解 AnonymousAccess 的访问路径，不需要身份验证即可访问
                .and().authorizeRequests().antMatchers(getAnonymousUrls()).permitAll()
                .anyRequest().authenticated();
        //添加登陆过滤器，用来处理基于令牌的身份验证
        http.addFilterBefore(createTokenAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);
        //添加权限鉴定过滤器 authorizationFilter，用于进行授权验证。
        http.addFilterBefore(authorizationFilter, UsernamePasswordAuthenticationFilter.class);

    }


    /**
     * @description: TODO 登陆过滤器
     * @author: LLong
     * @date: 2024/03/29 18:00:31
     * @param
     * @return: PostJsonAuthenticationFilter
     **/
    private PostJsonAuthenticationFilter createTokenAuthenticationFilter() throws Exception {
        // 创建PostJsonAuthenticationFilter实例，传入AuthenticationManager和ObjectMapper
        PostJsonAuthenticationFilter postJsonAuthenticationFilter =
                new PostJsonAuthenticationFilter(authenticationManagerBean(), objectMapper);

        // 设置身份验证成功处理器
        postJsonAuthenticationFilter.setAuthenticationSuccessHandler(postJsonAuthenticationSuccessHandler);

        // 设置身份验证失败处理器
        postJsonAuthenticationFilter.setAuthenticationFailureHandler(postJsonAuthenticationFailureHandler);

        return postJsonAuthenticationFilter;
    }


    /**
     * @description: TODO 密码BCrypt加密
     * 密码加密器，在授权时，框架为我们解析用户名密码时，密码会通过加密器加密在进行比较 将密码加密器交给spring管理，在注册时，密码也是需要加密的，再存入数据库中 用户输入登录的密码用加密器加密，再与数据库中查询到的用户密码比较
     * @author: LLong
     * @date: 2024/03/29 18:00:38
     * @param
     * @return: BCryptPasswordEncoder 加密器
     **/
    @Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder() {
        // 密码加密
        return new BCryptPasswordEncoder();
    }

    /**
     * @description: TODO 配置身份验证管理器，用于验证用户的身份
     * @author: LLong
     * @date: 2024/03/29 18:01:38
     * @param auth
     * @return: void
     **/
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
                // 设置使用自己实现的userDetailsService（loadUserByusername）
                .userDetailsService(userDetailsService)
                // 设置密码加密方式
                .passwordEncoder(bCryptPasswordEncoder());
    }

    /**
     * 获取标有注解 AnonymousAccess 的访问路径
     */
    /**
     * @description: TODO 获取标有注解 AnonymousAccess 的可匿名访问的路径
     * @author: LLong
     * @date: 2024/03/29 18:03:07
     * @param
     * @return: String
     **/
    private String[] getAnonymousUrls() {
        // 获取所有的 RequestMapping
        Map<RequestMappingInfo, HandlerMethod> handlerMethods = requestMappingHandlerMapping.getHandlerMethods();
        Set<String> allAnonymousAccess = new HashSet<>();
        // 循环 RequestMapping
        for (Map.Entry<RequestMappingInfo, HandlerMethod> infoEntry : handlerMethods.entrySet()) {
            HandlerMethod value = infoEntry.getValue();
            // 获取方法上 AnonymousAccess 类型的注解
            AnonymousAccess methodAnnotation = value.getMethodAnnotation(AnonymousAccess.class);
            // 如果方法上标注了 AnonymousAccess 注解，就获取该方法的访问全路径
            if (methodAnnotation != null) {
                allAnonymousAccess.addAll(infoEntry.getKey().getPatternsCondition().getPatterns());
            }
        }
        return allAnonymousAccess.toArray(new String[0]);
    }

    /**
     *  加密密码测试
     */
    public static void main(String[] args) {
        BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
        String encode = bCryptPasswordEncoder.encode("123456");
        System.out.println(encode);
    }


}

2、PostJsonAuthenticationFilter

package com.cx.cxBasic.common.config.authorization;

import com.cx.cxBasic.common.exception.ServiceException;
import com.cx.cxBasic.entity.UserEntity;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpMethod;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
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;
import java.io.IOException;

/**
 * @Author: LLong
 * @CreateTime: 2023-12-12  19:14
 * @Description: TODO 登陆拦截器
 * @Version: 1.0
 */
@Slf4j
public class PostJsonAuthenticationFilter extends AbstractAuthenticationProcessingFilter {

    private final ObjectMapper objectMapper;

    private final AuthenticationManager authenticationManager;

    /**
     * @description: TODO 配置过滤器的一些参数
     * 过滤器处理的请求的 URL、请求方法，并将所需的身份验证管理器和 JSON 序列化对象传递给过滤器
     * @author: LLong
     * @date: 2024/03/29 18:13:39
     * @param authenticationManager
     * @param objectMapper
     * @return: null
     **/
    public PostJsonAuthenticationFilter(AuthenticationManager authenticationManager,
                                        ObjectMapper objectMapper) {
        super(new AntPathRequestMatcher("/login", HttpMethod.POST.toString()));
        this.authenticationManager = authenticationManager;
        this.objectMapper = objectMapper;
    }

    /**
     * @description: TODO 处理用户身份验证
     * @author: LLong
     * @date: 2024/03/29 18:16:35
     * @param request
     * @param response
     * @return: Authentication
     **/
    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        try {
            // 从请求体中读取JSON数据并映射到UserEntity对象
            UserEntity users = objectMapper.readValue(request.getInputStream(), UserEntity.class);

            // 模仿usernamePasswordAuthenticationFilter的方式，创建一个usernamePasswordAuthenticationToken用于进行身份验证
            // 创建一个UsernamePasswordAuthenticationToken用于进行身份验证
            UsernamePasswordAuthenticationToken authenticationToken =
                    new UsernamePasswordAuthenticationToken(users.getUsername(), users.getPassword());

            // 进行身份验证
            return authenticationManager.authenticate(authenticationToken);
        } catch (IOException e) {
            // 处理IO异常，例如读取请求体失败
            log.error("登录异常: {}", e.getMessage(), e);

            // 抛出usernameNotFoundException异常，表示身份验证失败
            throw new ServiceException("身份验证失败");
        }
    }
}

3、UserDetailsServiceImpl

package com.cx.cxBasic.common.config.authorization;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.cx.cxBasic.entity.vamil.MailUserEntity;
import com.cx.cxBasic.mapper.vmail.MailUserMapper;
import com.cx.cxBasic.model.vo.admin.AuthLoginVO;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * @Author: LLong
 * @CreateTime: 2024/06/26  20:32
 * @Description: TODO
 * @Version: 1.0
 */
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Resource
    private MailUserMapper mailUserMapper;


    /**  * 根据用户名获取用户 - 用户的角色、权限等信息   */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
   // 创建查询条件，用于根据用户名查询用户信息
    LambdaQueryWrapper<MailUserEntity> lqw = new LambdaQueryWrapper<>();
    lqw.eq(MailUserEntity::getUsername, username);

    // 使用查询条件从数据库中查询用户信息
    MailUserEntity user = mailUserMapper.selectOne(lqw);
    if (user == null) {
        // 如果用户不存在，抛出 UsernameNotFoundException 异常
        throw new UsernameNotFoundException("用户不存在");
    }

    // 获取用户的权限集合
    Collection<GrantedAuthority> authList = getAuthorities();

    // 创建自定义的 AuthLoginVO 实例，包含用户名、密码、姓名和权限集合
    AuthLoginVO authLoginVO = new AuthLoginVO(user.getUsername(), user.getPassword(), user.getName(), authList);
        UserDetails userDetails = authLoginVO;

        return userDetails;
    }
    /**  * 获取用户的角色权限,为了降低实验的难度，这里去掉了根据用户名获取角色的步骤     * @param    * @return   */
    private Collection<GrantedAuthority> getAuthorities(){
        List<GrantedAuthority> authList = new ArrayList<GrantedAuthority>();
        return authList;
    }
}

4、PostJsonAuthenticationSuccessHandler

package com.cx.cxBasic.common.config.authorization.handler;

import cn.hutool.core.lang.UUID;
import com.cx.cxBasic.common.Result;
import com.cx.cxBasic.model.vo.admin.AuthLoginVO;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

import static com.cx.recordLibrary.common.constant.RedisKeyConstants.*;

/**
 * @Author: LLong
 * @CreateTime: 2023-12-14  11:50
 * @Description: TODO 登陆成功处理器
 * @Version: 1.0
 */
@Component
public class PostJsonAuthenticationSuccessHandler implements AuthenticationSuccessHandler {
    @Autowired
    private StringRedisTemplate redisTemplate;

    @Autowired
    private ObjectMapper objectMapper;

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
                                        Authentication authentication) throws IOException {
            // 从 authentication 对象中获取已认证的用户信息
    Object principal = authentication.getPrincipal();
    
    // 检查 principal 是否为 AuthLoginVO 实例
    if (principal instanceof AuthLoginVO) {
        AuthLoginVO user = (AuthLoginVO) authentication.getPrincipal(); // 将 principal 强制转换为 AuthLoginVO 类型

        // 从 Redis 中获取与用户名关联的 uuid
        String uuid = redisTemplate.opsForValue().get(USER_USERNAME_PRE + user.getUsername());

        // 如果 uuid 不存在，则生成一个新的 uuid
        if (StringUtils.isEmpty(uuid)) {
            uuid = UUID.fastUUID().toString(true);
        }

        // 将用户名和 uuid 存储到 Redis 中，并设置过期时间为 12 小时
        redisTemplate.opsForValue().set(USER_USERNAME_PRE + user.getUsername(), uuid, EXPIRE_TIME_12_HOURS, TimeUnit.SECONDS);

        // 将 uuid 和用户信息存储到 Redis 中，并设置过期时间为 12 小时
        redisTemplate.opsForValue().set(USER_TOKEN_PRE + uuid, objectMapper.writeValueAsString(user), EXPIRE_TIME_12_HOURS, TimeUnit.SECONDS);

        // 设置 HTTP 响应状态为 200
        response.setStatus(200);

        // 设置响应内容类型为 JSON，字符集为 UTF-8
        response.setContentType("application/json;charset=UTF-8");

        // 创建一个新的 AuthLoginVO 对象，用于响应
        AuthLoginVO authLoginVO = new AuthLoginVO();
        authLoginVO.setId(user.getId()); // 设置用户 ID
        authLoginVO.setUsername(user.getUsername()); // 设置用户名
        authLoginVO.setToken(uuid); // 设置用户 token

        // 将用户权限信息转换为 Set 并设置到 authLoginVO 中（此代码被注释掉）
        // authLoginVO.setPermissions(AuthorityUtils.authorityListToSet(authentication.getAuthorities()));

        // 将 authLoginVO 对象转换为 JSON 并写入响应
        response.getWriter().print(objectMapper.writeValueAsString(new Result<>(authLoginVO)));

        // 刷新缓冲区，确保所有数据被写入
        response.flushBuffer();
        }
    }
}

5、PostJsonAuthenticationFailureHandler

package com.cx.cxBasic.common.config.authorization.handler;

import cn.hutool.json.JSONUtil;
import com.cx.cxBasic.common.Result;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

import static com.cx.cxBasic.common.exception.ResultCode.LOGIN_FAIL;

/**
 * @BelongsProject: cx-basic-framework
 * @Author: LLong
 * @CreateTime: 2023-12-14  11:48
 * @Description: TODO 登陆失败处理器
 * @Version: 1.0
 */
@Component
public class PostJsonAuthenticationFailureHandler implements AuthenticationFailureHandler {

   @Override
public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
                                    AuthenticationException exception) throws IOException {
	    // 设置 HTTP 响应状态码为 200（OK）
	    response.setStatus(200);
	
	    // 设置响应内容类型为 JSON，字符集为 UTF-8
	    response.setContentType("application/json;charset=UTF-8");
	
	    // 将登录失败的结果转换为 JSON 并写入响应
	    response.getWriter().print(JSONUtil.toJsonStr(new Result<>(LOGIN_FAIL)));
	
	    // 刷新缓冲区，确保所有数据被写入
	    response.flushBuffer();
	}
}

6、TokenAuthorizationFilter

package com.cx.cxBasic.common.config.authorization;

import com.cx.cxBasic.model.vo.admin.AuthLoginVO;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Objects;
import java.util.concurrent.TimeUnit;

import static com.cx.cxBasic.common.constant.RedisKeyConstants.*;

/**
 * @BelongsProject: cx-record-library
 * @BelongsPackage: com.cx.recordLibrary.common.config.authorization
 * @Author: LLong
 * @CreateTime: 2023-12-12  18:40
 * @Description: TODO 请求认证拦截器
 * @Version: 1.0
 */
@Slf4j
@Component
public class TokenAuthorizationFilter extends OncePerRequestFilter {
    @Autowired
    private StringRedisTemplate redisTemplate;

    @Autowired
    private ObjectMapper objectMapper;

 /**
     * @description: TODO 过滤器 基于令牌设置用户的认证信息
     * 自定义的过滤器（Filter），用于在请求中提取令牌（token），然后基于令牌设置用户的认证信息
     * @author: LLong
     * @date: 2024/03/29 18:06:38
     * @param request
     * @param response
     * @param chain
     * @return: void
     **/
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 从请求头中获取名为 "token" 的令牌
        String token = request.getHeader("token");
        if (!StringUtils.isEmpty(token)) {
            // 从redis中获取用户名
            String user = redisTemplate.opsForValue().get(USER_TOKEN_PRE + token);
            //从 Redis 中获取到的用户信息 JSON 字符串反序列化为 AuthLoginVO 对象
            AuthLoginVO authUser = objectMapper.readValue(user, AuthLoginVO.class);
            if (SecurityContextHolder.getContext().getAuthentication() == null && Objects.nonNull(authUser)) {
                // 创建一个 UsernamePasswordAuthenticationToken 对象，用于表示用户的认证信息。
                // 其中 authUser 是从 Redis 中获取到的用户信息对象，authUser.getAuthorities() 返回用户的权限集合
                UsernamePasswordAuthenticationToken authentication =
                        new UsernamePasswordAuthenticationToken(authUser, null, authUser.getAuthorities());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                //将创建的认证信息对象设置到当前的安全上下文中
                SecurityContextHolder.getContext().setAuthentication(authentication);
                //刷新token
                redisTemplate.expire(USER_USERNAME_PRE + authUser.getUsername(), EXPIRE_TIME_12_HOURS,
                        TimeUnit.SECONDS);
                redisTemplate.expire(USER_TOKEN_PRE + token, EXPIRE_TIME_12_HOURS, TimeUnit.SECONDS);
            }
        }
        //调用 chain.doFilter(request, response) 继续执行过滤器链中的下一个过滤器
        chain.doFilter(request, response);
    }

}

7、TokenAuthenticationEntryPoint

package com.cx.cxBasic.common.config.authorization.handler;

import cn.hutool.json.JSONUtil;
import com.cx.cxBasic.common.Result;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

import static com.cx.cxBasic.common.exception.ResultCode.UNAUTHORIZED;

/**
 * @BelongsProject: cx-basic-framework
 * @Author: LLong
 * @CreateTime: 2023-12-14  11:51
 * @Description: TODO 未登录处理器
 * @Version: 1.0
 */
@Component
public class TokenAuthenticationEntryPoint implements AuthenticationEntryPoint {

	    @Override
	public void commence(HttpServletRequest request, HttpServletResponse response,
	                     AuthenticationException authException) throws IOException {
	    // 设置 HTTP 响应状态码为 200（OK）
	    response.setStatus(200);
	
	    // 设置响应内容类型为 JSON，字符集为 UTF-8
	    response.setContentType("application/json;charset=UTF-8");
	
	    // 将未授权的结果转换为 JSON 并写入响应
	    response.getWriter().print(JSONUtil.toJsonStr(new Result<>(UNAUTHORIZED)));
	
	    // 刷新缓冲区，确保所有数据被写入
	    response.flushBuffer();
	}
}

8、AnonymousAccess

package com.cx.cxBasic.common.config.authorization;

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

/**
 * @BelongsProject: cx-basic-framework
 * @Author: LLong
 * @CreateTime: 2023-12-14  11:52
 * @Description: TODO
 * @Version: 1.0
 */
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface AnonymousAccess {
}

9、AuthLoginVO

package com.cx.cxBasic.model.vo.admin;

import com.cx.cxBasic.common.config.authorization.CustomAuthorityDeserializer;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.math.BigInteger;
import java.util.Collection;

/**

 * @Author: LLong
 * @CreateTime: 2023-12-12  16:38
 * @Description: TODO token用户登录信息
 * @Version: 1.0
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class AuthLoginVO implements UserDetails {
    /**
     *  用户ID 主键id
     */
    private BigInteger id;
    /**
     *  用户名
     */
    private String username ;
    /**
     *  用户密码
     */
    private String password ;
    /**
     *  角色代码
     */
    private Integer code;
    /**
     *  角色名
     */
    private String roleName ;
    /**
     *  部门名
     */
    private String deptName ;
    /**
     *  令牌
     */
    private String token ;

    @JsonDeserialize(using = CustomAuthorityDeserializer.class)
    private Collection<? extends GrantedAuthority> authorities;


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

    @Override
    public String getPassword() {
        return password;
    }

    @Override
    public String getUsername() {
        return username;
    }
}

10、CustomAuthorityDeserializer

package com.cx.cxBasic.common.config.authorization;

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * @Author: LLong
 * @CreateTime: 2023-12-13  11:19
 * @Description: TODO GrantedAuthority集合json解析
 * @Version: 1.0
 */
public class CustomAuthorityDeserializer extends JsonDeserializer<List<GrantedAuthority>> {

    @Override
    public List<GrantedAuthority> deserialize(JsonParser jp, DeserializationContext context) throws IOException {
        ObjectMapper mapper = (ObjectMapper) jp.getCodec();
        JsonNode jsonNode = mapper.readTree(jp);
        List<GrantedAuthority> grantedAuthorities = new ArrayList<>();
        Iterator<JsonNode> elements = jsonNode.elements();
        while (elements.hasNext()) {
            JsonNode next = elements.next();
            JsonNode authority = next.get("authority");
            grantedAuthorities.add(new SimpleGrantedAuthority(authority.asText()));
        }
        return grantedAuthorities;
    }
}
老友@
关注
  • 19
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
使用网关和Spring Security进行认证和授权
weixin_44976692的博客
07-16 1万+
网关是微服务架构中的一个重要组件，它充当系统的入口，负责请求的路由、负载均衡、限流、熔断、日志记录等功能。通过网关，可以实现对外部请求的统一管理和控制，提高系统的安全性和可维护性。Spring Security是一个功能强大且高度可定制的安全框架，专为Java应用提供认证和授权服务。它可以与各种身份验证机制（如LDAP、OAuth2、JWT）集成，提供全面的安全解决方案。
Spring Security进行登录认证和授权
afjja的博客
08-19 5919
我们要定制化实现接口来达到从数据库查询用户信息，所以重新写一个实现类。然后认证通过使用用户id生成一个jwt（也就是token），然后用userId作为key,用户信息作为value存入redis中。用户第一次登陆认证流程如下图。导入依赖
如何利用SpringSecurity进行认证与授权
qq_63218110的博客
02-14 4662
本篇博客主要介绍SpringSecurity框架的学习，主要包含快速入门，以及认证、授权等方面的介绍，还涉及一些简单的自定义授权校验方法。
Spring Security认证和授权
play_big_knife的博客
12-20 940
Spring Security是Spring cloud的认证和授权的模块之一。认证和授权也是开发中安全的必要形式，有了安全，才能更好地保证项目的运行。
SpringSecurity和OAuth2认证授权流程
michael_linux的博客，一个小小小学生。滴水穿石，步步为营，只为那刹那芳华。
04-24 2968
1、SpringSecurity认证授权流程 1.1、SpringSecurity认证流程 1.2、SpringSecurity授权流程 2、SpringSecurityOAuth2认证授权流程 2.1、SpringSecurityOAuth2认证流程 2.2、刷新token（refresh_token）的流程 2.3、SpringSecurityOAuth2授权流程
SpringBoot的Spring Security用户授权和认证
qq_43880100的博客
10-14 2444
SpringBoot的Spring Security用户授权和认证
Spring Security的认证和授权（1）
weixin_43831002的博客
08-02 1995
Shiro本身是一个老牌的安全管理框架，有着众多的优点，例如轻量、简单、易于集成、可以在JavaSE环境中使用等。不过，在微服务时代，Shiro就显得力不从心了，在微服务面前,它无法充分展示自己的优势。也有开发者选择自己实现安全管理，这一部分人不在少数，但是一个系统的安全，不仅仅是登录和权限控制这么简单，我们还要考虑各种各样可能存在的网络攻击以及防御策略，从这个角度来说，开发者自己实现安全管理也并非是一件容易的事情，只有大公司才有足够的人力物力去支持这件事情。...
简单介绍Spring Security 的认证机制和授权机制
www_tlj的专栏
02-04 1094
Spring Security 的认证机制提供了一个强大而灵活的框架，支持多种认证方式，并允许通过自定义扩展来满足各种安全需求。通过正确配置和使用Spring Security，开发者可以为应用程序建立一个可靠的认证和安全模型。Spring Security的授权机制提供了灵活强大的访问控制能力，从简单的基于URL的安全规则到复杂的方法级安全和ACL。通过组合使用这些授权策略，开发者可以构建出既安全又灵活的应用程序，确保只有授权的用户才能访问敏感资源。
Spring Security基本框架之认证和授权
大后生大大大的博客
11-11 909
Authentication、AuthenticationManager、AuthenticationProvider、ProviderManager、AccessDecisionMamager、AccessDecisionVoter
Spring Security登录的认证和授权
S mile0804的博客
02-21 4322
一、Spring Security简介 Spring Security是一个专注于为Java应用程序提供身份认证和授权的框架，是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC，DI（控制反转Inversion of Control ,DI:Dependency Injection 依赖注入）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了......
Java课程实验 Spring Security 实现用户认证和授权管理
07-07
要在Spring Boot中实现用户认证和授权管理，你可以使用Spring Security框架。Spring Security提供了一套强大的功能来处理用户身份验证和授权，以下是一些常见的步骤： 1.添加Spring Security依赖： 在项目的 pom.xml...
Spring security认证授权
11-30
- 可以自定义未授权和未认证的处理方式，比如重定向到特定页面或者返回JSON响应。 综上所述，这个Spring Security的例子展示了如何结合数据库动态配置用户信息，实现认证和授权功能。通过理解并实践这些概念，...
Spring Security Oauth2.0认证授权专题
06-19
Spring boot+Spring Security Oauth2.0，Sprint cloud+Spring Security Oauth2集成。四种认证方式。附带有代码，和案例，案例，还有视频链接。我保证看完就回，如果视频链接失效，评论回复我，我单独再给你一份。
Spring Security OAuth2认证授权示例详解
08-25
通过以上讲解，我们可以看到Spring Security OAuth2如何帮助开发者构建安全的认证和授权系统，以及如何使用OAuth2授权协议来保护用户数据。理解这些概念和配置细节对于开发涉及用户数据交换和安全访问控制的现代Web...
高级java每日一道面试题-2024年8月28日-框架篇[Spring篇]-Spring 框架是什么?
qq_43071699的博客
08-28 797
1. 定义与起源Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。它由Rod Johnson最早提出，目的是解决企业级应用开发的复杂性，简化Java开发。2. 核心特性控制反转（IoC）：也称为依赖注入（DI），是Spring框架的核心。它将对象的创建和依赖关系的管理交给了容器，降低了代码间的耦合度。面向切面编程（AOP）：Spring提供了丰富的AOP支持，允许开发者将横切关注点（如日志、事务管理等）从业务逻辑中分离出来，形成可重用的功能组件。
Spring Security 认证源码超详细分析
緑水長流*z
08-30 710
AbstractAuthenticationProcessingFilter 为处理认证请求提供了一个基础框架。这个抽象类主要用于处理 HTTP 请求，并将其转换为 Authentication 对象，然后提交给 AuthenticationManager 进行认证。这不就是我们前面介绍的 UsernamePasswordAuthenticationFilter 吗？
Spring理论知识（Ⅳ）——Spring Instrumentation模块
最新发布
敢问路在何方，路在脚下
09-02 442
总的来说，Spring Instrumentation提供了类植入（Instrumentation）支持和类加载器的实现，可以在特定的应用服务器中使用。本质上是一种JVM级别（操作系统级别）的AOP，用到了代理java.lang.instrument（容器类）做动态Instrumentation是Java SE 5的新特性使用 Instrumentation，开发者可以构建一个独立于应用程序的代理程序（Agent），用来监测和协助运行在 JVM 上的程序，甚至能够替换和修改某些类的定义。
Spring MVC 八股文
szchen2的博客
09-02 661
Spring MVC 是 Spring 提供的一个基于 MVC 设计模式的轻量级 Web 开发框架，本质上相当于 Servlet。它将model、view、controller分离，对web层进行解耦，把复杂的web应用分成逻辑清晰的几部分，简化开发，减少出错，方便组内开发人员之间的配合。
spring security 会话管理
冬阳
08-31 1125
当浏览器调用登录接口登录成功后，服务端会和浏览器之间建立一个会话(Session)浏览器在每次发送请求时都会携带一个 Sessionld，服务端则根据这个 Sessionld 来判断用户身份当浏览器关闭后，服务端的 Session 并不会自动销毁，需要开发者手动在服务端调用Session销毁方法，或者等 Session 过期时间到了自动销毁。
SpringSecurity实现认证和授权
11-02
Spring Security是一个开源的安全框架，提供了基于权限的访问控制、身份认证、安全性事件发布等功能。在Spring Boot应用中使用Spring Security可以非常方便地实现用户身份认证和授权。Spring Security实现身份认证和授权的步骤如下： 1.添加Spring Security依赖，可以在pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> ``` 2.创建一个继承自WebSecurityConfigurerAdapter的配置类，并重写configure方法，配置用户认证和授权信息。例如： ```java @Configuration @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Autowired public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception { auth.inMemoryAuthentication() .withUser("user").password("{noop}password").roles("USER") .and() .withUser("admin").password("{noop}password").roles("USER", "ADMIN"); } @Override protected void configure(HttpSecurity http) throws Exception { http.authorizeRequests() .antMatchers("/admin/**").hasRole("ADMIN") .antMatchers("/**").hasAnyRole("USER", "ADMIN") .and().formLogin(); } } ``` 上述代码中，configureGlobal方法配置了两个用户，一个是user，一个是admin，密码都是password，其中admin用户具有ADMIN角色，user用户具有USER角色。configure方法配置了访问/admin/**路径的请求需要ADMIN角色，访问其他路径的请求需要USER或ADMIN角色，并启用了表单登录。 3.在应用程序的配置文件中配置用户名和密码。例如： ```properties spring.security.user.name=user spring.security.user.password=password ``` 以上就是Spring Security实现身份认证和授权的基本步骤。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值