基于http协议的自定义协议封装

最新推荐文章于 2024-08-20 09:00:00 发布
最新推荐文章于 2024-08-20 09:00:00 发布
阅读量731 收藏 4
点赞数 1
分类专栏： 个人总结 软件测试 文章标签： java http https jmeter 接口测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45375866/article/details/119222248
版权

最近，领了项目的接口测试任务，由于之前一直使用Jmeter工具进行接口的调用，所以一开始并使用Jmeter调用接口进行测试，由于后面的业务比较复杂，在进行某个接口测试的时候需要依赖很多接口，导致维护起来比较费力。于是，尝试对Jmeter工具进行修改，使用Java请求对接口进行封装操作。然后通过Jmeter工具的图形化进行接口测试，效果不错。

由于系统使用HTTPS协议，在进行java脚本编写之前，通过HttpClient对Post、Get、Delete请求协议进行封装在HTTPRequest类中进行调用。

具体步骤如下：

使用HttpClient发送请求、接收响应很简单，一般需要如下几步即可：

  1. 创建CloseableHttpClient对象。
  2. 创建请求方法的实例，并指定请求URL。如果需要发送GET请求，创建HttpGet对象；如果需要发送POST请求，创建HttpPost对象。
  3. 如果需要发送请求参数，可可调用setEntity(HttpEntity
    entity)方法来设置请求参数。setParams方法已过时（4.4.1版本）。
  4. 调用HttpGet、HttpPost对象的setHeader(String name, String
    value)方法设置header信息，或者调用setHeaders(Header[] headers)设置一组header信息。
  5. 调用CloseableHttpClient对象的execute(HttpUriRequest
    request)发送请求，该方法返回一个CloseableHttpResponse。
  6. 调用HttpResponse的getEntity()方法可获取HttpEntity对象，该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容；调用CloseableHttpResponse的getAllHeaders()、getHeaders(String
    name)等方法可获取服务器的响应头。
  7. 释放连接。无论执行方法是否成功，都必须释放连接

具体实现：
1、绕过SSL认证
https利用SSL/TLS建立全信道，加密数据包。HTTPS使用的主要目的是提供对网站服务器的身份认证，同时保护交换数据的隐私与完整性。相对于http协议，Https协议多了一个SSL证书认证。在使用java进行https请求时需要绕过SSL证书。

