使用multipart/form-data格式传送数据

最新推荐文章于 2024-06-28 14:40:16 发布
最新推荐文章于 2024-06-28 14:40:16 发布
阅读量1k 收藏 1
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65011645/article/details/132717645
版权

1导入依赖

      <dependency>
                <groupId>org.apache.httpcomponents</groupId>
                <artifactId>httpcore</artifactId>
                <version>4.4.14</version>
            </dependency>
            <dependency>
                <groupId>org.apache.httpcomponents</groupId>
                <artifactId>httpmime</artifactId>
                <version>4.5.13</version>
            </dependency>

2.编写工具类并调用其中的方法

package com.sgwl.warehouse.util.tool;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.sun.el.lang.FunctionMapperFactory;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.*;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.MultipartEntity;
import org.apache.http.entity.mime.content.StringBody;
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.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.*;

/**
 * HttpClient工具类
 * httpclient.jar
 */
@Slf4j
public class HttpClientUtil {



    //编码格式
    private static final String ENCODING = "UTF-8";

    //连接超时时间（毫秒）
    private static final int CONNECT_TIMEOUT = 2000;

    //响应时间（毫秒）
    private static final int SOCKET_TIMEOUT = 2000;

    /**
     * 发送get请求（不含header不含参数）
     *
     * @param url
     * @return
     * @throws Exception
     */
    public static HttpClientModel doGet(String url) throws Exception {
        return doGet(url, null, null);
    }

