springcloud+oauth2+sso单点登录+自定义获取用户token+第三方系统访问获取token

原创 已于 2026-05-13 13:58:13 修改 · 340 阅读 · 5 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#spring cloud #spring boot #后端
于 2026-05-09 17:47:47 首次发布
  1. springcloud+oauth2+sso单点登录实现
  2. 自定义获取某个用户token值和权限
  3. 第三方应用系统访问本应用系统接口获取指定用户名的token和权限

  • 指定用户名和权限定义 
    package com.shpl.scp.fin.controller;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.shpl.scp.admin.api.dto.UserTokenDTO;
import com.shpl.scp.admin.api.feign.RemoteTokenService;
import com.shpl.scp.common.core.util.R;
import com.shpl.scp.common.security.annotation.Inner;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpHeaders;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

/**
 * 第三方系统Token接口
 *
 * @author Dionys
 * @date 2025-12-09
 */
@Slf4j
@RestController
@RequiredArgsConstructor
@RequestMapping("/external/cloudpense")
@Tag(description = "cloudcheckToken", name = "云检系统Token接口")
@SecurityRequirement(name = HttpHeaders.AUTHORIZATION)
public class FinApiCloudPenseTokenController {

    private final RemoteTokenService remoteTokenService;

    @Inner(false)
    @RequestMapping("/token")
    public R<UserTokenDTO.Response> token() {
        // 创建请求对象
        UserTokenDTO.Request request = new UserTokenDTO.Request();
        request.setUsername("FinCloudAPI");  // 只需要提供用户名
        request.setAuthorities(List.of("ROLE_1", "fin_cloudpense")); // 设置用户角色（ROLE_ID 固定写法）权限字符串

        // 调用Token生成服务
        return remoteTokenService.generateToken(request);
    }

