HttpClient 讲解 (2) 项目封装

最新推荐文章于 2024-11-08 13:43:44 发布
最新推荐文章于 2024-11-08 13:43:44 发布
阅读量92 收藏
点赞数
文章标签： python java
原文链接：https://my.oschina.net/gaoguofan/blog/752914
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

maven加载

<!-- httpclient begin -->
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpclient</artifactId>
			<version>4.3.4</version>
		</dependency>
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpasyncclient</artifactId>
			<version>4.0.2</version>
		</dependency>
		<dependency>
			<groupId>commons-httpclient</groupId>
			<artifactId>commons-httpclient</artifactId>
			<version>3.1</version>
		</dependency>
		<!-- httpclient end -->

请求封装,自动转换https

package com.zefun.common.utils;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.commons.httpclient.HttpStatus;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
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.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.BasicHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;

/**
 * 
* @author 
* @date 2015年8月11日 下午2:13:37
 */
public class HttpClientUtil {

    /**
     * http协议
     */
    private static final String HTTPS_PROTOCOL = "https://";
    /**
     * 协议默认端口
     */
    private static final int HTTPS_PROTOCOL_DEFAULT_PORT = 443;

    /**
     * 默认编码格式
     */
    private static final String DEFAULT_CHARSET = "UTF-8";

    /**
     * 日志
     */
    private static Logger logger = Logger.getLogger(HttpClientUtil.class);

    /**
     * 
    * @author 
    * @date 2015年8月11日 下午2:16:57
    * @param url 路径
    * @return int
     */
    private static int getPort(String url) {
        int startIndex = url.indexOf("://") + "://".length();
        String host = url.substring(startIndex);
        if (host.indexOf("/") != -1) {
            host = host.substring(0, host.indexOf("/"));
        }
        int port = HTTPS_PROTOCOL_DEFAULT_PORT;
        if (host.contains(":")) {
            int i = host.indexOf(":");
            port = new Integer(host.substring(i + 1));
        }
        return port;
    }

    /**
     * 
    * @author 
    * @date 2015年8月11日 下午2:14:36
    * @param params 参数
    * @return List<NameValuePair>
     */
    private static List<NameValuePair> geneNameValPairs(Map<String, ?> params) {
        List<NameValuePair> pairs = new ArrayList<NameValuePair>();
        if (params == null) {
            return pairs;
        }
        for (String name : params.keySet()) {
            if (params.get(name) == null) {
                continue;
            }
            pairs.add(new BasicNameValuePair(name, params.get(name).toString()));
        }
        return pairs;
    }

    /**
     * 发送GET请求
     * @param url 请求地址
     * @param charset 返回数据编码
     * @return 返回数据
     */
    public static String sendGetReq(final String url, String charset) {
        if (null == charset){
            charset = DEFAULT_CHARSET;
        }
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        HttpGet get = new HttpGet(url);
        if (url.toLowerCase().startsWith(HTTPS_PROTOCOL)) {
            initSSL(httpClient, getPort(url));
        }
        try {
            // 提交请求并以指定编码获取返回数据
            HttpResponse httpResponse = httpClient.execute(get);
            int statuscode = httpResponse.getStatusLine().getStatusCode();
            if ((statuscode == HttpStatus.SC_MOVED_TEMPORARILY) || (statuscode == HttpStatus.SC_MOVED_PERMANENTLY)
                    || (statuscode == HttpStatus.SC_SEE_OTHER) || (statuscode == HttpStatus.SC_TEMPORARY_REDIRECT)) {
                Header header = httpResponse.getFirstHeader("location");
                if (header != null) {
                    String newuri = header.getValue();
                    if ((newuri == null) || (newuri.equals(""))){
                        newuri = "/";
                    }
                    try {
                        httpClient.close();
                    }
                    catch (Exception e) {
                        e.printStackTrace();
                        httpClient = null;
                    }
                    logger.info("重定向地址：" + newuri);
                    return sendGetReq(newuri, null);
                }
            }
            logger.info("请求地址：" + url + "；响应状态：" + httpResponse.getStatusLine());
            HttpEntity entity = httpResponse.getEntity();
            return EntityUtils.toString(entity, charset);
        }
        catch (ClientProtocolException e) {
            logger.error("协议异常,堆栈信息如下", e);
        }
        catch (IOException e) {
            logger.error("网络异常,堆栈信息如下", e);
        }
        finally {
            // 关闭连接，释放资源
            try {
                httpClient.close();
            }
            catch (Exception e) {
                e.printStackTrace();
                httpClient = null;
            }
        }
        return null;
    }