    /**
     * 发送post请求
     *
     * @param url        路径
     * @param jsonObject 参数(json类型)
     * @return
     * @throws
     * @throws IOException
     */
    public static String send(String url, JSONObject jsonObject) {
        String body = "";

        //创建httpclient对象
        CloseableHttpClient client = HttpClients.createDefault();
        //创建post方式请求对象
        HttpPost httpPost = new HttpPost(url);

        //装填参数
        StringEntity s = new StringEntity(jsonObject.toString(), "utf-8");
        s.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE,
                "application/json"));
        //设置参数到请求对象中
        httpPost.setEntity(s);
        System.out.println("请求地址：" + url);

        //设置header信息
        //指定报文头【Content-type】
        httpPost.setHeader("Content-type", "application/x-www-form-urlencoded");
        //执行请求操作，并拿到结果（同步阻塞）
        CloseableHttpResponse response = null;
        try {
            response = client.execute(httpPost);
            HttpEntity entity = response.getEntity();
            if (entity != null) {
                //按指定编码转换结果实体为String类型
                body = EntityUtils.toString(entity, "utf-8");
            }
            EntityUtils.consume(entity);
            //释放链接
            response.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //获取结果实体
        return body;
    }

    public static JSONObject dopostFor(String url, JSONObject param) {
        //定义接收数据
        JSONObject result = new JSONObject();
        HttpPost httpPost = new HttpPost(url);
        CloseableHttpClient client = HttpClients.createDefault();
        //请求参数转JOSN字符串
        StringEntity entity = new StringEntity(param.toString(), "UTF-8");
        entity.setContentEncoding("UTF-8");
        entity.setContentType("application/json");
        httpPost.setEntity(entity);
//        if (param.toString().length() <= 200) {
//            log.info("HttpClientUtil.doPost.url：{}||param：{}", url, param);
//        }
        try {
            HttpResponse response = client.execute(httpPost);
            if (response.getStatusLine().getStatusCode() == 200) {
                result = JSON.parseObject(EntityUtils.toString(response.getEntity(), "UTF-8"));
            }
        } catch (IOException e) {
            log.info("HttpClientUtil.doPost.url：{}||result：{}", url, result);
            e.printStackTrace();
            result.put("code", "500");
            result.put("error", "连接错误！");
        }
        return result;
    }

    public static JSONObject dopost(String url, JSONObject param) {
        //定义接收数据
        JSONObject result = new JSONObject();
        HttpPost httpPost = new HttpPost(url);
        CloseableHttpClient client = HttpClients.createDefault();
        //请求参数转JOSN字符串
        StringEntity entity = new StringEntity(param.toString(), "UTF-8");
        entity.setContentEncoding("UTF-8");
        entity.setContentType("application/json");
        httpPost.setEntity(entity);
        if (param.toString().length() <= 200) {
            log.info("HttpClientUtil.doPost.url：{}||param：{}", url, param);
        }
        try {
            HttpResponse response = client.execute(httpPost);
            if (response.getStatusLine().getStatusCode() == 200) {
                result = JSON.parseObject(EntityUtils.toString(response.getEntity(), "UTF-8"));
            }
            log.info("HttpClientUtil.doPost.url：{}||result：{}", url, result);
        } catch (IOException e) {
            log.info("HttpClientUtil.doPost.url：{}", url, e);
            result.put("code", "500");
            result.put("error", "连接错误！");
        }
        return result;
    }

    public static JSONObject dopostForm1(String url, JSONObject param) {
        JSONObject result = new JSONObject();

        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
            HttpPost httpPost = new HttpPost(url);

            MultipartEntity entity = new MultipartEntity();

            for (String key : param.keySet()) {
                String value = param.getString(key);
                entity.addPart(key, new StringBody(value, ContentType.TEXT_PLAIN));
            }

            httpPost.setEntity(entity);

            HttpResponse response = httpClient.execute(httpPost);

            if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                String responseBody = EntityUtils.toString(response.getEntity());
                result = JSON.parseObject(responseBody);
            }

            log.info("HttpClientUtil.doPost.url：{}||result：{}", url, result);
        } catch (IOException e) {
            e.printStackTrace();
            result.put("code", "500");
            result.put("error", "连接错误！");
        }

        return result;
    }



    public static JSONObject dopostForm(String url, JSONObject param) {
        //定义接收数据
        JSONObject result = new JSONObject();
        HttpPost httpPost = new HttpPost(url);
        CloseableHttpClient client = HttpClients.createDefault();
        //请求参数转JOSN字符串
        StringEntity entity = new StringEntity(param.toString(), "UTF-8");
        entity.setContentEncoding("UTF-8");
        entity.setContentType("multipart/form-data; boundary=<calculated when request is sent>");
        httpPost.setEntity(entity);
//        String boundary = "YOUR_BOUNDARY_VALUE"; // 用自定义的边界标识符替换 YOUR_BOUNDARY_VALUE
//        entity.setContentType("multipart/form-data; boundary=" + boundary);
        if (param.toString().length() <= 200) {
            log.info("HttpClientUtil.doPost.url：{}||param：{}", url, param);
        }
        try {
            HttpResponse response = client.execute(httpPost);
            if (response.getStatusLine().getStatusCode() == 200) {
                result = JSON.parseObject(EntityUtils.toString(response.getEntity(), "UTF-8"));
            }
            log.info("HttpClientUtil.doPost.url：{}||result：{}", url, result);
        } catch (IOException e) {
            e.printStackTrace();
            result.put("code", "500");
            result.put("error", "连接错误！");
        }
        return result;
    }



    /**
     * 发送get请求（不含header含参数）
     *
     * @param url
     * @param param
     * @return
     * @throws Exception
     */
    public static HttpClientModel doGet(String url, Map<String, String> param) throws Exception {
        return doGet(url, null, param);
    }

    /**
     * 发送get请求（含header含参数）
     *
     * @param url
     * @param header
     * @param param
     * @return
     * @throws Exception
     */
    public static HttpClientModel doGet(String url, Map<String, String> header, Map<String, String> param) throws Exception {
        CloseableHttpClient closeableHttpClient = HttpClients.createDefault();
        URIBuilder uriBuilder = new URIBuilder(url);
        if (param != null) {
            Set<Map.Entry<String, String>> entrySet = param.entrySet();
            for (Map.Entry<String, String> entry : entrySet) {
                uriBuilder.setParameter(entry.getKey(), entry.getValue());
            }
        }
        HttpGet httpGet = new HttpGet(uriBuilder.build());
        RequestConfig requestConfig = RequestConfig
                .custom()
                .setConnectTimeout(CONNECT_TIMEOUT)
                .setSocketTimeout(SOCKET_TIMEOUT)
                .build();
        httpGet.setConfig(requestConfig);
        /**
         * 封装header
         */
        packageHeader(header, httpGet);
        CloseableHttpResponse closeableHttpResponse = null;
        try {
            /**
             * 发送请求获取响应
             */
            return getHttpClientResult(closeableHttpResponse, closeableHttpClient, httpGet);
        } finally {
            /**
             * 关闭资源
             */
            close(closeableHttpResponse, closeableHttpClient);
        }
    }

    /**
     * 发送post请求（不含header不含参数）
     *
     * @param url
     * @return
     * @throws Exception
     */
    public static HttpClientModel doPost(String url) throws Exception {
        return doPost(url, null, null);
    }



    /**
     * 发送post请求（含header不含参数）
     *
     * @param url
     * @param param
     * @return
     * @throws Exception
     */
    public static HttpClientModel doPost(String url, Map<String, String> param) throws Exception {
        return doPost(url, null, param);
    }

    /**
     * 发送post请求（含header含参数）
     *
     * @param url
     * @param header
     * @param param
     * @return
     * @throws Exception
     */
    public static HttpClientModel doPost(String url, Map<String, String> header, Map<String, String> param) throws Exception {
        CloseableHttpClient closeableHttpClient = HttpClients.createDefault();
        HttpPost httpPost = new HttpPost(url);
        RequestConfig requestConfig = RequestConfig
                .custom()
                .setConnectTimeout(CONNECT_TIMEOUT)
                .setSocketTimeout(SOCKET_TIMEOUT)
                .build();
        httpPost.setConfig(requestConfig);
        /**
         * 设置header
         */
//		httpPost.setHeader("Cookie", "");
        httpPost.setHeader("Connection", "keep-alive");
        httpPost.setHeader("Accept", "application/json");
//		httpPost.setHeader("Accept-Language", "zh-CN,zh;q=0.9");
        httpPost.setHeader("Accept-Encoding", "gzip, deflate, br");
//		httpPost.setHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36");
        /**
         * 封装header
         */
        packageHeader(header, httpPost);
        /**
         * 封装参数
         */
        packageParam(param, httpPost);
        CloseableHttpResponse closeableHttpResponse = null;
        try {
            /**
             * 发送请求获取响应
             */
            return getHttpClientResult(closeableHttpResponse, closeableHttpClient, httpPost);
        } finally {
            /**
             * 关闭资源
             */
            close(closeableHttpResponse, closeableHttpClient);
        }
    }

    /**
     * 发送put请求（不含header不含参数）
     *
     * @param url
     * @return
     * @throws Exception
     */
    public static HttpClientModel doPut(String url) throws Exception {
        return doPut(url);
    }

    /**
     * 发送put请求（不含header含参数）
     *
     * @param url
     * @param param
     * @return
     * @throws Exception
     */
    public static HttpClientModel doPut(String url, Map<String, String> param) throws Exception {
        CloseableHttpClient closeableHttpClient = HttpClients.createDefault();
        HttpPut httpPut = new HttpPut(url);
        RequestConfig requestConfig = RequestConfig
                .custom()
                .setConnectTimeout(CONNECT_TIMEOUT)
                .setSocketTimeout(SOCKET_TIMEOUT)
                .build();
        httpPut.setConfig(requestConfig);
        /**
         * 封装参数
         */
        packageParam(param, httpPut);
        CloseableHttpResponse closeableHttpResponse = null;
        try {
            /**
             * 发送请求获取响应
             */
            return getHttpClientResult(closeableHttpResponse, closeableHttpClient, httpPut);
        } finally {
            /**
             * 关闭资源
             */
            close(closeableHttpResponse, closeableHttpClient);
        }
    }

    /**
     * 发送delete请求（不含header不含参数）
     *
     * @param url
     * @return
     * @throws Exception
     */
    public static HttpClientModel doDelete(String url) throws Exception {
        CloseableHttpClient closeableHttpClient = HttpClients.createDefault();
        HttpDelete httpDelete = new HttpDelete(url);
        RequestConfig requestConfig = RequestConfig
                .custom()
                .setConnectTimeout(CONNECT_TIMEOUT)
                .setSocketTimeout(SOCKET_TIMEOUT)
                .build();
        httpDelete.setConfig(requestConfig);
        CloseableHttpResponse closeableHttpResponse = null;
        try {
            /**
             * 发送请求获取响应
             */
            return getHttpClientResult(closeableHttpResponse, closeableHttpClient, httpDelete);
        } finally {
            /**
             * 关闭资源
             */
            close(closeableHttpResponse, closeableHttpClient);
        }
    }

    /**
     * 发送delete请求（不含header含参数）
     *
     * @param url
     * @param param
     * @return
     * @throws Exception
     */
    public static HttpClientModel doDelete(String url, Map<String, String> param) throws Exception {
        if (null == param) {
            param = new HashMap<String, String>();
        }
        param.put("_method", "delete");
        return doPost(url, param);
    }

    /**
     * 封装header
     *
     * @param param
     * @param httpRequestBase
     */
    public static void packageHeader(Map<String, String> param, HttpRequestBase httpRequestBase) {
        if (param != null) {
            Set<Map.Entry<String, String>> entrySet = param.entrySet();
            for (Map.Entry<String, String> entry : entrySet) {
                httpRequestBase.setHeader(entry.getKey(), entry.getValue());
            }
        }
    }

    /**
     * 封装参数
     *
     * @param param
     * @param httpEntityEnclosingRequestBase
     * @throws Exception
     */
    public static void packageParam(Map<String, String> param, HttpEntityEnclosingRequestBase httpEntityEnclosingRequestBase) throws Exception {
        if (param != null) {
            List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
            Set<Map.Entry<String, String>> entrySet = param.entrySet();
            for (Map.Entry<String, String> entry : entrySet) {
                nameValuePairs.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
            }
            httpEntityEnclosingRequestBase.setEntity(new UrlEncodedFormEntity(nameValuePairs, ENCODING));
        }
    }

    /**
     * 获取响应
     *
     * @param closeableHttpResponse
     * @param closeableHttpClient
     * @param httpRequestBase
     * @return
     * @throws Exception
     */
    public static HttpClientModel getHttpClientResult(CloseableHttpResponse closeableHttpResponse
            , CloseableHttpClient closeableHttpClient
            , HttpRequestBase httpRequestBase) throws Exception {
        closeableHttpResponse = closeableHttpClient.execute(httpRequestBase);
        if (closeableHttpResponse != null && closeableHttpResponse.getStatusLine() != null) {
            String content = "";
            if (closeableHttpResponse.getEntity() != null) {
                content = EntityUtils.toString(closeableHttpResponse.getEntity(), ENCODING);
            }
            return new HttpClientModel(closeableHttpResponse.getStatusLine().getStatusCode(), content);
        }
        return new HttpClientModel(HttpStatus.SC_INTERNAL_SERVER_ERROR);
    }

    /**
     * 关闭资源
     *
     * @param closeableHttpResponse
     * @param closeableHttpClient
     * @throws Exception
     */
    public static void close(CloseableHttpResponse closeableHttpResponse, CloseableHttpClient closeableHttpClient) throws Exception {
        if (closeableHttpResponse != null) {
            closeableHttpResponse.close();
        }
        if (closeableHttpClient != null) {
            closeableHttpClient.close();
        }
    }
}

