post请求_post请求参数 - CSDN
精华内容
参与话题
  • 四种常见的post请求中的参数形式

    万次阅读 2019-01-11 13:14:07
    四种常见的post请求中的参数形式 post请求中的参数形式 一、初识post请求实例 1、Angular的ajax功能 AngularJs的ajax的post请求参数就是提交的json字符串。如: var data = {'name':'jack'}; $http.post(url,data)....

    四种常见的post请求中的参数形式

    post请求中的参数形式
    一、初识post请求实例
    1、Angular的ajax功能

    AngularJs的ajax的post请求参数就是提交的json字符串。如:

    var data = {'name':'jack'};
    $http.post(url,data).success(function(rsp){
        //    code
     })
    

    2、application/json

    JSON.stringify()的方法,服务端也有处理JSON的函数。

    //请求的参数要处理:

    JSON.stringify({name:'jack'})
    

    在这里插入图片描述

    图片描述
    二、四种常见的post请求方式:
    1、背景

    注:enctype 属性规定在发送到服务器之前应该如何对表单数据进行编码。默认地,表单数据会编码为 “application/x-www-form-urlencoded”
    在这里插入图片描述

    图片描述

    (1)、HTTP 协议是以 ASCII 码 传输,建立在 TCP/IP 协议之上的应用层规范。规范把 HTTP 请求分为三个部分:状态行、请求头、消息主体。
    (2)、协议规定 POST 提交的数据必须放在消息主体(entity-body)中,但协议并没有规定数据必须 使用什么编码方式 。实际上,开发者完全可以自己决定消息主体的格式,只要最后发送的 HTTP 请求满足上面的格式就可以。
    (3)、数据发送出去,还要服务端解析成功才有意义。一般服务端语言如 php、python 等,以及它们的 framework,都内置了自动解析常见数据格式的功能。服务端通常是根据请求头(headers)中的 Content-Type 字段来获知请求中的消息主体是用何种方式编码,再对主体进行解析。
    2、开始介绍四种方式:

    (1)、application/x-www-form-urlencoded
    这应该是最常见的 POST 提交数据的方式了。浏览器的原生 表单,如果不设置 enctype 属性,那么最终就会以 application/x-www-form-urlencoded 方式提交数据。

    <form action="form_action.asp" enctype="text/plain">
      <p>First name: <input type="text" name="fname" /></p>
      <p>Last name: <input type="text" name="lname" /></p>
      <input type="submit" value="Submit" />
    </form>
    

    此时可以看到,

    Content-Type: application/x-www-form-urlencoded;charset=utf-8
    title=test&sub%5B%5D=1&sub%5B%5D=2&sub%5B%5D=3

    首先,Content-Type 被指定为 application/x-www-form-urlencoded;其次,提交的数据按照 key1=val1&key2=val2 的方式进行编码,key 和 val 都进行了 URL 转码。大部分服务端语言都对这种方式很好的支持,常用的如jQuery中的ajax请求,Content-Type 默认值都是「application/x-www-form-urlencoded;charset=utf-8

    (2)、multipart/form-data
    这也是常见的post请求方式,一般用来上传文件,各大服务器的支持也比较好。所以我们使用表单 上传文件 时,必须让表单的enctype属性值为 multipart/form-data.

    注意:以上两种方式:application/x-www-form-urlencoded和multipart/form-data都是浏览器原生支持的。
    

    (3)、application/json
    application/json作为响应头并不陌生,实际上,现在很多时候也把它作为请求头,用来告诉服务端消息主体是序列化的JSON字符串,除了低版本的IE,基本都支持。除了低版本的IE都支持JSON.stringify()的方法,服务端也有处理JSON的函数,使用json不会有任何麻烦。例如:

    //请求数据
    var data = {name:'jack',sex:'man'};
    //请求数据序列化处理
    JSON.stingify(data);
    

    //结果:{‘name’:‘jack’,‘sex’:‘man’};

    (4)、text/xml
    三、postman中post请求的form-data、x-www-form-urlencoded、raw、binary的区别

    1、form-data:
    等价于http请求中的multipart/form-data,它会将表单的数据处理为一条消息,以标签为单元,用分隔符分开。既可以上传键值对,也可以上传文件。当上传的字段是文件时,会有Content-Type来表名文件类型;content-disposition,用来说明字段的一些信息;
    由于有boundary隔离,所以multipart/form-data既可以上传文件,也可以上传键值对,它采用了键值对的方式,所以可以上传多个文件。

    在这里插入图片描述
    图片描述

    2、x-www-form-urlencoded:
    等价于application/x-www-from-urlencoded,会将表单内的数据转换为键值对,比如,name=java&age = 23
    在这里插入图片描述
    图片描述

    3、raw
    可以上传任意格式的文本,可以上传text、json、xml、html等
    在这里插入图片描述
    图片描述

    4、binary
    相当于Content-Type:application/octet-stream,从字面意思得知,只可以上传二进制数据,通常用来上传文件,由于没有键值,所以,一次只能上传一个文件。

    multipart/form-data与x-www-form-urlencoded区别
    multipart/form-data:既可以上传文件等二进制数据,也可以上传表单键值对,只是最后会转化为一条信息;
    x-www-form-urlencoded:只能上传键值对,并且键值对都是间隔分开的。

    展开全文
  • HTTP请求详解含POST,GET实例

    万次阅读 多人点赞 2018-05-05 21:45:55
    HTTP的组成http消息由客户端到服务端的请求以及服务端到客户端的响应组成HTTP请求报文的格式请求头与请求正文中间有一行空行,是告诉服务器请求头到此结束了接下来是请求正文请求方法:get,post,head,delete等等,...

    前言

    单纯的copy代码没有用,本篇从http请求的基本原理开始为大家讲解,后边有实例,希望大家一步一步看完,这样无论编写什么请求我们都可以得心应手。

    HTTP的组成

    http消息由客户端到服务端的请求以及服务端到客户端的响应组成

    HTTP请求报文的格式

    请求头与请求正文中间有一行空行,是告诉服务器请求头到此结束了接下来是请求正文

    请求方法:get,post,head,delete等等,告诉服务器你的具体操作是什么

    URL:可以从互联网上得到资源的位置和访问方法的一种简洁标识。URL结构:协议://域名 or IP地址:端口号/目录/文件名.文件名后缀?参数=值
    协议版本:目前几乎用的都是http1.1版本,增加了一个很重要的特性它支持长连接,其他具体细微差别不做讲述。
    请求头:请求头部为请求报文添加了一些附加信息,由“名/值”对组成,每行一对,名和值之间使用冒号分隔。
    常用的请求头包括:

    请求正文:添加请求实体即你具体要请求的内容用于POST请求,GET不用

    HTTP响应报文格式


    HTTP状态码


    HTTP响应头


    解析

    通过上述分析,我们可以发现HTTP请求其实像发送邮件一样,我们告诉邮局地址,邮局发送邮件,请求头是我们附加的一些信息,可以告诉收件人,谁发的邮件,谁可以看

    ,这是一封加密的邮件,你要根据什么规则把这封邮件翻译过来等等规则,请求内容当然就是我们要发送的具体内容,响应就是收件人给我的回信,响应头会告诉我们一些附加信息比如他告诉我们,你发送的那个收件人没有(404)或者我正确收到了你的来信(200),我给你的响应是什么加密方式,你要怎么解码,响应内容就是他要告诉我们的具体内容,你也可以把邮局当做一个代理,收件人当做服务器。

    实战

    接下来,我们根据以上规则使用JAVA来构造一些请求

    POST不带请求实体请求方法

    import org.apache.http.HttpEntity;
    import org.apache.http.HttpResponse;
    import org.apache.http.NameValuePair;
    import org.apache.http.client.ClientProtocolException;
    import org.apache.http.client.HttpClient;
    import org.apache.http.client.entity.UrlEncodedFormEntity;
    import org.apache.http.client.methods.HttpGet;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.client.utils.URIBuilder;
    import org.apache.http.entity.ContentType;
    import org.apache.http.entity.StringEntity;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.DefaultHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.message.BasicNameValuePair;
    import org.apache.http.util.EntityUtils;
    
    public class TestHttp{
    	public void postOne(){
    		HttpClient client = new DefaultHttpClient();
    		HttpResponse response = null;
    		String url = "http://write.blog.csdn.net/postedit";
    		HttpPost post = new HttpPost(url);
    		post.setHeader("Content-Type", "application/json");
    		response = client.execute(post);
    		String	ret      = EntityUtils.toString(response.getEntity(),"UTF-8");
    		System.out.println(ret);
    }
    }
    解析:
    1,首先我们要构造一个客户端,apache对HttpClient这个类的解释是该接口仅表示HTTP请求执行的最基本合同,它不会对请求执行过程施加任何限制或具体细节,并且将状态管理,身份验证和重定向处理的细节留给个别实现。具体意思就是我们要发送HTTP请求就要先构造这个HTTPClient,但是涉及一些具体的细节比如cookies,header,request   body我们不需要用它来实现,这些具体的细节我们留给其他类来实现,
    2,我们构造一个请求地址,即我们要把这个请求发送给谁
    3,构建Post请求,HttpPost有一个构造器HttpPost(String uri) ,我们用这个构造器来初始化HttpPost
    4,添加header,HttpPost里有一个setheader和addheader方法,这些方法是它继承接口org.apache.http.HttpMessage得来的,这里说一下add和set的区别,首先同名header
    可以有多个,运行时使用第一个,当我们使用addheader时,如果同名header已经存在它会追加至原同名header后面,使用setheader时,他会覆盖同名的header,我在header
    中设定了我要发送的请求体是json形式的(实际上并未携带请求体,携带请求体的会在下边给例子)
    5,当我们构造好客户端,请求header,url地址后,此时就可以发送了,自然就是client.execute即执行这个请求
    6,接下来是接受响应,即我们发送完邮件后,别人给我们回信了,我们要设法获得这个回信的内容即HttpResponse response = client.execute(post) 来关联我们的请求和响应,意思就是这个响应是我执行这个请求的响应getEntity是这个类自带的方法,用来获取响应实体,即具体的响应内容,它还有很多方法,获取响应信息,感兴趣可以自行研究
    7,EntityUtils这个类主要是用来处理HttpEntity的,它有一些静态方法,我用的就是将这个响应实体以UTF-8的编码格式转换成字符串,最后打印出来

    具体响应

    <html><head><title>Object moved</title></head><body><h2>Object moved to <a href="https://passport.csdn.net/account/login?from=http%3a%2f%2fwrite.blog.csdn.net%2fpostedit">here</a>.</h2></body></html>
    解析:
    还有一些其他的内容,不在这里粘贴,返回的html代码是一个重新登录的地址链接,点击以后告诉我们重新登录,因为我访问的url是csdn的编辑页,不登录怎么可能直接访问呢,我们可以尝试使用cookie这里告诉大家一个进阶技巧,我们打开浏览器,启用开发者模式,然后重新登录一次,找到csdnbi这个接口,然后获取requestheader中的cookies
    具体如图:

    在这里找到cookie后我们使用post.setheader("Cookie","*****")就可越过登录,直接请求到这个页面了。感兴趣的可以试一下。

    具体响应

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head>    <script type="text/javascript" src="//static-blog.csdn.net/scripts/tingyun-rum.js"></script><title>编辑文章 - CSDN博客</title><meta http-equiv="Content-Type" content="text/html; charset=utf-8" />    <link type="text/css" rel="Stylesheet" href="http://c.csdnimg.cn/pig/blog/write/css/main.css" />    <!--new top-->        <link rel="stylesheet" href="http://c.csdnimg.cn/public/common/toolbar/css/index.css">     <!--new top-->       <script type="text/javascript" src="//static-blog.csdn.net/scripts/jquery.js"></script>    <script type="text/javascript" src="//static-blog.csdn.net/scripts/jquery-version.js"></script><script type="text/javascript" src="//static-blog.csdn.net/scripts/csdn.js"></script><script type="text/javascript" src="http://c.csdnimg.cn/pig/blog/write/scripts/master.js"></script>        <script type="text/javascript">var statichost = "//static-blog.csdn.net";</script>               <link type='text/css' rel='Stylesheet' href='http://c.csdnimg.cn/pig/blog/write/css/write.css' /><script type='text/javascript' src='http://c.csdnimg.cn/pig/blog/write/scripts/jquery.autocomplete.min.js'></script> <script type='text/javascript' src='//static-blog.csdn.net/xheditor/xheditor-1.1.13-zh-cn.js'></script><link type='text/css' rel='Stylesheet' href='http://c.csdnimg.cn/pig/blog/write/css/jquery.autocomplete.css' /></head><body></body></html>
    body里包含我的个人信息在这里就不给大家展示了

    POST带请求参数和请求实体

    前言:如果我们前边的都掌握了,那么接下来的就很容易理解了,我们知道post请求时会携带一些参数比如 http://www.123.com/index.html?a=123还有一些我们要发送的报文
    其实参数和报文的处理方式是一样的,那么我们只要构造这个请求实体不就可以了吗?
    		List<BasicNameValuePair> nvps = new ArrayList<BasicNameValuePair>();
    		nvps.add(new BasicNameValuePair("baowen","UTF-8"));
    		post.setEntity(new UrlEncodedFormEntity(nvps,"UTF-8"));

    解析:
    1,我们加入BasicNameValuePair,这个类是干嘛用的呢,apache的官方解释是用作HTTP消息元素的名称 - 值对参数。我们就用它来构造参数
    2,我为什么用list,因为有时你的参数可能不止一个,这是它的一个构造器BasicNameValuePair(String name, String value) ,报文一定要是字符串格式,UrlEncodedForm
      Entity(List<? extends NameValuePair> parameters, String charset) 我要用这个类来构造实体就必须使用list来添加参数,同时这个类实际上是继承StringEntity,它又实现了
    HttpEntity这个接口,知道这一点很重要。
    3,public void setEntity(HttpEntity entity)这个方法要传入一个HttpEntity类型的参数,所以后边我可以直接用。

    GET不带参数请求

    		HttpGet get = new HttpGet(url);
    		get.setHeader("Content-Type", "application/json");
    		HttpResponse rese = client.execute(get);
    		String redsa = EntityUtils.toString(rese.getEntity());

    GET携带参数请求

    		 CloseableHttpClient client3 = HttpClients.createDefault();
    		 List<NameValuePair> nvps2 = new ArrayList<NameValuePair>();
    		 nvps2.add(new BasicNameValuePair("baowen","213"));
    		 HttpResponse resep = null;
    		 URIBuilder builder = new URIBuilder(url);
    		 builder.setParameters(nvps2);
    		 HttpGet get21312 = new HttpGet(builder.build());
    		 response = client.execute(get21312);
    		 String sdf = EntityUtils.toString(response.getEntity(),"UTF-8");

    注意

    1,后边的代码我没有写完整,我们需要根据自己的需求添加URL
    2,header里我用的都是json,大家可以根据自己需要什么类型做改变
    3,我将返回都转换成了字符串,方便打印
    4,我这里使用的是apache的http包,关于网络编程,JAVA也有自带的java.net包

    总结

    通过上边的学习我们明白,只要我们掌握了http请求由什么组成,哪些类来构造这些东西,然后在解析响应剩下的就对我们来说很简单了。万变不离其宗,这次我发这个总结主要是由于之前发的一遍http 发送 post请求 的贴访问量很高,感觉有必要指引一下新入坑的同学们,当然我自己也在学习之中,欢迎大家留言,咱们互相探讨,共同进步












    展开全文
  • Post请求基本步骤

    千次阅读 2018-09-09 10:24:46
    接着我的博客前后端交互来,使用Post请求完成操作。 get方法从服务器获取数据。post方法向服务器提交数据。 public class MainActivity extends AppCompatActivity { OkHttpClient okHttpClient=new ...

    接着我的博客前后端交互来,使用Post请求完成操作。

    get方法从服务器获取数据。post方法向服务器提交数据。

    public class MainActivity extends AppCompatActivity {
        OkHttpClient okHttpClient=new OkHttpClient();
        private TextView textView;
        public String string=null;
        private String mBaseUrl="http://192.168.43.248:8080/OkHttp_Get/";
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
        }
        public void doPost(View view){
                //post参数并不是拼接到url后面,而是作为请求体发送到服务端的。post方法需要传入一个RequestBody
                //get一般是从服务器获取一些数据,即使是传递参数也比较简单。直接拼接到url后面就可以了
                // post一般往服务器提交一些数据,提交表单注册信息,他所提交的一些数据比如说参数一般是作为请求体post到服务器端的。需要requestbody构造request。
                //如何构造request呢?它也有builder.
            textView=(TextView)findViewById(R.id.textView);
            //1.拿到okHttpClient对象
            FormEncodingBuilder requestBodyBuilder=new FormEncodingBuilder();
            //2.构造Request
            //2.1构造requestBody
            RequestBody requestBody=requestBodyBuilder.add("username","hyman").add("password","123").build();//它只有三个方法,仅仅是为了传递键值对的。
            Request.Builder builder=new Request.Builder();
            Request request= builder.url(mBaseUrl+"login").post(requestBody).build();
            //3  4
            executeRequest(request);
        }
        public void doGet(View view){
            textView=(TextView)findViewById(R.id.textView);
            //OkHttpClient okHttpClient=new OkHttpClient();
            Request.Builder builder=new Request.Builder();
            Request request=builder.get().url(mBaseUrl+"login?username=hyman&password=123").build();
            executeRequest(request);
        }
    
        private void executeRequest(Request request) {
            Call call = okHttpClient.newCall(request);
    
            call.enqueue(new Callback() {
                @Override
                public void onFailure(Request request, IOException e) {
                    L.e("onFailure"+e.getMessage());
                    e.printStackTrace();
                }
    
                @Override
                public void onResponse(Response response) throws IOException {
                    L.e("onResponse:");
                    //该方法的返回值是response,所以我们可以通过response拿到相关信息。
                    string = response.body().string();//想拿到字符串,可以从response-body-string
                    L.e(string);
                    /*InputStream is=response.body().byteStream();//即使是一个文件我们这里也可以IO操作。容量也就是我们一个buffer大小。这样就支持大文件下载。*/
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            textView.setText(string);
                        }
                    });
                }
            });
        }
    }
    

    点击Post按钮,在textview上出现Login success

    MyEclipse控制台出现:hyman , 123

    使用post请求往服务器传输数据得到hyman 123,然后在前端也就是我们的模拟器上显示内容。

    get和简单的post的用法就结束了。

     

    postString方法:

    我们在实际开发过程中有一个post Json字符串到服务器。字符串中可能包含了很多信息(业务代码)。

     

    //将String作为requestBody post出去。和doPost唯一不同的是,requestBody的构造。
    // doPost是通过 FormEncodingBuilder去构造的,它主要是传递一个post参数的builder,
    // 我们要通过一个Builder构造一个requestBody,这个requestBody仅仅是一个字符串。我们不需要构造模式了
    public void doPostString(View view){
        textView=(TextView)findViewById(R.id.textView);
        //传递一个String
        RequestBody requestBody= RequestBody.create(MediaType.parse("text/plain;charset=utf-8"),"{username:hyman,password:123}");
        Request.Builder builder=new Request.Builder();
        Request request= builder.url(mBaseUrl+"postString").post(requestBody).build();
        //3  4
        executeRequest(request);
    }
    

    RequestBody的create方法:

    在MyEclipse userAction添加:

      //获取传递过来的String对象。postString()方法还需要配置。
        public String postString() throws IOException{
            HttpServletRequest request=ServletActionContext.getRequest();
            ServletInputStream is=request.getInputStream();
            //流变成字符串
            StringBuilder sb=new  StringBuilder();
            int len=0;
            byte[] buf=new byte[1024];
            while((len=is.read(buf))!=-1){
                sb.append(new String(buf,0,len));
            }
            System.out.println(sb.toString());
            return null;

        }

    struts.xml中添加:

     <action name="postString" class="com.imooc.action.UserAction" method="postString">
     </action>

    我们的预期结果是服务器端接收到{username:hyman,password:123}字符串。

    运行AS:点击POST STRING按钮。服务器MyEclipse控制台出现 {username:hyman,password:123

     

    我们介绍完了post与传递key value,postString接下来介绍用post传递File到服务端。

     

    public void doPostFile(View view){
        textView=(TextView)findViewById(R.id.textView);
        File file=new File(Environment.getExternalStorageDirectory(),"banner2.jpg");
        if(!file.exists()){
            L.e(file.getAbsolutePath()+"not exist!");
            return;
        }
        //mime type
        RequestBody requestBody= RequestBody.create(MediaType.parse("application/octet-stream"),file);
        Request.Builder builder=new Request.Builder();
        Request request= builder.url(mBaseUrl+"postFile").post(requestBody).build();
        //3  4
        executeRequest(request);
    }

     public String postFile() throws IOException{
            HttpServletRequest request=ServletActionContext.getRequest();
            ServletInputStream is=request.getInputStream();
            //files在Tomcat/webapps/OkHttp_Get,在这里新建文件夹files.
            String dir=ServletActionContext.getServletContext().getRealPath("files");
            File file=new File(dir,"banner2.jpg");
            FileOutputStream fos=new FileOutputStream(file);
            int len=0;
            byte[] buf=new byte[1024];
            while((len=is.read(buf))!=-1){
                fos.write(buf,0,len);
                
            }
            fos.flush();
            fos.close();
            
            return null;

        }

    struts.xml:

     <action name="postFile" class="com.imooc.action.UserAction" method="postFile">

     </action>

    把图片上传到服务器有权限问题,

    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

    post上传文件:到此我们已经完成了get post提交参数,post提交String,post提交file。还有post上传文件。了解过web的朋友肯定知道post是upload的一个文件,比如说一个表单,注册信息,填写相关的用户密码上传头像甚至是附件等等。post还可以提交文件。web开发的朋友知道它有一个属性,MultipartFormData必须设置到表单上面。OkHttp是如何上传图片的?

     

    //传递头像。
    public void doUpload(View view){
        textView=(TextView)findViewById(R.id.textView);
        File file=new File(Environment.getExternalStorageDirectory(),"banner2.jpg");
        if(!file.exists()){
            L.e(file.getAbsolutePath()+"not exist!");
            return;
        }
        //因为我们设计到文件还有参数可以考虑到又是一个构造者模式。其所涉及到的类叫MultipartBuilder.
        //"mPhoto"表单域,一般情况它是个input标签,他的type是file,所有的表单域都有个共性他有个name是key,通过key找到所对应的value、比如说表单域,文件的表单域肯定是个文件就代表了那个key。
        MultipartBuilder multipartBuilder=new MultipartBuilder();
        RequestBody requestBody= multipartBuilder.type(MultipartBuilder.FORM)
                .addFormDataPart("username","hyman")
                .addFormDataPart("password","123")
                .addFormDataPart("mPhoto","hyman.jpg",RequestBody.create(MediaType.parse("application/octet-stream"),file))
                .build();
        //mime type
        Request.Builder builder=new Request.Builder();
        Request request= builder.url(mBaseUrl+"uploadInfo").post(requestBody).build();
        //3  4
        executeRequest(request);
    }
    <Button
        android:id="@+id/button_doUpload"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="doUpload"
        android:text="Upload" />
    

    public class UserAction extends ActionSupport{
        private String username;
        private String password;
       public File mPhoto;//必须和AS的那个key是一模一样的.可以指定fileName和contentType
        public String mPhotoFileName;
        public String mPhotoContentType;//没有它会有警告。
        
        public String uploadInfo() throws IOException{
            System.out.println(username+","+password);
            if (mPhoto==null) {
                System.out.print(mPhotoFileName+"is null");
            }
            String dir=ServletActionContext.getServletContext().getRealPath("files");
            File file=new File(dir,mPhotoFileName);
            FileUtils.copyFile(mPhoto,file);
            return  null;

        }

    }

     <action name="uploadInfo" class="com.imooc.action.UserAction" method="uploadInfo">
      </action>

    结果是:点击Upload按钮,服务器端出现一张图片,图片命名为hyman.jpg ,同时我们拿到username,password。

     

    post下载文件:

     

    展开全文
  • 在Http请求里post是其中比较常用的提交数据的请求方式,...Post请求包含两部分:请求头(header)和请求体(body)。 Post常见的请求体(body)有三种传输内容类型Content-type:application/x-www-form-urlenco...

    在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参数到底应该怎么传?

    万次阅读 多人点赞 2019-11-25 15:51:02
    接口请求现在基本上是应用必备了, 各个请求库用了这么多年从来没出什么岔子. 不过最近却产生了一点疑惑, 为什么之前用的好好的POST方法访问新接口时提示传递参数为空呢? 为什么网络上的接口请求测试工具中有两种...
  • HTTP_POST请求的数据格式

    万次阅读 2018-05-23 20:41:31
    HTTP_POST请求的数据格式 在HTTP的请求头中,可以使用Content-type来指定不同格式的请求信息。 Content-type的类型 常见的媒体格式类型: &nbsp;&nbsp;&nbsp; text/html : HTML格式 &nbsp;&...
  • Postman发送post请求

    万次阅读 多人点赞 2018-06-01 12:38:03
    Postman发送post请求在服务器开发过程中,要经常对get,post接口进行测试,get请求,浏览器就可以完成,而post请求浏览器用起来有点麻烦,有的浏览器支持的不太好,个人用过火狐,还可以,今天介绍一下Postman发送...
  • 浏览器模拟发送post请求

    万次阅读 2017-10-23 17:05:53
    需求:有时候提供接口API给别的模块使用,为了模拟测试,需要发送post请求来测试。 解决办法: 1.可以自己写代码,发送post请求,但是对于入参仅仅是个int等基本类型或者String,那么就不用大费周章,浏览器插件...
  • 像这种情况明明是post请求,但是在请求的url中拼接了参数 其实是在axios.create使用自定义配置新建一个 axios 实例用了params配置项 1. params会将请求的参数拼接到url中去,用于get请求 2. data是添加到请求体...
  • 使用Jmeter发送post请求的两种方式

    万次阅读 2017-10-20 22:09:31
    之前我们有介绍过,常见的接口测试类型包括get型接口和post型接口。...而post型请求的参数不能随url...那么在Jmeter中如何发送post请求数据呢?根据post请求数据的格式,分两种情况进行介绍:map格式、json格式。 一、p
  • CURL 发送POST请求

    万次阅读 2019-07-02 16:28:05
    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...
  • JS实现使用POST方式发送请求

    万次阅读 2017-05-18 15:37:58
    window.location.href是我们常用来在js中实现页面跳转的方法,这是使用get方式发送请求,示例如下window....下面我们来讲下如何通过POST请求实现页面跳转。//发送POST请求跳转到指定页面 function httpPost(URL,
  • Request Payload 请求头部的Content-Type: application/json,请求正文是一个 json 格式的字符串 Form Data 请求头部的Content-Type: application/x-www-form-urlencoded,请求正文是类似 get 请求 url 的请求参数 ...
  • curl命令发送Post请求

    万次阅读 2015-12-16 15:01:25
    用curl工具发送请求:  curl url  只是把页面下载下来了,不能发送post请求。  如果要发送post请示... 通过脚本发送post请求,顺便附带文本数据,比如通过"浏览"选择本地的card.txt并上传发送post请求  答案: cu
  • 模拟POST、Get 请求的工具----APIpost(中文版POSTMAN) 快速生成、一键导出api文档 在线模拟调试,结果实时返回 模拟登录后请求API 支持团队协作 官网:https://www.apipost.cn/  ...
  • 1)确定需要POST的数据 2)拼接数据,POST给服务器 3)查看服务器响应及结果
  • XMLHttpRequest发送POST请求

    万次阅读 2016-05-07 14:57:21
    POST请求的适用性更广,可使用更大的请求参数,而且POST请求的请求参数通常不能直接看到。因此在使用Ajax发送请求时,尽量采用POST方式而不是GET方式发送请求。发送POST请求通常需要如下的三个步骤: 1) 使用open...
  • post 请求可以加?
  • postman为chrome浏览器的一个插件,用来模拟post请求,get请求等。可以在chrome浏览器里安装插件(前提是你得访问了Google应用商店)。 如果不能访问Google,那个下载一个postman的一个插件的客户端,功能是...
  • Http请求指的是客户端向服务器的请求...下面就来介绍一下Linux系统如何模拟Http的get或post请求。 一、get请求:  1、使用curl命令:  curl “http://www.baidu.com” 如果这里的URL指向的是一个文件或者一幅图都可
1 2 3 4 5 ... 20
收藏数 776,787
精华内容 310,714
关键字:

post请求