httpclient中 RequestEntity和RequestBody区别

最新推荐文章于 2024-05-25 22:41:53 发布
最新推荐文章于 2024-05-25 22:41:53 发布
阅读量4.5w 收藏 6
点赞数
分类专栏： RequestEntity和RequestBody 文章标签： RequestEntity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HackAge4619/article/details/68062693
版权

httpclient中定制提交的使用

有些情况会要求定制提交内容，例如一些ajax接口，
就要使用 RequestEntity
Java代码
RequestEntity requestEntity=new StringRequestEntity(text);   
  1. post.setRequestEntity(requestEntity);  


这个方法代替了以前直接设置Request body。
RequestEntity是一个接口，有很多实现：
ByteArrayRequestEntity, FileRequestEntity, InputStreamRequestEntity , MultipartRequestEntity, StringRequestEntity

基本上从名字上就可以直接看出功能，可以从字符串，流，文件，字节数组中产生request body。

还有更复杂的Multipart，就是夹杂文件和普通字段的提交。

比如提交一段xml，就可以直接用字符串提交来实现，模拟ajax , http+xml。


RequestEntity和RequestBody区别

httpclient的poseMethod提交数据，httpclient3.1采用RequestEntity接口替代以前的RequestBody。 
两种实现方式 供参考

代码片段(2)[全屏查看所有代码]

1. HttpRequestEntityUtils.java      

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
package com.allcam.sys.thirdplat.kmc;
 
import java.io.IOException;
import java.io.InputStream;
 
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.methods.ByteArrayRequestEntity;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.InputStreamRequestEntity;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.RequestEntity;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
public class HttpRequestEntityUtils
{
     protected static final int httpConnectionTimeOut = 30 ;
     
     protected final static Logger log = LoggerFactory.getLogger(HttpRequestEntityUtils. class );
     
     public static String post(String url, String params)
         throws IOException
     {
         String body = null ;
         HttpClient httpClient = null ;
         PostMethod method = null ;
         
         try
         {
             httpClient = new HttpClient();
             
             method = new PostMethod(url);
             // 链接超时30秒
             httpClient.getHttpConnectionManager().getParams().setConnectionTimeout( 1000 * httpConnectionTimeOut);
             // 读取超时30秒
             httpClient.getHttpConnectionManager().getParams().setSoTimeout( 1000 * httpConnectionTimeOut); //
             
             log.info( "create http post:" + url);
             RequestEntity requestEntity = new ByteArrayRequestEntity(params.getBytes( "UTF-8" ));
             
             method.setRequestEntity(requestEntity);
             if (method.getStatusCode() == HttpStatus.SC_OK)
             {
                 body = method.getResponseBodyAsString();
             }
             else
             {
                 log.error( "method.getStatusCode()" + method.getStatusCode());
             }
         }
         catch (IOException e)
         {
             log.error( "IOException" , e);
             throw e;
         }
         catch (Exception e)
         {
             log.error( "Exception" , e);
             throw e;
         }
         finally
         {
             if (method != null )
             {
                 method.releaseConnection();
             }
         }
         return body;
     }
     
     public static String postPushStream(String url, InputStream inputStream)
         throws IOException
     {
         String body = null ;
         HttpClient httpClient = null ;
         PostMethod method = null ;
         
         try
         {
             httpClient = new HttpClient();
             
             method = new PostMethod(url);
             // 链接超时30秒
             httpClient.getHttpConnectionManager().getParams().setConnectionTimeout( 1000 * httpConnectionTimeOut);
             // 读取超时30秒
             httpClient.getHttpConnectionManager().getParams().setSoTimeout( 1000 * httpConnectionTimeOut); //
             
             log.info( "create http post:" + url);
             RequestEntity requestEntity = new InputStreamRequestEntity(inputStream, "UTF-8" );
             
             method.setRequestEntity(requestEntity);
             if (method.getStatusCode() == HttpStatus.SC_OK)
             {
                 body = method.getResponseBodyAsString();
             }
             else
             {
                 log.error( "method.getStatusCode()" + method.getStatusCode());
             }
         }
         catch (IOException e)
         {
             log.error( "IOException" , e);
             throw e;
         }
         catch (Exception e)
         {
             log.error( "Exception" , e);
             throw e;
         }
         finally
         {
             if (method != null )
             {
                 method.releaseConnection();
             }
         }
         return body;
     }
     