其中使用的是

   public static JSONObject dopostForm1(String url, JSONObject param) {
        JSONObject result = new JSONObject();

        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
            HttpPost httpPost = new HttpPost(url);

            MultipartEntity entity = new MultipartEntity();

            for (String key : param.keySet()) {
                String value = param.getString(key);
                entity.addPart(key, new StringBody(value, ContentType.TEXT_PLAIN));
            }

            httpPost.setEntity(entity);

            HttpResponse response = httpClient.execute(httpPost);

            if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                String responseBody = EntityUtils.toString(response.getEntity());
                result = JSON.parseObject(responseBody);
            }

            log.info("HttpClientUtil.doPost.url：{}||result：{}", url, result);
        } catch (IOException e) {
            e.printStackTrace();
            result.put("code", "500");
            result.put("error", "连接错误！");
        }

        return result;
    }
    @Override
    public JSONObject outOrderConfirm(String id, String[] rfIds) throws UnsupportedEncodingException {
        JSONObject param = new JSONObject();
        param.put("id", id);
        param.put("rfids", rfIds);

        return HttpClientUtil
                .dopostForm1(outEsIcBaseUrl + "ic/outOrderConfirm", param);
    }

上九天揽月347
关注
multipart form-data boundary 说明
oscar999的专栏
09-01 1万+
含义 ENCTYPE="multipart/form-data" 说明： 通过 http 协议上传文件 rfc1867协议概述，jsp 应用举例，客户端发送内容构造1、概述在最初的 http 协议中，没有上传文件方面的功能。 rfc1867(http://www.ietf.org/rfc/rfc1867.txt) 为 http 协议添加了这个功能。客户端的浏
html url传递数组,AFNetworking 使用multipart/form-data方式传数组
weixin_40001634的博客
07-20 817
文章结构1.http客户端常用的请求方式multipart/form-data传数组各个终端的实现方式以及后台怎么处理拿到的数据2.1 web端2.2 安卓端(OKHTTP)2.3 苹果端(AFNetworking)2.4 后台处理拿到的数据一、http请求常用的两种方式post/getHTTP请求方式有OPTIONS、GET、HEAD、POST、PUT、DELETE、TRACE、CONNECT通...
C#使用multipart/form-data示例
12-27
c#没有现成的multipart/form-data库，自己封的一个demo供参考。
WebAPIFileUploadDemo通过multipart/form-data方式同时上传文件以及数据包含客户端上传例子
07-23
WebAPI通过multipart/form-data方式同时上传文件以及数据包含客户端上传例子
PostMan提交file报错Content type ‘multipart/form-data；boundary=--------------------------94360607693488
最新发布
demoxp的博客
06-28 1052
这个报错通常发生在Spring框架中，当后端接口没有正确配置以支持类型的请求时。通常用于文件上传，其中请求体的格式包含了一个或多个文件，而不是普通的表单数据。
multipart/form-data格式接口调用工具类，实现文件上传
qq_44299529的博客
05-10 2162
multipart/form-data格式接口调用工具类
PHP curl post multipart/form-data 二维数组 多维数组 文件传送 例程
LingMax的博客
12-21 1万+
PHP multipart/form-data 二维数组 多维数组 文件传送 例程  楼主费劲千辛万苦 才弄出来的  $data = array( 'name_list'=&gt; array('LingMax'=&gt;12,'lisi'=&gt;12,'zhaoer'=&gt;12), 'age_list'=&gt;array('16','14','19'), 'name'=&g...
Content-Type: multipart/form-data; boundary=${bound} 及Postman请求例子
水逆呱的博客
01-17 1万+
Content-Type/MediaType/Internet Media Type，互联网媒体类型；也叫做MIME类型，在Http协议消息头中，使用Content-Type来表示具体请求中的媒体类型信息。 1.multipart/form-data 需要在表单中进行文件上传时，就需要使用该格式。 根据Http/1.1 （RFC 2616）的协议规定，我们的请求方式只有OPTIONS、G...
node基于“multipart / form-data“转发表单上传文件到后台
wen_j的博客
04-01 4238
过程： 后台（go）+ 中间（node）+前端（vue） 使用node进行中间层转发，前端使用form-data进行数据上传，传递给node，node使用form-data将数据传给后端（go） 前端上传excel 页面效果： 页面布局实现：(使用elementui框架) <el-upload class="upload-demo" ref="fileupload" accep...
form data怎么接收_使用multipart/form-data实现文件的上传
weixin_39942108的博客
01-19 2424
1. Form简介Form(中文译为表单)，是HTML标记语言中的重要语法元素。一个Form不仅包含正常的文本内容、标记等，还包含被称为控件的特殊元素。用户通常通过修改控件（比如：输入文本、选择菜单项等）来“完成”表单，然后将表单数据以HTTP Get或Post请求的形式提交（submit）给Web服务器。很多初学者总是混淆HTML和HTTP。其实，http通常作为html传输的承载体，打个比方，...
多文件上传multipart/form-data
沐上云霄的博客
03-02 3786
前言 在web开发中上传文件比较简单，一个普通的post表单再加上文件类型的标签就可以完成，上传的这些工作都是交给浏览器完成。但是在客户端上传文件时就需要自己写http上传相关的参数。 多文件上传 请求头 ...... Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryMHzissskK7K82uyt 多文件上传...
浅析application/x-www-form-urlencoded和multipart/form-data的区别
10-25
而`multipart/form-data`则专门用于处理包含文件或其他复杂数据类型的表单提交，它可以确保数据的完整性，特别是对于二进制数据。因此，在编写AJAX请求或者HTML表单时，根据实际需求选择合适的编码类型至关重要，以...
Python模拟浏览器上传文件脚本的方法(Multipart/form-data格式)
09-20
Multipart/form-data格式的数据传输是通过指定"Content-Type"为"multipart/form-data"，并设置一个唯一的boundary来区分多个数据域。 3. 请求头中的Content-Type和boundary： 在进行文件上传时，请求头的"Content-...
Delphi7 multipart/form-data实现上传文件
12-26
总的来说，Delphi 7 使用 Indy 10 的 `TIdHTTP` 控件和 `TIdMultipartFormDataStream` 类可以方便地实现 `multipart/form-data` 方式的文件上传。理解这些组件的工作原理和使用方法，对于开发涉及文件交互的Web应用...
Content type ‘multipart/form-data；boundary=------57031299820747271；charset=UTF-8‘ not supported的解决方案
No8g攻城狮的博客
02-25 1万+
现象描述 org.springframework.web.HttpMediaTypeNotSupportedException: Content type 'multipart/form-data;boundary=-------------------------- 570391279993820714772271;charset=UTF-8' not supported org.sp...
【使用multipart/form-data方式传递MultipartFile参数，实现服务间文件的传递】
weixin_43744563的博客
03-17 4748
使用MultipartFile接收前端文件调取第三方接口，发送 MultipartFile 文件。
multipart/form-data; boundary=--------------------------909512080119736368446920
weixin_42607969的博客
01-13 831
"multipart/form-data; boundary=--------------------------909512080119736368446920" 是 HTTP 请求中的一种 Content-Type，它表示请求体中包含多个部分数据。"boundary" 的值是一个随机字符串，用来在请求体中分割不同的部分数据。这种 Content-Type 通常用于文件上传。 ...
python实现Content-Type: multipart/form-data； boundary=xxx接口的调用
热门推荐
qq_17328759的博客
12-28 1万+
在接口测试的过程中，会遇到一些文件上传的接口，一般我们可以读取文件后，将其作为post的一个参数，直接实现文件的上传。例如： with open('massive-body') as f: requests.post('http://some.url/streamed', data=f) 更多的时候，遇到的是及包含表单数据，也包含需要上传的文件。抓取接口，会看到接口的请求实体中有“Content-Type: multipart/form-data; boundary=xxx”，接口的表单参数样式也
表单 post 提交时的字符集编码与乱码(下)--multipart/form-data 类型
Just do IT
07-03 4634
探讨了表单以 post 方式, enctype 为 multipart/form-data 提交时数据所使用的字符集编码（包含缺省使用页面编码及设置了 accept-charset 时两种情形）, 包括了上传文件及使用中文文件名时的情况, 以及后台的接收处理.
multipart/form-data数据类型
01-11
multipart/form-data是一种常用的数据编码方式，用于在HTTP请求中传输表单数据。它将表单数据编码为一条消息，每个控件对应消息中的一个部分。这种编码方式常用于上传文件或提交包含大量文本数据的表单。 以下是一个使用multipart/form-data编码方式的示例： ```html <form action="/upload" method="post" enctype="multipart/form-data"> <input type="text" name="username"> <input type="file" name="file"> <input type="submit" value="Submit"> </form> ``` 在这个示例中，表单中包含一个文本输入框和一个文件上传控件。当用户点击提交按钮时，浏览器会将表单数据编码为multipart/form-data格式，并将其作为请求的主体部分发送到服务器。 在服务器端，可以使用相应的编程语言或框架来解析multipart/form-data格式的请求，以获取表单数据。例如，在Python中，可以使用`request.FILES`来访问上传的文件，使用`request.POST`来访问其他表单字段的值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值