Spring Boot 4 实现JwtToken验证(重点)&&实现后端API(重点)&&前端：实现注册与登录模块(略)

已于 2022-08-18 04:12:38 修改
阅读量389 收藏
点赞数
分类专栏： Spring Boot 文章标签： 前端 spring boot java
于 2022-08-18 03:30:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52384627/article/details/126397513
版权

JwtToken&&注册与登录

不用认证，即不用ajax中headers配置项
登录+注册
.antMatchers("/user/account/token/","/user/account/register/").permitAll()

上面的跟前端没有什么联系
仅仅只是ajax时不用headers
前端具体的控制还在前端

1.实现JwtToken验证(重点)

1.1添加依赖

jjwt-api
jjwt-impl
jjwt-jackson

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.2</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.2</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId>
    <version>0.11.2</version>
    <scope>runtime</scope>
</dependency>

1.2 编写、修改相关类

1.2.1实现 JwtUtil 类

在 backend 目录下创建软件包 utils 并创建 JwtUtil 类。
JwtUtil 类为jwt 工具类，用来创建、解析 jwt token。

package com.kob.backend.utils;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.stereotype.Component;

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
import java.util.Date;
import java.util.UUID;

@Component
public class JwtUtil {
    public static final long JWT_TTL = 60 * 60 * 1000L * 24 * 14;  // 有效期14天
    public static final String JWT_KEY = "SDFGjhdsfalshdfHFdsjkdsfds121232131afasdfac";

    public static String getUUID() {
        return UUID.randomUUID().toString().replaceAll("-", "");
    }

    public static String createJWT(String subject) {
        JwtBuilder builder = getJwtBuilder(subject, null, getUUID());
        return builder.compact();
    }

    private static JwtBuilder getJwtBuilder(String subject, Long ttlMillis, String uuid) {
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
        SecretKey secretKey = generalKey();
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
        if (ttlMillis == null) {
            ttlMillis = JwtUtil.JWT_TTL;
        }

        long expMillis = nowMillis + ttlMillis;
        Date expDate = new Date(expMillis);
        return Jwts.builder()
                .setId(uuid)
                .setSubject(subject)
                .setIssuer("sg")
                .setIssuedAt(now)
                .signWith(signatureAlgorithm, secretKey)
                .setExpiration(expDate);
    }

    public static SecretKey generalKey() {
        byte[] encodeKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);
        return new SecretKeySpec(encodeKey, 0, encodeKey.length, "HmacSHA256");
    }

    public static Claims parseJWT(String jwt) throws Exception {
        SecretKey secretKey = generalKey();
        return Jwts.parserBuilder()
                .setSigningKey(secretKey)
                .build()
                .parseClaimsJws(jwt)
                .getBody();
    }
}
1.2.2实现 JwtAuthenticationTokenFilter 类

在 backend 的 config 目录下创建 config 软件包，并创建 JwtAuthenticationTokenFilter类。
实现 JwtAuthenticationTokenFilter 类，用来验证 jwt token ，如果验证成功，则将 User 信息注入上下文中。

package com.kob.backend.config.filter;


import com.kob.backend.mapper.UserMapper;
import com.kob.backend.pojo.User;
import com.kob.backend.service.impl.utils.UserDetailsImpl;
import com.kob.backend.utils.JwtUtil;
import com.sun.istack.internal.NotNull;
import io.jsonwebtoken.Claims;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
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;

@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
    @Autowired
    private UserMapper userMapper;

    @Override
    protected void doFilterInternal(HttpServletRequest request, @NotNull HttpServletResponse response, @NotNull FilterChain filterChain) throws ServletException, IOException {
        String token = request.getHeader("Authorization");

        if (!StringUtils.hasText(token) || !token.startsWith("Bearer ")) {
            filterChain.doFilter(request, response);
            return;
        }

        token = token.substring(7);

        String userid;
        try {
            Claims claims = JwtUtil.parseJWT(token);
            userid = claims.getSubject();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        User user = userMapper.selectById(Integer.parseInt(userid));

        if (user == null) {
            throw new RuntimeException("用户名未登录");
        }

        UserDetailsImpl loginUser = new UserDetailsImpl(user);
        UsernamePasswordAuthenticationToken authenticationToken =
                new UsernamePasswordAuthenticationToken(loginUser, null, null);

        SecurityContextHolder.getContext().setAuthentication(authenticationToken);

        filterChain.doFilter(request, response);
    }
}
1.2.3 配置config.SecurityConfig类