    /**
     * 发送put请求
     * @param url		请求地址
     * @param params	请求参数
     * @param charset	返回数据编码
     * @return String
     */
    public static String sendPutReq(String url, Map<String, Object> params, String charset) {
        if (null == charset){
            charset = DEFAULT_CHARSET;
        }
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        HttpPut put = new HttpPut(url);

        // 封装请求参数
        List<NameValuePair> pairs = geneNameValPairs(params);
        try {
            put.setEntity(new UrlEncodedFormEntity(pairs, charset));
            if (url.startsWith(HTTPS_PROTOCOL)) {
                initSSL(httpClient, getPort(url));
            }
            // 提交请求并以指定编码获取返回数据
            HttpResponse httpResponse = httpClient.execute(put);

            logger.info("请求地址：" + url + "；响应状态：" + httpResponse.getStatusLine());
            HttpEntity entity = httpResponse.getEntity();
            return EntityUtils.toString(entity, charset);
        }
        catch (ClientProtocolException e) {
            logger.error("协议异常,堆栈信息如下", e);
        }
        catch (IOException e) {
            logger.error("网络异常,堆栈信息如下", e);
        }
        finally {
            // 关闭连接，释放资源
            try {
                httpClient.close();
            }
            catch (Exception e) {
                e.printStackTrace();
                httpClient = null;
            }
        }
        return null;
    }

    /**
     * 发送delete请求
     * @param url		请求地址
     * @param charset	返回数据编码
     * @return String
     */
    public static String sendDelReq(String url, String charset) {
        if (null == charset){
            charset = DEFAULT_CHARSET;
        }
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        HttpDelete del = new HttpDelete(url);
        if (url.toLowerCase().startsWith(HTTPS_PROTOCOL)) {
            initSSL(httpClient, getPort(url));
        }
        try {
            // 提交请求并以指定编码获取返回数据
            HttpResponse httpResponse = httpClient.execute(del);
            logger.info("请求地址：" + url + "；响应状态：" + httpResponse.getStatusLine());
            HttpEntity entity = httpResponse.getEntity();
            return EntityUtils.toString(entity, charset);
        }
        catch (ClientProtocolException e) {
            logger.error("协议异常,堆栈信息如下", e);
        }
        catch (IOException e) {
            logger.error("网络异常,堆栈信息如下", e);
        }
        finally {
            // 关闭连接，释放资源
            try {
                httpClient.close();
            }
            catch (Exception e) {
                e.printStackTrace();
                httpClient = null;
            }
        }
        return null;
    }

    /**
     * 发送POST请求，支持HTTP与HTTPS
     * @param url 请求地址
     * @param params 请求参数
     * @param charset 返回数据编码
     * @return 返回数据
     */
    public static String sendPostReq(String url, Map<String, ?> params, String charset) {
        if (null == charset){
            charset = DEFAULT_CHARSET;
        }
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        RequestConfig reqConf = RequestConfig.DEFAULT;
        HttpPost httpPost = new HttpPost(url);
        // 封装请求参数
        List<NameValuePair> pairs = geneNameValPairs(params);
        try {
            httpPost.setEntity(new UrlEncodedFormEntity(pairs, charset));
            // 对HTTPS请求进行处理
            if (url.toLowerCase().startsWith(HTTPS_PROTOCOL)) {
                initSSL(httpClient, getPort(url));
            }
            // 提交请求并以指定编码获取返回数据
            httpPost.setConfig(reqConf);
            HttpResponse httpResponse = httpClient.execute(httpPost);
            int statuscode = httpResponse.getStatusLine().getStatusCode();
            if ((statuscode == HttpStatus.SC_MOVED_TEMPORARILY) || (statuscode == HttpStatus.SC_MOVED_PERMANENTLY)
                    || (statuscode == HttpStatus.SC_SEE_OTHER) || (statuscode == HttpStatus.SC_TEMPORARY_REDIRECT)) {
                Header header = httpResponse.getFirstHeader("location");
                if (header != null) {
                    String newuri = header.getValue();
                    if ((newuri == null) || (newuri.equals(""))){
                        newuri = "/";
                    }
                    try {
                        httpClient.close();
                    }
                    catch (Exception e) {
                        e.printStackTrace();
                        httpClient = null;
                    }
                    return sendGetReq(newuri, null);
                }
            }

            logger.info("请求地址：" + url + "；响应状态：" + httpResponse.getStatusLine());
            HttpEntity entity = httpResponse.getEntity();
            return EntityUtils.toString(entity, charset);
        }
        catch (UnsupportedEncodingException e) {
            logger.error("不支持当前参数编码格式[" + charset + "],堆栈信息如下", e);
        }
        catch (ClientProtocolException e) {
            logger.error("协议异常,堆栈信息如下", e);
        }
        catch (IOException e) {
            logger.error("网络异常,堆栈信息如下", e);
        }
        finally {
            // 关闭连接，释放资源
            try {
                httpClient.close();
            }
            catch (Exception e) {
                e.printStackTrace();
                httpClient = null;
            }
        }
        return null;
    }

