备份学习：httpClient调用接口的写法及依赖jar

最新推荐文章于 2024-02-04 19:55:13 发布
最新推荐文章于 2024-02-04 19:55:13 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouzhouzuiqiang/article/details/109093662
版权

学习博客：https://blog.csdn.net/wangpeng047/article/details/19624529?depth_1- 

jar包下载地址（上传到有道笔记中了）：http://note.youdao.com/noteshare?id=730e3385f30ac2d2af8238e6fef3125f 

 

package com.ncbi.medhub.util;

import com.alibaba.fastjson.JSONObject;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.*;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.util.EntityUtils;
import org.apache.logging.log4j.util.PropertiesUtil;

import javax.net.ssl.SSLContext;
import java.io.IOException;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 主要用于调用 http接口 https接口
 *
 */
public class HttpUtilTool {
    private static HttpUtilTool httpUtilTool;

    public static HttpUtilTool getInstance() {
        if (null == httpUtilTool) {
            httpUtilTool = new HttpUtilTool();
        }
        return httpUtilTool;
    }

//    public static String doHttpsPostByPostMedthod(){
//        HttpClient httpclient = HttpClients.createDefault();
//
//        try {
//            String result = "";
//            PostMethod post = new PostMethod(PropertiesUtil.getUrl());
//            post.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, "gbk");
//            post.addParameter("SpCode", PropertiesUtil.getSpCode());
//            post.addParameter("LoginName", PropertiesUtil.getLoginName());
//            post.addParameter("Password", PropertiesUtil.getPassword());
//            post.addParameter("MessageContent", String.format(PropertiesUtil.getTemplate(), content));
            post.addParameter("MessageContent", String.format(PropertiesUtil.getTemplate(), ((int)((Math.random()*9+1)*100000))+""));
//            post.addParameter("UserNumber", destPhone);
//            post.addParameter("SerialNumber", "");
//            post.addParameter("ScheduleTime", "");
//            post.addParameter("ExtendAccessNum", "");
//            post.addParameter("f", PropertiesUtil.getF());
//            httpclient.execute(post);
//            result = new String(post.getResponseBody(), "gbk");
//            if (null != result) {
//                String[] arr = result.split("&");
//                String code = arr[0].split("=")[1];
//                if (code.equals("0")) {
//                    return true;
//                } else {
//                    return false;
//                }
//            }
//
//        } catch (Exception e) {
//            e.printStackTrace();
//        } finally {
//        }
//    }


    public String toHttpsGet(String url, Map<String, String> headers) {
        HttpGet httpGet = null;
        HttpResponse httpResponse = null;
        String result = null;
        try (CloseableHttpClient closeableHttpClient = this.createHttpClient()) {
            httpGet = new HttpGet(url);
            if (null != headers && headers.size() > 0) {
                for (Map.Entry<String, String> entry : headers.entrySet()) {
                    httpGet.setHeader(entry.getKey(), entry.getValue());
                }
            }
            httpResponse = closeableHttpClient.execute(httpGet);
            if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                HttpEntity httpEntity = httpResponse.getEntity();
                result = EntityUtils.toString(httpEntity, "UTF-8");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyStoreException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        }
        return result;
    }

