用refresh token获取access token在springboot框架中的实例

最新推荐文章于 2025-05-20 09:04:48 发布
最新推荐文章于 2025-05-20 09:04:48 发布
阅读量4.2k 收藏 3
点赞数 2
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/magasea/article/details/96977383
本文提供了一个在SpringBoot应用中使用refresh token获取access token的实例。通过结合Spring Security的defaultTokenService和jdbc数据库存储tokens，配置client secret及访问控制，实现了token的管理。如果不需要缓存，可以不使用AmcJdbcTokenStore。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

用refresh token获取access token在springboot框架中的实例

springboot

上代码

package com.wensheng.zcc.sso.config;

import com.wensheng.zcc.sso.service.UserService;
import java.util.Arrays;
import java.util.Collection;
import javax.annotation.Resource;
import javax.sql.DataSource;
import javax.validation.Valid;
import lombok.extern.slf4j.Slf4j;
import org.hibernate.annotations.Cache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.core.support.SqlLobValue;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.ProviderManager;
import org.springframework.security.core.userdetails.UserDetailsByNameServiceWrapper;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.oauth2.common.OAuth2AccessToken;
import org.springframework.security.oauth2.common.OAuth2RefreshToken;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.ClientDetailsService;
import org.springframework.security.oauth2.provider.OAuth2Authentication;
import org.springframework.security.oauth2.provider.token.DefaultTokenServices;
import org.springframework.security.oauth2.provider.token.TokenEnhancer;
import org.springframework.security.oauth2.provider.token.TokenEnhancerChain;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JdbcTokenStore;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;
import org.springframework.security.web.authentication.preauth.PreAuthenticatedAuthenticationProvider;
import org.springframework.security.web.authentication.preauth.PreAuthenticatedAuthenticationToken;
import org.springframework.transaction.annotation.Transactional;

@Configuration
@EnableAuthorizationServer
@Slf4j
public class OAuth2AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    @Autowired
    @Qualifier("authenticationManagerBean")
    private AuthenticationManager authenticationManager;

