为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 请求动作封装实战：新手必读教程

请求动作封装实战：新手必读教程

标签：
数据结构 API 设计模式
概述

本文介绍了请求动作封装的概念及其重要性，通过封装HTTP请求的逻辑来提高代码的复用性、错误处理和日志记录能力。文中详细讲解了如何在实战中封装GET、POST、PUT和DELETE请求，并提供了示例代码和测试方法，涵盖了从准备工作到最终测试的全过程。请求动作封装实战中包括了选择开发语言、编写基础请求函数以及添加错误处理和日志记录。

引入请求动作封装的概念

什么是请求动作封装

请求动作封装是指将发送HTTP请求的逻辑封装成一个函数，以便在应用程序中重复使用。这包括构造HTTP请求、处理响应、错误处理等步骤。通过封装这些步骤，开发人员可以专注于业务逻辑，而无需每次都需要编写发送请求的代码。

封装请求动作的重要性

  1. 代码复用性：封装请求动作使得代码可以重复使用，避免了代码的重复编写。
  2. 错误处理：封装请求动作时可以集中处理错误，减少代码中的错误处理冗余。
  3. 日志记录：封装请求动作时可以加入日志记录，方便调试和追踪问题。
  4. 可维护性：封装请求动作使得代码更容易维护，便于后期进行优化和调整。
  5. 测试和调试：封装的请求动作便于进行单元测试和集成测试，提高代码质量。

示例代码：简单HTTP请求

以下是一个简单的Python示例，使用requests库发送GET请求。

import requests

def make_get_request(url):
    try:
        response = requests.get(url)
        response.raise_for_status()  # 如果响应状态码不是200，则抛出异常
        return response.json()
    except requests.RequestException as e:
        print(f"Request failed: {e}")
        return None

# 调用函数
data = make_get_request('https://api.example.com/data')
print(data)
常见的请求类型介绍

GET请求

GET请求用于从服务器获取资源。它通常用于查询数据，例如获取用户信息或产品列表。

示例代码：发送GET请求

import requests

def get_data(url):
    response = requests.get(url)
    if response.status_code == 200:
        return response.json()
    else:
        print(f"Failed to get data: {response.status_code}")
        return None

# 调用函数
data = get_data('https://api.example.com/users')
print(data)

POST请求

POST请求用于向服务器发送数据，通常用于创建新的资源或提交表单。

示例代码：发送POST请求

import requests

def post_data(url, data):
    response = requests.post(url, json=data)
    if response.status_code == 201:
        print("Data posted successfully")
    else:
        print(f"Failed to post data: {response.status_code}")

# 示例数据
data = {'name': 'John Doe', 'email': 'john@example.com'}

# 调用函数
post_data('https://api.example.com/users', data)

其他请求类型（如PUT、DELETE）

PUT请求用于更新资源，而DELETE请求用于删除资源。

示例代码：发送PUT和DELETE请求

import requests

def put_data(url, data):
    response = requests.put(url, json=data)
    if response.status_code == 200:
        print("Data updated successfully")
    else:
        print(f"Failed to update data: {response.status_code}")

def delete_data(url):
    response = requests.delete(url)
    if response.status_code == 204:
        print("Data deleted successfully")
    else:
        print(f"Failed to delete data: {response.status_code}")

# 示例数据
data = {'name': 'John Doe', 'email': 'john@example.com'}

# 调用函数
put_data('https://api.example.com/users/1', data)
delete_data('https://api.example.com/users/1')
封装请求动作的步骤详解

准备工作：选择开发语言和环境

选择适当的开发语言和环境对于封装请求动作至关重要。常用的开发语言包括Python、Java、JavaScript等，而对应的环境可能包括Django、Spring Boot、Node.js等框架。下面是使用不同语言和环境进行请求封装的准备工作示例。

示例代码：安装requests库（Python）

pip install requests

示例代码：安装axios库（Node.js）

npm install axios

示例代码：安装RestTemplate库（Java）

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

编写基础请求动作函数

封装请求动作通常包括构造请求、发送请求、处理响应和异常处理等步骤。

示例代码：基础请求动作函数（Python）

import requests

def make_request(url, method, data=None):
    try:
        if method == 'GET':
            response = requests.get(url)
        elif method == 'POST':
            response = requests.post(url, json=data)
        elif method == 'PUT':
            response = requests.put(url, json=data)
        elif method == 'DELETE':
            response = requests.delete(url)
        else:
            raise ValueError("Unsupported method")

        response.raise_for_status()
        return response.json()
    except requests.RequestException as e:
        print(f"Request failed: {e}")
        return None

示例代码：基础请求动作函数（Java）

