基于SpringSecurity新API并接收Json的SpringSecurity用户验证

原创 已于 2023-08-08 17:16:35 修改 · 289 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
SpringSecurity

当前文章被收录于：

SpringSecurity
1 篇文章 0 人学习
订阅专栏 查看详情
于 2023-08-08 17:10:06 首次发布

关于使用JSON传输数据来实现SpringSecurity用户验证的解决方案

前情摘要

  1. 本方案是解决WebConfigrationAdapter过时，利用新API解决的方案

  2. 本方案是解决传统表单提交数据，改用JSON传输数据

  3. 本方案使用了官方推荐的Bcytpe加密算法，将存储用户密码，解密，都使用了以上加密算法

  4. 最后，希望本套解决方案能够帮助您在使用SpringSecurity中解决一些问题

参考文章:【深入浅出Spring Security（五）】自定义过滤器进行前后端登录认证

ps:上面的大佬关于SpringSecurity有着深厚的理解，大家可以去学习学习

我们就废话不多说，开始我们的解决方案

我们需要干些什么？

1.引入依赖

 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.3.1</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter-test</artifactId>
            <version>2.3.1</version>
            <scope>test</scope>
        </dependency>
        <!--jwt依赖-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>
        <!--德鲁伊数据库连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.18</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.27</version>
        </dependency>
        <!--spring boot web模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
        </dependency>
     <!--配置文件提示-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
     <!--SpringSecurity依赖-->
        <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
        </dependency>

2.关于springSecurity老的表单认证

我们需要知道，老的表单认证，我们是基于UsernamePasswordFilter这个过滤器的

那我们需要做什么：新创建一个类去继承UsernamePasswordFilter,然后重写里面的方法 ——attemptAuthentication(HttpServletRequest request, HttpServletResponse response)

JsonUsernamePasswordFilter.java

package com.hitBadminton.security;

import com.fasterxml.jackson.databind.ObjectMapper;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.AuthenticationServiceException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;


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

public class JsonUsernamePasswordFilter extends UsernamePasswordAuthenticationFilter {
    @Autowired
    ObjectMapper objectMapper;

    public JsonUsernamePasswordFilter() {
    }