    @Inner(false)
    @RequestMapping("/tokenp")
    public R<Page> tokenp() {
        // 创建请求对象
        Map<String, Object> params = Map.of("current", 1, "size", 10);
        // 调用Token生成服务
        return remoteTokenService.getTokenPage(params);
    }

}

  • 自定义一个用户名的token实现 
    /**
     * 获取token  -  自定义token
     * @param request 请求参数
     * @return {@link UserTokenDTO.Response}
     */
    @Inner  // 这个注解表示只有内部系统可以调用
    @SneakyThrows
    @PostMapping("/token/generate-token")
    public R<UserTokenDTO.Response> generateToken(@RequestBody UserTokenDTO.Request request) {

        // 第1步：创建一个"客户端配置"，告诉系统这个Token的基本规则
        RegisteredClient registeredClient = RegisteredClient.withId(SecurityConstants.FROM)
                .clientId(SecurityConstants.FROM)
                .authorizationGrantType(AuthorizationGrantType.PASSWORD)
                .tokenSettings(TokenSettings.builder()
                        .accessTokenTimeToLive(Duration.ofHours(24)) // Token有效期：24小时
                        .refreshTokenTimeToLive(Duration.ofDays(7))  // 刷新Token有效期：7天
                        .accessTokenFormat(OAuth2TokenFormat.REFERENCE)
                        .build())
                .build();

        // 第2步：构建用户信息对象
        // 这里我们根据传入的用户名创建一个完整的用户对象
        ScpUser pigUser = new ScpUser(
                110L,                    // 用户ID
                request.getUsername(),   // 用户名
                null,                    // 密码（这里不需要）
                "", "", "", "", "",      // 其他用户信息（暂时为空）
                1L,                      // 部门ID
                "",                      // 其他信息
                true, true,              // 账户状态
                UserTypeEnum.TOB.getStatus(),
                true, false,
                // 将权限字符串转换为系统认识的权限对象
                request.getAuthorities().stream()
                        .map(SimpleGrantedAuthority::new)
                        .collect(Collectors.toList())
        );

        // 第3步：创建认证对象
        Authentication usernamePasswordAuthentication =
                new UsernamePasswordAuthenticationToken(pigUser, StrUtil.EMPTY);

        // 第4步：设置Token生成的上下文环境
        DefaultOAuth2TokenContext.Builder tokenContextBuilder = DefaultOAuth2TokenContext.builder()
                .registeredClient(registeredClient)
                .principal(usernamePasswordAuthentication)
                .authorizationServerContext(new AuthorizationServerContext() {
                    @Override
                    public String getIssuer() {
                        return "http://ai.com";  // Token发行者
                    }

                    @Override
                    public AuthorizationServerSettings getAuthorizationServerSettings() {
                        return AuthorizationServerSettings.builder().build();
                    }
                });

        // 第5步：开始构建授权信息
        OAuth2Authorization.Builder authorizationBuilder = OAuth2Authorization
                .withRegisteredClient(registeredClient)
                .principalName(usernamePasswordAuthentication.getName());

        // 第6步：生成访问Token（主要的通行证）
        OAuth2TokenContext tokenContext = tokenContextBuilder
                .tokenType(OAuth2TokenType.ACCESS_TOKEN)
                .authorizationGrantType(AuthorizationGrantType.PASSWORD)
                .authorizationGrant(new OAuth2ClientAuthenticationToken(
                        registeredClient,
                        ClientAuthenticationMethod.CLIENT_SECRET_BASIC,
                        null))
                .build();

        OAuth2Token generatedAccessToken = this.tokenGenerator.generate(tokenContext);
        OAuth2AccessToken accessToken = new OAuth2AccessToken(
                OAuth2AccessToken.TokenType.BEARER,
                generatedAccessToken.getTokenValue(),
                generatedAccessToken.getIssuedAt(),
                generatedAccessToken.getExpiresAt(),
                tokenContext.getAuthorizedScopes());

        // 第7步：保存访问Token信息
        if (generatedAccessToken instanceof ClaimAccessor) {
            authorizationBuilder.id(accessToken.getTokenValue())
                    .token(accessToken, (metadata) -> metadata.put(
                            OAuth2Authorization.Token.CLAIMS_METADATA_NAME,
                            ((ClaimAccessor) generatedAccessToken).getClaims()))
                    .attribute(Principal.class.getName(), usernamePasswordAuthentication);
        } else {
            authorizationBuilder.id(accessToken.getTokenValue()).accessToken(accessToken);
        }

        // 第8步：生成刷新Token（用来获取新的访问Token）
        OAuth2RefreshToken refreshToken;
        tokenContext = tokenContextBuilder.tokenType(OAuth2TokenType.REFRESH_TOKEN).build();
        OAuth2Token generatedRefreshToken = this.tokenGenerator.generate(tokenContext);
        refreshToken = (OAuth2RefreshToken) generatedRefreshToken;
        authorizationBuilder.refreshToken(refreshToken);

        // 第9步：保存完整的授权信息到数据库
        OAuth2Authorization authorization = authorizationBuilder
                .authorizationGrantType(AuthorizationGrantType.PASSWORD)
                .build();
        this.authorizationService.save(authorization);

        // 第10步：返回生成的Token
        return R.ok(new UserTokenDTO.Response(
                accessToken.getTokenValue(),
                refreshToken.getTokenValue()));
    }
    package com.shpl.scp.admin.api.dto;

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

import java.util.ArrayList;
import java.util.List;

@Data
public class UserTokenDTO {

    // 请求信封：装载我们要发送的数据
    @Data
    public static class Request {
        private String username;  // 用户名（必填）
        private List<String> authorities = new ArrayList<>();  // 用户权限列表（可选）
    }

    // 响应信封：装载系统返回给我们的数据
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public static class Response {
        private String accessToken;   // 访问令牌（主要的通行证）
        private String refreshToken;  // 刷新令牌（用来获取新的访问令牌）
    }
}
    /*
 *    Copyright (c) 2018-2025, scp All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 * Neither the name of the pig4cloud.com developer nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 * Author: scp
 */

