SpringSecurity+jwt使用

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量481 收藏 2
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BigBang_JJDS/article/details/134456405
版权

参考文章链接

自定义SpringSecurity用户

package com.daben.springsecurityjwt.vo;

import com.daben.springsecurityjwt.entity.SysUser;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.User;
import java.util.Collection;
/**
 * SpringSecurity用户
 *
 * @Author JinDongSheng
 * @Date 2023-11-16 09:21
 */
public class SpringSecurityUser extends User {
    /**
     * 系统用户
     */
    private SysUser sysUser;
    /**
     * 构造函数
     */
    public SpringSecurityUser(SysUser sysUser, Collection<? extends GrantedAuthority> authorities) {
        super(sysUser.getUsername(), sysUser.getPassword(), authorities);
        this.sysUser = sysUser;
    }
    public SysUser getSysUser() {
        return sysUser;
    }
    public void setSysUser(SysUser sysUser) {
        this.sysUser = sysUser;
    }
}

自定义认证失败处理类

package com.daben.springsecurityjwt.handle;

import com.alibaba.fastjson2.JSON;
import com.daben.springsecurityjwt.vo.Result;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
 * 未登录处理类
 *
 * @Author JinDongSheng
 * @Date 2023-11-15 17:37
 */
@Component
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        response.setStatus(200);
        response.setContentType("application/json");
        response.setCharacterEncoding("utf-8");
        response.getWriter().print(JSON.toJSONString(Result.error("认证失败，无法访问系统资源！")));
    }
}

自定义Security用户服务实现类

package com.daben.springsecurityjwt.service;

import com.daben.springsecurityjwt.entity.SysUser;
import com.daben.springsecurityjwt.vo.SpringSecurityUser;
import org.springframework.beans.factory.annotation.Autowired;
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.Collections;
/**
 * Security用户服务实现类
 *
 * @Author JinDongSheng
 * @Date 2023-11-16 09:14
 */
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Autowired
    private SysUserServiceImpl sysUserServiceImpl;
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 根据用户名称查询用户
        SysUser sysUser = sysUserServiceImpl.selectSysUserByName(username);
        // 查询用户权限
        List<GrantedAuthority> authorities = Collections.emptyList();
        // 返回Security指定的用户对象
        return new SpringSecurityUser(sysUser, authorities);
    }
}

自定义JWT工具类

package com.daben.springsecurityjwt.utils;

import cn.hutool.core.date.DateUtil;
import cn.hutool.json.JSONUtil;
import com.daben.springsecurityjwt.entity.SysUser;
import io.jsonwebtoken.*;
import org.apache.commons.lang3.StringUtils;
import java.util.Date;
/**
 * JWT工具类
 *
 * @Author JinDongSheng
 * @Date 2023-11-16 15:49
 */
public class JwtUtil {
    /**
     * Token有效期为30分钟
     */
    public static final int EXPIRE_TIME = 30;
    /**
     * 秘钥
     */
    private final static String SECRET_KEY = "ABCDE";
    /**
     * 生成token
     */
    public static String createToken(SysUser user) {
        return Jwts.builder()
                // 将user放进JWT
                .setSubject(JSONUtil.toJsonStr(user))
                // 设置过期时间
                .setExpiration(DateUtil.offsetMinute(new Date(), EXPIRE_TIME))
                // 设置加密算法和秘钥
                .signWith(SignatureAlgorithm.HS512, SECRET_KEY)
                .compact();
    }
    public static Claims parseToken(String token) {
        // 如果是空字符串直接返回null
        if (StringUtils.isEmpty(token)) {
            return null;
        }
        // 这个Claims对象包含了许多属性，比如签发时间、过期时间以及存放的数据等
        Claims claims = null;
        // 解析失败了会抛出异常，所以我们要捕捉一下。token过期、token非法都会导致解析失败
        try {
            claims = Jwts.parser()
                    .setSigningKey(SECRET_KEY) // 设置秘钥
                    .parseClaimsJws(token)
                    .getBody();
        } catch (JwtException e) {
            // 这里应该用日志输出，为了演示方便就直接打印了
            System.err.println("解析失败！");
        }
        return claims;
    }
}

自定义token认证过滤器

package com.daben.springsecurityjwt.filter;

import cn.hutool.json.JSONUtil;
import com.daben.springsecurityjwt.entity.SysUser;
import com.daben.springsecurityjwt.utils.JwtUtil;
import io.jsonwebtoken.Claims;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
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.Collections;
/**
 * 登录过滤器
 *
 * @Author JinDongSheng
 * @Date 2023-11-16 14:48
 */
@Component
public class LoginFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        // 解析token
        Claims claims = JwtUtil.parseToken(request.getHeader("Authorization"));
        if (claims != null) {
            // 获取用户
            SysUser sysUser = JSONUtil.toBean(claims.getSubject(), SysUser.class);
            // 手动组装一个认证对象
            Authentication authentication = new UsernamePasswordAuthenticationToken(sysUser, null, Collections.emptyList());
            // 将认证对象放到上下文中
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
        filterChain.doFilter(request, response);
    }
}

