SpringBoot+JWT实现单点登录解决方案

已于 2023-07-26 11:16:49 修改
阅读量1w 收藏 49
点赞数 6
分类专栏： SpringBoot 文章标签： spring boot 后端 java
于 2023-07-04 18:25:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qinxun2008081/article/details/131533908
版权

一、什么是单点登录?

单点登录是一种统一认证和授权机制，指在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的系统，不需要重新登录验证。

单点登录一般用于互相授信的系统，实现单一位置登录，其他信任的应用直接免登录的方式，在多个应用系统中，只需要登录一次，就可以访问其他互相信任的应用系统。

随着时代的演进，大型web系统早已从单体应用架构发展为如今的多系统分布式应用群。但无论系统内部多么复杂，对用户而言，都是一个统一的整体，访问web系统的整个应用群要和访问单个系统一样，登录/注销只要一次就够了，不可能让一个用户在每个业务系统上都进行一次登录验证操作，这时就需要独立出一个单独的认证系统，它就是单点登录系统。

二、单点登录的优点

1.方便用户使用。用户不需要多次登录系统，不需要记住多个密码，方便用户操作。

2.提高开发效率。单点登录为开发人员提供类一个通用的验证框架。

3.简化管理。如果在应用程序中加入了单点登录的协议，管理用户账户的负担就会减轻。

三、JWT 机制

JWT(JSON Web Token)它将用户信息加密到token里，服务器不保存任何用户信息。服务器通过使用保存的密钥验证JWTToken的正确性，只要正确就通过验证。

数据结构:

JWT包含三个部分:Header头部，Payload负载和Signature签名。三个部门用“.”分割。校验也是JWT内部自己实现的 ,并且可以将你存储时候的信息从token中取出来无须查库。

JWT执行流程:

JWT的请求流程也特别简单，首先使用账号登录获取Token，然后后面的各种请求，都带上这个Token即可。具体流程如下：

1. 客户端发起登录请求，传入账号密码；

2. 服务端使用私钥创建一个Token；

3. 服务器返回Token给客户端；

4. 客户端向服务端发送请求，在请求头中携带Token；

5. 服务器验证该Token；

6. 返回结果。

四.创建Maven父项目

 2.指定打包类型为pom

 五.创建认证模块sso

 1.添加依赖，完整的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>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.13</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>sso</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>sso</name>
    <description>sso</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--jwt-->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.8.2</version>
        </dependency>
        <!--thymeleaf-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2添加jwt相关配置

 3.创建JWT配置类和JWT工具类

示例代码如下:

package com.example.sso.bean;

import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @author qx
 * @date 2023/7/4
 * @des Jwt配置类
 */
@Component
@ConfigurationProperties(prefix = "jwt")
@Getter
@Setter
public class JwtProperties {

    /**
     * 过期时间-分钟
     */
    private Integer expireTime;

    /**
     * refreshToken时间
     */
    private Integer refreshTime;

    /**
     * 密钥
     */
    private String secret;
}

package com.example.sso.util;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.example.sso.bean.JwtProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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

/**
 * @author qx
 * @date 2023/7/4
 * @des JWT工具类
 */
@Component
public class JwtUtil {

    @Autowired
    private JwtProperties jwtProperties;

    /**
     * 生成一个jwt字符串
     *
     * @param username 用户名
     * @return jwt字符串
     */
    public String sign(String username) {
        Algorithm algorithm = Algorithm.HMAC256(jwtProperties.getSecret());
        return JWT.create()
                // 设置过期时间1个小时
                .withExpiresAt(new Date(System.currentTimeMillis() + jwtProperties.getExpireTime() * 60 * 1000))
                // 设置负载
                .withClaim("username", username).sign(algorithm);
    }

    /**
     * 生成refreshToken
     *
     * @param username 用户名
     * @return
     */
    public String refreshToken(String username) {
        Algorithm algorithm = Algorithm.HMAC256(jwtProperties.getSecret());
        return JWT.create()
                // 设置更新时间2个小时
                .withExpiresAt(new Date(System.currentTimeMillis() + jwtProperties.getRefreshTime() * 60 * 1000))
                // 设置负载
                .withClaim("username", username).sign(algorithm);
    }