package com.shpl.scp.common.security.service;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Getter;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.SpringSecurityCoreVersion;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.oauth2.core.OAuth2AuthenticatedPrincipal;

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

/**
 * @author scp
 * @date 2020/4/16 扩展用户信息
 */
public class ScpUser extends User implements OAuth2AuthenticatedPrincipal {

	private static final long serialVersionUID = SpringSecurityCoreVersion.SERIAL_VERSION_UID;

	/**
	 * 扩展属性，方便存放oauth 上下文相关信息
	 */
	private final Map<String, Object> attributes = new HashMap<>();

	/**
	 * 用户ID
	 */
	@Getter
	private Long id;

	/**
	 * 部门ID
	 */
	@Getter
	private Long deptId;

	/**
	 * 手机号
	 */
	@Getter
	private String phone;

	/**
	 * 头像
	 */
	@Getter
	private String avatar;

	/**
	 * 租户ID
	 */
	@Getter
	private Long tenantId;

	/**
	 * 拓展字段:昵称
	 */
	@Getter
	private String nickname;

	/**
	 * 拓展字段:姓名
	 */
	@Getter
	private String name;

	/**
	 * 拓展字段:邮箱
	 */
	@Getter
	private String email;

	@Getter
	private String userType;

	/**
	 * Construct the <code>User</code> with the details required by
	 * {@link DaoAuthenticationProvider}.
	 * @param id 用户ID
	 * @param deptId 部门ID
	 * @param tenantId 租户ID
	 * @param nickname 昵称
	 * @param name 姓名
	 * @param email 邮箱 the username presented to the
	 * <code>DaoAuthenticationProvider</code>
	 * @param password the password that should be presented to the
	 * <code>DaoAuthenticationProvider</code>
	 * @param enabled set to <code>true</code> if the user is enabled
	 * @param accountNonExpired set to <code>true</code> if the account has not expired
	 * @param credentialsNonExpired set to <code>true</code> if the credentials have not
	 * expired
	 * @param accountNonLocked set to <code>true</code> if the account is not locked
	 * @param authorities the authorities that should be granted to the caller if they
	 * presented the correct username and password and the user is enabled. Not null.
	 * @throws IllegalArgumentException if a <code>null</code> value was passed either as
	 * a parameter or as an element in the <code>GrantedAuthority</code> collection
	 */
	@JsonCreator
	public ScpUser(@JsonProperty("id") Long id, @JsonProperty("username") String username,
			@JsonProperty("deptId") Long deptId, @JsonProperty("phone") String phone,
			@JsonProperty("avatar") String avatar, @JsonProperty("nickname") String nickname,
			@JsonProperty("name") String name, @JsonProperty("email") String email,
			@JsonProperty("tenantId") Long tenantId, @JsonProperty("password") String password,
			@JsonProperty("enabled") boolean enabled, @JsonProperty("accountNonExpired") boolean accountNonExpired,
			@JsonProperty("userType") String userType,
			@JsonProperty("credentialsNonExpired") boolean credentialsNonExpired,
			@JsonProperty("accountNonLocked") boolean accountNonLocked,
			@JsonProperty("authorities") Collection<? extends GrantedAuthority> authorities) {
		super(username, password, enabled, accountNonExpired, credentialsNonExpired, accountNonLocked, authorities);
		this.id = id;
		this.deptId = deptId;
		this.phone = phone;
		this.avatar = avatar;
		this.tenantId = tenantId;
		this.nickname = nickname;
		this.name = name;
		this.email = email;
		this.userType = userType;
	}

	@Override
	public Map<String, Object> getAttributes() {
		return this.attributes;
	}

}

    package com.shpl.scp.common.security.service;

