当前位置： 首页 > article >正文

SpringSecurity-用户认证

article 2025/1/17 8:03:05

1、用户认证

1.1 用户认证核心组件

我们系统中会有许多用户，确认当前是哪个用户正在使用我们系统就是登录认证的最终目的。这里我们就提取出了一个核心概念：当前登录用户/当前认证用户。整个系统安全都是围绕当前登录用户展开的，这个不难理解，要是当前登录用户都不能确认了，那A下了一个订单，下到了B的账户上这不就乱套了。这一概念在Spring Security中的体现就是 Authentication，它存储了认证信息，代表当前登录用户。

我们在程序中如何获取并使用它呢？我们需要通过 SecurityContext 来获取Authentication，SecurityContext就是我们的上下文对象！这个上下文对象则是交由 SecurityContextHolder 进行管理，你可以在程序任何地方使用它：

Authentication authentication = SecurityContextHolder.getContext().getAuthentication();

SecurityContextHolder原理非常简单，就是使用ThreadLocal来保证一个线程中传递同一个对象,什么是ThreadLocal呢？ThreadLocal也叫线程变量，提供了线程本地的实例

1.2 Spring Security中三个核心组件

1、Authentication：存储了认证信息，代表当前登录用户

2、SeucirtyContext：上下文对象，用来获取Authentication

3、SecurityContextHolder：上下文管理对象，用来在程序任何地方获取SecurityContext

Authentication中是什么信息呢：

1、Principal：用户信息，没有认证时一般是用户名，认证后一般是用户对象

2、Credentials：用户凭证，一般是密码

3、Authorities：用户权限

2. 进行用户认证的流程

AuthenticationManager 就是Spring Security用于执行身份验证的组件，只需要调用它的authenticate方法即可完成认证。Spring Security默认的认证方式就是在UsernamePasswordAuthenticationFilter这个过滤器中进行认证的，该过滤器负责认证逻辑。

Spring Security用户认证关键代码如下：

// 生成一个包含账号密码的认证信息
Authentication authenticationToken = new UsernamePasswordAuthenticationToken(username, passwrod);
// AuthenticationManager校验这个认证信息，返回一个已认证的Authentication
Authentication authentication = authenticationManager.authenticate(authenticationToken);
// 将返回的Authentication存到上下文中
SecurityContextHolder.getContext().setAuthentication(authentication);

2.1 认证接口分析

AuthenticationManager的校验逻辑比较简单：

根据用户名先查询出用户对象(没有查到则抛出异常)将用户对象的密码和传递过来的密码进行校验，密码不匹配则抛出异常。

重点是这里每一个步骤Spring Security都提供了相关的组件：

1、是谁执行 根据用户名查询出用户对象 逻辑的呢？用户对象数据可以存在内存中、文件中、数据库中，你得确定好怎么查才行。这一部分就是交由**UserDetialsService** 处理，该接口只有一个方法loadUserByUsername(String username)，通过用户名查询用户对象，默认实现是在内存中查询。

2、那查询出来的 用户对象 又是什么呢？每个系统中的用户对象数据都不尽相同，咱们需要确认我们的用户数据是啥样的才行。Spring Security中的用户数据则是由**UserDetails** 来体现，该接口中提供了账号、密码等通用属性。

3、对密码进行校验：Spring Security框架除了if、else外还解决了密码加密的问题，这个组件就是**PasswordEncoder**，负责密码加密与校验。

PasswordEncoder接口如下：

package org.springframework.security.crypto.password;

public interface PasswordEncoder {
    String encode(CharSequence var1);

    boolean matches(CharSequence var1, String var2);

    default boolean upgradeEncoding(String encodedPassword) {
        return false;
    }
}

2.2 分析结果：

UserDetialsService、UserDetails、PasswordEncoder，这三个组件Spring Security都有默认实现，这一般是满足不了我们的实际需求的，所以这里需要我们自己来实现这些组件，对组件自定义实现。

3.在项目实现用户认证

这里我们采用MD5加密方式

在项目中建立utils包，导入MD5工具类

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;


public final class MD5 {

    public static String encrypt(String strSrc) {
        try {
            char hexChars[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8',
                    '9', 'a', 'b', 'c', 'd', 'e', 'f' };
            byte[] bytes = strSrc.getBytes();
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(bytes);
            bytes = md.digest();
            int j = bytes.length;
            char[] chars = new char[j * 2];
            int k = 0;
            for (int i = 0; i < bytes.length; i++) {
                byte b = bytes[i];
                chars[k++] = hexChars[b >>> 4 & 0xf];
                chars[k++] = hexChars[b & 0xf];
            }
            return new String(chars);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            throw new RuntimeException("MD5加密出错！！+" + e);
        }
    }

    public static void main(String[] args) {
        System.out.println(MD5.encrypt("111111"));
    }
}

3.1 自定义加密处理组件：CustomMd5PasswordEncoder

提示：@component：  标注一个类为Spring容器的Bean

import com.atguigu.common.utils.MD5;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;


@Component
public class CustomMd5PasswordEncoder implements PasswordEncoder {
    public String encode(CharSequence rawPassword) {
        return MD5.encrypt(rawPassword.toString());
    }

