Spring组件之SpringSecurity

最新推荐文章于 2024-08-29 18:05:57 发布
最新推荐文章于 2024-08-29 18:05:57 发布
阅读量374 收藏 11
点赞数 10
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42508501/article/details/135362288
版权

1、SpringSecurity是什么

作为Spring生态圈中的一员，适配Spring下的安全框架，极其简单的配置操作就能让你的项目套上一层保护膜。SpringSecurity主要分为两部分，分别是认证和授权。其中核心就是他的过滤链（filter）。

2、账号密码认证

默认身份认证

在Maven中导入SpringSecurity时，在其自动配置类中就已经默认帮你实现了账号密码的默认登录页，其中DefaultSecurityConfig类中，需要注意的几点，使用了EnableWebSecurity注解开启Security配置,在#inMemoryUserDetailsManager方法中实现了用户名为user 密码随机生成并会打印到控制台。#defaultAuthenticationEventPublisher主要是发布认证的事件发布器。

@EnableWebSecurity
@Configuration
public class DefaultSecurityConfig {
    @Bean
    @ConditionalOnMissingBean(UserDetailsService.class)
    InMemoryUserDetailsManager inMemoryUserDetailsManager() {
        String generatedPassword = // ...;
        return new InMemoryUserDetailsManager(User.withUsername("user")
                .password(generatedPassword).roles("ROLE_USER").build());
    }

    @Bean
    @ConditionalOnMissingBean(AuthenticationEventPublisher.class)
    DefaultAuthenticationEventPublisher defaultAuthenticationEventPublisher(ApplicationEventPublisher delegate) {
        return new DefaultAuthenticationEventPublisher(delegate);
    }
}

SecurityContextHolder

Spring Security 的认证模型的核心是 SecurityContextHolder。它包含了SecurityContext，SecurityContext中保存了用户的细节，包括用户名和密码以及角色，可以直接尝试给SecurityContext赋值，来表明用户已被认证。默认情况下SecurityContextHolder使用ThreadLocal来存储，所以在同一线程中SecurityContextHolder总是可用的。

SecurityContext context = SecurityContextHolder.createEmptyContext();
Authentication authentication =
    new TestingAuthenticationToken("username", "password", "ROLE_USER");
context.setAuthentication(authentication);

SecurityContextHolder.setContext(context);

如何使用做一个简单的身份验证

@Configuration
@EnableWebSecurity
public class SecurityConfig {
 
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf(Customizer.withDefaults())
            .authorizeHttpRequests(authorize -> authorize
                .anyRequest().authenticated()
            )
            .httpBasic(Customizer.withDefaults())
            .formLogin(Customizer.withDefaults());
        return http.build();
    }
 
}

上述代码中是官方文档中给出的一段实例在这里插入图片描述
下面示例

package com.tcb.config;

import com.tcb.filter.JwtAuthenticationTokenFilter;
import com.tcb.utils.JwtTokenUtil;
import lombok.AllArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.ProviderManager;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
import org.springframework.security.config.Customizer;
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.config.http.SessionCreationPolicy;
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 Tu
 */
@Configuration
@EnableWebSecurity
@AllArgsConstructor
public class CustomSecurityConfig {

    private final JwtTokenUtil jwtTokenUtil;

    private final UserDetailsService userDetailsService;
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.csrf(AbstractHttpConfigurer::disable)
                .cors(Customizer.withDefaults())
                .sessionManagement(sessionManager -> sessionManager.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
                .authenticationManager(this.authenticationManager())
                // 配置 JwtTokenAuthenticationFilter
                .addFilterBefore(new JwtAuthenticationTokenFilter(
                                this.jwtTokenUtil,
                                this.userDetailsService()),
                        UsernamePasswordAuthenticationFilter.class)
                // 请求认证授权
                .authorizeHttpRequests(requests -> {
                    // 放行 POST 请求接口 /auth/signin，/auth/signup
                    requests.requestMatchers(HttpMethod.POST, "/auth/signin", "/auth/signup").permitAll()
                            // 放行 /test/** 接口所有请求
                            .requestMatchers("/test/**").permitAll()
                            // 其余请求，一律需要进行认证
                            .anyRequest().authenticated();
                });
        return http.build();
    }
    // 密码加密器
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    // 获取用户及其相关详细信息
    @Bean
    public UserDetailsService userDetailsService() {
        return new UserDetailsService() {
            @Override
            public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
                User user = userService.findUser(username);
                if (null == user) {
                    throw new UsernameNotFoundException(String.format("[username: %s] not found!", username));
                }
                return user;
            }
        };
    }

    // 负责具体用户认证流程
    @Bean
    public AuthenticationProvider authenticationProvider() {
        // 创建一个用户认证提供者
        DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider();
        // 将该 Provider 关联到我们设置的 UserDetailsService
        authProvider.setUserDetailsService(this.userDetailsService());
        // 关联到我们设置的加密算法
        authProvider.setPasswordEncoder(this.passwordEncoder());
        return authProvider;
    }

    // 认证管理者
    @Bean
    public AuthenticationManager authenticationManager() {
        // 关联到我们设置的 AuthenticationProvider
        return new ProviderManager(this.authenticationProvider());
    }

}