     public static InputStream postGetStream(String url, String params)
         throws IOException
     {
         InputStream body = null ;
         HttpClient httpClient = null ;
         PostMethod method = null ;
         try
         {
             httpClient = new HttpClient();
             
             method = new PostMethod(url);
             // 链接超时30秒
             httpClient.getHttpConnectionManager().getParams().setConnectionTimeout( 1000 * httpConnectionTimeOut);
             // 读取超时30秒
             httpClient.getHttpConnectionManager().getParams().setSoTimeout( 1000 * httpConnectionTimeOut); //
             
             log.info( "create http post:" + url);
             RequestEntity requestEntity = new ByteArrayRequestEntity(params.getBytes( "UTF-8" ));
             
             method.setRequestEntity(requestEntity);
             if (method.getStatusCode() == HttpStatus.SC_OK)
             {
                 body = method.getResponseBodyAsStream();
             }
             else
             {
                 log.error( "method.getStatusCode()" + method.getStatusCode());
             }
         }
         catch (IOException e)
         {
             log.error( "IOException" , e);
             throw e;
         }
         catch (Exception e)
         {
             log.error( "Exception" , e);
             throw e;
         }
         finally
         {
             if (method != null )
             {
                 method.releaseConnection();
             }
         }
         return body;
     }
     
     public static String get(String url)
         throws IOException
     {
         String body = null ;
         HttpClient httpClient = null ;
         GetMethod method = null ;
         
         try
         {
             httpClient = new HttpClient();
             
             method = new GetMethod(url);
             // 链接超时30秒
             httpClient.getHttpConnectionManager().getParams().setConnectionTimeout( 1000 * httpConnectionTimeOut);
             // 读取超时30秒
             httpClient.getHttpConnectionManager().getParams().setSoTimeout( 1000 * httpConnectionTimeOut); //
             
             log.info( "create http get:" + url);
             if (method.getStatusCode() == HttpStatus.SC_OK)
             {
                 body = method.getResponseBodyAsString();
             }
             else
             {
                 log.error( "method.getStatusCode()" + method.getStatusCode());
             }
         }
         catch (IOException e)
         {
             log.error( "IOException" , e);
             throw e;
         }
         catch (Exception e)
         {
             log.error( "Exception" , e);
             throw e;
         }
         finally
         {
             if (method != null )
             {
                 method.releaseConnection();
             }
         }
         return body;
     }
}

2. HttpRequestBodyUtils.java 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 package com.allcam.sys.thirdplat.kmc;
 
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
 
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.ParseException;
import org.apache.http.client.ClientProtocolException;
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.methods.HttpUriRequest;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
public class HttpRequestBodyUtils
{
     protected final static Logger log = LoggerFactory.getLogger(HttpRequestBodyUtils. class );
     
     public static String post(String url, Map<String, String> params)
         throws IOException
     {
         DefaultHttpClient httpclient = new DefaultHttpClient();
         String body = null ;
         
         log.info( "create http post:" + url);
         HttpPost post = postForm(url, params);
         
         body = invoke(httpclient, post);
         
         httpclient.getConnectionManager().shutdown();
         
         return body;
     }
     
     public static String get(String url)
         throws IOException
     {
         DefaultHttpClient httpclient = new DefaultHttpClient();
         String body = null ;
         
         log.info( "create http post:" + url);
         HttpGet get = new HttpGet(url);
         body = invoke(httpclient, get);
         
         httpclient.getConnectionManager().shutdown();
         
         return body;
     }
     
     private static String invoke(DefaultHttpClient httpclient, HttpUriRequest httppost)
         throws IOException
     {
         
         HttpResponse response = sendRequest(httpclient, httppost);
         String body = paseResponse(response);
         
         return body;
     }
     
     private static String paseResponse(HttpResponse response)
         throws IOException
     {
         log.info( "get response from http server.." );
         HttpEntity entity = response.getEntity();
         
         log.info( "response status: " + response.getStatusLine());
         String charset = EntityUtils.getContentCharSet(entity);
         log.info(charset);
         
         String body = null ;
         try
         {
             body = EntityUtils.toString(entity);
             log.info(body);
         }
         catch (ParseException e)
         {
             log.error( "ParseException" , e);
             throw e;
         }
         catch (IOException e)
         {
             log.error( "IOException" , e);
             throw e;
         }
         catch (Exception e)
         {
             log.error( "Exception" , e);
             throw e;
         }
         return body;
     }
     
     private static HttpResponse sendRequest(DefaultHttpClient httpclient, HttpUriRequest httpost)
         throws IOException
     {
         log.info( "execute post..." );
         HttpResponse response = null ;
         
         try
         {
             response = httpclient.execute(httpost);
         }
         catch (ClientProtocolException e)
         {
             log.error( "ClientProtocolException" , e);
             throw e;
         }
         catch (IOException e)
         {
             log.error( "IOException" , e);
             throw e;
         }
         catch (Exception e)
         {
             log.error( "Exception" , e);
             throw e;
         }
         return response;
     }
     
