微信登录功能的实现

已于 2023-04-24 18:17:17 修改
阅读量416 收藏 2
点赞数
分类专栏： java 文章标签： 微信 spring java
于 2022-08-29 00:12:50 首次发布
xtm
本文链接：https://blog.csdn.net/weixin_62108279/article/details/126571009
版权

1.配置文件的配置

id appid
wx.open.app_id=wxed9954c01bb89b47
# 微信密钥¨ appsecret
wx.open.app_secret=a7482517235173ddb4083788de60b90e
# 重定向 url
wx.open.redirect_url=http://guli.shop/api/ucenter/wx/callback

2.创建工具类

import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class ConstantWxUtils implements InitializingBean {
//微信id
    @Value("${wx.open.app_id}")
    private String appId;
//微信密钥
    @Value("${wx.open.app_secret}")
    private String appSecret;
//微信url
    @Value("${wx.open.redirect_url}")
    private String redirectUrl;

    public static String WX_OPEN_APP_ID;
    public static String WX_OPEN_APP_SECRET;
    public static String WX_OPEN_REDIRECT_URL;

    @Override
    public void afterPropertiesSet() throws Exception {
        WX_OPEN_APP_ID = appId;
        WX_OPEN_APP_SECRET = appSecret;
        WX_OPEN_REDIRECT_URL = redirectUrl;
    }
}

3.二维码的生成

import com.atguigu.commonutils.JwtUtils;
import com.atguigu.educenter.entity.UcenterMember;
import com.atguigu.educenter.service.UcenterMemberService;
import com.atguigu.educenter.utils.ConstantWxUtils;
import com.atguigu.educenter.utils.HttpClientUtils;
import com.atguigu.servicebase.exceptionhandler.GuliException;
import com.google.gson.Gson;
import org.bouncycastle.util.encoders.Base64Encoder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import sun.misc.BASE64Encoder;

import java.net.URLEncoder;
import java.util.HashMap;

@CrossOrigin
@Controller  //只是请求地址，不需要返回数据
@RequestMapping("/api/ucenter/wx")
public class WxApiController {
 
//1 生成微信扫描二维码
    @GetMapping("login")
    public String getWxCode() {
        //固定地址，后面拼接参数
//        String url = "https://open.weixin.qq.com/" +
//                "connect/qrconnect?appid="+ //ConstantWxUtils.WX_OPEN_APP_ID+"&response_type=code";

        // 微信开放平台授权baseUrl  %s相当于?代表占位符
        String baseUrl = "https://open.weixin.qq.com/connect/qrconnect" +
                "?appid=%s" +
                "&redirect_uri=%s" +
                "&response_type=code" +
                "&scope=snsapi_login" +
                "&state=%s" +
                "#wechat_redirect";

        //对redirect_url进行URLEncoder编码
        String redirectUrl = ConstantWxUtils.WX_OPEN_REDIRECT_URL;
        try {
            redirectUrl = URLEncoder.encode(redirectUrl, "utf-8");
        }catch(Exception e) {
        }

        //设置%s里面值
        String url = String.format(
                    baseUrl,//对应上面的方法
                    ConstantWxUtils.WX_OPEN_APP_ID,//对应第一个%s，
                    redirectUrl,//第二个
                    "atguigu"//第三个
                 );

        //重定向到请求微信地址里面
        return "redirect:"+url;
    }
}

4.获取给扫描人信息，进行数据的添加（和二维码的生产为同一个类）

1）引入依赖

<dependencies>

    <!--httpclient-->
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
    </dependency>
    <!--commons-io-->
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
    </dependency>
    <!--gson-->
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
    </dependency>
</dependencies>

2）添加工具类

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.config.RequestConfig.Builder;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContextBuilder;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.conn.ssl.X509HostnameVerifier;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocket;
import java.io.IOException;
import java.net.SocketTimeoutException;
import java.security.GeneralSecurityException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 *  依赖的jar包有：commons-lang-2.6.jar、httpclient-4.3.2.jar、httpcore-4.3.1.jar、commons-io-2.4.jar
 * @author zhaoyb
 *
 */
public class HttpClientUtils {

   public static final int connTimeout=10000;
   public static final int readTimeout=10000;
   public static final String charset="UTF-8";
   private static HttpClient client = null;

   static {
      PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
      cm.setMaxTotal(128);
      cm.setDefaultMaxPerRoute(128);
      client = HttpClients.custom().setConnectionManager(cm).build();
   }

