1. Toy模板网首页
  2. > Toy博客

HTTP工具类封装与http请求响应

7月前 作者：奋力向前123 分类：Toy博客 阅读(28) 违法举报

这篇具有很好参考价值的文章主要介绍了HTTP工具类封装与http请求响应。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、前言

在Java web系统中经常需要与外部接口进行对接，比较多的方式就是是http的方式。在springboot中，我们可以直接使用封装的feign如：我们去请求微信的接口，定义一个client客户端，使用feign框架去请求就可以。但是也有很多系统没有使用feign的框架，那就需要使用http工具类了。

@FeignClient(name = "weixin", url = "https://api.weixin.qq.com/")
public interface WXCLient {

    /**
     * 获取微信token
     * @param appid
     * @param secret
     * @return
     */
    @GetMapping("cgi-bin/token")
    Map<String, Object> gettoken(@RequestParam("appid") String appid, 
    @RequestParam("secret") String secret, @RequestParam("grant_type") String grant_type);

    /**
     * 获取微信token
     *
     * @param appid
     * @param secret
     * @return
     */
    @GetMapping("cgi-bin/token")
    Map<String, Object> getQRtoken(@RequestParam("appid") String appid, @RequestParam("secret") String secret, @RequestParam("grant_type") String grant_type);

    
    /**
     * 小程序登录
     *
     * @param appid
     * @param secret
     * @param grant_type
     * @param jsCode
     * @return  map {"session_key": "", "openid": ""}
     */
    @GetMapping("sns/jscode2session")
    Map<String, Object> jscode2session(@RequestParam("appid") String appid, @RequestParam("secret") String secret, @RequestParam("grant_type") String grant_type, @RequestParam("js_code") String jsCode);
    /**
     * 根据access_token和code获取微信登录信息
     *
     * @param access_token
     * @param code
     * @return
     */
    @GetMapping("cgi-bin/user/getUserInfo")
    Map<String, Object> getuserinfo(@RequestParam("access_token") String access_token, @RequestParam("code") String code);


    /**
     * @param access_token
     * @param userId
     * @return
     */
    @GetMapping("cgi-bin/user/get")
    Map<String, Object> get(@RequestParam("access_token") String access_token, @RequestParam("userid") String userId);

    /**
     * 获取微信用户手机号
     *
     * @param bodyMap
     * @param accessToken
     * @return
     */
    @PostMapping("wxa/business/getuserphonenumber")
    Map<String, Object> getPhone(@RequestParam("access_token") String accessToken, @RequestBody Map<String, Object> bodyMap);

    /**
     * 创建特定路径的微信小程序二维码
     *
     * @param bodyMap {"path":"", "with": 430}
     * @param accessToken
     * @return 返回的图片 Buffer
     */
    @PostMapping("cgi-bin/wxaapp/createwxaqrcode")
    Response createwxaqrcode(@RequestParam("access_token") String accessToken, @RequestBody Map<String, Object> bodyMap);
    
    
    /**
     * 获取urlscheme
     * @param accessToken
     * @param bodyMap
     * @return
     */
    @PostMapping("wxa/generatescheme")
    Map<String, Object>  generatescheme(@RequestParam("access_token") String accessToken, @RequestBody Map<String, Object> bodyMap);

    
    /**
     * 通过短信链接跳转
     * 获取generate_urllink
     * @param accessToken
     * @param bodyMap
     * @return
     */
    @PostMapping("wxa/generate_urllink")
    Map<String, Object>  generateUrllink(@RequestParam("access_token") String accessToken, @RequestBody Map<String, Object> bodyMap);

    
    /**
     * 二维码
     *该接口用于获取小程序码，适用于需要的码数量极多的业务场景。通过该接口生成的小程序码，永久有效，数量暂无限制。
     * @param accessToken
     * @param bodyMap
     * @return
     */
    @PostMapping("wxa/getwxacodeunlimit")
    byte[] getwxacodeunlimit(@RequestParam("access_token") String accessToken, @RequestBody Map<String, Object> bodyMap);
    
    /**
	     * 二维码
	     *该接口用于获取小程序码，适用于需要的码数量较少的业务场景。通过该接口生成的小程序码，永久有效，有数量限制，详见获取小程序码。
     * @param accessToken
     * @param bodyMap
     * @return
     */
    @PostMapping("wxa/getwxacode")
    byte[] getwxacode(@RequestParam("access_token") String accessToken, @RequestBody Map<String, Object> bodyMap);

    

}

二、http工具类

public class HttpUtils {
    private static Log logger = LogFactory.getLog(HttpUtils.class);

