Http客户端工具类

最新推荐文章于 2024-06-01 19:36:53 发布
最新推荐文章于 2024-06-01 19:36:53 发布
阅读量253 收藏
点赞数
分类专栏： java 文章标签： java httpclient
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37125796/article/details/81070943
版权

       在平时工作中，我们经常会有请求接口的需求，抽时间总结了一下供大家参考。

依赖包: 

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

 工具类文件：

package com.rz.util;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.SocketTimeoutException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.ParseException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
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.client.utils.URLEncodedUtils;
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;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.fastjson.JSONObject;

/**
 * HTTP客户端帮助类
 */
public class HttpClientUtil {
	private static final Logger LOG = LoggerFactory.getLogger(HttpClientUtil.class);
	public static final String CHAR_SET = "UTF-8";

	private static CloseableHttpClient httpClient;
	private static int socketTimeout = 30000;
	private static int connectTimeout = 30000;
	private static int connectionRequestTimeout = 30000;
	// 配置总体最大连接池（maxConnTotal）和单个路由连接最大数（maxConnPerRoute），默认是(20，2)
	private static int maxConnTotal = 200; // 最大不要超过1000
	private static int maxConnPerRoute = 100;// 实际的单个连接池大小，如tps定为50，那就配置50

	static {
		RequestConfig config = RequestConfig.custom()
				.setSocketTimeout(socketTimeout)
				.setConnectTimeout(connectTimeout)
				.setConnectionRequestTimeout(connectionRequestTimeout).build();
		httpClient = HttpClients.custom().setDefaultRequestConfig(config)
				.setMaxConnTotal(maxConnTotal)
				.setMaxConnPerRoute(maxConnPerRoute).build();
	}

	public static CloseableHttpClient getClient() {
		return httpClient;
	}

	
	public static String get(String url) {
		try {
			return get(url, null, null);
		} catch (IOException e) {
			LOG.error("HttpClientUtil.get()报错：", e);
		}
		return null;
	}

	public static String get(String url, Map<String, String> map) {
		try {
			return get(url, map, null);
		} catch (IOException e) {
			LOG.error("HttpClientUtil.get()报错：", e);
		}
		return null;
	}

	public static String get(String url, String charset) {
		try {
			return get(url, null, charset);
		} catch (IOException e) {
			LOG.error("HttpClientUtil.get()报错：", e);
		}
		return null;
	}

