精华内容
下载资源
问答
  • httppost和httpget需要的jar包

    千次下载 热门讨论 2013-12-06 10:53:55
    httppost和httpget需要的jar包
  • MFC程序中通过HttpGet和HttpPost方式向WebService发送请求,WebService以Json的方式返回数据,MFC程序解析Json,得到指定数据。
  • HttpPost 携带参数的请求方式

    万次阅读 2018-11-12 20:31:48
    Http的几种请求方式对应程序包中的HttpGet, HttpHead, HttpPost, HttpPut, HttpDelete, HttpTrace, and HttpOptions,这些类均实现了HttpUriRequest接口,所以可以作为execute的执行参数使用。 根据HTTP的请格式,...

    一、HTTP请求

    Http的几种请求方式对应程序包中的HttpGet, HttpHead, HttpPost, HttpPut, HttpDelete, HttpTrace, and HttpOptions,这些类均实现了HttpUriRequest接口,所以可以作为execute的执行参数使用。

    根据HTTP的请格式,我们可以知道有两种方式可以为request提供参数。

    第一种方式:request-line

    第二种方式:request-body

    因为工作中使用HttpPost请求用到了这两种请求方式,所以下面就只列出HttpPost的请求,其他请求方式的等下次用到在补上。

    二、HttpPost

    1、request-line方式

      URI uri = null;
            List<NameValuePair> qparams = new ArrayList<NameValuePair>();
            qparams.add(new BasicNameValuePair("region", String.valueOf(departmentId)));//需要对应传参的name和value
            qparams.add(new BasicNameValuePair("platNum", carNum));//需要对应传参的name和value
            try {
                uri = URIUtils.createURI("http", "192.168.1.xx:23002", -1, "/zyc/get/latestdd",
                        URLEncodedUtils.format(qparams, "UTF-8"), null);
                HttpPost httpPost = new HttpPost(uri);
                System.out.println(httpPost.getURI());
            } catch (URISyntaxException e) {
                e.printStackTrace();
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }

    打印结果如下:  http://192.168.1.75:23002/zyc/get/latest?region=320211&platNum

    2、request-body

     PageHelper pageHelper =new PageHelper(pageIndex,pageSize,null);
     ObjectMapper MAPPER = new ObjectMapper();
     stringPage = MAPPER.writeValueAsString(pageHelper);//对象转String
     List<NameValuePair> list = new LinkedList<>();
            list.add( new BasicNameValuePair("pageHelper",stringPage ));//pageHelper放在body中传过去
      HttpPost httpPost = new HttpPost(uri);
      // 使用URL实体转换工具
     UrlEncodedFormEntity entityParam = new UrlEncodedFormEntity(list, "UTF-8");         //使用 UrlEncodedFormEntity 来设置 body,消息体内容
                httpPost.setEntity(entityParam);
    

    3、HttpPost两种方式结合在一起请求

        /**
         * 发送 post请求
         */
        public String postParams(PageHelper pageHelper, Long region, String platNum) {
            // 获取连接客户端工具
            CloseableHttpClient httpClient = HttpClients.createDefault();
            String entityStr = null;
            CloseableHttpResponse response = null;
            ObjectMapper MAPPER = new ObjectMapper();
            try {
                String stringPage = MAPPER.writeValueAsString(pageHelper);
                List<NameValuePair> qparams = new ArrayList<NameValuePair>();
                qparams.add(new BasicNameValuePair("region", String.valueOf(region)));
                qparams.add(new BasicNameValuePair("platNum", platNum));
                URI uri = null;
                try {
                    uri = URIUtils.createURI("http", "192.168.X.X:23002", -1, "/zyc/get/latestdd",
                            URLEncodedUtils.format(qparams, "UTF-8"), null);
                } catch (URISyntaxException e) {
                    e.printStackTrace();
                }
                HttpPost httpPost = new HttpPost(uri);
                System.out.println(httpPost.getURI());     
                // 创建请求参数HttpUriRequest
                List<NameValuePair> list = new LinkedList<>();
                list.add( new BasicNameValuePair("pageHelper",stringPage ));//放在body中
                 /*JSONObject postData = new JSONObject();
                postData.put("pageHelper", stringPage);
                httpPost.setEntity(new StringEntity(postData.toString(), HTTP.UTF_8));*/
                // 使用URL实体转换工具
                UrlEncodedFormEntity entityParam = new UrlEncodedFormEntity(list, "UTF-8");// UrlEncodedFormEntity  request-body
                httpPost.setEntity(entityParam);
                System.out.println("executing request " + httpPost.getURI());
                // 浏览器表示
                httpPost.addHeader("User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.7.6)");
                // 传输的类型
                httpPost.addHeader("Content-Type", "application/x-www-form-urlencoded");
                // 执行请求
                response = httpClient.execute(httpPost);
                // 获得响应的实体对象
                HttpEntity entity = response.getEntity();
                // 使用Apache提供的工具类进行转换成字符串
                entityStr = EntityUtils.toString(entity, "UTF-8");
            } catch (ClientProtocolException e) {
                System.err.println("Http协议出现问题");
                e.printStackTrace();
            } catch (ParseException e) {
                System.err.println("解析错误");
                e.printStackTrace();
            } catch (IOException e) {
                System.err.println("IO异常");
                e.printStackTrace();
            } finally {
                // 释放连接
                if (null != response) {
                    try {
                        response.close();
                        httpClient.close();
                    } catch (IOException e) {
                        System.err.println("释放连接出错");
                        e.printStackTrace();
                    }
                }
            }
            // 打印响应内容
            System.out.println(entityStr);
            return  entityStr;
        }

    注:说一下上面用到的BasicNameValuePair方法

    三、BasicNameValuePair方法

    new BasicNameValuePair(String1,String2)

    BasicNameValuePair方法 进行参数传递时,只能使用String这种类型进行传递,事实上表单提交的get和post只能传递String类型,所以如何传递非String类型的参数,比如布尔类型、整型或者实体类。

    其实第一个想到的就是将这些符合要求的类型转换成String类型就可以了,但是为什么可以直接转呢?

    因为,httpPost.setEntity(new UrlEncodedFormEntity(params));这段神奇的代码

    这里放到http entity里面的类型都是字节类型,HTTP协议与FTP,SMTP类似都是通过plain-text ASCII来进行CS数据通信的(不像TCP使用二进制,有历史原因,也更加节约带宽和方便调试),实际上并不存在什么String,Boolean,Integer数据类型,都是通过将byte进行ASCII编码来实现的,服务器端反序列化成String类型后,通过springMVC的框架进行解析,注意这里也需要区分提交方式,框架可能会选取适当的httpMessageConverter进行解析(这个是服务器关注的事情了)

                                                

    展开全文
  • HttpPost 上传文件

    千次阅读 2019-03-10 15:22:59
    HttpPost httpPost = new HttpPost("http://localhost:8080/UploadServlet"); //把文件转换成流对象FileBody FileBody bin = new FileBody(new File(filePath)); //普通字段 重新设置了编码方式 StringBody...
    /**
     * Project Name:testHttpClient
     * File Name:ClientMultipartFormPost.java
     * Package Name:com.test.httpclient
     * Date:2016年12月28日下午4:01:59
     * Copyright (c) 2016, 77493077@qq.com All Rights Reserved.
     *
     */
    
    package com.test.httpclient;
    
    import java.io.File;  
    import java.io.IOException;  
    import java.nio.charset.Charset;  
      
    import org.apache.http.Consts;  
    import org.apache.http.HttpEntity;  
    import org.apache.http.client.methods.CloseableHttpResponse;  
    import org.apache.http.client.methods.HttpPost;  
    import org.apache.http.entity.ContentType;
    import org.apache.http.entity.mime.HttpMultipartMode;
    import org.apache.http.entity.mime.MultipartEntityBuilder;  
    import org.apache.http.entity.mime.content.FileBody;  
    import org.apache.http.entity.mime.content.StringBody;  
    import org.apache.http.impl.client.CloseableHttpClient;  
    import org.apache.http.impl.client.HttpClients;  
    import org.apache.http.util.EntityUtils;  
    /**
     * ClassName:ClientMultipartFormPost <br/>
     * Function: TODO ADD FUNCTION. <br/>
     * Reason:	 TODO ADD REASON. <br/>
     * Date:     2016年12月28日 下午4:01:59 <br/>
     * @author   ZengZhuo(lenovo)
     * @version  
     * @since    JDK 1.8+
     * @see 	 
     */
    public class ClientMultipartFormPost {
    
        /** 
         * 这个例子展示了如何执行请求包含一个多部分编码的实体 
         * 模拟表单提交 
         * @throws IOException  
         */  
        public static void main(String[] args) throws IOException {  
            CloseableHttpClient httpClient = HttpClients.createDefault();  
            try{  
                //要上传的文件的路径  
                String filePath = "D:\\mail.jpeg";  
                //把一个普通参数和文件上传给下面这个地址    是一个servlet  
                HttpPost httpPost = new HttpPost("http://localhost:8080/UploadServlet");  
                //把文件转换成流对象FileBody  
                FileBody bin = new FileBody(new File(filePath));  
                //普通字段  重新设置了编码方式  
                StringBody comment = new StringBody("这里是一个评论", ContentType.create("text/plain", Consts.UTF_8));  
                //StringBody comment = new StringBody("这里是一个评论", ContentType.TEXT_PLAIN);  
                  
                StringBody name = new StringBody("王五", ContentType.create("text/plain", Consts.UTF_8));  
                StringBody password = new StringBody("123456", ContentType.create("text/plain", Consts.UTF_8));  
                  
                HttpEntity reqEntity = MultipartEntityBuilder.create().setMode(HttpMultipartMode.BROWSER_COMPATIBLE)  
                .addPart("media", bin)//相当于<input type="file" name="media"/>  
                .addPart("comment", comment)  
                .addPart("name", name)//相当于<input type="text" name="name" value=name>  
                .addPart("password", password)
                .addTextBody("value", "roy")
                .build();  
                  
                httpPost.setEntity(reqEntity);  
                  
                System.out.println("发起请求的页面地址 " + httpPost.getRequestLine());  
                //发起请求   并返回请求的响应  
                CloseableHttpResponse response = httpClient.execute(httpPost);  
                try {  
                    System.out.println("----------------------------------------");  
                    //打印响应状态  
                    System.out.println(response.getStatusLine());  
                    //获取响应对象  
                    HttpEntity resEntity = response.getEntity();  
                    if (resEntity != null) {  
                        //打印响应长度  
                        System.out.println("Response content length: " + resEntity.getContentLength());  
                        //打印响应内容  
                        System.out.println(EntityUtils.toString(resEntity,Charset.forName("UTF-8")));  
                    }  
                    //销毁  
                    EntityUtils.consume(resEntity);  
                } finally {  
                    response.close();  
                }  
            }finally{  
                httpClient.close();  
            }  
        }  
      
    }
    
    package com.test.httpclient;
    
    import java.io.File;
    import java.io.IOException;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Map;
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import org.apache.commons.fileupload.FileItem;
    import org.apache.commons.fileupload.FileUploadException;
    import org.apache.commons.fileupload.disk.DiskFileItemFactory;
    import org.apache.commons.fileupload.servlet.ServletFileUpload;  
    
    /**
     * Servlet implementation class UploadServlet
     */
    @WebServlet("/UploadServlet")
    public class UploadServlet extends HttpServlet {
    	private static final long serialVersionUID = 1L;
    
        /**
         * Default constructor. 
         */
        public UploadServlet() {
            // TODO Auto-generated constructor stub
        }
    
    	/**
    	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
    	 */
    	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		// TODO Auto-generated method stub
    		response.getWriter().append("Served at: ").append(request.getContextPath());
    	}
    
    	/**
    	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
    	 */
    	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		// TODO Auto-generated method stub
    		request.setCharacterEncoding("utf-8");  
            response.setCharacterEncoding("utf-8");  
              
            //利用apache的common-upload上传组件来进行  来解析获取到的流文件  
              
            //把上传来的文件放在这里  
            String uploadPath = getServletContext().getRealPath("/upload");//获取文件路径   
              
            //检测是不是存在上传文件  
            // Check that we have a file upload request  
            boolean isMultipart = ServletFileUpload.isMultipartContent(request);  
              
            if(isMultipart){  
                  
                DiskFileItemFactory factory = new DiskFileItemFactory();  
                //指定在内存中缓存数据大小,单位为byte,这里设为1Mb  
                factory.setSizeThreshold(1024*1024);  
                //设置一旦文件大小超过getSizeThreshold()的值时数据存放在硬盘的目录   
                factory.setRepository(new File("D://temp"));  
                // Create a new file upload handler  
                ServletFileUpload upload = new ServletFileUpload(factory);  
                // 指定单个上传文件的最大尺寸,单位:字节,这里设为5Mb    
                upload.setFileSizeMax(5 * 1024 * 1024);    
                //指定一次上传多个文件的总尺寸,单位:字节,这里设为10Mb    
                upload.setSizeMax(10 * 1024 * 1024);     
                upload.setHeaderEncoding("UTF-8"); //设置编码,因为我的jsp页面的编码是utf-8的   
                  
                List<FileItem> items = null;  
                  
                try {  
                    // 解析request请求  
                    items = upload.parseRequest(request);  
                } catch (FileUploadException e) {  
                    e.printStackTrace();  
                }  
                if(items!=null){  
                    //把上传文件放到服务器的这个目录下  
                    if (!new File(uploadPath).isDirectory()){    
                        new File(uploadPath).mkdirs(); //选定上传的目录此处为当前目录,没有则创建    
                    }   
                    //解析表单项目  
                    // Process the uploaded items  
                    Iterator<FileItem> iter = items.iterator();  
                    while (iter.hasNext()) {  
                        FileItem item = iter.next();  
                        //如果是普通表单属性  
                        if (item.isFormField()) {  
                            //<input type="text" name="content">  
                            String name = item.getFieldName();//相当于input的name属性  
                            String value = item.getString();//input的value属性  
                            System.out.println("属性:"+name+" 属性值:"+value);  
                        }  
                        //如果是上传文件  
                        else {  
                            //属性名  
                            String fieldName = item.getFieldName();  
                            //上传文件路径  
                            String fileName = item.getName();  
                            fileName = fileName.substring(fileName.lastIndexOf("/")+1);// 获得上传文件的文件名  
                            try {  
                                item.write(new File(uploadPath,fileName));  
                            } catch (Exception e) {  
                                e.printStackTrace();  
                            }  
                            //给请求页面返回响应  
                            response.getWriter().println("文件上传成功! 文件名是:"+fileName);  
                        }  
                    }  
                }  
            }
    	}
    	
    	public static void main(String[] args) {
    		String name ="aaa";
    		String [] values = new String[]{"123"};
    		Map<String,String[]> ms = new HashMap<String,String[]>();
    		ms.put(name, values);
    		System.out.println(ms.toString());
    	}
    }
    
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>Systemmonitor</groupId>
      <artifactId>Systemmonitor</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <packaging>war</packaging>
      <name/>
      <description/>
      <dependencies>
        <dependency>
          <groupId>org.apache.openejb</groupId>
          <artifactId>javaee-api</artifactId>
          <version>5.0-1</version>
          <scope>provided</scope>
        </dependency>
        <dependency>
          <groupId>javax.faces</groupId>
          <artifactId>jsf-api</artifactId>
          <version>1.2_04</version>
          <scope>provided</scope>
        </dependency>
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>jstl</artifactId>
          <version>1.2</version>
          <scope>provided</scope>
        </dependency>
        <dependency>
          <groupId>javax.servlet.jsp</groupId>
          <artifactId>jsp-api</artifactId>
          <version>2.1</version>
          <scope>provided</scope>
        </dependency>
        <dependency>
          <groupId>javax.faces</groupId>
          <artifactId>jsf-impl</artifactId>
          <version>1.2_04</version>
          <scope>provided</scope>
        </dependency>
        <dependency>
        	<groupId>org.springframework</groupId>
        	<artifactId>spring-web</artifactId>
        	<version>3.1.1.RELEASE</version>
        	<type>jar</type>
        	<scope>compile</scope>
        </dependency>
        <dependency>
        	<groupId>org.springframework</groupId>
        	<artifactId>spring-core</artifactId>
        	<version>3.1.1.RELEASE</version>
        	<type>jar</type>
        	<scope>compile</scope>
        </dependency>
        <dependency>
        	<groupId>org.springframework</groupId>
        	<artifactId>spring-webmvc</artifactId>
        	<version>3.1.1.RELEASE</version>
        	<type>jar</type>
        	<scope>compile</scope>
        </dependency>
      </dependencies>
      <build>
        <sourceDirectory>${basedir}/src</sourceDirectory>
        <outputDirectory>${basedir}/WebRoot/WEB-INF/classes</outputDirectory>
        <resources>
          <resource>
            <directory>${basedir}/src</directory>
            <excludes>
              <exclude>**/*.java</exclude>
            </excludes>
          </resource>
        </resources>
        <plugins>
          <plugin>
            <artifactId>maven-war-plugin</artifactId>
            <configuration>
              <webappDirectory>${basedir}/WebRoot</webappDirectory>
              <warSourceDirectory>${basedir}/WebRoot</warSourceDirectory>
            </configuration>
          </plugin>
          <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
              <source>1.5</source>
              <target>1.5</target>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </project>

     

    展开全文
  • Http请求里post是其中比较常用的提交数据的请求方式,那么接下来就给大家详细讲解下post的几种数据传输格式,以及写法。 Http的请求传输方式很多: 我们着重讲解Post方式。Post请求包含两部分:请求头(header...

    在Http请求里post是其中比较常用的提交数据的请求方式,那么接下来就给大家详细讲解下post的几种数据传输格式,以及写法。

    Http的请求传输方式很多:

    我们着重讲解Post方式。Post请求包含两部分:请求头(header)和请求体(body)。

    Post常见的请求体(body)有三种传输内容类型Content-type:application/x-www-form-urlencoded、application/json、multipart/form-data,当然还有其他的几种,不过不常用,常用的就是这三种。

    先看第一种:application/x-www-form-urlencoded。

    通过Postman可以看到Post请求的参数一般放在Body里。我们的application/x-www-form-urlencoded方式也是Post请求最早支持的一种数据传输方式,这种也是key和value形式,将我们的参数类似于GET方式那样拼接成一个字符串,例如:key1=value1&key2=value2,这种形式,然后将这个参数字符串进行urlencode编码,放到Body里进行发送请求数据。

    接下来分别用Java Spring MVC、Android OkHttp、Retrofit、JS Ajax、Nodejs分别演示下这种方式的请求和接口编写:

    在Java的Spring MVC中默认的编写Controller接口请求数据传输就是这种方式:application/x-www-form-urlencoded。

    package com.web.mvc.controller;
    
    import com.google.gson.FieldAttributes;
    import com.google.gson.Gson;
    import com.web.mvc.model.Entity;
    import com.web.mvc.model.User;
    import com.web.mvc.service.EntityService;
    import com.web.mvc.service.IEntityService;
    import com.web.mvc.utils.RedisUtils;
    import com.web.mvc.utils.Utils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.http.MediaType;
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.*;
    
    import java.io.File;
    import java.io.IOException;
    import java.sql.SQLException;
    
    import org.apache.commons.codec.binary.Base64;
    import org.springframework.web.multipart.MultipartFile;
    
    import javax.servlet.http.HttpServletRequest;
    import java.util.HashMap;
    import java.util.List;
    
    //@Controller
    @RestController
    @RequestMapping("/entity")
    public class EntityController {
        @Autowired
        private IEntityService entityService;
    
        //默认form-urlcoded
        @CrossOrigin
        @RequestMapping(value = "/urlcodedReq", method = RequestMethod.POST)
        @ResponseBody
        public String urlcodedReq(@RequestParam String name,
                                  @RequestParam String pwd) {
            System.out.println("urlcodedReq:" + name + "  " + pwd);
            Gson gson = new Gson();
            HashMap<String, String> map = new HashMap<>();
            map.put("name", name);
            map.put("pwd", pwd);
            return gson.toJson(map);
        }
    }

    @CrossOrigin:用来处理支持跨域请求的;

    @ResponseBody:作用在方法上,表示请求返回的数据写入http response body里,也就是返回数据,而不是进行页面跳转。

    以上就是Java Spring MVC编写Controller Post接口的写法。

    接下来看下Android中Retrofit的请求写法:

    public interface ApiService {
    
        //application/x-www-form-urlencoded
        @FormUrlEncoded
        @POST("urlcodedReq")
        Call<ResponseBody> getRepos(@Field("name") String name, @Field("pwd") String pwd);
    }

    就是加入了@FormUrlEncoded注解即可。

    再看下Okhttp发送请求的写法:

    public class Utils {
        private static String
                url = "http://192.168.1.130:8086/entity/urlcodedReq";
    
        public static void okPost() {
            OkHttpClient client = new OkHttpClient();
            client.newBuilder()
                    .build();
            //application/x-www-form-urlencoded
            RequestBody body = new FormBody.Builder()
                    .add("name", "123")
                    .add("pwd", "pwd1")
                    .build();
    
            Request request = new Request.Builder()
                    .post(body)
                    .url(url)
                    .build();
            client.newCall(request).enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
                    System.out.println("onFailure:" + e.getLocalizedMessage());
                }
    
                @Override
                public void onResponse(Call call, Response response) throws IOException {
                    System.out.println("onResponse:" + response.body().string());
                }
            });
        }
    }

    接下来看下JS中Ajax的写法:

    /**
     * 原生Ajax POST请求
     */
    function getOrigantAjaxPost() {
        var stringData='name=value1&pwd=value2'
        var oAjax = null;
        //这里进行HTTP请求
        try {
            oAjax = new XMLHttpRequest();
        } catch (e) {
            oAjax = new ActiveXObject("Microsoft.XMLHTTP");
        };
        //post方式
        oAjax.open('post', 'http://' + hostName + ':' + port + '/entity/urlReq', true);
        oAjax.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
        //post发送数据
        oAjax.send(stringData);
        oAjax.onreadystatechange = function () {
            //当状态为4的时候,执行以下操作
            if (oAjax.readyState == 4 && oAjax.status == 200) {
                try {
                    //+ oAjax.responseText
                    console.log('data:' + oAjax.responseText);
                } catch (e) {
                    // alert('你访问的页面出错了' + e);
                };
            };
        };
    }

    Jquery Ajax写法:

    function getOrigantAjaxPost() {
        var stringData = 'name=value1&pwd=value2'
        $.ajax({
            data: stringData,
            async: true,
            url: 'http://' + hostName + ':' + port + '/entity/urlReq',
            type: "post",
            processData: false,  //tell jQuery not to process the data
            contentType: "application/x-www-form-urlencoded",
            success: function (data, status) {
                // alert("Data: " + status);
                console.log("Data: " + JSON.stringify(data) + "  " + status);
            },
            error: function (e) {
                // alert("Data: error" + JSON.stringify(e));
                console.log('error ' + JSON.stringify(e));
            }
        });
    }

    接下来再看下Nodejs的接口和请求写法:

    var http = require("http");
    var url = require('url');
    var express = require('express')
    var bodyParser = require('body-parser');
    //设置主机名
    var hostName = '192.168.56.1';
    //设置端口
    var port = 8092;
    var app = express()
    var urlencodedParser = bodyParser.urlencoded({ extended: false })
    routes.post('/url', urlencodedParser, (req, res) => {
        //解析参数
        var params = req.body;
        var user = {};
        user.name = params.name;
        user.pwd = params.pwd;
        var response = { status: 1, data: user };
        res.send(JSON.stringify(response));
        res.end();
    });
    

    Nodejs原生写Post接口解析写法:

    const http = require('http');
    
    //用http模块创建一个http服务端 
    http.createServer(function(req, res) {
      if (req.method.toLowerCase() === 'post') {
        var body = '';   
        req.on('data', function(chunk){
          body += chunk;
        });
    
        req.on('end', function(){
          if(req.headers['content-type'].indexOf('application/json')!==-1){
            // JSON 格式请求体解析
            JSON.parse(body);
          } else if(req.headers['content-type'].indexOf('application/octet-stream')!==-1){
            // Raw 格式请求体解析
            // ……
          } else if(req.headers['content-type'].indexOf('text/plain')!==-1){
            // text 文本格式请求体解析
            // ……
          } else if(req.headers['content-type'].indexOf('application/x-www-form-urlencoded')!==-1){
            // URL-encoded 格式请求体解析
            // ……
          } else {
          	// 其它格式解析
          }
        })
      } else {
        res.end('其它提交方式');
      }
    }).listen(3000);

    Nodejs的请求写法:

    /**
     * 原生POST请求
     */
    function urlPost() {
        var http = require('http');
        var querystring = require('querystring');
        var contents = querystring.stringify({
            name: 'nameuser',
            pwd: '123'
        });
        var options = {
            host: hostName,
            port: port,
            path: '/entity/req',
            method: 'POST',
            headers: {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': contents.length
            }
        }
        var req = http.request(options, function (res) {
            res.setEncoding('utf8');
            res.on('data', function (data) {
                console.log("data:", data);//返回数据
            });
        });
        req.write(contents);
        req.end();
    }

    再看第二种:application/json。

    application/json也就是告诉我们的服务器我们的消息体内容类型是序列化的JSON字符串,例如:{ "name": "value1", "pwd": "value2" }。获取到这个body直接解析Json格式字符串即可拿到参数数据。

    接下来分别用Java Spring MVC、Android OkHttp、Retrofit、JS Ajax、Nodejs分别演示下这种方式的请求和接口编写:

    在Java的Spring MVC中编写Controller接口接收解析application/json这种数据格式的需要在注解里定义consumes和produces为application/json类型。

    @CrossOrigin
        @RequestMapping(value = "/req", method = RequestMethod.POST,
                consumes = MediaType.APPLICATION_JSON_VALUE
                , produces = MediaType.APPLICATION_JSON_VALUE)
        @ResponseBody
        public String postReq(@RequestBody User user) {
            System.out.println("req:" + user.getName() + "  " + user.getPwd());
            Gson gson = new Gson();
            HashMap<String, String> map = new HashMap<>();
            map.put("name", user.getName());
            map.put("pwd", user.getPwd());
            return gson.toJson(map);
        }

    Retrofit定义的话就是要加上@Headers注解,里面声明Content-Type即可。

    //application/json
        @Headers({"Content-Type: application/json", "Accept: application/json"})
        @POST("req")
        Call<ResponseBody> getRepos(@Body Entity entity);

    Android OkHttp使用方法如下:

    public static void okPost() {
            OkHttpClient client = new OkHttpClient();
            client.newBuilder()
                    .build();
            //application/json
            MediaType mediaType = MediaType.parse("application/json; charset=utf-8");
            Gson gson = new Gson();
            HashMap<String, String> map = new HashMap<>();
            map.put("name", "name1");
            map.put("pwd", "pwd1");
            String postString = gson.toJson(map);
            RequestBody requestBody = RequestBody.create(mediaType, postString);
            
            Request request = new Request.Builder()
                    .post(requestBody)
                    .url(url)
                    .build();
            client.newCall(request).enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
                    System.out.println("onFailure:" + e.getLocalizedMessage());
                }
    
                @Override
                public void onResponse(Call call, Response response) throws IOException {
                    System.out.println("onResponse:" + response.body().string());
                }
            });
        }

    Ajax写法:

    /**
     * 原生Ajax POST请求
     */
    function getOrigantAjaxPost() {
        var postData = '{ "name": "value1", "pwd": "value2" }';
        var oAjax = null;
        //这里进行HTTP请求
        try {
            oAjax = new XMLHttpRequest();
        } catch (e) {
            oAjax = new ActiveXObject("Microsoft.XMLHTTP");
        };
        //post方式
        oAjax.open('post', 'http://' + hostName + ':' + port + '/entity/req', true);
        oAjax.setRequestHeader("Content-type", "application/json");
        //post发送数据
        oAjax.send(postData);
        oAjax.onreadystatechange = function () {
            //当状态为4的时候,执行以下操作
            if (oAjax.readyState == 4 && oAjax.status == 200) {
                try {
                    //+ oAjax.responseText
                    console.log('tryForm:' + oAjax.responseText);
                    // alert('readyState' + oAjax.status + "  "
                    //     + oAjax.responseText);
                } catch (e) {
                    // alert('你访问的页面出错了' + e);
                };
            };
        };
    }

    Jquery Ajax写法:

    /**
     * 原生Ajax POST请求
     */
    function getOrigantAjaxPost() {
        var postData = '{ "name": "value1", "pwd": "value2" }';
        $.ajax({
            data: postData,
            async: true,
            url: 'http://' + hostName + ':' + port + '/entity/req',
            type: "post",
            processData: false,  //tell jQuery not to process the data
            contentType: "application/json",  //tell jQuery not to set contentType
            success: function (data, status) {
                // alert("Data: " + status);
                console.log("Data: " + JSON.stringify(data) + "  " + status);
            },
            error: function (e) {
                // alert("Data: error" + JSON.stringify(e));
                console.log('error ' + JSON.stringify(e));
            }
        });
    }

    Nodejs的接口写法,只是变成bodyParser.json即可:

    var urlencodedParser = bodyParser.json({ extended: false })
    routes.post('/url', urlencodedParser, (req, res) => {
        //解析参数
        var params = req.body;
        var user = {};
        user.name = params.name;
        user.pwd = params.pwd;
        var response = { status: 1, data: user };
        res.send(JSON.stringify(response));
        res.end();
    });

    Nodejs请求的写法:

    /**
     * 原生POST请求
     */
    function getAPost() {
        var http = require('http');
        var contents='{ "name": "value1json", "pwd": "value2" }';
        var options = {
            host: hostName,
            port: port,
            path: '/entity/req',
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Content-Length': contents.length
            }
        }
        var req = http.request(options, function (res) {
            res.setEncoding('utf8');
            res.on('data', function (data) {
                console.log("data:", data);//返回数据
            });
        });
        req.write(contents);
        req.end();
    }

    接下来看下最后一种常用的Post请求的数据格式,:multipart/form-data。

    这种格式主要用来进行文件上传,当然可以作为表单内容进行键值对提交数据,各个表单项之间用boundary分开。

    接下来分别用Java Spring MVC、Android OkHttp、Retrofit、JS Ajax、Nodejs分别演示下这种方式的请求和接口编写:

    在Java的Spring MVC中编写Controller接口接收解析multipart/form-data这种数据格式的需要在注解里定义consumes和produces为multipart/form-data​​​​​​​类型。

    @CrossOrigin
        @RequestMapping(value = "/upReq", method = RequestMethod.POST,
                consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
        @ResponseBody
        public String uploadReq(@RequestPart(value = "file") MultipartFile multipartFile,
                                @RequestParam("description") String description) {
            String fileType = multipartFile.getContentType();
            String fileName = multipartFile.getOriginalFilename();
            File file = new File("E:/file.jpg");
            System.out.println("请求:" + fileType + " "
                    + fileName + "  " + description);
            try {
                multipartFile.transferTo(file);
                return "success";
            } catch (IOException e) {
                e.printStackTrace();
                return "failure";
            }
        }
    
        @CrossOrigin
        @RequestMapping(value = "/formReq", method = RequestMethod.POST,
                consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
        @ResponseBody
        public String formDataReq(@RequestParam String name,
                                  @RequestParam String pwd) {
            System.out.println("formReq:" + name + "  " + pwd);
            Gson gson = new Gson();
            HashMap<String, String> map = new HashMap<>();
            map.put("name", name);
            map.put("pwd", pwd);
            return gson.toJson(map);
        }

    Retrofit的写法就是加上@Multipart注解,参数用@Part进行注解:

        //multipart/form-data
        @Multipart
        @POST("req")
        Call<ResponseBody> getRepos(@Part("description") RequestBody description,
                                    @Part MultipartBody.Part file);

    Android OkHttp的写法是:

    public static void okPost() {
            OkHttpClient client = new OkHttpClient();
            client.newBuilder()
                    .build();
    
            //multipart/form-data
            File file = new File("E:/img.png");
            RequestBody fileBody = new MultipartBody.Builder()
                    .setType(MultipartBody.FORM)
                    .addFormDataPart("file", file.getName(),
                            RequestBody.create(MediaType.parse("image/png"), file))
                    .addFormDataPart("description", "description")
                    .build();
    
            Request request = new Request.Builder()
                    .post(fileBody)
                    .url(formUrl)
                    .build();
            client.newCall(request).enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
                    System.out.println("onFailure:" + e.getLocalizedMessage());
                }
    
                @Override
                public void onResponse(Call call, Response response) throws IOException {
                    System.out.println("onResponse:" + response.body().string());
                }
            });
        }

    Ajax写法是:

    /**
     * 原生Ajax POST请求
     */
    function getOrigantAjaxPost() {
        var oAjax = null;
        //这里进行HTTP请求
        try {
            oAjax = new XMLHttpRequest();
        } catch (e) {
            oAjax = new ActiveXObject("Microsoft.XMLHTTP");
        };
        var formData = new FormData();
        formData .append("file", file); // 文件对象
        formData .append("description", "description");
        //post方式
        oAjax.open('post', 'http://' + hostName + ':' + port + '/entity/formReq', true);
        // oAjax.setRequestHeader("Content-type", "multipart/form-data");
        //post发送数据
        oAjax.send(formData );
        oAjax.onreadystatechange = function () {
            //当状态为4的时候,执行以下操作
            if (oAjax.readyState == 4 && oAjax.status == 200) {
                try {
                    //+ oAjax.responseText
                    console.log('tryForm:' + oAjax.responseText);
                    // alert('readyState' + oAjax.status + "  "
                    //     + oAjax.responseText);
                } catch (e) {
                    // alert('你访问的页面出错了' + e);
                };
            };
        };
    }

    Jquery Ajax写法:

    /**
     * 原生Ajax POST请求
     */
    function getOrigantAjaxPost() {
        var form = new FormData();
        form.append("file", file); // 文件对象
        form.append("description", "image");
        $.ajax({
            data: form,
            async: true,
            url: 'http://' + hostName + ':' + port + '/entity/formReq',
            type: "post",
            processData: false,  //tell jQuery not to process the data
            contentType: "multipart/form-data",  //tell jQuery not to set contentType
            success: function (data, status) {
                // alert("Data: " + status);
                console.log("Data: " + data + "  " + status);
            },
            error: function (e) {
                // alert("Data: error" + JSON.stringify(e));
                console.log('error ' + JSON.stringify(e));
            }
        });
    }

    Nodejs接口写法,用了multipart:

    var multipartMiddleware = multipart();
    routes.post('/url', multipartMiddleware, (req, res) => {
        res.send("success:" + JSON.stringify(req.body) + " " + req.files.file.type);
        res.end();
    });

    Nodejs请求写法:

    /**
     * 原生POST请求
     */
    function getAPost() {
        var http = require('http');
        var formData = new FormData();
        formData.append('file', fs.createReadStream("./filename.zip"));
        formData.append('description', 'image');
        var options = {
            host: hostName,
            port: port,
            path: '/entity/req',
            method: 'POST',
            headers: {
                'Content-Type': 'multipart/form-data',
            }
        }
        var req = http.request(options, function (res) {
            res.setEncoding('utf8');
            res.on('data', function (data) {
                console.log("data:", data);//返回数据
            });
        });
        req.write(formData);
        req.end();
    }

    以上就是给大家介绍的主流Http Post的数据传输格式在各个语言上的用法。

     

    展开全文
  • HTTP POST body常见的四种数据格式

    千次阅读 2021-01-25 00:15:02
    1、HTTP POST body常见的四种数据格式 1.1、概述 HTTP 请求分为三个部分:状态行、请求头、消息主体。 <method> <request-URL> <version><headers><entity-body> 协议规定 POST ...

    1、HTTP POST body常见的四种数据格式

    1.1、概述

    • HTTP 请求分为三个部分:状态行、请求头、消息主体。
    <method> <request-URL> <version><headers><entity-body>
    
    • 协议规定 POST 提交的数据必须放在消息主体(entity-body)中(虽然拼接在url中也能请求,但服务器不一定能识别),但协议并没有规定数据必须使用什么编码方式。实际上,开发者完全可以自己决定消息主体的格式,只要最后发送的 HTTP 请求满足上面的格式就可以。当然对于服务器端的解析,不同的语言或者框架也会有一定的区别。

    1.2、body常见的四种数据格式

    • application/x-www-form-urlencoded
      • 浏览器的原生form表单,如果不设置 Content-Type 属性,则默认以 application/x-www-form-urlencoded 方式传输数据。
    POST <http://www.example.com> HTTP/1.1Content-Type: application/x-www-form-urlencoded;charset=utf-8title=test&sub%5B%5D=1&sub%5B%5D=2&sub%5B%5D=3(url编码)
    
    • multipart/form-data
      • 使用表单上传文件时,必须让 表单的 Content-Type 等于 multipart/form-data。
      • 支持传输多种文件格式,关于 multipart/form-data 的详细定义,查看 rfc1867
    POST <http://www.example.com> HTTP/1.1Content-Type:multipart/form-data; boundary=----WebKitFormBoundaryrGKCBY7qhFd3TrwA------WebKitFormBoundaryrGKCBY7qhFd3TrwAContent-Disposition: form-data; name="text"title------WebKitFormBoundaryrGKCBY7qhFd3TrwAContent-Disposition: form-data; name="file"; filename="chrome.png"Content-Type: image/png... content of chrome.png(省略) ...------WebKitFormBoundaryrGKCBY7qhFd3TrwA--
    
    • application/json
      • 也是现在用得比较多的一种方式JSON字符串,支持结构化的数据。
    POST <http://www.example.com> HTTP/1.1 Content-Type: application/json;charset=utf-8{"title":"test","sub":[1,2,3]}
    
    • text/xml
      • 一般用于传输xml格式的数据,这种数据格式相比于json稍微复杂,臃肿,但还常用来作为配置文件。
    POST <http://www.example.com> HTTP/1.1 Content-Type: text/xml<?xml version="1.0"?><methodCall>    <methodName>examples.getStateName</methodName>    <params>        <param>            <value><i4>41</i4></value>        </param>    </params></methodCall>
    

    1.3、参考文档

    展开全文
  • httpPost设置代理

    千次阅读 2018-10-12 14:26:32
    public JSONObject httpPost(String url, JSONObject jsonParam) {  // post请求返回结果  CloseableHttpClient httpClient = HttpClients.createDefault();  JSONObject jsonResult = null;  ...
  • HttpPost如何设置超时时间

    万次阅读 2019-07-25 16:54:13
    类:org.apache.http.client.methods.HttpPost 今天一位姓申的同事问,特做记录埋汰一下波波。:) //请求超时 httpclient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 3000); //读取...
  • [HttpPost] [Route("PostX")] public ActionResult<string> Post([FromBody] string value) { return value; } } Json请求   我们从最常见的json输入请求开始。 User-Agent: Fiddler Host: ...
  • http post传递map

    千次阅读 2019-05-30 09:51:06
    HttpPost httpPost = new HttpPost(url); httpPost.setHeader("Content-Type","application/json;charset=utf-8"); httpPost.setHeader("Accept","application/json"); try { httpPost.setEntity(new ...
  • Nodejs 发送HTTP POST请求实例

    万次阅读 2019-03-25 09:19:36
    项目里面需要用到使用NodeJs来转发HTTP POST请求,研究了很久最后才弄通,把过程记录一下: 接收端代码很简单,就是回送body.address属性: [javascript]view plaincopy print? exports.sendEmail=function(req,...
  • http post方式上传文件(C#)

    热门讨论 2010-07-30 11:45:25
    1.稍微修改可以实现自动上传文件 2.上传文件不受大小限制 3。文件上传过程中可以显示当前上传进度,当前平均上传速度、上传文件已花费时长 上传文件大小和总的文件大小百分比 4。保证文件的稳定传输
  • http post文件上传机制

    万次阅读 2018-03-16 11:40:30
    在开发中,我们使用的比较多的HTTP请求方式基本上就是GET、POST。其中GET用于从服务器获取数据,POST主要用于向服务器提交一些表单数据,例如文件上传等。而我们在使用HTTP请求时中遇到的比较麻烦的事情就是构造文件...
  • java发送httpPost请求

    万次阅读 2019-04-01 15:12:43
    最近调用外部厂商提供的Post接口,总结了几种方法: 一、项目的maven依赖: <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpcore</artifactId>...
  • 除了发送的文件主体之外,还能附加一些其他参数,例如本例中...public static string HttpPost(string url, string filepath, string filename, string token) { string strResult; try { FileStream fs = new F...
  • 最近项目要调用第三方接口来获取json数据,并解析数据入库。这里用到了kettle作为数据抽取工具。Kettle 除了常规的数据处理之外...”post“顾名思义应该就是http请求方式为post,这里查看源码也得到证实,是引入的o...
  • 单片机使用HTTP POST方式发送数据

    万次阅读 多人点赞 2018-03-25 15:16:49
    HTTP请求是依赖TCP的,也就是在单片机上面,我们一样可以使用,无非就是先发送一个http请求头,再发送正文,比如我最近就使用了http post方式发送数据到服务器,服务器端使用的是WEB API,单片机使用的STM32 与SIM...
  • 趁热打铁!HTTPGet 与HTTPPost的区别

    千次阅读 多人点赞 2018-03-22 20:01:00
    突然看到一个页面用了2种不同的传值类型,突然有了兴趣,想弄明白本质的区别,虽然以前用的知道2种的用法,但是还是云里雾里的,下面是那位大神的文章:原文链接 作者:WebTechGardenGET和POSTHTTP请求的两种基本...
  • PHP 获取 HTTP POST 请求的四种方式

    万次阅读 2019-07-02 15:29:17
    一、HTTP POST请求常见的四种方式 (1)application/x-www-form-urlencoded (2)multipart/form-data (3)application/json (4)text/xml 二、PHP获取参数的方式 一、HTTP POST请求常见的四种方式 ...
  • http post带参数请求

    千次阅读 2018-04-25 08:28:31
    import java.util.ArrayList; import java.util.List; import org.apache.http.NameValuePair; import org.apache....import org.apache.http.client.methods.CloseableHttp...
  • java用HttpPost发送post请求,传body

    万次阅读 2020-03-30 18:06:38
    try { HttpPost httppost = new HttpPost(clockAuditArticle); RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(200000) .setSocketTimeout(200000).build(); httppost.setConfig...
  • HTTP POST Flood&慢速攻击

    千次阅读 2019-01-07 16:17:51
    amp;tid=367981 0x01 HTTP POST Flood攻击与防御 ...书接上回,本篇我们来介绍HTTP POST Flood攻击和HTTP慢速攻击的原理及防御方式,先来看HTTP POST Flood攻击。攻击者利用攻击工具或者操纵僵尸主机,向目标...
  • httppost的用法

    万次阅读 2018-05-16 17:02:38
    (一)案例一定义了一个list,该list的数据类型是NameValuePair(简单名称值对节点类型),这个代码多处用于Java像url发送Post请求。...HttpPost httppost=new HttpPost(url); //建立HttpPost对象 L...
  • python3 http post get 收发数据

    千次阅读 2019-09-05 13:40:54
    python3 http post get 收发数据 from http.server import HTTPServer, BaseHTTPRequestHandler import json import urllib data = {'result':'this is test'} host = ('localhost',12345) class Resquest...
  • http post 请求raw(字符串请求)

    千次阅读 2020-03-18 14:48:23
    HttpURLConnection //post字符串请求 public String HttpPost(String url, String rawBody){ HttpURLConnection conn = null; PrintWriter pw = null ; BufferedReader rd = null ; ...
  • java代码实现http请求工具类封装 ...post方式请求:url:请求地址的字符串 jsonString:json字符串 注意:json字符串的生成的方法如下 需要封装的json格式如下: { "touser":"OPENID", ...
  • http postpost传输数据大小

    千次阅读 2020-05-07 14:19:27
    之前知道get请求对url请求长度有限制,post请求没有限制。今天在做程序的时候遇到了这个问题。 场景:我需要将前端生成的Svg图片转化base64生成字符串传入后台,后台根据字符串解码生成到PPT里面。 附:前端将svg...
  • Java利用HttpPost工具类提交数据

    千次阅读 2018-03-08 10:48:25
    需求:最近在网上找了一个weixin的工具包,但是利用在post提交的时候总是出错,看了下weixin工具包里面的提交方式是采用httpPost,于是自己也写了一个专门用于提交数据的工具类package com.wx.common; import java....
  • 导入HttpPost

    千次阅读 2017-08-01 09:47:48
    右键Module - Open Module Settings - Dependencies, 找到"+"按钮,选择Library dependency,弹出对话框, 输入org.apache.http.client 点击搜索,确认加入即可

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,324,213
精华内容 529,685
关键字:

httppost