httpClient的调用

清疚 2022-05-20 06:53 169阅读 0赞

我们项目中以前使用的httpClient代码，现在把他记录下来，.

这是调用的方法类，delete做了处理支持body参数

package org.system.request;
 
 import java.text.MessageFormat;
 import java.util.HashMap;
 import java.util.Map;
 
 import javax.annotation.Resource;
 
 import org.springframework.stereotype.Component;
 import org.system.entity.permission.BaseModule;
 import org.system.service.impl.permission.BaseModuleService;
 import org.tools.StringUtil;
 import org.tools.spring.PropertyConfigurer;
 import org.utils.http.DeleteClient;
 import org.utils.http.GetClient;
 import org.utils.http.PostClient;
 import org.utils.http.PutClient;
 import org.utils.rsa.RSAUtils;
 
 import com.alibaba.fastjson.JSON;
 
 @Component
 public class HttpAPIRequest {
 	@Resource
 	private PropertyConfigurer propertyConfigurer;
 	@Resource
 	private BaseModuleService moduleService;
 	
 	
 	/**
 	 * GET查列表
 	* @author Gong.YiYang
 	* @param url
 	* @return 
 	* @date 2017年9月5日
 	* @version 1.0
 	* @description
 	 */
 	/*public Map<String,Object> APIGetFromMap(String url,Object object) {
 		Map<String, Object> obj2Map = StringUtil.obj2Map(object);
 		String synchronization = GetClient.synchronization(appendURL(url), obj2Map,getPermissionTokenString());
 		Map<String, Object> string2Map = StringUtil.String2Map(synchronization);
 		return string2Map;
 	}*/
 	/**
 	 * GET查详情
 	* @author Gong.YiYang
 	* @param url
 	* @param prams
 	* @return 
 	* @date 2017年9月6日
 	* @version 1.0
 	* @description
 	 */
 	public Map<String,Object> APIGetFromMap(String url,Object object,Object... arguments) {
 		Map<String, Object> obj2Map = StringUtil.obj2Map(object);
 		String synchronization = GetClient.synchronization(appendURL(url,arguments), obj2Map,getPermissionTokenString());
 		Map<String, Object> string2Map = StringUtil.String2Map(synchronization);
 		return string2Map;
 	}
 	/**
 	 * POST
 	* @author Gong.YiYang
 	* @param url
 	* @param object
 	* @return 
 	* @date 2017年9月5日
 	* @version 1.0
 	* @description
 	 */
 	public Map<String, Object> APIPostFromMap(String url,Object object){
 		Map<String,Object> map = StringUtil.obj2Map(object);
 		Map<String, String> headers = getPermissionTokenString();
 		String synchronizationForJSON = PostClient.synchronizationForJSON(appendURL(url), map, headers);
 		Map<String, Object> string2Map = StringUtil.String2Map(synchronizationForJSON);
 		return string2Map;
 	}
 	/**
 	 * 执行PUT方法
 	* @author Gong.YiYang
 	* @param url
 	* @param object
 	* @return 
 	* @date 2017年9月6日
 	* @version 1.0
 	* @description
 	 */
 	public Map<String, Object> APIPutFromMap(String url,Object object,Object... arguments){
 		Map<String,Object> map = StringUtil.obj2Map(object);
 		Map<String, String> headers = getPermissionTokenString();
 		String synchronizationForJSON = PutClient.synchronizationForJSON(appendURL(url,arguments), map, headers);
 		Map<String, Object> string2Map = StringUtil.String2Map(synchronizationForJSON);
 		return string2Map;
 	}
 	
 	/**
 	 * 执行Delete方法
 	* @author Gong.YiYang
 	* @param url
 	* @param object
 	* @return 
 	* @date 2017年9月7日
 	* @version 1.0
 	* @description
 	 */
 	public Map<String, Object> APIDeleteFromMap(String url,Object object,Object... arguments){
 		Map<String, Object> map = StringUtil.obj2Map(object);
 		Map<String, String> headers = getPermissionTokenString();
 		String synchronization = DeleteClient.synchronization(appendURL(url,arguments), map, headers);
 		Map<String, Object> string2Map = StringUtil.String2Map(synchronization);
 		return string2Map;
 	}
 	
 	/**
 	 * 生成token
 	* @author Gong.YiYang
 	* @return 
 	* @date 2017年9月5日
 	* @version 1.0
 	* @description
 	 */
 	public Map<String, String> getPermissionTokenString() {
 		这个方法是生成校验的token
 		 return headers;
 	}
 	/**
 	 * 拼接URL
 	* @author Gong.YiYang
 	* @param url
 	* @return 
 	* @date 2017年9月5日
 	* @version 1.0
 	* @description 这是在配置文件获取配置好的url地址
 	 */
 	public String appendURL(String url,Object... arguments){
 		String URL = propertyConfigurer.getProperty("URL");
 		String PropertiesURL = MessageFormat.format(propertyConfigurer.getProperty(url), arguments);
 		URL = URL+PropertiesURL;
 		return URL;
 	}
 
 	
 }