    public static void main(String[] args) {
        Algorithm algorithm = Algorithm.HMAC256("KU5TjMO6zmh03bU3");
        String username = "admin";
        String token = JWT.create()
                // 设置过期时间1个小时
                .withExpiresAt(new Date(System.currentTimeMillis() + 60 * 60 * 1000))
                // 设置负载
                .withClaim("username", username).sign(algorithm);
        System.out.println(token);
    }

    /**
     * 校验token是否正确
     *
     * @param token token值
     */
    public boolean verify(String token) {
        if (token == null || token.length() == 0) {
            throw new RuntimeException("token为空");
        }
        try {
            Algorithm algorithm = Algorithm.HMAC256(jwtProperties.getSecret());
            JWTVerifier jwtVerifier = JWT.require(algorithm).build();
            DecodedJWT decodedJWT = jwtVerifier.verify(token);
            Map<String, Claim> map = decodedJWT.getClaims();
            System.out.println("claims:" + map.get("username").asString());
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 重新生成token和refreshToken
     *
     * @param refreshToken refreshToken
     * @return 返回token和refreshToken
     */
    public Map<String, String> refreshJwt(String refreshToken) {
        if (refreshToken == null || refreshToken.length() == 0) {
            throw new RuntimeException("refreshToken为空");
        }
        Algorithm algorithm = Algorithm.HMAC256(jwtProperties.getSecret());
        JWTVerifier jwtVerifier = JWT.require(algorithm).build();
        DecodedJWT decodedJWT = jwtVerifier.verify(refreshToken);
        Map<String, Claim> map = decodedJWT.getClaims();
        // 获取用户名
        String username = map.get("username").asString();
        Map<String, String> resultMap = new HashMap<>();
        // 重新生成token和refreshToken
        resultMap.put("token", sign(username));
        resultMap.put("refreshToken", refreshToken(username));
        return resultMap;
    }
}

4.创建服务层

package com.example.sso.service;

import com.example.sso.util.JwtUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

/**
 * @author qx
 * @date 2023/7/4
 * @des 登录服务层
 */
@Service
public class LoginService {


    @Autowired
    private JwtUtil jwtUtil;

    /**
     * 登录
     *
     * @param username 用户名
     * @param password 密码
     * @return token值
     */
    public Map<String, String> login(String username, String password) {
        Map<String, String> map = new HashMap<>();
        if ("".equals(username) || "".equals(password)) {
            throw new RuntimeException("用户名或密码不能为空");
        }
        // 为了测试方便 不去数据库比较密码
        if ("123".equals(password)) {
            // 返回生成的token
            map.put("token", jwtUtil.sign(username));
            map.put("refreshToken", jwtUtil.refreshToken(username));
        }
        return map;
    }

    /**
     * 校验jwt是否成功
     *
     * @param token token值
     * @return 校验是否超过
     */
    public boolean checkJwt(String token) {
        return jwtUtil.verify(token);
    }

    /**
     * 重新生成token和refreshToken
     *
     * @param refreshToken refreshToken
     * @return token和refreshToken
     */
    public Map<String, String> refreshJwt(String refreshToken) {
        return jwtUtil.refreshJwt(refreshToken);
    }
}

5.创建控制层

package com.example.sso.controller;

import com.example.sso.service.LoginService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.Map;

/**
 * @author qx
 * @date 2023/7/4
 * @des 验证控制层
 */
@Controller
@RequestMapping("/sso")
public class AuthController {

    @Autowired
    private LoginService loginService;

    /**
     * 登录页面
     */
    @GetMapping("/login")
    public String toLogin() {
        return "login";
    }

    /**
     * 登录
     *
     * @param username 用户名
     * @param password 密码
     * @return token值
     */
    @PostMapping("/login")
    @ResponseBody
    public Map<String, String> login(String username, String password) {
        return loginService.login(username, password);
    }

    /**
     * 验证jwt
     *
     * @param token token
     * @return 验证jwt是否合法
     */
    @RequestMapping("/checkJwt")
    @ResponseBody
    public boolean checkJwt(String token) {
        return loginService.checkJwt(token);
    }


    /**
     * 重新生成token和refreshToken
     *
     * @param refreshToken refreshToken
     * @return token和refreshToken
     */
    @RequestMapping("/refreshJwt")
    @ResponseBody
    public Map<String, String> refreshJwt(String refreshToken) {
        return loginService.refreshJwt(refreshToken);
    }

}

6.创建一个登录页面login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录</title>
</head>
<body>
    <form method="post" action="/sso/login">
        用户名:<input type="text" name="username"/><br/>
        密码:<input type="password" name="password"/><br/>
        <button type="submit">登录</button>
    </form>
</body>
</html>

六、创建应用系统projectA 

 1.项目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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.example</groupId>
        <artifactId>my-sso</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>projectA</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.7.13</version>
        </dependency>
        <!--okhttp-->
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>4.10.0</version>
        </dependency>
    </dependencies>
</project>

 2.修改配置文件

 3.创建过滤器

package com.example.projectA.filter;

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @author qx
 * @date 2023/7/4
 * @des 登录过滤器
 */
@Component
@WebFilter(urlPatterns = "/**")
public class LoginFilter implements Filter {

    @Value("${sso_server}")
    private String serverHost;

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
        String token = httpServletRequest.getParameter("token");
        if (this.check(token)) {
            filterChain.doFilter(servletRequest, servletResponse);
        } else {
            // token过期后再使用refreshToken处理
            String refreshToken = httpServletRequest.getHeader("refreshToken");
            if (check(refreshToken)) {
                // 重新生成token和refreshtoken给客户端保存 下次传递token参数的时候使用这个重新生成的
                System.out.println("更新后的token和refreshToken:" + refreshToken(refreshToken));
                filterChain.doFilter(servletRequest, servletResponse);
            }
            // 如果refreshToken也过期 那么需要重新登录
            HttpServletResponse response = (HttpServletResponse) servletResponse;
            String redirect = serverHost + "/login";
            response.sendRedirect(redirect);
        }
    }

    /**
     * 验证token
     *
     * @param token
     * @return
     * @throws IOException
     */
    private boolean check(String token) throws IOException {
        if (token == null || token.trim().length() == 0) {
            return false;
        }
        OkHttpClient client = new OkHttpClient();
        // 请求验证token的合法性
        String url = serverHost + "/checkJwt?token=" + token;
        Request request = new Request.Builder().url(url).build();
        Response response = client.newCall(request).execute();
        return Boolean.parseBoolean(response.body().string());
    }

    /**
     * 重新获取token和refreshToken
     *
     * @param refreshToken
     * @return
     * @throws IOException
     */
    private String refreshToken(String refreshToken) throws IOException {
        if (refreshToken == null || refreshToken.trim().length() == 0) {
            return null;
        }
        OkHttpClient client = new OkHttpClient();
        // 请求重新获取token和refreshToken
        String url = serverHost + "/refreshJwt?refreshToken=" + refreshToken;
        Request request = new Request.Builder().url(url).build();
        Response response = client.newCall(request).execute();
        return response.body().string();

    }
}

4.创建测试控制层

package com.example.projectA.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author qx
 * @date 2023/7/4
 * @des 测试A
 */
@RestController
public class IndexController {