import cn.hutool.core.collection.CollUtil;
import com.shpl.scp.common.core.constant.SecurityConstants;
import lombok.RequiredArgsConstructor;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.lang.Nullable;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.oauth2.core.OAuth2AccessToken;
import org.springframework.security.oauth2.core.OAuth2RefreshToken;
import org.springframework.security.oauth2.core.endpoint.OAuth2ParameterNames;
import org.springframework.security.oauth2.server.authorization.OAuth2Authorization;
import org.springframework.security.oauth2.server.authorization.OAuth2AuthorizationCode;
import org.springframework.security.oauth2.server.authorization.OAuth2AuthorizationService;
import org.springframework.security.oauth2.server.authorization.OAuth2TokenType;
import org.springframework.util.Assert;

import java.security.Principal;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author scp
 * @date 2022/5/27
 */
@RequiredArgsConstructor
public class ScpRedisOAuth2AuthorizationService implements OAuth2AuthorizationService {

	private final static Long TIMEOUT = 10L;

	private static final String AUTHORIZATION = "token";

	private final RedisTemplate<String, Object> redisTemplate;

	private static boolean isState(OAuth2Authorization authorization) {
		return Objects.nonNull(authorization.getAttribute("state"));
	}

	private static boolean isCode(OAuth2Authorization authorization) {
		OAuth2Authorization.Token<OAuth2AuthorizationCode> authorizationCode = authorization
			.getToken(OAuth2AuthorizationCode.class);
		return Objects.nonNull(authorizationCode);
	}

	private static boolean isRefreshToken(OAuth2Authorization authorization) {
		return Objects.nonNull(authorization.getRefreshToken());
	}

	private static boolean isAccessToken(OAuth2Authorization authorization) {
		return Objects.nonNull(authorization.getAccessToken());
	}

	@Override
	public void save(OAuth2Authorization authorization) {
		Assert.notNull(authorization, "authorization cannot be null");

		if (isState(authorization)) {
			String token = authorization.getAttribute("state");
			redisTemplate.setValueSerializer(RedisSerializer.java());
			redisTemplate.opsForValue()
				.set(buildKey(OAuth2ParameterNames.STATE, token), authorization, TIMEOUT, TimeUnit.MINUTES);
		}

		if (isCode(authorization)) {
			OAuth2Authorization.Token<OAuth2AuthorizationCode> authorizationCode = authorization
				.getToken(OAuth2AuthorizationCode.class);
			OAuth2AuthorizationCode authorizationCodeToken = authorizationCode.getToken();
			long between = ChronoUnit.MINUTES.between(authorizationCodeToken.getIssuedAt(),
					authorizationCodeToken.getExpiresAt());
			redisTemplate.setValueSerializer(RedisSerializer.java());
			redisTemplate.opsForValue()
				.set(buildKey(OAuth2ParameterNames.CODE, authorizationCodeToken.getTokenValue()), authorization,
						between, TimeUnit.MINUTES);
		}

		if (isRefreshToken(authorization)) {
			OAuth2RefreshToken refreshToken = authorization.getRefreshToken().getToken();
			long between = ChronoUnit.SECONDS.between(refreshToken.getIssuedAt(), refreshToken.getExpiresAt());
			redisTemplate.setValueSerializer(RedisSerializer.java());
			redisTemplate.opsForValue()
				.set(buildKey(OAuth2ParameterNames.REFRESH_TOKEN, refreshToken.getTokenValue()), authorization, between,
						TimeUnit.SECONDS);
		}

		if (isAccessToken(authorization)) {
			OAuth2AccessToken accessToken = authorization.getAccessToken().getToken();
			long between = ChronoUnit.SECONDS.between(accessToken.getIssuedAt(), accessToken.getExpiresAt());
			redisTemplate.setValueSerializer(RedisSerializer.java());
			redisTemplate.opsForValue()
				.set(buildKey(OAuth2ParameterNames.ACCESS_TOKEN, accessToken.getTokenValue()), authorization, between,
						TimeUnit.SECONDS);

			UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = authorization
				.getAttribute(Principal.class.getName());

			if (Objects.nonNull(usernamePasswordAuthenticationToken)
					&& usernamePasswordAuthenticationToken.getPrincipal() instanceof ScpUser scpUser) {
				// 扩展记录 access-token 、username 的关系 token::username::admin::tenantId::xxx
				String tokenUsername = String.format("%s::%s::%s::%s::%s::%s", AUTHORIZATION,
						SecurityConstants.DETAILS_USERNAME, authorization.getPrincipalName(),
						authorization.getRegisteredClientId(), scpUser.getTenantId(), accessToken.getTokenValue());
				redisTemplate.opsForValue().set(tokenUsername, accessToken.getTokenValue(), between, TimeUnit.SECONDS);
			}
		}
	}