//    private int accessTokenValidSeconds = 3600;
    private int accessTokenValidSeconds = 150;

    private int refreshTokenValidSeconds = 2592000;

    @Value("${spring.security.oauth2.client.registration.amc-admin.client-id}")
    private String amcAdminClientId;


    @Value("${spring.security.oauth2.client.registration.amc-admin.secret}")
    private String amcAdminSecret;


    @Value("${spring.security.oauth2.client.registration.amc-admin.scopes}")
    private String amcAdminScopes;

    @Value("${spring.security.oauth2.client.registration.amc-admin.authorizedGrantTypes}")
    private String amcAdminAuthorizedGrantTypes;

    @Value("${spring.security.oauth2.client.registration.amc-admin.redirectUris}")
    private String amcAdminRedirectUris;



    @Value("${spring.security.oauth2.client.registration.amc-client-thirdpart.client-id}")
    private String amcWechatClientId;

    @Value("${spring.security.oauth2.client.registration.amc-client-thirdpart.secret}")
    private String amcWechatSecret;


    @Value("${spring.security.oauth2.client.registration.amc-client-thirdpart.scopes}")
    private String amcWechatScopes;

    @Value("${spring.security.oauth2.client.registration.amc-client-thirdpart.authorizedGrantTypes}")
    private String amcWechatAuthorizedGrantTypes;

    @Value("${spring.security.oauth2.client.registration.amc-client-thirdpart.redirectUris}")
    private String amcWechatRedirectUris;

    @Autowired
    PasswordEncoder passwordEncoder;

    @Autowired
    DataSource dataSource;


    @Autowired
    UserService userService;

    @Override
    public void configure(final AuthorizationServerSecurityConfigurer oauthServer) throws Exception {
        oauthServer.tokenKeyAccess("permitAll()").checkTokenAccess("isAuthenticated()");
    }

    @Override
    public void configure(final ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory().withClient("sampleClientId").authorizedGrantTypes("implicit").scopes("read", "write", "foo", "bar").autoApprove(false).accessTokenValiditySeconds(3600).redirectUris("http://localhost:8083/","http://localhost:8086/")

                .and().withClient("testImplicitClientId").authorizedGrantTypes("implicit").scopes("read", "write", "foo", "bar").autoApprove(true).redirectUris("xxx")
//            .and().withClient(amcWechatClientId).authorizedGrantTypes(amcWechatAuthorizedGrantTypes.replace(" ","").split(",")).scopes(amcWechatScopes.replace(" ", "").split(",")).autoApprove(true).redirectUris(amcWechatRedirectUris.split(","))
                .and().withClient(amcAdminClientId).secret(passwordEncoder.encode(amcAdminSecret))
            .authorizedGrantTypes(amcAdminAuthorizedGrantTypes.replace(" ","").split(",")).scopes(amcAdminScopes.replace(" ","").split(
                ","))
            .autoApprove(false).redirectUris(amcAdminRedirectUris.split(","))
            .accessTokenValiditySeconds(accessTokenValidSeconds).refreshTokenValiditySeconds(refreshTokenValidSeconds)
        ;

    }

    @Bean
    @Primary
    public DefaultTokenServices tokenServices() {
        final DefaultTokenServices defaultTokenServices = new DefaultTokenServices();
        defaultTokenServices.setTokenStore(tokenStore());
        defaultTokenServices.setSupportRefreshToken(true);
        defaultTokenServices.setReuseRefreshToken(false);
        addUserDetailsService(defaultTokenServices, userService);
        final TokenEnhancerChain tokenEnhancerChain = new TokenEnhancerChain();
        tokenEnhancerChain.setTokenEnhancers(Arrays.asList(tokenEnhancer(), accessTokenConverter()));
        defaultTokenServices.setAccessTokenValiditySeconds(accessTokenValidSeconds);
        defaultTokenServices.setRefreshTokenValiditySeconds(refreshTokenValidSeconds);
        defaultTokenServices.setTokenEnhancer(tokenEnhancerChain);
        return defaultTokenServices;
    }

    private void addUserDetailsService(DefaultTokenServices tokenServices, UserService userService) {
        if (userService != null) {
            PreAuthenticatedAuthenticationProvider provider = new PreAuthenticatedAuthenticationProvider();
            provider.setPreAuthenticatedUserDetailsService(new UserDetailsByNameServiceWrapper<PreAuthenticatedAuthenticationToken>(
                userService));
            tokenServices
                .setAuthenticationManager(new ProviderManager(Arrays.<AuthenticationProvider> asList(provider)));
        }
    }



    @Override
    public void configure(final AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        final TokenEnhancerChain tokenEnhancerChain = new TokenEnhancerChain();
        tokenEnhancerChain.setTokenEnhancers(Arrays.asList(tokenEnhancer(), accessTokenConverter()));
        endpoints.tokenServices(tokenServices()).tokenEnhancer(tokenEnhancerChain).authenticationManager(authenticationManager);
//        endpoints.pathMapping("oauth/token", "oauth/token");

    }

    @Bean
    public TokenStore tokenStore() {
        JdbcTokenStore jdbcTokenStore =  new AmcJdbcTokenStore(dataSource);
        return jdbcTokenStore;
//        return new JwtTokenStore(accessTokenConverter());
    }

    @Bean
    public JwtAccessTokenConverter accessTokenConverter() {
        final JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        converter.setSigningKey("YOUR—KEY—PASSWORD");
        // final KeyStoreKeyFactory keyStoreKeyFactory = new KeyStoreKeyFactory(new ClassPathResource("mytest.jks"), "mypass".toCharArray());
        // converter.setKeyPair(keyStoreKeyFactory.getKeyPair("mytest"));
        return converter;
    }

    @Bean
    public TokenEnhancer tokenEnhancer() {
        return new CustomTokenEnhancer();
    }

    @Bean
    public TokenEnhancer wechatTokenEnhancer(){ return new WechatTokenEnhancer(); }

    @CacheConfig(cacheNames = {"TOKEN"})
    class AmcJdbcTokenStore extends JdbcTokenStore{

        public AmcJdbcTokenStore(DataSource dataSource) {
            super(dataSource);
        }

        @Override
        @Cacheable
        public Collection<OAuth2AccessToken> findTokensByClientId(String clientId){
            log.info("query caches with clientId:{}", clientId);
            return super.findTokensByClientId(clientId);
        }

        @Transactional
        @CacheEvict
        public void removeAccessTokenUsingRefreshToken(OAuth2RefreshToken refreshToken) {
            super.removeAccessTokenUsingRefreshToken(refreshToken);
        }

        @Transactional
        @CacheEvict
        public void removeAccessTokenUsingRefreshToken(String refreshToken) {
            super.removeAccessTokenUsingRefreshToken(refreshToken);
        }
        @Transactional
        @CacheEvict
        public void removeAccessToken(OAuth2AccessToken token) {
            super.removeAccessToken(token);
        }
        @Transactional
        @CacheEvict
        public void removeAccessToken(String tokenValue) {
            super.removeAccessToken(tokenValue);
        }
        @Transactional
        @CacheEvict
        public void storeAccessToken(OAuth2AccessToken token, OAuth2Authentication authentication) {
            super.storeAccessToken(token, authentication);
        }

    }


}

