通用模块封装

package gHttpClientFactory;

import java.io.IOException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.List;

import javax.net.ssl.SSLContext;

import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContextBuilder;
import org.apache.http.conn.ssl.TrustStrategy;
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.BasicHeader;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

public class gHttpsUtils
{
	private static JSONObject stringConvertJsonObject(String str)
	{
		JSONObject json = JSON.parseObject(str);
		return json;
	}

	public static JSONObject getHttpsGetJsonObject(String httpsUrl)
	{
		JSONObject json = null;
		try {
			CloseableHttpClient httpclient = HttpClients.createDefault();
			HttpGet httpGet = new HttpGet(httpsUrl);
			CloseableHttpResponse response = httpclient.execute(httpGet);
			HttpEntity entity = response.getEntity();
			String str = EntityUtils.toString(entity, "utf-8");
			json = stringConvertJsonObject(str);
			EntityUtils.consume(entity);
			response.close();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return json;
	}
	public static String getHttpsGetStrings(String httpsUrl)
	{
		String str = null;
		try {
			CloseableHttpClient httpclient = HttpClients.createDefault();
			HttpGet httpGet = new HttpGet(httpsUrl);
			CloseableHttpResponse response = httpclient.execute(httpGet);
			HttpEntity entity = response.getEntity();
			str = EntityUtils.toString(entity, "utf-8");
			EntityUtils.consume(entity);
			response.close();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return str;
	}

	public static String getHttpPostNvp(String url, List Lnvp)
	{
		String str = null;
		try {
			CloseableHttpClient httpClient = HttpClients.createDefault();
			HttpPost httpPost = new HttpPost(url);
			httpPost.setEntity(new UrlEncodedFormEntity(Lnvp));
			CloseableHttpResponse httpResponse=httpClient.execute(httpPost);
			HttpEntity entity=httpResponse.getEntity();
			str = EntityUtils.toString(entity, "utf-8");
			EntityUtils.consume(entity);
			httpResponse.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return str;
	}
	public static String getHttpsGetString(String httpsUrl)
	{
		String str = null;
		try {
			SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy()
			{
				// 锟斤拷锟斤拷锟斤拷锟斤拷
				public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException
				{
					return true;
				}
			}).build();
			SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext);
			CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
			HttpGet httpGet = new HttpGet(httpsUrl);
			CloseableHttpResponse response = httpclient.execute(httpGet);
			HttpEntity entity = response.getEntity();
			str = EntityUtils.toString(entity, "utf-8");
			EntityUtils.consume(entity);
			response.close();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return str;
	}
	public static JSONObject getHttpPostJson(JSONObject json, String url)
	{
		JSONObject T_Json = null;
		try {
			CloseableHttpClient httpclient = HttpClients.createDefault();
			HttpPost httpPost = new HttpPost(url);
			StringEntity se = new StringEntity(json.toString(), "utf-8");
			se.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
			se.setContentType(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
			httpPost.setEntity(se);
			CloseableHttpResponse response = httpclient.execute(httpPost);
			response.setHeader("content-type", "application/json");
			HttpEntity entity = response.getEntity();
			String str = EntityUtils.toString(entity, "utf-8");
			T_Json = stringConvertJsonObject(str);
			EntityUtils.consume(entity);
			response.close();
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		return T_Json;
	}

	public static JSONObject getHttpsPostJson(JSONObject json, String url)
	{
		JSONObject T_Json = null;
		try {
			SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy()
			{
				// 锟斤拷锟斤拷锟斤拷锟斤拷
				public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException
				{
					return true;
				}
			}).build();
			SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext);
			CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
			HttpPost httpPost = new HttpPost(url);
			StringEntity se = new StringEntity(json.toString(), "utf-8");
			se.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
			se.setContentType(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
			httpPost.setEntity(se);
			CloseableHttpResponse response = httpclient.execute(httpPost);
			response.setHeader("content-type", "application/json");
			HttpEntity entity = response.getEntity();
			String str = EntityUtils.toString(entity, "utf-8");
			System.out.println(str);
			T_Json = stringConvertJsonObject(str);
			EntityUtils.consume(entity);
			response.close();
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		return T_Json;
	}
	
	public static String getHttpsPostXml(String strMsg, String url)
	{
		String str=null;
		try {
			SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy()
			{
				// 锟斤拷锟斤拷锟斤拷锟斤拷
				public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException
				{
					return true;
				}
			}).build();
			SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext);
			CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
			HttpPost httpPost = new HttpPost(url);
			StringEntity se = new StringEntity(strMsg.toString(), "utf-8");
			se.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
			se.setContentType(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
			httpPost.setEntity(se);
			CloseableHttpResponse response = httpclient.execute(httpPost);
			response.setHeader("content-type", "application/json");
			HttpEntity entity = response.getEntity();
			str = EntityUtils.toString(entity, "utf-8");
			EntityUtils.consume(entity);
			response.close();
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		return str;
	}
}

---------------------------------------------------------------------------------------------------------------------------------
package gDataBaseFactory;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.sql.DataSource;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.apache.commons.lang3.StringUtils;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;

import g.LogsFactory.gLogUtils;

public class gDbUtils {
	private static DataSource ds = null;

	private static String driverClassName = "com.mysql.jdbc.Driver";
	private static String url = "jdbc:mysql://localhost:3306/mc_wx?autoReconnect=true&useUnicode=true&characterEncoding=utf-8";
	private static String username = "root";
	private static String password = "mc2016";
	private static String initialSize = "5";
	private static String maxActive = "10";
	private static String minIdle = "1";
	private static String maxWait = "60000";
	private static String removeAbandoned = "true";
	private static String removeAbandonedTimeout = "180";
	private static String timeBetweenEvictionRunsMillis = "60000";
	private static String minEvictableIdleTimeMillis = "300000";
	private static String validationQuery = "SELECT 1 FROM DUAL";
	private static String testWhileIdle = "true";
	private static String testOnBorrow = "false";
	private static String testOnReturn = "false";
	private static String poolPreparedStatements = "true";
	private static String maxPoolPreparedStatementPerConnectionSize = "50";
	private static String filters = "stat";

	static {
		try {
			// InputStream in =
			// DataBaseFactory.class.getClassLoader().getResourceAsStream("ds.properties");
			// Properties props = new Properties();
			// props.load(in);
			Map druidMap = new HashMap();
			druidMap.put(DruidDataSourceFactory.PROP_DRIVERCLASSNAME, driverClassName);
			druidMap.put(DruidDataSourceFactory.PROP_URL, url);
			druidMap.put(DruidDataSourceFactory.PROP_USERNAME, username);
			druidMap.put(DruidDataSourceFactory.PROP_PASSWORD, password);
			druidMap.put(DruidDataSourceFactory.PROP_INITIALSIZE, initialSize);
			druidMap.put(DruidDataSourceFactory.PROP_MAXACTIVE, maxActive);
			druidMap.put(DruidDataSourceFactory.PROP_MINIDLE, minIdle);
			druidMap.put(DruidDataSourceFactory.PROP_MAXWAIT, maxWait);
			druidMap.put(DruidDataSourceFactory.PROP_REMOVEABANDONED, removeAbandoned);
			druidMap.put(DruidDataSourceFactory.PROP_REMOVEABANDONEDTIMEOUT, removeAbandonedTimeout);
			druidMap.put(DruidDataSourceFactory.PROP_TIMEBETWEENEVICTIONRUNSMILLIS, timeBetweenEvictionRunsMillis);
			druidMap.put(DruidDataSourceFactory.PROP_MINEVICTABLEIDLETIMEMILLIS, minEvictableIdleTimeMillis);
			druidMap.put(DruidDataSourceFactory.PROP_VALIDATIONQUERY, validationQuery);
			druidMap.put(DruidDataSourceFactory.PROP_TESTWHILEIDLE, testWhileIdle);
			druidMap.put(DruidDataSourceFactory.PROP_TESTONBORROW, testOnBorrow);
			druidMap.put(DruidDataSourceFactory.PROP_TESTONRETURN, testOnReturn);
			druidMap.put(DruidDataSourceFactory.PROP_POOLPREPAREDSTATEMENTS, poolPreparedStatements);
			druidMap.put(DruidDataSourceFactory.PROP_MAXOPENPREPAREDSTATEMENTS,
					maxPoolPreparedStatementPerConnectionSize);
			druidMap.put(DruidDataSourceFactory.PROP_FILTERS, filters);

			ds = DruidDataSourceFactory.createDataSource(druidMap);
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}

	public static void main(String[] args) throws Exception {
		Object[] parm = null;
		if (parm == null)
			System.out.println("111111111111111");
		String sql = "select * from t_oo_event ";
		JSONArray jsons = execFindJsons(sql, null);
		System.out.println(jsons);

	}

	private static Connection openConnection() throws SQLException {
		return ds.getConnection();
	}

	/** 
	 * 此方法禁止使用！！！！
	 **/
	public static List> execFinds(String sql, Object[] parm) throws SQLException {
		Connection con = openConnection();
		QueryRunner runner = new QueryRunner();
		List> listmap = runner.query(con, sql, new MapListHandler(), parm);
		if (con != null)
			con.close();

		JSONObject json = new JSONObject();
		json.put("type", "SqlCommand");
		json.put("method", "gFactory.gDataBaseFactory.execFinds");
		json.put("sql", sql);
		if (parm != null)
			json.put("parm", JSON.parse(Arrays.asList(parm).toString()));
		json.put("result", listmap.toString());
		gLogUtils.AppendLog(json, "sql.log");

		return listmap;
	}

	public static JSONArray execFindJsons(String sql, Object[] parm) {
		JSONArray jsons = null;
		try {
			Connection con = openConnection();
			QueryRunner runner = new QueryRunner();
			List> listmap = runner.query(con, sql, new MapListHandler(), parm);
			jsons = JSON.parseArray(JSON.toJSONString(listmap, SerializerFeature.WriteDateUseDateFormat));
			if (con != null)
				con.close();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		JSONObject json = new JSONObject();
		json.put("type", "SqlCommand");
		json.put("method", "gFactory.gDataBaseFactory.execFindJsons");
		json.put("sql", sql);
		if (parm != null)
			json.put("parm", Arrays.asList(parm).toString());
		json.put("result", jsons.toJSONString());
		gLogUtils.AppendLog(json, "sql.log");

		return jsons;
	}

	public static int ExecuteUpdate(String sql, Object[] parm) throws SQLException {
		Connection con = openConnection();
		QueryRunner runner = new QueryRunner();
		int i = runner.update(con, sql, parm);
		if (con != null)
			con.close();

		JSONObject json = new JSONObject();
		json.put("type", "SqlCommand");
		json.put("method", "gFactory.gDataBaseFactory.ExecuteUpdate");
		json.put("sql", sql);
		if (parm != null)
			json.put("parm", Arrays.asList(parm).toString());
		json.put("result", i);
		gLogUtils.AppendLog(json, "sql.log");

		return i;
	}

	public static int ExecuteCheckIsNull(String sql, Object[] parm) throws SQLException {
		Connection con = openConnection();
		QueryRunner runner = new QueryRunner();
		int i = (int) (long) runner.query(con, sql, new ScalarHandler