普通的get和post请求只能执行http的请求，遇到的了https的就歇菜了，需要SSL安全证书处理。

该方法只能用jdk1.7和1.8进行处理，jdk1.6会报Could not generate DH keypair的错误。

1、引入相关依赖包

jar包下载：httpcore4.5.5.jar    fastjson-1.2.47.jar

maven：

<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.5</version>
</dependency>

<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency>

2、主要类HttpClientService

1 package com.sinotn.service;
2
3 import com.alibaba.fastjson.JSONObject;
4 import org.apache.http.HttpEntity;
5 import org.apache.http.NameValuePair;
6 import org.apache.http.client.entity.UrlEncodedFormEntity;
7 import org.apache.http.client.methods.CloseableHttpResponse;
8 import org.apache.http.client.methods.HttpGet;
9 import org.apache.http.client.methods.HttpPost;
10 import org.apache.http.client.utils.URIBuilder;
11 import org.apache.http.entity.StringEntity;
12 import org.apache.http.impl.client.CloseableHttpClient;
13 import org.apache.http.impl.client.HttpClients;
14 import org.apache.http.message.BasicHeader;
15 import org.apache.http.message.BasicNameValuePair;
16 import org.apache.http.util.EntityUtils;
17 import org.slf4j.Logger;
18 import org.slf4j.LoggerFactory;
19 import java.util.ArrayList;
20 import java.util.List;
21
22 /**
23  * HttpClient发送GET、POST请求
24  * @Author libin
25  * @CreateDate 2018.5.28 16:56
26  */
27 public class HttpClientService {
28
29     private static final Logger LOGGER = LoggerFactory.getLogger(HttpClientService.class);
30     /**
31      * 返回成功状态码
32      */
33     private static final int SUCCESS_CODE = 200;
34
35     /**
36      * 发送GET请求
37      * @param url   请求url
38      * @param nameValuePairList    请求参数
39      * @return JSON或者字符串
40      * @throws Exception
41      */
42     public static Object sendGet(String url, List<NameValuePair> nameValuePairList) throws Exception{
43         JSONObject jsonObject = null;
44         CloseableHttpClient client = null;
45         CloseableHttpResponse response = null;
46         try{
47             /**
48              * 创建HttpClient对象
49              */
50             client = HttpClients.createDefault();
51             /**
52              * 创建URIBuilder
53              */
54             URIBuilder uriBuilder = new URIBuilder(url);
55             /**
56              * 设置参数
57              */
58             uriBuilder.addParameters(nameValuePairList);
59             /**
60              * 创建HttpGet
61              */
62             HttpGet httpGet = new HttpGet(uriBuilder.build());
63             /**
64              * 设置请求头部编码
65              */
66             httpGet.setHeader(new BasicHeader("Content-Type", "application/x-www-form-urlencoded; charset=utf-8"));
67             /**
68              * 设置返回编码
69              */
70             httpGet.setHeader(new BasicHeader("Accept", "text/plain;charset=utf-8"));
71             /**
72              * 请求服务
73              */
74             response = client.execute(httpGet);
75             /**
76              * 获取响应吗
77              */
78             int statusCode = response.getStatusLine().getStatusCode();
79
80             if (SUCCESS_CODE == statusCode){
81                 /**
82                  * 获取返回对象
83                  */
84                 HttpEntity entity = response.getEntity();
85                 /**
86                  * 通过EntityUitls获取返回内容
87                  */
88                 String result = EntityUtils.toString(entity,"UTF-8");
89                 /**
90                  * 转换成json,根据合法性返回json或者字符串
91                  */
92                 try{
93                     jsonObject = JSONObject.parseObject(result);
94                     return jsonObject;
95                 }catch (Exception e){
96                     return result;
97                 }
98             }else{
99                 LOGGER.error("HttpClientService-line: {}, errorMsg{}", 97, "GET请求失败！");
100             }
101         }catch (Exception e){
102             LOGGER.error("HttpClientService-line: {}, Exception: {}", 100, e);
103         } finally {
104             response.close();
105             client.close();
106         }
107         return null;
108     }
109
110     /**
111      * 发送POST请求
112      * @param url
113      * @param nameValuePairList
114      * @return JSON或者字符串
115      * @throws Exception
116      */
117     public static Object sendPost(String url, List<NameValuePair> nameValuePairList) throws Exception{
118         JSONObject jsonObject = null;
119         CloseableHttpClient client = null;
120         CloseableHttpResponse response = null;
121         try{
122             /**
123              *  创建一个httpclient对象
124              */
125             client = HttpClients.createDefault();
126             /**
127              * 创建一个post对象
128              */
129             HttpPost post = new HttpPost(url);
130             /**
131              * 包装成一个Entity对象
132              */
133             StringEntity entity = new UrlEncodedFormEntity(nameValuePairList, "UTF-8");
134             /**
135              * 设置请求的内容
136              */
137             post.setEntity(entity);
138             /**
139              * 设置请求的报文头部的编码
140              */
141             post.setHeader(new BasicHeader("Content-Type", "application/x-www-form-urlencoded; charset=utf-8"));
142             /**
143              * 设置请求的报文头部的编码
144              */
145             post.setHeader(new BasicHeader("Accept", "text/plain;charset=utf-8"));
146             /**
147              * 执行post请求
148              */
149             response = client.execute(post);
150             /**
151              * 获取响应码
152              */
153             int statusCode = response.getStatusLine().getStatusCode();
154             if (SUCCESS_CODE == statusCode){
155                 /**
156                  * 通过EntityUitls获取返回内容
157                  */
158                 String result = EntityUtils.toString(response.getEntity(),"UTF-8");
159                 /**
160                  * 转换成json,根据合法性返回json或者字符串
161                  */
162                 try{
163                     jsonObject = JSONObject.parseObject(result);
164                     return jsonObject;
165                 }catch (Exception e){
166                     return result;
167                 }
168             }else{
169                 LOGGER.error("HttpClientService-line: {}, errorMsg：{}", 146, "POST请求失败！");
170             }
171         }catch (Exception e){
172             LOGGER.error("HttpClientService-line: {}, Exception：{}", 149, e);
173         }finally {
174             response.close();
175             client.close();
176         }
177         return null;
178     }
179
180     /**
181      * 组织请求参数{参数名和参数值下标保持一致}
182      * @param params    参数名数组
183      * @param values    参数值数组
184      * @return 参数对象
185      */
186     public static List<NameValuePair> getParams(Object[] params, Object[] values){
187         /**
188          * 校验参数合法性
189          */
190         boolean flag = params.length>0 && values.length>0 &&  params.length == values.length;
191         if (flag){
192             List<NameValuePair> nameValuePairList = new ArrayList<>();
193             for(int i =0; i<params.length; i++){
194                 nameValuePairList.add(new BasicNameValuePair(params[i].toString(),values[i].toString()));
195             }
196             return nameValuePairList;
197         }else{
198             LOGGER.error("HttpClientService-line: {}, errorMsg：{}", 197, "请求参数为空且参数长度不一致");
199         }
200         return null;
201     }
202 }

 3、调用方法

