Httpclient

最新推荐文章于 2024-03-26 21:15:09 发布
最新推荐文章于 2024-03-26 21:15:09 发布
阅读量131 收藏
点赞数
分类专栏： 工具类 java--后端 文章标签： Httpclient
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43467870/article/details/100629162
版权

文章简介

  1. 分析自己写的代码并总结
  2. get请求
  3. post请求

分析自己写的代码并总结

  • 一般使用步骤
    参考文章：https://www.jianshu.com/p/375be5929bed
使用HttpClient发送请求、接收响应，一般需要以下步骤。
HttpGet请求响应的一般步骤：
1). 创建HttpClient对象,可以使用HttpClients.createDefault()；
2). 如果是无参数的GET请求，则直接使用构造方法HttpGet(String url)创建HttpGet对象即可；
如果是带参数GET请求，则可以先使用URIBuilder(String url)创建对象，再调用addParameter(String param, String value)，或setParameter(String param, String value)来设置请求参数，并调用build()方法构建一个URI对象。只有构造方法HttpGet(URI uri)来创建HttpGet对象。
3). 创建HttpResponse，调用HttpClient对象的execute(HttpUriRequest request)发送请求，该方法返回一个HttpResponse。调用HttpResponse的getAllHeaders()、getHeaders(String name)等方法可获取服务器的响应头；调用HttpResponse的getEntity()方法可获取HttpEntity对象，该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容。通过调用getStatusLine().getStatusCode()可以获取响应状态码。
4). 释放连接。

HttpPost请求响应的一般步骤：
1). 创建HttpClient对象,可以使用HttpClients.createDefault()；
2). 如果是无参数的GET请求，则直接使用构造方法HttpPost(String url)创建HttpPost对象即可；
如果是带参数POST请求，先构建HttpEntity对象并设置请求参数，然后调用setEntity(HttpEntity entity)创建HttpPost对象。
3). 创建HttpResponse，调用HttpClient对象的execute(HttpUriRequest request)发送请求，该方法返回一个HttpResponse。调用HttpResponse的getAllHeaders()、getHeaders(String name)等方法可获取服务器的响应头；调用HttpResponse的getEntity()方法可获取HttpEntity对象，该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容。通过调用getStatusLine().getStatusCode()可以获取响应状态码。
4). 释放连接。
  • 代码
package com.zhangxiaoguang.utils;

import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.http.NameValuePair;
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.URIBuilder;
import org.apache.http.entity.ContentType;
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.util.EntityUtils;

public class HttpClientUtil {

