精华内容
下载资源
问答
  • 10 request.getParameterNames()方法是将发送请求页面中form表单里所有具有name属性的表单对象获取(包括button).返回一个Enumeration类型的枚举. 11 12 通过Enumeration的hasMoreElements()方法遍历.再由next...
     1 protected Map<String, String> initRequestParams(HttpServletRequest request) {
     2         Map<String, String> paramMap = new HashMap<String, String>();
     3         if (request == null) {
     4             return paramMap;
     5         }
     6         Enumeration<?> paramNames = request.getParameterNames();
     7 /*
     8 Enumeration<?>代表可以传递任意类型,?是通配符即Object及其下的子类,也就是java的所有对象了。
     9 
    10 request.getParameterNames()方法是将发送请求页面中form表单里所有具有name属性的表单对象获取(包括button).返回一个Enumeration类型的枚举.
    11 
    12 通过Enumeration的hasMoreElements()方法遍历.再由nextElement()方法获得枚举的值.此时的值是form表单中所有控件的name属性的值.
    13 
    14 最后通过request.getParameter()方法获取表单控件的value值.
    15 */
    16         if (request != null && paramNames != null && paramNames.hasMoreElements()) {
    17             while (paramNames.hasMoreElements()) {
    18                 String paramName = (String) paramNames.nextElement();
    19                 String[] paramValues = request.getParameterValues(paramName);
    20 /*
    21 先获得变量mane再获得其值,对于getParameterName()其值是变量/对象的名称,getParameterValue()获得的是变量/对象的值。
    22 request.getParameterValues("name")方法将获取所有form表单中name属性为"name"的值.该方法返回一个数组.遍历数组就可得到value值.
    23 */
    24                 if (paramValues.length == 1) {
    25                     paramMap.put(paramName, paramValues[0]);
    26                 } else {
    27                     paramMap.put(paramName, ArrayUtils.toString(paramValues));
    28                 }
    29             }
    30         }
    31         return paramMap;
    32 }
    33 /*
    34 request.getParameterNames()的值是无序排列request.getParameterValues()是按照from表单的控件顺序排列.
    35 */

     

    转载于:https://www.cnblogs.com/lxl57610/p/7348378.html

    展开全文
  • 哪些类型的参数适合放在url,哪些类型的参数适合放在body 中
  • POST请求获取数组参数

    千次阅读 2018-12-01 15:43:04
    post请求参数为 json格式,json内部含有 test5的数组参数,在不进行字符串切割的情况下。如何获取数组内的值呢? springmvc请求方式 @RequestMapping(value="mytest",method=RequestMethod.POST) ...

    post请求如何获取数组参数呢?

    如post请求参数为  json格式,json内部含有 test5的数组参数,在不进行字符串切割的情况下。如何获取数组内的值呢?

    springmvc请求方式

    @RequestMapping(value="mytest",method=RequestMethod.POST)

    1.增加获取参数

    首先在请求方法中新增参数  @RequestBody     param为自定义的。

    public void   test( @RequestBody String param) {
    
    
    
    }

    2. 对象转换     将String类型 转成   json

           //对象转化
            JSONObject jsonObject = JSONObject.parseObject(param);

    3.将test5数组转成jsonArray

           

      //获取test5
            JSONArray jsonArray = jsonObject.getJSONArray("test5");

    4.jsonArray 迭代器

               

     //迭代器  子单
                Iterator<Object> jsonIterator = jsonArray.iterator();

    5. 循环获取

    while(jsonIterator.hasNext()) {
                    //获取数据并转化成JSONObject
                    JSONObject parseObject = (JSONObject) jsonIterator.next();
                    //sonOrderId1
                    String sonOrderId1= parseObject.getString("sonOrderId1");
                    //sonXml
                    String sonXml = parseObject.getString("sonXml");
    
    }

     

    6.总的代码

    public void   test( @RequestBody String param) {
    
           //对象转化
            JSONObject jsonObject = JSONObject.parseObject(param);
    
            //获取test5
            JSONArray jsonArray = jsonObject.getJSONArray("test5");
    
            while(jsonIterator.hasNext()) {
                    //获取数据并转化成JSONObject
                    JSONObject parseObject = (JSONObject) jsonIterator.next();
                    //sonOrderId1
                    String sonOrderId1= parseObject.getString("sonOrderId1");
                    //sonXml
                    String sonXml = parseObject.getString("sonXml");
    
                     /**********************可对参数进行操作******************/
    
                }
    
    }

    获取完毕

    展开全文
  • 理解Android客户端POST请求参数

    千次阅读 2017-01-20 14:12:27
    深入Android客户端POST请求参数 我们都知道,我们的客户端通过HTTP向服务器发送的post请求实质都是在拼接一个form表单。我们一般会使用下面几种方式进行post 1. 提交参数 2. 提交文件 3. 即提交参数也提交...

    理解Android客户端POST请求参数

    我们都知道,我们的客户端通过HTTP向服务器发送的post请求实质都是在拼接一个form表单。我们一般会使用下面几种方式进行post
    1. 提交参数
    2. 提交文件
    3. 即提交参数也提交文件
    本文也将就这三种方式的请求进行分析

    提交参数的请求

    如我们使用OkHttp发起一个post请求,我们需要自己构建一个FormBody表单。使用方法如下:

    FormBody.Builder builder = new FormBody.Builder();
    builder.add("uid", "10059");
    builder.add("token", "J8ihCfw6JniZnUsxpiUPM9iKtymuZ-p-");
    FormBody body = builder.build();
    
    Request request = new Request.Builder()
         .post(body)
         .url(URL_BASE)
         .build();
    mClient.newCall(request).enqueue(new Callback() {..}

    其中不重要的回调部分已经省略。可以看出我们简单拼接了一个uid和一个token的Params参数。我们通过拦截器获得请求长这个样子:

    D/HttpLogInfo: --> POST https://beta.goldenalpha.com.cn/fundworks/sys/getBanners http/1.1
    D/HttpLogInfo: Content-Type: application/x-www-form-urlencoded
    D/HttpLogInfo: Content-Length: 48
    D/HttpLogInfo: uid=10059&token=J8ihCfw6JniZnUsxpiUPM9iKtymuZ-p-

    这样的一个请求表现成form表单格式如下

    <form method="post"action="https://beta.goldenalpha.com.cn/fundworks/sys/getBanners" enctype="text/plain">
        <inputtype="text" name="uid" value=10059>
        <inputtype="text" name="uid" value=“J8ihCfw6JniZnUsxpiUPM9iKtymuZ-p-> 
    </form>
    
    
    ----- 下面是发出去的请求的样子
    POST / HTTP/1.1
    Content-Type:application/x-www-form-urlencoded
    Accept-Encoding: gzip, deflate
    Content-Length: 48
    Connection: Keep-Alive
    Cache-Control: no-cache
    
    uid=10059&token=J8ihCfw6JniZnUsxpiUPM9iKtymuZ-p-

    对于普通的Form POST请求,头信息每行一条,空行之后便是请求体 也就是我们添加的Params

    1. Content-Length注明内容长度。

    2. Content-Type是application/x-www-form-urlencoded,这意味着消息内容会经过URL编码,就像在GET请 求时URL里的QueryString那样。

    3. Accept-Encoding表示是浏览器发给服务器,声明浏览器支持的编码类型也就是服务返回的时候的编码格式必须是client支持的不然就会出现乱码等情况。常见的是gzip格式。参考Accept-Encoding

    4. Cache-Control 是缓存处理字段,服务器将会根据该字段判断此次请求是否需要进行缓存,OkHttp也可以配置该字段。但是由于Android的缓存大部分是在本地做的,所以这里也不研究这个字段, 该字段常见的取值有 private、no-cache、max-age、must-revalidate等,默认为private。 参考Cache-control

    看完了请求我们再来看看请求结果是什么样的

    Connection →keep-alive
    Content-Encoding →gzip
    Content-Type →application/json;charset=utf-8
    Date →Thu, 19 Jan 2017 08:08:12 GMT
    Transfer-Encoding →chunked
    Vary →Accept-Encoding
    
    {"status":200,"message":"获取banner成功","debug":null,"attachment":{"banners":[{"qbid":1,"title":"test","summary":"test","url":"","rank":1,"status":1,"image":"http://source.goldenalpha.com.cn/S0XsJR7GHaeIpz","createTime":1482407860000}]}}

    可以看到响应和请求一样也包括响应头和响应体,响应头包含的信息有

    1. Content-Encoding 响应采用的编码形式,该形式是在请求中Accept-Encoding的内容选择一种编码方式进行编码的。客户端拿到这个响应将通过该方式进行解码 参考HTTP 协议中的 Content-Encoding

    2. Content-Type 指定请求和响应的HTTP内容类型。如果未指定 ContentType,默认为text/html。application/json是指响应体内是一个json,charset表示的是该json的编码方式为 utf-8

    3. Transfer-Encoding →chunked 表示分块传输编码,通常,HTTP应答消息中发送的数据是整个发送的,Content-Length消息头字段表示数据的长度。然而,使用分块传输编码,数据分解成一系列数据块,并以一个或多个块发送,这样服务器可以发送数据而不需要预先知道发送内容的总大小。通常数据块的大小是一致的,但也不总是这种情况。如果一个HTTP消息(请求消息或应答消息)的Transfer-Encoding消息头的值为chunked,那么,消息体由数量未定的块组成,并以最后一个大小为0的块为结束。参考维基百科分块传输编码

    4. 空一行以后就是响应体的真正内容了


    Content-Type enctype MediaType等概念

    通过上述的post提交参数请求分析,我们梳理了一个请求到响应的具体过程。这样方便我们梳理更复杂的提交文件以及混合提交方式。 需要关注的是Content-Type和enctype这两个字段,因为在这3种请求中这两个字段会有所差异。其实在web中是通过enctype来规定请求表单数据的编码格式,而在Android中是通过setContentType来设置的。这两种形式在HTTP中都表现为Content-type.

    这里的Content-type类型遵循了MIME协议对的传输类型。也就是我们的参数类型MediaType多媒体类型:

    常见的MediaType有
    1. URLencoded: application/x-www-form-urlencoded
    2. Multipart: multipart/form-data
    3. JSON: application/json
    4. XML: text/xml
    5. 纯文本: text/plain
    6. 二进制流数据 application/octet-stream
    参考HTTP 表单编码 enctype

    一个完整的Content-type表示方式为:Content-Type: [type]/[subtype]; parameter 也就是我们在响应头中看到的样式。如果我们不已完整的形式填写。则不同的客户端会有不同的默认值。

    1. type有下面的形式

      1. Text:用于标准化地表示的文本信息,文本消息可以是多种字符集和或者多种格式的;

      2. Multipart:用于连接消息体的多个部分构成一个消息,这些部分可以是不同类型的数据;

      3. Application:用于传输应用程序数据或者二进制数据;

      4. Message:用于包装一个E-mail消息;

      5. Image:用于传输静态图片数据;

      6. Audio:用于传输音频或者音声数据;

      7. Video:用于传输动态影像数据,可以是与音频编辑在一起的视频数据格式。

    2. subtype用于指定type的具体形式,MIME使用Internet Assigned Numbers Authority (IANA)作为中心的注册机制来管理这些值。 如果想了解到底有哪些组合方式请参考Media Types

    3. parameter 常用于指定附加信息,一般是用于来指定文本的编码格式如UTF-8

    4. MIME根据type制定了默认的subtype,当客户端不能确定消息的subtype的情况下,消息被看作默认的subtype进行处理。Text默认是text/plain,Application默认是application/octet-stream而Multipart默认情况下被看作multipart/mixed。

    5. 事实上我们在Android中的上传下载操作设置的contenttype多为application/octet-stream 即为二进制流。

    6. 对于multipart的请求方式,还可以单独设置part的content-type的。稍后再上传文件的时候回详细讲。


    post请求提交文件

    这里为什么要把上传文件但单独列出来,是因为post上传文件可以有两种方式一种是使用FileBody 一种是是使用MultipartBody 两者的不同之处是请求体中的数据类型,前者是只有文件,后者是还可以包含一些text参数。

    同样贴出File请求的办法

    File mfile = new File("/storage/sdcard0/alpha/image/1484209275141.jpg");
    
    String sha1_ = MD5Util.sha1(mfile);
    String size = String.valueOf(mfile.length());
    String uid = "10060";
    String token = "8ihCfw6JniZnUsxpiUPM9iKtymuZ-p-";
    String url = "......falphaupload/upload/upload.json";
    url = url + "?" + "sha1" + "=" + sha1_ + "&" + "size" + "=" + size + "&" + "uid" + "=" + uid + "&" + "token" + "=" + token
          + "&" + "vinfo" + "=" + "AA_samsung_001_30000" + "&" + "suffix" + "=" + "jpg" + "&" + "type" + "=" + "1" + "&" + "plat" + "=" + "0";
    
    RequestBody requestBody = RequestBody.create(MediaType.parse("application/octet-stream"), mfile);
    Request request = new Request.Builder()
          .post(requestBody)
          .url(url)
          .build();
    
    mClient.newCall(request).enqueue(new Callback() {

    Log显示:

    请求
    D/HttpLogInfo: --> POST https://beta.goldenalpha.com.cn/falphaupload/upload/upload.json?sha1=1F179D204C4D89533240E51EF8CCCA5D6E08A0F5&size=27748&uid=10060&token=8ihCfw6JniZnUsxpiUPM9iKtymuZ-p-&vinfo=AA_samsung_001_30000&suffix=jpg&type=1&plat=0 http/1.1
    D/HttpLogInfo: Content-Type: application/octet-stream
    D/HttpLogInfo: Content-Length: 27748
    D/HttpLogInfo: --> END POST (binary 27748-byte body omitted)
    
    响应
    D/HttpLogInfo: Server: nginx/1.0.15
    D/HttpLogInfo: Date: Thu, 19 Jan 2017 09:54:12 GMT
    D/HttpLogInfo: Content-Type: application/json;charset=UTF-8
    D/HttpLogInfo: Transfer-Encoding: chunked
    D/HttpLogInfo: Connection: keep-alive
    D/HttpLogInfo: Vary: Accept-Encoding
    D/HttpLogInfo: {"status":200,"message":"成功","debug":null,"attachment":{"mid":8426}}
    D/HttpLogInfo: <-- END HTTP (72-byte body)

    由log可以看出请求的Content-Type 为application/octet-stream意思就是请求体内包含的信息为二进制流数据。也就是说我们的文件被编码为二进制的形式发送给服务器。

    值得注意的是,我们这里RequestBody内就添加了一个file,而没有其他的key value,然后我们使用MediaType.parse("application/octet-stream")设置我们请求体的Content-Type。我们可以尝试把该字段改成其他的类型如image/jpeg,但是请求不会成功。其他的Content—Type类型可以参考Content—Type对照表


    Post上传文件及参数

    上述请求的时候我们的请求体只携带了一个文件,而且只能携带一个。如果我们单纯的想上传一个图片或者文件的时候我们可以通过上述方法构建一个请求体。但是日常的开发中我们这样的需求并不能满足我们的需求,而且我们也不希望手动拼接如上的url这么多参数。那么采用multipart/form-data的请求方式就此诞生了。

    我们发送一个multipart/form-data的表单格式大体如下:

    <form method="post"action="url" enctype=”multipart/form-data”>
        <inputtype="text" name="desc">
        <inputtype="file" name="pic">
     </form>

    其中的enctype就是我们上述所说的content-type属性。那么我们通过拦截器拦截请求后大体会看出该请求的数据为:

    POST  HTTP/1.1
    Accept-Language: zh-cn,zh;q=0.5
    Accept-Charset: GBK,utf-8
    Connection: keep-alive
    Content-Length: 60408
    Content-Type:multipart/form-data; boundary=ZnGpDtePMx0KrHh_G0X99Yef9r8JZsRJSXC
    
    --ZnGpDtePMx0KrHh_G0X99Yef9r8JZsRJSXC
    Content-Disposition: form-data;name="desc"
    Content-Type: text/plain; charset=UTF-8
    Content-Transfer-Encoding: 8bit
    
    [......][......][......][......]...........................
    --ZnGpDtePMx0KrHh_G0X99Yef9r8JZsRJSXC
    Content-Disposition: form-data;name="pic"; filename="photo.jpg"
    Content-Type: application/octet-stream
    Content-Transfer-Encoding: binary
    
    [图片二进制数据]
    --ZnGpDtePMx0KrHh_G0X99Yef9r8JZsRJSXC--

    我们来分析一下上述数据的内容:
    我们可以看multipart的请求体有多块数据构成,每一块都有他自己的Content-Type,Content-Transfer-Encoding,Content-Disposition。而且在请求头中我们也发现了boundary这个字段。--ZnGpDtePMx0KrHh_G0X99Yef9r8JZsRJSXC--看起来像分隔线的东西就好像是boundary的值。

    这个boundary根据RFC 1867定义,是一段数据的“分割边界”,这个“边界数据”不能在内容其他地方出现,一般来说使用一段从概率上说“几乎不可能”的数据即可。不同的浏览器及webkite实现的方式不太相同,但是这个数据是webkit随机生成的。而不是遍历请求体后生成的,虽然是随机生成,但是绝大多数条件下他也是不能和请求体中的字节重复的。如果你发现有重复的话,那么请去买彩票。

    选择了这个边界之后,webkite便把它放在Content-Type 里面传递给服务器,服务器根据此边界解析数据。下面的数据便根据boundary划分段,每一段便是一项数据。

    每个field被分成小部分,而且包含一个value是”form-data”的”Content-Disposition”的头部;一个”name”属性对应field的名称,文件的话还会多出一个filename的属性。

    接下来我们看下在OkHttp中该请求应该如何构造:

       File mFile = new File("/storage/sdcard0/alpha/image/1484209275141.jpg");
       String sha1_ = MD5Util.sha1(mFile);
       String size = String.valueOf(mFile.length());
       String uid = "10060";
       String token = "8ihCfw6JniZnUsxpiUPM9iKtymuZ-p-";
       String url = "..../falphaupload/upload/upload.json";
    
       MultipartBody.Builder builder = new MultipartBody.Builder();
       builder.addFormDataPart("sha1",sha1_);
       builder.addFormDataPart("size",size);
       builder.addFormDataPart("suffix","jpg");
       builder.addFormDataPart("type","1");
       builder.addFormDataPart("uid",uid);
       builder.addFormDataPart("plat","0");
       builder.addFormDataPart("token",token);
       builder.addFormDataPart("vinfo","AA_samsung_001_30000");
       builder.addFormDataPart("temp.jpg",mFile.getAbsolutePath(),RequestBody.create(MediaType.parse("application/octet-stream"),mFile));
    
       MultipartBody multipartBody = builder.build();
    
       Request request = new Request.Builder()
               .post(multipartBody)
               .url(url)
               .build();
    
       mClient.newCall(request).enqueue(new Callback() {
           @Override
           public void onFailure(Call call, IOException e) {
    
           }
    
           @Override
           public void onResponse(Call call, Response response) throws IOException {
    
           }
       });

    我们看到OkHttp提供给你么MultipartBody的构造器Builder,我们通过构造器可以调用addFormDataPart方法来构建我们的表单。该方法有如下两个重载方法。

    /** Add a form data part to the body. */
    public Builder addFormDataPart(String name, String value) {
     return addPart(Part.createFormData(name, value));
    }
    
    /** Add a form data part to the body. */
    public Builder addFormDataPart(String name, String filename, RequestBody body) {
     return addPart(Part.createFormData(name, filename, body));
    }

    接下来Part.createFormData应该就是构造我们对应的上述表单数据中的每一段数据了,进入源一看果真不出意外,form-data name Content-Disposition 这几个熟悉的字样就映入眼帘了。至于具体怎么拼接的有兴趣的可以自己在深入研究,毕竟我们已经知道他最终的样子。

    public static Part createFormData(String name, String filename, RequestBody body) {
          if (name == null) {
            throw new NullPointerException("name == null");
          }
          StringBuilder disposition = new StringBuilder("form-data; name=");
          appendQuotedString(disposition, name);
    
          if (filename != null) {
            disposition.append("; filename=");
            appendQuotedString(disposition, filename);
          }
    
          return create(Headers.of("Content-Disposition", disposition.toString()), body);
        }

    为什么会写这篇文章

    至于为什么要整理这篇文章,是因为最近询问我使用OkHttp上传图片或者文件的小伙伴有点多,因为现在的项目的框架,还是我们公司的老大自己搭的HttpClient的框架,对于OkHttp的了解也不多,所以就研究了一下,以后也可能使用这个框架来替代掉公司的项目框架。

    其中有一个同学也问了我使用Client上传图片和使用OkHttp上传图片的区别。那么就以他们公司的上传框架代码分析下如何从HttpClient 转到 OkHttp

    下面是使用HttpClient构造请求的方法:

    HttpClient包中各种各样的body: FileBody StringBody MultiBody 其实就是对应了常用的三种请求方式。而这几个类在OkHttp中也能找到他的身影,我们知道OkHttp的RequestBody有三种构造参数:

    1. public static RequestBody create(MediaType contentType, String content) {} — Stringbody

    2. public static RequestBody create(final MediaType contentType, final File file) {} — FileBody

    3. 而MultiBody 在OkHttp3.0以后单独出来一个RequestBody的子类,它的 public Builder addFormDataPart(String name, String filename, RequestBody body) {} 以及public Builder addFormDataPart(String name, String value) {} 通过这两个方法 我们基本上可以构造任何请求体。


    下面来看下具体实现:

           HttpEntity entity = null;
            HttpPost httpPostUpLoadFile = new HttpPost(uri);
            //这里拼接了一个Http请求的请求头 就是我们上边分析的 Accept-Charset: GBK,utf-8 Content-Type:multipart/form-data; boundary=
            httpPostUpLoadFile.addHeader("Accept", "application/json");
            // boundary可以是任意字符,但是必须和MultipartEntity的boundary相同,否则就会报错
            httpPostUpLoadFile.addHeader("Content-Type", "multipart/form-data;boundary=-");
            try {
                // 与header的boundary一致,否则报错
                MultipartEntity multiEntity = new MultipartEntity(HttpMultipartMode.STRICT, "-", Charset.forName(HTTP.UTF_8));
    
                //拼接params参数 在Client包中称作StringBody请求体 其实就是Content—Type为text/plan的字段 new Stringbody对应的请求头内容
                //Content-Disposition: form-data;name="desc"
                //Content-Type: text/plain; charset=UTF-8
                for (Iterator<String> iter = params.keySet().iterator(); iter.hasNext(); ) {
                    String name = iter.next();
                    String value = params.get(name);
                    multiEntity.addPart(name, new StringBody(value, Charset.forName(HTTP.UTF_8)));
    
                }
                //这里是上传文件
                if (files != null) {
                    for (int i = 0; i < files.size(); i++) {
                        File file = new File(files.get(i));
                        //拼接一个文件的请求体 在client中被称为FileBody 也就是Content-Type为application/octet-stream的请求体
    
                        //Content-Disposition: form-data;name="pic"; filename="photo.jpg"
                        //Content-Type: application/octet-stream
                        //Content-Transfer-Encoding: binary
                        ContentBody cbFile = new FileBody(file);
    
                        //addpart的两个参数一个是filename 一个是file 请求体
                        multiEntity.addPart("fjList" + "[" + i + "].file", cbFile);
                    }
                }
                if (images != null) {
    
                    // 图片参数 图片的话求file是相同的了唯一不同的就是FileBody的Content—Type可以更进一步的指定为image/jpeg 其实实质也是而二进制传输,
                    // 但是这个字段需要跟服务器约定好,如果服务器解析的image/jpeg你传application/octet-stream服务器可能解析不到
    
                    for (int i = 0; i < images.size(); i++) {
                        File f = new File(images.get(i));
                        if (f.exists()) {
                            FileBody fp = new FileBody(f, "image/jpeg");
                            multiEntity.addPart("fjList" + "[" + i + "].file", fp);
                        }
                    }
                }
                //接下来就是发送请求 这里不再赘述了
    
                httpPostUpLoadFile.setEntity(multiEntity);
                // 创建客户端
                HttpClient httpClient = getNewHttpClient();
                // 执行请求获得响应
                HttpResponse response = httpClient.execute(httpPostUpLoadFile);
                // 解析响应对象
                if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                    entity = response.getEntity();
                    String json = "";
                    if (entity != null) {
                        json = EntityUtils.toString(entity, "utf-8");
                        System.out.println(json);
                        return json;
                    }
                }
            } catch (Exception e) {
                System.out.println(e.toString());
            }
            return uri;

    这里是修改为OkHttp后的请求操作,主要区别就是在与请求体的封装方法。

    public static String getEntity2(String uri, Map<String, String> params, ArrayList<String> images, ArrayList<String> files) {
    
            OkHttpClient.Builder builder = new OkHttpClient.Builder();
            OkHttpClient okHttpClient = builder.build();
    
            MultipartBody.Builder multiBuilder = new MultipartBody.Builder("-");
            //添加key value 请求体
            for (Iterator<String> iter = params.keySet().iterator(); iter.hasNext(); ) {
                String name = iter.next();
                String value = params.get(name);
                multiBuilder.addPart(RequestBody.create(MediaType.parse("text/plain"), value)); //对于text/plain okhttp默认的Charset就是UTF-8所以不用手动设置
                //multiBuilder.addFormDataPart(name,value); 这种方式也可以 为了方便理解写成上边的添加请求体方式
            }
    
            //这里是上传文件
            if (files != null) {
                for (int i = 0; i < files.size(); i++) {
                    File file = new File(files.get(i));
                    //这两种方式都可以,但是服务器对于file的名字有要求的时候就需要用第一种了
                    multiBuilder.addFormDataPart("fjList" + "[" + i + "].file", file.getAbsolutePath(), RequestBody.create(MediaType.parse("application/octet-stream"), file));
                    //multiBuilder.addPart(RequestBody.create(MediaType.parse("application/octet-stream"),file));
                }
            }
    
            if (images != null) {
    
                for (int i = 0; i < images.size(); i++) {
                    File f = new File(images.get(i));
                    if (f.exists()) {
                        multiBuilder.addFormDataPart("fjList" + "[" + i + "].file", f.getAbsolutePath(), RequestBody.create(MediaType.parse("image/jpeg"), f));
                    }
                }
            }
    
            //构造请求体完成
            MultipartBody multipartBody = multiBuilder.build();
    
            Request.Builder requestBuilder = new Request.Builder();
            // okHttp的请求头是在Request.Builder添加的
            requestBuilder.addHeader("Accept", "application/json");
            requestBuilder.addHeader("Content-Type", "multipart/form-data;boundary=-");
            Request request = requestBuilder
                    .post(multipartBody)
                    .url(uri)
                    .build();
    
            okHttpClient.newCall(request).enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
                    //响应失败操作
                }
    
                @Override
                public void onResponse(Call call, Response response) throws IOException {
                    //响应完成操作
                }
            });
    
            return null;
        }
    展开全文
  • ajax中POST请求参数(请求体)设置

    千次阅读 2020-12-31 04:13:26
    2.创建post.html文件 3.创建server.js文件 post.html文件 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, ...

    回到文章总目录

    1.创建在testthree文件夹并在这个文件夹里面
    2.创建post.html文件
    3.创建server.js文件

    本篇文章使用了当鼠标移动至方框内则发送请求示例

    post.html文件

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Ajax post 请求</title>
    </head>
    <body>
        <!-- id为result的div -->
        <div id="result" style="width:  200px;height: 100px;border: solid 1px #770088;">
            鼠标经过向服务器发送post请求,并把结果返回,展示在本div内
        </div>
        <script>
            // 获取元素
            const btn = document.getElementsByTagName('result');
            // 把获取到的响应体展示在div中
            const result = document.getElementById("result");
            // 2.绑定事件 
            // result.addEventListener('mouseover', function(){console.log('test');});
            result.addEventListener('mouseover', function(){
                // 0.测试打印
                console.log('test');
                // 1.创建对象
                const textone = new XMLHttpRequest();
                // 2.初始化,设置请求类型与URL
                // 第一个参数为[请求类型]
                // 第二个参数为[给那个url发送]
                textone.open('POST','http://127.0.0.1:8000/server');
                // 3.发送 POST参数
                // 没有参数是直接——textone.send();
                // 当有参数时,就直接写在这里面
                // 格式1:textone.send("a=100&b=200&c=300");
                // 格式2:textone.send("a:100&b:200&c:300")
                // 任意格式都可以的            但前提是服务端   设置好了接收的处理的方式
                textone.send("新年的第一个红包使我送给你的");
                // 4.事件绑定 处理服务端返回的结果
                textone.onreadystatechange = function(){
                    // 判断 (服务端返回了所有的结果) 4
                    if(textone.readyState === 4){
                        // 再次判断——响应状态码  
                        if(textone.status >= 200 && textone.status < 300){
                            // 处理服务端返回的结果
                            result.innerHTML = textone.response;
                        }else{}
                    }
                }
            });
        </script>
    </body>
    </html>
    

    server.js文件

    // 1. 引入express
    const express = require('express');
    
    // 2.创建对象
    const app = express();
    
    // 3.创建路由规则  里面的形参 request与response   (自己可以随便定义名字的)
    //  建议写成  request与response  因为可以见名思意,方便自己看
    // request  对请求报文的封装
    // responst 对响应报文的封装
    //  请求路径为'/server'
    app.post('/server', (request, response)=>{
        // 设置响应头 设置允许跨域
        // 头名字为Access-Control-Allow-Origin
        // 头的值为
        response.setHeader('Access-Control-Allow-Origin','*');
        // 设置响应体
        response.send('POST请求成功,路由设置为server,响应体为本段文字');
    
    });
    
    // 4. 监听端口启动服务
    // 这里listen(8000)后面添加了一个回调,用来提示,告诉自己是否监听成功
    app.listen(8000, ()=>{
        console.log("服务已经启动,8000端口监听中......");
    });
    

    启动服务
    请求返回图
    在这里插入图片描述参数显示位置
    在这里插入图片描述在这里插入图片描述

    展开全文
  • 直接看代码和截图吧,代码中有注释,还有文字说明!...表单中如果有2个控件的name属性的值相同,服务器端获取请求参数的时候,获取到的是前面的那个请求参数(不信的话,可以用get方式提交表单,在浏览器地址栏看下这...
  • nodejs 发送 post 请求参数

    千次阅读 2013-08-20 14:25:06
    var http = require('http'); var querystring = require('querystring'); var post_data = querystring.stringify({  product : 'club',  sign : 'ddddddddddddddd',  sender
  • Tomcat日志记录post请求参数

    千次阅读 2020-04-26 22:51:00
    公司的项目向用户提供接口,但是最近偶尔会出现超时的情况,用户的调用设置的超时时间是1分钟,所以首先要排查代码的执行... public boolean post(@RequestBody OaModel oaModel, HttpServletRequest request) { l...
  •  记录Post请求参数 另外% r 参数能打印出请求的 url 和 get 参数。如果 url 指定访问方式是 post , post 的参数是打印不出来的。当需要打印 post 参数,该怎么办? server.xml配置 tomcat 访问日志...
  • 偏偏我们的应用,有时候需要通过json格式传输数据,这个时候json格式的数据应该是作为body传给后台的,没有参数名字,我们需要设置请求头为"Content-Type: application/json",此外,我们通过...
  • ajax的post请求多同名参数数处理

    千次阅读 2019-05-27 17:18:41
    参数 参数说明 token 字符串 person 对象 Person 对象说明 name 姓名,String age 年龄,Integer ids 集合,List 针对这种情况一般是吧token放在Person里面后台@RequestBody接受, 先在不想...
  • 记得要一一对应 特别是你设置的名字 下面贴出我的配置 server { server_name api .boyazhibo .com ; access_log /data/wwwlogs/api .2 .com _nginx .log access ; index index .html index .htm ...
  • 直接上代码,testFormSubmit.jsp页面 ; charset=utf-8" pageEncoding="utf-8"%> ...测试使用表单post方式提交到某个servlet,请求参数不会在地址栏显示,达到隐藏请求参数的目的 <link rel="stylesheet" type="t
  • FastAPI http请求参数的接收 我最开始接触FastAPI的时候,最搞不懂的就是POST方式是如何接收参数的。 GET方式的参数 GET方式的参数有两种,一种是路径参数,一种是查询参数。举个例子来说明两者的区别 路径参数 ...
  • 1.直接在controller接收参数参数名称要与getURl中传递的参数一致 get url : https://localhost:8080/demo/login?&userName=bob&passWord=123 @Controller public class demo { @request
  • 前言最近在做一个博客的小项目,需要用到文件上传,HttpClient又被Android给弃用...理论知识背景最早的HTTP POST是 不支持 文件上传的,给编程开发带来很多问题。但是在1995年,ietf出台了rfc1867,也就是《RFC 1867 -F
  • 一、配置与说明 tomcat访问日志格式配置,在config/server.xml里Host标签下加上  prefix="localhost_access_log." suffix=".txt" ... pattern="%h %l %u %t "... [%{postdata}r] %s %{Referer}
  • post请求中requestBody的参数名问题

    千次阅读 2020-03-12 17:02:05
    @RequestBody中的参数名好像要叫pos. @PostMapping public void test(@RequestBody TestDto pos){} class TestDto{ private List<TestPo> pos; } class TestPo{ private String name; private ...
  • CURL 发送POST请求

    千次阅读 2020-08-18 10:41:47
    CURL 发送POST请求 curl -H "Content-Type: application/json" -X POST -d '{"user_id": "123", "coin":100, "success":1, "msg":"OK!" }' "http://192.168.0.1:8001/test" 参数 内容 -H 请求头 -d POST内容 -X ...
  • post 请求下载文件

    千次阅读 2019-11-29 11:35:43
    最近遇到一个下载的需求,由于 url 参数太长(常用的下载方法 a 标签或者 location.href 的方法都是 get 请求,get 请求参数长度有限制),无法下载,考虑了好几种方案,最终还是觉得通过 ajax 的 POST 方法进行下载,...
  • } 第二章 Post请求 2.1 application/x-www-form-urlencoded 前端传的content-type为application/x-www-form-urlencoded,这也是默认的请求方式 这样,参数在请求体以标准的Form Data的形式提交,以&符号拼接,参数...
  • 如果后台Bool 参数没有同时支持【 0,1】 ;和【 true false】,get请求的时候 就需要特殊处理。 问题 [params setValue:[NSNumber numberWithBool:self.viewModel.multipleSwitchCellTableViewCellModel.IsSon] ...
  • Curl命令POST请求

    千次阅读 2019-07-17 17:23:19
    curl工具介绍: CURL是一个利用URL语法在命令行下工作的文件传输工具,被广泛应用在Unix、Linux发行版中,并且有DOS和Win32、Win64... 我们可以使用它进行HTTP POST、HTTP PUT、FTP上传、cookies、用户认证、IP代...
  • AJAX的表单请求POST请求方式

    千次阅读 2018-11-09 09:50:44
    post: 把数据名称和数据值用=连接,如果有多个的话,那么他会把多个数据组合用&amp;进行连接,然后把数据放到url?后面传到指定页面 enctype : 提交的数据格式,默认application/x-www-form-urlencoded &lt;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 119,342
精华内容 47,736
关键字:

post请求没有参数名字