   public static String postParameters(String url, String parameterStr) throws ConnectTimeoutException, SocketTimeoutException, Exception{
      return post(url,parameterStr,"application/x-www-form-urlencoded",charset,connTimeout,readTimeout);
   }

   public static String postParameters(String url, String parameterStr,String charset, Integer connTimeout, Integer readTimeout) throws ConnectTimeoutException, SocketTimeoutException, Exception{
      return post(url,parameterStr,"application/x-www-form-urlencoded",charset,connTimeout,readTimeout);
   }

   public static String postParameters(String url, Map<String, String> params) throws ConnectTimeoutException,
         SocketTimeoutException, Exception {
      return postForm(url, params, null, connTimeout, readTimeout);
   }

   public static String postParameters(String url, Map<String, String> params, Integer connTimeout,Integer readTimeout) throws ConnectTimeoutException,
         SocketTimeoutException, Exception {
      return postForm(url, params, null, connTimeout, readTimeout);
   }

   public static String get(String url) throws Exception {
      return get(url, charset, null, null);
   }

   public static String get(String url, String charset) throws Exception {
      return get(url, charset, connTimeout, readTimeout);
   }

   /**
    * 发送一个 Post 请求, 使用指定的字符集编码.
    *
    * @param url
    * @param body RequestBody
    * @param mimeType 例如 application/xml "application/x-www-form-urlencoded" a=1&b=2&c=3
    * @param charset 编码
    * @param connTimeout 建立链接超时时间,毫秒.
    * @param readTimeout 响应超时时间,毫秒.
    * @return ResponseBody, 使用指定的字符集编码.
    * @throws ConnectTimeoutException 建立链接超时异常
    * @throws SocketTimeoutException  响应超时
    * @throws Exception
    */
   public static String post(String url, String body, String mimeType,String charset, Integer connTimeout, Integer readTimeout)
         throws ConnectTimeoutException, SocketTimeoutException, Exception {
      HttpClient client = null;
      HttpPost post = new HttpPost(url);
      String result = "";
      try {
         if (StringUtils.isNotBlank(body)) {
            HttpEntity entity = new StringEntity(body, ContentType.create(mimeType, charset));
            post.setEntity(entity);
         }
         // 设置参数
         Builder customReqConf = RequestConfig.custom();
         if (connTimeout != null) {
            customReqConf.setConnectTimeout(connTimeout);
         }
         if (readTimeout != null) {
            customReqConf.setSocketTimeout(readTimeout);
         }
         post.setConfig(customReqConf.build());

         HttpResponse res;
         if (url.startsWith("https")) {
            // 执行 Https 请求.
            client = createSSLInsecureClient();
            res = client.execute(post);
         } else {
            // 执行 Http 请求.
            client = HttpClientUtils.client;
            res = client.execute(post);
         }
         result = IOUtils.toString(res.getEntity().getContent(), charset);
      } finally {
         post.releaseConnection();
         if (url.startsWith("https") && client != null&& client instanceof CloseableHttpClient) {
            ((CloseableHttpClient) client).close();
         }
      }
      return result;
   }


   /**
    * 提交form表单
    *
    * @param url
    * @param params
    * @param connTimeout
    * @param readTimeout
    * @return
    * @throws ConnectTimeoutException
    * @throws SocketTimeoutException
    * @throws Exception
    */
   public static String postForm(String url, Map<String, String> params, Map<String, String> headers, Integer connTimeout,Integer readTimeout) throws ConnectTimeoutException,
         SocketTimeoutException, Exception {

      HttpClient client = null;
      HttpPost post = new HttpPost(url);
      try {
         if (params != null && !params.isEmpty()) {
            List<NameValuePair> formParams = new ArrayList<NameValuePair>();
            Set<Entry<String, String>> entrySet = params.entrySet();
            for (Entry<String, String> entry : entrySet) {
               formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
            }
            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(formParams, Consts.UTF_8);
            post.setEntity(entity);
         }

         if (headers != null && !headers.isEmpty()) {
            for (Entry<String, String> entry : headers.entrySet()) {
               post.addHeader(entry.getKey(), entry.getValue());
            }
         }
         // 设置参数
         Builder customReqConf = RequestConfig.custom();
         if (connTimeout != null) {
            customReqConf.setConnectTimeout(connTimeout);
         }
         if (readTimeout != null) {
            customReqConf.setSocketTimeout(readTimeout);
         }
         post.setConfig(customReqConf.build());
         HttpResponse res = null;
         if (url.startsWith("https")) {
            // 执行 Https 请求.
            client = createSSLInsecureClient();
            res = client.execute(post);
         } else {
            // 执行 Http 请求.
            client = HttpClientUtils.client;
            res = client.execute(post);
         }
         return IOUtils.toString(res.getEntity().getContent(), "UTF-8");
      } finally {
         post.releaseConnection();
         if (url.startsWith("https") && client != null
               && client instanceof CloseableHttpClient) {
            ((CloseableHttpClient) client).close();
         }
      }
   }