import org.springframework.http.*;
import org.springframework.web.client.RestTemplate;

public class HttpRequestUtil {
    public static ResponseEntity<String> makeRequest(String url, HttpMethod method, Object data) {
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<Object> entity = new HttpEntity<>(data, headers);
        try {
            ResponseEntity<String> response = restTemplate.exchange(url, method, entity, String.class);
            return response;
        } catch (Exception e) {
            System.out.println("Request failed: " + e.getMessage());
            return null;
        }
    }
}

示例代码：基础请求动作函数（Node.js）

const axios = require('axios');

function makeRequest(url, method, data) {
    try {
        if (method === 'GET') {
            return axios.get(url);
        } else if (method === 'POST') {
            return axios.post(url, data);
        } else if (method === 'PUT') {
            return axios.put(url, data);
        } else if (method === 'DELETE') {
            return axios.delete(url);
        } else {
            throw new Error("Unsupported method");
        }
    } catch (error) {
        console.error(`Request failed: ${error.message}`);
        return null;
    }
}

添加错误处理和日志记录

错误处理和日志记录是封装请求动作的重要组成部分。通过添加日志记录，可以更好地追踪请求的执行情况。

示例代码：添加错误处理和日志记录（Python）

import requests
import logging

logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

def make_request(url, method, data=None):
    try:
        if method == 'GET':
            response = requests.get(url)
        elif method == 'POST':
            response = requests.post(url, json=data)
        elif method == 'PUT':
            response = requests.put(url, json=data)
        elif method == 'DELETE':
            response = requests.delete(url)
        else:
            logger.error("Unsupported method")
            raise ValueError("Unsupported method")

        response.raise_for_status()
        logger.info(f"Request to {url} succeeded")
        return response.json()
    except requests.RequestException as e:
        logger.error(f"Request failed: {e}")
        return None

示例代码：添加错误处理和日志记录（Java）

import org.springframework.http.*;
import org.springframework.web.client.RestTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HttpRequestUtil {
    private static final Logger logger = LoggerFactory.getLogger(HttpRequestUtil.class);

    public static ResponseEntity<String> makeRequest(String url, HttpMethod method, Object data) {
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<Object> entity = new HttpEntity<>(data, headers);
        try {
            ResponseEntity<String> response = restTemplate.exchange(url, method, entity, String.class);
            logger.info("Request to {} succeeded", url);
            return response;
        } catch (Exception e) {
            logger.error("Request failed: {}", e.getMessage());
            return null;
        }
    }
}

示例代码：添加错误处理和日志记录（Node.js）

const axios = require('axios');
const logger = require('winston');

const expressLogger = new (winston.Logger)({
    transports: [
        new (winston.transports.Console)(),
    ],
});

function makeRequest(url, method, data) {
    try {
        if (method === 'GET') {
            return axios.get(url);
        } else if (method === 'POST') {
            return axios.post(url, data);
        } else if (method === 'PUT') {
            return axios.put(url, data);
        } else if (method === 'DELETE') {
            return axios.delete(url);
        } else {
            logger.error('Unsupported method');
            throw new Error("Unsupported method");
        }
    } catch (error) {
        logger.error(`Request failed: ${error.message}`);
        return null;
    }
}
封装请求动作的实战演练

实战案例：封装GET请求

封装GET请求时，可以使用之前编写的基础请求动作函数，并进行适当的参数化。

示例代码：封装GET请求（Python）

import requests
import logging

logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

def make_get_request(url):
    try:
        response = requests.get(url)
        response.raise_for_status()
        logger.info(f"GET request to {url} succeeded")
        return response.json()
    except requests.RequestException as e:
        logger.error(f"GET request failed: {e}")
        return None

# 调用函数
data = make_get_request('https://api.example.com/users')
print(data)

示例代码：封装GET请求（Java）

public class HttpRequestUtil {
    private static final Logger logger = LoggerFactory.getLogger(HttpRequestUtil.class);

    public static ResponseEntity<String> makeGetRequest(String url) {
        try {
            ResponseEntity<String> response = HttpRequestUtil.makeRequest(url, HttpMethod.GET, null);
            logger.info("GET request to {} succeeded", url);
            return response;
        } catch (Exception e) {
            logger.error("GET request failed: {}", e.getMessage());
            return null;
        }
    }
}

示例代码：封装GET请求（Node.js）

const axios = require('axios');
const logger = require('winston');

function makeGetRequest(url) {
    return new Promise((resolve, reject) => {
        axios.get(url)
            .then(response => {
                logger.info(`GET request to ${url} succeeded`);
                return resolve(response.data);
            })
            .catch(error => {
                logger.error(`GET request failed: ${error.message}`);
                return reject(null);
            });
    });
}

