SpringBoot使用JWT进行跨域身份验证

最新推荐文章于 2024-05-31 17:28:36 发布
最新推荐文章于 2024-05-31 17:28:36 发布
阅读量304 收藏
点赞数
文章标签： spring boot java spring mybatis 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/china_coding/article/details/127356295
版权

整合JWT令牌

一、不在拦截器使用

1、在模块中添加jwt工具依赖

<dependencies>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
    </dependency>

    <dependency>
        <groupId>joda-time</groupId>
        <artifactId>joda-time</artifactId>
    </dependency>
</dependencies>

2、创建JWT工具类

package com.stu.service.base.utils;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/******************************
 * 用途说明:
 * 作者姓名: Administrator
 * 创建时间: 2022-06-30 21:47
 ******************************/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class JwtInfo {
    private String id;
    private String nickName;
    private String avatar;
    //权限、角色等
    //不要存敏感信息
}

JwtUtils

package com.stu.service.base.utils;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jws;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.joda.time.DateTime;
import org.springframework.util.StringUtils;

import javax.crypto.spec.SecretKeySpec;
import javax.servlet.http.HttpServletRequest;
import javax.xml.bind.DatatypeConverter;
import java.security.Key;
import java.util.Date;

/******************************
 * 用途说明:jwt工具类
 * 作者姓名: Administrator
 * 创建时间: 2022-06-30 21:48
 ******************************/
public class JwtUtils {

    public static final String APP_SECRET = "sdfGRRD323FGSfdrtr4233";

    private static Key getKeyInstance() {
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
        byte[] bytes = DatatypeConverter.parseBase64Binary(APP_SECRET);
        return new SecretKeySpec(bytes, signatureAlgorithm.getJcaName());
    }

    /**
     * 获取 jwt token
     *
     * @param jwtInfo 实体
     * @param expire  过期时间 m
     * @return 生成的 token
     */
    public static String getJwtToken(JwtInfo jwtInfo, int expire) {

        String JwtToken = Jwts.builder()
                .setHeaderParam("typ", "JWT")
                .setHeaderParam("alg", "HS256")
                // 主题
                .setSubject("stu-user")
                // 颁发时间
                .setIssuedAt(new Date())
                // 过期时间
                .setExpiration(DateTime.now().plusSeconds(expire).toDate())
                // 用户id
                .claim("id", jwtInfo.getId())
                // 用户昵称
                .claim("nickName", jwtInfo.getNickName())
                // 用户头像
                .claim("avatar", jwtInfo.getAvatar())
                .signWith(SignatureAlgorithm.HS256, getKeyInstance())
                .compact();

        return JwtToken;
    }