    public boolean matches(CharSequence rawPassword, String encodedPassword) {
        return encodedPassword.equals(MD5.encrypt(rawPassword.toString()));
    }
}

3.2 用户对象UserDetails

该接口就是我们所说的用户对象，它提供了用户的一些通用属性，源码如下：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.springframework.security.core.userdetails;

import java.io.Serializable;
import java.util.Collection;
import org.springframework.security.core.GrantedAuthority;

public interface UserDetails extends Serializable {
    Collection<? extends GrantedAuthority> getAuthorities();

    String getPassword();

    String getUsername();

    boolean isAccountNonExpired();

    boolean isAccountNonLocked();

    boolean isCredentialsNonExpired();

    boolean isEnabled();
}

实际开发中我们的用户属性各种各样，这些默认属性可能是满足不了，所以我们一般会自己实现该接口，然后设置好我们实际的用户实体对象。实现此接口要重写很多方法比较麻烦，我们可以继承Spring Security提供的org.springframework.security.core.userdetails.User类，该类实现了UserDetails接口帮我们省去了重写方法的工作：

添加自定义对象

3.3 添加UserDetailsServiceImpl类，实现UserDetailsService接口

到此AuthenticationManager校验所调用的三个组件已经进行自定义实现，接下来编写自定义用户认证接口，在filter包下创建TokenLoginFilter类

public class TokenLoginFilter extends UsernamePasswordAuthenticationFilter {

    public TokenLoginFilter(AuthenticationManager authenticationManager) {
        this.setAuthenticationManager(authenticationManager);
        this.setPostOnly(false);
        //指定登录接口及提交方式，可以指定任意路径
        this.setRequiresAuthenticationRequestMatcher(new AntPathRequestMatcher("/admin/system/index/login","POST"));
    }

    /**
     * 登录认证
     * @param req
     * @param res
     * @return
     * @throws AuthenticationException
     */
    @Override
    public Authentication attemptAuthentication(HttpServletRequest req, HttpServletResponse res)
            throws AuthenticationException {
        try {
            LoginVo loginVo = new ObjectMapper().readValue(req.getInputStream(), LoginVo.class);

            Authentication authenticationToken = new UsernamePasswordAuthenticationToken(loginVo.getUsername(), loginVo.getPassword());
            return this.getAuthenticationManager().authenticate(authenticationToken);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }

    /**
     * 登录成功
     * @param request
     * @param response
     * @param chain
     * @param auth
     * @throws IOException
     * @throws ServletException
     */
    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain,
                                            Authentication auth) throws IOException, ServletException {
        CustomUser customUser = (CustomUser) auth.getPrincipal();
        String token = JwtHelper.createToken(customUser.getSysUser().getId(), customUser.getSysUser().getUsername());

        Map<String, Object> map = new HashMap<>();
        map.put("token", token);
        ResponseUtil.out(response, Result.ok(map));
    }

    /**
     * 登录失败
     * @param request
     * @param response
     * @param e
     * @throws IOException
     * @throws ServletException
     */
    @Override
    protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response,
                                              AuthenticationException e) throws IOException, ServletException {

        if(e.getCause() instanceof RuntimeException) {
            ResponseUtil.out(response, Result.build(null, 204, e.getMessage()));
        } else {
            ResponseUtil.out(response, Result.build(null, ResultCodeEnum.LOGIN_MOBLE_ERROR));
        }
    }
}

3.4 认证解析token

分析：由于用户登录状态在token中存储在客户端，所以每次请求接口请求头携带token， 后台通过自定义token过滤器拦截解析token完成认证并填充用户信息实体。

filter包中创建TokenAuthenticationFilter类，实现认证解析过程

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.util.CollectionUtils;
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.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;

public class TokenAuthenticationFilter extends OncePerRequestFilter {

    private RedisTemplate redisTemplate;
    public TokenAuthenticationFilter(RedisTemplate redisTemplate){
        this.redisTemplate = redisTemplate;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request,//请求
                                    HttpServletResponse response,//响应
                                    FilterChain chain) throws ServletException, IOException {//获取请求头中的token
        logger.info("uri:"+request.getRequestURI());
        //如果是登录接口，直接放行
        if("/admin/system/index/login".equals(request.getRequestURI())) {
            chain.doFilter(request, response);
            return;
        }
        //如果不是登录接口，则需要验证token
        UsernamePasswordAuthenticationToken authentication = getAuthentication(request);
        if(null != authentication) {
            //如果token不为空，则设置到SecurityContextHolder中
            SecurityContextHolder.getContext().setAuthentication(authentication);
            //放行
            chain.doFilter(request, response);
        } else {
            //如果token为空，则返回错误信息
            ResponseUtil.out(response, Result.build(null, ResultCodeEnum.LOGIN_MOBLE_ERROR));
        }
    }
    //获取token
    private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
        //从请求头中获取token
        String token = request.getHeader("token");
        if(!StringUtils.isEmpty(token)){
            //从token中获取用户名称
            String username = JwtHelper.getUsername(token);
            if(!StringUtils.isEmpty(username)){
                //从redis中获取用户权限信息
                String authString = (String) redisTemplate.opsForValue().get(username);
                if(!StringUtils.isEmpty(authString))
                {
                    //将权限信息转换为SimpleGrantedAuthority对象
                    List<Map> mapList = JSON.parseArray(authString,Map.class);
                    System.out.println(mapList);
                    //遍历权限信息，将每个权限转换为SimpleGrantedAuthority对象
                    List<SimpleGrantedAuthority> authList = new ArrayList<>();
                    for (Map map:mapList) {
                        //获取权限字符串
                        String authority = (String) map.get("authority");
                        authList.add(new SimpleGrantedAuthority(authority));
                    }
                    //返回UsernamePasswordAuthenticationToken对象
                    return new UsernamePasswordAuthenticationToken(username,null, authList);
                }else {
                    //如果redis中没有权限信息，则返回空的SimpleGrantedAuthority对象
                    return new UsernamePasswordAuthenticationToken(username,null, new ArrayList<>());
                }

            }
            }
        return null;
        }
    }