    public JsonUsernamePasswordFilter(AuthenticationManager authenticationManager) {
        super(authenticationManager);
    }


    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {

        // 判断请求方式是否是 POST 方式
        if (!request.getMethod().equals("POST")) {
            throw new AuthenticationServiceException("Authentication method not supported: " + request.getMethod());
        }
        // 然后判断是否是 JSON 格式的数据
        if (request.getContentType().equalsIgnoreCase(MediaType.APPLICATION_JSON_VALUE)) {
            // 如果是的话就从 JSON 中取出用户信息进行认证
            try {
                //使用jackson读取json
                Map<String, String> userInfo = objectMapper.readValue(request.getInputStream(), Map.class);
                String username = userInfo.get(getUsernameParameter());
                String password = userInfo.get(getPasswordParameter());
                // 封装成Authentication
                UsernamePasswordAuthenticationToken authRequest = UsernamePasswordAuthenticationToken.unauthenticated(username, password);
                // 仿造父类去调用AuthenticationManager.authenticate认证就可以了
                setDetails(request, authRequest);
                return getAuthenticationManager().authenticate(authRequest);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        // 否则用父类的方式去认证
        return super.attemptAuthentication(request, response);
    }
}

3.在springSecurity的配置类中将这个JSONUsernamePasswordFilter替换掉原有的UsernamePasswordFilter

以前我们需要自己新建一个类去继承WebConfigurationAdepter

like this :

public class WebConfig extends WebConfigurationAdepter {
   
}

但是现在springSecurity升级过后，将 WebConfigrationAdepter 标注 WebConfigrationAdepter ，那么这个方法就过时了。

那我们就使用新的API去配置SpringSecurity的配置类

WebSecurityConfig.java

package com.hitBadminton.config;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.hitBadminton.security.JsonUsernamePasswordFilter;
import com.hitBadminton.security.UserDetailsServiceImpl;
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.config.annotation.authentication.builders.AuthenticationManagerBuilder;
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.configuration.WebSecurityConfiguration;

import org.springframework.security.config.annotation.web.configuration.WebSecurityCustomizer;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
//@Configuration 可标可不标
//因为@EnableWebSecurity 已经包含了@Configuration
@EnableWebSecurity
public class WebSecurityConfig {
    @Autowired
    ObjectMapper objectMapper;
    @Autowired
    UserDetailsServiceImpl userDetailsService;
    @Bean
    public WebSecurityCustomizer webSecurityCustomizer() {
        return web -> web.ignoring().antMatchers(HttpMethod.POST,"/user");
    }
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        return http.authorizeRequests()
                .anyRequest()
                .authenticated()
                .and()
                .logout()
                .logoutSuccessHandler(this::onAuthenticationSuccess)
                .logoutUrl("/logout")
                .and()
            	//.addFilterAt 替换掉目标类
                .addFilterAt(JsonUsernamePasswordFilter(http), UsernamePasswordAuthenticationFilter.class)
                .csrf()
                .disable()
                .build();
    }

    /**
     * 自定义 AuthenticationManager
     *
     * @param http
     * @return AuthenticationManager
     * @throws Exception
     */
    @Bean
    public AuthenticationManager authenticationManager(HttpSecurity http) throws Exception {
        return http.
                getSharedObject(AuthenticationManagerBuilder.class)
                .userDetailsService(userDetailsService)
                .and()
                .build();
    }

    @Bean
    public JsonUsernamePasswordFilter JsonUsernamePasswordFilter(HttpSecurity http) throws Exception {
        JsonUsernamePasswordFilter filter = new JsonUsernamePasswordFilter(authenticationManager(http));
        // 自定义 JSON 的 key
        filter.setUsernameParameter("username");
        filter.setPasswordParameter("password");
        // 自定义接收的url，默认是login
        // 此过滤器的doFilter是在AbstractAuthenticationProcessingFilter，在那里进行的url是否符合的判定
        filter.setFilterProcessesUrl("/user/login");
        // 设置login成功返回的JSON数据
        filter.setAuthenticationSuccessHandler(this::onAuthenticationSuccess);
        // 设置login失败返回的JSON数据
        filter.setAuthenticationFailureHandler(this::onAuthenticationFailure);
        return filter;
    }

    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
                                        Authentication authentication) throws IOException, ServletException {
        response.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=utf-8");
        PrintWriter out = response.getWriter();
        if (request.getRequestURI().endsWith("/login"))
            out.write(objectMapper.writeValueAsString("登录成功"));
        else if (request.getRequestURI().endsWith("/logout"))
            out.write(objectMapper.writeValueAsString("注销成功"));
        out.close();
    }

    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
                                        AuthenticationException exception) throws IOException, ServletException {
        response.setContentType("text/html;charset=utf-8");
        PrintWriter out = response.getWriter();
        out.write(objectMapper.writeValueAsString("登录失败"));
        out.close();
    }
    /**
     * 向容器注入passwordEncoder进行加密
     * @return
     */
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();//官方推荐使用BCryptPasswordEncoder，更安全！！！
    }
}

4.接下来去实现我们的UserDetailsService

UserDetailsServiceImpl

package com.hitBadminton.security;


import com.hitBadminton.service.UserService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.userdetails.User;
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 java.util.List;

@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Autowired
    UserService userService;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        if (userService.getUserDetail(username) == null) {
            throw new UsernameNotFoundException("用户不存在");
        }
        com.hitBadminton.pojo.User user = userService.getUserDetail(username);
        String encodePassword = user.getUserPassword();
        //这里demo随便写的权限list
        List<GrantedAuthority> list = AuthorityUtils.commaSeparatedStringToAuthorityList("admin");
        return new User(user.getUserId(), encodePassword, list);
    }

}

PasswordUtils

package com.hitBadminton.utills;

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

public class PasswordUtils {
   public static BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
    public static String encodePassword(String rawPassword) {
        return bCryptPasswordEncoder.encode(rawPassword);
    }
}