    public static String doGet(String url, Map<String, String> param) {

        // 创建Httpclient对象
        CloseableHttpClient httpclient = HttpClients.createDefault();

        String resultString = "";
        CloseableHttpResponse response = null;
        try {
            // 创建uri
            URIBuilder builder = new URIBuilder(url);
            if (param != null) {
                for (String key : param.keySet()) {
                    builder.addParameter(key, param.get(key));
                }
            }
            URI uri = builder.build();

            // 创建http GET请求
            HttpGet httpGet = new HttpGet(uri);

            // 执行请求
            response = httpclient.execute(httpGet);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
                httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return resultString;
    }

    public static String doGet(String url) {
        return doGet(url, null);
    }

    public static String doPost(String url, Map<String, String> param) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(3000)
                    .setSocketTimeout(3000).setConnectTimeout(3000).build();
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded");
            httpPost.setConfig(requestConfig);

            // 创建参数列表
            if (param != null) {
                List<NameValuePair> paramList = new ArrayList<>();
                for (String key : param.keySet()) {
                    paramList.add(new BasicNameValuePair(key, (String) param.get(key)));
                }
                // 模拟表单
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList, "utf-8");
                httpPost.setEntity(entity);
            }
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static String doPost(String url, Map<String, String> param, Map<String, String> headerParam) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(10000)
                    .setSocketTimeout(10000).setConnectTimeout(10000).build();
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded");
            httpPost.setConfig(requestConfig);
            if (headerParam != null) {
                for (Map.Entry<String, String> entry : headerParam.entrySet()) {
                    httpPost.setHeader(entry.getKey(), entry.getValue());
                }
            }

            // 创建参数列表
            if (param != null) {
                List<NameValuePair> paramList = new ArrayList<>();
                for (String key : param.keySet()) {
                    paramList.add(new BasicNameValuePair(key, (String) param.get(key)));
                }
                // 模拟表单
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList, "utf-8");
                httpPost.setEntity(entity);
            }
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("请求异常", e);
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static String doPostJson(String url, Map<String, String> param) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            httpPost.addHeader("Content-Type", "application/json");
            String jsonStr = JSONUtility.objectToJson(param);
            logger.info("post json parm：" + jsonStr);
            // 创建参数列表
            httpPost.setEntity(new StringEntity(jsonStr, "UTF-8"));
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static String doPost(String url) {
        return doPost(url, null);
    }

    public static String jsonPostHttps(String url, JSONObject params, int connectTimeout) {
        String responseContent = null;
        HttpPost httpPost = new HttpPost(url);
        CloseableHttpClient httpClient = HttpClients.createDefault();
        try {
            RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(connectTimeout)
                    .setConnectTimeout(connectTimeout).setConnectionRequestTimeout(connectTimeout).build();
            httpPost.setHeader("Content-type", "application/x-www-form-urlencoded");
            httpPost.setEntity(new StringEntity(params.toString(), Consts.UTF_8));
            httpPost.setConfig(requestConfig);
            CloseableHttpResponse response = httpClient.execute(httpPost);

            try {
                // 执行POST请求
                HttpEntity entity = response.getEntity(); // 获取响应实体
                try {
                    if (null != entity) {
                        responseContent = EntityUtils.toString(entity, Consts.UTF_8);
                    }
                } finally {
                    if (entity != null) {
                        entity.getContent().close();
                    }
                }
            } finally {
                if (response != null) {
                    response.close();
                }
            }
        } catch (ClientProtocolException e) {
        } catch (IOException e) {
        } finally {
            httpPost.releaseConnection();
        }
        return responseContent;
    }

    public static String doPostJson(String url, String json) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            httpPost.setHeader("Content-Type", "application/json");
            // 创建请求内容
            StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
            httpPost.setEntity(entity);
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static String doPostJson(String url, String json, Map<String, String> headerParam) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            httpPost.setHeader("Content-Type", "application/json");
            if (headerParam != null) {
                for (Map.Entry<String, String> entry : headerParam.entrySet()) {
                    httpPost.setHeader(entry.getKey(), entry.getValue());
                }
            }
            // 创建请求内容
            StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
            httpPost.setEntity(entity);
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static String doPostStream(String url, Map<String, String> param, Map<String, InputStream> streamMap) {
        // MultipartEntityBuilder;
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            // 创建参数列表
            MultipartEntityBuilder meBuilder = MultipartEntityBuilder.create();
            if (param != null) {
                for (String key : param.keySet()) {
                    meBuilder.addPart(key, new StringBody((String) param.get(key), ContentType.APPLICATION_JSON));
                }
            }
            if (streamMap != null) {
                for (String key : streamMap.keySet()) {
                    InputStreamBody inputStreamBody = new InputStreamBody(streamMap.get(key), key);
                    meBuilder.addPart(key, inputStreamBody);
                }
            }
            HttpEntity entity = meBuilder.build();
            httpPost.setEntity(entity);
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static String doPost(String url, Map<String, String> param, int connectTimeout) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();

        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(connectTimeout)
                    .setSocketTimeout(connectTimeout).setConnectTimeout(connectTimeout).build();
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded");
            httpPost.setConfig(requestConfig);

            // 创建参数列表
            if (param != null) {
                List<NameValuePair> paramList = new ArrayList<>();
                for (String key : param.keySet()) {
                    paramList.add(new BasicNameValuePair(key, (String) param.get(key)));
                }
                // 模拟表单
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList, "utf-8");
                httpPost.setEntity(entity);
            }
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static String doPost(String url, String param, String contentType, int connectTimeout) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();

        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(connectTimeout)
                    .setSocketTimeout(connectTimeout).setConnectTimeout(connectTimeout).build();
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            httpPost.setHeader("Content-Type", contentType);
            httpPost.setConfig(requestConfig);

            // 创建参数列表
            if (param != null) {
//                List<NameValuePair> paramList = new ArrayList<>();
//                for (String key : param.keySet()) {
//                    paramList.add(new BasicNameValuePair("key", (String) param.get(key)));
//                }
//                // 模拟表单
//                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList, "utf-8");
                httpPost.setEntity(new StringEntity(param, Consts.UTF_8));
            }
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }

三、http请求数据和响应数据详解

请求与响应的封装,计算机网络,java,http,网络协议,网络

HTTP请求数据

HTTP请求通常由四部分组成：请求行、请求头部、空行和请求体（如果有的话）。

  1. 请求行：

    • 请求方法：如GET、POST、PUT、DELETE等。它告诉服务器你想要执行的操作类型。
    • URL：请求的资源的路径。
    • HTTP协议版本：客户端使用的HTTP协议版本，通常是HTTP/1.1。

  2. 请求头部：包含一系列键值对，提供了关于请求和客户端的额外信息。例如：

    • Host：请求的目标主机。
    • User-Agent：发送请求的客户端的类型和版本。
    • Accept：客户端可以处理的内容类型。
    • Content-Type：请求体的媒体类型（如果有的话）。
    • Content-Length：请求体的长度（如果有的话）。

  3. 空行：请求头部之后是一个空行，用于分隔请求头部和请求体。

  4. 请求体：包含发送给服务器的数据，通常用于POST和PUT请求。

HTTP响应数据

HTTP响应也由四部分组成：状态行、响应头部、空行和响应体。

  1. 状态行：

    • HTTP协议版本：服务器使用的HTTP协议版本。
    • 状态码：一个三位数，表示请求的处理结果，如200表示成功，404表示未找到资源等。
    • 状态消息：对状态码的简短描述。

  2. 响应头部：与请求头部类似，包含一系列键值对，提供了关于响应和服务器的额外信息。例如：

    • Content-Type：响应体的媒体类型。
    • Content-Length：响应体的长度。
    • Date：响应生成的日期和时间。
    • Server：服务器软件的名称和版本。

  3. 空行：响应头部之后是一个空行，用于分隔响应头部和响应体。

  4. 响应体：包含服务器返回给客户端的数据，通常是HTML、JSON或其他类型的内容。

四、TCP的三次握手

HTTP通常建立在TCP之上，因此，当我们在谈论网络请求时，实际上在底层是通过TCP来建立和维护连接的。

以下是TCP三次握手的简要概述：

  1. SYN（同步）阶段：
    • 客户端向服务器发送一个SYN包，并等待服务器确认。SYN包中包含客户端的初始序列号。
  2. SYN-ACK（同步-应答）阶段：
    • 服务器收到SYN包后，向客户端发送一个SYN-ACK包作为应答。这个包中包含对客户端SYN包的确认信息（ACK）以及服务器自己的初始序列号。
  3. ACK（应答）阶段：
    • 客户端收到SYN-ACK包后，再向服务器发送一个ACK包，此包包含对服务器SYN-ACK包的确认信息。

完成这三次握手后，TCP连接就建立起来了，之后客户端和服务器就可以开始传输数据了。文章来源地址https://www.toymoban.com/news/detail-857836.html