    /**
     * 发送POST请求，支持HTTP与HTTPS, 参数放入请求体方式
     * @param url 请求地址
     * @param content 请求参数
     * @param charset 返回数据编码
     * @return 返回数据
     */
    public static String sendPost(String url, String content, String charset) {
        if (null == charset){
            charset = DEFAULT_CHARSET;
        }
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        RequestConfig reqConf = RequestConfig.DEFAULT;
        HttpPost httpPost = new HttpPost(url);
        try {
            httpPost.setEntity(new StringEntity(content, charset));
            // 对HTTPS请求进行处理
            if (url.toLowerCase().startsWith(HTTPS_PROTOCOL)) {
                initSSL(httpClient, getPort(url));
            }
            // 提交请求并以指定编码获取返回数据
            httpPost.setConfig(reqConf);
            HttpResponse httpResponse = httpClient.execute(httpPost);
            int statuscode = httpResponse.getStatusLine().getStatusCode();
            if ((statuscode == HttpStatus.SC_MOVED_TEMPORARILY) || (statuscode == HttpStatus.SC_MOVED_PERMANENTLY)
                    || (statuscode == HttpStatus.SC_SEE_OTHER) || (statuscode == HttpStatus.SC_TEMPORARY_REDIRECT)) {
                Header header = httpResponse.getFirstHeader("location");
                if (header != null) {
                    String newuri = header.getValue();
                    if ((newuri == null) || (newuri.equals(""))){
                        newuri = "/";
                    }
                    try {
                        httpClient.close();
                    }
                    catch (Exception e) {
                        e.printStackTrace();
                        httpClient = null;
                    }
                    return sendGetReq(newuri, null);
                }
            }

            logger.info("请求地址：" + url + "；响应状态：" + httpResponse.getStatusLine());
            HttpEntity entity = httpResponse.getEntity();
            return EntityUtils.toString(entity, charset);
        }
        catch (UnsupportedEncodingException e) {
            logger.error("不支持当前参数编码格式[" + charset + "],堆栈信息如下", e);
        }
        catch (ClientProtocolException e) {
            logger.error("协议异常,堆栈信息如下", e);
        }
        catch (IOException e) {
            logger.error("网络异常,堆栈信息如下", e);
        }
        finally {
            // 关闭连接，释放资源
            try {
                httpClient.close();
            }
            catch (Exception e) {
                e.printStackTrace();
                httpClient = null;
            }
        }
        return null;
    }

    /**
     * 初始化HTTPS请求服务
     * @param httpClient HTTP客户端
     * @param port 端口
     */
    public static void initSSL(CloseableHttpClient httpClient, int port) {
        SSLContext sslContext = null;
        try {
            sslContext = SSLContext.getInstance("SSL");
            final X509TrustManager trustManager = new X509TrustManager() {
                public void checkClientTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
                }

                public void checkServerTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
                }

                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }
            };
            // 使用TrustManager来初始化该上下文,TrustManager只是被SSL的Socket所使用
            sslContext.init(null, new TrustManager[] { trustManager }, null);
            ConnectionSocketFactory ssf = new SSLConnectionSocketFactory(sslContext);
            Registry<ConnectionSocketFactory> r = RegistryBuilder.<ConnectionSocketFactory> create().register("https", ssf).build();
            BasicHttpClientConnectionManager ccm = new BasicHttpClientConnectionManager(r);
            HttpClients.custom().setConnectionManager(ccm).build();
        }
        catch (KeyManagementException e) {
            e.printStackTrace();
        }
        catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }
}

调用请求

String url = "http://up.qiniu.com/putb64/-1";
            HttpPost post = new HttpPost(url);
            post.addHeader("Content-Type", "application/octet-stream");
            post.addHeader("Authorization", "UpToken " + qiniuUptoken().get("uptoken"));
            //post.setEntity(new ByteArrayEntity(src));
            post.setEntity(new StringEntity(stringBase64));
            HttpClient c = Http.getClient();
            HttpResponse res = c.execute(post);
            System.out.println(res.getStatusLine().getReasonPhrase());
            String responseBody = EntityUtils.toString(
                    res.getEntity(), Config.CHARSET);
            System.out.println(responseBody);