	@Override
	public void remove(OAuth2Authorization authorization) {
		Assert.notNull(authorization, "authorization cannot be null");

		List<String> keys = new ArrayList<>();
		if (isState(authorization)) {
			String token = authorization.getAttribute("state");
			keys.add(buildKey(OAuth2ParameterNames.STATE, token));
		}

		if (isCode(authorization)) {
			OAuth2Authorization.Token<OAuth2AuthorizationCode> authorizationCode = authorization
				.getToken(OAuth2AuthorizationCode.class);
			OAuth2AuthorizationCode authorizationCodeToken = authorizationCode.getToken();
			keys.add(buildKey(OAuth2ParameterNames.CODE, authorizationCodeToken.getTokenValue()));
		}

		if (isRefreshToken(authorization)) {
			OAuth2RefreshToken refreshToken = authorization.getRefreshToken().getToken();
			keys.add(buildKey(OAuth2ParameterNames.REFRESH_TOKEN, refreshToken.getTokenValue()));
		}

		if (isAccessToken(authorization)) {
			OAuth2AccessToken accessToken = authorization.getAccessToken().getToken();
			keys.add(buildKey(OAuth2ParameterNames.ACCESS_TOKEN, accessToken.getTokenValue()));

			// 扩展记录 access-token 、username 的关系 1::token::username::admin::xxx
			String key = String.format("%s::%s::%s::%s::*::%s", AUTHORIZATION, SecurityConstants.DETAILS_USERNAME,
					authorization.getPrincipalName(), authorization.getRegisteredClientId(),
					accessToken.getTokenValue());
			Set<String> pattenKey = redisTemplate.keys(key);
			if (CollUtil.isNotEmpty(pattenKey)) {
				keys.addAll(pattenKey);
			}
		}

		redisTemplate.delete(keys);
	}

	@Override
	@Nullable
	public OAuth2Authorization findById(String id) {
		throw new UnsupportedOperationException();
	}

	@Override
	@Nullable
	public OAuth2Authorization findByToken(String token, @Nullable OAuth2TokenType tokenType) {
		Assert.hasText(token, "token cannot be empty");
		redisTemplate.setValueSerializer(RedisSerializer.java());
		return (OAuth2Authorization) redisTemplate.opsForValue()
			.get(buildKey(Objects.requireNonNullElse(tokenType, OAuth2TokenType.ACCESS_TOKEN).getValue(), token));
	}

	private String buildKey(String type, String id) {
		return String.format("%s::%s::%s", AUTHORIZATION, type, id);
	}

	/**
	 * 根据用户名移除相关授权信息
	 * @param authentication 认证信息，包含用户名
	 */
	public void removeByUsername(Authentication authentication) {
		// 根据 username查询对应access-token
		String authenticationName = authentication.getName();

		// 扩展记录 access-token 、username 的关系 1::token::username::admin::xxx
		String tokenUsernameKey = String.format("%s::%s::%s::*", AUTHORIZATION, SecurityConstants.DETAILS_USERNAME,
				authenticationName);
		Set<String> keys = redisTemplate.keys(tokenUsernameKey);
		if (CollUtil.isEmpty(keys)) {
			return;
		}

		List<Object> tokenList = redisTemplate.opsForValue().multiGet(keys);

		for (Object token : tokenList) {
			// 根据token 查询存储的 OAuth2Authorization
			OAuth2Authorization authorization = this.findByToken((String) token, OAuth2TokenType.ACCESS_TOKEN);

			if (Objects.isNull(authorization)) {
				continue;
			}
			// 根据 OAuth2Authorization 删除相关令牌
			this.remove(authorization);
		}

		redisTemplate.delete(keys);
	}

}