    @GetMapping("/testA")
    public String testA() {
        return "输出testA";
    }
}

5.启动类

package com.example.projectA;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;

/**
 * @author qx
 * @date 2023/7/4
 * @des Projecta启动类
 */
@SpringBootApplication
@ServletComponentScan
public class ProjectaApplication {

    public static void main(String[] args) {
        SpringApplication.run(ProjectaApplication.class,args);
    }
}

6.启动项目测试

我们访问http://localhost:8081/testA 系统跳转到了验证模块的登录页面

我们输入账号密码登录成功后返回token

 如何我们复制这段数据，把数据传递到token参数。

 我们看到正确获取到了数据。

当我们的token过期之后，我们使用refreshToken重新获取到新的token和refreshToken。

 由于我们的项目中refreshToken的更新时间为2分钟，我们等这个时间过期之后我们再次请求接口，那么这个时候就要去重新登录了。

一般的我们的refreshToken时间设置要比token的过期时间要长。

客户端登录后，将 token和refreshToken 保存在客户端本地，每次访问将 token 传给服务端。服务端校验 accessToken 的有效性，如果过期的话，就将 refreshToken 传给服务端。如果 refreshToken 有效，服务端就生成新的 accessToken 给客户端。否则，客户端就重新登录即可。

七、创建应用系统projectB

我们再次模仿projectA创建projectB子模块。

 