放行登录、注册等接口。

package com.kob.backend.config;

import com.kob.backend.config.filter.JwtAuthenticationTokenFilter;
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.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;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                //此处两个连接不需要认证，可以理解为不登陆就能访问的页面
                .antMatchers("/user/account/token/", "/user/account/register/").permitAll()
                .antMatchers(HttpMethod.OPTIONS).permitAll()
                .anyRequest().authenticated();

        http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
    }
}

2.实现后端API

2.1 修改数据库

在这里插入图片描述
在这里插入图片描述

2.2实现接口API(重点)

在这里插入图片描述

实现LoginService

在这里插入图片描述

package com.kob.backend.service.user.account;

import java.util.Map;

public interface LoginService {
    public Map<String, String> getToken(String username, String password);

}

在这里插入图片描述

package com.kob.backend.service.impl.user.account;

import com.kob.backend.pojo.User;
import com.kob.backend.service.impl.utils.UserDetailsImpl;
import com.kob.backend.service.user.account.LoginService;
import com.kob.backend.utils.JwtUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.neo4j.Neo4jProperties;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.Map;

@Service
public class LoginServiceImpl implements LoginService {

    @Autowired
    private AuthenticationManager authenticationManager;

    @Override
    public Map<String, String> getToken(String username, String password) {
        UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(username, password);

        Authentication authenticate = authenticationManager.authenticate(authenticationToken);
        UserDetailsImpl loginUser = (UserDetailsImpl) authenticate.getPrincipal();
        User user = loginUser.getUser();
        String jwt = JwtUtil.createJWT(user.getId().toString());

        Map<String, String> map = new HashMap<>();
        map.put("error_message", "success");
        map.put("token", jwt);

        return map;
    }
}

在这里插入图片描述

package com.kob.backend.controller.user.account;

import com.kob.backend.service.user.account.LoginService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;

@RestController
public class LoginController {

    @Autowired
    private LoginService loginService;

    @PostMapping("/user/account/token/")
    public Map<String, String> getToken(@RequestParam Map<String, String> map) {
        String username = map.get("username");
        String password = map.get("password");

        System.out.println(username + ' ' + password);
        return loginService.getToken(username, password);
    }
}
实现InfoService

在这里插入图片描述

package com.kob.backend.service.user.account;

import java.util.Map;

public interface InfoService {
    public Map<String, String> getInfo();
}

在这里插入图片描述

package com.kob.backend.service.impl.user.account;

import com.kob.backend.pojo.User;
import com.kob.backend.service.impl.utils.UserDetailsImpl;
import com.kob.backend.service.user.account.InfoService;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.Map;
@Service
public class InfoServiceImpl implements InfoService {

    /**
     * 根据token返回用户信息
     * @return map存储的信息
     */
    @Override
    public Map<String, String> getInfo() {
        UsernamePasswordAuthenticationToken authentication = (UsernamePasswordAuthenticationToken) SecurityContextHolder.getContext().getAuthentication();

        UserDetailsImpl loginUser = (UserDetailsImpl) authentication.getPrincipal();
        User user = loginUser.getUser();

        Map<String, String> map = new HashMap<>();
        map.put("error_message", "success");
        map.put("id", user.getId().toString());
        map.put("username", user.getUsername());
        map.put("photo", user.getPhoto());
        return map;
    }
}

在这里插入图片描述

package com.kob.backend.controller.user.account;

import com.kob.backend.service.user.account.InfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;

@RestController
public class InfoController {

    @Autowired
    private InfoService infoService;

    @GetMapping("/user/account/info/")
    public Map<String, String> getInfo() {
        return infoService.getInfo();
    }
}
实现RegisterService

在这里插入图片描述

package com.kob.backend.service.user.account;