StringUtil是一个转化类，主要是map和对象的转化，

package org.tools;
 
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.HashMap;
 import java.util.Map;
 
 import org.core.result.ResultCode;
 import org.core.result.ResultMap;
 
 import com.fasterxml.jackson.core.JsonParseException;
 import com.fasterxml.jackson.databind.JsonMappingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 
 public class StringUtil {
 
 	/**
 	 * string转Map
 	 * 
 	 * @author Gong.YiYang
 	 * @param reString
 	 * @return
 	 * @date 2017年9月5日
 	 * @version 1.0
 	 * @throws IOException 
 	 * @throws JsonMappingException 
 	 * @throws JsonParseException 
 	 * @description
 	 */
 	@SuppressWarnings("unchecked")
 	public static Map<String, Object> String2Map(String reString) {
 		ObjectMapper mapper = new ObjectMapper();
 		Map<String, Object> readValue = ResultMap.convertMap(ResultCode.FAIL);
 		try {
 			readValue = mapper.readValue(reString, Map.class);
 		} catch (IOException e) {
 			throw new RuntimeException(e.getMessage());
 		}
 		return readValue;
 	}
 
 	/**
 	 * object转map
 	 * 
 	 * @author Gong.YiYang
 	 * @param obj
 	 * @return
 	 * @date 2017年9月5日
 	 * @version 1.0
 	 * @description
 	 */
 	public static Map<String, Object> obj2Map(Object obj) {
 
 		Map<String, Object> map = new HashMap<String, Object>();
 		// System.out.println(obj.getClass());
 		//获取父类分页
 		Object rows = getFieldValue(obj, "rows");
 		Object page = getFieldValue(obj, "page");
 		if (null != rows) {
 			map.put("rows", rows);
 		} 
 		if (null != page) {
 			map.put("page", page);
 		}
 		// 获取f对象对应类中的所有属性域
 		Field[] fields = obj.getClass().getDeclaredFields();
 		for (int i = 0, len = fields.length; i < len; i++) {
 			String varName = fields[i].getName();
 			//varName = varName.toLowerCase();// 将key置为小写，默认为对象的属性
 			try {
 				// 获取原来的访问控制权限
 				boolean accessFlag = fields[i].isAccessible();
 				// 修改访问控制权限
 				fields[i].setAccessible(true);
 				// 获取在对象f中属性fields[i]对应的对象中的变量
 				Object o = fields[i].get(obj);
 				if (null != o) {
 					map.put(varName, o);
 					//System.out.println("传入的对象中包含一个如下的变量：" + varName + " = " + o);
 				}
 				// 恢复访问控制权限
 				fields[i].setAccessible(accessFlag);
 			} catch (IllegalArgumentException ex) {
 				ex.printStackTrace();
 			} catch (IllegalAccessException ex) {
 				ex.printStackTrace();
 			}
 		}
 		return map;
 	}
 
 	public static Method getDeclaredMethod(Object object, String methodName, Class<?>... parameterTypes) {
 		Method method = null;
 		for (Class<?> clazz = object.getClass(); clazz != Object.class; clazz = clazz.getSuperclass()) {
 			try {
 				method = clazz.getDeclaredMethod(methodName, parameterTypes);
 				return method;
 			} catch (Exception e) {
 				// 这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。
 				// 如果这里的异常打印或者往外抛，则就不会执行clazz =
 				// clazz.getSuperclass(),最后就不会进入到父类中了
 			}
 		}
 		return null;
 	}
 
 	/**
 	 * 循环向上转型, 获取对象的 DeclaredField
 	 * 
 	 * @param object
 	 * : 子类对象
 	 * @param fieldName
 	 * : 父类中的属性名
 	 * @return 父类中的属性对象
 	 */
 	public static Field getDeclaredField(Object object, String fieldName) {
 		Field field = null;
 		Class<?> clazz = object.getClass();
 		for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
 			try {
 				field = clazz.getDeclaredField(fieldName);
 				return field;
 			} catch (Exception e) {
 				// 这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。
 				// 如果这里的异常打印或者往外抛，则就不会执行clazz =
 				// clazz.getSuperclass(),最后就不会进入到父类中了
 			}
 		}
 		return null;
 	}
 
 	/**
 	 * 直接读取对象的属性值, 忽略 private/protected 修饰符, 也不经过 getter
 	 * 
 	 * @param object
 	 * : 子类对象
 	 * @param fieldName
 	 * : 父类中的属性名
 	 * @return : 父类中的属性值
 	 */
 	public static Object getFieldValue(Object object, String fieldName) {
 
 		// 根据 对象和属性名通过反射 调用上面的方法获取 Field对象
 		Field field = getDeclaredField(object, fieldName);
 		// 抑制Java对其的检查
 		field.setAccessible(true);
 		try {
 			// 获取 object 中 field 所代表的属性值
 			return field.get(object);
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 		return null;
 	}
 }