    public String toHttpsDelete(String url, Map<String, String> headers) {
        String encode = "UTF-8";
        HttpDelete httpDelete = null;
        HttpResponse httpResponse = null;
        String result = null;
        try (CloseableHttpClient closeableHttpClient = createHttpClient()) {
            httpDelete = new HttpDelete(url);
            if (null != headers && headers.size() > 0) {
                for (Map.Entry<String, String> entry : headers.entrySet()) {
                    httpDelete.setHeader(entry.getKey(), entry.getValue());
                }
            }
            httpResponse = closeableHttpClient.execute(httpDelete);
            if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                HttpEntity httpEntity = httpResponse.getEntity();
                result = EntityUtils.toString(httpEntity, encode);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    public String toHttpsPut(String url, String json, Map<String, String> headers) {
        String result = "";
        String encode = "UTF-8";
        try (CloseableHttpClient closeableHttpClient = createHttpClient()) {
            HttpPut httpPut = new HttpPut(url);

            if (null != headers && headers.size() > 0) {
                for (Map.Entry<String, String> entry : headers.entrySet()) {
                    httpPut.setHeader(entry.getKey(), entry.getValue());
                }
            }
            StringEntity stringEntity = new StringEntity(json, encode);
            stringEntity.setContentType("application/json");
            httpPut.setEntity(stringEntity);
            try (CloseableHttpResponse httpResponse = closeableHttpClient.execute(httpPut)) {
                int code = httpResponse.getStatusLine().getStatusCode();
                if (code == 500) {
                    System.out.println("error");
                }
                if (code == HttpStatus.SC_OK) {
                    result = EntityUtils.toString(httpResponse.getEntity(), encode);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyStoreException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        }
        return result;
    }

    public String toHttpsPost(String url, String json, Map<String, String> headers) throws NoSuchAlgorithmException, KeyStoreException, KeyManagementException, IOException {
        String encode = "UTF-8";
        String result = null;
        try (CloseableHttpClient closeableHttpClient = createHttpClient();) {
            HttpPost httpPost = new HttpPost(url);

            if (null != headers && headers.size() > 0) {
                for (Map.Entry<String, String> entry : headers.entrySet()) {
                    httpPost.setHeader(entry.getKey(), entry.getValue());
                }
            }

            StringEntity stringEntity = new StringEntity(json, "UTF-8");
            stringEntity.setContentType("application/json");
            httpPost.setEntity(stringEntity);
            try (CloseableHttpResponse httpResponse = closeableHttpClient.execute(httpPost)) {
                int code = httpResponse.getStatusLine().getStatusCode();
                if (code == HttpStatus.SC_OK) {
                    result = EntityUtils.toString(httpResponse.getEntity(), encode);
//                    result = JSONObject.parseObject(result);

                }
            }
        }
        return result;
    }

    //避免需要证书
    private CloseableHttpClient createHttpClient() throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
        SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, (chain, authtyep) -> true).build();
        SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(sslContext, null, null, new NoopHostnameVerifier());
        return HttpClients.custom().setSSLSocketFactory(socketFactory).build();
    }

    public JSONObject toDelete(String url, Map<String, String> headers) {
        String encode = "UTF-8";
        CloseableHttpClient httpClient = HttpClients.createDefault();
        HttpDelete httpDelete = null;
        HttpResponse httpResponse = null;
        JSONObject jsonObject = null;
        try {
            httpDelete = new HttpDelete(url);
            if (null != headers && headers.size() > 0) {
                for (Map.Entry<String, String> entry : headers.entrySet()) {
                    httpDelete.setHeader(entry.getKey(), entry.getValue());
                }
            }
            httpResponse = httpClient.execute(httpDelete);
            if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                HttpEntity httpEntity = httpResponse.getEntity();
                String result = EntityUtils.toString(httpEntity, encode);
                jsonObject = JSONObject.parseObject(result);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                httpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return jsonObject;
    }

    public JSONObject toPut(String url, String jsonStr, Map<String, String> headers) throws IOException {
        String encode = "UTF-8";
        try (CloseableHttpClient httpClient = HttpClients.createDefault();) {
            HttpPut httpPut = null;
            HttpResponse httpResponse = null;
            JSONObject jsonObject = null;
            try {
                httpPut = new HttpPut(url);
                httpPut.setHeader("Content-type", "application/json");
                if (null != headers && headers.size() > 0) {
                    for (Map.Entry<String, String> entry : headers.entrySet()) {
                        httpPut.setHeader(entry.getKey(), entry.getValue());
                    }
                }
                StringEntity stringEntity = new StringEntity(jsonStr, encode);
                httpPut.setEntity(stringEntity);
                httpResponse = httpClient.execute(httpPut);
                if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                    HttpEntity httpEntity = httpResponse.getEntity();
                    String result = EntityUtils.toString(httpEntity, encode);
                    jsonObject = JSONObject.parseObject(result);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    httpClient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return jsonObject;
        }
    }

    /**
    * form表单传参方式
    */
    public JSONObject toPost(String url, Map<String, Object> map, Map<String, String> headers, String encode) {
        if (null == encode) {
            encode = "UTF-8";
        }
        CloseableHttpClient httpClient = HttpClients.createDefault();
        HttpPost httpPost = null;
        HttpResponse httpResponse = null;
        JSONObject jsonObject = null;
        try {
            httpPost = new HttpPost(url);
            if (null != headers && headers.size() > 0) {
                for (Map.Entry<String, String> entry : headers.entrySet()) {
                    httpPost.setHeader(entry.getKey(), entry.getValue());
                }
            }

            if (null != map) {
                List<NameValuePair> pairList = new ArrayList<>();
                for (String key : map.keySet()) {
                    pairList.add(new BasicNameValuePair(key, (String) map.get(key)));
                }
                UrlEncodedFormEntity encodedFormEntity = new UrlEncodedFormEntity(pairList, encode);
                httpPost.setEntity(encodedFormEntity);
            }
            httpResponse = httpClient.execute(httpPost);
            httpResponse.setHeader("Cache-Control", "no-cache");
            if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                String result = EntityUtils.toString(httpResponse.getEntity(), encode);
                jsonObject = JSONObject.parseObject(result);
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                httpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return jsonObject;
    }

    public JSONObject toGet(String url, Map<String, String> headers, String encode) {
        if (null == encode) {
            encode = "UTF-8";
        }
        CloseableHttpClient httpClient = HttpClients.createDefault();
        HttpGet httpGet = null;
        HttpResponse httpResponse = null;
        JSONObject jsonObject = null;
        try {
            httpGet = new HttpGet(url);
            if (null != headers && headers.size() > 0) {
                for (Map.Entry<String, String> entry : headers.entrySet()) {
                    httpGet.setHeader(entry.getKey(), entry.getValue());
                }
            }
            httpResponse = httpClient.execute(httpGet);
            if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                HttpEntity httpEntity = httpResponse.getEntity();
                String result = EntityUtils.toString(httpEntity, encode);
                jsonObject = JSONObject.parseObject(result);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                httpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return jsonObject;
    }

    public JSONObject toPostByJsonString(String url, String jsonStr, Map<String, String> headers) {
        String encode = "UTF-8";
        CloseableHttpClient httpClient = HttpClients.createDefault();
        HttpPost httpPost = null;
        HttpResponse httpResponse = null;
        JSONObject jsonObject = null;
        try {
            httpPost = new HttpPost(url);
            httpPost.setHeader("Content-type", "application/json");
            if (null != headers && headers.size() > 0) {
                for (Map.Entry<String, String> entry : headers.entrySet()) {
                    httpPost.setHeader(entry.getKey(), entry.getValue());
                }
            }

            StringEntity stringEntity = new StringEntity(jsonStr, encode);
            httpPost.setEntity(stringEntity);
            httpResponse = httpClient.execute(httpPost);
            if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                HttpEntity httpEntity = httpResponse.getEntity();
                String result = EntityUtils.toString(httpEntity, encode);
                jsonObject = JSONObject.parseObject(result);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                httpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return jsonObject;
    }


}



post请求插入数据:
package com.test;

import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;

public class TestPost {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String url ="http://192.168.1.88:8088/SrmCommSrv.asmx/upVender";
        CloseableHttpClient client= HttpClients.createDefault();
        HttpPost post=new HttpPost(url);
//        post.setHeader("Content-Type","application/json;charset=utf-8");
//        String params="{\"FormID\":\"QA00001\",\"NodeID\":\"09\",\"Statue\":\"同意\",\"User\":\"009608\",\"UserName\":\"信息部\",\"ApprovalTime\":\"2020-10-15 10:33:22\"}";
//        StringEntity postEntity=new StringEntity(params,"UTF-8");
        List<NameValuePair> pairs=new ArrayList<>();
        pairs.add(new BasicNameValuePair("FormID","QA00001"));
        pairs.add(new BasicNameValuePair("NodeID","09"));
        pairs.add(new BasicNameValuePair("Statue","同意"));
        pairs.add(new BasicNameValuePair("USER","009608"));
        pairs.add(new BasicNameValuePair("USERNAME","信息部"));
        UrlEncodedFormEntity encodedFormEntity=new UrlEncodedFormEntity(pairs,"utf-8");
        post.setEntity(encodedFormEntity);
        HttpResponse response=null;
        try{
            response=client.execute(post);
            response.setHeader("Cache-Control","no-cache");
            int code=response.getStatusLine().getStatusCode();
            System.out.println(code);
            if(response.getStatusLine().getStatusCode()== HttpStatus.SC_OK){
                String result=EntityUtils.toString(response.getEntity(),"utf-8");
                System.out.println(result);
            }
        }catch (Exception e){
            e.printStackTrace();
        }

    }
}



get请求获取数据：（使用HttpURLConnection）
package com.test;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class Test {
    public static void main(String[] args) {
        String urlString = "http://192.168.1.88:8088/SrmCommSrv.asmx/getVender?venderNO=602998";
        try {
            URL url = new URL(urlString);
//            HttpURLConnection.setFollowRedirects(false);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setDoOutput(true);
            conn.setDoInput(true);
//            conn.setRequestMethod("GET");
            InputStream is = conn.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
            String line = null;
            while((line=br.readLine())!=null){
                System.out.println(line);
            }
            is.close();
            conn.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

 

 

MyZeroLife
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用HttpClient调用接口的实例讲解
08-29
下面小编就为大家带来一篇使用HttpClient调用接口的实例讲解。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
httpclient调用接口demo
12-01
本demo有两个例子test是作为服务端开启的，httpclient是客户端调用的，模拟服务端的test在启动后是没有界面的，要加上id才能看到json数据，httpclient的HttpClient33.java是测试类，最后的结果是接受到一个对象。需要链接数据库，要是不想连接数据库可以自己修改一下。
Userimport org.apache.http.impl.client.HttpClients；属于java的哪个版本
最新发布
qq_33192454的博客
02-04 233
属于 Apache HttpComponents 库的一部分，不是 Java 核心库的一部分。它是 Apache HttpClient 库的一部分，用于进行 HTTP 请求。如果你在使用 Maven 或 Gradle 等构建工具，你可以在项目的依赖中添加 Apache HttpClient。请注意，具体的版本号可能会有所不同，你可以根据你的需求选择合适的版本。
org.apache.http的jar包是使用HttpClient发送http请求需要的jar包
11-10
httpmime-4.5.2.jar httpcore-4.4.4.jar httpclient-win-4.5.2.jar httpclient-cache-4.5.2.jar httpclient-4.5.2.jar 提供以上5个jar包
org.apache.commons.httpclient工具类
wang___wang___的博客
12-24 3577
import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler; import org.apache.commons.httpclient.HttpClient; import org.apache.commons.httpclient.HttpMethod; import org.apache.commons.httpclie...
HttpClient接口调用工具类(附带demo)
11-28
HttpClient接口调用工具类 (Post请求 get请求 put请求 delete请求 下载就可以用 )
Springboot2.5集成HttpClient依赖，封装HTTP请求类并配置连接池
我思故我在的博客空间
12-10 4913
先看需要引入的依赖： <!--Http服务器的访问功能--> <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpasyncclient</artifactId> </dependency> <!-- http通信 --> <dependency> <groupId>o
实例详解httpclient发送post请求
weixin_39302449的博客
04-10 2434
在上面的代码中，我们首先创建了一个HttpClient对象，然后创建了一个HttpPost对象，并设置了请求URL和请求体。接着设置了请求头信息，其中Content-Type指定了请求体的数据格式。最后执行请求，并获取响应结果。在获取响应结果时，我们使用了EntityUtils工具类将响应实体转换成字符串。最后在finally块中关闭了HttpClient对象。2.创建HttpPost对象，设置请求URL和请求体。1.创建HttpClient对象。4.执行请求，获取响应结果。
maven依赖冲突查找
xyr05288的专栏
05-17 4514
转载自：http://blog.csdn.net/loongshawn/article/details/50831890 《Maven依赖加载错误的情况分析》《Java Web工程转换为基于Maven的Web工程》《Maven Web工程运行异常:Maven.multiModuleProjectDirectory system propery is not set的问题》《Maven运行异常
HttpClient使用详解
热门推荐
鹏霄万里展雄飞
02-28 88万+
Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。因此熟练掌握HttpClient是很重要的必修内容，掌握HttpClient后，相信对于Http协议的了解会更加深入。 一、简介 HttpClient是Apache Jakarta Common下的子项目，用来提供高效的
org.apache.http.client.methods.HttpPost的使用和坑
hw1287789687的专栏
12-23 9004
org.apache.http.client.methods.HttpPost的使用和坑 依赖的jar包: &lt;dependency&gt; &lt;groupId&gt;org.apache.httpcomponents&lt;/groupId&gt; &lt;artifactId&gt;httpclient&lt;/artifact...
JAVA利用HttpClient进行HTTPS接口调用的方法
08-29
本篇文章主要介绍了JAVA利用HttpClient进行HTTPS接口调用的方法，具有一定的参考价值，有兴趣的可以了解一下
HttpClient依赖jar包.zip
07-29
Http/Https协议请求java实现依赖jar包
适配 android9.0 系统之路(Apache HTTP client) 二
SantoriniBat的博客
08-29 1219
N多天忘了写了，哈哈哈哈哈哈哈哈哈，毕竟我也是一个小白。最近补上一点我碰到的适配问题，我是真*小白，如果没有解决的话请留言，我将和你讨论下~~共同成长~~~好了话不多说。 Android Studio在build时提示 Unable to find optional library: org.apache.http.legacy 是说找不到这个类。这是什么情况呢？ 查阅文档发现，原来是An...
Android HTTPS详解
小一的专栏
09-15 6416
前言 最近有一个跟Https相关的问题需要解决，因此花时间学习了一下Android平台Https的使用，同时也看了一些Https的原理，这里分享一下学习心得。 HTTPS原理 HTTPS(Hyper Text Transfer Protocol Secure)，是一种基于SSL/TLS的HTTP，所有的HTTP数据都是在SSL/TLS协议封装之上进行传输的。HTTPS协议是在HTTP
java http put请求方式_Http四种请求方式:post ,get ,put,delete
weixin_36236774的博客
02-16 653
packagecom.clw.drp.http;importjava.util.List;importorg.apache.http.HttpResponse;importorg.apache.http.HttpStatus;importorg.apache.http.NameValuePair;importorg.apache.http.client.HttpClient;importorg.a...
android studio没有org.apache.http.client.HttpClient;等包问题 解决方案
white__cat的专栏
09-26 1147
以前用Eclipse做Android开发工具一直使用apache的http做网络请求，最近换用了Android studio发现没有办法引用apache的包，下面是我引用的步骤
安卓网络编程——Apache HTTP Client
旧日灯塔
04-17 1235
接上文HttpURLConnection https://blog.csdn.net/nishigesb123/article/details/89328097 上文提到了，Android主要有三种形式实现网络编程，HttpURLConnection一种，Apache HTTP Client也是一种。 但是Android 6.0(api 23) 谷歌将Http Client相关类移除了，并且...
commons-httpclient.jar的使用2
liulecode的专栏
03-20 2419
package com.test;import java.io.IOException;import org.apache.commons.httpclient.HttpClient;import org.apache.commons.httpclient.HttpMethod;import org.apache.commons.httpclient.NameValuePair;impor
httpclient调用远程接口
06-13
好的，关于使用HttpClient调用远程接口的方法，具体步骤如下： 1. 创建HttpClient对象 ```java CloseableHttpClient httpClient = HttpClients.createDefault(); ``` 2. 创建请求方式 ```java ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值