自定义Jwt工具类生成token

package com.tcb.utils;


import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.userdetails.UserDetails;

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * @author tu.cb
 */
@Slf4j
public class JwtTokenUtil {


    @Value("${jwt.secret}")
    private String secret;
    @Value("${jwt.expiration}")
    private Long expiration;
    @Value("${jwt.tokenHead}")
    private String tokenHead;

    private static final String CLAIM_KEY_USERNAME = "sub";
    private static final String CLAIM_KEY_CREATED = "created";

    /**
     * 根据用户信息生成token
     */
    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        claims.put(CLAIM_KEY_USERNAME, userDetails.getUsername());
        claims.put(CLAIM_KEY_CREATED, System.currentTimeMillis());
        return generateToken(claims);
    }

    /**
     * 根据用户名、创建时间生成JWT的token
     */
    private String generateToken(Map<String, Object> claims) {
        return Jwts.builder()
                .setClaims(claims)
                .setExpiration(generateExpirationDate())
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }

    private Date generateExpirationDate() {
        return new Date(System.currentTimeMillis() + expiration * 1000);
    }

    /**
     * 从token中获取登录用户名
     */
    public String getUserNameFromToken(String token) {
        String username = null;
        Claims claims = getClaimsFromToken(token);
        if (claims != null) {
            username = claims.getSubject();
        }

        return username;
    }

    /**
     * 从token中获取JWT中的负载
     */
    private Claims getClaimsFromToken(String token) {
        Claims claims = null;
        try {
            claims = Jwts.parser()
                    .setSigningKey(secret)
                    .parseClaimsJws(token)
                    .getBody();
        } catch (Exception e) {
            log.info("JWT格式验证失败:{}", token);
        }
        return claims;
    }

    /**
     * 验证token是否还有效
     *
     * @param token       客户端传入的token
     * @param userDetails 从数据库中查询出来的用户信息
     */
    public boolean validateToken(String token, UserDetails userDetails) {
        String username = getUserNameFromToken(token);
        return username.equals(userDetails.getUsername()) && !isTokenExpired(token);
    }

    /**
     * 判断token是否已经失效
     */
    public boolean isTokenExpired(String token) {
        Date expiredDate = getExpiredDateFromToken(token);
        return expiredDate.before(new Date());
    }

    /**
     * 从token中获取过期时间
     */
    private Date getExpiredDateFromToken(String token) {
        Claims claims = getClaimsFromToken(token);
        return claims.getExpiration();
    }
}

JWT过滤器，在HttpSecurity中添加到过滤链中

package com.tcb.filter;

import com.tcb.service.LoginService;
import com.tcb.service.RedisServer;
import com.tcb.utils.JwtTokenUtil;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import java.io.IOException;

/**
 * JWT登录授权过滤器
 *    on 2018/4/26.
 */
@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
    private static final Logger LOGGER = LoggerFactory.getLogger(JwtAuthenticationTokenFilter.class);

    private final LoginService loginService;

    private final RedisServer redisServer;

    private final JwtTokenUtil jwtTokenUtil;

    @Value("${jwt.tokenHeader}")
    private String tokenHeader;

    @Value("${jwt.tokenHead}")
    private String tokenHead;

    @Value("${redis.redisPrefix}")
    private String redisPrefix;

    public JwtAuthenticationTokenFilter(LoginService loginService, RedisServer redisServer, JwtTokenUtil jwtTokenUtil) {
        this.loginService = loginService;
        this.redisServer = redisServer;
        this.jwtTokenUtil = jwtTokenUtil;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain chain) throws ServletException, IOException {
        // 从客户端请求中获取 JWT
        String authHeader = request.getHeader(this.tokenHeader);
        // 该 JWT 是我们规定的格式，以 tokenHead 开头
        if (authHeader != null && authHeader.startsWith(this.tokenHead)) {
            // The part after "Bearer "
            String authToken = authHeader.substring(this.tokenHead.length());
            // 从 JWT 中获取用户名
            String username = jwtTokenUtil.getUserNameFromToken(authToken);
            LOGGER.info("checking username:{}", username);
            // SecurityContextHolder 是 SpringSecurity 的一个工具类
            // 保存应用程序中当前使用人的安全上下文
            if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
                // 根据用户名获取登录用户信息
                UserDetails userDetails = this.loginService.loadUserByUsername(username);
                // 验证 token 是否过期
                if (jwtTokenUtil.validateToken(authToken, userDetails)&&redisServer.getValue(redisPrefix+username).equals(authToken)) {
                    // 将登录用户保存到安全上下文中
                    UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails,
                            null, userDetails.getAuthorities());
                    authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                    SecurityContextHolder.getContext().setAuthentication(authentication);
                    LOGGER.info("authenticated user:{}", username);
                }
            }
        }
        chain.doFilter(request, response);
    }
}