下面的客户端，是我们老大自己写的

package org.utils.http;
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
 import org.apache.commons.collections.MapUtils;
 import org.apache.http.Consts;
 import org.apache.http.HttpResponse;
 import org.apache.http.HttpStatus;
 import org.apache.http.NameValuePair;
 import org.apache.http.ParseException;
 import org.apache.http.client.HttpClient;
 import org.apache.http.client.config.RequestConfig;
 import org.apache.http.client.entity.UrlEncodedFormEntity;
 import org.apache.http.client.methods.HttpGet;
 import org.apache.http.impl.client.HttpClientBuilder;
 import org.apache.http.message.BasicNameValuePair;
 import org.apache.http.util.EntityUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
 * @author 
 * @date 2017年7月12日
 * @version 1.0
 * @description Get方式调用
 */
 public class GetClient {
 	private static final Logger logger = LoggerFactory.getLogger(GetClient.class);
 	static ExecutorService pool = Executors.newCachedThreadPool();
 	private static HttpClient httpClient = HttpClientBuilder.create().build();
 	private static RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(20000).setConnectTimeout(10000).build();// 设置请求和传输超时时间
 
 	/**
 	 * @author 
 	 * @param url
 	 * @param headers
 	 * @date 2017年7月12日
 	 * @version 1.0
 	 * @description Get异步调用
 	 */
 	public static void asynchronous(String url, Map<String, String> headers) {
 		pool.execute(new Runnable() {
 			@Override
 			public void run() {
 				HttpGet get = new HttpGet(url);
 				/* 设置链接等待时间和超时时间 */
 				get.setConfig(requestConfig);
 				/* 设置Header */
 				if (headers != null && headers.size() > 0) {
 					for (Entry<String, String> header : headers.entrySet()) {
 						get.setHeader(header.getKey(), header.getValue());
 					}
 				}
 				try {
 					long startTime = System.currentTimeMillis();
 					HttpResponse response = httpClient.execute(get);
 					String resposeText = EntityUtils.toString(response.getEntity());
 					long times = System.currentTimeMillis() - startTime;
 					if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
 						if (logger.isInfoEnabled()) {
 							logger.info("GET:[{}] Success Taking:[{}] Header:[{}] Response:[{}]", url, times, headers, resposeText);
 						}
 					} else {
 						if (logger.isWarnEnabled()) {
 							logger.warn("GET:[{}] Fail Taking:[{}] Header:[{}] Response:[{}]", url, times, headers, resposeText);
 						}
 					}
 				} catch (IOException e) {
 					logger.error("GET:[{}] Error Taking:[{}] Header:[{}] Error Message:[{}]", url, headers, e);
 				}
 			}
 		});
 	}
 
 	/**
 	 * @author 
 	 * @param url
 	 * @param headers
 	 * @return {@link String}
 	 * @date 2017年7月12日
 	 * @version 1.0
 	 * @description Get同步调用
 	 */
 	public static String synchronization(String url, Map<String, String> headers) {
 		HttpGet get = new HttpGet(url);
 		/* 设置链接等待时间和超时时间 */
 		get.setConfig(requestConfig);
 		/* 设置Header */
 		if (headers != null && headers.size() > 0) {
 			for (Entry<String, String> header : headers.entrySet()) {
 				get.setHeader(header.getKey(), header.getValue());
 			}
 		}
 		try {
 			long startTime = System.currentTimeMillis();
 			HttpResponse response = httpClient.execute(get);
 			String resposeText = EntityUtils.toString(response.getEntity());
 			long times = System.currentTimeMillis() - startTime;
 			if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
 				if (logger.isInfoEnabled()) {
 					logger.info("GET:[{}] Success Taking:[{}] Header:[{}] Response:[{}]", url, times, headers, resposeText);
 				}
 				return resposeText;
 			} else {
 				if (logger.isWarnEnabled()) {
 					logger.warn("GET:[{}] Fail Taking:[{}] Header:[{}] Response:[{}]", url, times, headers, resposeText);
 				}
 			}
 		} catch (IOException e) {
 			logger.error("GET:[{}] Error Taking:[{}] Header:[{}] Error Message:[{}]", url, headers, e);
 		}
 		return null;
 	}
 	/**
 	 * Get同步查询
 	 * @param url
 	 * @param prams
 	 * @param headers
 	 * @return
 	 * @throws IOException 
 	 * @throws ParseException 
 	 */
 	public static String synchronization(String url,Map<String, Object> prams, Map<String, String> headers) {
 		try {
 		 //封装请求参数 
 ArrayList<NameValuePair> arrayList = new ArrayList<>();
 if (MapUtils.isNotEmpty(prams)) {
 			for (String key : prams.keySet()) {
 					if (null != prams.get(key) || ""!= prams.get(key)) {
 						arrayList.add(new BasicNameValuePair(key, String.valueOf(prams.get(key)))); 
 					}
 			}
 		}
 String str = ""; 
 //转换为键值对 
 str = EntityUtils.toString(new UrlEncodedFormEntity(arrayList, Consts.UTF_8));
 		HttpGet get = new HttpGet(url+"?"+str);
 		/* 设置链接等待时间和超时时间 */
 		get.setConfig(requestConfig);
 		/* 设置Header */
 		if (headers != null && headers.size() > 0) {
 			for (Entry<String, String> header : headers.entrySet()) {
 				get.setHeader(header.getKey(), header.getValue());
 			}
 		}
 	
 			long startTime = System.currentTimeMillis();
 			HttpResponse response = httpClient.execute(get);
 			String resposeText = EntityUtils.toString(response.getEntity());
 			long times = System.currentTimeMillis() - startTime;
 			if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
 				if (logger.isInfoEnabled()) {
 					logger.info("GET:[{}] Success Taking:[{}] Header:[{}] Response:[{}]", url, times, headers, resposeText);
 				}
 				return resposeText;
 			} else {
 				if (logger.isWarnEnabled()) {
 					logger.warn("GET:[{}] Fail Taking:[{}] Header:[{}] Response:[{}]", url, times, headers, resposeText);
 				}
 			}
 		} catch (IOException e) {
 			logger.error("GET:[{}] Error Taking:[{}] Header:[{}] Error Message:[{}]", url, headers, e);
 		}
 		return null;
 	}
 	
 }