     private static HttpPost postForm(String url, Map<String, String> params)
         throws UnsupportedEncodingException
     {
         
         HttpPost httpost = new HttpPost(url);
         List<NameValuePair> nvps = new ArrayList<NameValuePair>();
         
         Set<String> keySet = params.keySet();
         for (String key : keySet)
         {
             nvps.add( new BasicNameValuePair(key, params.get(key)));
         }
         
         try
         {
             log.info( "set utf-8 form entity to httppost" );
             httpost.setEntity( new UrlEncodedFormEntity(nvps, HTTP.UTF_8));
         }
         catch (UnsupportedEncodingException e)
         {
             log.error( "UnsupportedEncodingException" , e);
             throw e;
         }
         catch (Exception e)
         {
             log.error( "Exception" , e);
             throw e;
         }
         return httpost;
     }
}
写给初学者的几封信
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
httpClient模仿Basic Auth //@RequestBody使用
weixin_45143899的博客
05-12 378
@RequestBody使用 作用： 主要用来接收前端传递给后端的json字符串中的数据的(请求体中的数据的)； 要求： GET方式无请求体，所以使用@RequestBody接收数据时，前端不能使用GET方式提交数据，而是用POST方式进行提交。 在后端的同一个接收方法里，@RequestBody与@RequestParam()可以同时使用，@RequestBody最多只能有一个，而@RequestParam()可以有多个。 简言之： 一个请求——》只有一个@RequestBody； 一个请求——》可以有多
22-06-20 西安 ssm springmvc(03) RequestEntity、@RequestBody、@ResponseBody、ResponseEntity 、文件下载与文件上传
m0_56799642的博客
06-20 1721
2个注解和2个类型@RequestBody，@ResponseBody RequestEntity，ResponseEntity @RequestBody 将请求体和形参绑定 @RequestBody
JavaWeb常用注解
最新发布
CH_happy的博客
05-25 836
如果要注入的属性非常的多，并且还想做到复用，就可以定义这么一个bean对象。在其他的类当中，我要想获取到注入进来的属性，我直接注入 bin 对象，然后调用 get 方法，就可以获取到对应的属性值了。所以这项依赖它的作用就是会自动的识别被。答案是肯定有，在Spring中给我们提供了一种简化方式，可以直接将配置文件中配置项的值自动的注入到对象的属性中。一般将我们定义的controller，service，dao这些包呢，都放在引导类所在包com.xxx的子包下，这样我们定义的bean就会被自动的扫描到。
HttpClient发送Post请求————StringEntity 和 UrlEncodedFormEntity 的区别
热门推荐
WannaRunning的博客
03-29 4万+
一直用hutool的工具类做http调用，今天有空看了一下apache的httpclient，在实现带参数的post请求的时候看到有两个entity可以作为参数，再分别看了两个类在这做一下笔记。 首先说StringEntity StringEntity extends AbstractHttpEntity implements Cloneable 继承于AbstractHttpEntity...
使用HttpClient发起请求时将参数放入requestBody中
weixin_33721344的博客
08-09 7559
2019独角兽企业重金招聘Python工程师标准>>> ...
HttpClient发送请求 Required request body is missing
zhangtxsir的博客
03-02 1727
Required request body is missing出现的原因就是使用@RequestBody方式的问题 1.@RequestBody主要用来接收前端传递给后端的json字符串中的数据的(请求体中的数据的)； 2.GET方式无请求体，所以使用@RequestBody接收数据时，前端不能使用GET方式提交数据，而是用POST方式进行提交； 3.在后端的同一个接收方法里，@Request...
HttpClient请求接口@RequestBody无法获取参数
weixin_38164678的博客
10-26 1473
HttpClient请求接口@RequestBody无法获取参数 接口案例： 如图所示JSON.parseObject(jsonParam),后台报空指针， 原因： HttpClientUtil的post请求没有增加Content-type=application/json，HttpPost默认用的是application/x-www-form-urlencoded， 解决办法： 在工具类的请求头里追加： httpPost.setHeader(“Content-type”, ContentType.APP
jsp 中HttpClient中的POST方法实例详解
10-19
postMethod.setRequestBody(data); ``` 设置好请求体后，就可以执行POST请求了： ```java int statusCode = httpClient.executeMethod(postMethod); ``` 这里，`executeMethod`方法会返回HTTP响应的状态码。如果...
使用HttpURLConnection或HttpClient方式传json值到spring中
03-09
public ResponseEntity<?> handleJson(@RequestBody MyData myData) { // 处理myData对象 return ResponseEntity.ok().build(); } // 假设MyData是一个Java类，与JSON匹配 public static class MyData { ...
httpclient简单使用
09-09
public String sendPostRequest(String url, String requestBody) throws IOException { // 发送POST请求并返回响应体 } } ``` 8. **异常处理和资源关闭** 执行HTTP请求时可能出现IOException，因此应妥善...
HttpClient通过Post上传文件的实例代码
09-01
在实际应用中，当我们需要同时发送普通参数和文件到服务器时，HttpClient是一个理想的选择，因为它支持多部分请求，这是上传文件所必需的。 在HTTP中，POST请求通常用于向服务器提交数据，包括表单数据、文件等。...
AndroidHttpClient详解及调用示例
09-03
- 虽然HttpGet可以在URL中携带参数，但这种方式并不安全，建议使用HttpPost配合RequestBody传递参数，以提高安全性。 总的来说，AndroidHttpClient提供了方便的HTTP请求接口，尤其适合处理复杂的HTTP交互。然而，...
Springboot HttpClient createDefault @RequestBody 发送请求解决乱码问题
JesseCary的博客
06-15 1493
ApplyInfoDTO applyInfo=JSON.parseObject(strAppInfo,ApplyInfoDTO.class);     CancelReqData reqdata= HtInsured.installCancelReqData(applyInfo,date,channelCode);     String insureJson=JSON.toJSONString...
HttpEntity
qq_27000425的博客
06-07 629
HttpEntity和@RequestBody和@ResponseBody很像。出了能够访问请求和响应体，HttpEntity（和子类ResponseEntity）也能访问请求（和响应）头，就像这样： @RequestMapping("/something") public ResponseEntityString> handle(HttpEntitybyte[]> requestEntity)
springmvc二十六:springmvc-requestBody获取请求体, 与HttpEntity获取请求头
m0_37564426的博客
10-07 1263
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <% String path = request.getContextPath(); String basePath = request.getScheme()+"://"+request.getServerName()+":"+reques...
SpringMVC详解五、@ResponseBody、@RequestBody、HttpEntity、ResponseEntity、文件上传、HandlerInterceptor拦截器及异常处理
mxcsdn的博客
06-23 5074
1、MultipartFile ：文件上传2、使用@ResponseBody将返回的数据转成json        @JsonFormat修改时间在json中的格式3、使用@RequestBody接收请求体数据4、使用HttpEntity参数获取请求头和请求体5、使用ResponseEntity返回值操作响应头和响应体:下载文件6、HandlerInterceptor拦截器7、异常处理1、文件上传...
JAVA使用http包进行url接口调用以及返回值处理 HttpEntity ResponseEntity
weixin_41147129的博客
12-02 2949
一个request包含 header和request body，我们用 HttpEntity<body,header>来构造一个请求 发出request之后会得到 response 用ResponseEntity来接收返回内容 在发送请求的时候，可以使用 HttpClient RestTemplate OkHttp 一个文章看下三者的区别和使用方法。 这里用的okhttpRestTemplate 是自己写的一个util 基本用法和 restTemplate一样。 https://blog.
Java Httpclient 常用请求一篇就够用了
微笑的 Java
08-12 472
/** * httpHelper 帮助类 */ public class HttpHelper { public static final Logger logger = Logger.getLogger(HttpHelper.class.getName()); public static int SOCKETTIMEOUT = 5000; // get 请求 public static JSONObject httpGet(String url) { HttpGet h..
request entity too large
07-27
根据引用\[1\]和引用\[2\]的内容，文件无法上传可能有以下几个原因： 1. 服务器对上传文件大小做了限制，例如Nginx、Apache、IIS等服务器。可以通过修改服务器配置文件来增加文件大小限制。在Nginx中，可以在nginx.conf的http{}中设置client_max_body_size参数来增加文件大小限制。 2. 网关对上传文件大小做了限制。可以通过添加配置来增加文件大小限制。 3. SpringBoot/Spring对上传文件大小做了限制。可以通过添加配置来增加文件大小限制。 4. 文件确实过大，导致前后端链接超时，自动断开链接。可以在前端做限制，例如限制文件大小或者增加链接超时时间。 综上所述，如果出现"request entity too large"的错误，可能是由于文件大小超过了服务器或者网关的限制，或者文件确实过大导致链接超时。可以根据具体情况来调整服务器、网关或者前端的配置来解决该问题。 #### 引用[.reference_title] - *1* *2* [413 Request Entity Too Large](https://blog.csdn.net/weixin_47162914/article/details/127325350)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [出现 Request Entity Too Large问题的解决方法](https://blog.csdn.net/jewelry008/article/details/77865147)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值