自定义SpringSecurity配置类

package com.daben.springsecurityjwt.config;

import com.daben.springsecurityjwt.filter.LoginFilter;
import com.daben.springsecurityjwt.handle.AuthenticationEntryPointImpl;
import com.daben.springsecurityjwt.service.UserDetailsServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
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.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
/**
 * spring security 配置
 *
 * @Author JinDongSheng
 * @Date 2023-11-15 17:16
 */
@EnableWebSecurity
public class SpringSecurityConfig extends WebSecurityConfigurerAdapter {
    /**
     * 登录认证过滤器
     */
    @Autowired
    private LoginFilter loginFilter;
    /**
     * Security用户服务实现类
     */
    @Autowired
    private UserDetailsServiceImpl userDetailsService;
    /**
     * 未登录处理类
     */
    @Autowired
    private AuthenticationEntryPointImpl authenticationEntryPoint;
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 关闭csrf
        http.csrf().disable();
        // 关闭frameOptions
        http.headers().frameOptions().disable();
        // 指定未登录处理类
        http.exceptionHandling().authenticationEntryPoint(authenticationEntryPoint);
        // 前置登录认证过滤器
        http.addFilterBefore(loginFilter, UsernamePasswordAuthenticationFilter.class);
        // 禁用session
        http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
        // 配置认证和授权接口
        http.authorizeRequests()
                // 指出放行接口
                .antMatchers("/sys/port/*").permitAll()
                // 拦截剩余接口
                .anyRequest().authenticated();
    }
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 指定UserDetailService和加密器
        auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
    }
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
    @Bean
    public PasswordEncoder passwordEncoder() {
        // 使用bcrypt加密
        return new BCryptPasswordEncoder();
    }
}

登录入口

package com.daben.springsecurityjwt.controller;

import com.daben.springsecurityjwt.entity.SysUser;
import com.daben.springsecurityjwt.utils.JwtUtil;
import com.daben.springsecurityjwt.vo.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
 * 登录控制器
 *
 * @Author JinDongSheng
 * @Date 2023-11-15 17:25
 */
@RestController
@RequestMapping("/sys/port")
public class SysPortController {
    @Autowired
    private AuthenticationManager authenticationManager;
    @PostMapping("/login")
    public Result login(@RequestBody SysUser sysUser) {
        // 认证
        Authentication authenticate = authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(sysUser.getUsername(), sysUser.getPassword()));
        if (authenticate.isAuthenticated()) {
            // 生成token
            String token = JwtUtil.createToken(sysUser);
            // 返回token
            return Result.success(token);
        }
        return Result.error("用户名或密码错误");
    }
}

整体调用流程

  1. 服务启动，根据【自定义SpringSecurity配置类】配置信息（指定放行和认证接口、token认证过滤器、认证失败处理器、密码加密器、用户查询服务等。）
  2. 用户发起登录请求。
  3. token认证过滤器过滤，因为不携带token，直接放行调用登录接口，在登录接口中手动调用AuthenticationManager进行用户信息认证。
  4. AuthenticationManager进行用户信息认证时会调用【自定义Security用户服务实现类】查询数据库用户，然后将数据库用户封装成Security指定用户返回。
  5. 认证失败调用【自定义认证失败处理类】，认证成功则返回token
  6. 用户发起非登录请求，token过滤器过滤，token校验成功将认证对象放入上下文中。调用请求接口。token校验失败，调用【自定义认证失败处理类】。

pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.vitalframework</groupId>
        <artifactId>vital-framework-dependencies</artifactId>
        <version>1.1.0</version>
    </parent>
    <groupId>com.citic</groupId>
    <artifactId>vital-portal-core</artifactId>
    <version>1.0.0</version>
    <name>vital-portal-core</name>
    <description>系统管理（门面工程）模块</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.rep4orting.outputEncoding>UTF-8</project.rep4orting.outputEncoding>
        <java.version>1.8</java.version>
        <maven.compiler.source>${java.version}</maven.compiler.source>
        <maven.compiler.target>${java.version}</maven.compiler.target>
    </properties>

    <dependencies>
        <!--CITIC 一些公共包-->
        <dependency>
            <groupId>com.vitalframework.web</groupId>
            <artifactId>vital-framework-web-common</artifactId>
            <version>1.0.0</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>easyexcel</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-net</groupId>
            <artifactId>commons-net</artifactId>
        </dependency>
        <dependency>
            <groupId>com.jcraft</groupId>
            <artifactId>jsch</artifactId>
        </dependency>
        <!--代码生成器-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
        </dependency>

        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
        </dependency>

        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml-schemas</artifactId>
        </dependency>

        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-scratchpad</artifactId>
        </dependency>

        <dependency>
            <groupId>org.codehaus.castor</groupId>
            <artifactId>castor-xml</artifactId>
        </dependency>
    </dependencies>

    <build>