package org.utils.http;
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
 import org.apache.http.HttpResponse;
 import org.apache.http.HttpStatus;
 import org.apache.http.NameValuePair;
 import org.apache.http.client.HttpClient;
 import org.apache.http.client.config.RequestConfig;
 import org.apache.http.client.entity.UrlEncodedFormEntity;
 import org.apache.http.client.methods.HttpPost;
 import org.apache.http.entity.StringEntity;
 import org.apache.http.impl.client.HttpClientBuilder;
 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;
 
 /**
 * @author 
 * @date 2017年7月12日
 * @version 1.0
 * @description Post方式调用
 */
 public class PostClient {
 	private static final Logger logger = LoggerFactory.getLogger(PostClient.class);
 	static ExecutorService pool = Executors.newCachedThreadPool();
 	private static HttpClient httpClient = HttpClientBuilder.create().build();
 	private static RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(20000).setConnectTimeout(10000).build();// 设置请求和传输超时时间
 
 	/**
 	 * @author 
 	 * @param url
 	 * @param params
 	 * @param headers
 	 * @date 2017年7月12日
 	 * @version 1.0
 	 * @description Post异步调用 表单
 	 */
 	public static void asynchronous(String url, Map<String, Object> params, Map<String, String> headers) {
 		pool.execute(new Runnable() {
 			@Override
 			public void run() {
 				HttpPost post = new HttpPost(url);
 				/* 设置链接等待时间和超时时间 */
 				post.setConfig(requestConfig);
 				/* 设置响应头 */
 				if (headers != null && headers.size() > 0) {
 					for (Entry<String, String> header : headers.entrySet()) {
 						post.setHeader(header.getKey(), header.getValue());
 					}
 				}
 				/* 设置需要提交的参数 非JSON格式提交 */
 				List<NameValuePair> list = new ArrayList<NameValuePair>();
 				if (params != null && params.size() > 0) {
 					for (Entry<String, Object> entry : params.entrySet()) {
 						Object objValue = entry.getValue();
 						list.add(new BasicNameValuePair(entry.getKey(), objValue == null ? "" : objValue.toString()));
 					}
 				}
 				try {
 					post.setEntity(new UrlEncodedFormEntity(list, "UTF-8"));
 					long startTime = System.currentTimeMillis();
 					HttpResponse response = httpClient.execute(post);
 					String resposeText = EntityUtils.toString(response.getEntity());
 					long times = System.currentTimeMillis() - startTime;
 					if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
 						if (logger.isInfoEnabled()) {
 							logger.info("POST:[{}] Success Taking:[{}] Header:[{}] Params:[{}] Response:[{}]", url, times, headers, params, resposeText);
 						}
 					} else {
 						if (logger.isWarnEnabled()) {
 							logger.warn("POST:[{}] Fail Taking:[{}] Header:[{}] Params:[{}] Response:[{}]", url, times, headers, params, resposeText);
 						}
 					}
 				} catch (IOException e) {
 					logger.error("POST:[{}] Error Taking:[{}] Header:[{}] Params:[{}] Error Message:[{}]", url, headers, params, e);
 				}
 			}
 		});
 	}
 
 	/**
 	 * @author 
 	 * @param url
 	 * @param params
 	 * @param headers
 	 * @return {@link String}
 	 * @date 2017年7月12日
 	 * @version 1.0
 	 * @description Post同步调用 表单
 	 */
 	public static String synchronization(String url, Map<String, Object> params, Map<String, String> headers) {
 		HttpPost post = new HttpPost(url);
 		/* 设置链接等待时间和超时时间 */
 		post.setConfig(requestConfig);
 		/* 设置响应头 */
 		if (headers != null && headers.size() > 0) {
 			for (Entry<String, String> header : headers.entrySet()) {
 				post.setHeader(header.getKey(), header.getValue());
 			}
 		}
 		/* 设置需要提交的参数 非JSON格式提交 */
 		List<NameValuePair> list = new ArrayList<NameValuePair>();
 		if (params != null && params.size() > 0) {
 			for (Entry<String, Object> entry : params.entrySet()) {
 				Object objValue = entry.getValue();
 				list.add(new BasicNameValuePair(entry.getKey(), objValue == null ? "" : objValue.toString()));
 			}
 		}
 		try {
 			post.setEntity(new UrlEncodedFormEntity(list, "UTF-8"));
 			long startTime = System.currentTimeMillis();
 			HttpResponse response = httpClient.execute(post);
 			String resposeText = EntityUtils.toString(response.getEntity());
 			long times = System.currentTimeMillis() - startTime;
 			if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
 				if (logger.isInfoEnabled()) {
 					logger.info("POST:[{}] Success Taking:[{}] Header:[{}] Params:[{}] Response:[{}]", url, times, headers, params, resposeText);
 				}
 				return resposeText;
 			} else {
 				if (logger.isWarnEnabled()) {
 					logger.warn("POST:[{}] Fail Taking:[{}] Header:[{}] Params:[{}] Response:[{}]", url, times, headers, params, resposeText);
 				}
 			}
 		} catch (IOException e) {
 			logger.error("POST:[{}] Error Taking:[{}] Header:[{}] Params:[{}] Error Message:[{}]", url, headers, params, e);
 		}
 		return null;
 	}
 
 	/**
 	 * @author 
 	 * @param url
 	 * @param params
 	 * @param headers
 	 * @date 2017年7月12日
 	 * @version 1.0
 	 * @description Post异步调用 JSON
 	 */
 	public static void asynchronousForJSON(String url, Map<String, Object> params, Map<String, String> headers) {
 		pool.execute(new Runnable() {
 			@Override
 			public void run() {
 				HttpPost post = new HttpPost(url);
 				/* 设置链接等待时间和超时时间 */
 				post.setConfig(requestConfig);
 				/* 设置响应头 */
 				if (headers != null && headers.size() > 0) {
 					for (Entry<String, String> header : headers.entrySet()) {
 						post.setHeader(header.getKey(), header.getValue());
 					}
 				}
 				/* 设置需要提交的参数 JSON格式提交 */
 				JSONObject jsonParam = new JSONObject();
 				if (params != null && params.size() > 0) {
 					for (Entry<String, Object> entry : params.entrySet()) {
 						jsonParam.put(entry.getKey(), entry.getValue());
 					}
 				}
 				try {
 					StringEntity entity = new StringEntity(jsonParam.toString(), "UTF-8");
 					entity.setContentEncoding("UTF-8");
 					entity.setContentType("application/json");
 					post.setEntity(entity);
 					long startTime = System.currentTimeMillis();
 					HttpResponse response = httpClient.execute(post);
 					long times = System.currentTimeMillis() - startTime;
 					String resposeText = EntityUtils.toString(response.getEntity());
 					if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
 						if (logger.isInfoEnabled()) {
 							logger.info("POST:[{}] Success Taking:[{}] Header:[{}] Params:[{}] Response:[{}]", url, times, headers, params, resposeText);
 						}
 					} else {
 						if (logger.isWarnEnabled()) {
 							logger.warn("POST:[{}] Fail Taking:[{}] Header:[{}] Params:[{}] Response:[{}]", url, times, headers, params, resposeText);
 						}
 					}
 				} catch (IOException e) {
 					logger.error("POST:[{}] Error Taking:[{}] Header:[{}] Params:[{}] Error Message:[{}]", url, headers, params, e);
 				}
 			}
 		});
 	}
 
 	/**
 	 * @author 
 	 * @param url
 	 * @param params
 	 * @param headers
 	 * @return {@link String}
 	 * @date 2017年7月12日
 	 * @version 1.0
 	 * @description Post同步调用 JSON
 	 */
 	public static String synchronizationForJSON(String url, Map<String, Object> params, Map<String, String> headers) {
 		HttpPost post = new HttpPost(url);
 		/* 设置链接等待时间和超时时间 */
 		post.setConfig(requestConfig);
 		/* 设置响应头 */
 		if (headers != null && headers.size() > 0) {
 			for (Entry<String, String> header : headers.entrySet()) {
 				post.setHeader(header.getKey(), header.getValue());
 			}
 		}
 		/* 设置需要提交的参数 JSON格式提交 */
 		JSONObject jsonParam = new JSONObject();
 		if (params != null && params.size() > 0) {
 			for (Entry<String, Object> entry : params.entrySet()) {
 				jsonParam.put(entry.getKey(), entry.getValue());
 			}
 		}
 		try {
 			StringEntity entity = new StringEntity(jsonParam.toString(), "UTF-8");
 			entity.setContentEncoding("UTF-8");
 			entity.setContentType("application/json");
 			post.setEntity(entity);
 			long startTime = System.currentTimeMillis();
 			HttpResponse response = httpClient.execute(post);
 			long times = System.currentTimeMillis() - startTime;
 			String resposeText = EntityUtils.toString(response.getEntity());
 			if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
 				if (logger.isInfoEnabled()) {
 					logger.info("POST:[{}] Success Taking:[{}] Header:[{}] Params:[{}] Response:[{}]", url, times, headers, params, resposeText);
 				}
 				return resposeText;
 			} else {
 				if (logger.isWarnEnabled()) {
 					logger.warn("POST:[{}] Fail Taking:[{}] Header:[{}] Params:[{}] Response:[{}]", url, times, headers, params, resposeText);
 				}
 			}
 		} catch (IOException e) {
 			logger.error("POST:[{}] Error Taking:[{}] Header:[{}] Params:[{}] Error Message:[{}]", url, headers, params, e);
 		}
 		return null;
 	}
 }