	public static String doGet(String url, Map<String, String> param) {

		// 创建Httpclient对象
		CloseableHttpClient httpclient = HttpClients.createDefault();

		String resultString = "";
		CloseableHttpResponse response = null;
		try {
			// 创建uri
			URIBuilder builder = new URIBuilder(url);
			if (param != null) {
				for (String key : param.keySet()) {
					builder.addParameter(key, param.get(key));
				}
			}
			URI uri = builder.build();

			// 创建http GET请求
			HttpGet httpGet = new HttpGet(uri);

			// 执行请求
			response = httpclient.execute(httpGet);
			// 判断返回状态是否为200
			if (response.getStatusLine().getStatusCode() == 200) {
				resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (response != null) {
					response.close();
				}
				httpclient.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return resultString;
	}

	public static String doGet(String url) {
		return doGet(url, null);
	}

	public static String doPost(String url, Map<String, String> param) {
		// 创建Httpclient对象
		CloseableHttpClient httpClient = HttpClients.createDefault();
		CloseableHttpResponse response = null;
		String resultString = "";
		try {
			// 创建Http Post请求
			HttpPost httpPost = new HttpPost(url);
			// 创建参数列表
			if (param != null) {
				List<NameValuePair> paramList = new ArrayList<>();
				for (String key : param.keySet()) {
					paramList.add(new BasicNameValuePair(key, param.get(key)));
				}
				// 模拟表单
				UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
				httpPost.setEntity(entity);
			}
			// 执行http请求
			response = httpClient.execute(httpPost);
			resultString = EntityUtils.toString(response.getEntity(), "utf-8");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				response.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

		return resultString;
	}

	public static String doPost(String url) {
		return doPost(url, null);
	}
	
	public static String doPostJson(String url, String json) {
		// 创建Httpclient对象
		CloseableHttpClient httpClient = HttpClients.createDefault();
		CloseableHttpResponse response = null;
		String resultString = "";
		try {
			// 创建Http Post请求
			HttpPost httpPost = new HttpPost(url);
			// 创建请求内容
			StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
			httpPost.setEntity(entity);
			// 执行http请求
			response = httpClient.execute(httpPost);
			resultString = EntityUtils.toString(response.getEntity(), "utf-8");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				response.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

		return resultString;
	}
}

第二篇;

public class HttpClientUtils {

    private HttpClientUtils() {
    }

    private volatile static HttpClientUtils instance = null;

    private PoolingHttpClientConnectionManager cm;
    private Timer conncetionMonitor;
    private RequestConfig defaultRequestConfig;

    private int REQUEST_TIMEOUT = 5 * 1000;
    private int REQUEST_SOCKET_TIME = 20 * 1000;

    /**
     * 默认每个路由最大连接数，默认5。
     */
    private int defaultMaxPerRoute = 100;
    /**
     * 最大连接数，默认20。
     */
    private int maxTotal = 100;

    private boolean init() {
        try {
            Properties properties = SystemConfigUtil.getProperties();
            KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
            String keyStoreClientPath = properties.getProperty("keyStoreClientPath");
            InputStream ksIn = new FileInputStream(keyStoreClientPath);

            String keyStorePass = properties.getProperty("keyStorePass");

            keyStore.load(ksIn, keyStorePass.toCharArray());

            SSLContext sslcontext = SSLContexts.createDefault();

            // 咪咕单点要求客户端提供证书认证
            KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            keyManagerFactory.init(keyStore, keyStorePass.toCharArray());

            X509TrustManager x509mgr = getX509TrustManager();
            // 取消服务端证书认证
            sslcontext.init(keyManagerFactory.getKeyManagers(), new TrustManager[]{ x509mgr }, null);


            // 客户端支持TLSv1,指定TLS_RSA_WITH_AES_128_CBC_SHA加密算法
            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext,
                    new String[]{"TLSv1"},
                    new String[] {"TLS_RSA_WITH_AES_128_CBC_SHA"},
                    new HostnameVerifier() {
                        @Override
                        public boolean verify(String s, SSLSession sslSession) {
                            return true;
                        }
                    }); // 跳过客户端验证服务器身份的策略

//            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext,
//                    new String[]{"TLSv1", "TLSv1.1", "TLSv1.2"}, null,
//                    new HostnameVerifier() {
//                        @Override
//                        public boolean verify(String s, SSLSession sslSession) {
//                            return true;
//                        }
//                    }); // 跳过客户端验证服务器身份的策略


            // Create a registry of custom connection socket factories for supported
            // protocol schemes.
            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                    .register("http", PlainConnectionSocketFactory.INSTANCE)
                    .register("https", sslsf).build();

            cm = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
            cm.setDefaultMaxPerRoute(defaultMaxPerRoute);
            cm.setMaxTotal(maxTotal);

            final int idleTimeOut = 30;
            conncetionMonitor = new Timer();
            TimerTask task = new TimerTask() {
                @Override
                public void run() {
                    // 关闭失效的连接
                    cm.closeExpiredConnections();
                    // 关闭N秒内部活动的连接
                    cm.closeIdleConnections(idleTimeOut, TimeUnit.SECONDS);
                }
            };
            // 每5秒检测一次
            conncetionMonitor.schedule(task, 5000, 10000);

            defaultRequestConfig = RequestConfig.custom().setSocketTimeout(REQUEST_SOCKET_TIME)
                    .setConnectTimeout(REQUEST_TIMEOUT).setConnectionRequestTimeout(REQUEST_TIMEOUT)
                    .build();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    private X509TrustManager getX509TrustManager() {
        return new X509TrustManager() {
            @Override
            public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            }

            @Override
            public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            }

            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }
        };
    }

    public static HttpClientUtils getInstance() {
        if (instance == null) {
            synchronized (HttpClientUtils.class) {
                if (instance == null) {
                    HttpClientUtils clientUtils = new HttpClientUtils();
                    if (clientUtils.init()) {
                        instance = clientUtils;
                    }
                }
            }
        }

        return instance;
    }


    public void destory() {
        if (conncetionMonitor != null) {
            conncetionMonitor.cancel();
        }
        if (cm != null) {
            cm.close();
        }
    }

    private CloseableHttpClient getHttpclient() {
        return HttpClients.custom().setConnectionManager(cm)
                .setRetryHandler(new DefaultHttpRequestRetryHandler(0, false)).build();
    }

    public JSONObject executePostJSON(String url, JSONObject jsonObject) {

        JSONObject respJson = new JSONObject();
        String result = "000";
        String desc = "成功";
        String respData = "";

        CloseableHttpClient httpClient = null;
        CloseableHttpResponse resp = null;
        HttpEntity entity = null;
        try {
            httpClient = getHttpclient();
            HttpPost httppost = createHttpPost(url);
            if (jsonObject != null) {
                HttpEntity httpEntity = new StringEntity(jsonObject.toString(), ContentType.APPLICATION_JSON);
                httppost.setEntity(httpEntity);
            }

            resp = httpClient.execute(httppost);
            int statusCode = resp.getStatusLine().getStatusCode();
            entity = resp.getEntity();
            if (200 == statusCode) {
                respData = EntityUtils.toString(entity);
            } else {
                result = "001";
                desc = "statusCode 为 " + statusCode;
            }
        } catch (Exception e) {
            result = "001";
            desc = "异常:" + CommonUtil.getExceptionInfo(e);
        } finally {
            if (entity != null) {
                try {
                    entity.getContent().close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            try {
                if (resp != null) {
                    resp.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        respJson.put("url", url);
        respJson.put("result", result);
        respJson.put("desc", desc);
        respJson.put("reqData", jsonObject);
        respJson.put("respData", respData);
        return respJson;
    }

    /**
     *
     * @param url
     * @param param
     * @return
     */
    public JSONObject executeGetJSON(String url, Map<String, String> param) {

        JSONObject respJson = new JSONObject();
        String result = "000";
        String desc = "成功";
        String respData = "";

        CloseableHttpClient httpClient = null;
        CloseableHttpResponse resp = null;
        HttpEntity entity = null;
        try {
            httpClient = getHttpclient();

            // 创建uri
            URIBuilder builder = new URIBuilder(url);
            if (param != null) {
                for (String key : param.keySet()) {
                    builder.addParameter(key, param.get(key));
                }
            }
            URI uri = builder.build();

            // 创建http GET请求
            HttpGet httpGet = new HttpGet(uri);

            // 执行请求
            resp = httpClient.execute(httpGet);

            int statusCode = resp.getStatusLine().getStatusCode();
            entity = resp.getEntity();
            if (200 == statusCode) {
                respData = EntityUtils.toString(entity);
            } else {
                result = "001";
                desc = "statusCode 为 " + statusCode;
            }
        } catch (Exception e) {
            result = "001";
            desc = "异常:" + CommonUtil.getExceptionInfo(e);
        } finally {
            if (entity != null) {
                try {
                    entity.getContent().close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            try {
                if (resp != null) {
                    resp.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        respJson.put("url", url);
        respJson.put("result", result);
        respJson.put("desc", desc);
        respJson.put("reqData", JSONObject.fromObject( param ));
        respJson.put("respData", respData);
        return respJson;


    }
        private HttpPost createHttpPost(String url) {
        HttpPost httpPost = new HttpPost(url);
        httpPost.setConfig(RequestConfig.copy(defaultRequestConfig).build());
        return httpPost;
    }
}
  • 总结
    注：访问第三方接口返回的数据肯定是HttpEntity对象，需解析成想要对象
    不管是get或者是post请求，只有创建get或者post请求对象方式不一样，其他是一样的。
    1.涉及到对象：
    ①创建Httpclient对象：CloseableHttpClient
    ②访问后响应对象：CloseableHttpResponse
    返回状态：response.getStatusLine().getStatusCode()
    返回HttpEntity对象数据（特殊的是post请求数据也是封装到这个对象）：response.getEntity()
    返回json字符串数据：
    ③请求参数
    get请求：可以分装到URIBuilder对象中或者加载url路径上
    post请求：分装到http协议的请求内容里面（先模拟表单或者直接封装到HttpEntity）
 post:
 第一种：
 			// 创建Http Post请求
			HttpPost httpPost = new HttpPost(url);
			// 创建参数列表
			if (param != null) {
				List<NameValuePair> paramList = new ArrayList<>();
				for (String key : param.keySet()) {
					paramList.add(new BasicNameValuePair(key, param.get(key)));
				}
				// 模拟表单
				UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
				httpPost.setEntity(entity);
第二种：         
                HttpEntity httpEntity = new StringEntity(jsonObject.toString(), ContentType.APPLICATION_JSON);
                httppost.setEntity(httpEntity);

2.创建get或者post请求对象方式
请求参数是map:

创建get请求：带参数
			// 创建uri
			URIBuilder builder = new URIBuilder(url);
			if (param != null) {
				for (String key : param.keySet()) {
					builder.addParameter(key, param.get(key));
				}
			}
			URI uri = builder.build();

			// 创建http GET请求
			HttpGet httpGet = new HttpGet(uri);

			// 执行请求
			response = httpclient.execute(httpGet);
创建post请求：带参数（模拟表单）
		// 创建Http Post请求
			HttpPost httpPost = new HttpPost(url);
			// 创建参数列表
			if (param != null) {
				List<NameValuePair> paramList = new ArrayList<>();
				for (String key : param.keySet()) {
					paramList.add(new BasicNameValuePair(key, param.get(key)));
				}
				// 模拟表单
				UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
				httpPost.setEntity(entity);
			}
			// 执行http请求
			response = httpClient.execute(httpPost);
创建post请求：带参数（请求参数是json字符串）
 HttpEntity httpEntity = new StringEntity(jsonObject.toString(), ContentType.APPLICATION_JSON);
                httppost.setEntity(httpEntity);            
            resp = httpClient.execute(httppost);

get请求

被抽空的血管
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
StringEntity格式编码问题
至愚则明
02-21 2万+
最近使用Apache的httpclient发起httpPost请求，后端一直提示编码格式错误。代码和环境都是在UTF-8写处理的，后端接受的编码也是UTF-8，但是后端依然报错。在跟踪代码的时候，发现主要是客户端StringEntity的处理问题。StringEntity设置编码格式主要有以下两种方式 //第一种方式：后端无法解码 StringEntity stringEntity ...
【HttpClient】处理路径参数
拉二胡写前端的后端程序员
03-01 276
【代码】【HttpClient】处理路径参数。
Java+HttpClient学习笔记02-URL和参数
梦忆安凉的博客
08-13 1134
URIBuilder类：用来构建修改URI NameValuePair类：用来构建参数 构建URI import org.apache.http.client.utils.URIBuilder; import java.net.URI; import java.net.URISyntaxException; public class LessonUrl { publ...
HttpClient详细使用示例
qq_35911118的博客
12-11 671
HttpClient的主要功能： 实现了所有 HTTP 的方法（GET、POST、PUT、HEAD、DELETE、HEAD、OPTIONS 等） 支持 HTTPS 协议 支持代理服务器（Nginx等）等 支持自动（跳转）转向 org.apache.httpcomponents</ groupId> httpclient 4.5.5 com.alibaba</ groupId> fastjson 1.2.47 /** * GET---无参测试 * */ @Test pub
HTTP请求工具类实现
最新发布
weixin_44775694的博客
03-26 217
一个基本的 HTTP 工具类通常会提供一些常见的 HTTP 请求功能，比如发送 GET 和 POST 请求，并且可能会处理一些常见的请求头、参数、以及处理响应等。
HttpClient用法的简单
dongtedu的博客
02-21 367
在项目开发中应用到了HttpClient，在这里做一个简单总结并提供一个简单案例，以备他日参考
httpclient
03-16
创建HttpClient实例是使用HttpClient的第一步。通常，我们会创建一个`CloseableHttpClient`对象，这可以通过`HttpClientBuilder`或者`HttpAsyncClientBuilder`来实现。例如： ```java CloseableHttpClient ...
httpClient
04-25
HttpClient库提供了丰富的API来处理这两种请求类型，允许设置请求头、携带参数、处理响应等。例如，你可以使用`HttpGet`和`HttpPost`类创建请求对象，通过`NameValuePair`或`HttpEntity`添加请求参数，使用`...
httpclient方式调用url
04-04
本篇文章将深入探讨如何使用HttpClient方式调用URL，以及相关的知识点。 首先，HttpClient允许我们构建复杂的HTTP请求，包括GET、POST以及其他HTTP方法。使用HttpClient调用URL的基本步骤包括创建HttpClient实例、...
HttpClient调用大宝CA版本JSSE访问国密SSL协议的HTTPS服务的方法
upset_ming的博客
06-19 1955
系统要求 1. Windows系统、Linux系统、Mac系统 2. JDK7及以上 3. JDK使用无限制的安全策略文件 HttpClient客户端核心代码 import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.secur...
基于httpclient4.5.6实现ssl双向访问、单向访问
luoni186的专栏
09-11 1602
1.引入包 &lt;dependency&gt;     &lt;groupId&gt;org.apache.httpcomponents&lt;/groupId&gt;     &lt;artifactId&gt;httpclient&lt;/artifactId&gt;     &lt;version&gt;4.5.6&lt;/version&gt; &lt;/dependency&
用HttpClient发送HTTPS请求报SSLException: Certificate for <域名> doesn't match any of the subject alternative...
weixin_30751947的博客
02-25 2868
最近用server酱-PushBear做消息自动推送，用apache HttpClient做https的get请求，但是代码上到服务器端就报javax.net.ssl.SSLException: Certificate for <域名> doesn't match any of the subject alternative names: [域名]，仔细翻了一下文档发现是HttpCli...
HttpClient 连接池配置和使用
lhq15222807611的博客
07-06 2471
如果每次都重新创建一个新的HttpClient对象的话，当并发上来时，容易出现异常或连接失败，超时。这里可以使用HttpClient的连接池配置，减少HttpClient创建的数量，减少资源开销。 packagecom.mygame.common.utils; importjava.io.IOException; importjava.security.KeyManagementException; importjava.security.KeyStoreException; imp...
HttpClient 双向认证
Frank的博客
11-28 1956
文章目录功能背景角色介绍服务器端证书获取Gateway 信任客户端证书OpenSSL对d证书文件处理证书文件生成JKS文件Server端证书处理Client端证书处理证书文件生成P12文件Server端证书处理Client端证书处理HttpClient双向认证（Mutual Authentication ）实现WebSphere中的特殊处理 功能背景 最近我们项目很多依赖API纷纷上Azure,通...
Java调用第三方接口示范
热门推荐
code_monkey的博客
10-08 30万+
人工智能，零基础入门！http://www.captainbed.net/inner 在项目开发中经常会遇到调用第三方接口的情况，比如说调用第三方的天气预报接口。 使用流程 【1】准备工作：在项目的工具包下导入HttpClientUtil这个工具类，或者也可以使用Spring框架的restTemplate来调用，上面有调用接口的方法【分为Get和Post方式的有参和无参调用】： pa...
HttpClient使用方法及基本参数含义
飞火龙在天的博客
08-24 1713
一、方法 使用HttpClient发送请求、接收响应很简单，一般需要如下几步即可。 1. 创建HttpClient对象。 2. 创建请求方法的实例，并指定请求URL。如果需要发送GET请求，创建HttpGet对象；如果需要发送POST请求，创建HttpPost对象。 3. 如果需要发送请求参数，可调用HttpGet、HttpPost共同的setParams(HetpParams params...
使用HttpClient携带证书报错_Certificate for <IP> doesn't match any of the subject alternative names:[域名]
gaoshan12345678910的博客
06-20 1万+
使用HttpClient携带pfx证书通过Https协议发送SOUP报文调用WebService接口时报如下错误： Exception in thread "main" javax.net.ssl.SSLPeerUnverifiedException: Certificate for <IP地址> doesn't match any of the subject alternati...
HttpClient通信
Object
01-02 276
/** * 默认请求超时时间 */ private static final int TIMEOUT = 10000; /** * 默认连接超时时间 */ private static final int SO_TIMEOUT = 10000; /** * 默认编码 */ private static
HttpClient实现https请求
何超杰的博客
08-23 9446
package test.ssl; import java.security.KeyManagementException; import java.security.NoSuchAlgorithmException; import java.security.SecureRandom; import java.util.ArrayList; import java.util.List; impo...
HttpClient
10-09
HttpClient最初是Apache的一个开源项目，现在已经成为了Apache HttpComponents的一部分。HttpClient的主要特点包括： 1. 简单易用：HttpClient提供了简洁、易用的API，使得我们可以轻松地发送HTTP请求。 2. 可扩展...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值