   /**
    * 发送一个 GET 请求
    *
    * @param url
    * @param charset
    * @param connTimeout  建立链接超时时间,毫秒.
    * @param readTimeout  响应超时时间,毫秒.
    * @return
    * @throws ConnectTimeoutException   建立链接超时
    * @throws SocketTimeoutException   响应超时
    * @throws Exception
    */
   public static String get(String url, String charset, Integer connTimeout,Integer readTimeout)
         throws ConnectTimeoutException,SocketTimeoutException, Exception {

      HttpClient client = null;
      HttpGet get = new HttpGet(url);
      String result = "";
      try {
         // 设置参数
         Builder customReqConf = RequestConfig.custom();
         if (connTimeout != null) {
            customReqConf.setConnectTimeout(connTimeout);
         }
         if (readTimeout != null) {
            customReqConf.setSocketTimeout(readTimeout);
         }
         get.setConfig(customReqConf.build());

         HttpResponse res = null;

         if (url.startsWith("https")) {
            // 执行 Https 请求.
            client = createSSLInsecureClient();
            res = client.execute(get);
         } else {
            // 执行 Http 请求.
            client = HttpClientUtils.client;
            res = client.execute(get);
         }

         result = IOUtils.toString(res.getEntity().getContent(), charset);
      } finally {
         get.releaseConnection();
         if (url.startsWith("https") && client != null && client instanceof CloseableHttpClient) {
            ((CloseableHttpClient) client).close();
         }
      }
      return result;
   }


   /**
    * 从 response 里获取 charset
    *
    * @param ressponse
    * @return
    */
   @SuppressWarnings("unused")
   private static String getCharsetFromResponse(HttpResponse ressponse) {
      // Content-Type:text/html; charset=GBK
      if (ressponse.getEntity() != null  && ressponse.getEntity().getContentType() != null && ressponse.getEntity().getContentType().getValue() != null) {
         String contentType = ressponse.getEntity().getContentType().getValue();
         if (contentType.contains("charset=")) {
            return contentType.substring(contentType.indexOf("charset=") + 8);
         }
      }
      return null;
   }



   /**
    * 创建 SSL连接
    * @return
    * @throws GeneralSecurityException
    */
   private static CloseableHttpClient createSSLInsecureClient() throws GeneralSecurityException {
      try {
         SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
            public boolean isTrusted(X509Certificate[] chain,String authType) throws CertificateException {
               return true;
            }
         }).build();

         SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext, new X509HostnameVerifier() {

            @Override
            public boolean verify(String arg0, SSLSession arg1) {
               return true;
            }

            @Override
            public void verify(String host, SSLSocket ssl)
                  throws IOException {
            }

            @Override
            public void verify(String host, X509Certificate cert)
                  throws SSLException {
            }

            @Override
            public void verify(String host, String[] cns,
                           String[] subjectAlts) throws SSLException {
            }

         });

         return HttpClients.custom().setSSLSocketFactory(sslsf).build();

      } catch (GeneralSecurityException e) {
         throw e;
      }
   }

   public static void main(String[] args) {
      try {
         String str= post("https://localhost:443/ssl/test.shtml","name=12&page=34","application/x-www-form-urlencoded", "UTF-8", 10000, 10000);
         //String str= get("https://localhost:443/ssl/test.shtml?name=12&page=34","GBK");
            /*Map<String,String> map = new HashMap<String,String>();
            map.put("name", "111");
            map.put("page", "222");
            String str= postForm("https://localhost:443/ssl/test.shtml",map,null, 10000, 10000);*/
         System.out.println(str);
      } catch (ConnectTimeoutException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      } catch (SocketTimeoutException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      } catch (Exception e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }
   }

}

3）代码的实现 