package org.utils.http;
 
 
 import java.io.IOException;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
 
 import org.apache.http.HttpResponse;
 import org.apache.http.HttpStatus;
 import org.apache.http.client.HttpClient;
 import org.apache.http.client.config.RequestConfig;
 import org.apache.http.client.methods.HttpPut;
 import org.apache.http.entity.StringEntity;
 import org.apache.http.impl.client.HttpClientBuilder;
 import org.apache.http.util.EntityUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 
 import com.alibaba.fastjson.JSONObject;
 /**
  * PUT方式提交
  * @author 
  * @Date 2017年9月6日
  * @Version 
  * @Description
  */
 public class PutClient {
 
 
 	private static final Logger logger = LoggerFactory.getLogger(PutClient.class);
 	static ExecutorService pool = Executors.newCachedThreadPool();
 	private static HttpClient httpClient = HttpClientBuilder.create().build();
 	private static RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(20000).setConnectTimeout(10000).build();// 设置请求和传输超时时间
 
 
 
 
 	
 	/**
 	 * 同步调用PUT使用JSON
 	* @author 
 	* @param url
 	* @param params
 	* @param headers
 	* @return 
 	* @date 2017年9月6日
 	* @version 1.0
 	* @description
 	 */
 	public static String synchronizationForJSON(String url, Map<String, Object> params, Map<String, String> headers) {
 		HttpPut put = new HttpPut(url);
 		/* 设置链接等待时间和超时时间 */
 		put.setConfig(requestConfig);
 		/* 设置响应头 */
 		if (headers != null && headers.size() > 0) {
 			for (Entry<String, String> header : headers.entrySet()) {
 				put.setHeader(header.getKey(), header.getValue());
 			}
 		}
 		/* 设置需要提交的参数 JSON格式提交 */
 		JSONObject jsonParam = new JSONObject();
 		if (params != null && params.size() > 0) {
 			for (Entry<String, Object> entry : params.entrySet()) {
 				jsonParam.put(entry.getKey(), entry.getValue());
 			}
 		}
 		try {
 			StringEntity entity = new StringEntity(jsonParam.toString(), "UTF-8");
 			entity.setContentEncoding("UTF-8");
 			entity.setContentType("application/json");
 			put.setEntity(entity);
 			long startTime = System.currentTimeMillis();
 			HttpResponse response = httpClient.execute(put);
 			long times = System.currentTimeMillis() - startTime;
 			String resposeText = EntityUtils.toString(response.getEntity());
 			if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
 				if (logger.isInfoEnabled()) {
 					logger.info("PUT:[{}] Success Taking:[{}] Header:[{}] Params:[{}] Response:[{}]", url, times, headers, params, resposeText);
 				}
 				return resposeText;
 			} else {
 				if (logger.isWarnEnabled()) {
 					logger.warn("PUT:[{}] Fail Taking:[{}] Header:[{}] Params:[{}] Response:[{}]", url, times, headers, params, resposeText);
 				}
 			}
 		} catch (IOException e) {
 			logger.error("PUT:[{}] Error Taking:[{}] Header:[{}] Params:[{}] Error Message:[{}]", url, headers, params, e);
 		}
 		return null;
 	}
 
 
 }

