HttpClient工具类

原创 已于 2024-07-08 09:34:48 修改 · 7.2k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#json #java #前端

于 2022-11-21 09:56:58 首次发布
本文介绍了一个实用的HTTP客户端工具类，包含多种HTTP请求方法（GET、POST、PUT、DELETE等），支持基本认证、JSON和表单提交，并设置了合理的超时时间。 
public class HttpClientUtil {

	/**
	 * Http 基本认证
	 * @param username 用户名
	 * @param password 密码
	 * @return Base64加密值
	 *
	 */
	public static String getBasicAuthentication(String username, String password) {
		String valueToEncode = username + ":" + password;
		return "Basic " + Base64.getEncoder().encodeToString(valueToEncode.getBytes());
	}

	public static String sendGet(String url) {
        CloseableHttpResponse resp = null;
        CloseableHttpClient client = null;
        try {
            client = HttpClients.createDefault();
            HttpGet get = new HttpGet(url);
            resp = client.execute(get);
            HttpEntity entity = resp.getEntity();
            return EntityUtils.toString(entity, "utf-8");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (resp != null) {
                    resp.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (client != null) {
                    client.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

	public static String sendGet(String url,Map<String, String> headers) {
        CloseableHttpResponse resp = null;
        CloseableHttpClient client = null;
        try {
            client = HttpClients.createDefault();
            HttpGet get = new HttpGet(url);
            for(String key : headers.keySet()){
                get.addHeader(key, headers.get(key));
            }
            resp = client.execute(get);
            HttpEntity entity = resp.getEntity();
            return EntityUtils.toString(entity, "utf-8");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (resp != null) {
                    resp.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (client != null) {
                    client.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

	/**
     * post请求json
     * @param url
     * @param json
     * @return
     * @throws Exception
     */
    public static String sendJsonPost(String url, String json) throws Exception {
        return sendPost(url, json, "application/json");
    }


    public static String sendPost(String url, String content, String type) {
        CloseableHttpClient client = null;
        CloseableHttpResponse resp = null;
        try {
            client = HttpClients.createDefault();
            HttpPost post = new HttpPost(url);
            post.addHeader("Content-type", type);
            StringEntity entity = new StringEntity(content, ContentType.create(type, "UTF-8"));
            post.setEntity(entity);
            resp = client.execute(post);
            int statusCode = resp.getStatusLine().getStatusCode();
            return EntityUtils.toString(resp.getEntity(), "utf-8");
        } catch (UnsupportedCharsetException | ParseException | IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (client != null)
                    client.close();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            try {
                if (resp != null)
                    resp.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

	public static String sendPost(String url, Map<String, String> headers, String content) {
        CloseableHttpClient client = null;
        CloseableHttpResponse resp = null;
        try {
            client = HttpClients.createDefault();
            HttpPost post = new HttpPost(url);
            for(String key : headers.keySet()){
                post.addHeader(key, headers.get(key));
            }
            StringEntity entity = new StringEntity(content, "UTF-8");
            post.setEntity(entity);
            resp = client.execute(post);
            return EntityUtils.toString(resp.getEntity(), "utf-8");
        } catch (UnsupportedCharsetException | ParseException | IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (client != null)
                    client.close();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            try {
                if (resp != null)
                    resp.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
    
	/**
	 * Http Post 请求设置过期时间
	 * @param url 请求地址
	 * @param headers 请求头
	 * @param content 参数内容 JSON
	 * @return 响应
	 */
	public static String sendPost(String url, Map<String, String> headers, String content) {
		CloseableHttpClient client = null;
		CloseableHttpResponse resp = null;
		try {
			RequestConfig defaultRequestConfig = RequestConfig.custom()
					.setConnectTimeout(5000)// 设置连接超时时间
					.setConnectionRequestTimeout(5000) // 设置从 connect Manager 获取 Connection 超时时间
					.setSocketTimeout(5000)// 请求获取数据的超时时间
					.build();
			client = HttpClients.custom().setDefaultRequestConfig(defaultRequestConfig).build();
			HttpPost post = new HttpPost(url);
			for (String key : headers.keySet()) {
				post.addHeader(key, headers.get(key));
			}
			StringEntity entity = new StringEntity(content, StandardCharsets.UTF_8);
			post.setEntity(entity);
			resp = client.execute(post);
			return EntityUtils.toString(resp.getEntity(), StandardCharsets.UTF_8);
		} catch (UnsupportedCharsetException | ParseException | IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (client != null)
					client.close();
			} catch (IOException e1) {
				e1.printStackTrace();
			}
			try {
				if (resp != null)
					resp.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	/**
     * POST请求x-www-form-urlencoded方式
     */
	public static String sendPost(String url,Map<String, String> headers, Map<String,String> params){
        CloseableHttpClient client = null;
        CloseableHttpResponse resp = null;
        try {
            client = HttpClients.createDefault();
            HttpPost post = new HttpPost(url);
            for (String key : headers.keySet()) {
                post.addHeader(key, headers.get(key));
            }
            List<NameValuePair> parameters = new ArrayList<>();
            for (Map.Entry<String, String> entry : params.entrySet()) {
                parameters.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
            }
            UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(parameters,StandardCharsets.UTF_8);
            post.setEntity(formEntity);
            resp = client.execute(post);
            return EntityUtils.toString(resp.getEntity(), StandardCharsets.UTF_8);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (client != null) {
                    client.close();
                }
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            try {
                if (resp != null) {
                    resp.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

 	/**
     * POST请求x-www-form-urlencoded方式
     */
    public static String sendPostForm(String url, Map<String, String> headers, Map<String, Object> params) {
        try {
            // 设置请求头
            org.springframework.http.HttpHeaders httpHeaders = new org.springframework.http.HttpHeaders();
            for (String key : headers.keySet()) {
                httpHeaders.add(key, headers.get(key));
            }
            // 设置参数
            MultiValueMap<String, Object> parameters = new LinkedMultiValueMap<>();
            for (Map.Entry<String, Object> entry : params.entrySet()) {
                parameters.add(entry.getKey(), entry.getValue());
            }
            // 发送请求
            org.springframework.http.HttpEntity<MultiValueMap<String, Object>> requestEntity = new org.springframework.http.HttpEntity<>(parameters, httpHeaders);
            ResponseEntity<String> response = new RestTemplate().exchange(url, HttpMethod.POST, requestEntity, String.class);
            return response.getBody();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

	public static void main(String[] args) {
        // 设置参数
        Map<String, Object> params = new LinkedHashMap<>();
        params.put("name", "Amy");
        params.put("age", "22");
        // 设置请求头
        Map<String, String> headers = new HashMap<>();
        headers.put("Content-Type", "application/x-www-form-urlencoded");
        // 发送请求
        String response = sendPostForm("http://127.0.0.1:8080", headers, params);
        System.out.println(response);
    }

	public static String sendPut(String url, Map<String, String> headers, String content) {
        CloseableHttpClient client = null;
        CloseableHttpResponse resp = null;
        try {
            client = HttpClients.createDefault();
            HttpPut put = new HttpPut(url);
            for(String key : headers.keySet()){
                put.addHeader(key, headers.get(key));
            }
            StringEntity entity = new StringEntity(content, "UTF-8");
            put.setEntity(entity);
            resp = client.execute(put);
            return EntityUtils.toString(resp.getEntity(), "utf-8");
        } catch (UnsupportedCharsetException | ParseException | IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (client != null)
                    client.close();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            try {
                if (resp != null)
                    resp.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

	public static String sendPut(String url, Map<String, String> headers, byte[] content) {
        CloseableHttpClient client = null;
        CloseableHttpResponse resp = null;
        try {
            client = HttpClients.createDefault();
            HttpPut put = new HttpPut(url);
            for(String key : headers.keySet()){
                put.addHeader(key, headers.get(key));
            }
            ByteArrayEntity entity = new ByteArrayEntity(content);
            put.setEntity(entity);
            resp = client.execute(put);
            return EntityUtils.toString(resp.getEntity(), "utf-8");
        } catch (UnsupportedCharsetException | ParseException | IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (client != null)
                    client.close();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            try {
                if (resp != null)
                    resp.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

	public static String sendDelete(String url, Map<String, String> headers) {
        CloseableHttpClient client = null;
        CloseableHttpResponse resp = null;
        try {
            client = HttpClients.createDefault();
            HttpDelete delete = new HttpDelete(url);
            for(String key : headers.keySet()){
                delete.addHeader(key, headers.get(key));
            }
            resp = client.execute(delete);
            return EntityUtils.toString(resp.getEntity(), "utf-8");
        } catch (UnsupportedCharsetException | ParseException | IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (client != null)
                    client.close();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            try {
                if (resp != null)
                    resp.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

}
httpclientUtil
07-12
该项目其实有3个工具类： 1.基于HttpClient-4.4.1封装的一个工具类； 2.基于HttpAsycClient-4.1封装的异步HttpClient工具类； 3.javanet包下面是基于jdk自带的UrlConnection进行封装的。 前2个工具类支持插件式配置Header、插件式配置httpclient对象，这样就可以方便地自定义header信息、配置ssl、配置proxy等。 第三个虽然支持代理、ssl，但是并没有把代理ssl等进行抽象。
httpclientutil
07-12
HttpClientUtil2-发送json返回json测试通过.java
httpClientUtil
04-02
超全的httpClient工具类，post get 参数
精选资源
httpClient 工具类
05-06
httpClient 工具类，简化请求开发，拿来即用，我用在SpringBoot框架；对于依赖，你可以根据包名导入。
httpclient 工具类
05-17
在本文中，我们将深入探讨HttpClient工具类的创建与使用，以及如何自定义返回的对象。 首先，我们需要引入HttpClient的相关依赖。在Maven项目中，可以在pom.xml文件中添加以下依赖： ```xml <groupId>org.apache...
HTTPClient工具类，完整
08-07
HTTPClient工具类，完整，HTTPClient工具类，完整，HTTPClient工具类，完整HTTPClient工具类，完整，HTTPClient工具类，完整
精选资源
高效池化-JAVA-HttpClient工具类
05-19
1.高效简单池化的HttpClient工具类,提供单元测试用列。 2.支持基于SpringBoot 2.1.x的自动装载模块，引用依赖即可使用。 3.公司几十个项目都使用该工具类访问第三方的Http/Https+json协议接口。 4.经过上市公司多个...
HttpClient 4.5 封装的工具类 HttpUtil 可用于爬虫和模拟登陆
06-26
基于Apache HttpClient 4.5.2 封装的工具类 HttpUtil 可用于爬虫和模拟登陆。使用新的语法后比3.*版本的速度感觉有提升。使用后注意资源的释放 pom 部分，应该不全，需要用的根据代码的import去找maven资源即可。 org.apache.httpcomponents httpclient 4.5.2 org.apache.httpcomponents httpmime 4.5.1
HttpclientUtil
u011165335的博客
11-19 370
参考: import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Map; import org.apache.http.HttpEntity; import org.apache.http.NameValuePair; import org.apache.http.client
HTTPClientUtil工具
Alice_8899的博客
02-27 322
package com.finlabtech.pinjamancepatanalyse.util; import com.google.common.base.Predicates; import com.google.common.collect.Maps; import lombok.extern.slf4j.Slf4j; import org.apache.commons.collecti...
工具类——HttpClientUtil（进行http请求，机试时可用）
weixin_40805079的博客
07-28 1329
想起之前去面试的时候，有一家让上机测试的，就是做一个简单的增删改查，远程操作，给了接口。当时想用webService来做的，但是半天jar包下不下来，当时也没想到用httpClient，结果没做出来，也就没了下文了。正好现在的项目也用到了httpClient，当然只是封装了一下，也是做请求用的，现在把这个工具类的代码贴出来，供以后备用。 public class HttpClientUtil ...
HttpClientUtil
weixin_42957419的博客
02-23 362
HttpClientUtil接口调用工具类
httpclient工具类
07-27
Java HttpClient工具类是一个用于发送HTTP请求的Java类库。...该工具类可以用于访问Web服务、下载文件、上传文件等各种场景。...使用Java HttpClient工具类可以方便地实现与Web服务的交互，提高开发效率。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值