然后根据自定义登录逻辑判断写一个Service类来判断账号密码是否正确。
引用：
1、https://springdoc.cn/spring-security/ Spring Security中文文档

前夕zz
关注
spring security原理和机制 | Spring Boot 35
学Java，找哪吒
06-25 5万+
一、SpringSecurity 框架简介 Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的 成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方 案。 正如你可能知道的关于安全方面的两个主要区域是“认证”和“授权”（或者访问控 制），一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权 （Authorization）两个部分，这两点也是 Spring
SpringSecurity组件
Fujiwara_Takumi的博客
10-21 197
编写spring-security.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:security="http://www.springframework.org/schema/security...
深入理解Spring Security
最新发布
weixin_51052174的博客
08-29 1070
Spring Security是一个功能强大且灵活的安全框架，专为保护基于Spring的应用程序而设计。它提供了一系列安全服务，包括身份验证、授权、攻击防护、会话管理等，帮助开发者轻松实现应用程序的安全控制。
Spring Security——组件
violetlove的专栏
09-05 406
一、Security Interceptor：         Security Interceptor组件是Spring Security中最重要的组件，它用来鉴定一个请求是否可以访问某个资源。包含一个抽象类AbstractSecurityInterceptor，以及两个具体的实现类FilterSecurityInterceptor 以及MethodSecurityInterceptor。 ...
spring security
weixin_43060721的博客
01-07 635
spring security工作原理简介 spring security和springmvc配合使用可以提供安全性，可以通过注册org.springframework.web.filter.DelegatingFilterProxy这个filter进行安全管理，也可以扩展AbstractSecurityWebApplicationInitializer类进行java方式的配置，AbstractS...
20个SpringSecurity框架核心组件详解
威哥爱编程，CSDN 博客专家、全栈领域新星创作者、华为 HDE，愿交天下 IT 技术爱好者
03-22 1149
其运行过程是在用户发送请求时被调用，根据请求的路径匹配相应的 SecurityFilterChain，并按照配置的安全过滤器链对请求进行处理。SecurityContextHolder 是 Spring Security 中非常重要的组件之一，它为安全框架的运行提供了关键的支持。通过配置不同的过滤器链，开发人员可以实现灵活的安全策略，包括身份验证、授权、会话管理等功能。通常情况下，开发人员需要实现自己的 UserDetails 类，从数据源中加载用户信息，并提供相应的方法来获取用户的身份信息和权限信息。
springsecurity学习笔记
12-13
在"springsecurity学习笔记"中，你可能会涉及以下主题： - Spring Security的基本配置，包括web安全配置和全局安全配置。 - 如何自定义认证和授权流程，比如实现自定义的AuthenticationProvider和...
全面解析Spring Security 过滤器链的机制和特性
08-18
在 Spring Security 中，FilterChainProxy 是一个核心组件，负责代理众多的 Spring Security Filter。FilterChainProxy 在 WebSecurityConfiguration 中以 springSecurityFilterChain 的名称注册为 Spring Bean。...
详解spring security 配置多个AuthenticationProvider
08-30
Spring Security 配置多个 AuthenticationProvider 详解 Spring Security 是一个功能强大且灵活的安全框架，提供了多种身份验证机制和访问控制机制。在实际开发中，我们经常需要配置多个身份验证提供程序...
Spring Security
weixin_44543307的博客
05-03 201
开发工具与关键技术：IntelliJ IDEA java 作者：木林森 撰写时间：2021年 5月 3 日 Spring Security 是spring的安全框架。它是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架，简单来说就是一个功能强大且高度可定制的身份验证和访问控制框架。它提供了一组可以在Spring应用上下文中 配置的Bean，充分利用了Spring IoC，DI（控制反转Inversion of Control ,DI:Dependency Inject
狂神说SpringBoot18：集成SpringSecurity
热门推荐
狂神说
03-29 1万+
狂神说SpringBoot系列连载课程，通俗易懂，基于SpringBoot2.2.5版本，欢迎各位狂粉转发关注学习。未经作者授权，禁止转载SpringSecurity安全简介在 Web ...
SpringSecurity安全框架学习笔记
清茶淡粥的博客
12-31 1044
Spring Security Spring Security简介 Spring Security 是一种高度自定义的安全框架，利用（基于）SpringIOC/DI和AOP功能，为系统提供了声明式安全访问控制功能，减少了为系统安全而编写大量重复代码的工作。 核心功能：认证和授权 Spring Security 认证流程 Spring Security 项目搭建 导入依赖 Spring Security已经被Spring boot进行集成，使用时直接引入启动器即可 <dependency>
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值