import java.util.Map;

public interface RegisterService {
    public Map<String, String> register(String username, String password, String confirmedPassword);
}

在这里插入图片描述

package com.kob.backend.service.impl.user.account;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.kob.backend.mapper.UserMapper;
import com.kob.backend.pojo.User;
import com.kob.backend.service.user.account.RegisterService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class RegisterServiceImpl implements RegisterService {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    public Map<String, String> register(String username, String password, String confirmedPassword) {
        Map<String, String> map = new HashMap<>();
        if (username == null) {
            map.put("error_message", "用户名不能为空");
            return map;
        }

        if (password == null || confirmedPassword == null) {
            map.put("error_message", "密码不能为空");
            return map;
        }
        //删除首尾的空白字符
        username = username.trim();
        if (username.length() == 0) {
            map.put("error_message", "用户名不能为空");
            return map;
        }

        if (password.length() == 0 || confirmedPassword.length() == 0) {
            map.put("error_message", "密码不能为空");
            return map;
        }

        if (username.length() > 100) {
            map.put("error_message", "用户名长度不能大于100");
            return map;
        }

        if (password.length() > 100 || confirmedPassword.length() > 100) {
            map.put("error_message", "密码不能大于100");
            return map;
        }

        if (!password.equals(confirmedPassword)) {
            map.put("error_message", "两次输入的密码不一致");
            return map;
        }

        //查询用户名是否重复
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
        queryWrapper.eq("username", username);
        List<User> users = userMapper.selectList(queryWrapper);
        if (!users.isEmpty()) {
            map.put("error_message", "用户名已存在");
            return map;
        }

        // 添加一个新用户
        String encodedPassword = passwordEncoder.encode(password);
        //输入自己的图片地址
        String photo = "******************************";
        User user = new User(null, username, encodedPassword, photo);
        userMapper.insert(user);

        map.put("error_message", "success");
        return map;
    }
}

在这里插入图片描述

package com.kob.backend.controller.user.account;

import com.kob.backend.service.user.account.RegisterService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;

@RestController
public class RegisterController {

    @Autowired
    private RegisterService registerService;

    @PostMapping("/user/account/register/")
    public Map<String, String> register(@RequestParam Map<String, String> map) {
        String username = map.get("username");
        String password = map.get("password");
        String confirmedPassword = map.get("confirmedPassword");
        return registerService.register(username, password, confirmedPassword);
    }
}
前端调试

在这里插入图片描述

<template>
  <NavBar></NavBar>
  <router-view></router-view>
</template>

<script>

import NavBar from "@/components/NavBar.vue";
import "bootstrap/dist/css/bootstrap.min.css";
import "bootstrap/dist/js/bootstrap";
import $ from 'jquery'

export default {
  components:{
    NavBar
  },

  setup() {
    // 测试LoginService
    $.ajax({
      url: "http://127.0.0.1:8080/user/account/token/",
      type: "post",
      data: {
        username: 'syy',
        password: 'psyy',
      },
      success(resp) {
        console.log(resp);
      },
      error(resp) {
        console.log(resp); 
      }
    });
    // 测试InfoService
    $.ajax({
      url: "http://127.0.0.1:8080/user/account/info/",
      type: "get",
      headers: {
        Authorization: "Bearer " + "eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiI4MjliMjQzYjg4YmM0NjdjYmRkMDAwMmNiMzYwZDJiMyIsInN1YiI6IjEiLCJpc3MiOiJzZyIsImlhdCI6MTY1OTU3ODUyMiwiZXhwIjoxNjYwNzg4MTIyfQ.s5nd3RgtDKkPBDDm4P87ET8biZk8H79VMII1p_O9OsA",
      },
      success(resp) {
        console.log(resp);
      },
      error(resp) {
        console.log(resp);
      }
    });
    // 测试RegisterService
    $.ajax({
      url: "http://127.0.0.1:8080/user/account/register/",
      type: "post",
      data: {
        username: "hmy",
        password: "phmy",
        confirmedPassword: "phmy",
      },
      success(resp) {
        console.log(resp);
      },
      error(resp) {
        console.log(resp);
      }
    })
  }
}
</script>


