http请求工具
public class WebConstant {
// HTTP参数传递方式
public final static int by_header = 1;
public final static int by_params = 2;
}
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.lang3.StringUtils;
/**
* 操作HttpServletRequest的参数(以后可能通过类似ServletRequestWrapper实现)
*
* @author ybbk
* @date Jun 5, 2009 2:55:16 PM
* @version 0.0.1-snapshot
*/
public class ParamUtils {
/**
* 对参数按字典升序排序 ，并且去掉不需要的参数<br>
*
* @param params
* @param ignoreParams
* @return
*/
public static Map<String, Object> sortParams(Map<String, Object> params,
List<String> ignoreParams) {
Collection<String> keyset = params.keySet();
List<String> list = new ArrayList<String>(keyset);
// 对key键值按字典升序排序
Collections.sort(list);
// 签名步骤一：按字典排序参数
Map<String, Object> result = new TreeMap<String, Object>();
for (Iterator<String> it = list.iterator(); it.hasNext();) {
String key = it.next();
if (ignoreParams != null && ignoreParams.contains(key)) {
continue;
}
result.put(key, params.get(key));
}
return result;
}
/**
* 作用：格式化参数， name=xx&age=xx
*
* @param params
* @param urlencode
* @param escapeBlank 是否去掉值是空的参数
* @return
* @throws UnsupportedEncodingException
*/
public static String formatParamMap(Map<String, Object> params, boolean needEncode,
boolean escapeBlank, String charSet) throws UnsupportedEncodingException {
StringBuilder sb = new StringBuilder();
for (Iterator<String> it = params.keySet().iterator(); it.hasNext();) {
String key = it.next();
Object value = params.get(key);
if (value == null && escapeBlank) {
continue;
} else {
if (value instanceof String) {
String str = (String) value;
if (StringUtils.isBlank(str) && escapeBlank) {
continue;
} else {
if (needEncode) {
value = URLEncoder.encode(value + "", charSet);
}
}
}
}
sb.append(key).append("=").append(value).append("&");
}
String result = sb.toString();
if (result.length() > 0) {
result = result.substring(0, result.length() - 1);
}
return result;
}
/**
* 去掉空白的参数
*
* @param params
* @param needEncode
* @param charSet
* @return
* @throws UnsupportedEncodingException
*/
public static String formatParamMap(Map<String, Object> params, boolean needEncode,
String charSet) throws UnsupportedEncodingException {
return formatParamMap(params, needEncode, true, charSet);
}
/**
* 模糊匹配某类参数值，如new-img-*
*
* @param request
* @param paramNamePrefix
* @return
*/
public static List<String> getValues(HttpServletRequest request, String paramNamePrefix) {
Map requestParams = request.getParameterMap();
List<String> results = new ArrayList<String>();
for (Iterator iter = requestParams.keySet().iterator(); iter.hasNext();) {
String name = (String) iter.next();
if (name.startsWith(paramNamePrefix)) {
String[] values = (String[]) requestParams.get(name);
for (String value : values) {
results.add(value);
}
}
}
return results;
}
/**
* 模糊匹配某类参数名称，如new-img-*
*
* @return
*/
public static List<String> getParamters(HttpServletRequest request, String paramNamePrefix) {
Map requestParams = request.getParameterMap();
List<String> params = new ArrayList<String>();
for (Iterator iter = requestParams.keySet().iterator(); iter.hasNext();) {
String name = (String) iter.next();
if (name.startsWith(paramNamePrefix)) {
params.add(name);
}
}
return params;
}
/**
* 得到Http参数
*
* @param request HttpServletRequest
* @param paramName 参数名
* @param defaultStr 默认值
* @return
*/
public static String getString(HttpServletRequest request, String paramName, String defaultStr) {
String value = request.getParameter(paramName);
if (value == null) {
return defaultStr;
}
return value.trim();
}
/**
* 得到Http字符串数组参数
*
* @param request HttpServletRequest
* @param paramName 参数名
* @return
*/
public static String[] getStringArray(HttpServletRequest request, String paramName) {
return request.getParameterValues(paramName);
}
/**
* 得到整形参数
*
* @param request HttpServletRequest
* @param paramName 参数名
* @param defaultInt 默认值
* @return
*/
public static Integer getInteger(HttpServletRequest request, String paramName, int defaultInt) {
String value = request.getParameter(paramName);
if (value == null) {
return defaultInt;
}
try {
return new Integer(value);
} catch (NumberFormatException e) {
return defaultInt;
}
}
public static Integer[] getIntegerArray(HttpServletRequest request, String paramName) {
String[] values = getStringArray(request, paramName);
if (values == null) {
return null;
}
List<Integer> list = new ArrayList<Integer>();
for (String value : values) {
try {
Integer paramValue = new Integer(value);
list.add(paramValue);
} catch (NumberFormatException e) {
}
}
return list.toArray(new Integer[] {});
}
public static Long getLong(HttpServletRequest request, String paramName, long defaultLong) {
String value = request.getParameter(paramName);
if (value == null) {
return defaultLong;
}
try {
return new Long(value);
} catch (NumberFormatException e) {
return defaultLong;
}
}
public static Long[] getLongArray(HttpServletRequest request, String paramName) {
String[] values = getStringArray(request, paramName);
if (values == null) {
return null;
}
List<Long> list = new ArrayList<Long>();
for (String value : values) {
try {
Long paramValue = new Long(value);
list.add(paramValue);
} catch (NumberFormatException e) {
}
}
return list.toArray(new Long[] {});
}
public static Double getDouble(HttpServletRequest request, String paramName,
double defaultDouble) {
String value = request.getParameter(paramName);
if (value == null) {
return defaultDouble;
}
try {
return new Double(value);
} catch (NumberFormatException e) {
return defaultDouble;
}
}
public static Double[] getDoubleArray(HttpServletRequest request, String paramName) {
String[] values = getStringArray(request, paramName);
if (values == null) {
return null;
}
List<Double> list = new ArrayList<Double>();
for (String value : values) {
try {
Double paramValue = new Double(value);
list.add(paramValue);
} catch (NumberFormatException e) {
}
}
return list.toArray(new Double[] {});
}
/**
* 把HttpServletRequest中所有的参数重新组织,形成新的查询字符串.用于转向页面时,保存request中的参数值不丢失
*
* @param request
* @param encoding URL编码格式
* @return 新的参数排除.格式是: aaa=value&bbb=value&
*/
@SuppressWarnings("rawtypes")
public static String getFullRequestUrl(HttpServletRequest request, String encoding) {
StringBuffer sb = new StringBuffer();
Map requestParams = request.getParameterMap();
for (Iterator iter = requestParams.keySet().iterator(); iter.hasNext();) {
String name = (String) iter.next();
String[] values = (String[]) requestParams.get(name);
for (String value : values) {
try {
sb.append(name).append("=").append(java.net.URLEncoder.encode(value, encoding))
.append("&");
} catch (UnsupportedEncodingException e) {
}
}
}
return sb.toString();
}
public static String getFullRequestUrl(String url, Map params, String ext, String encoding) {
return getFullRequestUrl(url, params, ext, encoding, true, false);
}
/**
* 将参数拼接到URL后面
*
* @param url
* @param params
* @param ext 如#tip3
* @param encoding
* @param needEncode 是否需要编码
* @param dropEmpty 去掉空的参数，如name=
* @return
*/
@SuppressWarnings("rawtypes")
public static String getFullRequestUrl(String url, Map params, String ext, String encoding,
boolean needEncode, boolean dropEmpty) {
StringBuffer sb = new StringBuffer();
for (Iterator iter = params.keySet().iterator(); iter.hasNext();) {
String name = (String) iter.next();
Object value = params.get(name);
try {
if (value == null) {
if (dropEmpty) {
continue;
}
sb.append(name).append("=&");
} else {
String str = value.toString();
if (StringUtils.isBlank(str) && dropEmpty) {
continue;
}
if (needEncode) {
str = java.net.URLEncoder.encode(str, encoding);
}
sb.append(name).append("=").append(str).append("&");
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
String requesturl = url + "?" + sb.toString();
if (requesturl.lastIndexOf("&") != -1) {
requesturl = requesturl.substring(0, requesturl.length() - 1);
}
if (StringUtils.isNotBlank(ext)) {
requesturl = requesturl + ext;
}
return requesturl;
}
/**
* 将参数拼接到URL后面，除了参数外，不带多余的#信息，默认使用utf8进行encode
*
* @param url
* @param params
* @param ext
* @param encoding
* @return
*/
@SuppressWarnings("rawtypes")
public static String getFullRequestUrl(String url, Map params) {
return getFullRequestUrl(url, params, "", "utf-8");
}
/**
* 把HttpServletRequest中所有的参数重新组织,形成新的查询字符串.用于转向页面时,保存request中的参数值不丢失,默认utf-8 编码
*
* @param request
* @return 新的参数排除.格式是: aaa=value&bbb=value&
*/
public static String getFullRequestUrl(HttpServletRequest request) {
return getFullRequestUrl(request, "utf-8");
}
/**
* 得到当前的URL及所有参数,用于转向页面时,保存request中的参数值不丢失,默认utf-8编码
*
* @param request
* @return 请求地址中,完整的URL和参数
*/
public static String getRequestUrl(HttpServletRequest request) {
String requesturl = request.getRequestURL().toString();
String params = getFullRequestUrl(request);
if (params.length() > 0) {
requesturl = requesturl + "?" + params;
}
return requesturl;
}
/////////////////////////////////////////////////////////
/**
* @param request
* @return
*/
public static Map<String, String> parseFromHeader(HttpServletRequest request) {
Map<String, String> params = new HashMap<String, String>();
@SuppressWarnings("unchecked")
Enumeration<String> e = request.getHeaderNames();
while (e.hasMoreElements()) {
String key = e.nextElement();
params.put(key.toLowerCase(), request.getHeader(key));
}
return params;
}
/**
* 请求参数组转换成Map
*/
public static Map<String, String> parameterToMap(HttpServletRequest request) {
Map<String, String> params = new HashMap<String, String>();
@SuppressWarnings("unchecked")
Enumeration<String> e = request.getParameterNames();
while (e.hasMoreElements()) {
String key = e.nextElement();
params.put(key, request.getParameter(key));
}
return params;
}
/**
* 请求参数组换成字符串, 格式为: key=value. 方便打印日志
*/
public static String parameterToString(HttpServletRequest request) {
StringBuffer sb = new StringBuffer();
@SuppressWarnings("unchecked")
Enumeration<String> e = request.getParameterNames();
while (e.hasMoreElements()) {
String key = e.nextElement();
sb.append(key).append("=").append(request.getParameter(key)).append(" ");
}
return sb.toString();
}
/**
* POST请求的BODY转化为String
*
* @param request
* @return
* @throws IOException
*/
public static String contentToString(HttpServletRequest request) throws IOException {
try {
java.io.BufferedReader reader =
new java.io.BufferedReader(new java.io.InputStreamReader(request.getInputStream()));
StringBuffer sb = new StringBuffer();
String tmp = null;
while ((tmp = reader.readLine()) != null) {
sb.append(tmp).append("\r\n");
}
return sb.toString();
} catch (IOException e) {
throw e;
}
}
/**
* 请求参数表转转换. 转换规则为,参数名前加上"c_"以和数据库字段名一致. 重要规则: 数据库建表时, 接口字段统一为字符串型, 字段名为 c_参数名
*/
public static void parserParameter(HttpServletRequest request, Map<String, Object> params,
String[] parameterList) {
for (String k : parameterList) {
String v = ParamUtils.getString(request, k, "");
params.put("c_".concat(k), v);
}
}
/**
* 请求参数表转转换. 传入二维数组,数组为: 参数名, 列名
*/
public static void parserParameter(HttpServletRequest request, Map<String, Object> params,
String[][] parameterList) {
for (String[] k : parameterList) {
String v = ParamUtils.getString(request, k[0], "");
params.put(k[1], v);
}
}
/**
* 信息费转换
*
* @param price 信息费 单位：分
*/
public static BigDecimal getPrice(String price/* 信息费：单位：分 */) {
BigDecimal amount = null;
try {
float fee = Float.parseFloat(price);
amount = new BigDecimal(fee / 100);
} catch (NumberFormatException e) {
amount = null;
}
return amount;
}
/**
* 转码转换
*
* @param inputStr
* @param srcEncoding
* @param dstEncoding
* @return
*/
public static String encoding(String inputStr, String srcEncoding, String dstEncoding) {
try {
return new String(inputStr.getBytes(srcEncoding), dstEncoding);
} catch (UnsupportedEncodingException e) {
}
return inputStr;
}
/**
* 将参数从request封装到指定bean
*
* @author: hejianhui@wegooooo.com
* @param request
* @param clazz
* @return
* @return: Object
* @time: 2016年7月11日 下午4:05:43
*/
@SuppressWarnings("rawtypes")
public Object request2bean(HttpServletRequest request, Class clazz) {
try {
Field[] file = clazz.getDeclaredFields();
Object obj = clazz.newInstance();
for (int i = 0; i < file.length; i++) {
String value = request.getParameter(file[i].getName());
BeanUtils.setProperty(obj, file[i].getName(), value);
}
return obj;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
.
import com.google.gson.Gson;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.net.ssl.SSLContext;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
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.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustStrategy;
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.ssl.SSLContextBuilder;
import org.apache.http.util.CharsetUtils;
import org.apache.http.util.EntityUtils;
import org.springframework.util.CollectionUtils;
/**
* http请求工具
*/
@Slf4j
public class HttpRequestClient {
public static class MyX509TrustManager implements TrustStrategy {
@Override
public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
return true;
}
}
public static CloseableHttpClient createHttpClient(boolean enableSSL) throws Exception {
try {
if (enableSSL) {
SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new MyX509TrustManager())
.build();
SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext);
return HttpClients.custom().setSSLSocketFactory(sslsf).build();
} else {
return HttpClients.createDefault();
}
} catch (Exception e) {
throw e;
}
}
public static String doPostText(String url, String text, boolean enableSSL) throws Exception {
CloseableHttpClient httpclient = createHttpClient(enableSSL);
HttpPost httpPost = new HttpPost(url);
CloseableHttpResponse response = null;
try {
httpPost.setEntity(new StringEntity(text, "utf-8"));
response = httpclient.execute(httpPost);
org.apache.http.HttpEntity entity = response.getEntity();
if (response.getStatusLine().getStatusCode() == org.apache.http.HttpStatus.SC_OK) {
if (entity != null) {
String result = EntityUtils.toString(entity, "utf-8");
EntityUtils.consume(entity);
return result;
} else {
return null;
}
}
EntityUtils.consume(entity);
return null;
} catch (ClientProtocolException e) {
throw new Exception(e);
} catch (IOException e) {
throw new Exception(e);
} finally {
try {
if (response != null) {
response.close();
}
} catch (IOException e) {
throw new Exception(e);
}
}
}
public static byte[] getBytes(String urlPath) throws Exception {
InputStream inStream = getInputStream(urlPath);
if (inStream != null) {
return readStream(inStream);
}
return null;
}
private static byte[] readStream(InputStream inStream) throws Exception {
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int len = 0;
while ((len = inStream.read(buffer)) != -1) {
outStream.write(buffer, 0, len);
}
outStream.close();
inStream.close();
return outStream.toByteArray();
}
public static InputStream getInputStream(String urlPath) throws IOException {
URL url = new URL(urlPath);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setConnectTimeout(5 * 1000);
conn.setRequestMethod("GET");
if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {
return conn.getInputStream();
}
return null;
}
public static void saveToFile(String urlPath, File saveFile)
throws Exception {
URL url = new URL(urlPath);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setConnectTimeout(5 * 1000);
conn.setRequestMethod("GET");
if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {
InputStream is = conn.getInputStream();
FileOutputStream fos = new FileOutputStream(saveFile);
byte[] buffer = new byte[1024];
int len = 0;
while ((len = is.read(buffer)) != -1) {
fos.write(buffer, 0, len);
}
is.close();
fos.close();
}
}
public static String doGetByParams(String url, Map<String, Object> params)
throws Exception {
return doGet(WebConstant.by_params, url, params);
}
public static String doGetByHeader(String url, Map<String, Object> params)
throws Exception {
return doGet(WebConstant.by_header, url, params);
}
public static String doGet(int paramsPassMethod, String url,
Map<String, Object> params) throws Exception {
return doGet(paramsPassMethod, url, params, false, null);
}
public static String doGet(int paramsPassMethod, String url,
Map<String, Object> params, boolean enableSSL, HttpClient client) throws Exception {
return doGet(paramsPassMethod, url, params, enableSSL, client, "utf-8");
}
public static String doGet(int paramsPassMethod, String url,
Map<String, Object> params, boolean enableSSL, HttpClient client, String charset) throws Exception {
log.info("doGet():url={};params={};", url, params);
if (WebConstant.by_params != paramsPassMethod
&& WebConstant.by_header != paramsPassMethod) {
throw new Exception("不支持的参数传递方式");
}
if (StringUtils.isEmpty(url)) {
throw new Exception("URL为空");
}
if (WebConstant.by_params == paramsPassMethod) {
if (params != null && !params.isEmpty()) {
url = ParamUtils.getFullRequestUrl(url, params);
}
}
CloseableHttpClient httpclient = null;
if (client == null) {
httpclient = createHttpClient(enableSSL);
} else {
httpclient = (CloseableHttpClient) client;
}
HttpGet httpGet = new HttpGet(url);
if (WebConstant.by_header == paramsPassMethod) {
if (params != null && !params.isEmpty()) {
for (Iterator<String> it = params.keySet().iterator(); it
.hasNext(); ) {
String key = it.next();
String value = String.valueOf(params.get(key));
httpGet.setHeader(key, value);
}
}
}
CloseableHttpResponse response = null;
try {
response = httpclient.execute(httpGet);
HttpEntity entity = response.getEntity();
if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
if (entity != null) {
String result = EntityUtils.toString(entity, CharsetUtils.get(charset)); //20141205增加UTF-8
EntityUtils.consume(entity);
return result;
} else {
return null;
}
}
} catch (Exception e) {
log.error("http请求接口异常：", e);
throw new Exception(e);
} finally {
try {
if (response != null) {
response.close();
}
} catch (IOException e) {
throw new Exception(e);
}
}
return null;
}
// ////////////////////////////////////////////////////////////////////////////////////////
public static String doPostByParams(String url, Map<String, Object> params)
throws Exception {
return doPost(WebConstant.by_params, url, params);
}
public static String doPostByHeader(String url, Map<String, Object> params)
throws Exception {
return doPost(WebConstant.by_header, url, params);
}
public static String doPost(int paramsPassMethod, String url,
Map<String, Object> params) throws Exception {
return doPost(paramsPassMethod, url, params, false, null);
}
public static String doPost(int paramsPassMethod, String url,
Map<String, Object> params, boolean enableSSL, HttpClient client) throws Exception {
log.info("doPost():url={},params={}", url, params);
if (WebConstant.by_params != paramsPassMethod
&& WebConstant.by_header != paramsPassMethod) {
throw new Exception("不支持的参数传递方式");
}
if (StringUtils.isEmpty(url)) {
throw new Exception("URL为空");
}
CloseableHttpClient httpclient = null;
if (client == null) {
httpclient = createHttpClient(enableSSL);
} else {
httpclient = (CloseableHttpClient) client;
}
HttpPost httpPost = new HttpPost(url);
CloseableHttpResponse response = null;
try {
if (WebConstant.by_params == paramsPassMethod) {
List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
for (Iterator<String> it = params.keySet().iterator(); it
.hasNext(); ) {
String key = it.next();
Object obj = params.get(key);
if (obj != null) {
String value = String.valueOf(obj);
nameValuePairs.add(new BasicNameValuePair(key, value));
} else {
nameValuePairs.add(new BasicNameValuePair(key, null));
}
}
httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
}
if (WebConstant.by_header == paramsPassMethod) {
if (params != null && !params.isEmpty()) {
for (Iterator<String> it = params.keySet().iterator(); it
.hasNext(); ) {
String key = it.next();
String value = String.valueOf(params.get(key));
httpPost.setHeader(key, value);
}
}
}
response = httpclient.execute(httpPost);
HttpEntity entity = response.getEntity();
if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
if (entity != null) {
String result = EntityUtils.toString(entity, CharsetUtils.get("utf-8")); //20141205增加UTF-8
EntityUtils.consume(entity);
return result;
} else {
return null;
}
}
EntityUtils.consume(entity);
return null;
} catch (ClientProtocolException e) {
throw e;
} catch (IOException e) {
throw e;
} finally {
try {
if (response != null) {
response.close();
}
} catch (IOException e) {
throw e;
}
}
}
public static String doPost(String url, Map<String, Object> headers,
Map<String, Object> params, boolean enableSSL, HttpClient client) throws Exception {
log.info("doPost():url={},headers={},params={}", url, headers, params);
if (StringUtils.isEmpty(url)) {
throw new IllegalArgumentException("URL为空");
}
CloseableHttpClient httpclient = null;
if (client == null) {
httpclient = createHttpClient(enableSSL);
} else {
httpclient = (CloseableHttpClient) client;
}
HttpPost httpPost = new HttpPost(url);
CloseableHttpResponse response = null;
try {
if (!CollectionUtils.isEmpty(headers)) {
if (headers != null && !headers.isEmpty()) {
for (Iterator<String> it = headers.keySet().iterator(); it
.hasNext(); ) {
String key = it.next();
String value = String.valueOf(headers.get(key));
httpPost.setHeader(key, value);
}
}
}
if (!CollectionUtils.isEmpty(params)) {
List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
for (Iterator<String> it = params.keySet().iterator(); it
.hasNext(); ) {
String key = it.next();
Object obj = params.get(key);
if (obj != null) {
String value = String.valueOf(obj);
nameValuePairs.add(new BasicNameValuePair(key, value));
} else {
nameValuePairs.add(new BasicNameValuePair(key, null));
}
}
httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
}
response = httpclient.execute(httpPost);
HttpEntity entity = response.getEntity();
if (entity != null) {
String result = EntityUtils.toString(entity, CharsetUtils.get("utf-8")); //20141205增加UTF-8
EntityUtils.consume(entity);
return result;
} else {
EntityUtils.consume(entity);
return null;
}
} catch (ClientProtocolException e) {
throw e;
} catch (IOException e) {
throw e;
} finally {
try {
if (response != null) {
response.close();
}
} catch (IOException e) {
throw e;
}
}
}
/**
* 使用post方式提交json数据<br>
* 并将返回的信息也进行json格式化
*/
public static Map<String, Object> postJson(String url, Map<String, Object> params) throws Exception {
Gson gson = new Gson();
String json = gson.toJson(params);
String resp = doPostText(url, json, true);
log.info("resp:{}", resp);
if (StringUtils.isNotBlank(resp)) {
Map<String, Object> dataMap = gson.fromJson(resp, Map.class);
if (dataMap == null) {
return new HashMap<String, Object>();
}
return dataMap;
}
return new HashMap<String, Object>();
}
}
测试
import org.junit.Test;
import java.util.HashMap;
import java.util.Map;
public class CreateUserTest {
@Test
public void createUserTest() throws Exception {
Map<String, Object> paramMap = new HashMap<String, Object>();
String userId="5af2aebb478d200e400ec4d4";
paramMap.put("username", userId);
paramMap.put("password", "123456");
Map<String, Object> headerMap = new HashMap<String, Object>();
headerMap.put("Content-Type", "application/x-www-form-urlencoded");
headerMap.put("Authorization", String.format("Basic %s", "dG9vX3VzZXJfcHJvZDo5OTk5OTk="));
String result = HttpRequestClient.doPost( "https://xx.dd.cn/oauth/user", headerMap, paramMap, true, null);
if (StringUtils.isBlank(result) || (result.indexOf("ok") == -1&& result.indexOf("duplicated") == -1) ) {
throw new IllegalStateException("创建Oauth2用户失败。userid: " + userId);
}
}
}
相关推荐
例子在协程中的用法可能是： from th2c import AsyncHTTP2Clientfrom tornado . httpclient import HTTPRequestclient = AsyncHTTP2Client ( host = 'nghttp2.org' , port = 443 , secure = True ,)request = ...
在上面的示例中，我们创建了一个 `HttpRequestClient` 类，用于初始化 Retrofit 客户端。我们使用 `OkHttpClient` 创建了一个客户端，并添加了一个 log 拦截器用于日志显示。 三、上传文件 在使用 Retrofit2.0 ...
JSONObject jsonObject = new JSONObject(HttpRequestClient.executeRequest(Constant.Url.GET_FOLLOW_GOODS_URL, param, true)); ResponseInfo responseInfo = new ResponseInfo(); try { if (jsonObject....
ImageLoaderTask 使用内存缓存和OkHttp3加载图像的模块还支持Get Request要求HttpRequestClient库可以包含在任何Android应用程序中。 HttpRequestClient库支持Android 4.4（Kitkat）及更高版本。在应用程序中使用...
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
MMC整流器技术解析：基于Matlab的双闭环控制策略与环流抑制性能研究,Matlab下的MMC整流器技术文档：18个子模块，双闭环控制稳定直流电压，环流抑制与最近电平逼近调制，优化桥臂电流波形，高效并网运行。,MMC整流器（Matlab），技术文档 1.MMC工作在整流侧，子模块个数N＝18，直流侧电压Udc＝25.2kV，交流侧电压6.6kV 2.控制器采用双闭环控制，外环控制直流电压，采用PI调节器，电流内环采用PI＋前馈解耦； 3.环流抑制采用PI控制，能够抑制环流二倍频分量； 4.采用最近电平逼近调制（NLM）， 5.均压排序：电容电压排序采用冒泡排序，判断桥臂电流方向确定投入切除； 结果： 1.输出的直流电压能够稳定在25.2kV； 2.有功功率，无功功率稳态时波形稳定，有功功率为3.2MW，无功稳定在0Var； 3.网侧电压电流波形均为对称的三相电压和三相电流波形，网侧电流THD＝1.47％<2％，符合并网要求； 4.环流抑制后桥臂电流的波形得到改善，桥臂电流THD由9.57％降至1.93％，环流波形也可以看到得到抑制； 5.电容电压能够稳定变化 ,工作点关键词：MMC
Boost二级升压光伏并网结构的Simulink建模与MPPT最大功率点追踪：基于功率反馈的扰动观察法调整电压方向研究,Boost二级升压光伏并网结构的Simulink建模与MPPT最大功率点追踪：基于功率反馈的扰动观察法调整电压方向研究,Boost二级升压光伏并网结构，Simulink建模，MPPT最大功率点追踪，扰动观察法采用功率反馈方式，若ΔP>0，说明电压调整的方向正确，可以继续按原方向进行“干扰”；若ΔP<0，说明电压调整的方向错误，需要对“干扰”的方向进行改变。 ,Boost升压;光伏并网结构;Simulink建模;MPPT最大功率点追踪;扰动观察法;功率反馈;电压调整方向。,光伏并网结构中Boost升压MPPT控制策略的Simulink建模与功率反馈扰动观察法
STM32F103C8T6 USB寄存器开发详解(12)-键盘设备
科技活动人员数专指直接从事科技活动以及专门从事科技活动管理和为科技活动提供直接服务的人员数量
Matlab Simulink仿真探究Flyback反激式开关电源性能表现与优化策略,Matlab Simulink仿真探究Flyback反激式开关电源的工作机制,Matlab Simulimk仿真，Flyback反激式开关电源仿真 ,Matlab; Simulink仿真; Flyback反激式; 开关电源仿真,Matlab Simulink在Flyback反激式开关电源仿真中的应用
基于Comsol的埋地电缆电磁加热计算模型：深度解析温度场与电磁场分布学习资料与服务,COMSOL埋地电缆电磁加热计算模型：温度场与电磁场分布的解析与学习资源,comsol 埋地电缆电磁加热计算模型，可以得到埋地电缆温度场及电磁场分布，提供学习资料和服务， ,comsol;埋地电缆电磁加热计算模型;温度场分布;电磁场分布;学习资料;服务,Comsol埋地电缆电磁加热模型：温度场与电磁场分布学习资料及服务
1、文件内容：ibus-table-chinese-yong-1.4.6-3.el7.rpm以及相关依赖 2、文件形式：tar.gz压缩包 3、安装指令： #Step1、解压 tar -zxvf /mnt/data/output/ibus-table-chinese-yong-1.4.6-3.el7.tar.gz #Step2、进入解压后的目录，执行安装 sudo rpm -ivh *.rpm 4、更多资源/技术支持：公众号禅静编程坊
基于51单片机protues仿真的汽车智能灯光控制系统设计（仿真图、源代码） 一、设计项目 根据本次设计的要求，设计出一款基于51单片机的自动切换远近光灯的设计。 技术条件与说明： 1. 设计硬件部分，中央处理器采用了STC89C51RC单片机； 2. 使用两个灯珠代表远近光灯，感光部分采用了光敏电阻，因为光敏电阻输出的是电压模拟信号，单片机不能直接处理模拟信号，所以经过ADC0832进行转化成数字信号； 3. 显示部分采用了LCD1602液晶，还增加按键部分电路，可以选择手自动切换远近光灯； 4. 用超声模块进行检测距离；
altermanager的企业微信告警服务
MyAgent测试版本在线下载
Comsol技术：可调BIC应用的二氧化钒VO2材料探索,Comsol模拟二氧化钒VO2的可调BIC特性研究,Comsol二氧化钒VO2可调BIC。 ,Comsol; 二氧化钒VO2; 可调BIC,Comsol二氧化钒VO2材料：可调BIC技术的关键应用
C++学生成绩管理系统源码
基于Matlab与Cplex的激励型需求响应模式：负荷转移与电价响应的差异化目标函数解析,基于Matlab与CPLEX的激励型需求响应负荷转移策略探索,激励型需求响应 matlab +cplex 激励型需求响应采用激励型需求响应方式对负荷进行转移，和电价响应模式不同，具体的目标函数如下 ,激励型需求响应; matlab + cplex; 负荷转移; 目标函数。,Matlab与Cplex结合的激励型需求响应模型及其负荷转移策略
scratch介绍（scratch说明）.zip
内容概要：本文全面介绍了深度学习模型的概念、工作机制和发展历程，详细探讨了神经网络的构建和训练过程，包括反向传播算法和梯度下降方法。文中还列举了深度学习在图像识别、自然语言处理、医疗和金融等多个领域的应用实例，并讨论了当前面临的挑战，如数据依赖、计算资源需求、可解释性和对抗攻击等问题。最后，文章展望了未来的发展趋势，如与量子计算和区块链的融合，以及在更多领域的应用前景。 适合人群：对该领域有兴趣的技术人员、研究人员和学者，尤其适合那些希望深入了解深度学习原理和技术细节的读者。 使用场景及目标：①理解深度学习模型的基本原理和结构；②了解深度学习模型的具体应用案例；③掌握应对当前技术挑战的方向。 阅读建议：文章内容详尽丰富，读者应在阅读过程中注意理解各个关键技术的概念和原理，尤其是神经网络的构成及训练过程。同时也建议对比不同模型的特点及其在具体应用中的表现。