1 package com.sinotn.service.impl;
2
3 import com.sinotn.service.HttpClientService;
4 import org.apache.http.NameValuePair;
5
6 import java.util.List;
7
8 /**
9  * 发送post/get 测试类
10  */
11 public class Test {
12
13     public static void main(String[] args) throws Exception{
14         String url = "要请求的url地址";
15         /**
16          * 参数值
17          */
18         Object [] params = new Object[]{"param1","param2"};
19         /**
20          * 参数名
21          */
22         Object [] values = new Object[]{"value1","value2"};
23         /**
24          * 获取参数对象
25          */
26         List<NameValuePair> paramsList = HttpClientService.getParams(params, values);
27         /**
28          * 发送get
29          */
30         Object result = HttpClientService.sendGet(url, paramsList);
31         /**
32          * 发送post
33          */
34         Object result2 = HttpClientService.sendPost(url, paramsList);
35
36         System.out.println("GET返回信息：" + result);
37         System.out.println("POST返回信息：" + result2);
38     }
39 }

4、对于发送https

为了避免需要证书，所以用一个类继承DefaultHttpClient类，忽略校验过程。

写一个SSLClient类，继承至HttpClient

1 import java.security.cert.CertificateException;
2 import java.security.cert.X509Certificate;
3 import javax.net.ssl.SSLContext;
4 import javax.net.ssl.TrustManager;
5 import javax.net.ssl.X509TrustManager;
6 import org.apache.http.conn.ClientConnectionManager;
7 import org.apache.http.conn.scheme.Scheme;
8 import org.apache.http.conn.scheme.SchemeRegistry;
9 import org.apache.http.conn.ssl.SSLSocketFactory;
10 import org.apache.http.impl.client.DefaultHttpClient;
11 //用于进行Https请求的HttpClient
12 public class SSLClient extends DefaultHttpClient{
13     public SSLClient() throws Exception{
14         super();
15         SSLContext ctx = SSLContext.getInstance("TLS");
16         X509TrustManager tm = new X509TrustManager() {
17                 @Override
18                 public void checkClientTrusted(X509Certificate[] chain,
19                         String authType) throws CertificateException {
20                 }
21                 @Override
22                 public void checkServerTrusted(X509Certificate[] chain,
23                         String authType) throws CertificateException {
24                 }
25                 @Override
26                 public X509Certificate[] getAcceptedIssuers() {
27                     return null;
28                 }
29         };
30         ctx.init(null, new TrustManager[]{tm}, null);
31         SSLSocketFactory ssf = new SSLSocketFactory(ctx,SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
32         ClientConnectionManager ccm = this.getConnectionManager();
33         SchemeRegistry sr = ccm.getSchemeRegistry();
34         sr.register(new Scheme("https", 443, ssf));
35     }
36 }

5、对于https调用

转载于:https://www.cnblogs.com/tiandi/p/10719666.html