package org.utils.http;
 
 import java.io.IOException;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
 import org.apache.commons.collections.MapUtils;
 import org.apache.http.HttpResponse;
 import org.apache.http.HttpStatus;
 import org.apache.http.ParseException;
 import org.apache.http.client.HttpClient;
 import org.apache.http.client.config.RequestConfig;
 import org.apache.http.client.methods.HttpDelete;
 import org.apache.http.entity.StringEntity;
 import org.apache.http.impl.client.HttpClientBuilder;
 import org.apache.http.util.EntityUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import com.alibaba.fastjson.JSONObject;
 /**
 * delete方法调用
 * @author 
 * @Date 2017年9月6日
 * @Version 
 * @Description
 */
 public class DeleteClient {
 
 	private static final Logger logger = LoggerFactory.getLogger(DeleteClient.class);
 	static ExecutorService pool = Executors.newCachedThreadPool();
 	private static HttpClient httpClient = HttpClientBuilder.create().build();
 	private static RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(20000).setConnectTimeout(10000).build();// 设置请求和传输超时时间
 
 	/**
 	 * delete同步调用
 	* @author 
 	* @param url
 	* @param headers
 	* @return 
 	* @date 2017年9月6日
 	* @version 1.0
 	* @description
 	 */
 	public static String synchronization(String url, Map<String, String> headers) {
 		HttpDelete delete = new HttpDelete(url);
 		/* 设置链接等待时间和超时时间 */
 		delete.setConfig(requestConfig);
 		/* 设置Header */
 		if (headers != null && headers.size() > 0) {
 			for (Entry<String, String> header : headers.entrySet()) {
 				delete.setHeader(header.getKey(), header.getValue());
 			}
 		}
 		try {
 			long startTime = System.currentTimeMillis();
 			HttpResponse response = httpClient.execute(delete);
 			String resposeText = EntityUtils.toString(response.getEntity());
 			long times = System.currentTimeMillis() - startTime;
 			if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
 				if (logger.isInfoEnabled()) {
 					logger.info("DELETE:[{}] Success Taking:[{}] Header:[{}] Response:[{}]", url, times, headers, resposeText);
 				}
 				return resposeText;
 			} else {
 				if (logger.isWarnEnabled()) {
 					logger.warn("DELETE:[{}] Fail Taking:[{}] Header:[{}] Response:[{}]", url, times, headers, resposeText);
 				}
 			}
 		} catch (IOException e) {
 			logger.error("DELETE:[{}] Error Taking:[{}] Header:[{}] Error Message:[{}]", url, headers, e);
 		}
 		return null;
 	}
 	/**
 	 * delete同步调用可传参
 	 * @param url
 	 * @param prams
 	 * @param headers
 	 * @return
 	 * @throws IOException 
 	 * @throws ParseException 
 	 */
 	public static String synchronization(String url,Map<String, Object> prams, Map<String, String> headers) {
 		HttpDeteleWithBody delete = new HttpDeteleWithBody(url);
 		/* 设置链接等待时间和超时时间 */
 		delete.setConfig(requestConfig);
 		/* 设置Header */
 		if (headers != null && headers.size() > 0) {
 			for (Entry<String, String> header : headers.entrySet()) {
 				delete.setHeader(header.getKey(), header.getValue());
 			}
 		}
 		//设置提交的参数，JSON格式提交
 		JSONObject jsonParam = new JSONObject();
 		if (MapUtils.isNotEmpty(prams)) {
 			for (Entry<String, Object> entry : prams.entrySet()) {
 				jsonParam.put(entry.getKey(), entry.getValue());
 			}
 		}
 		try {
 			StringEntity entity = new StringEntity(jsonParam.toString(), "UTF-8");
 			entity.setContentEncoding("UTF-8");
 			entity.setContentType("application/json");
 			delete.setEntity(entity);
 			long startTime = System.currentTimeMillis();
 			HttpResponse response = httpClient.execute(delete);
 			String resposeText = EntityUtils.toString(response.getEntity());
 			long times = System.currentTimeMillis() - startTime;
 			if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
 				if (logger.isInfoEnabled()) {
 					logger.info("DELETE:[{}] Success Taking:[{}] Header:[{}] Response:[{}]", url, times, headers, resposeText);
 				}
 				return resposeText;
 			} else {
 				if (logger.isWarnEnabled()) {
 					logger.warn("DELETE:[{}] Fail Taking:[{}] Header:[{}] Response:[{}]", url, times, headers, resposeText);
 				}
 			}
 		} catch (IOException e) {
 			logger.error("DELETE:[{}] Error Taking:[{}] Header:[{}] Error Message:[{}]", url, headers, e);
 		}
 		return null;
 	}
 	
 }

package org.tools.spring;
 
 import java.util.Properties;
 
 import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;
 
 /**
 * @author Gong.YiYang
 * @Date 2018年7月14日
 * @Version 
 * @Description // 存取properties配置文件key-value结果
 */
 public class PropertyConfigurer extends PropertyPlaceholderConfigurer {
 	
 	private Properties props; // 存取properties配置文件key-value结果
 
 @Override
 protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)
 throws BeansException {
 super.processProperties(beanFactoryToProcess, props);
 this.props = props;
 }
 
 public String getProperty(String key){
 return this.props.getProperty(key);
 }
 
 public String getProperty(String key, String defaultValue) {
 return this.props.getProperty(key, defaultValue);
 }
 
 public Object setProperty(String key, String value) {
 return this.props.setProperty(key, value);
 }
 }

调用风格使用的restful，自动拼接路径参数