到了这里，关于HTTP工具类封装与http请求响应的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • HTTP协议，请求响应

    HTTP协议，请求响应

    2024年02月07日
    浏览(39)
  • HTTP、请求和响应

    HTTP、请求和响应

    1.规定了交互的方式：请求、响应 2.数据的格式：行、头、体 在HTTP/1.0中默认使用短连接。也就是说，客户端和服务器每进行一次HTTP操作，就建立一次连接，任务结束就中断连接。当客户端浏览器访问的某个HTML或其他类型的Web页中包含有其他的Web资源（如JavaScript文件、图像

    2024年02月20日
    浏览(37)

  • Java http 响应式请求和非响应式请求有什么区别

    以下是一个使用Spring WebFlux实现真正的流式编程的案例： 运行Spring Boot应用程序，并使用浏览器或类似cURL的工具发送GET请求： 获取所有用户的请求：http://localhost:8080/users/stream 你将会看到一个持续不断的流式响应，每秒钟返回一个用户对象。这个案例中，我们使用了 @GetMapp

    2024年01月17日
    浏览(63)

  • 网站建设入门教程||HTTP 请求方法||HTTP 响应头信息

    根据 HTTP 标准，HTTP 请求可以使用多种请求方法。 HTTP1.0 定义了三种请求方法： GET, POST 和 HEAD 方法。 HTTP1.1 新增了六种请求方法：OPTIONS、PUT、PATCH、DELETE、TRACE 和 CONNECT 方法。 序号 方法 描述 1 GET 请求指定的页面信息，并返回实体主体。 2 HEAD 类似于 GET 请求，只不过返回的

    2024年02月12日
    浏览(66)
  • http请求和响应格式说明，http的get和post请求方式说明，http的请求体body的几种数据格式

    http请求和响应格式说明，http的get和post请求方式说明，http的请求体body的几种数据格式

    一个HTTP请求报文由 请求行（request line）、请求头部（header）、空行和请求数据 4个部分组成， 请求报文的一般格式 1、第一行必须是一个请求行(request-line),用来说明请求类型,要访问的资源以及所使用的HTTP版本 2、紧接着是一个请求头(header),用来说明服务器要使用的附加信息

    2024年02月02日
    浏览(56)
  • 《二》HTTP 请求报文和响应报文、请求方法、状态码

    《二》HTTP 请求报文和响应报文、请求方法、状态码

    请求报文: 客户端向服务器发送的请求信息，就叫做请求报文。 客户端发送一个 HTTP 请求到服务器，请求信息包含四部分：请求行、请求头、空行、请求体。 请求行：包含三部分，分别是请求方法、请求资源的路径、协议版本。 请求头：头信息，告诉服务器一些信息，在客

    2023年04月26日
    浏览(46)
  • 发送HTTP POST请求并处理响应

    发送HTTP POST请求并处理响应

    发送HTTP POST请求并处理响应是Web开发中的常见任务。在Go语言中，可以使用 net/http 包来发送HTTP POST请求并处理响应。 以下是一个示例代码，演示了如何发送HTTP POST请求并处理响应： go 复制代码 package  main import  ( \\\"bytes\\\"   \\\"fmt\\\"   \\\"io/ioutil\\\"   \\\"net/http\\\"   ) func   main ()  { // 创建一

    2024年01月17日
    浏览(35)
  • Http请求响应 Ajax 过滤器

    Http请求响应 Ajax 过滤器

    10/10/2023 近期总结：         最近学的后端部署，web服务器运行，各种请求响应，内容很多，学的很乱，还是需要好好整理，前面JavaSE内容还没有完全掌握，再加上一边刷题，感觉压力很大哈哈。看群友们都在说找工作难，又会被打击，不过感觉一切都以实力说话，提升自己

    2024年02月07日
    浏览(49)
  • http和https的请求与响应

    http和https的请求与响应

    HTTP协议 （HyperText Transfer Protocol，超文本传输协议）：是一种发布和接收 HTML页面的方法。 HTTPS （Hypertext Transfer Protocol over Secure Socket Layer）简单讲是HTTP的安全版，在HTTP下加入SSL层。 SSL （Secure Sockets Layer 安全套接层）主要用于Web的安全传输协议，在传输层对网络连接进行加密

    2024年02月03日
    浏览(81)

  • 常见的http请求头以及响应头

    1-1 Accept 1、 Accept ： text/html 浏览器可以接收服务器回发的类型为text/html 2、 Accept： */*代表浏览器可以处理所有类型 1-2 Accept-Encoding 1、 Accept-Encoding： gzip，deflate 浏览器申明自己接收的编码方法，通常指定压缩方法，是否支持压缩，支持什么压缩方法（gzip，deflate） 1-3 Accept

    2023年04月09日
    浏览(41)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包