rest访问

编程语言 2018-05-12 02:45:27 阅读次数: 0
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

public class HttpClientUtil {

private HttpClientUtil() {
}

private static RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(20000).setConnectTimeout(5000).build();// 设置请求和传输超时时间

public static String sendGetRequest(String reqURL) throws Exception {
return sendGetRequest(reqURL, "UTF-8");
}

/**
* 发送HTTP_GET请求
*
* @see 该方法会自动关闭连接,释放资源
* @param requestURL
*            请求地址(含参数)
* @param decodeCharset
*            解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码
* @return 远程主机响应正文
*/
public static String sendGetRequest(String reqURL, String decodeCharset) throws Exception {
String responseContent = null; // 响应内容
CloseableHttpClient httpClient = HttpClients.createDefault();
CloseableHttpResponse response = null;
HttpGet httpGet = new HttpGet(reqURL); // 创建org.apache.http.client.methods.HttpGet
try {
httpGet.setConfig(requestConfig);
response = httpClient.execute(httpGet); // 执行GET请求
HttpEntity entity = response.getEntity(); // 获取响应实体
if (null != entity) {
responseContent = EntityUtils.toString(entity, decodeCharset == null ? "UTF-8" : decodeCharset);
}
Header[] allHeaders = response.getAllHeaders();
for(Header head : allHeaders){
System.out.println(head.getName());
System.out.println(URLDecoder.decode(head.getValue(), "UTF-8"));
System.out.println(new String(head.getValue().getBytes("UTF-8"),"UTF-8"));
}
// System.out.println("请求地址: " + httpGet.getURI());
// System.out.println("响应状态: " + response.getStatusLine());
// System.out.println("响应长度: " + responseLength);
// System.out.println("响应内容: " + responseContent);
} catch (Exception e) {
throw new Exception(e);
} finally {
if (response != null) {
response.close();
}
httpClient.close();
}
return responseContent;
}

public static String sendPostRequest(String reqURL, String sendData) throws Exception {
return sendPostRequest(reqURL, sendData, null, false, null, null);
}

public static String sendPostRequest(String reqURL, String sendData, Map<String, String> header) throws Exception {
return sendPostRequest(reqURL, sendData, header, false, null, null);
}

/**
* 发送HTTP_POST请求
*
* @see 该方法为
*      <code>sendPostRequest(String,String,boolean,String,String)</code>
*      的简化方法
* @see 该方法在对请求数据的编码和响应数据的解码时,所采用的字符集均为UTF-8
* @see 当<code>isEncoder=true</code>时,其会自动对<code>sendData</code>中的[中文][|][
*      ]等特殊字符进行<code>URLEncoder.encode(string,"UTF-8")</code>
* @param isEncoder
*            用于指明请求数据是否需要UTF-8编码,true为需要
*/
public static String sendPostRequest(String reqURL, String sendData, boolean isEncoder) throws Exception {
return sendPostRequest(reqURL, sendData, null, isEncoder, null, null);
}

/**
* 发送HTTP_POST请求
*
* @see 该方法会自动关闭连接,释放资源
* @see 当<code>isEncoder=true</code>时,其会自动对<code>sendData</code>中的[中文][|][
*      ]等特殊字符进行<code>URLEncoder.encode(string,encodeCharset)</code>
* @param reqURL
*            请求地址
* @param sendData
*            请求参数,若有多个参数则应拼接成param11=value11¶m22=value22¶m33=value33的形式后,
*            传入该参数中
* @param isEncoder
*            请求数据是否需要encodeCharset编码,true为需要
* @param encodeCharset
*            编码字符集,编码请求数据时用之,其为null时默认采用UTF-8解码
* @param decodeCharset
*            解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码
* @return 远程主机响应正文
*/
public static String sendPostRequest(String reqURL, String sendData, Map<String, String> header, boolean isEncoder,
String encodeCharset, String decodeCharset) throws Exception {
String responseContent = null;
CloseableHttpClient httpClient = HttpClients.createDefault();
CloseableHttpResponse response = null;
HttpPost httpPost = new HttpPost(reqURL);
httpPost.setHeader(HTTP.CONTENT_TYPE, "application/x-www-form-urlencoded");
try {
if (header != null && header.size() > 0) {
for (String headerName : header.keySet()) {
httpPost.setHeader(headerName, header.get(headerName));
}
}
httpPost.setConfig(requestConfig);
if (isEncoder) {
List<NameValuePair> formParams = new ArrayList<NameValuePair>();
for (String str : sendData.split("&")) {
formParams.add(new BasicNameValuePair(str.substring(0, str.indexOf("=")),
str.substring(str.indexOf("=") + 1)));
}
httpPost.setEntity(new StringEntity(
URLEncodedUtils.format(formParams, encodeCharset == null ? "UTF-8" : encodeCharset)));
} else {
httpPost.setEntity(new StringEntity(sendData,"UTF-8"));
}
response = httpClient.execute(httpPost);
HttpEntity entity = response.getEntity();
if (null != entity) {
responseContent = EntityUtils.toString(entity, decodeCharset == null ? "UTF-8" : decodeCharset);
EntityUtils.consume(entity);
}
} catch (Exception e) {
throw new Exception(e);
// LogUtil.getLogger().error("与[" + reqURL + "]通信过程中发生异常,堆栈信息如下",
// e);
} finally {
if (response != null) {
response.close();
}
httpClient.close();
}
return responseContent;
}

public static String sendPostRequest(String reqURL, Map<String, String> params, Map<String, String> header)
throws Exception {
return sendPostRequest(reqURL, params, header, null, null);
}

public static String sendPostRequest(String reqURL, Map<String, String> params) throws Exception {
return sendPostRequest(reqURL, params, null, null, null);
}

/**
* 发送HTTP_POST请求
*
* @see 该方法会自动关闭连接,释放资源
* @see 该方法会自动对<code>params</code>中的[中文][|][ ]等特殊字符进行
*      <code>URLEncoder.encode(string,encodeCharset)</code>
* @param reqURL
*            请求地址
* @param params
*            请求参数
* @param encodeCharset
*            编码字符集,编码请求数据时用之,其为null时默认采用UTF-8解码
* @param decodeCharset
*            解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码
* @return 远程主机响应正文
*/
public static String sendPostRequest(String reqURL, Map<String, String> params, Map<String, String> header,
String encodeCharset, String decodeCharset) throws Exception {
String responseContent = null;
CloseableHttpClient httpClient = HttpClients.createDefault();
CloseableHttpResponse response = null;
HttpPost httpPost = new HttpPost(reqURL);
List<NameValuePair> formParams = new ArrayList<NameValuePair>(); // 创建参数队列
for (Map.Entry<String, String> entry : params.entrySet()) {
formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
}
try {
httpPost.setConfig(requestConfig);
httpPost.setEntity(new UrlEncodedFormEntity(formParams, encodeCharset == null ? "UTF-8" : encodeCharset));
if (header != null && header.size() > 0) {
for (String headerName : header.keySet()) {
httpPost.setHeader(headerName, header.get(headerName));
}
}

response = httpClient.execute(httpPost);
HttpEntity entity = response.getEntity();
if (null != entity) {
responseContent = EntityUtils.toString(entity, decodeCharset == null ? "UTF-8" : decodeCharset);
EntityUtils.consume(entity);
}
} catch (Exception e) {
throw new Exception(e);
// LogUtil.getLogger().error("与[" + reqURL + "]通信过程中发生异常,堆栈信息如下",
// e);
} finally {
if (response != null) {
response.close();
}
httpClient.close();
}
return responseContent;
}

/**
* 发送HTTPS_POST请求
*
* @see 该方法为
*      <code>sendPostSSLRequest(String,Map<String,String>,String,String)</code>
*      方法的简化方法
* @see 该方法在对请求数据的编码和响应数据的解码时,所采用的字符集均为UTF-8
* @see 该方法会自动对<code>params</code>中的[中文][|][ ]等特殊字符进行
*      <code>URLEncoder.encode(string,"UTF-8")</code>
*/
// public static String sendPostSSLRequest(String reqURL, Map<String,
// String> params) throws Exception {
// return sendPostSSLRequest(reqURL, params, null, null);
// }
//
// /**
// * 发送HTTPS_POST请求
// *
// * @see 该方法会自动关闭连接,释放资源
// * @see 该方法会自动对<code>params</code>中的[中文][|][ ]等特殊字符进行
// * <code>URLEncoder.encode(string,encodeCharset)</code>
// * @param reqURL
// * 请求地址
// * @param params
// * 请求参数
// * @param encodeCharset
// * 编码字符集,编码请求数据时用之,其为null时默认采用UTF-8解码
// * @param decodeCharset
// * 解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码
// * @return 远程主机响应正文
// */
// public static String sendPostSSLRequest(String reqURL, Map<String,
// String> params, String encodeCharset,
// String decodeCharset) throws Exception {
// String responseContent = "";
// CloseableHttpClient httpClient = HttpClients.createDefault();
// CloseableHttpResponse response = null;
// X509TrustManager xtm = new X509TrustManager() {
// public void checkClientTrusted(X509Certificate[] chain, String authType)
// throws CertificateException {
// }
//
// public void checkServerTrusted(X509Certificate[] chain, String authType)
// throws CertificateException {
// }
//
// public X509Certificate[] getAcceptedIssuers() {
// return null;
// }
// };
// try {
// SSLContext ctx = SSLContext.getInstance("TLS");
// ctx.init(null, new TrustManager[] { xtm }, null);
// SSLSocketFactory socketFactory = new SSLSocketFactory(ctx);
// httpClient.getConnectionManager().getSchemeRegistry().register(new
// Scheme("https", 443, socketFactory));
//
// HttpPost httpPost = new HttpPost(reqURL);
// List<NameValuePair> formParams = new ArrayList<NameValuePair>();
// for (Map.Entry<String, String> entry : params.entrySet()) {
// formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
// }
// httpPost.setEntity(new UrlEncodedFormEntity(formParams, encodeCharset ==
// null ? "UTF-8" : encodeCharset));
//
// response = httpClient.execute(httpPost);
// HttpEntity entity = response.getEntity();
// if (null != entity) {
// responseContent = EntityUtils.toString(entity, decodeCharset == null ?
// "UTF-8" : decodeCharset);
// EntityUtils.consume(entity);
// }
// } catch (Exception e) {
// throw new Exception(e);
// // LogUtil.getLogger().error("与[" + reqURL + "]通信过程中发生异常,堆栈信息为", e);
// } finally {
// httpClient.getConnectionManager().shutdown();
// }
// return responseContent;
// }
//
// /**
// * 发送HTTP_POST请求
// *
// * @see 若发送的<code>params</code>中含有中文,记得按照双方约定的字符集将中文
// * <code>URLEncoder.encode(string,encodeCharset)</code>
// * @see 本方法默认的连接超时时间为30秒,默认的读取超时时间为30秒
// * @param reqURL
// * 请求地址
// * @param params
// * 发送到远程主机的正文数据,其数据类型为<code>java.util.Map<String, String></code>
// * @return 远程主机响应正文`HTTP状态码,如<code>"SUCCESS`200"</code><br>
// * 若通信过程中发生异常则返回"Failed`HTTP状态码",如<code>"Failed`500"</code>
// */
// public static String sendPostRequestByJava(String reqURL, Map<String,
// String> params) throws Exception {
// StringBuilder sendData = new StringBuilder();
// for (Map.Entry<String, String> entry : params.entrySet()) {
// sendData.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
// }
// if (sendData.length() > 0) {
// sendData.setLength(sendData.length() - 1); // 删除最后一个&符号
// }
// return sendPostRequestByJava(reqURL, sendData.toString());
// }
//
// /**
// * 发送HTTP_POST请求
// *
// * @see 若发送的<code>sendData</code>中含有中文,记得按照双方约定的字符集将中文
// * <code>URLEncoder.encode(string,encodeCharset)</code>
// * @see 本方法默认的连接超时时间为30秒,默认的读取超时时间为30秒
// * @param reqURL
// * 请求地址
// * @param sendData
// * 发送到远程主机的正文数据
// * @return 远程主机响应正文`HTTP状态码,如<code>"SUCCESS`200"</code><br>
// * 若通信过程中发生异常则返回"Failed`HTTP状态码",如<code>"Failed`500"</code>
// */
// public static String sendPostRequestByJava(String reqURL, String
// sendData) throws Exception {
// HttpURLConnection httpURLConnection = null;
// OutputStream out = null; // 写
// InputStream in = null; // 读
// int httpStatusCode = 0; // 远程主机响应的HTTP状态码
// try {
// URL sendUrl = new URL(reqURL);
// httpURLConnection = (HttpURLConnection) sendUrl.openConnection();
// httpURLConnection.setRequestMethod("POST");
// httpURLConnection.setDoOutput(true); // 指示应用程序要将数据写入URL连接,其值默认为false
// httpURLConnection.setUseCaches(false);
// httpURLConnection.setConnectTimeout(30000); // 30秒连接超时
// httpURLConnection.setReadTimeout(30000); // 30秒读取超时
//
// out = httpURLConnection.getOutputStream();
// out.write(sendData.toString().getBytes());
//
// // 清空缓冲区,发送数据
// out.flush();
//
// // 获取HTTP状态码
// httpStatusCode = httpURLConnection.getResponseCode();
//
// // 该方法只能获取到[HTTP/1.0 200 OK]中的[OK]
// // 若对方响应的正文放在了返回报文的最后一行,则该方法获取不到正文,而只能获取到[OK],稍显遗憾
// // respData = httpURLConnection.getResponseMessage();
//
// // //处理返回结果
// // BufferedReader br = new BufferedReader(new
// // InputStreamReader(httpURLConnection.getInputStream()));
// // String row = null;
// // String respData = "";
// // if((row=br.readLine()) != null){
// // //readLine()方法在读到换行[\n]或回车[\r]时,即认为该行已终止
// // respData = row; //HTTP协议POST方式的最后一行数据为正文数据
// // }
// // br.close();
//
// in = httpURLConnection.getInputStream();
// byte[] byteDatas = new byte[in.available()];
// in.read(byteDatas);
// return new String(byteDatas) + "`" + httpStatusCode;
// } catch (Exception e) {
// e.printStackTrace();
// // throw new Exception(e);
// // LogUtil.getLogger().error(e.getMessage());
// return "Failed`" + httpStatusCode;
// } finally {
// if (out != null) {
// try {
// out.close();
// } catch (Exception e) {
// throw new Exception(e);
// // LogUtil.getLogger().error("关闭输出流时发生异常,堆栈信息如下", e);
// }
// }
// if (in != null) {
// try {
// in.close();
// } catch (Exception e) {
// throw new Exception(e);
// // LogUtil.getLogger().error("关闭输入流时发生异常,堆栈信息如下", e);
// }
// }
// if (httpURLConnection != null) {
// httpURLConnection.disconnect();
// httpURLConnection = null;
// }
// }
// }

public static void main(String[] args) {
try {
Map<String, String> header = new HashMap<String,String>();
header.put("Content-Type","application/json" );
String reqMsg = "{\"body\":{},\"head\":{\"timestamp\":\"2016-09-28 16:17:00\",\"sign\":\"\",\"appId\":\"5382261659\",\"accessToken\":\"access中文*.Token\",\"remark\":\"remark\",\"accessSign\":\"wangjun\",\"method\":\"fundFile\",\"format\":\"json\",\"version\":\"v1\",\"openId\":\"test\"}}";
String reqURL = "http://127.0.0.1:10002/openapi-netway-front/openapi/file/lfex";
// String fileContext = HttpClientUtil.sendPostRequest(reqURL,reqMsg,header);
byte[] responseContent = null;
CloseableHttpClient httpClient = HttpClients.createDefault();
CloseableHttpResponse response = null;
HttpPost httpPost = new HttpPost(reqURL);
httpPost.setHeader(HTTP.CONTENT_TYPE, "application/x-www-form-urlencoded");
try {
if (header != null && header.size() > 0) {
for (String headerName : header.keySet()) {
httpPost.setHeader(headerName, header.get(headerName));
}
}
httpPost.setConfig(requestConfig);
httpPost.setEntity(new StringEntity(reqMsg));
response = httpClient.execute(httpPost);
HttpEntity entity = response.getEntity();
if (null != entity) {
responseContent = EntityUtils.toByteArray(entity);
EntityUtils.consume(entity);
}
} catch (Exception e) {
throw new Exception(e);
// LogUtil.getLogger().error("与[" + reqURL + "]通信过程中发生异常,堆栈信息如下",
// e);
} finally {
if (response != null) {
response.close();
}
httpClient.close();
}


File file = new File("D:\\test\\file.dbf");
// byte bt[] = fileContext.getBytes("UTF-8"); 
FileOutputStream in = new FileOutputStream(file);
try {
in.write(responseContent, 0, responseContent.length);
in.close();
// boolean success=true;
// System.out.println("写入文件成功");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}











@Override
public String updateTest(CustInfoForm form) {
String reqUrl = url
+ "/videoCustInfo/updateTest";
Map<String, String> header = new HashMap<String, String>();
header.put("accessSign", openId);
header.put("Content-Type", "application/json");
String respStr = "";
try {
// 请求的业务参数，必须以json格式传递
String reqStr = "{" + "\"cuacctCode\":\"" + form.getCuacctCode() + "\","
+ "\"custName\":\"" + form.getCustName() + "\","
+ "\"custName\":\"" + form.getCustName() + "\","
+ "\"zipCode\":\"" + form.getZipCode() + "\","
+ "\"issuingAuthority\":\"" + form.getIssuingAuthority() + "\","
+ "\"startTime\":\"" + form.getStartTime() + "\","
+ "\"endTime\":\"" + form.getEndTime() + "\","
+ "\"address\":\"" + form.getAddress() + "\","
+ "\"addr\":\"" + form.getAddr() + "\"" + "}";
// 发送请求
respStr = HttpClientUtil.sendPostRequest(reqUrl, reqStr, header);
logger.info("test updateTest接口成功返回:::" + respStr + "请求参数:::" + reqStr+",请求url:::" + reqUrl);

} catch (Exception e) {
e.printStackTrace();
logger.info("调用test updateTest接口异常");
}

return respStr;
}

猜你喜欢

转载自niedashun201611260002.iteye.com/blog/2341449
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
【转】spring中对控制反转和依赖注入的理解
tms webcore 安装和使用
java程序员进阶相关书籍
SpringMVC接受请求参数、
如何保存训练好的机器学习模型
MyEclipse、Eclipse设置项目JDK的三个地方
商超行业微信小程序开发定制一般多少钱 （行业技术人员解读）
Markdown编辑器语言——30分钟入门到到精通
Linux系统下MongoDB的简单安装与基本操作
Power Strings
每日归档
更多
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022