代码实现如下：

 /**
     * 绕过验证SSL证书
     */
    private static CloseableHttpClient getCloseableHttpClient(String httpUrl){
        CloseableHttpClient client = null;
        if(httpUrl.split(":")[0].equals("https"))
            {
            try{
                SSLContext sslContext;
                sslContext = SSLContextBuilder.create().useProtocol(SSLConnectionSocketFactory.SSL).loadTrustMaterial((x, y)->true).build();
                RequestConfig config = RequestConfig.custom().setConnectTimeout(10000).setSocketTimeout(10000).build();
                client = HttpClientBuilder.create().setDefaultRequestConfig(config).setSSLContext(sslContext).setSSLHostnameVerifier((x, y)->true).build();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        else if("http".equals(httpUrl.split(":")[0])){
            client = HttpClients.createDefault();
        }else {
            System.out.println("http链接输入错误");
        }
        return client;
    }

2、带token的Get请求.

/**
     *  带token的get方法
     */
    public static String httpGet(String httpUrl, String token) {
        String result = "";
        try {
            CloseableHttpClient client = null;
            CloseableHttpResponse response = null;
            try {
                client = getCloseableHttpClient(httpUrl);
                HttpGet httpGet = new HttpGet(httpUrl);
                if (!token.isEmpty()) {
                    httpGet.setHeader("token", token);
                }
                response = client.execute(httpGet);
                HttpEntity entity = response.getEntity();
                result = EntityUtils.toString(entity);
            } finally {
                if (response != null) {
                    response.close();
                }
                if (client != null) {
                    client.close();
                }
            }
        }
            catch (Exception e) {
                e.printStackTrace();
            }
            return result;
    }

3、带Json格式的post请求并返回token值和cookie值,用于登录请求.

 /**
     * 带Json格式参数传入post方法
     * 并获取token和带cookie，一般用于登录
     */
    public static Map<String ,String > httpPostJsonSetCookie(String httpUrl, String jsonString){
        Map<String ,String> map = new HashMap<>();
        map.clear();
        try{
            CloseableHttpClient client = null;
            CloseableHttpResponse response = null;
            try{
                client = getCloseableHttpClient(httpUrl);
                HttpPost httpPost = new HttpPost(httpUrl);
                StringEntity se = new StringEntity(jsonString,"UTF-8");
                httpPost.setEntity(se);
                httpPost.setHeader(HTTP.CONTENT_TYPE,"application/json");

                response = client.execute(httpPost);
                HttpEntity entity = response.getEntity();
                map.put("ResponseResult",EntityUtils.toString(entity));

                Header[] headerArray = response.getAllHeaders();
                for (Header header:headerArray){
                    if("Set-Cookie".equals(header.getName())){
                        map.put("Cookie",header.getValue().split(";")[0]);
                        break;
                    }else if("token".equals(header.getName())){
                        map.put("token",header.getValue().split(";")[0]);
                        break;
                    }
                    else {
                        continue;
                    }
                }
            }finally {
                if (response != null) {
                    response.close();
                }
                if (client != null) {
                    client.close();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return map;
    }

4、带token值得post请求.

/**
     * 带Json格式参数传入post方法
     * 带token和不带cookie
     */
    public static String httpPostJson(String httpUrl, String jsonString, String token){
        String result = "";
        try{
            CloseableHttpClient client = null;
            CloseableHttpResponse response = null;
            try{
                client = getCloseableHttpClient(httpUrl);
                HttpPost httpPost = new HttpPost(httpUrl);
                StringEntity se = new StringEntity(jsonString,"UTF-8");
                httpPost.setEntity(se);
                httpPost.setHeader(HTTP.CONTENT_TYPE,"application/json");
                if(!token.isEmpty()) {
                    httpPost.setHeader("token", token);
                }

                response = client.execute(httpPost);
                HttpEntity entity = response.getEntity();
                result = EntityUtils.toString(entity);
            }finally {
                if (response != null) {
                    response.close();
                }
                if (client != null) {
                    client.close();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }

5、带token值得Delete请求.

/**
     * 带token和cookie的删除delete请求
     */
    public static class HttpDeleteWithBody extends HttpEntityEnclosingRequestBase{
        public static final String METHOD_NAME = "DELETE";
        @Override
        public String getMethod(){
            return METHOD_NAME;
        }
        public HttpDeleteWithBody(final String httpUrl){
            super();
            setURI(URI.create(httpUrl));
        }
        public HttpDeleteWithBody(final URI httpUrl){
            super();
            setURI(httpUrl);
        }
        public HttpDeleteWithBody(){
            super();
        }
    }

    public static String httpDelete(String httpUrl,String jsonString,String token,String cookie) {
        String result = "";
        try{
            //创建内置httpClient对象
            CloseableHttpClient client = null;
            CloseableHttpResponse response = null;

            try {
                //创建Delete请求对象
                client = getCloseableHttpClient(httpUrl);
                HttpDeleteWithBody httpDelete = new HttpDeleteWithBody(httpUrl);
                //添加Delete请求头
                httpDelete.setHeader(HTTP.CONTENT_TYPE, "application/json");
                if (!token.isEmpty() && !cookie.isEmpty()) {
                    httpDelete.setHeader("token", token);
                    httpDelete.setHeader("Cookie", cookie);
                }
                //设置请求实体
                StringEntity se = new StringEntity(jsonString, "UTF-8");
                httpDelete.setEntity(se);

                response = client.execute(httpDelete);
                HttpEntity entity = response.getEntity();
                result = EntityUtils.toString(entity);
            } finally {
                if (client != null) {
                    client.close();
                }
                if (response != null) {
                    response.close();
                }
            }
        }catch(Exception e)
    {
        e.printStackTrace();
    }
        return result;
    }

附录：完整代码：
依赖jar包：点击获取

import javax.net.ssl.SSLContext;


import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.ssl.SSLContextBuilder;
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.protocol.HTTP;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;


public class HttpRequest {
    /**
     * 绕过验证SSL证书
     */
    private static CloseableHttpClient getCloseableHttpClient(String httpUrl){
        CloseableHttpClient client = null;
        if(httpUrl.split(":")[0].equals("https"))
            {
            try{
                SSLContext sslContext;
                sslContext = SSLContextBuilder.create().useProtocol(SSLConnectionSocketFactory.SSL).loadTrustMaterial((x, y)->true).build();
                RequestConfig config = RequestConfig.custom().setConnectTimeout(10000).setSocketTimeout(10000).build();
                client = HttpClientBuilder.create().setDefaultRequestConfig(config).setSSLContext(sslContext).setSSLHostnameVerifier((x, y)->true).build();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        else if("http".equals(httpUrl.split(":")[0])){
            client = HttpClients.createDefault();
        }else {
            System.out.println("http链接输入错误");
        }
        return client;
    }

    /**
     *  带token的get方法
     */
    public static String httpGet(String httpUrl, String token) {
        String result = "";
        try {
            CloseableHttpClient client = null;
            CloseableHttpResponse response = null;
            try {
                client = getCloseableHttpClient(httpUrl);
                HttpGet httpGet = new HttpGet(httpUrl);
                if (!token.isEmpty()) {
                    httpGet.setHeader("token", token);
                }
                response = client.execute(httpGet);
                HttpEntity entity = response.getEntity();
                result = EntityUtils.toString(entity);
            } finally {
                if (response != null) {
                    response.close();
                }
                if (client != null) {
                    client.close();
                }
            }
        }
            catch (Exception e) {
                e.printStackTrace();
            }
            return result;
    }

    /**
     * 带token值和Cookie值得Get请求方法
     */
    public static String httpGet(String httpUrl,String token,String cookie){
        String result = "";
        try {
            CloseableHttpClient client = null;
            CloseableHttpResponse response = null;
            try {
                client = getCloseableHttpClient(httpUrl);
                HttpGet httpGet = new HttpGet(httpUrl);
                if (!token.isEmpty()) {
                    httpGet.setHeader("token", token);
                    httpGet.setHeader("Cookie", cookie);
                }
                response = client.execute(httpGet);
                HttpEntity entity = response.getEntity();
                result = EntityUtils.toString(entity);
            } finally {
                if (response != null) {
                    response.close();
                }
                if (client != null) {
                    response.close();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 带Json格式参数传入post方法
     * 并获取token和带cookie，一般用于登录
     */
    public static Map<String ,String > httpPostJsonSetCookie(String httpUrl, String jsonString){
        Map<String ,String> map = new HashMap<>();
        map.clear();
        try{
            CloseableHttpClient client = null;
            CloseableHttpResponse response = null;
            try{
                client = getCloseableHttpClient(httpUrl);
                HttpPost httpPost = new HttpPost(httpUrl);
                StringEntity se = new StringEntity(jsonString,"UTF-8");
                httpPost.setEntity(se);
                httpPost.setHeader(HTTP.CONTENT_TYPE,"application/json");

                response = client.execute(httpPost);
                HttpEntity entity = response.getEntity();
                map.put("ResponseResult",EntityUtils.toString(entity));

                Header[] headerArray = response.getAllHeaders();
                for (Header header:headerArray){
                    if("Set-Cookie".equals(header.getName())){
                        map.put("Cookie",header.getValue().split(";")[0]);
                        break;
                    }else if("token".equals(header.getName())){
                        map.put("token",header.getValue().split(";")[0]);
                        break;
                    }
                    else {
                        continue;
                    }
                }
            }finally {
                if (response != null) {
                    response.close();
                }
                if (client != null) {
                    client.close();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return map;
    }

    /**
     * 带Json格式参数传入post方法
     * 不带token和cookie
     */
    public static String httpPostJson(String httpUrl, String jsonString){
        String result = "";
        try{
            CloseableHttpClient client = null;
            CloseableHttpResponse response = null;
            try{
                client = getCloseableHttpClient(httpUrl);
                HttpPost httpPost = new HttpPost(httpUrl);
                StringEntity se = new StringEntity(jsonString,"UTF-8");
                httpPost.setEntity(se);
                httpPost.setHeader(HTTP.CONTENT_TYPE,"application/json");

                response = client.execute(httpPost);
                HttpEntity entity = response.getEntity();
                result = EntityUtils.toString(entity);
            }finally {
                if (response != null) {
                    response.close();
                }
                if (client != null) {
                    client.close();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }



    /**
     * 带Json格式参数传入post方法
     * 带token和不带cookie
     */
    public static String httpPostJson(String httpUrl, String jsonString, String token){
        String result = "";
        try{
            CloseableHttpClient client = null;
            CloseableHttpResponse response = null;
            try{
                client = getCloseableHttpClient(httpUrl);
                HttpPost httpPost = new HttpPost(httpUrl);
                StringEntity se = new StringEntity(jsonString,"UTF-8");
                httpPost.setEntity(se);
                httpPost.setHeader(HTTP.CONTENT_TYPE,"application/json");
                if(!token.isEmpty()) {
                    httpPost.setHeader("token", token);
                }

                response = client.execute(httpPost);
                HttpEntity entity = response.getEntity();
                result = EntityUtils.toString(entity);
            }finally {
                if (response != null) {
                    response.close();
                }
                if (client != null) {
                    client.close();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 带Json格式参数传入post方法
     * 带token和cookie
     */
    public static String httpPostJson(String httpUrl, String jsonString, String token, String cookie){
        String result = "";
        try{
            CloseableHttpClient client = null;
            CloseableHttpResponse response = null;
            try{
                client = getCloseableHttpClient(httpUrl);
                HttpPost httpPost = new HttpPost(httpUrl);
                StringEntity se = new StringEntity(jsonString,"UTF-8");
                httpPost.setEntity(se);
                httpPost.setHeader(HTTP.CONTENT_TYPE,"application/json");
                if(!token.isEmpty() && !cookie.isEmpty()) {
                    httpPost.setHeader("token", token);
                    httpPost.setHeader("Cookie", cookie);
                }

                response = client.execute(httpPost);
                HttpEntity entity = response.getEntity();
                result = EntityUtils.toString(entity);
            }finally {
                if (response != null) {
                    response.close();
                }
                if (client != null) {
                    client.close();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }

    /**
     * param格式参数传入post方法
     * 带token
     */
    public static String httpPostParam(String httpUrl, String token){
        String result = "";
        try{
            CloseableHttpClient client = null;
            CloseableHttpResponse response = null;
            try{
                client = getCloseableHttpClient(httpUrl);
                HttpPost httpPost = new HttpPost(httpUrl);

                if(!token.isEmpty()) {
                    httpPost.setHeader("token",token);
                }

                response = client.execute(httpPost);
                HttpEntity entity = response.getEntity();
                result = EntityUtils.toString(entity);
            }finally {
                if (response != null) {
                    response.close();
                }
                if (client != null) {
                    client.close();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }

    /**
     * param格式参数传入post方法
     * 带token和cookie
     */
    public static String httpPostParam(String httpUrl, String token,String cookie){
        String result = "";
        try{
            CloseableHttpClient client = null;
            CloseableHttpResponse response = null;
            try{
                client = getCloseableHttpClient(httpUrl);
                HttpPost httpPost = new HttpPost(httpUrl);

                if(!token.isEmpty() && !cookie.isEmpty()) {
                    httpPost.setHeader("token",token);
                    httpPost.setHeader("Cookie",cookie);
                }

                response = client.execute(httpPost);
                HttpEntity entity = response.getEntity();
                result = EntityUtils.toString(entity);
            }finally {
                if (response != null) {
                    response.close();
                }
                if (client != null) {
                    client.close();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 带token和cookie的删除delete请求
     */
    public static class HttpDeleteWithBody extends HttpEntityEnclosingRequestBase{
        public static final String METHOD_NAME = "DELETE";
        @Override
        public String getMethod(){
            return METHOD_NAME;
        }
        public HttpDeleteWithBody(final String httpUrl){
            super();
            setURI(URI.create(httpUrl));
        }
        public HttpDeleteWithBody(final URI httpUrl){
            super();
            setURI(httpUrl);
        }
        public HttpDeleteWithBody(){
            super();
        }
    }

    public static String httpDelete(String httpUrl,String jsonString,String token,String cookie) {
        String result = "";
        try{
            //创建内置httpClient对象
            CloseableHttpClient client = null;
            CloseableHttpResponse response = null;

            try {
                //创建Delete请求对象
                client = getCloseableHttpClient(httpUrl);
                HttpDeleteWithBody httpDelete = new HttpDeleteWithBody(httpUrl);
                //添加Delete请求头
                httpDelete.setHeader(HTTP.CONTENT_TYPE, "application/json");
                if (!token.isEmpty() && !cookie.isEmpty()) {
                    httpDelete.setHeader("token", token);
                    httpDelete.setHeader("Cookie", cookie);
                }
                //设置请求实体
                StringEntity se = new StringEntity(jsonString, "UTF-8");
                httpDelete.setEntity(se);

                response = client.execute(httpDelete);
                HttpEntity entity = response.getEntity();
                result = EntityUtils.toString(entity);
            } finally {
                if (client != null) {
                    client.close();
                }
                if (response != null) {
                    response.close();
                }
            }
        }catch(Exception e)
    {
        e.printStackTrace();
    }
        return result;
    }
}
闲小憨
关注
专栏目录
HTTP协议简介/数据包封装/三次握手/DNS解析
sunshine612的博客
04-28 3752
HTTP协议简介/数据包封装/三次握手/DNS解析1.浏览器背后的故事2.HTTP3.透过TCP/IP看HTTP4.数据包的封装过程5.传输层--TCP三次握手6.DNS域名解析DNS 域名解析协议的工作原理 递归式 迭代式7.HTTP事务处理过程实验---对于浏览器来说HTTP请求到底是什么样子 1.浏览器背后的故事 解释： 打给小红，由姓名的代号来记录， 小红就是域名，电话号就是IP地址，共同...
HTTP访问协议封装
test_touch的专栏
06-16 143
此封装类可以直接调用接口 package com.google.zxing.client.android.util; import java.io.IOException; import org.apache.http.HttpResponse; import org.apache.http.client.ClientProtocolException; import org.apac...
【应用层协议】简单的HTTP服务器 {封装Socket API；封装HTTP协议；实现HttpServer；超文本标记语言HTML；通过表单提交数据；测试Cookie机制；永久重定向和临时重定向}
最新发布
芥末虾的博客
08-20 614
【应用层协议】简单的HTTP服务器 {封装Socket API；封装HTTP协议；实现HttpServer；超文本标记语言HTML；通过表单提交数据；测试Cookie机制；永久重定向和临时重定向}
一个基于http协议的访问网络的封装类
罗朝辉（飘飘白云）
12-31 3248
转一个基于http协议的访问网络的封装类，使用时只需调用public static synchronized byte[] connect(String url, byte[] data,String method, String contentType, long lowRange, long highRange,  boolean disableProxy, boolean detache
HTTP协议封装使用说明
Angle_sister的博客
12-23 1368
initHomeHttp package com.example.smartcity.http; import android.content.Context; import android.os.Handler; import android.os.Message; import android.util.Log; import com.example.smartcity.info.GetPersonInfo; import com.example.smartcity.info.HomeRotatio
基于libevent自定义封装的函数接口(启动http服务器、启动事件服务等)
12-22
libevent_api：是基于libevent自定义封装的函数接口(启动http服务器、启动事件服务等) 运行 http服务器demo：（http服务器可使用postman软件测试，在电脑上给服务器发送请求） ./http_server_test 运行 定时事件...
基于c#实现MQTT协议的报文封装
04-18
总之，基于C#实现MQTT协议的报文封装是一项涉及网络编程、协议解析和事件驱动编程等多个技术层面的任务。通过这样的实践，开发者可以更好地理解和控制物联网设备的通信过程，同时也能锻炼自己的编程技能。
CrossWalkDemo:基于crosswalk，实现简单封装，以及自定义通信协议
05-02
说明：在本SDK内，可自定义多种协议，以及专属的解析方式，如无特殊要求，则使用默认的协议 -- codvision 一、协议组织方式 协议是按照一定规范组织行程的字符串 本SDK采用协议形式为Uri形式 协议组织格式： [scheme...
Android基于Http协议实现文件上传功能的方法
01-20
通过以上步骤，Android应用能够实现基于HTTP协议的文件上传功能。需要注意的是，实际项目中可能会使用更高级的库来处理网络请求，如`Retrofit`或`OkHttp`，它们提供了更方便的API来处理文件上传，并且性能更优。同时...
pythonsocket自定义协议_python爬虫最为核心的HTTP协议解析，及自定义协议的分析...
weixin_39837607的博客
12-04 327
机器之间的协议就是机器通信的语法，只有按照这种语法发来的信息，机器之间才能相互理解内容，也可以理解为信息的一种格式。HTTP/IP协议是互联网最为重要的协议，没有HTTP/IP协议，也就没有互联跟不会有网，对于爬虫而言一切数据、请求都是围绕HTTP协议展开。但是在python实现的网络爬虫中都是使用封装好了的请求库如：requests、scrapy、urllib等，这些是对socket的封装，而s...
【网络】http自定制协议
zhaocx111222333的博客
07-14 321
1 #include <cstdio> ...
Http传输协议（包含对get和post请求的封装）
weixin_44409569的博客
05-01 1613
get和post传参，入参封装，携带参数传值区别
HTTP协议数据封装模型
yan_xiaobo的博客
11-19 2091
一、HTTP之Request:   格式如下图所示：   参数说明： 请求方法：POST/GET URL:      以http://inanter.com/login?user=yxb&amp;pwd=1234为例，只写inanter.com后面的字符串（官方叫作虚拟路径），前面的部分作为请求头HOST字段的值，其中HOST字段为请求头当中的必须字段。如果存在端口信息，也写在此字...
http封装
developer_yk的博客
08-01 292
//基于系统的NSURLConnection的封装，暂时没有加入缓存 public enum HttpMethod: String {    case GET = "GET"    case POST = "POST"    case PUT = "PUT"    case DELETE = "DELETE"      } class HttpConnect
对http协议的应用层封装实现
Tryturned
02-15 1019
简单讲述了基于http协议请求和响应报文设计的请求和响应报文数据结构，以及在缓存基础上的解码和编码操作。最后讨论了请求报文的get和post的区别。代码基于C语言实现。
http协议介绍_Request_Response_自定义套接字分析http协议
qq_31455841的博客
09-20 378
HTTP 协议 1. http协议简介 1. 互联网 互联网 = 物理连接介质 + 互联网协议 2. 互联网建立的目的 数据传输打破地域限制 (否则的话，我想获得对方主机上的数据，只能拿着硬盘去对方主机拷贝) 3. 什么是上网 用户上网的过程即浏览器向服务端发送请求，然后将服务端主机的文本文件下载到本地显示的过程。而浏览器与服务器之间走的HTTP协议 我们学习前端开发就是为了编排好一个文本文件存放到服务端主机，然后提供给浏览器下载显示的，所以在学习前端开发前，我们必须先研究HTTP协议 4
关于http网络通信数据包封装的过程
探测???
09-25 1138
当我们谈论网络通信时，数据在从源到目的地传输的过程中会通过多层网络协议。在每一层，都会添加一些头信息（和有时尾信息）来帮助处理和传输数据。这个过程被称为"封装"（Encapsulation）。简单来说，封装就是在当前层的数据前（和/或后）添加该层协议所需的头（和/或尾）信息。这个封装的过程允许每层协议独立地工作，而不需要知道其他层的具体细节。在数据到达目的地后，每层协议的头信息会被相应的协议处理，并逐层解封装，最终将应用层数据（HTTP请求）交给目标应用（例如，Web服务器）。
【web server】HTTP协议如何解析or封装
gaoyuelong的博客
09-13 346
状态机解析封装HTTP协议整体思路流程。
基于click自定义协议的软件路由器设计与实现详解
本文档详细介绍了如何基于click开源框架设计并实现一个自定义协议的软件路由器。click是一个灵活的网络处理框架，特别适合用于构建高性能的网络应用，如路由器和交换机。实验的目的是通过实践加深对软件路由器工作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

闲小憨

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值