//2 获取扫描人信息，添加数据
@GetMapping("callback")
public String callback(String code, String state) {
    try {
        //1 获取code值，临时票据，类似于验证码
        //2 拿着code请求 微信固定的地址，得到两个值 accsess_token 和 openid
        String baseAccessTokenUrl = "https://api.weixin.qq.com/sns/oauth2/access_token" +
                "?appid=%s" +
                "&secret=%s" +
                "&code=%s" +
                "&grant_type=authorization_code";
        //拼接三个参数 ：id  秘钥 和 code值
        String accessTokenUrl = String.format(
                baseAccessTokenUrl,
                ConstantWxUtils.WX_OPEN_APP_ID,
                ConstantWxUtils.WX_OPEN_APP_SECRET,
                code
        );
        //请求这个拼接好的地址，得到返回两个值 accsess_token 和 openid
        //使用httpclient发送请求，得到返回结果
        String accessTokenInfo = HttpClientUtils.get(accessTokenUrl);

        //从accessTokenInfo字符串获取出来两个值 accsess_token 和 openid
        //把accessTokenInfo字符串转换map集合，根据map里面key获取对应值
        //使用json转换工具 Gson
        Gson gson = new Gson();
        HashMap mapAccessToken = gson.fromJson(accessTokenInfo, HashMap.class);
        String access_token = (String)mapAccessToken.get("access_token");
        String openid = (String)mapAccessToken.get("openid");

        //把扫描人信息添加数据库里面
        //判断数据表里面是否存在相同微信信息，根据openid判断
        UcenterMember member = memberService.getOpenIdMember(openid);
        if(member == null) {//memeber是空，表没有相同微信数据，进行添加

            //3 拿着得到accsess_token 和 openid，再去请求微信提供固定的地址，获取到扫描人息
            //访问微信的资源服务器，获取用户信息
            String baseUserInfoUrl = "https://api.weixin.qq.com/sns/userinfo" +
                    "?access_token=%s" +
                    "&openid=%s";
            //拼接两个参数
            String userInfoUrl = String.format(
                    baseUserInfoUrl,
                    access_token,
                    openid
            );
            //发送请求
            String userInfo = HttpClientUtils.get(userInfoUrl);
            //获取返回userinfo字符串扫描人信息
            HashMap userInfoMap = gson.fromJson(userInfo, HashMap.class);
            String nickname = (String)userInfoMap.get("nickname");//昵称
            String headimgurl = (String)userInfoMap.get("headimgurl");//头像

            member = new UcenterMember();
            member.setOpenid(openid);
            member.setNickname(nickname);
            member.setAvatar(headimgurl);
            memberService.save(member);
        }


        //使用jwt根据member对象生成token字符串
        String jwtToken = JwtUtils.getJwtToken(member.getId(), member.getNickname());
        //最后：返回首页面，通过路径传递token字符串
        return "redirect:http://localhost:3000?token="+jwtToken;
    }catch(Exception e) {
        throw new GuliException(20001,"登录失败");
    }
}

}