3.5 进行用户认证配置



import com.atguigu.security.custom.CustomMd5PasswordEncoder;
import com.atguigu.security.filter.TokenAuthenticationFilter;
import com.atguigu.security.filter.TokenLoginFilter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.security.authentication.AuthenticationManager;
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.builders.WebSecurity;
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.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.cors.CorsUtils;

@Configuration
@EnableWebSecurity //@EnableWebSecurity是开启SpringSecurity的默认行为
@EnableGlobalMethodSecurity(prePostEnabled = true)//开启注解功能，默认禁用注解
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private UserDetailsService userDetailsService;//自定义的UserDetailsService

    @Autowired
    private CustomMd5PasswordEncoder customMd5PasswordEncoder; //自定义的密码加密器


    @Bean // 将AuthenticationManager注册为Bean，方便在其他地方使用
    @Override
    protected AuthenticationManager authenticationManager() throws Exception {// 重写authenticationManager方法，返回AuthenticationManagerBuilder
        return super.authenticationManager();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 这是配置的关键，决定哪些接口开启防护，哪些接口绕过防护
        http
                //关闭csrf跨站请求伪造
                .csrf().disable()
                // 开启跨域以便前端调用接口
                .cors().and()
                .authorizeRequests()
                // 指定某些接口不需要通过验证即可访问。登陆接口肯定是不需要认证的
                .antMatchers("/admin/system/index/login").permitAll()
                // 这里意思是其它所有接口需要认证才能访问
                .anyRequest().authenticated()
                .and()
                //TokenAuthenticationFilter放到UsernamePasswordAuthenticationFilter的前面，这样做就是为了除了登录的时候去查询数据库外，其他时候都用token进行认证。
                .addFilterBefore(new TokenAuthenticationFilter(redisTemplate), UsernamePasswordAuthenticationFilter.class)
                .addFilter(new TokenLoginFilter(authenticationManager(),redisTemplate));

        //禁用session
        http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 指定UserDetailService和加密器
        auth.userDetailsService(userDetailsService)
                .passwordEncoder(customMd5PasswordEncoder);
    }

    /**
     * 配置哪些请求不拦截
     * 排除swagger相关请求
     * @param web
     * @throws Exception
     */
    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers("/favicon.ico","/swagger-resources/**", "/webjars/**", "/v2/**", "/swagger-ui.html/**", "/doc.html");
    }
}


http://www.kler.cn/a/320085.html

相关文章：

  • centos使用dpdk库
  • Redisson
  • 11-天猫订单数据分析
  • 题解 CodeForces 430B Balls Game 栈 C/C++
  • 通过将模型权重的矩阵表示为低秩矩阵，可以减少需要调整的参数数量，通俗易懂的解释，不懂你爬网线打我
  • c++领域展开第十二幕——类和对象（STL简介——简单了解STL）超详细！！！！
  • JAVA基础语法 day07
  • 全能通人工智能的能力评估框架-Levels of AGI: Operationalizing Progress on the Path to AGI
  • 欺诈文本分类检测（十六）：支持分类原因评测改造
  • 面经 | 手写
  • 口语笔记——被动语态
  • spring boot 项目中redis的使用，key=value值 如何用命令行来查询并设置值。
  • 001、restful设计规范
  • OpenHarmony（鸿蒙南向）——平台驱动开发【SDIO】
  • golang雪花算法实现64位的ID
  • JWT（JSON Web Tokens) 详细介绍
  • LeetCode - 503 下一个更大元素 II
  • 使用iTextPDF库实现矩形框和打勾符号（√）
  • 【网络安全】更改参数实现试用计划延长
  • 国内可用ChatGPT-4中文镜像网站整理汇总【持续更新】
  • keepalived+lvs集群
  • 体育馆管理系统|基于SpingBoot+vue的体育馆管理系统(源码+数据库+文档)
  • 微信小程序-分包加载
  • AWS开启MFA，提高安全性
  • 数据库——sql语言学习 查找语句
  • 【CSS】鼠标 、轮廓线 、 滤镜 、 堆叠层级