代码如下，不支持https
package UDS.UdsTest.comme;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.ParseException;
import org.apache.http.StatusLine;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
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.util.EntityUtils;
import org.apache.log4j.Logger;
import org.json.JSONObject;
import org.json.JSONTokener;
public class HttpRequest
{
private static Logger log = Logger.getLogger(HttpRequest.class);
public JSONObject dopost(String url, JSONObject jsonobject)
{
HttpClient httpclient = new DefaultHttpClient();
HttpPost httpost = new HttpPost(url);
JSONObject response = null;
try
{
StringEntity sEntity = new StringEntity(jsonobject.toString());
sEntity.setContentEncoding("UTF-8");
sEntity.setContentType("application/json");
httpost.setEntity(sEntity);
HttpResponse httpResponse = httpclient.execute(httpost);
if (httpResponse.getStatusLine().getStatusCode() == 200)
{
response = new JSONObject(new JSONTokener(new InputStreamReader(httpResponse.getEntity().getContent())));
log.info(response);
}
else
{
log.info(Integer.valueOf(httpResponse.getStatusLine().getStatusCode()));
}
}
catch (Exception e)
{
throw new RuntimeException(e);
}
return response;
}
public JSONObject dopost(String url, JSONObject jsonobject, Map<String, Object> params)
{
HttpClient httpclient = new DefaultHttpClient();
HttpPost httpost = null;
JSONObject response = null;
Iterator<Map.Entry<String, Object>> it = params.entrySet().iterator();
try
{
if (params.size() == 0) {
return response;
}
if (params.size() == 1)
{
Map.Entry<String, Object> entry = (Map.Entry)it.next();
url = url + "?" + (String)entry.getKey() + "=" + entry.getValue().toString();
httpost = new HttpPost(url);
}
else
{
url = url + "?";
while (it.hasNext())
{
Map.Entry<String, Object> entry = (Map.Entry)it.next();
url = url + (String)entry.getKey() + "=" + entry.getValue().toString() + "&";
}
url = url.substring(0, new StringBuffer(url).length() - 1);
httpost = new HttpPost(url);
}
}
catch (ParseException e)
{
e.printStackTrace();
}
try
{
StringEntity sEntity = new StringEntity(jsonobject.toString());
sEntity.setContentEncoding("UTF-8");
sEntity.setContentType("application/json");
httpost.setEntity(sEntity);
HttpResponse httpResponse = httpclient.execute(httpost);
if (httpResponse.getStatusLine().getStatusCode() == 200)
{
response = new JSONObject(new JSONTokener(new InputStreamReader(httpResponse.getEntity().getContent())));
log.info(response);
}
else
{
log.info(Integer.valueOf(httpResponse.getStatusLine().getStatusCode()));
}
}
catch (Exception e)
{
throw new RuntimeException(e);
}
return response;
}
public JSONObject dopost(String url, Map<String, Object> params)
{
HttpClient httpclient = new DefaultHttpClient();
HttpPost httpost = null;
JSONObject response = null;
Iterator<Map.Entry<String, Object>> it = params.entrySet().iterator();
try
{
if (params.size() == 0) {
return response;
}
if (params.size() == 1)
{
Map.Entry<String, Object> entry = (Map.Entry)it.next();
url = url + "?" + (String)entry.getKey() + "=" + entry.getValue().toString();
httpost = new HttpPost(url);
}
else
{
url = url + "?";
while (it.hasNext())
{
Map.Entry<String, Object> entry = (Map.Entry)it.next();
url = url + (String)entry.getKey() + "=" + entry.getValue().toString() + "&";
}
url = url.substring(0, new StringBuffer(url).length() - 1);
httpost = new HttpPost(url);
}
}
catch (ParseException e)
{
e.printStackTrace();
}
try
{
StringEntity sEntity = new StringEntity("");
sEntity.setContentEncoding("UTF-8");
sEntity.setContentType("application/json");
httpost.setEntity(sEntity);
HttpResponse httpResponse = httpclient.execute(httpost);
if (httpResponse.getStatusLine().getStatusCode() == 200)
{
response = new JSONObject(new JSONTokener(new InputStreamReader(httpResponse.getEntity().getContent())));
log.info(response);
}
else
{
log.info(Integer.valueOf(httpResponse.getStatusLine().getStatusCode()));
}
}
catch (Exception e)
{
throw new RuntimeException(e);
}
return response;
}
public String doget(String url, Map<String, Object> params)
{
CloseableHttpClient httpClient = HttpClients.createDefault();
Iterator<Map.Entry<String, Object>> it = params.entrySet().iterator();
HttpResponse response = null;
HttpGet httpGet = null;
String json = null;
try
{
if (params.size() == 0)
{
httpGet = new HttpGet(url);
}
else if (params.size() == 1)
{
Map.Entry<String, Object> entry = (Entry<String, Object>)it.next();
url = url + "?" + (String)entry.getKey() + "=" + entry.getValue().toString();
httpGet = new HttpGet(url);
}
else
{
url = url + "?";
while (it.hasNext())
{
Map.Entry<String, Object> entry = (Entry<String, Object>)it.next();
url = url + (String)entry.getKey() + "=" + entry.getValue().toString() + "&";
}
url = url.substring(0, new StringBuffer(url).length() - 1);
httpGet = new HttpGet(url);
}
log.info(httpGet.getURI());
response = httpClient.execute(httpGet);
HttpEntity entity = response.getEntity();
if (entity != null)
{
json=EntityUtils.toString(response.getEntity(), "utf-8");
}
}
catch (ParseException e)
{
log.debug(e.getMessage());
e.printStackTrace();
}
catch (IOException e)
{
log.debug(e.getMessage());
e.printStackTrace();
}
return json;
}
public String doget(String url, Map<String, Object> params,Map<String, String> headers)
{
CloseableHttpClient httpClient = HttpClients.createDefault();
Iterator<Map.Entry<String, Object>> it = params.entrySet().iterator();
HttpResponse response = null;
HttpGet httpGet = null;
String json = null;
try
{
if (params.size() == 0)
{
httpGet = new HttpGet(url);
}
else if (params.size() == 1)
{
Map.Entry<String, Object> entry = (Entry<String, Object>)it.next();
url = url + "?" + (String)entry.getKey() + "=" + entry.getValue().toString();
httpGet = new HttpGet(url);
}
else
{
url = url + "?";
while (it.hasNext())
{
Map.Entry<String, Object> entry = (Entry<String, Object>)it.next();
url = url + (String)entry.getKey() + "=" + entry.getValue().toString() + "&";
}
url = url.substring(0, new StringBuffer(url).length() - 1);
httpGet = new HttpGet(url);
}
log.info("URL="+httpGet.getURI());
for(Map.Entry<String, String> e : headers.entrySet()){
httpGet.addHeader(e.getKey(),e.getValue());
}
response = httpClient.execute(httpGet);
HttpEntity entity = response.getEntity();
if (entity != null)
{
json=EntityUtils.toString(response.getEntity(), "utf-8");
}
}
catch (ParseException e)
{
//log.debug(e.getMessage());
e.printStackTrace();
}
catch (IOException e)
{
//log.debug(e.getMessage());
e.printStackTrace();
}
return json;
}
public StatusLine getStatus(String flag,String url, Map<String, Object> params,Map<String, String> headers){
CloseableHttpClient httpClient = HttpClients.createDefault();
Iterator<Map.Entry<String, Object>> it = params.entrySet().iterator();
HttpResponse response = null;
HttpGet httpGet = null;
HttpPost httpPost=null;
String json = null;
StatusLine sl=null;
if(flag.equals("GET")){
try
{
if (params.size() == 0)
{
httpGet = new HttpGet(url);
}
else if (params.size() == 1)
{
Map.Entry<String, Object> entry = (Entry<String, Object>)it.next();
url = url + "?" + (String)entry.getKey() + "=" + entry.getValue().toString();
httpGet = new HttpGet(url);
}
else
{
url = url + "?";
while (it.hasNext())
{
Map.Entry<String, Object> entry = (Entry<String, Object>)it.next();
url = url + (String)entry.getKey() + "=" + entry.getValue().toString() + "&";
}
url = url.substring(0, new StringBuffer(url).length() - 1);
httpGet = new HttpGet(url);
}
log.info("URL="+httpGet.getURI());
for(Map.Entry<String, String> e : headers.entrySet()){
httpGet.addHeader(e.getKey(),e.getValue());
}
response = httpClient.execute(httpGet);
sl=response.getStatusLine();
}catch (Exception e){
e.printStackTrace();
}
}
else if(flag.equals("POST")){
}
return sl;
}
public static void main(String[] args) {}
}
如果要请求https，请使用下面代码：
package UDS.UdsTest.comme;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
public class HttpUtils {
/**
* get
*
* @param host
* @param path
* @param method
* @param headers
* @param querys
* @return
* @throws Exception
*/
public static HttpResponse doGet(String host, String path,Map<String, String> headers,Map<String, String> querys){
HttpClient httpClient = wrapClient(host);
HttpGet request=null;
HttpResponse response=null;
try {
request = new HttpGet(buildUrl(host, path, querys));
response=httpClient.execute(request);
} catch (Exception e1) {
e1.printStackTrace();
}
for (Map.Entry<String, String> e : headers.entrySet()) {
request.addHeader(e.getKey(), e.getValue());
}
return response;
}
/**
* post form
*
* @param host
* @param path
* @param method
* @param headers
* @param querys
* @param bodys
* @return
* @throws Exception
*/
public static HttpResponse doPost(String host, String path, String method,
Map<String, String> headers,
Map<String, String> querys,
Map<String, String> bodys)
throws Exception {
HttpClient httpClient = wrapClient(host);
HttpPost request = new HttpPost(buildUrl(host, path, querys));
for (Map.Entry<String, String> e : headers.entrySet()) {
request.addHeader(e.getKey(), e.getValue());
}
if (bodys != null) {
List<NameValuePair> nameValuePairList = new ArrayList<NameValuePair>();
for (String key : bodys.keySet()) {
nameValuePairList.add(new BasicNameValuePair(key, bodys.get(key)));
}
UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nameValuePairList, "utf-8");
formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8");
request.setEntity(formEntity);
}
return httpClient.execute(request);
}
/**
* Post String
*
* @param host
* @param path
* @param method
* @param headers
* @param querys
* @param body
* @return
* @throws Exception
*/
public static HttpResponse doPost(String host, String path, String method,
Map<String, String> headers,
Map<String, String> querys,
String body)
throws Exception {
HttpClient httpClient = wrapClient(host);
HttpPost request = new HttpPost(buildUrl(host, path, querys));
for (Map.Entry<String, String> e : headers.entrySet()) {
request.addHeader(e.getKey(), e.getValue());
}
if (StringUtils.isNotBlank(body)) {
request.setEntity(new StringEntity(body, "utf-8"));
}
return httpClient.execute(request);
}
/**
* Post stream
*
* @param host
* @param path
* @param method
* @param headers
* @param querys
* @param body
* @return
* @throws Exception
*/
public static HttpResponse doPost(String host, String path, String method,
Map<String, String> headers,
Map<String, String> querys,
byte[] body)
throws Exception {
HttpClient httpClient = wrapClient(host);
HttpPost request = new HttpPost(buildUrl(host, path, querys));
for (Map.Entry<String, String> e : headers.entrySet()) {
request.addHeader(e.getKey(), e.getValue());
}
if (body != null) {
request.setEntity(new ByteArrayEntity(body));
}
return httpClient.execute(request);
}
private static String buildUrl(String host, String path, Map<String, String> querys) throws UnsupportedEncodingException {
StringBuilder sbUrl = new StringBuilder();
sbUrl.append(host);
if (!StringUtils.isBlank(path)) {
sbUrl.append(path);
}
if (null != querys) {
StringBuilder sbQuery = new StringBuilder();
for (Map.Entry<String, String> query : querys.entrySet()) {
if (0 < sbQuery.length()) {
sbQuery.append("&");
}
if (StringUtils.isBlank(query.getKey()) && !StringUtils.isBlank(query.getValue())) {
sbQuery.append(query.getValue());
}
if (!StringUtils.isBlank(query.getKey())) {
sbQuery.append(query.getKey());
if (!StringUtils.isBlank(query.getValue())) {
sbQuery.append("=");
sbQuery.append(URLEncoder.encode(query.getValue(), "utf-8"));
}
}
}
if (0 < sbQuery.length()) {
sbUrl.append("?").append(sbQuery);
}
}
return sbUrl.toString();
}
private static HttpClient wrapClient(String host) {
HttpClient httpClient = new DefaultHttpClient();
if (host.startsWith("https://")) {
sslClient(httpClient);
}
return httpClient;
}
private static void sslClient(HttpClient httpClient) {
try {
SSLContext ctx = SSLContext.getInstance("TLS");
X509TrustManager tm = new X509TrustManager() {
public X509Certificate[] getAcceptedIssuers() {
return null;
}
public void checkClientTrusted(X509Certificate[] xcs, String str) {
}
public void checkServerTrusted(X509Certificate[] xcs, String str) {
}
};
ctx.init(null, new TrustManager[] { tm }, null);
SSLSocketFactory ssf = new SSLSocketFactory(ctx);
ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
ClientConnectionManager ccm = httpClient.getConnectionManager();
SchemeRegistry registry = ccm.getSchemeRegistry();
registry.register(new Scheme("https", 443, ssf));
} catch (KeyManagementException ex) {
throw new RuntimeException(ex);
} catch (NoSuchAlgorithmException ex) {
throw new RuntimeException(ex);
}
}
}