实战案例：封装POST请求

封装POST请求时，可以使用之前编写的基础请求动作函数，并进行适当的参数化。

示例代码：封装POST请求（Python）

import requests
import logging

logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

def make_post_request(url, data):
    try:
        response = requests.post(url, json=data)
        response.raise_for_status()
        logger.info(f"POST request to {url} succeeded")
        return response.json()
    except requests.RequestException as e:
        logger.error(f"POST request failed: {e}")
        return None

# 示例数据
data = {'name': 'John Doe', 'email': 'john@example.com'}

# 调用函数
response = make_post_request('https://api.example.com/users', data)
print(response)

示例代码：封装POST请求（Java）

public class HttpRequestUtil {
    private static final Logger logger = LoggerFactory.getLogger(HttpRequestUtil.class);

    public static ResponseEntity<String> makePostRequest(String url, Object data) {
        try {
            ResponseEntity<String> response = HttpRequestUtil.makeRequest(url, HttpMethod.POST, data);
            logger.info("POST request to {} succeeded", url);
            return response;
        } catch (Exception e) {
            logger.error("POST request failed: {}", e.getMessage());
            return null;
        }
    }
}

示例代码：封装POST请求（Node.js）

const axios = require('axios');
const logger = require('winston');

function makePostRequest(url, data) {
    return new Promise((resolve, reject) => {
        axios.post(url, data)
            .then(response => {
                logger.info(`POST request to ${url} succeeded`);
                return resolve(response.data);
            })
            .catch(error => {
                logger.error(`POST request failed: ${error.message}`);
                return reject(null);
            });
    });
}

实战案例：封装PUT和DELETE请求

封装PUT和DELETE请求时，可以使用之前编写的基础请求动作函数，并进行适当的参数化。

示例代码：封装PUT和DELETE请求（Python）

import requests
import logging

logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

def make_put_request(url, data):
    try:
        response = requests.put(url, json=data)
        response.raise_for_status()
        logger.info(f"PUT request to {url} succeeded")
        return response.json()
    except requests.RequestException as e:
        logger.error(f"PUT request failed: {e}")
        return None

def make_delete_request(url):
    try:
        response = requests.delete(url)
        response.raise_for_status()
        logger.info(f"DELETE request to {url} succeeded")
        return response.json()
    except requests.RequestException as e:
        logger.error(f"DELETE request failed: {e}")
        return None

# 示例数据
data = {'name': 'John Doe', 'email': 'john@example.com'}

# 调用函数
response = make_put_request('https://api.example.com/users/1', data)
print(response)
response = make_delete_request('https://api.example.com/users/1')
print(response)

示例代码：封装PUT和DELETE请求（Java）

public class HttpRequestUtil {
    private static final Logger logger = LoggerFactory.getLogger(HttpRequestUtil.class);

    public static ResponseEntity<String> makePutRequest(String url, Object data) {
        try {
            ResponseEntity<String> response = HttpRequestUtil.makeRequest(url, HttpMethod.PUT, data);
            logger.info("PUT request to {} succeeded", url);
            return response;
        } catch (Exception e) {
            logger.error("PUT request failed: {}", e.getMessage());
            return null;
        }
    }

    public static ResponseEntity<String> makeDeleteRequest(String url) {
        try {
            ResponseEntity<String> response = HttpRequestUtil.makeRequest(url, HttpMethod.DELETE, null);
            logger.info("DELETE request to {} succeeded", url);
            return response;
        } catch (Exception e) {
            logger.error("DELETE request failed: {}", e.getMessage());
            return null;
        }
    }
}

示例代码：封装PUT和DELETE请求（Node.js）

const axios = require('axios');
const logger = require('winston');

function makePutRequest(url, data) {
    return new Promise((resolve, reject) => {
        axios.put(url, data)
            .then(response => {
                logger.info(`PUT request to ${url} succeeded`);
                return resolve(response.data);
            })
            .catch(error => {
                logger.error(`PUT request failed: ${error.message}`);
                return reject(null);
            });
    });
}

function makeDeleteRequest(url) {
    return new Promise((resolve, reject) => {
        axios.delete(url)
            .then(response => {
                logger.info(`DELETE request to ${url} succeeded`);
                return resolve(response.data);
            })
            .catch(error => {
                logger.error(`DELETE request failed: ${error.message}`);
                return reject(null);
            });
    });
}
封装请求动作的常见问题和解决方法

常见错误及解决方法

  1. 404 Not Found：检查URL是否正确。
  2. 403 Forbidden：检查请求是否包含了必要的权限信息。
  3. 500 Internal Server Error：检查服务器端是否存在问题。
  4. Connection Reset：检查网络连接是否正常。