	public static String get(String url, Map<String, String> paramsMap, String charset) throws IOException {
		if ( StringUtils.isBlank(url) ) {
			return null;
		}
		charset = (charset == null ? CHAR_SET : charset);
		if (null != paramsMap && !paramsMap.isEmpty()) {
			List<NameValuePair> params = new ArrayList<NameValuePair>();
			for (Map.Entry<String, String> map : paramsMap.entrySet()) {
				params.add(new BasicNameValuePair(map.getKey(), map.getValue()));
			}
			//GET方式URL参数编码
			String querystring = URLEncodedUtils.format(params, charset);
			if(StringUtils.contains(url, "?")) {
				url += "&" + querystring;
			} else {
				url += "?" + querystring;
			}
		}
		HttpGet httpGet = new HttpGet(url);
		httpGet.addHeader("Accept-Encoding", "*");
		CloseableHttpResponse response = null;
		try {
			response = getClient().execute(httpGet);
		} catch (SocketTimeoutException e) {
			LOG.error("请求超时，1秒后将重试1次："+ url, e);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e1) { }
			response = getClient().execute(httpGet);
		}
		// 状态不为200的异常处理。
		return EntityUtils.toString(response.getEntity(), charset);
	}
	
	
	/**
	 * 提供返回json结果的get请求(ESG专用)
	 * @param url
	 * @param charset
	 * @return
	 * @throws IOException   */
	public static String getResponseJson(String url, Map<String, String> map) {
		try {
			return getResponseJson(url, map, null);
		} catch (IOException e) {
			LOG.error("HttpClientUtil.getResponseJson()报错：", e);
		}
		return null;
	}

	public static String getResponseJson(String url, Map<String, String> paramsMap, String charset) throws IOException {
		if ( StringUtils.isBlank(url) ) {
			return null;
		}
		charset = (charset == null ? CHAR_SET : charset);
		if (null != paramsMap && !paramsMap.isEmpty()) {
			List<NameValuePair> params = new ArrayList<NameValuePair>();
			for (Map.Entry<String, String> map : paramsMap.entrySet()) {
				params.add(new BasicNameValuePair(map.getKey(), map.getValue()));
			}
			//GET方式URL参数编码
			String querystring = URLEncodedUtils.format(params, charset);
			if(StringUtils.contains(url, "?")) {
				url += "&" + querystring;
			} else {
				url += "?" + querystring;
			}
		}
		HttpGet httpGet = new HttpGet(url);
		httpGet.addHeader("Accept-Encoding", "*");
		httpGet.addHeader("Accept", "application/json;charset=UTF-8");
		CloseableHttpResponse response = null;
		try {
			response = getClient().execute(httpGet);
		} catch (SocketTimeoutException e) {
//			LOG.error("请求超时，1秒后将重试1次："+ url, e);
			LOG.error(e.getMessage()+ "请求超时，1秒后将重试1次："+ url);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e1) { }
			response = getClient().execute(httpGet);
		}
		
		// 状态不为200的异常处理。
		return EntityUtils.toString(response.getEntity(), charset);
	}

	public static String delete(String url, Map<String, String> paramsMap, String charset) throws IOException {
		if ( StringUtils.isBlank(url) ) {
			return null;
		}
		charset = (charset == null ? CHAR_SET : charset);
		if (null != paramsMap && !paramsMap.isEmpty()) {
			List<NameValuePair> params = new ArrayList<NameValuePair>();
			for (Map.Entry<String, String> map : paramsMap.entrySet()) {
				params.add(new BasicNameValuePair(map.getKey(), map.getValue()));
			}
			//GET方式URL参数编码
			String querystring = URLEncodedUtils.format(params, charset);
			if(StringUtils.contains(url, "?")) {
				url += "&" + querystring;
			} else {
				url += "?" + querystring;
			}
		}
		HttpDelete httpDelete = new HttpDelete(url);
		httpDelete.addHeader("Accept-Encoding", "*");
		CloseableHttpResponse response = getClient().execute(httpDelete);
		// 状态不为200的异常处理。
		return EntityUtils.toString(response.getEntity(), charset);
	}

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

	public static String post(String url, String request, String charset) {
		if ( StringUtils.isBlank(url) ) {
			return null;
		}
		String res = null;
		CloseableHttpResponse response = null;
		try {
			charset = (charset == null ? CHAR_SET : charset);
			StringEntity entity = new StringEntity(request, charset);
			HttpPost httpPost = new HttpPost(url);
			httpPost.addHeader("Content-Type", "application/json;charset=utf-8");
			httpPost.addHeader("Accept-Encoding", "*");
			httpPost.setEntity(entity);
			try {
				response = getClient().execute(httpPost);
			} catch (SocketTimeoutException e) {
				LOG.error("请求超时，1秒后将重试1次："+ url, e);
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e1) { }
				response = getClient().execute(httpPost);
			}
			res = EntityUtils.toString(response.getEntity());
			// 状态不为200的异常处理。
		} catch (ParseException e) {
			LOG.error("HTTP Post(), ParseException: ", e);
		} catch (IOException e) {
			LOG.error("HTTP Post(), IOException: ", e);
		} finally {
			if (response != null) {
				try {
					response.close();
				} catch (IOException e) {
				}
			}
		}
		return res;
	}

	public static String post(String url, Map<String, String> map) {
		return post(url, map, null);
	}

	public static String post(String url, Map<String, String> paramsMap, String charset) {
		if ( StringUtils.isBlank(url) ) {
			return null;
		}
		String res = null;
		CloseableHttpResponse response = null;
		try {
			charset = (charset == null ? CHAR_SET : charset);
			List<NameValuePair> params = new ArrayList<NameValuePair>();
			for (Map.Entry<String, String> map : paramsMap.entrySet()) {
				params.add(new BasicNameValuePair(map.getKey(), map.getValue()));
			}
			UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(params, charset);
			HttpPost httpPost = new HttpPost(url);
			httpPost.addHeader("Accept-Encoding", "*");
			httpPost.setEntity(formEntity);
			try {
				response = getClient().execute(httpPost);
			} catch (SocketTimeoutException e) {
				LOG.error("请求超时，1秒后将重试1次："+ url, e);
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e1) { }
				response = getClient().execute(httpPost);
			}
			
			res = EntityUtils.toString(response.getEntity());
			// 状态不为200的异常处理。
			if (response.getStatusLine().getStatusCode() != 200) {
				throw new IOException(res);
			}
		} catch (IOException e) {
			LOG.error("HTTP Post(), IOException: ", e);
		} finally {
			if (response != null) {
				try {
					response.close();
				} catch (IOException e) {
				}
			}
		}
		return res;
	}
	
	
	/**
	 * 提供返回json结果的post请求 
	 * @param url
	 * @param map
	 * @param charset
	 * @return json
	 * @throws IOException  */
	public static String postResponseJson(String url, Map<String, String> map) {
		return postResponseJson(url, map, null);
	}
	
	/**
	 * Put方式提交
	 * @param url
	 * @param paramsMap
	 * @param charset
	 * @return response.getEntity()  */
	public static String postResponseJson(String url, Map<String, String> paramsMap, String charset) {
		if ( StringUtils.isBlank(url) ) {
			return null;
		}
		String res = null;
		CloseableHttpResponse response = null;
		try {
			charset = (charset == null ? CHAR_SET : charset);
			List<NameValuePair> params = new ArrayList<NameValuePair>();
			for (Map.Entry<String, String> map : paramsMap.entrySet()) {
				params.add(new BasicNameValuePair(map.getKey(), map.getValue()));
			}
			UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(params, charset);
			
			//解决url中的一些特殊字符
			URI uri = null;
			HttpPost httpPost = null;
			try {
				URL url2 = new URL(url);
				uri = new URI(url2.getProtocol(), url2.getUserInfo(), url2.getHost(), url2.getPort(), url2.getPath(), url2.getQuery(), null);
			} catch (URISyntaxException e) {
				LOG.error("URL中存在非法编码："+ url, e);
				uri = null;
			}
			if(uri != null) {
				httpPost = new HttpPost( uri );
			} else {
				httpPost = new HttpPost( url );
			}
			httpPost.addHeader("Accept-Encoding", "*");
			httpPost.addHeader("Accept", "application/json;charset=UTF-8");
			httpPost.setEntity(formEntity);
			try {
				response = getClient().execute(httpPost);
			} catch (SocketTimeoutException e) {
//				LOG.error("请求超时，1秒后将重试1次："+ url, e);
				LOG.error(e.getMessage()+ "请求超时，1秒后将重试1次："+ url);
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e1) { }
				response = getClient().execute(httpPost);
			}
			
			res = EntityUtils.toString(response.getEntity());
			// 状态不为200的异常处理。
			if (response.getStatusLine().getStatusCode() != 200) {
				throw new IOException(res);
			}
		} catch (IOException e) {
			LOG.error("postResponseJson方法报错: ", e);
		} finally {
			if (response != null) {
				try {
					response.close();
				} catch (IOException e) {
				}
			}
		}
		return res;
	}
	

	/**
	 * Put方式提交
	 * @param url
	 * @param paramsMap
	 * @param charset
	 * @return response.getEntity()  */
	public static String put(String url, Map<String, String> paramsMap, String charset) {
		if ( StringUtils.isBlank(url) ) {
			return null;
		}
		String res = null;
		CloseableHttpResponse response = null;
		try {
			charset = (charset == null ? CHAR_SET : charset);
			List<NameValuePair> params = new ArrayList<NameValuePair>();
			for (Map.Entry<String, String> map : paramsMap.entrySet()) {
				params.add(new BasicNameValuePair(map.getKey(), map.getValue()));
			}
			UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(params, charset);
			HttpPut httpPut = new HttpPut(url);
			httpPut.addHeader("Accept-Encoding", "*");
			httpPut.setEntity(formEntity);
			try {
				response = getClient().execute(httpPut);
			} catch (SocketTimeoutException e) {
				LOG.error("请求超时，1秒后将重试1次："+ url, e);
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e1) { }
				response = getClient().execute(httpPut);
			}
			
			res = EntityUtils.toString(response.getEntity());
			// 状态不为200的异常处理。
			if (response.getStatusLine().getStatusCode() != 200) {
				throw new IOException(res);
			}
		} catch (IOException e) {
			LOG.error("HTTP put(), IOException: ", e);
		} finally {
			if (response != null) {
				try {
					response.close();
				} catch (IOException e) {
				}
			}
		}
		return res;
	}

	
	/**
	 * Titel 提交HTTP请求，获得响应(application/x-www-form-urlencoded) Description
	 * 使用NameValuePair封装参数，适用于下载文件。
	 * @param serviceURI : 接口地址
	 * @param timeOut : 超时时间
	 * @param params : 请求参数
	 * @param charset : 参数编码
	 * @return CloseableHttpResponse  */
	public static CloseableHttpResponse submitPostHttpReq(final String serviceURI, final int timeOut, 
			final Map<String, String> pmap, final String charset) {
		CloseableHttpResponse response = null;
		LOG.info("即将发起HTTP请求！serviceURI：" + serviceURI);
		// 遍历封装参数
		List<NameValuePair> formParams = new ArrayList<NameValuePair>();
		for (String key : pmap.keySet()) {
			NameValuePair pair = new BasicNameValuePair(key, pmap.get(key));
			formParams.add(pair);
		}
		// 转换为from Entity
		UrlEncodedFormEntity fromEntity = null;
		try {
			fromEntity = new UrlEncodedFormEntity(formParams, CHAR_SET);
		} catch (UnsupportedEncodingException e) {
			LOG.error("创建UrlEncodedFormEntity异常，编码问题: " + e.getMessage());
			return null;
		}

		// 创建http post请求
		HttpPost httpPost = new HttpPost(serviceURI);
		httpPost.setEntity(fromEntity);
		// 设置请求和传输超时时间
		RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(timeOut).setConnectTimeout(timeOut).build();
		httpPost.setConfig(requestConfig);

		// 提交请求、获取响应
		LOG.info("提交http请求！serviceURI：" + serviceURI);
		CloseableHttpClient httpclient = HttpClients.createDefault();
		try {
			response = httpclient.execute(httpPost);
		} catch (SocketTimeoutException e) {
			LOG.error("请求超时，1秒后将重试1次："+ serviceURI, e);
			try {
				Thread.sleep(1000);
				response = httpclient.execute(httpPost);
			} catch (Exception e1) {
				LOG.error("超时后再次请求报错：", e);
				response = null;
			}
		} catch (IOException e) {
			LOG.error("httpclient.execute异常！" + e.getMessage());
			response = null;
		}
		LOG.info("提交http请求！serviceURI：" + serviceURI);
		return response;
	}


	public static int getSocketTimeout() {
		return socketTimeout;
	}

	public static void setSocketTimeout(int socketTimeout) {
		HttpClientUtil.socketTimeout = socketTimeout;
	}

	public static int getConnectTimeout() {
		return connectTimeout;
	}

	public static void setConnectTimeout(int connectTimeout) {
		HttpClientUtil.connectTimeout = connectTimeout;
	}

	public static int getConnectionRequestTimeout() {
		return connectionRequestTimeout;
	}

	public static void setConnectionRequestTimeout(int connectionRequestTimeout) {
		HttpClientUtil.connectionRequestTimeout = connectionRequestTimeout;
	}
	
	/**
	 * 请求josn串，返回josn对象
	 * */
	public static JSONObject doPost(String url, String jsonStr) {
		HttpPost post = new HttpPost(url);
		JSONObject response = null;
		try {
			StringEntity s = new StringEntity(jsonStr,"UTF-8");
			s.setContentType("application/json");// 发送json数据需要设置contentType
			post.setEntity(s);
			HttpResponse res = getClient().execute(post);
			if (res.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
				String result = EntityUtils.toString(res.getEntity());// 返回json格式：
				response = JSONObject.parseObject(result);
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		return response;
	}
}

完

 

csdn-延
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
http客户端工具类 - 含完整代码及内部解析
.
12-04 1万+
文章目录Http客户端工具用途及分析完整的代码段结束 Http客户端工具 文章目录 Maven打包Jar + Http向Url发送Get请求_lijiamin-的CSDN博客 前段时间，我写了一个非常简陋的Get请求的代码用于刷CSDN的访客量，但是那个玩意并不能用于实际工作中，因为它里面并没有包含什么其他的参数，只是简简单单的发起请求，但是在这几天的工作中，我有幸接触到了这篇代码，现将它刨析一番并分享给大家 用途及分析 顾名思义，是一个HTTP客户端工具，能通过代码方式发起get、po
HTTP客户端工具该选哪个？进来看
javajavajava
12-27 927
HTTP（超文本传输协议）是一种应用层协议，用于客户端和服务端进行通信，按照标准格式如JSON、XML等进行网络数据的传输，通常也作为应用程序之间以RESTAPI形式进行通信的常用协议。在Java应用中需要调用其他应用提供的HTTP服务API时，通常需要使用一些HTTP客户端组件。而可选择的HTTP客户端有很多，本期内容主要介绍在Java应用程序中可以使用的HTTP客户端工具。Java 11+版本中提供的HttpClientApache HttpComponents项目中的HttpClient。
Hutool简介及http客户端工具类
zhang2312600_a的博客
10-27 1686
Hutool简介及http客户端工具类
第一回 比Postman还好用的Http客户端工具：HttpClient小工具
最新发布
天天智作
06-01 1298
全能型Http客户端工具(HttpClient)，比Postman还好用！快速调试Http API、快速形成测试用例、极大提高开发和测试效率！
Hutool Http客户端工具类-HttpUtil使用
旭东怪的博客
02-18 3万+
HttpUtil是应对简单场景下Http请求的工具类封装，这个工具类可以保证在一个方法之内完成Http请求。 1HttpUtil.get() 用于请求普通页面，然后返回页面内容的字符串，同时提供一些重载方法用于指定请求参数。 // 最简单的HTTP请求，可以自动通过header等信息判断编码，不区分HTTP和HTTPS String result1= HttpUtil.get("https://www.baidu.com"); // 当无法识别页面编码的时候，可以自定义请求页面的编码 Strin.
Http客户端工具类-HttpUtil
Hningning的博客
11-27 5344
Http客户端工具类-HttpUtil 概述 HttpUtil是应对简单场景下Http请求的工具类封装，此工具封装了HttpRequest对象常用操作，可以保证在一个方法之内完成Http请求。 此模块基于JDK的HttpUrlConnection封装完成，完整支持https、代理和文件上传。 使用 请求普通页面 针对最为常用的GET和POST请求，HttpUtil封装了两个方法， H...
Java中的HTTP客户端工具——RestTemplate
意识流的博客
09-27 4916
Java中的HTTP客户端工具——RestTemplate
【工具类】Elasticsearch的HTTP客户端（Java）
dreambyday
12-27 808
Java基于Http请求操作ES，与Kibana上的操作一致。如图该DSL可转化为HTTP请求。
Qt项目实战4：http客户端工具
Charles的博客
03-21 4190
文章目录qhttpc功能实现http请求http回复http同步接收数据http用户认证界面设计 qhttpc功能实现 支持通过URL访问http服务器 支持选择GET、POST、PUT、DELETE、HEAD等请求方式 支持在URL后追加query字段 支持追加PUT/POST body数据 支持显示接收回复body数据 支持显示接收回复头数据 http请求 在.pro文件中增加网络组件支持...
java 获取客户端真实IP工具类
rocky的编程随记
06-19 1072
随着nginx等工具兴起，单纯采用 HttpServletRequest.getRemoteHost()已经不能获取客户端的真实IP。以下是一个Java获取客户端真实IP工具类。 import javax.servlet.http.HttpServletRequest; public class RequestUtil { public static String getRealIp(...
java http 客户端_HTTP 客户端性能大比拼
weixin_30413679的博客
02-12 1202
Http客户端调用目前应用很普遍，无论是分布式系统，或安卓等移动手机或开放API调用等，哪种客户端调用性能最快呢？该文比较了目前大部分如下客户端库包：1. Apache httpcomponents-client4.2.5Java IOJava语言2. Apache commons-httpclient (discontinued)3.1Java IOJava语言3. Apache HttpAsy...
Http客户端工具类.txt
07-05
Http客户端工具类中包含了多种请求方式、多种参数类型的客户端请求方式的方法实现
HTTP请求客户端工具类RestTemplateUtil.java
06-09
org.springframework.web.client.AsyncRestTemplate org.springframework.web.client.RestTemplate HTTP请求工具类，基于以上两个Rest请求工具模板完成封装HTTP请求，包括同步和异步请求的实现。
http请求工具类及相关jar包
05-29
4. **HttpClient类**：Apache HttpClient是一个强大的HTTP客户端库，提供了更高级的功能，如重试策略、连接池管理、多线程请求等。它是许多Java应用处理HTTP请求的首选工具。 5. **工具类的设计**：这个“http请求...
HTTP网络客户端请求基础工具类
02-12
HTTP网络客户端请求基础工具类，可发送常见的GET、POST等请求方式，中文编码已处理，基于SSL连接，依赖的jar包有：commons-lang-2.6.jar、httpclient-4.3.2.jar、httpcore-4.3.1.jar、commons-io-2.4.jar
http客户端
11-15
在Windows环境中，使用Visual Studio作为开发工具，我们可以选择多种编程语言（如C#、VB.NET或C++）来创建HTTP客户端。VS提供了丰富的库支持，如.NET Framework中的System.Net.Http命名空间，它包含HttpClient类，...
Java多线程：向线程传递参数的三种方法
热门推荐
延宝小白马的博客
03-18 6万+
在传统的同步开发模式下，当我们调用一个函数时，通过这个函数的参数将数据传入，并通过这个函数的返回值来返回最终的计算结果。但在多线程的异步开发模式下，数据的传递和返回和同步开发模式有很大的区别。由于线程的运行和结束是不可预料的，因此，在传递和返回数据时就无法象函数一样通过函数参数和return语句来返回数据。本文就以上原因介绍了几种用于向线程传递数据的方法，在下一篇文章中将介绍从线程中返回数据的方法......
使用java8将list转为map
延宝小白马的博客
03-27 2万+
常用方式 代码如下： public Map<Long, String> getIdNameMap(List<Account> accounts) { return accounts.stream().collect(Collectors.toMap(Account::getId, Account::getUsername)); } 收集成实体本身ma...
java实现自动化Git操作
延宝小白马的博客
06-12 2万+
       最近在做一个项目中需要将系统中操作的SQL自动化维护到远程服务器上，git是一个非常强大的代码维护工具，遂对其自动化push做了一些研究，供大家学习参考。  java git api - jgit的资料还是比较多的，而且git的操作比svn更容易理解，所以毅然决然的在git的道路上越走越远。        如果你想在一个 Java 程序中使用 Git ，有一个功能齐全的 Git 库...
Java实现HTTP客户端程序设计
`HttpURLConnection`类提供了设置请求头、控制连接行为和处理响应的方法，是实现HTTP客户端的首选工具。 五、课程设计步骤 1. 设计HTTP客户端类，初始化URL对象。 2. 创建`HttpURLConnection`实例，设置请求方法和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值