<style>
body {
  background-image: url("./assets/images/background.png");
  background-size: cover;
}
</style>

在这里插入图片描述

3. 实现前端的登陆、注册界面（略）

3.1实现前端的页面授权功能—重定向到登录页面(重点)

在这里插入图片描述
router.index.js实现

router.beforeEach((to, from, next) => {
  if (to.meta.requestAuth && !store.state.user.is_login) {
    next({name: "user_account_login"});
  }
  else {
    next();
  }
})

3.2实现登录界面的可持久化(重点)

在这里插入图片描述

let jwt_token = localStorage.getItem("jwt_token");
        if (jwt_token) {
            store.commit("updateToken",jwt_token);
            //判断是否合法的，就是从云端获取用户信息
            store.dispatch("getinfo",{
                success() {
                    router.push({name: "home"});
                },
                error() {

                }
            })
        }

在这里插入图片描述

阿斯卡码
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
SpringBoot基于token的请求验证
一路向北的博客
09-09 4531
SpringBoot实现基于Token的请求验证
使用freeMarker模板和Spring boot后端API接口实现查询用户列表的功能。
03-06
使用freeMarker模板和Spring boot后端API接口实现查询用户列表的功能。 http://localhost:8080/ftl/index
jwt+token验证
qq_51127361的博客
09-19 1820
导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId
JWT token 相关配置 (全局配置 身份认证 重写Authenticate方法)
weixin_69282446的博客
04-27 1757
文章目录一. jwt 全局配置 判断用户是否登录1.settings配置二. 配置jwt过期时间 自定义返回的json数据1.utils.py函数编写,返回指定格式的json数据2.settings配置三. 配置django的认证后端 目的是只让管理员登录 自定义一个认证类 重写Authenticate方法1.utils.py类编写 重写Authenticate方法2.settings配置四. 路由配置五. 模型类1.models.py里定义用户类2.settings配置3 添加测试数据 一.
四、【Django】基于Jwt的token认证（登录接口）
Ataoker的博客
07-18 3602
django 使用jwt token的东西来进行认证
整合SpringSecurity和JWT实现登录认证和授权
Java升级之路的博客
09-07 4252
文章目录前言一、SpringSecurity是什么？二、JWT是什么？1. JWT的组成2. JWT实现认证和授权的原理三、整合步骤1. 引入相关依赖2. yml配置中加入jwt配置信息3. 添加JWT token的工具类4. 添加SpringSecurity的配置类5. 添加自定义结果处理类5.1 添加CustomAccessDeniedHandler5.2 添加CustomAuthenticationEntryPoint6. 添加JwtUser类7. 添加过滤器JwtAuthenticationTok
spring boot+jwt实现api的token认证详解
08-26
主要给大家介绍了关于spring boot+jwt实现api的token认证的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一学习学习吧
spring boot3.x结合spring security最新版实现jwt登录验证
09-02
spring boot3.x结合spring security最新版实现jwt登录验证
spring boot如何基于JWT实现单点登录详解
08-25
主要介绍了spring boot如何基于JWT实现单点登录详解，用户只需登录一次就能够在这两个系统中进行操作。很明显这就是单点登录(Single Sign-On)达到的效果,需要的朋友可以参考下
新闻系统（前端：Android 后端：Spring boot）
最新发布
03-13
（2）未登录用户：登录功能、注册功能。 （3）用户：查询新闻分类功能、查询某类新闻列表功能、查看文章（包括评论数，点赞数）功能、评论功能、查看评论列表功能、点赞和取消功能、查询本人评论过的新闻功能、查询...
vue利用request拦截器发送JWT校验.后台无法获取到Authorization信息怎么办？
计算机毕业论文源码，学生个人网页制作html源码。贴近用户做网络推广和互联网优化。
08-11 959
　　我来详细描述一下问题： 　　最近在自学用vue-element-admin和.net core写一个前后端分离的程序。目前的问题出在：登录成功后，后台会返回一个Token给前端，前端在登录后需要利用Token再次请求后端获取用户信息。问题就出在这里：我虽然在request拦截器中加入了Token,但是后台无法获取...
JSON WEB TOKEN 介绍
想走在路上的博客
04-10 1645
概要 JSON Web Token (JWT) 是一种紧凑，URL安全的方法，用于通信两端之间传递 claims 。在JWT中，claims 被编码成一个JSON 对象，在 JSON Web Sinature (JWS) 体系中，它充当payload， 在 JSON Web Encryption (JWE) 体系中，它充当  plaintext，通过消息鉴权编码（Message Authe
厉害，我带的实习生仅用四步就整合好SpringSecurity+JWT实现登录认证
热门推荐
沉默王二
04-07 2万+
小二是新来的实习生，作为技术 leader，我还是很负责任的，有什么锅都想甩给他，啊，不，一不小心怎么把心里话全说出来了呢？重来！ 小二是新来的实习生，作为技术 leader，我还是很负责任的，有什么好事都想着他，这不，我就安排了一个整合SpringSecurity+JWT实现登录认证的小任务交，没想到，他仅用四步就搞定了，这让我感觉倍有面。 一、关于 SpringSecurity 在 Spring Boot 出现之前，SpringSecurity 的使用场景是被另外一个安全管理框架 Shiro 牢牢霸占
解锁互联网安全的新钥匙：JWT（JSON Web Token）
weixin_74268571的博客
10-13 1640
JWT互联网安全，JWT的简介，并讲解了JWT的工作原理和JWT是如何工作的，JWT认证和session认证又有什么区别。介绍了JWT的结构和工具类的使用，以及案例的讲解
认证过滤器
Leon_Jinhai_Sun的博客
06-05 2054
认证
自定义Spring Security过滤器 JwtAuthenticationTokenFilter
zyx1234321的博客
11-19 362
这个过滤器的作用是在请求到达时验证 JWT，并将用户信息存储到 Spring Security 的上下文和 ThreadLocal 中，方便后续的权限验证和用户信息获取。放在所有过滤器前面，检查浏览器携带的token是否合法。
shiro学习——整合jwt时全局异常处理器无法处理JWTFilter中抛出的异常
weixin_43344930的博客
08-09 4584
springboot+shiro+jwt全局异常处理器无法处理JWTFilter中抛出的异常一、shiro中会出现的异常1、 AuthencationException2、 AuthorizationException二、为什么无法被全局异常处理器处理三、解决方案1、把统一返回的信息写入response中2、使用重定向到处理该错误的controller中 一、shiro中会出现的异常 1、 AuthencationException AuthenticationException 异常是Shiro在登录认
Spring Security+JWT在前后端分离项目中，实现认证授权的入门及理论讲解
penriver的博客
05-03 1577
SpringSecurity的原理其实就是一个过滤器链，内部包含了提供各种功能的过滤器。包含如下核心过滤器 - UsernamePasswordAuthenticationFilter： 根据用户名及密码进行认证工作 - ExceptionTranslationFilter：处理过滤器链中抛出的任何AccessDeniedException和 AuthenticationException - FilterSecurityInterceptor: 负责进行授权操作 本文讲解认证授权的入门及理论讲解
SpringBoot 整合 JWT 实现 Token 验证
qq_37634156的博客
06-20 2778
业务实现 1、创建Jwt生成验证token工具类 2、创建/oauth/token接口获取token 这里是我的生产环境上的获取token接口，主要功能就是根据传递过来的参数使用Jwt工具类创建token，再组合成规定的返回格式返回给对方。 基于HandlerInterceptor的实现类，对接口进行拦截，然后获取接口传递过来的token，用Jwt工具类进行解密，如果token验证通过则返回true并放行接口，验证不通过则返回错误信息。 5、测试获取token接口 至此功能实现
请介绍基础框架为Spring Boot和vue的用户登录功能的实现思路和使用的技术
05-18
1. Spring Boot：后端框架，用于构建 RESTful API。 2. Spring Security：安全框架，用于用户认证和授权。 3. JWT：用于生成和验证 JSON Web Tokens。 4. Vue：前端框架，用于构建用户界面。 5. Vue Router：用于...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿斯卡码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值