    /**
     * 判断token是否存在与有效
     *
     * @param jwtToken
     * @return
     */
    public static boolean checkJwtToken(String jwtToken) {
        if (StringUtils.isEmpty(jwtToken)) {
            return false;
        }
        try {
            Jwts.parser().setSigningKey(getKeyInstance()).parseClaimsJws(jwtToken);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 判断token是否存在与有效
     *
     * @param request
     * @return
     */
    public static boolean checkJwtToken(HttpServletRequest request) {
        String jwtToken = request.getHeader("token");
        return checkJwtToken(jwtToken);
    }

    /**
     * 根据token获取会员信息
     *
     * @param request
     * @return
     */
    public static JwtInfo getMemberIdByJwtToken(HttpServletRequest request) {
        String jwtToken = request.getHeader("token");
        if (StringUtils.isEmpty(jwtToken)) {
            return null;
        }
        Jws<Claims> claimsJws = Jwts.parser().setSigningKey(getKeyInstance()).parseClaimsJws(jwtToken);
        Claims claims = claimsJws.getBody();
        JwtInfo jwtInfo = new JwtInfo(claims.get("id").toString(), claims.get("nickName").toString(), claims.get(
                "avatar").toString());
        return jwtInfo;
    }
}

3、使用

package com.stu.service.trade.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.stu.service.base.dto.CourseDto;
import com.stu.service.base.dto.MemberDto;
import com.stu.service.base.exception.CustomException;
import com.stu.service.base.result.R;
import com.stu.service.base.result.ResultCodeEnum;
import com.stu.service.base.utils.JwtInfo;
import com.stu.service.base.utils.JwtUtils;
import com.stu.service.trade.entity.Order;
import com.stu.service.trade.feign.EduCourseService;
import com.stu.service.trade.feign.UcenctMemberService;
import com.stu.service.trade.mapper.OrderMapper;
import com.stu.service.trade.service.OrderService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.stu.service.trade.utli.OrderUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;

/**
 * <p>
 * 订单 服务实现类
 * </p>
 *
 * @author stu
 * @since 2022-07-10
 */
@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {

    @Autowired
    private EduCourseService eduCourseService;

    @Autowired
    private UcenctMemberService ucenctMemberService;

    /***********************************
     * 用途说明:新增订单
     * @param courseId
     * @param request
     * 返回值说明:
     * @return java.lang.String
     ***********************************/
    @Override
    public String saveOrder(String courseId, HttpServletRequest request) {

        Order addOrder = null;
        JwtInfo jwtInfo = JwtUtils.getMemberIdByJwtToken(request);
        if (null == jwtInfo) {
            throw new CustomException(ResultCodeEnum.FETCH_ACCESSTOKEN_FAILD);
        }
        String memberId = jwtInfo.getId();
        if (StringUtils.isEmpty(memberId)) {
            throw new CustomException(ResultCodeEnum.FETCH_ACCESSTOKEN_FAILD);
        }
        //查询当前用户是否已有当前课程的订单
        QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("course_id", courseId);
        queryWrapper.eq("member_id", memberId);
        Order order = baseMapper.selectOne(queryWrapper);
        if (null != order) {
            return order.getId();
        }
        //查询用户信息
        MemberDto memberDto = ucenctMemberService.getMemberInfo(memberId);
        if (null == memberDto) {
            throw new CustomException(ResultCodeEnum.ILLEGAL_CALLBACK_REQUEST_ERROR);
        }

        //查询课程信息
        CourseDto courseDto = eduCourseService.getCourseById(courseId);

        if (null == courseDto) {
            throw new CustomException(ResultCodeEnum.ILLEGAL_CALLBACK_REQUEST_ERROR);
        }
        addOrder = new Order();
        addOrder.setOrderNo(OrderUtils.getOrderNo());
        addOrder.setCourseId(courseId);
        addOrder.setCourseId(courseDto.getId());
        addOrder.setCourseTitle(courseDto.getTitle());
        addOrder.setCourseCover(courseDto.getCover());
        addOrder.setTotalFee(courseDto.getPrice());
        addOrder.setTeacherName(courseDto.getTeacherName());

        addOrder.setMemberId(memberId);
        addOrder.setNickname(jwtInfo.getNickName());
        addOrder.setMobile(memberDto.getMobile());
        addOrder.setStatus(0);//"订单状态(0：未支付 1：已支付)"
        addOrder.setPayType(1);
        baseMapper.insert(addOrder);

        return addOrder.getId();
    }

    /***********************************
     * 用途说明:支付成功
     * @param orderId
     * 返回值说明:
     * @return boolean
     ***********************************/
    @Override
    public Order updateOrderStraus(String orderId) {
        Order order = baseMapper.selectById(orderId);
        order.setStatus(1);
        eduCourseService.updateBuyCountById(order.getCourseId());
        return order;
    }
}

4、vue页面

import axios from 'axios'
import { Message, MessageBox } from 'element-ui'
import store from '../store'
import { getToken } from '@/utils/auth'

// 创建axios实例
const service = axios.create({
  baseURL: process.env.BASE_API, // api的base_url
  timeout: 5000 // 请求超时时间
})

// request拦截器
service.interceptors.request.use(
  config => {
    if (store.getters.token) {
      config.headers['token'] = getToken() // 让每个请求携带自定义token 请根据实际情况自行修改
    }
    return config
  },
  error => {
    // Do something with request error
    console.log(error) // for debug
    Promise.reject(error)
  }
)

// respone拦截器
service.interceptors.response.use(
  response => {
    /**
     * code为非20000是抛错 可结合自己业务进行修改
     */
    const res = response.data
    if (res.code !== 20000) {
       
      Message({
        message: res.message,
        type: 'error',
        duration: 5 * 1000
      })

      // 50008:非法的token; 50012:其他客户端登录了;  50014:Token 过期了;
      if (res.code === 50008 || res.code === 50012 || res.code === 50014) {
        MessageBox.confirm(
          '你已被登出，可以取消继续留在该页面，或者重新登录',
          '确定登出',
          {
            confirmButtonText: '重新登录',
            cancelButtonText: '取消',
            type: 'warning'
          }
        ).then(() => {
          store.dispatch('FedLogOut').then(() => {
            location.reload() // 为了重新实例化vue-router对象 避免bug
          })
        })
      }
      return Promise.reject('error')
    } else {
      return response.data
    }
  },
  error => {
 
    console.log('err' + error) // for debug
    Message({
      message: error.message,
      type: 'error',
      duration: 5 * 1000
    })
    return Promise.reject(error)
  }
)

export default service

二、通过拦截器方式验证

创建拦截器

package com.qfedu.fmmall.interceptor;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.qfedu.fmmall.vo.ResStatus;
import com.qfedu.fmmall.vo.ResultVO;
import io.jsonwebtoken.*;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

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

@Component
public class CheckTokenInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String method = request.getMethod();
        if("OPTIONS".equalsIgnoreCase(method)){
            return true;
        }
        String token = request.getHeader("token");
        if(token == null){
            ResultVO resultVO = new ResultVO(ResStatus.LOGIN_FAIL_NOT, "请先登录！", null);
            doResponse(response,resultVO);
        }else{
            try {
                JwtParser parser = Jwts.parser();
                parser.setSigningKey("QIANfeng6666"); //解析token的SigningKey必须和生成token时设置密码一致
                //如果token正确(密码正确，有效期内)则正常执行，否则抛出异常
                Jws<Claims> claimsJws = parser.parseClaimsJws(token);
                return true;
            }catch (ExpiredJwtException e){
                ResultVO resultVO = new ResultVO(ResStatus.LOGIN_FAIL_OVERDUE, "登录过期，请重新登录！", null);
                doResponse(response,resultVO);
            }catch (UnsupportedJwtException e){
                ResultVO resultVO = new ResultVO(ResStatus.LOGIN_FAIL_NOT, "Token不合法，请自重！", null);
                doResponse(response,resultVO);
            }catch (Exception e){
                ResultVO resultVO = new ResultVO(ResStatus.LOGIN_FAIL_NOT, "请先登录！", null);
                doResponse(response,resultVO);
            }
        }
        return false;
    }