<!--        <finalName>${project.artifactId}</finalName>-->
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                    <skip>true</skip>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <version>${maven-source-plugin.version}</version>
            </plugin>
        </plugins>
    </build>
</project>
JDS_DIJ
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringSecurity+JWT使用
qq_42218187的博客
03-20 1448
maven依赖 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependen
解析SpringSecurity+JWT认证流程实现
08-18
首先，我们需要配置SpringSecurity来使用JWT认证方式，然后在认证流程中，我们使用JWT token来验证用户的身份。在认证完成后，我们将生成一个JWT token，并将其传递给客户端，以便客户端在每次请求时都可以带上这个...
使用jwtsecurity和登录功能的实现
lmxx9939的博客
06-05 988
登录功能的实现
【SpringBoot3】Spring Security 详细使用实例（简单使用、JWT模式）
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
02-23 2853
Spring Security 使用起来非常简单，只要引入相关依赖包，然后增加注解`@EnableWebSecurity`就可以。同时提供了丰富的扩展点，可以让你自定义权限校验策略。 常见的使用场景分两类： 1. 有session模式，通常是前端不分离的项目，使用cookie + session 模式存储以及校验用户权限； 2. 无session模式，通常是前后端分离项目，使用Jwt形式的Token校验权限
SpringSecurity+JWT使用步骤及心得
qq_35213765的博客
05-06 1234
1、添加相关依赖 主要是springsecurity和jwt依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://mav
SpringSecurity +Jwt 使用手机号码 + 验证码登录
qq_45524787的博客
07-25 3449
SpringSecurity +Jwt 使用手机号码 + 验证码登录
SpringSecurity + JWT 实现登录认证
xaiobit_hl的博客
07-17 1201
Component@Override// 1.获取 JWT 令牌if (!// 2.判断 JWT 令牌正确性// 3.获取用户信息，存储 Security 中= null= null) {// 4.创建用户对象null,// 绑定 request 对象。
Spring Security+JWT简述
热门推荐
姜守威的博客
06-03 2万+
目录一. 什么是Spring Security1. 登陆校验的流程2. SpringSecurity基础案例二. Spring Security原理流程 一. 什么是Spring Security Spring Security是Spring家族的一个安全管理框架, 相比于另一个安全框架Shiro, 它具有更丰富的功能。一般中大型项目都是使用SpringSecurity做安全框架, 而Shiro上手比较简单 spring security 的核心功能: 认证(你是谁): 只有你的用户名或密码正确才能
SpringSecurity +Jwt 使用用户名密码登录
qq_45524787的博客
07-23 2183
SpringSecurity +Jwt 使用用户名密码登录
Spring Security + JWT基础整合
weixin_45565886的博客
02-08 1404
Spring Security + JWT基础整合
SpringSecurity + JWT 实现携带信息请求
m0_73179389的博客
04-22 731
类型为“小型文本文件”，是某些网站为了辨别用户身份，进行 Session 跟踪而储存在用户本地终端上的数据（通常经过加密），由用户客户端计算机暂时或永久保存 的信息。考虑将用户的信息存储到服务器端，请求时只携带可以识别用户身份的身份信息就可以了，再根据用户 身份获取用户的其他资料比如：实名信息，订单信息，访问记录等。SpringSecurity框架的本质就是过滤链，所以说我们也可以自定义过滤器，放到过滤链中，完成我们自己的逻辑业务代码。是要查找用的后边请求，判断权限的时候，放置进去的数据是用户的信息。
详解SpringBoot+SpringSecurity+jwt整合及初体验
08-25
SpringBoot+SpringSecurity+jwt整合详解 SpringBoot是当前最流行的Java框架之一，它提供了便捷的方式来构建基于Web的应用程序。然而，在构建Web应用程序时，安全性是不可忽视的重要方面。因此，本文将详细介绍如何...
SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统
04-30
基于当前流行技术组合的前后端分离商城系统：SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统， 包含商城、sku、运费模板、素材库、小程序直播、拼团、砍价、商户管理、 秒杀、优惠券...
基于SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端商城系统源码
05-13
yshop基于当前流行技术组合的前后端分离商城系统： SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统， 包含分类、sku、运费模板、素材库、小程序直播、拼团、砍价、商户管理、 秒杀、...
springsecurity+jwt权限系统demo.zip
11-19
springsecurity+jwt权限系统demo，只有后端，测试请使用postman，未登录情况下不可以访问指定路径的接口，用户登录之后不可以访问管理员接口，管理员可以访问其角色一下的所有接口，角色可以继承
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 728
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 690
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 709
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1231
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
springsecurity +jwt 使用手机号码 + 验证码登录
03-11
可以使用springsecurity和jwt实现手机号码和验证码登录。首先，用户输入手机号码和验证码，然后将其发送到后端进行验证。如果验证通过，后端将生成一个jwt令牌并将其返回给前端。前端将在后续请求中使用该令牌进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值