上传文件

基于File上传

File file = new File("d:\\1.jpg");
            FileBody body = new FileBody(file);
            MultipartEntity entity = new MultipartEntity();
            //注意file是在后台中接受的参数File file
            entity.addPart("file", body);
            httpPost.setEntity(entity);

基于流上传

InputStreamBody inputStreamBody = new InputStreamBody(new FileInputStream(file), file.getName());
            MultipartEntity entity = new MultipartEntity();
            //注意file是在后台中接受的参数File file
            entity.addPart("file", inputStreamBody);
            httpPost.setEntity(entity);

后台接受都是一样的 

@RequestMapping(value = Url.Project.UPLOAD_PROJECT)
    public BaseDto uploadTest(@RequestParam(value = "file", required = false) MultipartFile file, HttpServletRequest request){
        String path = request.getSession().getServletContext().getRealPath("upload"); 
        String fileName = file.getOriginalFilename();  
        File targetFile = new File(path, fileName);  
        if (!targetFile.exists()){  
            targetFile.mkdir();
        }  
        try {  
            file.transferTo(targetFile);  
        } 
        catch (Exception e) {  
            e.printStackTrace();  
        }
        return new BaseDto(App.System.API_RESULT_CODE_FOR_SUCCEES, App.System.API_RESULT_MSG_FOR_SUCCEES);
    }


转载于:https://my.oschina.net/gaoguofan/blog/752914