    private void doResponse(HttpServletResponse response,ResultVO resultVO) throws IOException {
        response.setContentType("application/json");
        response.setCharacterEncoding("utf-8");
        PrintWriter out = response.getWriter();
        String s = new ObjectMapper().writeValueAsString(resultVO);
        out.print(s);
        out.flush();
        out.close();
    }

}

配置拦截器

package com.qfedu.fmmall.config;

import com.qfedu.fmmall.interceptor.CheckTokenInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {

    @Autowired
    private CheckTokenInterceptor checkTokenInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(checkTokenInterceptor)
                .addPathPatterns("/shopcart/**")
                .addPathPatterns("/orders/**")
                .addPathPatterns("/useraddr/**")
                .addPathPatterns("/user/check");
    }
}

axios通过请求头传值

axios({
    method: "get",
    url: baseUrl + "shopcart/list",
    headers: {
        token: this.token
    }
}).then(function(res) {
    console.log(res);
});

各种异常

JwtException 总异常
ClaimJwtException 获取Claim异常
ExpiredJwtException token过期异常
IncorrectClaimException token无效
MalformedJwtException 密钥验证不一致
MissingClaimException JWT无效
RequiredTypeException 必要类型异常
SignatureException 签名异常
UnsupportedJwtException 不支持JWT异常