如何为微信小程序添加微信登录和微信授权功能
wx_linying1029的博客
07-12 1053
至此，微信登录功能的实现就完成了。用户点击登录按钮后，小程序会调用微信的登录接口获取用户的code，并将该code发送给服务器进行登录验证。同时，用户点击获取用户信息按钮后，小程序会调用微信的获取用户信息接口获取用户信息。微信登录和微信授权是小程序中常用的功能，可以方便用户登录小程序并获取用户信息。在微信登录和微信授权功能实现的代码案例中，我们已经获取到了用户的基本信息，包括用户的头像、昵称等。用户点击获取用户授权信息按钮后，小程序会调用微信的获取用户授权信息接口获取用户的授权状态。
Vue.js 应用集成微信登录功能实战
qq_46292480的博客
10-29 1150
随着社交媒体的普及，越来越多的应用选择集成社交登录功能来简化用户的注册和登录流程。当用户同意授权后，微信会将用户重定向回你的应用，并附带一个授权码（code）。通过上述步骤，你已经能够在Vue.js应用中集成微信登录功能。在微信开放平台的应用设置中，配置一个合法的回调URL，该URL将在用户授权后被调用。在前端Vue.js应用中，我们需要添加一个微信登录按钮，并在点击时触发微信授权流程。这里假设你有一个Node.js的后端API，用来处理微信登录逻辑。在后端API中处理微信登录逻辑。中添加微信登录按钮。
微信登录功能实现（可用）
qq_41060547的博客
12-20 1533
本次实现微信登录功能，主要根据微信官方文档，流程如下 1微信登录接口实现思路，根据申请的， wx.open.app_id， wx.open.app_secret， wx.open.redirect_url， baseUrl，进行封装，具体如下可参考使用 //生成微信扫描的二维码，在前段显示,弹出框方式 @GetMapping("get") @ResponseBody public Result wxLogin(HttpSession session) throws UnsupportedEncod
微信登录的方式
richpersion的博客
05-27 397
登录和注册的controller层 @ApiOperation(value = "登录") @PostMapping("/login") public Msg login(@RequestBody UcenterMember member){ String token =ucenterMemberService.login(member); return Msg.success().data("token",token); } @ApiOpe
【Java】—— 后端实现微信小程序登录
最新发布
张修宇的博客
02-23 432
调用wx.login()获取临时code将code发送到向微信接口请求和openid创建自定义登录态（如Token）并返回给小程序后续请求携带Token进行身份验证。
Spring Boot携手OAuth2.0，轻松实现微信扫码登录！
Yaml4的博客
04-26 3815
✌️大厂全栈码农|毕设实战开发，专注于大学生项目实战开发、讲解和毕业答疑辅导。推荐订阅精彩专栏 👇🏻 避免错过下次更新。
如何使用微信小程序。
weixin_46597615的博客
06-28 230
【代码】如何使用微信小程序。
Springboot+oauth2.0实现微信登录（oauth2.0自定义授权模式）
hgswsdn的博客
02-20 5792
1、前置准备参考 https://blog.csdn.net/qq_34190023/article/details/81133619 2、微信登录实现流程图 3、oauth自定义授权模式 上图大概描述了微信登录的一个流程。如果你是用oauth2.0，就会存在一个问题。oauth2.0自身支持四种授权模式，分别是： authorization code（授权码模式） implicit（简化模式） resource owner password credentials（密码模式） client crede
PHP实现网站应用微信登录功能详解
10-17
主要介绍了PHP实现网站应用微信登录功能,结合实例形式详细分析了php实现微信授权登录功能的具体操作步骤与相关实现技巧,需要的朋友可以参考下
java-spring boot项目之微信支付功能实现（微信公众号支付 代码demo
09-28
最近在做微信公众号支付，看文档做的，感觉踩了不少坑，为了避免后人采坑，所以写下此demo----微信支付功能实现（微信公众号支付）
微信登录实现
bear_309的博客
09-01 801
微信登录实现思路
基于springboot2.x的Oauth2.0一键授权登录和微信网页扫码支付测试开发案例(含源码)
08-25
使用idea开发工具，基于springboot2.x、jwt鉴权、nginx集群，前后端分离的微信Oauth2.0一键登录和微信网页扫码支付测试开发demo
OAuth2实现单点登录SSO完整教程，其实不难！
weixin_44421461的博客
03-16 1350
点击上方“Java基基”，选择“设为星标”做积极的人，而不是积极废人！源码精品专栏原创 | Java 2020超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网...
微信登录思路及代码实现
weixin_45622992的博客
04-11 1630
微信登录 前端使用uni-app配置好微信信息,直接使用uni.login({})获取code uni.login({ success: async res => { // 利用小程序登陆，配合code码进行用户登陆操作，并返回用户的token值 const result = await this.$u.api.getWxLogin({ code: res.code }); console.log(result,result.token,"&lt
微信开放平台---网站应用开发---微信登录功能 简介
weixin_34119545的博客
06-12 636
1 微信开放平台：https://open.weixin.qq.com/ 2 开通流程： 3 微信官方教程：https://open.weixin.qq.com/cgi-bin/showdocument?action=dir_list&amp;t=resource/res_list&amp;verify=1&amp;id=open1419316505&amp;token=&amp;lang...
实现微信登录
忆往昔的博客
08-30 1223
标题 微信开放平台文档 第一步：请求CODE 第三方使用网站应用授权登录前请注意已获取相应网页授权作用域（scope=snsapi_login），则可以通过在PC端打开以下链接： https://open.weixin.qq.com/connect/qrconnect?appid=APPID&redirect_uri=REDIRECT_URI&response_type=code&scope=SCOPE&state=STATE#wechat_redirect 若提示“该
Springboot实现微信扫码登录
qq_45751976的博客
01-20 3139
springboot实现微信扫码登录
【编程开发】之微信登录
王廷云的博客
10-19 3173
一、微信登录介绍 1、准备工作 网站应用微信登录是基于 OAuth2.0 协议标准构建的微信 OAuth2.0 授权登录系统。如果想了解 OAuth2.0 可以参考我的另一篇博客：【编程开发】之 OAuth2 。 在进行微信 OAuth2.0 授权登录接入之前，需要完成以下步骤： （1）、在微信开放平台注册开发者帐号：https://open.weixin.qq.com，注册时需要注意的是： 目前只支持企业类型注册，也就是说是对企业开放的，不对个人开放 注册之后会得到相应的微信 id（AppID） 和微
spring boot项目实现 微信扫码登陆
weixin_58691039的博客
12-07 1747
spring boot项目实现 微信扫码登陆
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值