httpClient的调用

我们项目中以前使用的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 <font color="green"><b>Gong.YiYang</b></font>
	* @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 <font color="green"><b>Gong.YiYang</b></font>
	* @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 <font color="green"><b>Gong.YiYang</b></font>
	* @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 <font color="green"><b>Gong.YiYang</b></font>
	* @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 <font color="green"><b>Gong.YiYang</b></font>
	* @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 <font color="green"><b>Gong.YiYang</b></font>
	* @return 
	* @date 2017年9月5日
	* @version 1.0
	* @description
	 */
	public Map<String, String> getPermissionTokenString() {
		这个方法是生成校验的token
		 return headers;
	}
	/**
	 * 拼接URL
	* @author <font color="green"><b>Gong.YiYang</b></font>
	* @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 <font color="green"><b>Gong.YiYang</b></font>
	 * @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 <font color="green"><b>Gong.YiYang</b></font>
	 * @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 <font color="green"><b></b></font>
 * @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 <font color="red"><b></b></font>
	 * @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 <font color="red"><b></b></font>
	 * @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 <font color="green"><b></b></font>
 * @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 <font color="red"><b></b></font>
	 * @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 <font color="red"><b></b></font>
	 * @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 <font color="red"><b></b></font>
	 * @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 <font color="red"><b></b></font>
	 * @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 <font color="red"><b></b></font>
 * @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 <font color="green"><b></b></font>
	* @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 <font color="red"><b></b></font>
 * @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 <font color="green"><b></b></font>
	* @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 <font color="red"><b>Gong.YiYang</b></font>
 * @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，自动拼接路径参数