作者：明
出处：https://www.cnblogs.com/konglxblog//
版权：本文版权归作者和博客园共有
转载：欢迎转载，文章中请给出原文连接，此文章仅为个人知识学习分享，否则必究法律责任 

小明的学习圈子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring-boot框架下使用JWT实现跨域认证
Skeeter_wen的博客
08-13 311
一、JWT简介： JSON Web Token（缩写 JWT）是目前最流行的跨域认证解决方案。是用于对应用程序上的用户进行身份验证的标记。也就是说，使用 JWT 的应用程序不再需要保存有关其用户的 cookie 或其他session数据。此特性便于可伸缩性，同时保证应用程序的安全。 在身份验证过程中, 当用户使用其凭据成功登录时, 将返回 JSON Web token，并且必须在本地保存 (通常在本地存储中)。 每当用户要访问受保护的资源时，需要在请求头中携带 JWT。后端服务器接收到带有 JWT 的
Web 开发 身份验证2 | SpringBoot 整合 JWT | 前后端分离策略 | 跨域问题的出现与解决
希望每天都能进步一点点
07-24 335
基于上次SpringBoot 整合 JWT，在前后端不分离的情况下使用 JWT 是比较麻烦的，如果配置拦截器，那么拦截器里需考虑页面跳转到问题，本次学习中我们实现在前后端分离情况下前后端的 JWT 认证，其中设计到了跨域问题，从零开始了解跨域，并介绍后端三种解决跨域不同的方式，实现CORS方式的跨域。通过本篇文章，能提升对前后端交互方式的理解，前端目前只采用简短的 JQuery，未涉及路由的概念，下次学习我将使用 Vue2来实现 JWT认证，到时候可以用到路由，这样一来，前后端交互的逻辑就更加清晰了。...
【SpringBoot】1、SpringBoot整合JWT实现Token验证
qq_24099547的博客
04-10 6044
单点登录
springboot项目集成JWT实现身份认证(权鉴)
dhklsl的专栏
04-11 1854
springboot集成JWT实现身份认证
SpringBoot使用Jwt处理跨域认证问题的教程详解
08-19
主要介绍了SpringBoot使用Jwt处理跨域认证问题，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
SpringBoot2.0 整合 JWT 框架，解决Token跨域验证问题
【积累】，是一个长期持续的过程。
07-11 2371
JWT(全称JSONWebToken)，在基于HTTP通信过程中，进行身份认证。
SpringBoot允许跨域请求
飞鸟的轨迹
02-23 1617
实例代码： import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.spring...
SpringBoot 使用jwt进行身份验证的方法示例
08-26
主要介绍了SpringBoot 使用jwt进行身份验证的方法示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringBoot使用JWT实现登录验证的方法示例
08-25
主要介绍了SpringBoot使用JWT实现登录验证的方法示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
c#关于JWT跨域身份验证的实现代码
08-25
主要介绍了c#关于JWT跨域身份验证的实现代码，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
SpringBoot集成jwt,解决前后端分离token跨域验证问题
weixin_46608377的博客
07-17 813
在之前进行登录验证的，主要用的是session的方式，session是由客户端首次发起请求，后端为此创建空间，返回给前端用来身份识别标识sessionId,前端基于cookie存储起来，在后面的请求中都会携带sessionId，后端就会根据这sessionId识别出身份信息。前端sessionid是基于cookie进行存储的。这种方式会存在安全问题，如果被不法分子拦截这个sessionId或cookie信息，就能跳过后端验证，从而盗取你的信息。而且seesion这种方式容易占用到服务端的内存空间。
spring boot 之 整合 knife4j 在线接口文档
我叫晨曦啊的博客
05-30 195
spring boot knife4j 在线接口文档
基于Spring Boot+Vue的广场舞团系统|文档|ppt 编号：701
paopaokaka_luck的博客
05-29 914
系统分为三个角色： 用户 管理员 社团后端使用Java编程语言的Springboot框架项目架构：B/S架构前端技术：Vue后端技术：Java 、mybatis、Spring boot运行环境：win10/win11、jdk1.8数据库：mysql5.7/8.0。
博客星球大冒险：用Spring Boot和JWT打造你的数字王国
Geek_H
05-30 800
在这个实战项目中，我们从零基础出发，一步步构建了一个炫酷的个人博客系统，用Spring Boot和JWT打造了它的骨架和护盾。我们不仅赋予了它CRUD的超能力，还通过HTTPS和CORS等神秘仪式加固了它的安全。但故事远未结束，社区的力量和开源的魔法将如何引领它走向未来？人工智能、移动应用、社交功能...这些又将如何融入我们的乐园？跟随我们，一起揭开这个技术奇迹的神秘面纱，探索更多未知的可能！
【spring boot+Lazy ORM+mysql】开发一个数据库管理系统实现对应数据库数据查看和修改
忙碌的吴小二博客
05-27 536
【代码】【spring boot+Lazy ORM+mysql】开发一个数据库管理系统实现对应数据库数据查看和修改。
基于Spring Boot框架的分页查询和文件上传
weixin_74521994的博客
05-29 1656
要想从数据库中进行分页查询，我们要使用LIMIT关键字，格式为：limit 开始索引 每页显示的条数假设一页想展示10条数据查询第1页数据的SQL语句是：查询第2页数据的SQL语句是：查询第3页的数据的SQL语句是：观察以上SQL语句，发现： 开始索引一直在改变 ， 每页显示条数是固定的开始索引的计算公式： 开始索引 = (当前页码 - 1) * 每页显示条数开始索引 = (当前页码 - 1) * 每页显示条数当前页码 page每页显示条数 pageSize。
Spring Boot详解：深入了解与实践
最新发布
Easonmax的博客
05-31 911
Spring Boot是由Pivotal团队开发的基于Spring框架的项目，旨在简化新Spring应用的初始搭建及开发过程。通过提供一系列默认配置和自动化功能，Spring Boot可以大幅减少配置文件的数量和复杂度，使开发者能够专注于业务逻辑的实现。虽然自动配置为开发者提供了极大的便利，但有时需要自定义配置以满足特定需求。配置属性：在或文件中配置属性。配置类：创建配置类并使用注解。排除自动配置：通过注解排除特定的自动配置类。
在Spring Boot项目中使用Redisson实现延迟执行
canduecho的专栏
05-30 518
在这个服务类中，我们首先通过`@Autowired`注解注入`RedissonClient`实例。然后，我们创建了两个方法：`addTaskToQueue`用于向延迟队列中添加任务，`processTaskFromQueue`用于处理延迟队列中的任务。在这个控制器中，我们创建了两个端点：`/addTask`用于向延迟队列中添加任务，`/processTask`用于处理延迟队列中的任务。在这个配置类中，我们使用`@Value`注解获取Redis服务器的地址，并创建一个`RedissonClient`实例。
springboot整合jwt登录退出
04-11
JWT是一种安全的跨域身份验证方案，可以让用户通过一次身份验证就可以在多个应用程序中进行访问。在Spring Boot中，您需要使用Spring Security来实现JWT身份验证。要实现JWT登录和退出，您需要编写自定义的登录和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值