接下来的操作都大同小异，你们就自己实现啦~

注意事项

  1. 我们在使用Bcypt加密需要将password字段长度设置至少大于60
public class PasswordUtils {
   public static BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
    public static String encodePassword(String rawPassword) {
        return bCryptPasswordEncoder.encode(rawPassword);
    }
}

接下来的操作都大同小异，你们就自己实现啦~

注意事项

  1. 我们在使用Bcypt加密需要将password字段长度设置至少大于60

测试效果

1.登录（username & password == true）
在这里插入图片描述
2.登录（username & password != true）
在这里插入图片描述

标签
#json #spring #java
spring boot整合spring security（前后端分离时的json登录方式，解决获取不到用户名密码问题）
lichuangcsdn的博客
07-06 1万+
如果是自己验证用户名密码的话，spring security仅仅支持传统的form表单方式（form-data）登录。这是一个比较大的坑点。现在都流行使用前后端分离，前端发送的是json格式数据。下面我谈下如何操作。 通过跟踪源代码，可以知道，获取用户名密码是在UsernamePasswordAuthenticationFilter这个类里面的attemptAuthentication方法，如下...
SpringBoot整合SpringSecurity实现JWT认证
热门推荐
我的博客
03-30 3万+
前言 微服务架构，前后端分离目前已成为互联网项目开发的业界标准，其核心思想就是前端（APP、小程序、H5页面等）通过调用后端的API接口，提交及返回JSON数据进行交互。 在前后端分离项目中，首先要解决的就是登录及授权的问题。微服务架构下，传统的session认证限制了应用的扩展能力，无状态的JWT认证方法应运而生，该认证机制特别适用于分布式站点的单点登录（SSO）场景 目录 该文会通过创建...
spring-security-core-5.5.2-API文档-中文版.zip
06-04
赠送jar包：spring-security-core-5.5.2.jar； 赠送原API文档：spring-security-core-5.5.2-javadoc.jar； 赠送源代码：spring-security-core-5.5.2-sources.jar； 赠送Maven依赖信息文件：spring-security-core-5.5.2.pom； 包含翻译后的API文档：spring-security-core-5.5.2-javadoc-API文档-中文(简体)版.zip； Maven坐标：org.springframework.security:spring-security-core:5.5.2； 标签：springframework、security、spring、core、中文文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
SpringBoot 集成SpringSecurity JWT
weixin_55765992的博客
07-01 1230
1. 简介 今天ITDragon分享一篇在Spring Security 框架中使用JWT，以及对失效Token的处理方法。 1.1 SpringSecurity Spring Security 是Spring提供的安全框架。提供认证、授权和常见的攻击防护的功能。功能丰富和强大。 Spring Security is a powerful and highly customizable authentication and access-control framework. It is the de-fa
springSecurity配置和相关API
weixin_45933638的博客
12-26 429
首先进行pom文件配置 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> Config类的配置 通过连接数据库上的数据进行验证 ...
spring-security--基础--03--注解和api说明
zhou920786312的博客
10-26 831
参考手册 https://www.springcloud.cc/spring-security-zhcn.html 三、注解和api说明 3.1、HttpSecurity api 3.2、@EnableWebSecurity @Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) @Target(value = { java.lang.annotation.ElementType.TYPE }) @Documented @Im
SpringSecurity 配置与使用（含新 API 替换过时的 WebSecurityConfigurerAdapter）
泡泡的博客
10-28 5715
As we all know，现今主流权限框架有 SpringSecurity、Shiro、SaToken，Shiro在前后端分离时代基本被淘汰，剩下适合大型项目的和 适合中小型项目的SaToken可以选择，SaToken 我也写了文章Springboot 使用 SaToken 进行登录认证、权限管理以及路由规则接口拦截。
SpringBoot整合SpringSecurity实现用户登录（一）用户验证及JWT令牌生成
qq_45607971的博客
04-21 1064
SpringSecurity入门级使用（一） 用户登录以及JWT生成
SpringSecurity 整合 JWT
niceyoo的博客
06-02 1万+
项目集成Spring Security（一） 在上一篇基础上继续集成 JWT ，实现用户身份验证。 前言 前后端分离项目中，如果直接把 API 接口对外开放，我们知道这样风险是很大的，所以在上一篇中我们引入了 Spring Security ，但是我们在登陆后缺少了请求凭证部分。 什么是JWT? JWT是 Json Web Token 的缩写。它是基于 RFC 7519 标准定义的一种可以安全...
SpringSecurity之表单验证
xkshihaoren的博客
11-23 348
1.默认表单验证 首先在config包中新建一个SpringSecurity的配置类 @EnableWebSecurity public webSecurityConfig extends WebSecurityConfigureAdapter{ } 在该配置类中有三个常重写的方法： @Override // 配置springSecurity用户和权限 protect...
SpringSecurity（10）——Csrf防护
peng_gx的博客
01-20 2866
SpringSecurity Csrf防护
Springboot+SpringSecurity+jwt++Swagger2 验证码验证
springboot+springSecurity+jwt+OAuth2+Swagger2
11-08 1344
第一步：加入工具类包 <!--加入验证码工具包--> <dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> <version>4.5.11</version&gt...
使用API​​身份验证的Spring Security
最佳 Java 编程
05-12 227
背景 尽管有许多博客文章详细介绍了如何使用Spring Security，但是当问题域位于标准LDAP或数据库身份验证之外时，我仍然经常发现配置挑战。 在本文中，我将介绍一些针对Spring Security的简单自定义，使其能够与基于REST的API调用一起使用。 具体来说，用例是您拥有一个API服务，该服务将返回包含SHA-256密码哈希的用户对象。 设定 运行此样本的先决条件...
SpringBoot整合SpringSecurity+JWT实现用户验证和鉴权
qq_42109746的博客
05-28 2599
前言 之前一直都是用shiro在做用户的验证和鉴权，最近在SpringSecurity上也踩了不少坑。对于SpringSecurity比较官方的解释是：Spring Security是Spring提供的一个安全框架，提供认证和授权功能，最主要的是它提供了简单的使用方式，同时又有很高的灵活性，简单，灵活，强大。但在使用的时候，却没有说的那样轻松，明明作为一个框架，应该是又简单又方便使用，配合上JWT，那就是双倍的快乐。 技术栈 SpringBoot、SpringSecurity、JWT、Spring D
SpringBoot整合SpringSecurity前后端分离实现JSON登录
Wanik666
03-31 1572
在前后端分离项目中，通常是通过json格式数据传递信息，但是SpingSecurity中默认获取登录账号密码方式为通过表单提交的key/value形式过去，具体官方源码处理方式如下： public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) thr...
SpringSecurity+jwt，实现前后分离 适配Resful API的权限控制
TheJam的博客
03-13 788
前言 SpringSecurity默认采用的基于表单的认证形式，以session识别 从用户登录授权、鉴权等都与表单相关。而当前许多应用都采用SpringBoot 基于Resful API风格的开发，使用默认的SpringSecurity无法直接使用满足。解决方案：不采用默认的登录鉴权方式，而通过覆写增加其中的过滤器Filter来实现 登录和鉴权，并将JWT（JSON WEB TOKEN）作为认证...
SpringSecurity入门
ChatYU的博客
12-20 1762
是一个基于Spring框架的安全性框架，可用于对Java应用程序进行身份验证、授权和其他安全性功能的添加。它不仅可以对Web应用程序进行保护，还可以保护非Web环境下的应用程序，如远程服务和命令行应用程序等。提供了一系列可插拔的安全性特性，如基于标记的身份验证、权限控制、单点登录、密码加密等。它还支持多种安全性协议和标准，如OAuthSAMLOpenID等，可与各种身份提供商集成。是的一个核心类，用于配置应用程序的安全策略。
springsecurity完成前后端完全分离
z2331198564653的博客
07-31 1640
Json web token (JWT)，是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准((RFC7519).该token被设计为紧凑且==安全==的，特别适用于==分布式站点的单点登录(SSO)场景==。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值