 启动模块B

我们直接测试带上token参数

通过之前的token，无需登录即可成功进入了应用系统B。说明我们的单点登录系统搭建成功。

qinxun2008081
关注
  • 6
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
基于SpringBoot实现单点登录的两种方式
09-01
基于SpringBoot实现单点登录的两种方式，第一种（Session）：SpringBoot+SpringSession+Redis；第二种基于（Session+Cookie）：SpringBoot+Redis（redis集群+池化:一致性Hash分片算法） 实现单点登陆
springsecurity实现单点登录
专注于Java架构学习 https://gitee.com/laokouyun https://github.com/KouShenhai
07-11 1万+
小伙伴们，你们好呀！我是老寇！废话不多说，跟我一起学习单点登录SSO。
SpringBoot整合OAuth2 实现单点登录 SSO
usa_washington的博客
02-29 1205
SSO
使用Spring Security实现单点登录
m0_64714024的博客
06-30 6767
一.导入依赖 注意:需要使用SpringBoot web的基础依赖以及测试依赖,防止启动工程时出错.添加完依赖之后即可启动工程,启动工程后,会在控制台看到如下信息:Using generated security password: 28b90a94-29d3-4a69-a62c-f4309c72f077Spring Security有默认的登录的账号和密码,密码是随机的,就是上面的信息中后半部分,每次启动项目都会不一样.然后访问http://localhost/8080,会看到如下信息:Spring
基于JWT实现单点登录
热门推荐
Lyh_ok的博客
05-15 1万+
单点登录概述： 多系统共存下，用户在一处地方登录，得到其他所有系统的信任，无需再次登录。 自己的理解：在进行用户登录的时候，jwt生成一个token，用户带着这个token去其他页面进行验证。(token设置过期时间) 这里介绍一些jwt基本概念 JWT：1.认证流程 a.首先，前端通过web表单将自己的用户民和密码发送到后端的接口，这一过程一般是一个HTTP,POST请求。建议的方式是通过SSL 加密的方式传输(https协议)，从而避免敏感信息被嗅探。 b.后端核对用户名和密码成功后，将用户的id
基于SpringBoot实现简易的单点登录系统（提供gitee源码）
黄团团的个人博客
09-02 7305
单点登录的英文名全称叫做：Single Sign On，简称SSO，是指在同一个账号平台下的多个子系统中，用户只需要登录一次，就可以访问其余所有相互的信任的系统，比如支付宝旗下有天猫和淘宝，当我登陆了淘宝以后，天猫也会同步进行登录，就不需要们再一个个去进行登录操作了，简而言之便是，多个互相信任的子系统同步登陆。这里我主要通过Token拼接在URL上面实现的单点登录，整体项目写的非常简易，仅用于提供一个学习思路，对单点登录有个基础的了解。
企业员工角色权限管理平台（SpringBoot2.0+Mybatis+Shiro+Vue）
08-07
课程简介：历经半个多月的时间，Debug亲自撸的 “企业员工角色权限管理平台” 终于完成了。正如字面意思，本课程讲解的是一个真正意义上的、企业级的项目实战，主要介绍了企业级应用系统中后端应用权限的管理，其中主要涵盖了六大核心业务模块、十几张数据库表。 其中的核心业务模块主要包括用户模块、部门模块、岗位模块、角色模块、菜单模块和系统日志模块；与此同时，Debug还亲自撸了额外的附属模块，包括字典管理模块、商品分类模块以及考勤管理模块等等，主要是为了更好地巩固相应的技术栈以及企业应用系统业务模块的开发流程！ 核心技术栈列表： 值得介绍的是，本课程在技术栈层面涵盖了前端和后端的大部分常用技术，包括Spring Boot、Spring MVC、Mybatis、Mybatis-Plus、Shiro(身份认证与资源授权跟会话等等)、Spring AOP、防止XSS攻击、防止SQL注入攻击、过滤器Filter、验证码Kaptcha、热部署插件Devtools、POI、Vue、LayUI、ElementUI、JQuery、HTML、Bootstrap、Freemarker、一键打包部署运行工具Wagon等等，如下图所示： 课程内容与收益： 总的来说，本课程是一门具有很强实践性质的“项目实战”课程，即“企业应用员工角色权限管理平台”，主要介绍了当前企业级应用系统中员工、部门、岗位、角色、权限、菜单以及其他实体模块的管理；其中，还重点讲解了如何基于Shiro的资源授权实现员工-角色-操作权限、员工-角色-数据权限的管理；在课程的最后，还介绍了如何实现一键打包上传部署运行项目等等。如下图所示为本权限管理平台的数据库设计图： 以下为项目整体的运行效果截图： 值得一提的是，在本课程中，Debug也向各位小伙伴介绍了如何在企业级应用系统业务模块的开发中，前端到后端再到数据库，最后再到服务器的上线部署运行等流程，如下图所示：
[SpringBoot]单点登录
YJH000_的博客
06-30 4225
【实现手段】当用户提交登录请求时，就需要获取用户的IP地址与设备信息，当验证登录通过后，将此用户的JWT、IP地址、设备信息全部存入到Redis中，后续，当客户端提交请求后，在。）中，首先检查Redis中的信息，如果此JWT在Redis中存在（例如白名单），则视为有效，所以，当退出登录时，只需要在Redis中将对应的JWT删除即可。目前的代码中，将管理员的权限列表存储在JWT中，导致JWT数据太长，并且，权限数据应该视为敏感数据，不应该表现在JWT中。以上问题都可以结合Redis的应用来解决！
springboot简单实现单点登录思路
weixin_61307867的博客
11-26 2414
springboot简单实现单点登录思路
基于SpringBoot的单点登录实现
weixin_43220867的博客
10-13 3207
基于SpringBoot的单点登录实现
Spring Boot | Spring Boot使用JWT实现单点登录
jonssonyan
09-15 4329
Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。 传统的session认证 我们知道，http协议本身是一种无状态的协议，而这就意味着如果用户向我们.
liugh-parent:SpringBoot+SpringCloud Oauth2+JWT+MybatisPlus实现Restful快速开发后端脚手架
05-24
bx-cloud#注意由于升级到了...Spring Cloud Security 为构建安全的SpringBoot应用提供了一系列解决方案，结合Oauth2可以实现单点登录、令牌中继、令牌交换等功能.是一个 的增强工具，有代码生成器，并且提供了类似
基于SpringBoot+Vue实现的企业级微服务多租户多系统架构（部署完成标准企业级WEB后台、可二次开发）
12-19
真正实现了手撸RBAC、jwt的无状态统一权限认证的解决方案，面向互联网设计同时适合B端和C端用户，支持CI/CD多环境部署；同时还集合各种微服务治理功能和监控功能。模块包括:企业级的认证系统、开发平台、应用监控、...
基于Spring Cloud+SpringBoot+VUE家教预约平台后台管理前端.zip
03-04
Spring Cloud作为后端基础开发框架，Vue.js作为前端基础开发框架，以微服务架构进行设计，前后端完全分离，使用JWT作为无状态解决方案，提供RESTful风格的API、后台动态权限管理、第三方登录以及单点登录功能。...
Spring Boot分段处理List集合多线程批量插入数据
涛哥是个大帅比
04-22 498
Spring Boot分段处理List集合多线程批量插入数据
快速构建Spring boot项目
Fxdll的博客
04-22 502
2、运行4、开发环境热部署查看目前已有的依赖。
# 使用 spring boot 时，@Autowired 注解 自动装配注入时，变量报红解决方法：
最新发布
段子手168的博客
04-29 107
# 使用 spring boot 时，@Autowired 注解 自动装配注入时，变量报红解决方法：
用springboot+JWT+Redis实现单点登录
05-25
单点登录（Single Sign-On，简称SSO）是一种身份验证技术，可以让用户只需一次登录，就可以访问多个应用程序。在实际开发中，我们可以使用Spring Boot、JWT和Redis来实现单点登录功能。 下面是实现单点登录的步骤： 1. 创建Spring Boot项目并引入所需依赖：spring-boot-starter-web、spring-boot-starter-data-redis和jjwt。 2. 创建一个User实体类，包含用户名和密码等信息。 3. 创建一个UserService，实现对用户信息的操作，包括注册、登录等。 4. 引入JWT依赖后，我们需要创建一个JWTUtil类，实现token的生成和解析。 5. 创建一个LoginController，用于处理用户的登录请求。在登录成功后，生成token并将其存储到Redis中。 6. 创建一个AuthController，用于验证用户的token是否有效。在验证成功后，可以获取用户信息并返回。 7. 在需要进行单点登录验证的应用程序中，只需要在请求中携带token，并调用AuthController进行验证即可。 具体实现细节可以参考以下代码示例： User实体类： ```java public class User { private String username; private String password; // 省略setter和getter方法 } ``` UserService接口： ```java public interface UserService { void register(User user); String login(String username, String password); } ``` UserService实现类： ```java @Service public class UserServiceImpl implements UserService { @Autowired private RedisTemplate<String, String> redisTemplate; @Override public void register(User user) { // 省略用户注册逻辑 } @Override public String login(String username, String password) { // 省略用户登录逻辑 // 登录成功后生成token并存储到Redis中 String token = JWTUtil.generateToken(username); redisTemplate.opsForValue().set(username, token, 30, TimeUnit.MINUTES); return token; } } ``` JWTUtil类： ```java public class JWTUtil { private static final String SECRET_KEY = "my_secret_key"; private static final long EXPIRATION_TIME = 3600000; public static String generateToken(String username) { return Jwts.builder() .setSubject(username) .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION_TIME)) .signWith(SignatureAlgorithm.HS256, SECRET_KEY) .compact(); } public static String getUsernameFromToken(String token) { return Jwts.parser() .setSigningKey(SECRET_KEY) .parseClaimsJws(token) .getBody() .getSubject(); } } ``` LoginController： ```java @RestController public class LoginController { @Autowired private UserService userService; @PostMapping("/login") public ResponseEntity<String> login(@RequestBody User user) { String token = userService.login(user.getUsername(), user.getPassword()); return ResponseEntity.ok(token); } } ``` AuthController： ```java @RestController public class AuthController { @Autowired private RedisTemplate<String, String> redisTemplate; @GetMapping("/auth") public ResponseEntity<User> auth(@RequestHeader("Authorization") String token) { String username = JWTUtil.getUsernameFromToken(token); if (StringUtils.isEmpty(username)) { return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build(); } String redisToken = redisTemplate.opsForValue().get(username); if (!token.equals(redisToken)) { return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build(); } User user = new User(); user.setUsername(username); return ResponseEntity.ok(user); } } ``` 在请求中携带token的示例： ```java @Configuration public class RestTemplateConfig { @Bean public RestTemplate restTemplate() { RestTemplate restTemplate = new RestTemplate(); restTemplate.setInterceptors(Collections.singletonList((request, body, execution) -> { String token = // 从Redis中获取token request.getHeaders().add("Authorization", token); return execution.execute(request, body); })); return restTemplate; } } ``` 以上就是使用Spring Boot、JWT和Redis实现单点登录的步骤和示例代码。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

qinxun2008081

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

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

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

打赏作者

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

抵扣说明：

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

余额充值