这里面利用spring security框架里面defaultTokenService结合jdbc数据库作为token的datasource，自己定义一些client secret和访问控制。 AmcJdbcTokenStore只是想用缓存试试， 没有缓存必要的话可以不需要重载jdbcTokenStore

这里插入图片描述
就这样完成refreshtoken来获取accessToken

magasea
关注
5步实现Spring Boot中的双Token（access_token + refresh_token）授权与续期
java专栏
11-03 3623
通过今天的介绍，相信你已经掌握了如何在Spring Boot项目中实现基于JWT的双Token（access_token + refresh_token）授权与续期功能。Redis的使用使得Token管理更加灵活和高效，希望这篇文章能够帮助你在未来的开发中更加得心应手。如果你有任何问题或建议，欢迎在评论区留言，让我们一起交流，共同进步！
【SpringBoot】JWT+Token之Token自动续期
低调做人，低调编码，神码都是浮云
05-31 1680
Springboot+jwt+token实现双token认证
SpringBoot 中基于 JWT 的双 Token（access_token + refresh_token）授权和续期方案
小蜗牛的珍贵百宝箱
09-30 2457
通过本文的详细介绍，您已经掌握了如何在 SpringBoot 中实现基于 JWT 的双 Token（access_token + refresh_token）授权和续期方案。这种方案不仅提高了安全性，还增强了用户体验，使用户能够在 token 过期后无缝续期。我们使用了 JWT 工具类来生成和解析 token，确保了安全性。提供了用户认证和 token 刷新接口，使得用户能够便捷地获取和更新 token。
SpringBoot OAuth2.0 refresh_token（刷新令牌）
狮子大大
03-26 6437
SpringBoot OAuth2.0 刷新令牌 通常在 access_token 时间过期后，需要去获取新的 token 才能继续访问接口 在 使用 SpringSecurity + OAuth2.0， 可以采用 refresh_token 模式重新申请 access_token 修改 MooseAuthorizationServerConfiguration 文件 /** * Authorization Server endpoints. * * @throws Exception
SpringBoot 如何做到无感刷新 token？
最新发布
lxw1844912514的博客
05-20 111
不要在失败的时候发送，而是提前检查存在本地的token有没有过期，当检查token过期时间小于一个临界点，则异步调用刷新token方法，更新现有的token信息，此时是不是就解决上面的问题，只要是服务器端gateway拦截到token失效的请求我都要求重新登录。半天这token解析不了就很奇怪了，后面在网上查阅资料的过程中总结出来，由于后端生成的token是通过jjwt这个依赖实现的，对于不同的库底层的编码实现逻辑会有差异导致a库加密生成的token并不能完全被b库的方法来解密。
nuxt 刷新之后接口报错_SpringBoot OAuth2.0 refresh_token（刷新令牌）
weixin_39541044的博客
12-22 360
上一篇：江景：SpringBoot OAuth2.0 使用短信验证码登录授权​zhuanlan.zhihu.com通常在 access_token 时间过期后，需要去获取新的 token 才能继续访问接口江景：SpringBoot OAuth2.0 使用短信验证码登录授权通常在 access_token 时间过期后，需要去获取新的 token 才能继续访问接口在 使用 SpringSecurity...
SpringBoot中基于JWT的双Token（access_token+refresh_token）授权和续期方案详解
2301_79727522的博客
11-08 1781
基于JWT的双Token（access_token+refresh_token）授权和续期方案是一种有效的用户认证机制，它结合了JWT的简洁性和安全性，以及双Token策略的用户体验优势。通过合理配置JWT属性和实现相应的代码逻辑，你可以在Spring Boot应用程序中实现这一方案，从而提升应用程序的安全性和用户体验。
SpringBoot+SpringSecurity+SpringCloudOauth2密码模式使用+RefreshToken（四）
鹏举的博客
06-09 1974
Oauth2中的RefreshToken介绍 refresh token是用于获取access token的凭据。refreshtoken由授权服务器颁发给client，用于在当前访问令牌变为无效或过期时获取新的访问令牌，或者获取具有相同或更窄范围的其他访问令牌（访问令牌可能具有更短的生命周期和权限少于资源所有者授权的权限。根据授权服务器的判断，发出刷新令牌是可选的。如果授权服务器发出刷新令牌，则在发出访问令牌时包括它 刷新令牌是表示资源所有者授予客户端的权限的字符串。该字符串通常对客户端不透明。令牌表
使用java代码获取新浪微博应用的access token代码实例
08-26
在本文中，我们将深入探讨如何使用Java代码获取新浪微博应用的Access Token。Access Token是OAuth授权框架下用于访问受保护资源的密钥，它允许应用程序代表用户执行特定操作，如发布微博、读取用户信息等。在Java中...
SpringBoot项目实战（009）Spring Security（三）JWT+Redis+RefreshToken
IT老吴的博客
07-17 3859
本章打算： 使用redis作为缓存。 使用refreshtoken刷新accesstoken 缓存角色信息到redis
oauth2 java 获取token_基于SpringBoot整合oauth2实现token认证
weixin_42363231的博客
02-13 1596
这篇文章主要介绍了基于SpringBoot整合oauth2实现token 认证,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下session和token的区别：session是空间换时间，而token是时间换空间。session占用空间，但是可以管理过期时间，token管理部了过期时间，但是不占用空间.sessionId失效问题和token内包含。...
springSecurity-jwt:JWT access_token和refresh_token
04-10
SpringSecurity-JWT-VERSION2（AccessToken和RefreshToken） version1太复杂，无法优化。 accessToken refreshToken流 安全登录处理流程 详细说明转到博客文章 JWT异常处理 安全异常处理（AuthenticationEntryPoint，AccessDeniedHandler） 仅使用AccessToken时 如果将AccessToken的有效时间设置得较长，则很方便，因为用户不需要频繁登录，但是只要有效时间长，恶意用户就可以窃取AccessToken，从而降低了安全性。 相反，如果将AccessToken的有效时间设置为较短时间，则安全性将提高，但由于用户频繁登录，其便利性将降低。 您可能会认为使JWT无效将不起作用，但是JWT只能在设置的到期时间过去之后才到期。 我不能强迫它在那之前过期。 同时使用
基于springboot+jwt实现刷新token过程解析
08-19
主要介绍了基于springboot+jwt实现刷新token过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
springboot整和jwt、shiro、redis实现token自动刷新
08-19
springboot整和jwt、shiro、redis实现token自动刷新
Java实战：Spring Boot实现无感刷新Token机制
oandy0的博客
03-03 5232
本文将深入探讨如何在Spring Boot项目中实现无感刷新Token机制，并通过具体的示例代码，逐步引导读者掌握这一核心技术。
token过期机制的问题
qq_46940224的博客
10-15 6754
浅谈一下token过期机制的问题
SpringBootSecurity学习（20）前后端分离版之OAuth2.0刷新token
Blues的专栏
10-11 2563
刷新token 前面的例子和配置都是从头开始申请授权码和令牌，现在来看一下如何根据获取令牌时，回参中的 refresh_token 来刷新令牌。现在在项目中配置的是内存模式的默认用户名密码，第一步先改成数据库查询的方式，具体过程参考前面的文章即可，来看security配置类： 然后修改授权服务配置类，在 endpoints 中配置userDetailsService： 修改成数据库方式也是为了...
SpringBoot结合JWT+Shiro+Redis实现token无状态登录授权验证以及token刷新
weixin_51542566的博客
04-13 1659
1. 本身AccessToken的过期时间为5分钟，RefreshToken过期时间为30分钟，当登录后时间过了5分钟之后，当前AccessToken便会过期失效，再次带上AccessToken访问JWT会抛出TokenExpiredException异常说明Token过期，开始判断是否要进行AccessToken刷新，首先redis查询RefreshToken是否存在，以及时间戳和过期AccessToken所携带的时间戳是否一致，如果存在且一致就进行AccessToken刷新。
SpringBoot中基于JWT的双token（access_token+refresh_token）授权和续期方案
热门推荐
码到三十五
09-22 13万+
鉴于JWT包含用户信息且需保障安全，其过期时间通常设置较短。然而，这易导致用户频繁登录，尤其是在处理复杂表单时(比如在线考试)，因耗时过长而遇token过期，引发不必要的登录中断和数据丢失，严重影响用户体验。如何在用户无感知状态下实现token自动续期的策略，减少频繁登录需求，确保表单数据不丢失呢? 解决token过期续期问题可以有很多种不同的方案，这里举一些比较有代表性的例子，一种是单token续期，一种是双token续期。
在JWT中，access和refresh token都是怎样生成和管理的呢，请给出实例
02-24
<think>嗯，用户问的是JWT中access和refresh token的生成和管理，需要给出实例。首先，我得回忆一下JWT的基本结构，access token和refresh token的作用区别。access token通常用于认证，有较短的有效期，而refresh token用来获取新的access token，有效期较长。 接下来，生成这两个token的方法，应该都需要使用密钥，可能access用更短的过期时间，比如15分钟，refresh用几天或者更久。然后，管理方面需要考虑如何存储，比如access token存在客户端内存，refresh token可能存在数据库或者HTTP-only的cookie里，防止XSS攻击。 然后，用户可能需要具体的例子，比如用Node.js和Express，jsonwebtoken库来生成，用Redis或者数据库来管理refresh token。要注意安全性的问题，比如密钥的保护，token的撤销机制，可能还需要处理黑名单的情况。 另外，用户可能没有明说但需要考虑的是如何在实际应用中处理token的刷新流程，比如提供一个/auth/refresh的端点，接收refresh token来颁发新的access token。同时，需要处理refresh token的过期和存储，确保每次使用后可以更新或者删除旧的token，防止重复使用。 还要注意在响应中返回新的access token，并让客户端处理替换旧的。可能还要提到如何验证token的签名，确保不被篡改。可能需要代码示例来展示生成、签名、验证的整个过程，以及如何用中间件来保护路由。 最后，应该提醒用户安全最佳实践，比如HTTPS、密钥管理、refresh token的存储方式，避免常见的安全漏洞。可能还需要提到关于token泄露后的应对措施，比如及时撤销refresh token。</think>在JWT（JSON Web Token）中，**Access Token** 和 **Refresh Token** 是两种常见的令牌机制，以下是它们的生成、管理及实际应用示例： --- ### **1. 核心区别** - **Access Token** 用于访问受保护资源，有效期短（如 15 分钟），需频繁更换。 - **Refresh Token** 用于获取新的 Access Token，有效期长（如 7 天），存储更安全。 --- ### **2. 生成示例（Node.js + `jsonwebtoken`）** ```javascript const jwt = require('jsonwebtoken'); const SECRET_KEY = 'your-secret-key'; // 实际应使用环境变量存储 // 生成 Access Token（15分钟过期） const accessToken = jwt.sign( { userId: '123', role: 'user' }, SECRET_KEY, { expiresIn: '15m' } ); // 生成 Refresh Token（7天过期，单独密钥更安全） const refreshToken = jwt.sign( { userId: '123' }, SECRET_KEY + 'refresh', // 使用不同密钥 { expiresIn: '7d' } ); ``` --- ### **3. 管理流程** #### **(1) 颁发令牌（登录接口）** ```javascript app.post('/login', (req, res) => { // 验证用户身份后... res.json({ accessToken, refreshToken }); }); ``` #### **(2) 使用 Access Token 访问资源** ```javascript // 中间件验证 Access Token const authenticate = (req, res, next) => { const token = req.headers.authorization?.split(' ')[1]; jwt.verify(token, SECRET_KEY, (err, decoded) => { if (err) return res.sendStatus(403); // Forbidden req.user = decoded; next(); }); }; app.get('/protected', authenticate, (req, res) => { res.send('Access granted'); }); ``` #### **(3) 使用 Refresh Token 更新 Access Token** ```javascript app.post('/refresh', (req, res) => { const { refreshToken } = req.body; // 验证 Refresh Token 有效性（可结合数据库或Redis校验是否被撤销） jwt.verify(refreshToken, SECRET_KEY + 'refresh', (err, decoded) => { if (err) return res.sendStatus(403); // 生成新 Access Token const newAccessToken = jwt.sign( { userId: decoded.userId }, SECRET_KEY, { expiresIn: '15m' } ); res.json({ accessToken: newAccessToken }); }); }); ``` --- ### **4. 安全最佳实践** 1. **存储方式** - Access Token：客户端内存（如 Vue/React 状态），**避免 localStorage**（防XSS）。 - Refresh Token：通过 HTTP-only Cookie 或安全存储服务（如移动端 Keychain）。 2. **黑名单机制** 使用 Redis 或数据库记录已注销但未过期的 Token，验证时检查是否在黑名单中。 3. **密钥管理** - 使用强随机密钥（如 `crypto.randomBytes(64).toString('hex')`）。 - 通过环境变量或密钥管理服务（如 AWS KMS）存储密钥。 4. **Token 撤销** 提供 `/logout` 接口，将 Refresh Token 标记为失效： ```javascript // 伪代码：将 Refresh Token 存入Redis黑名单 redisClient.set(refreshToken, 'revoked', 'EX', 7 * 86400); // 设置7天过期 ``` --- ### **5. 流程图解** ``` 用户登录 → 颁发 Access + Refresh Token │ ├─ Access Token 过期 → 使用 Refresh Token 获取新 Access Token │ └─ Refresh Token 过期 → 重新登录 ``` 通过合理设计 Token 生命周期和安全策略，可以在保证用户体验的同时提升系统安全性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值