示例代码：处理404错误（Python）

import requests
import logging

logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

def make_request(url, method, data=None):
    try:
        if method == 'GET':
            response = requests.get(url)
        elif method == 'POST':
            response = requests.post(url, json=data)
        elif method == 'PUT':
            response = requests.put(url, json=data)
        elif method == 'DELETE':
            response = requests.delete(url)
        else:
            logger.error("Unsupported method")
            raise ValueError("Unsupported method")

        if response.status_code == 404:
            logger.error(f"Not Found: {url}")
            return None
        response.raise_for_status()
        logger.info(f"Request to {url} succeeded")
        return response.json()
    except requests.RequestException as e:
        logger.error(f"Request failed: {e}")
        return None

性能优化建议

  1. 请求缓存：对于频繁请求的数据，可以考虑使用缓存机制。
  2. 异步请求：对于需要发送大量请求的情况，可以使用异步请求提高响应速度。
  3. 批量请求：对于需要处理大量数据的情况，可以考虑使用批量请求的方式。

示例代码：使用异步请求（Python）

import requests
import asyncio

async def make_request(url, method, data=None):
    try:
        if method == 'GET':
            response = await requests.get(url)
        elif method == 'POST':
            response = await requests.post(url, json=data)
        elif method == 'PUT':
            response = await requests.put(url, json=data)
        elif method == 'DELETE':
            response = await requests.delete(url)
        else:
            raise ValueError("Unsupported method")

        response.raise_for_status()
        return response.json()
    except requests.RequestException as e:
        print(f"Request failed: {e}")
        return None

async def main():
    tasks = [
        make_request('https://api.example.com/users', 'GET'),
        make_request('https://api.example.com/users', 'POST', {'name': 'John Doe'}),
        make_request('https://api.example.com/users/1', 'PUT', {'name': 'John Doe'}),
        make_request('https://api.example.com/users/1', 'DELETE')
    ]
    responses = await asyncio.gather(*tasks)
    print(responses)

# 运行主函数
asyncio.run(main())
封装请求动作的注意事项和最佳实践

代码可读性和可维护性

封装请求动作时，要注意代码的可读性和可维护性。良好的注释、清晰的命名以及模块化的设计都是提高可读性和可维护性的关键。

示例代码：清晰的命名和注释（Python）

import requests
import logging

logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

def make_request(url, method, data=None):
    """
    发送HTTP请求
    :param url: 请求URL
    :param method: 请求方法（GET, POST, PUT, DELETE）
    :param data: 请求数据（仅适用于POST, PUT方法）
    :return: 响应数据
    """
    try:
        if method.upper() == 'GET':
            response = requests.get(url)
        elif method.upper() == 'POST':
            response = requests.post(url, json=data)
        elif method.upper() == 'PUT':
            response = requests.put(url, json=data)
        elif method.upper() == 'DELETE':
            response = requests.delete(url)
        else:
            logger.error("Unsupported method")
            raise ValueError("Unsupported method")

        response.raise_for_status()
        logger.info(f"Request to {url} succeeded")
        return response.json()
    except requests.RequestException as e:
        logger.error(f"Request failed: {e}")
        return None

测试和调试技巧

为了确保封装的请求动作能够正确工作，需要进行充分的测试和调试。可以使用单元测试和集成测试来验证代码的正确性。

示例代码：单元测试（Python）

import unittest
import requests

class TestHttpRequests(unittest.TestCase):

    def test_get_request(self):
        response = requests.get('https://api.example.com/users')
        self.assertEqual(response.status_code, 200)

    def test_post_request(self):
        data = {'name': 'John Doe', 'email': 'john@example.com'}
        response = requests.post('https://api.example.com/users', json=data)
        self.assertEqual(response.status_code, 201)

    def test_put_request(self):
        data = {'name': 'John Doe', 'email': 'john@example.com'}
        response = requests.put('https://api.example.com/users/1', json=data)
        self.assertEqual(response.status_code, 200)

    def test_delete_request(self):
        response = requests.delete('https://api.example.com/users/1')
        self.assertEqual(response.status_code, 204)

# 运行测试
if __name__ == '__main__':
    unittest.main()

通过以上的步骤和示例代码，您可以更好地理解和掌握请求动作封装的概念及其实际应用。希望这篇文章能帮助您更有效地管理和使用请求动作。

点击查看更多内容
发表于 2024.11.01 13:46， 共 51 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

作者其他优质文章

正在加载中

噜噜哒

移动开发工程师
手记
篇
粉丝
8
获赞与收藏
25

关注作者，订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消