weixin_33971205
关注
对于C#（HttpClient）方式网络请求的封装
06-28
描述中的链接指向了一个具体的博客文章，该文章详细解释了如何在C#项目中实现HttpClient的封装。根据上下文，我们可以预期博客会包含以下内容： 1. **HttpClient的基本使用**：介绍HttpClient类的基本概念，包括...
httpclient简化封装Starget.Http
06-29
本篇文章将详细讲解基于HttpClient的简化封装Starget.Http，以及如何利用它更方便地调用WebAPI接口，并通过Attribute控制模型序列化的位置。 首先，HttpClient虽然强大且功能齐全，但其基础使用往往需要编写大量的...
使用HttpClient调用接口的实例讲解
08-29
使用HttpClient调用接口的实例讲解 在本文中，我们将探讨使用HttpClient调用接口的实例讲解。HttpClient是一个强大且灵活的HTTP客户端库，它允许我们轻松地发送HTTP请求并获取响应。在本文中，我们将从基本概念开始...
Edoc2自己封装的java api
10-30
本文将详细讲解如何封装Edoc2的Java API，并探讨相关技术点。 首先，我们需要理解Edoc2提供的原始API。这些API通常包括一系列的HTTP请求，用于执行诸如上传文件、检索文档、设置权限等操作。在Java中，我们可以通过...
cocos2dx HttpClient网络访问
06-22
通过以上讲解，我们可以了解到，cocos2dx中的HttpClient是实现游戏网络功能的关键工具。通过合理利用HttpClient，开发者可以轻松地构建网络通信功能，实现游戏与服务器之间的数据交换，从而提升游戏体验和功能多样性...
智能化运维的未来：AI和机器学习在运维中的应用
Echo_Wish的博客
11-05 431
AI和机器学习在运维中的应用，不仅提高了运维效率和质量，还为企业的数字化转型提供了强有力的技术支持。通过预测性维护、自动化运维、异常检测和智能告警等应用，企业可以更好地管理和优化其IT基础设施，确保系统的高效、稳定运行。希望本文能为读者提供有价值的参考，帮助你在运维实践中更好地应用AI和机器学习技术。如果有任何问题或需要进一步讨论，欢迎交流探讨。让我们共同推动智能运维的发展，实现更高效、更智能的运维管理。
【anaconda】使用记录
zhuyan108的博客
11-05 328
window11 下安装anaconda。
自助餐剩余食品识别图像分割系统：教学内容全覆盖
sgcsdn99的博客
11-04 1468
数据集信息展示在本研究中，我们使用的数据集名为“9_5_Merged”，该数据集专门用于训练改进YOLOv8-seg的自助餐剩余食品识别图像分割系统。该数据集包含71个类别，涵盖了丰富多样的食品种类，旨在提高模型对不同类型剩余食品的识别和分割能力。通过对这些类别的细致划分，我们希望能够实现更高精度的图像分割，进而优化自助餐剩余食品的管理和利用。
【python GUI编码入门-21】如何用Tkinter创建一个记事本应用
最新发布
木头大左的博客
11-08 24
在现代编程环境中，图形用户界面（GUI）应用程序的开发变得越来越重要。Python的Tkinter库是一个功能强大且易于使用的GUI工具包，非常适合初学者和有经验的开发者使用。本文将详细介绍如何使用Tkinter创建一个简易的记事本应用，涵盖从安装到实现各项功能的全过程。Tkinter是Python的标准GUI库，它提供了丰富的接口来创建窗口、对话框、按钮等常见的GUI组件。Tkinter具有良好的跨平台性，可以在Windows、Mac OS和Linux上运行。
一次薅国家超算平台的记录
weixin_55179972的博客
11-07 407
参与 谁是下一个“AI”跃人 -AI体验推介活动，赢取千元算力券！（https://www.scnet.cn/home/subject/modular/index270.html）2. Clone开源的Llama3 Chinese （https://github.com/LlamaFamily/Llama-Chinese）活动名称主题：国家超算互联网「AI跃升季」：谁是下一个“AI”跃人 - AI算力体验活动。其中位置1，2替换为商品基模型和训练出来的微调模型。模型改为商城下载的模型。2、运行的过程记录。
探索 Python 的新天地：Helium 库揭秘
AIGC搞起
11-04 811
在自动化测试和网页交互的领域，Selenium 是一个强大的工具，但它的复杂性和陡峭的学习曲线让许多开发者望而却步。Helium库的出现，以其简洁的 API 和易用性，为 Python 开发者提供了一个新的选择。它不仅简化了 Selenium 的使用，还自带 WebDriver，减少了配置的复杂性。Helium 以其简洁的 API 和易用性，为 Python 开发者提供了一个强大的 Selenium 替代方案。它不仅减少了代码量，还简化了 WebDriver 的管理，使得自动化测试和网页交互变得更加容易。
Python 类和对象
疯一样的码农
11-04 746
在 Python 中，类是一个对象创建的蓝图。它指定了对象（实例）将具有的属性和方法的集合。类通过封装数据和行为，促进了代码的组织、复用和模块化。使用类可以建模现实世界中的对象，定义其属性，并更有效地控制应用程序的复杂性。在 Python 中，一切都是对象，所有的数据类型和结构都是特定类的实例。对象是类的实例，具有用于修改数据的方法和存储数据的属性。理解对象对于掌握 Python 中的面向对象编程（OOP）范式至关重要。
Python小游戏21——拼图小游戏
cxh666888_的博客
11-05 1038
如果图像大小不同，你需要调整tile_size和图像缩放代码。初始化Pygame：使用pygame.init()来初始化Pygame库，这是使用Pygame进行任何游戏开发的第一步。更新屏幕：使用pygame.display.flip()或pygame.display.update()来更新屏幕显示。调整图像大小：使用pygame.transform.scale()来调整图像的大小，以适应拼图游戏的需求。设置屏幕尺寸：使用pygame.display.set_mode()来设置游戏的屏幕尺寸和模式。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 95
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
Python的自然语言生成与对话系统介绍
余生的博客
11-05 821
自然语言生成(Natural Language Generation，NLG)和对话系统是人工智能领域的重要研究方向。NLG 涉及将计算机理解的信息转换为自然语言文本，而对话系统则涉及计算机与用户之间的自然语言交互。Python 作为一种易于学习、易于使用的编程语言，在这两个领域中发挥了重要作用。核心概念与联系核心算法原理和具体操作步骤数学模型公式详细讲解具体最佳实践：代码实例和详细解释说明实际应用场景工具和资源推荐总结：未来发展趋势与挑战。
nvlink 训练笔记
jacke121的专栏
11-05 245
nvlink 训练笔记
Python中的模块
piziliul的博客
11-04 258
创建introduce.py模块文件。创建my_info.py模块文件。
Python中的json.load方法和json.loads方法
11-05 117
在Python中，json.load()和json.loads()是两个用于处理JSON数据的方法，它们的主要区别在于输入数据的类型和返回值的类型。功能：json.load()方法用于从已打开的文件对象中读取JSON数据，并将其转换为Python对象（如字典或列表）。在这个例子中，json.load()方法从名为data.json的文件中读取JSON数据，并将其转换为Python对象。json.load()用于从文件中读取JSON数据，而json.loads()用于从字符串中解析JSON数据。
爬台阶问题
小杏儿的小家
11-05 554
爬楼梯问题的分析，思考，解析以及如何动手用代码进行实践。
Spring Boot封装HTTPClient实战教程
2. 函数：讲解了函数的声明、定义、参数列表、返回值，main函数的特殊性，以及标准函数库的使用。 3. 数组与指针：介绍了数组的定义、初始化、多维数组，字符串的表示，指针的概念、类型、操作，以及数组名与指针的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值