xiaogg3678
关注
SpringCloud+SpringBoot+SSO单点登录之OAuth2.0 根据token获取用户信息(4)
m0_46411169的博客
06-10 1539
上一篇我根据框架中OAuth2.0的使用总结，画了SSO单点登录之OAuth2.0 登出流程，今天我们看一下根据用户token获取yoghurt信息的流程： Java代码 /** * 根据token获取用户信息 * @param accessToken * @return * @throws Exception */ @RequestMapping(value = "/user/token/{accesstoken}", method = RequestMethod.G
springsecurity实现单点登录
.
07-11 1万+
小伙伴们，你们好呀！我是老寇！废话不多说，跟我一起学习单点登录SSO。
SpringCloud之SSO单点登录-基于Gateway和OAuth2的跨系统统一认证和鉴权详解
踏雨歌青春，诗酒趁年华
05-29 2万+
本文详述了如何利用SpringCloud、Gateway和OAuth2实现跨系统的统一认证和鉴权。文章介绍了SSO单点登录的概念和优势，通过具体的配置和代码示例，讲解了如何搭建一个安全、高效的认证中心，实现用户只需一次登录即可访问多个系统的目标，从而提高系统安全性和用户体验。
OAuth2.0 实现单点登录
热门推荐
qq15035899256的博客
03-17 3万+
本文是对OAuth2.0的学习，了解了它的4种授权方式，学会了如何搭建验证服务器，使用 postman对四种模式作了接口测试。并且学会了资源服务器实现单点登录的两种方式，也成功解决了远程调用时没有携带 token 的问题。最后也学会了使用 JWT 存储 Token，大大提高了安全性。
Spring Boot 进阶实战：整合 MyBatis、Redis、JWT，搭一个更像真实项目的后端服务
RonieWhite的博客
06-15 285
如果说 Spring Boot 基础篇解决的是“项目怎么起起来”，那么进阶篇更关心的是：这篇文章用一个偏典型的用户认证 + 商品查询场景，把下面四块内容串起来：目标是给出一套更像真实业务系统的实现骨架，而不是只给你几个零散知识点。假设我们现在要做一个简单的后端服务，支持这些能力：一个合理的技术职责拆分大致是：先看 Maven 依赖。 3. 项目结构建议 建议按下面这种方式组织： 这么分的好处是： 说明： 5.2 业务异常 5.3 全局异常处理 6. JWT：签发、解析、校验 6.1 配置类 6.2
Spring Boot 中 Starter 是什么？它的核心规范有哪些？请说明如何自定义一个 Starter。
java1234的博客
06-14 353
自定义一个 Starter 其实非常简单。以下步骤将引导你如何创建一个自定义的 Spring Boot Starter。在目录下创建一个文件，以便 Spring Boot 可以识别你的自动配置类。最后，在另一个 Spring Boot 项目中引入这个 Starter 依赖，并使用你定义的服务：</</</</然后，在 Spring Boot 应用中，你可以注入MyServiceimport com} } }} } }MyService;import org。
Spring Boot 3.x迁移指南：从2.x升级的完整流程和坑点总结
最新发布
yp0to1的博客
06-17 501
Spring Boot 3.x迁移工作量不小，但这是必须做的。新项目：直接用Spring Boot 3.2 + Java 21（一步到位）老项目：制定迁移计划，逐步迁移（先迁移不重要的服务）测试优先：迁移完后一定要做充分的测试（单元测试 + 集成测试 + 压测）工具辅助：用Spring Boot Migrator和OpenRewrite自动化迁移，减少手动改代码的工作量迁移虽然麻烦，但迁移后能用上虚拟线程、Native Image这些新特性，还是很值得的。参考资料。
JWT 认证全面解析：原理、流程与 Spring Boot 实战
BADAO_LIUMANG_QIZHI的博客
06-12 209
JWT 认证全面解析 本文系统介绍了 JWT（JSON Web Token）的工作原理和实现方式。主要内容包括： JWT 结构：由 Header（算法声明）、Payload（数据载体）和 Signature（签名验证）三部分组成，通过 Base64Url 编码连接 签名算法：对比了对称加密（HMAC）和非对称加密（RSA）的优缺点，推荐微服务架构使用 RS256 算法 认证流程：详细说明了从用户登录到业务接口调用的完整 JWT 验证时序 Spring Security 集成：介绍了 JWT 在 Spring
OpenTelemetry Java Agent 实战：零侵入接入 Spring Boot 调用链追踪并上报 OTLP Collector
xinzhiyishi的博客
06-16 279
很多 Spring Boot 项目已经接入了日志、接口耗时和基础 JVM 指标，但一到跨服务调用、下游接口变慢、偶发超时，就很难快速回答：这次请求经过了哪些服务？哪个环节最慢？TraceId 怎么串起来？本文用 OpenTelemetry Java Agent 演示一种“零侵入”接入方式：不改业务代码，通过-javaagent挂载 Agent，将 Spring Boot 应用的调用链数据通过 OTLP 上报到 OpenTelemetry Collector。
Spring Boot Actuator + Micrometer 实战：自定义业务指标并接入 Prometheus 观测接口耗时
xinzhiyishi的博客
06-14 237
Spring Boot Actuator 解决的是“指标如何暴露”，Micrometer 解决的是“Java 代码如何记录指标”，Prometheus 解决的是“如何抓取和查询指标”。只接只能说明服务大概率还活着，不能说明核心业务接口是不是正在变慢、失败是不是集中在某个阶段、队列是不是正在积压。落地业务指标时，最重要的不是多埋点，而是指标设计要克制：指标名稳定、tag 低基数、Counter / Timer / Gauge 用对场景、异常和耗时都能被 PromQL 查询。
Spring Boot Starter 中间件账号密码加密方案设计与实现
Crg的博客
06-13 293
本文介绍了一种轻量级的Spring Boot Starter中间件账号密码加密方案，采用AES-256-GCM加密算法实现敏感信息的安全存储。该方案具有以下特点： 支持密文格式"ENC:"+Base64(IV+密文)，使用12字节随机IV和128位认证标签 通过SHA-256哈希将任意长度密钥转为256位AES密钥 提供三种安全的密钥传递方式：环境变量、JVM参数和密钥文件 仅使用JDK自带加密库，无额外依赖 自动检测并警告不安全的密钥配置方式 实现上，通过AesTextEncryptor工具类完成加解密操
拥抱 Java 21 与 Spring Boot 4：Apache Grails 8 核心新特性与平稳升级指南
weixin_49715102的博客
06-15 410
确认 build.gradle 中的每个 Grails 插件均已升级至兼容 Grails 8 的版本。对于使用 grails-micronaut 的项目，务必确保 BOM（物料清单） 已通过 enforcedPlatform 引入（若未正确配置，Grails Gradle 插件将在构建配置阶段直接导致构建失败）。
【Spring Boot + Vue + DeepSeek】从零打造一个AI驱动的智能健康分析系统
qq_55236656的博客
06-15 259
体检报告数据专业性强，普通人难以解读健康数据分散，缺乏统一的智能分析手段医患沟通效率低，专家资源分配不均IoT健康设备数据无法与管理系统打通AuraHealth正是为了解决这些问题而设计——将 DeepSeek 大模型深度融入健康管理全流程，实现从数据采集 → AI分析 → 智能预警 → 医患协作 → 健康改进的完整闭环。
【Spring Boot + MyBatis|第7篇】JWT 登录认证与拦截器实现
2401_88139521的博客
06-13 629
前面我们已经学习了三层架构、参数接收、统一返回结果、动态 SQL、分页查询和全局异常处理。这些内容基本覆盖了普通 CRUD 接口的开发。用户没有登录，能不能访问后端接口？答案肯定是不可以。JWT + 拦截器。这一篇主要学习了 Spring Boot 项目中 JWT 登录认证和拦截器的实现。登录成功后，后端生成 JWT 返回给前端；前端后续请求携带 JWT；后端通过拦截器统一校验 token。这样就可以避免每个接口都手动判断用户是否登录。
基于Spring Boot的在线拍卖系统 附源码
风雨桥的博客
06-13 201
本文介绍了一个基于Spring Boot和Vue.js的在线拍卖系统，采用前后端分离架构，包含竞拍订单、历史竞拍、留言板等核心模块。系统使用Spring Boot作为后端框架，结合MyBatis-Plus、Shiro等技术，前端采用Vue.js+Element UI（后台）和Layui+Vue（前台）。项目亮点包括完整的业务闭环、权限控制、数据可视化、富文本编辑等，并附带SQL文件、文档和演示PPT。支持快速部署，适合作为学习项目或二次开发基础。
Spring Boot 国际化（i18n）完全指南
BADAO_LIUMANG_QIZHI的博客
06-16 229
本文介绍了Spring Boot中实现国际化(i18n)的完整指南。主要内容包括：i18n的核心概念，即将用户可见文本从代码抽离到资源文件；核心组件MessageSource、LocaleResolver和资源文件的职责；资源文件的命名规范和查找优先级；两种配置方式（YAML和Java Config）；以及一个完整的用户注册模块示例，展示中文和英文资源文件的定义、配置类实现和工具类封装。文章强调了UTF-8编码的重要性，并提供了缓存策略等实用技巧，帮助开发者在Spring Boot应用中高效实现多语言支持。
Spring Boot + Spring Security + RBAC：从登录鉴权到权限模型设计
RonieWhite的博客
06-15 246
Spring Boot 解决的是项目骨架问题MyBatis 解决的是 SQL 可控问题Redis 解决的是缓存和高频访问问题JWT 解决的是前后端分离下的登录态问题那么接下来一定会遇到的，就是权限控制问题。用户登录成功生成 JWT后续请求带 Token服务端能识别“这个人是谁”但很快你就会发现，这还远远不够。这个用户能访问哪些接口这个用户属于什么角色角色和菜单、按钮、数据范围如何关联接口权限和页面权限如何统一权限变更后如何生效。
Spring Boot集成电子签章的7个典型问题与解决方案：从入门到生产级实践
2601_96196338的博客
06-15 398
本文针对SpringBoot项目集成电子签章服务（以爱签电子合同为例）时常见的7个技术难题进行深度剖析：1）SDK依赖冲突问题及版本强制管理方案；2）HTTPS证书校验失败的两种解决路径；3）PDF签名无效的成因分析与证书链完整性保障；4）高并发场景下的异步队列与水平扩展架构；5）可信时间戳服务的司法合规实现；6）多环境证书管理的Profile隔离策略；7）司法存证的关键要素与区块链存证方案。文章强调电子签章集成需兼顾密码学安全、性能优化和法律合规，建议优先选择具备等保三级、国密认证的成熟平台，通过标准化A
Spring Boot 连接 MySQL 失败怎么办？常见报错原因和解决方法总结
2401_86617027的博客
06-14 602
如果不确定 yml 是否写对，可以临时改用 application.properties，因为 properties 对缩进不敏感，例如 spring.datasource.url、spring.datasource.username、spring.datasource.password 分别写在三行即可。对于初学者来说，可以先记住一个简单顺序：先检查 MySQL 服务，再检查 url、端口、库名，然后检查账号密码，接着看驱动依赖和 yml 缩进，最后再考虑远程权限和 URL 参数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值