httpclient请求

最新推荐文章于 2021-12-10 17:45:28 发布
最新推荐文章于 2021-12-10 17:45:28 发布
阅读量457 收藏
点赞数
分类专栏： 随笔
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wobuaiyy/article/details/105037213
版权

引入maven依赖

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.1.4</version>
</dependency>
<dependency>
    <groupId>org.apache.httpcomponents</groupId>    
     <artifactId>httpcore</artifactId>
    <version>4.4.12</version>
</dependency>
 <dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpasyncclient</artifactId>
    <version>4.4.12</version>
</dependency>
 <dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpcore-nio</artifactId>
    <version>4.4.12</version>
</dependency>
 <dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpmime</artifactId>
    <version>4.5.9</version>
</dependency>

 

import com.alibaba.fastjson.TypeReference;
import com.alibaba.fastjson.util.IOUtils;
import com.google.common.base.Joiner;
import com.google.common.base.Stopwatch;
import com.google.common.collect.Maps;
import com.meituan.mtrace.http.HttpAsyncClients;
import com.meituan.mtrace.http.HttpClients;
import com.sankuai.meituan.common.json.JSONUtil;
import com.sankuai.shangou.empower.uwms.common.utils.FastJsonUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.MapUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.HttpClientConnectionManager;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
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.conn.PoolingHttpClientConnectionManager;
import org.apache.http.impl.nio.client.CloseableHttpAsyncClient;
import org.apache.http.impl.nio.conn.PoolingNHttpClientConnectionManager;
import org.apache.http.impl.nio.reactor.DefaultConnectingIOReactor;
import org.apache.http.impl.nio.reactor.IOReactorConfig;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.nio.reactor.ConnectingIOReactor;
import org.apache.http.nio.reactor.IOReactorException;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class HttpClientUtil {

    private static final String CHARSET_UTF8 = "UTF-8";
    private static final Pattern HTTP_PATTERN = Pattern.compile("^(https?|ftp|file)://[-a-zA-Z0-9+&@#/%?=~_|!:,.;]*[-a-zA-Z0-9+&@#/%=~_|]");
    private static volatile CloseableHttpClient httpClient;
    private static volatile CloseableHttpAsyncClient httpAsyncClient;

    // 默认socket连接超时时间
    private static final int DEFAULT_SOCKET_TIMEOUT = 10 * 1000;
    // 默认HTTP连接超时时间
    private static final int DEFAULT_CONNECT_TIMEOUT = 5 * 1000;

    /**
     * 默认请求头
     */
    private static final Map<String, String> DEFAULT_HEADER = Maps.newHashMap();

    static {
        // DEFAULT_HEADER.put("Content-Type", "application/json; charset=UTF-8");
    }

    private HttpClientUtil() {
    }

    /**
     * 启动时初始化httpClient及连接池的连接数
     */
    public static CloseableHttpClient getHttpClient() {
        if (null == httpClient) {
            synchronized (HttpClientUtil.class) {
                if (null == httpClient) {
                    log.info("HttpClientUtil.getHttpClient, 初始化httpClient");
                    httpClient = HttpClients.custom().setConnectionManager(
                            buildConnectionManager()).setRetryHandler(buildRetryHandler()).build();
                }
            }
        }
        return httpClient;
    }

    /**
     * 启动时初始化httpAsyncClient及连接池的连接数
     */
    public static CloseableHttpAsyncClient getHttpAsyncClient() {
        if (null == httpAsyncClient) {
            synchronized (HttpClientUtil.class) {
                if (null == httpAsyncClient) {
                    httpAsyncClient = HttpAsyncClients.custom()
                            .setConnectionManager(buildPoolConnectionManager())
                            .setDefaultRequestConfig(RequestConfig.custom().setSocketTimeout(DEFAULT_SOCKET_TIMEOUT)
                                    .setConnectTimeout(DEFAULT_CONNECT_TIMEOUT).build()).build();
                }
            }
        }
        return httpAsyncClient;
    }


    /**
     * 执行post请求获取响应字符串
     *
     * @param url            请求url
     * @param connectTimeOut 连接超时时间
     * @param socketTimeOut  socket超时时间
     * @param params         post请求参数
     * @return 响应字符串
     */
    public static String post(String url, int connectTimeOut, int socketTimeOut, Map<String, Object> params) {
        return post(url, connectTimeOut, socketTimeOut, params, DEFAULT_HEADER);
    }

    public static String post(String url, int connectTimeOut, int socketTimeOut, Map<String, Object> params,
                              Map<String, String> headers) {
        // 构建httppost请求配置、实体、请求头
        HttpPost httpPost = new HttpPost(url);
        setPostConfig(httpPost, connectTimeOut, socketTimeOut);
        setPostEntity(httpPost, params);
        setPostHeader(httpPost, headers);
        // 发送post请求
        CloseableHttpResponse response = null;
        String result = "";
        Stopwatch stopwatch = Stopwatch.createStarted();
        try {
            response = getHttpClient().execute(httpPost);
            // 返回不为成功时直接返回null
            if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
                log.error("HttpClientUtil.post, 发送POST请求获取响应, httpcode:{}, url:{}, connectTimeOut:{}, socketTimeOut:{}, params:{}, headers:{}",
                        response.getStatusLine().getStatusCode(), url, connectTimeOut, socketTimeOut, params, headers);
                return null;
            }
            HttpEntity entity = response.getEntity();
            result = EntityUtils.toString(entity, CHARSET_UTF8);
            if (MccConfigUtil.getCanLogHttpRequestResult()) {
                try {
                    log.info("url = {} param = {}, result = {} header = {}", url, JSONUtil.toJSONString(params), result);
                } catch (Exception e) {
                    log.error("url = {}", url, e);
                }
            }
            return result;
        } catch (Exception e) {
            log.error("HttpClientUtil.post, 执行POST请求失败, url:{}, connectTimeOut:{}, socketTimeOut:{}, params:{}, headers:{}, exception",
                    url, connectTimeOut, socketTimeOut, params, headers, e);
            return null;
        } finally {
            // 关闭响应
            IOUtils.close(response);
            log.info("HttpClientUtil.post, 发送POST请求的url:{}, cost={}", url, stopwatch.elapsed(TimeUnit.MILLISECONDS));
        }
    }

    public static String get(String url, int connectTimeOut, int socketTimeOut, Map<String, String> params) {
        return getWithHeader(url, connectTimeOut, socketTimeOut, params, null);
    }

    /**
     * 执行get请求获取响应字符串
     *
     * @param url 请求url
     * @return 响应字符串
     */
    public static String getWithHeader(String url, int connectTimeOut, int socketTimeOut, Map<String, String> params,
                                       Map<String, String> header) {
        String result = "";
        CloseableHttpResponse response = null;
        Stopwatch stopwatch = Stopwatch.createStarted();
        try {
            HttpGet httpGet = new HttpGet(assembleUrl(url, params));
            setGetConfig(httpGet, connectTimeOut, socketTimeOut);
            if (header != null) {
                for (Map.Entry<String, String> entry : header.entrySet()) {
                    httpGet.setHeader(entry.getKey(), entry.getValue());
                }
            }
            response = getHttpClient().execute(httpGet);

            // 返回不为成功时直接返回null
            if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
                log.error("HttpClientUtil.get, 发送GET请求获取响应状态, httpcode={}, url:{}, connectTimeOut:{}, socketTimeOut:{}, params:{}",
                        response.getStatusLine().getStatusCode(), assembleUrl(url, params), connectTimeOut, socketTimeOut, params);
                return null;
            }
            HttpEntity entity = response.getEntity();
            result = EntityUtils.toString(entity, CHARSET_UTF8);
            return result;
        } catch (Exception e) {
            log.error("HttpClientUtil.get, 执行GET请求失败, url:{}, connectTimeOut:{}, socketTimeOut:{}, params:{}, exception={}",
                    assembleUrl(url, params), connectTimeOut, socketTimeOut, FastJsonUtils.toJSONString(params), e);
            return null;
        } finally {
            // 关闭响应
            IOUtils.close(response);
            if (MccConfigUtil.getCanLogHttpRequestResult()) {
                log.info("HttpClientUtil.get, 发送GET请求的, url:{}, param = {} result = {} cost:{}, ",
                        url,
                        FastJsonUtils.toJSONString(params),
                        result,
                        stopwatch.elapsed(TimeUnit.MILLISECONDS));
            }
        }
    }

    /**
     * 拼接GET请求参数
     */
    public static String assembleUrl(String url, Map<String, String> params) {
        //校验参数
        if (MapUtils.isEmpty(params)) {
            return url;
        }
        //校验url的准确性
        Matcher matcher = HTTP_PATTERN.matcher(url);
        if (!matcher.matches()) {
            throw new IllegalArgumentException("illegal argument with url = " + url);
        }
        StringBuilder resultUrl = new StringBuilder(url);
        try {
            if (!url.contains("?")) {
                resultUrl.append("?");
            } else {
                if (!"?".endsWith(url)) {
                    resultUrl.append("&");
                }
            }
            return resultUrl.append(Joiner.on("&").withKeyValueSeparator("=").join(params)).toString();
        } catch (Exception e) {
            log.error("HttpClientUtil.assembleUrl, 拼接url异常, url:{}, exception={}", url, e);
        }
        return resultUrl.toString();
    }

    /**
     * 设置post请求超时时间
     *
     * @param httpPost       httppost
     * @param connectTimeOut 连接超时时间
     * @param socketTimeOut  socket读写超时时间
     */
    private static void setPostConfig(HttpPost httpPost, int connectTimeOut, int socketTimeOut) {
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectionRequestTimeout(connectTimeOut)
                .setConnectTimeout(connectTimeOut)
                .setSocketTimeout(socketTimeOut).build();
        httpPost.setConfig(requestConfig);
    }

    /**
     * 设置get请求超时时间
     *
     * @param httpGet        httpget
     * @param connectTimeOut 连接超时时间
     * @param socketTimeOut  socket读写超时时间
     */
    private static void setGetConfig(HttpGet httpGet, int connectTimeOut, int socketTimeOut) {
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectionRequestTimeout(connectTimeOut)
                .setConnectTimeout(connectTimeOut)
                .setSocketTimeout(socketTimeOut).build();
        httpGet.setConfig(requestConfig);
    }

    /**
     * 设置post请求实体
     *
     * @param httpPost httppost
     * @param params   实体参数
     */
    private static void setPostEntity(HttpPost httpPost, Map<String, Object> params) {
        // 将map转化成httppost的实体
        List<NameValuePair> nvps = new ArrayList<>();
        for (Map.Entry<String, Object> entry : params.entrySet()) {
            nvps.add(new BasicNameValuePair(entry.getKey(), String.valueOf(entry.getValue())));
        }
        try {
            httpPost.setEntity(new UrlEncodedFormEntity(nvps, CHARSET_UTF8));
        } catch (UnsupportedEncodingException e) {
            log.error("HttpClientUtil.setPostEntity, 实体转化成UTF-8格式出错, httpPost:{}, params:{}, exception={}", httpPost, params, e);
        }
    }

    /**
     * 设置post请求头
     *
     * @param httpPost httppost
     * @param headers  请求头
     */
    private static void setPostHeader(HttpPost httpPost, Map<String, String> headers) {
        for (Map.Entry<String, String> entry : headers.entrySet()) {
            httpPost.setHeader(entry.getKey(), entry.getValue());
        }
    }

    /**
     * 构建http连接管理器
     *
     * @return 连接管理器
     */
    private static HttpClientConnectionManager buildConnectionManager() {
        ConnectionSocketFactory plainsf = PlainConnectionSocketFactory.getSocketFactory();
        LayeredConnectionSocketFactory sslsf = SSLConnectionSocketFactory.getSocketFactory();
        Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", plainsf).register("https", sslsf).build();
        PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(registry);
        // 将最大连接数增加
        cm.setMaxTotal(MccConfigUtil.getHttpMaxTotal());
        // 将每个路由基础的连接增加
        cm.setDefaultMaxPerRoute(MccConfigUtil.getHttpMaxPerRoute());
        return cm;
    }

    /**
     * 构建http异步连接管理器
     *
     * @return
     */
    private static PoolingNHttpClientConnectionManager buildPoolConnectionManager() {
        try {
            IOReactorConfig ioReactorConfig = IOReactorConfig.custom().setIoThreadCount(MccConfigUtil.getHttpAsyncIoThreadCount()).build();
            ConnectingIOReactor ioReactor = new DefaultConnectingIOReactor(ioReactorConfig);
            PoolingNHttpClientConnectionManager cm = new PoolingNHttpClientConnectionManager(ioReactor);
            cm.setMaxTotal(MccConfigUtil.getHttpAsyncMaxTotal());
            cm.setDefaultMaxPerRoute(MccConfigUtil.getHttpAsyncMaxPerRoute());
            return cm;
        } catch (IOReactorException e) {
            log.error("HttpClientUtil.buildPoolConnectionManager, 构建http异步连接管理器异常, exception={}", e);
        }
        return null;
    }

    /**
     * 构建重试次数的handler
     *
     * @return handler
     */
    private static HttpRequestRetryHandler buildRetryHandler() {
        return (IOException exception, int executionCount, HttpContext context) -> {
            // 校验重试次数
            if (executionCount >= MccConfigUtil.getHttpRetryTimes()) {
                return false;
            }
            return true;
        };
    }

    public static <T> T postJson(String url, int connectTimeOut, int socketTimeOut, Map<String, Object> params,
                                 TypeReference<T> typeReference) {

        // 构建httppost请求配置、实体、请求头
        HttpPost httpPost = new HttpPost(url);
        setPostConfig(httpPost, connectTimeOut, socketTimeOut);
        setJsonData(httpPost, params);
        // 发送post请求
        CloseableHttpResponse response = null;
        String result = "";
        Stopwatch stopwatch = Stopwatch.createStarted();
        try {
            response = getHttpClient().execute(httpPost);
            // 返回不为成功时直接返回null
            if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
                log.error("HttpClientUtil.post, 发送POST请求获取响应, httpcode:{}, url:{}, connectTimeOut:{}, socketTimeOut:{}, params:{}",
                        response.getStatusLine().getStatusCode(), url, connectTimeOut, socketTimeOut, params);
                return null;
            }
            HttpEntity entity = response.getEntity();
            result = EntityUtils.toString(entity, CHARSET_UTF8);
            return FastJsonUtils.parseObject(result, typeReference);
        } catch (Exception e) {
            log.error("HttpClientUtil.post, 执行POST请求失败, url:{}, connectTimeOut:{}, socketTimeOut:{}, params:{}, exception={}",
                    url, connectTimeOut, socketTimeOut, params, e);
            return null;
        } finally {
            // 关闭响应
            IOUtils.close(response);
            log.info("HttpClientUtil.post, 发送POST请求的url:{}, param = {} , result = {}cost={}", url,
                    FastJsonUtils.toJSONString(params),
                    result,
                    stopwatch.elapsed(TimeUnit.MILLISECONDS));
        }
    }

    private static void setJsonData(HttpPost httpPost, Map<String, Object> params) {
        StringEntity entity = new StringEntity(FastJsonUtils.toJSONString(params),
                "utf-8");//解决中文乱码问题
        entity.setContentEncoding("UTF-8");
        entity.setContentType("application/json");
        httpPost.setEntity(entity);
    }
}
wobuaiyy
关注
专栏目录
java发送HttpClient请求及接收请求结果过程的简单实例
09-01
下面将详细解释如何使用HttpClient发送请求以及处理返回结果的过程。 首先，我们需要导入必要的依赖库，这通常包括Apache HttpClient库和JSON处理库，如net.sf.json.JSONObject。在本例中，我们看到代码使用了`org....
JAVA发送HttpClient请求及接收请求完整代码实例
08-13
在本实例中，我们将深入探讨如何使用HttpClient来发送请求以及处理返回的数据。 首先，让我们了解HttpClient的基本用法。Apache HttpClient库提供了一个`CloseableHttpClient`接口，它是执行HTTP请求的主要入口点。...
HTTP工具类
码农星
12-04 2669
/* * Copyright (C) 2018 All rights reserved. * * Created by gaoxing on 2018/11/28. */ package com.missfresh.antispam.sdk.utils; import java.io.IOException; import java.io.InputStream; import ja...
org.apache.http.impl.conn.PoolingClientConnectionManager
金溪的博客
02-14 4793
不推荐使用，推荐用PoolingHttpClientConnectionManager替换。用于管理OperateClientConnection连接池，对于服务连接请求可以多线程执行，连接的获取是基于路由的，对于每个路由管理器会保证至少有一个持久连接。这个管理器对地每个路由及总体上连接数都有一个最大连接数的限制。默认情况下，每个路由不会超过2个并发的连接，总共不会超过20个并发的连接，但是可以使...
apache httpclient连接池PoolingHttpClientConnectionManager
mazhongjia的博客
08-11 9944
一、首先,明确以下内容: 1.http连接池不是万能的,过多的长连接会占用服务器资源,导致其他服务受阻 2.http连接池只适用于请求是经常访问同一主机(或同一个接口)的情况下 3.并发数不高的情况下资源利用率低下 那么,当你的业务符合上面3点,那么你可以考虑使用http连接池来提高服务器性能 使用http连接池的优点: 1.复用http连接,省去了tcp的3次握手和4次挥手的时间,极大降低请求响应的时间 2.自动管理tcp连接,不用人为地释放/创建连接 使用http连接池的大致流程 : 1.创
HttpClient连接池的使用
chugang1854的博客
02-19 213
package com.iminer.rd.tools; import org.apache.http.*; import org.apache.http.client.HttpRequestRetryHandler; import org.apache.http.client.config...
异步httpclient(httpasyncclient)的使用与总结
热门推荐
Kevin.yang专栏
12-24 6万+
1. 前言应用层的网络模型有同步与异步。同步意味当前线程是阻塞的，只有本次请求完成后才能进行下一次请求;异步意味着所有的请求可以同时塞入缓冲区,不阻塞当前的线程;httpclient在4.x之后开始提供基于nio的异步版本httpasyncclient,httpasyncclient借助了Java并发库和nio进行封装(虽说NIO是同步非阻塞IO,但是HttpAsyncClient提供了回调的机制,
httpClient请求
12-31
在本文中，我们将深入探讨HttpClient工具类及其在多个系统间数据请求中的应用。 首先，我们看到有两个文件：`HttpClientUtils.java`和`RestClient.java`。`HttpClientUtils`通常是封装了HttpClient核心操作的工具类...
在java后端发送HTTPClient请求工具类
最新发布
09-30
在java后端发送HTTPClient请求工具类
httpclient请求方式+cookies
12-11
httpclient 请求两种方式,如果有cookie可加上cookies，同步获取返回值
java org.apache.http.nio jar包
04-17
找了好久，终于找到了，java刷新同步获取网络资源
No buffer space available (maximum connections reached?): connect
IT云清
07-27 4094
java调用es,过于频繁，发生了如下错误： 2018-07-27 11:44:28 814 | ERROR | pool-2722-thread-1 | CloseableHttpAsyncClientBase$1 | I/O reactor terminated abnormally org.apache.http.nio.reactor.IOReactorException: Failur...
HttpClient 的实现原理
没故事的码农的博客
02-08 1006
一、背景 HTTP是一个传输内容有可读性的公开协议，客户端与服务器端的数据完全通过明文传输。在这个背景之下，整个依赖于Http协议的互联网数据都是透明的，这带来了很大的数据安全隐患。想要解决这个问题有两个思路： C/S端各自负责，即客户端与服务端使用协商好的加密内容在Http上通信 C/S端不负责加解密，加解密交给通信协议本身解决 第一种在现实中的应用范围其实比想象中的要广泛一些。双方线下交换密钥，客户端在发送的数据采用的已经是密文了，这个密文通过透明的Http协议在互联网上.
【转】异步的AsyncHttpClient使用详解
weixin_33860553的博客
07-10 489
http://blog.csdn.net/angjunqiang/article/details/55259170 背景        前面的一篇文章【同步的HttpClient使用详解】中，提到了服务端通进行网络请求的方式。也讲述了在并发量大的情况下使用HttpClient的连接池来提高性能。此方法虽然很有效果，但是当访问量极大或网络不好的情况下也会出现某些网络请求慢导致其它请求阻塞的情况，...
Java线程泄露的分析与处理
weixin_33725126的博客
04-27 448
1. 生产环境的异常现象及初步分析最近发现系统程序内存消耗越来越大，开始并没特别注意，就简单调了一下jvm参数。但直到前些天内存爆满，持续Full GC，这肯定出现了内存泄露。原以为哪里出现了比较低级的错误，所以很直接想到先去看看程序是在跑哪段代码。jstack -l <pid>以后，居然有上千个线程，而且都是属于RUNNING并WAIT的状态。I/Odispa...
高并发下ES对象的创建问题
Nicky_LC的博客
12-10 4142
问题场景： 业务为定时任务，每隔一分钟加载文件夹下的新产生的文件（每分钟新增文件数大约100~200个），解析文件内容写入es。 1）根据host来生成一个对象，使用这一个对象进行es操作：因为并发操作，100个线程全部占满，经调查发现瓶颈在于这一个对象进行发送，故此方案舍弃！ 2）根据业务区分定时任务，当前一个调度周期的任务创建一个对象，同时缓存下来，定时清除5分钟未使用的缓存对象：此方案在初期执行时没有问题，在执行一段时间后，会报以下异常： Caused by: java.io.IOExcep
基于HttpClient 4.3的可访问自签名HTTPS站点的新版工具类
Slash Youth - Jack Chai
10-17 2万+
本文出处：http://blog.csdn.net/chaijunkun/article/details/40145685，转载请注明。由于本人不定期会整理相关博文，会对相应内容作出完善。因此强烈建议在原始出处查看此文。 HttpClient在当今Java应用中的位置越来越重要。从该项目的变迁过程我们不难发现，其已经从apache-commons众多的子项目中剥离，一跃成为如今的顶级项目，...
Java HttpClient请求实例：POST与GET方法详解
本文档提供了一个Java实现中使用Apache HttpClient发送HTTP请求的简单实例。主要讲解了如何创建一个名为HttpRequestUtils的工具类，用于执行GET和POST方法，以及处理响应结果。以下是详细内容的阐述： 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值