Java常用公共工具记录

其他 2018-07-05 07:00:14 阅读次数: 0

转载于：https://blog.csdn.net/Evankaka/article/details/72614601

1、日期处理工具

  1. import java.text.SimpleDateFormat;
  2. import java.util.Calendar;
  3. import java.util.Date;
  5. /**
  6. * 日期常用格式转换
  7. */
  8. public class DateTimeUtil {
  10. static {
  11. ymdhmsFormat = new SimpleDateFormat( "yyyyMMddHHmmss");
  12. ymdhmsFormat2 = new SimpleDateFormat( "yyyyMMdd HH:mm:ss");
  13. ymdFormat = new SimpleDateFormat( "yyyyMMdd");
  14. ymdFormat2 = new SimpleDateFormat( "yyyy-MM-dd");
  15. hmsFormat = new SimpleDateFormat( "HHmmss");
  16. ymFormat = new SimpleDateFormat( "yyyyMM");
  17. c = Calendar.getInstance();
  18. }
  20. private static SimpleDateFormat ymdhmsFormat;
  22. private static SimpleDateFormat ymdhmsFormat2;
  24. private static SimpleDateFormat ymdFormat;
  26. private static SimpleDateFormat ymdFormat2;
  28. private static SimpleDateFormat hmsFormat;
  30. private static SimpleDateFormat ymFormat; //年月
  32. private static Calendar c;
  34. public static Date dateOnly(Date date) {
  35. return yyyyMMddToDate(parseToyyyyMMdd(date));
  36. }
  38. /**
  39. * 转换为 yyyyMMddHHmmss格式
  40. */
  41. public static String parseToyyyyMMddHHmmss(Date date) {
  43. if (date == null) {
  44. return null;
  45. }
  46. return ymdhmsFormat.format(date);
  48. }
  50. /**
  51. * 转换为 yyyyMMdd HH:mm:ss格式
  52. */
  53. public static String parseToyyyyMMddHHmmss2(Date date) {
  55. if (date == null) {
  56. return null;
  57. }
  58. return ymdhmsFormat2.format(date);
  60. }
  62. /**
  63. * 转换为HHmmss格式
  64. */
  65. public static String parseToHHmmss(Date date) {
  66. if (date == null) {
  67. return null;
  68. }
  69. return hmsFormat.format(date);
  70. }
  72. /**
  73. * 转换为yyyyMMdd格式
  74. */
  75. public static String parseToyyyyMMdd(Date date) {
  76. if (date == null) {
  77. return null;
  78. }
  80. return ymdFormat.format(date);
  81. }
  83. /**
  84. * 转换为yyyyMM格式
  85. */
  86. public static int parseToyyyyMM(Date date) {
  87. if (date == null) {
  88. return 0;
  89. }
  91. return Integer.valueOf(ymFormat.format(date));
  92. }
  94. public static Date yyyyMMddHHmmssToDate(String yyyyMMddHHmmss) {
  95. try {
  97. return ymdhmsFormat.parse(yyyyMMddHHmmss);
  98. }
  99. catch (Exception e) {
  100. return null;
  101. }
  103. }
  105. public static Date yyyyMMddToDate(String yyyyMMdd) {
  106. try {
  108. return ymdFormat.parse(yyyyMMdd);
  109. }
  110. catch (Exception e) {
  111. return null;
  112. }
  114. }
  116. public static Date yyyyMMToDate(String yyyyMM) {
  117. try {
  119. return ymFormat.parse(yyyyMM);
  120. }
  121. catch (Exception e) {
  122. return null;
  123. }
  125. }
  127. /**
  128. * yyyy-MM-dd转换成date
  129. * @author linbingwen
  130. * @since 2016年4月14日
  131. * @param yyyyMMdd2
  132. * @return
  133. */
  134. public static Date yyyyMMddToDate2(String yyyyMMdd2) {
  135. try {
  137. return ymdFormat2.parse(yyyyMMdd2);
  138. }
  139. catch (Exception e) {
  140. return null;
  141. }
  143. }
  145. public static Date HHmmssToDate(String HHmmss) {
  146. try {
  148. return hmsFormat.parse(HHmmss);
  149. }
  150. catch (Exception e) {
  151. return null;
  152. }
  154. }
  156. public static Date getDate(Date srcDate, Integer daysToAdd) {
  158. c.setTime(srcDate);
  159. c.add(Calendar.DATE, daysToAdd); // number of days to add
  161. return c.getTime();
  162. }
  164. public static Date yyyyMMddHHmmssToDate2(String yyyyMMddHHmmss) {
  165. try {
  166. return ymdhmsFormat2.parse(yyyyMMddHHmmss);
  167. }
  168. catch (Exception e) {
  169. return null;
  170. }
  172. }
  174. public static final int daysBetween(Date early, Date late) {
  176. java.util.Calendar calst = java.util.Calendar.getInstance();
  177. java.util.Calendar caled = java.util.Calendar.getInstance();
  178. calst.setTime(early);
  179. caled.setTime(late);
  180. // 设置时间为0时
  181. calst.set(java.util.Calendar.HOUR_OF_DAY, 0);
  182. calst.set(java.util.Calendar.MINUTE, 0);
  183. calst.set(java.util.Calendar.SECOND, 0);
  184. caled.set(java.util.Calendar.HOUR_OF_DAY, 0);
  185. caled.set(java.util.Calendar.MINUTE, 0);
  186. caled.set(java.util.Calendar.SECOND, 0);
  187. // 得到两个日期相差的天数
  188. int days = (( int) (caled.getTime().getTime() / 1000) - ( int) (calst.getTime().getTime() / 1000)) / 3600 / 24;
  190. return days;
  191. }
  193. public static Date getNextDayOfWeek(Date date, int dayOfWeek) {
  194. if (dayOfWeek == 0) {
  195. dayOfWeek = 7;
  196. }
  197. if (dayOfWeek > 7 || dayOfWeek < 1) {
  198. throw new RuntimeException( "星期：" + dayOfWeek + "不存在");
  199. }
  200. Calendar cal = Calendar.getInstance();
  201. cal.setTime(date);
  202. while ( true) {
  203. int day = cal.get(Calendar.DAY_OF_WEEK);
  204. if (preWeekDay(day) == dayOfWeek) {
  205. return cal.getTime();
  206. }
  207. cal.add(Calendar.DATE, 1);
  208. }
  209. }
  211. public static Date getNextMonthDate(Date date, int nextMonthDate) {
  212. Calendar cal = Calendar.getInstance();
  213. cal.setTime(date);
  215. int day = cal.get(Calendar.DATE);
  216. if (day <= nextMonthDate) {
  217. cal.set(Calendar.DATE, nextMonthDate);
  218. }
  219. else {
  220. cal.set(Calendar.DATE, 1);
  221. cal.add(Calendar.MONTH, 1);
  222. cal.set(Calendar.DATE, nextMonthDate);
  223. }
  224. return cal.getTime();
  225. }
  227. public static int nextWeekDay(int day) {
  228. if (day == 7) {
  229. return 1;
  230. }
  231. else {
  232. return day++;
  233. }
  234. }
  236. public static int preWeekDay(int day) {
  237. if (day == 1) {
  238. return 7;
  239. }
  240. else {
  241. return day - 1;
  242. }
  243. }
  245. /**
  246. * 计算两个日期相差的天数
  247. * @param beginDate 【YYYYMMDD】
  248. * @param endDate 【YYYYMMDD】
  249. * @return Integer
  250. * @author linbingwen
  251. * @since 2015年7月21日
  252. */
  253. public static long diffDate(Date beginDate,Date endDate){
  254. Calendar theCa1= Calendar.getInstance();
  255. Calendar theCa2= Calendar.getInstance();
  256. theCa1.setTime(beginDate);
  257. theCa2.setTime(endDate);
  258. long between_days=(theCa2.getTimeInMillis()-theCa1.getTimeInMillis())/( 1000* 3600* 24);
  259. return between_days;
  260. }
  262. /**
  263. * 分钟差
  264. * @Title: diffMinute 
  265. * @Description: TODO
  266. * @author : liuqiuyun
  267. * @param @param beginDate
  268. * @param @param endDate
  269. * @param @return    设定文件 
  270. * @return long    返回类型 
  271. * @throws 
  272. */
  273. public static long diffMinute(Date beginDate,Date endDate){
  274. Calendar theCa1= Calendar.getInstance();
  275. Calendar theCa2= Calendar.getInstance();
  276. theCa1.setTime(beginDate);
  277. theCa2.setTime(endDate);
  278. long between_minutes=(theCa2.getTimeInMillis()-theCa1.getTimeInMillis())/( 1000* 60);
  279. return between_minutes;
  280. }
  282. /**
  283. * 获取月份差第一天
  284. * @Title: getMonthFirstDate 
  285. * @Description: TODO
  286. * @author : liuqiuyun
  287. * @param @param date
  288. * @param @param monthToAdd
  289. * @param @param minOrMax 月初还是月末
  290. * @param @return    设定文件 
  291. * @return Date    返回类型 
  292. * @throws 
  293. */
  294. public static Date getMonthFirstDate(Date date,int monthToAdd, String minOrMax) {
  295. Calendar calendar = Calendar.getInstance();
  296. calendar.setTime(date);
  297. calendar.add(Calendar.MONTH, monthToAdd);
  298. if(minOrMax.equals( "min")){
  299. calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMinimum(Calendar.DAY_OF_MONTH));
  300. } else if(minOrMax.equals( "max")){
  301. calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
  302. }
  304. return calendar.getTime();
  305. }
  307. public static long getLastMonth(Date date) {
  308. Date lastDate = getMonthFirstDate(date,- 1, "min");
  309. long lastMonth = parseToyyyyMM(lastDate);
  311. return lastMonth;
  312. }
  316. public static void main(String[] args) throws InterruptedException {
  317. // Calendar cal = Calendar.getInstance();
  318. // System.out.println(" cal.get(Calendar.DAY_OF_WEEK);:" + cal.get(Calendar.DAY_OF_WEEK));
  319. // System.out.println(" cal.get(Calendar.DAY_OF_WEEK_IN_MONTH);:" + cal.get(Calendar.DAY_OF_WEEK_IN_MONTH));
  320. //
  321. // System.out.println(getNextDayOfWeek(cal.getTime(), 0));
  322. // System.out.println(getNextDayOfWeek(cal.getTime(), 7));
  323. // System.out.println(getNextDayOfWeek(cal.getTime(), 1));
  324. // System.out.println(getNextDayOfWeek(cal.getTime(), 2));
  325. //
  326. // System.out.println(getNextMonthDate(cal.getTime(), 0));
  327. // System.out.println(parseToyyyyMMdd(getNextMonthDate(cal.getTime(), 15)));
  329. System.out.println(parseToyyyyMMdd(getMonthFirstDate(yyyyMMddToDate( "20160618"),- 1, "max")));
  331. // System.out.println(yyyyMMddToDate2("2012-09-01"));
  332. //
  333. // Date start = new Date();
  334. // System.out.println(start);
  335. // Thread.sleep(60*1000*5+1000);
  336. // Date end = new Date();
  337. // System.out.println(end);
  338. // System.out.println(diffMinute(start,end));
  339. }
  340. }
2、http请求处理工具

  1. import java.io.ByteArrayInputStream;
  2. import sun.misc.BASE64Decoder;
  3. import sun.misc.BASE64Encoder;
  5. import java.io.File;
  6. import java.io.FileOutputStream;
  7. import java.io.IOException;
  8. import java.io.InputStream;
  9. import java.io.OutputStream;
  10. import java.net.HttpURLConnection;
  11. import java.net.Proxy;
  12. import java.net.URL;
  13. import java.security.SecureRandom;
  14. import java.security.cert.CertificateException;
  15. import java.security.cert.X509Certificate;
  16. import java.util.Map;
  18. import javax.net.ssl.HostnameVerifier;
  19. import javax.net.ssl.HttpsURLConnection;
  20. import javax.net.ssl.KeyManager;
  21. import javax.net.ssl.SSLContext;
  22. import javax.net.ssl.SSLSession;
  23. import javax.net.ssl.TrustManager;
  24. import javax.net.ssl.X509TrustManager;
  26. import org.slf4j.Logger;
  27. import org.slf4j.LoggerFactory;
  29. //import com.lz.common.util.http.FileItem;
  31. public class HttpClientUtil {
  33. private static Logger logger = LoggerFactory
  34. .getLogger(HttpClientUtil.class);
  36. public static void main(String[] args) {
  37. HttpURLConnection conn = null;
  38. InputStream ins = null;
  39. try {
  40. // String boundary = System.currentTimeMillis() + "";
  41. // String ctype = "multipart/form-data;boundary=" + boundary;
  42. // conn = HttpClientUtil
  43. // .getConnection(
  44. // null,
  45. // new URL(
  46. // "http://10.75.201.68:8888/cfile/file/image?imageId=group2/M00/05/64/CkvJo1cQVPyATVbKACIyO0-AKoo7735712"),
  47. // "GET", ctype, null);
  48. // conn.setConnectTimeout(1000);
  49. // conn.setReadTimeout(5000);
  50. byte[] bytes = downLoadFile( "http://10.75.201.68:8888/cfile/file/image?imageId=group2/M00/05/64/CkvJo1cQVPyATVbKACIyO0-AKoo7735712");
  51. InputStream inputStream = new ByteArrayInputStream(bytes);
  52. // ins = conn.getInputStream();
  53. File file = new File( "D:/6.docx");
  54. FileOutputStream fot = new FileOutputStream(file);
  55. com.slob.util.io.IOUtil.inputStreamToOutputStream(inputStream, fot);
  56. } catch (Exception e) {
  58. }
  59. }
  61. public static byte[] downLoadFile(String url) throws IOException {
  62. HttpURLConnection conn = null;
  63. InputStream ins = null;
  64. byte[] bytes = null;
  65. try {
  66. String boundary = System.currentTimeMillis() + "";
  67. String ctype = "multipart/form-data;boundary=" + boundary;
  68. conn = HttpClientUtil.getConnection( null, new URL(url), "GET", ctype, null);
  69. conn.setConnectTimeout( 1000);
  70. conn.setReadTimeout( 5000);
  71. ins = conn.getInputStream();
  72. bytes = readBytes(ins);
  73. return bytes;
  74. } catch (Exception e) {
  75. throw new RuntimeException(e);
  76. } finally {
  77. if (ins != null) {
  78. ins.close();
  79. }
  80. if (conn != null) {
  81. conn.disconnect();
  82. }
  83. }
  84. }
  86. public static String uploadFile(String url, String fieldName,
  87. String fileName, InputStream ips, ResponseProcess respProcess)
  88. throws IOException {
  90. HttpURLConnection conn = null;
  91. OutputStream out = null;
  92. try {
  93. String boundary = System.currentTimeMillis() + "";
  94. String ctype = "multipart/form-data;boundary=" + boundary;
  95. conn = HttpClientUtil.getConnection( null, new URL(url), "POST",
  96. ctype, null);
  97. conn.setConnectTimeout( 1000);
  98. conn.setReadTimeout( 5000);
  99. out = conn.getOutputStream();
  101. byte[] entryBoundaryBytes = ( "\r\n--" + boundary + "\r\n")
  102. .getBytes( "UTF-8");
  103. out.write(entryBoundaryBytes);
  105. byte[] data = new byte[ 1024 * 1024];
  106. int size = ips.read(data);
  107. byte[] fileBytes = getFileEntry(fieldName, fileName,
  108. getMimeType(data), "UTF-8");
  109. out.write(fileBytes);
  111. while (size > 0) {
  112. out.write(data, 0, size);
  113. size = ips.read(data);
  114. }
  115. byte[] endBoundaryBytes = ( "\r\n--" + boundary + "--\r\n")
  116. .getBytes( "UTF-8");
  117. out.write(endBoundaryBytes);
  119. return respProcess.processResponse(conn);
  120. } catch (Exception e) {
  121. throw new RuntimeException(e);
  122. } finally {
  123. if (out != null) {
  124. out.close();
  125. }
  126. if (conn != null) {
  127. conn.disconnect();
  128. }
  129. }
  130. }
  132. // public static String doPost(Proxy proxy, String url, String requestType,
  133. // Map<String, String> params,
  134. // Map<String, FileItem> fileParams, String charset, int connectTimeout, int
  135. // readTimeout,
  136. // Map<String, String> headerMap, ResponseProcess respProcess) throws
  137. // IOException {
  138. //
  139. // String boundary = System.currentTimeMillis() + "";
  140. // HttpURLConnection conn = null;
  141. // OutputStream out = null;
  142. // String rsp = null;
  143. // try {
  144. // try {
  145. // String ctype = "multipart/form-data;boundary=" + boundary;
  146. // conn = getConnection(proxy, new URL(url), requestType, ctype, headerMap);
  147. // conn.setConnectTimeout(connectTimeout);
  148. // conn.setReadTimeout(readTimeout);
  149. // }
  150. // catch (IOException e) {
  151. // logger.error(url, e);
  152. // throw e;
  153. // }
  154. //
  155. // try {
  156. // out = conn.getOutputStream();
  157. //
  158. // byte[] entryBoundaryBytes = ("\r\n--" + boundary +
  159. // "\r\n").getBytes(charset);
  160. //
  161. // if (params != null) {
  162. // // 文本
  163. // Set<Entry<String, String>> textEntrySet = params.entrySet();
  164. // for (Entry<String, String> textEntry : textEntrySet) {
  165. // byte[] textBytes = getTextEntry(textEntry.getKey(), textEntry.getValue(),
  166. // charset);
  167. // out.write(entryBoundaryBytes);
  168. // out.write(textBytes);
  169. // }
  170. // }
  171. //
  172. // // 文件
  173. // if (fileParams != null) {
  174. // Set<Entry<String, FileItem>> fileEntrySet = fileParams.entrySet();
  175. // for (Entry<String, FileItem> fileEntry : fileEntrySet) {
  176. // FileItem fileItem = fileEntry.getValue();
  177. // if (fileItem.getContent() == null) {
  178. // continue;
  179. // }
  180. // byte[] fileBytes = getFileEntry(fileEntry.getKey(),
  181. // fileItem.getFileName(),
  182. // fileItem.getMimeType(), charset);
  183. // out.write(entryBoundaryBytes);
  184. // out.write(fileBytes);
  185. // out.write(fileItem.getContent());
  186. // }
  187. // }
  188. //
  189. // byte[] endBoundaryBytes = ("\r\n--" + boundary +
  190. // "--\r\n").getBytes(charset);
  191. // out.write(endBoundaryBytes);
  192. // rsp = respProcess.processResponse(conn);
  193. // }
  194. // catch (IOException e) {
  195. // logger.error(url, e);
  196. // throw e;
  197. // }
  198. // }
  199. // finally {
  200. // if (out != null) {
  201. // out.close();
  202. // }
  203. // if (conn != null) {
  204. // conn.disconnect();
  205. // }
  206. // }
  207. //
  208. // return rsp;
  209. // }
  211. public static String doGet(Proxy proxy, String url, String charset,
  212. ResponseProcess respProcess) throws IOException {
  214. if (url == null) {
  215. return "";
  216. }
  217. HttpURLConnection conn = null;
  218. String rsp = null;
  219. try {
  220. String ctype = "application/x-www-form-urlencoded;charset="
  221. + charset;
  222. conn = getConnection(proxy, new URL(url), "GET", ctype, null);
  223. rsp = respProcess.processResponse(conn);
  224. } catch (IOException e) {
  225. logger.error(url, e);
  226. throw e;
  227. } finally {
  228. if (conn != null) {
  229. conn.disconnect();
  230. }
  231. }
  233. return rsp;
  234. }
  236. private static class DefaultTrustManager implements X509TrustManager {
  238. public X509Certificate[] getAcceptedIssuers() {
  239. return null;
  240. }
  242. public void checkClientTrusted(X509Certificate[] chain, String authType)
  243. throws CertificateException {
  244. }
  246. public void checkServerTrusted(X509Certificate[] chain, String authType)
  247. throws CertificateException {
  248. }
  249. }
  251. public static HttpURLConnection getConnection(Proxy proxy, URL url,
  252. String method, String ctype, Map<String, String> headerMap)
  253. throws IOException {
  254. HttpURLConnection conn = null;
  255. if ( "https".equals(url.getProtocol())) {
  256. SSLContext ctx = null;
  257. try {
  258. ctx = SSLContext.getInstance( "TLS");
  259. ctx.init( new KeyManager[ 0],
  260. new TrustManager[] { new DefaultTrustManager() },
  261. new SecureRandom());
  262. } catch (Exception e) {
  263. throw new IOException(e);
  264. }
  265. HttpsURLConnection connHttps;
  266. if (proxy != null) {
  267. connHttps = (HttpsURLConnection) url.openConnection(proxy);
  268. } else {
  269. connHttps = (HttpsURLConnection) url.openConnection();
  270. }
  271. connHttps.setSSLSocketFactory(ctx.getSocketFactory());
  272. connHttps.setHostnameVerifier( new HostnameVerifier() {
  274. public boolean verify(String hostname, SSLSession session) {
  275. return true;
  276. }
  277. });
  278. conn = connHttps;
  279. } else {
  280. if (proxy != null) {
  281. conn = (HttpURLConnection) url.openConnection(proxy);
  282. } else {
  283. conn = (HttpURLConnection) url.openConnection();
  284. }
  285. }
  287. conn.setRequestMethod(method);
  288. conn.setDoInput( true);
  289. conn.setDoOutput( true);
  290. conn.setRequestProperty( "Accept",
  291. "text/xml,text/javascript,text/html,application/json");
  292. conn.setRequestProperty( "User-Agent", "java");
  293. conn.setRequestProperty( "Content-Type", ctype);
  294. if (headerMap != null) {
  295. for (Map.Entry<String, String> entry : headerMap.entrySet()) {
  296. conn.setRequestProperty(entry.getKey(), entry.getValue());
  297. }
  298. }
  299. return conn;
  300. }
  302. private static byte[] getTextEntry(String fieldName, String fieldValue,
  303. String charset) throws IOException {
  304. StringBuilder entry = new StringBuilder();
  305. entry.append( "Content-Disposition:form-data;name=\"");
  306. entry.append(fieldName);
  307. entry.append( "\"\r\nContent-Type:text/plain\r\n\r\n");
  308. entry.append(fieldValue);
  309. return entry.toString().getBytes(charset);
  310. }
  312. private static byte[] getFileEntry(String fieldName, String fileName,
  313. String mimeType, String charset) throws IOException {
  314. StringBuilder entry = new StringBuilder();
  315. entry.append( "Content-Disposition:form-data;name=\"");
  316. entry.append(fieldName);
  317. entry.append( "\";filename=\"");
  318. entry.append(fileName);
  319. entry.append( "\"\r\nContent-Type:");
  320. entry.append(mimeType);
  321. entry.append( "\r\n\r\n");
  322. return entry.toString().getBytes(charset);
  323. }
  325. public static interface ResponseProcess {
  327. String processResponse(HttpURLConnection conn);
  328. };
  330. public static String getMimeType(byte[] bytes) {
  331. String suffix = getFileSuffix(bytes);
  332. String mimeType;
  334. if ( "JPG".equals(suffix)) {
  335. mimeType = "image/jpeg";
  336. } else if ( "GIF".equals(suffix)) {
  337. mimeType = "image/gif";
  338. } else if ( "PNG".equals(suffix)) {
  339. mimeType = "image/png";
  340. } else if ( "BMP".equals(suffix)) {
  341. mimeType = "image/bmp";
  342. } else {
  343. mimeType = "application/octet-stream";
  344. }
  346. return mimeType;
  347. }
  349. /**
  350. * 获取文件的真实后缀名。目前只支持JPG, GIF, PNG, BMP四种图片文件。
  351. *
  352. * @param bytes
  353. * 文件字节流
  354. * @return JPG, GIF, PNG or null
  355. */
  356. public static String getFileSuffix(byte[] bytes) {
  357. if (bytes == null || bytes.length < 10) {
  358. return null;
  359. }
  361. if (bytes[ 0] == 'G' && bytes[ 1] == 'I' && bytes[ 2] == 'F') {
  362. return "GIF";
  363. } else if (bytes[ 1] == 'P' && bytes[ 2] == 'N' && bytes[ 3] == 'G') {
  364. return "PNG";
  365. } else if (bytes[ 6] == 'J' && bytes[ 7] == 'F' && bytes[ 8] == 'I'
  366. && bytes[ 9] == 'F') {
  367. return "JPG";
  368. } else if (bytes[ 0] == 'B' && bytes[ 1] == 'M') {
  369. return "BMP";
  370. } else {
  371. return null;
  372. }
  373. }
  375. public static byte[] readBytes(InputStream in) throws IOException {
  376. byte[] temp = new byte[in.available()];
  377. byte[] result = new byte[ 0];
  378. int size = 0;
  379. while ((size = in.read(temp)) != - 1) {
  380. byte[] readBytes = new byte[size];
  381. System.arraycopy(temp, 0, readBytes, 0, size);
  382. result = mergeArray(result,readBytes);
  383. }
  384. return result;
  385. }
  387. public static byte[] mergeArray( byte[]... a) {
  388. // 合并完之后数组的总长度
  389. int index = 0;
  390. int sum = 0;
  391. for ( int i = 0; i < a.length; i++) {
  392. sum = sum + a[i].length;
  393. }
  394. byte[] result = new byte[sum];
  395. for ( int i = 0; i < a.length; i++) {
  396. int lengthOne = a[i].length;
  397. if(lengthOne== 0){
  398. continue;
  399. }
  400. // 拷贝数组
  401. System.arraycopy(a[i], 0, result, index, lengthOne);
  402. index = index + lengthOne;
  403. }
  404. return result;
  405. }
  408. }

3、图像处理工具

  1. import java.awt.image.BufferedImage;
  2. import java.io.ByteArrayInputStream;
  3. import java.io.ByteArrayOutputStream;
  4. import java.io.FileInputStream;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  7. import java.io.InputStream;
  8. import java.io.OutputStream;
  9. import java.net.MalformedURLException;
  10. import java.net.URL;
  12. import javax.imageio.ImageIO;
  14. import sun.misc.BASE64Decoder;
  15. import sun.misc.BASE64Encoder;
  17. /**
  18. *
  19. * 功能概要：图片处理工具类
  20. *
  21. * @author linbingwen
  22. * @since 2016年3月30日
  23. */
  24. public class ImageUtil {
  26. /**
  27. * 将图片文件转化为字节数组字符串，并对其进行Base64编码处理
  28. *
  29. * @author linbingwen
  30. * @since 2016年3月30日
  31. * @param imgFilePath 图片路径
  32. * @return base64编码的字符串
  33. * @throws IOException
  34. */
  35. public static String imageToBase64(String imgFilePath) throws IOException {
  36. byte[] data = null;
  37. InputStream in = null;
  38. try {
  39. in = new FileInputStream(imgFilePath);
  40. data = new byte[in.available()]; // 读取图片字节数组
  41. in.read(data);
  42. } catch (IOException e) {
  43. e.printStackTrace();
  44. } finally {
  45. if (in != null) {
  46. in.close();
  47. }
  48. }
  49. BASE64Encoder encoder = new BASE64Encoder(); // 对字节数组Base64编码
  50. return encoder.encode(data); // 返回Base64编码过的字节数组字符串
  51. }
  53. /**
  54. * 对字节数组字符串进行Base64解码并生成图片
  55. *
  56. * @author linbingwen
  57. * @since 2016年3月30日
  58. * @param imgStr base64编码的数据
  59. * @param imgFilePath 要保存的图片路径
  60. * @param imgFileName 要保存的图片名
  61. * @return
  62. * @throws IOException
  63. */
  64. public static Boolean base64ToImage(String base64, String imgFilePath,String imgFileName) throws IOException {
  65. if (base64 == null) {
  66. return null;
  67. }
  68. BASE64Decoder decoder = new BASE64Decoder();
  69. OutputStream out = null;
  70. try {
  71. byte[] bytes = decoder.decodeBuffer(base64); // Base64解码
  72. for ( int i = 0; i < bytes.length; ++i) {
  73. if (bytes[i] < 0) { // 调整异常数据
  74. bytes[i] += 256;
  75. }
  76. }
  77. InputStream input = new ByteArrayInputStream(bytes);
  78. out = new FileOutputStream(imgFilePath + imgFileName); // 生成jpeg图片
  79. out.write(bytes);
  80. out.flush();
  81. return true;
  82. } catch (Exception e) {
  83. return false;
  84. } finally {
  85. if (out != null) {
  86. out.close();
  87. }
  88. }
  89. }
  91. /**
  92. * 将base64编码的字符串转成InputStream
  93. * @author linbingwen
  94. * @since 2016年3月30日
  95. * @param base64
  96. * @return InputStream
  97. */
  98. public static InputStream base64ToInputStream(String base64) {
  99. if (base64 == null) {
  100. return null;
  101. }
  102. BASE64Decoder decoder = new BASE64Decoder();
  103. try {
  104. byte[] bytes = decoder.decodeBuffer(base64); // Base64解码
  105. for ( int i = 0; i < bytes.length; ++i) {
  106. if (bytes[i] < 0) { // 调整异常数据
  107. bytes[i] += 256;
  108. }
  109. }
  110. InputStream input = new ByteArrayInputStream(bytes);
  111. return input;
  112. } catch (Exception e) {
  113. return null;
  114. }
  115. }
  117. /**
  118. * 将网络图片进行Base64位编码
  119. * @author linbingwen
  120. * @since 2016年3月30日
  121. * @param imageUrl 图片的url路径，如http://.....xx.jpg
  122. * @return 返回Base64编码过的字节数组字符串
  123. * @throws IOException
  124. */
  125. public static String imageUrlToBase64(String imageUrl) throws IOException {
  126. ByteArrayOutputStream outputStream = null;
  127. try {
  128. URL url = new URL(imageUrl);
  129. BufferedImage bufferedImage = ImageIO.read(url);
  130. outputStream = new ByteArrayOutputStream();
  131. ImageIO.write(bufferedImage, "jpg", outputStream);
  132. } catch (MalformedURLException e1) {
  133. e1.printStackTrace();
  134. } catch (IOException e) {
  135. e.printStackTrace();
  136. } finally {
  137. if (outputStream != null) {
  138. outputStream.close();
  139. }
  140. }
  141. BASE64Encoder encoder = new BASE64Encoder(); // 对字节数组Base64编码
  142. return encoder.encode(outputStream.toByteArray());
  143. }
  145. /**
  146. *
  147. * @author linbingwen
  148. * @since 2016年4月13日
  149. * @param imageUrl 图片url
  150. * @param imageType 图片格式 如 jpg/bmp/png
  151. * @return
  152. * @throws IOException
  153. */
  154. public static byte[] imageUrlToBytes(String imageUrl,String imageType) throws IOException {
  155. ByteArrayOutputStream outputStream = null;
  156. byte[] bytes = null;
  157. try {
  158. URL url = new URL(imageUrl);
  159. BufferedImage bufferedImage = ImageIO.read(url);
  160. outputStream = new ByteArrayOutputStream();
  161. ImageIO.write(bufferedImage, imageType, outputStream);
  162. bytes = outputStream.toByteArray();
  163. } catch (MalformedURLException e1) {
  164. e1.printStackTrace();
  165. } catch (IOException e) {
  166. e.printStackTrace();
  167. } finally {
  168. if (outputStream != null) {
  169. outputStream.close();
  170. }
  171. }
  172. return bytes;
  173. }
  175. public static void main(String[] args) throws IOException {
  176. String imgFilePath = "D:\\";
  177. String ttString = imageUrlToBase64( "http://10.75.201.68:8888/cfile/file/image?imageId=group2/M00/05/25/CkvJolb5nIOAcHMZAADU5zn6AlI7014866");
  178. base64ToImage(ttString, imgFilePath, "44.bmp");
  180. urlBase64ToFile( "http://10.75.201.68:8888/cfile/file/image?imageId=group2/M00/05/97/CkvJo1dxbqKAEBqzAARHjfpHsPk7518600");
  181. }
  183. /**
  184. * @author linbingwen
  185. * @since 2016年6月28日
  186. * @param string
  187. */
  188. private static void urlBase64ToFile(String string) {
  190. }
  193. }

4、JSON转换处理工具

  1. /**
  2. * 功能概要：java与json转换工具类
  3. *
  4. * @author linbingwen
  5. * @since 2016年4月20日
  6. */
  7. import java.text.SimpleDateFormat;
  8. import java.util.ArrayList;
  9. import java.util.Collection;
  10. import java.util.Date;
  11. import java.util.HashMap;
  12. import java.util.Iterator;
  13. import java.util.List;
  14. import java.util.Map;
  16. import net.sf.ezmorph.MorpherRegistry;
  17. import net.sf.ezmorph.object.DateMorpher;
  18. import net.sf.json.JSONArray;
  19. import net.sf.json.JSONObject;
  20. import net.sf.json.JsonConfig;
  21. import net.sf.json.processors.JsonValueProcessor;
  22. import net.sf.json.util.JSONUtils;
  23. import net.sf.json.xml.XMLSerializer;
  25. public class JsonUtil {
  27. private static String YYYY_MM_DD = "yyyy-MM-dd";
  28. private static String YYYY_MM_DD_HH_MM_ss = "yyyy-MM-dd HH:mm:ss";
  29. private static String HH_MM_ss = "HH-mm-ss";
  30. private static String YYYYMMDD = "yyyyMMdd";
  31. private static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
  32. private static String HHMMss = "HHmmss";
  34. /**
  35. * 设置日期转换格式
  36. */
  37. static {
  38. //注册器
  39. MorpherRegistry mr = JSONUtils.getMorpherRegistry();
  41. //可转换的日期格式，即Json串中可以出现以下格式的日期与时间
  42. DateMorpher dm = new DateMorpher( new String[] { YYYY_MM_DD,
  43. YYYY_MM_DD_HH_MM_ss, HH_MM_ss, YYYYMMDD,
  44. YYYYMMDDHHMMSS, HHMMss});
  45. mr.registerMorpher(dm);
  46. }
  48. /**
  49. * 从json串转换成实体对象
  50. * @param jsonObjStr e.g. {'name':'get','dateAttr':'2009-11-12'}
  51. * @param clazz Person.class
  52. * @return
  53. */
  54. public static Object getDtoFromJsonObjStr(String jsonObjStr, Class clazz) {
  55. return JSONObject.toBean(JSONObject.fromObject(jsonObjStr), clazz);
  56. }
  58. /**
  59. * 从json串转换成实体对象，并且实体集合属性存有另外实体Bean
  60. * @param jsonObjStr e.g. {'data':[{'name':'get'},{'name':'set'}]}
  61. * @param clazz e.g. MyBean.class
  62. * @param classMap e.g. classMap.put("data", Person.class)
  63. * @return Object
  64. */
  65. public static Object getDtoFromJsonObjStr(String jsonObjStr, Class clazz, Map classMap) {
  66. return JSONObject.toBean(JSONObject.fromObject(jsonObjStr), clazz, classMap);
  67. }
  69. /**
  70. * 把一个json数组串转换成普通数组
  71. * @param jsonArrStr e.g. ['get',1,true,null]
  72. * @return Object[]
  73. */
  74. public static Object[] getArrFromJsonArrStr(String jsonArrStr) {
  75. return JSONArray.fromObject(jsonArrStr).toArray();
  76. }
  78. /**
  79. * 把一个json数组串转换成实体数组
  80. * @param jsonArrStr e.g. [{'name':'get'},{'name':'set'}]
  81. * @param clazz e.g. Person.class
  82. * @return Object[]
  83. */
  84. public static Object[] getDtoArrFromJsonArrStr(String jsonArrStr, Class clazz) {
  85. JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);
  86. Object[] objArr = new Object[jsonArr.size()];
  87. for ( int i = 0; i < jsonArr.size(); i++) {
  88. objArr[i] = JSONObject.toBean(jsonArr.getJSONObject(i), clazz);
  89. }
  90. return objArr;
  91. }
  93. /**
  94. * 把一个json数组串转换成实体数组，且数组元素的属性含有另外实例Bean
  95. * @param jsonArrStr e.g. [{'data':[{'name':'get'}]},{'data':[{'name':'set'}]}]
  96. * @param clazz e.g. MyBean.class
  97. * @param classMap e.g. classMap.put("data", Person.class)
  98. * @return Object[]
  99. */
  100. public static Object[] getDtoArrFromJsonArrStr(String jsonArrStr, Class clazz,
  101. Map classMap) {
  102. JSONArray array = JSONArray.fromObject(jsonArrStr);
  103. Object[] obj = new Object[array.size()];
  104. for ( int i = 0; i < array.size(); i++) {
  105. JSONObject jsonObject = array.getJSONObject(i);
  106. obj[i] = JSONObject.toBean(jsonObject, clazz, classMap);
  107. }
  108. return obj;
  109. }
  111. /**
  112. * 把一个json数组串转换成存放普通类型元素的集合
  113. * @param jsonArrStr e.g. ['get',1,true,null]
  114. * @return List
  115. */
  116. public static List getListFromJsonArrStr(String jsonArrStr) {
  117. JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);
  118. List list = new ArrayList();
  119. for ( int i = 0; i < jsonArr.size(); i++) {
  120. list.add(jsonArr.get(i));
  121. }
  122. return list;
  123. }
  125. /**
  126. * 把一个json数组串转换成集合，且集合里存放的为实例Bean
  127. * @param jsonArrStr e.g. [{'name':'get'},{'name':'set'}]
  128. * @param clazz
  129. * @return List
  130. */
  131. public static List getListFromJsonArrStr(String jsonArrStr, Class clazz) {
  132. JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);
  133. List list = new ArrayList();
  134. for ( int i = 0; i < jsonArr.size(); i++) {
  135. list.add(JSONObject.toBean(jsonArr.getJSONObject(i), clazz));
  136. }
  137. return list;
  138. }
  140. /**
  141. * 把一个json数组串转换成集合，且集合里的对象的属性含有另外实例Bean
  142. * @param jsonArrStr e.g. [{'data':[{'name':'get'}]},{'data':[{'name':'set'}]}]
  143. * @param clazz e.g. MyBean.class
  144. * @param classMap e.g. classMap.put("data", Person.class)
  145. * @return List
  146. */
  147. public static List getListFromJsonArrStr(String jsonArrStr, Class clazz, Map classMap) {
  148. JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);
  149. List list = new ArrayList();
  150. for ( int i = 0; i < jsonArr.size(); i++) {
  151. list.add(JSONObject.toBean(jsonArr.getJSONObject(i), clazz, classMap));
  152. }
  153. return list;
  154. }
  156. /**
  157. * 把json对象串转换成map对象
  158. * @param jsonObjStr e.g. {'name':'get','int':1,'double',1.1,'null':null}
  159. * @return Map
  160. */
  161. public static Map getMapFromJsonObjStr(String jsonObjStr) {
  162. JSONObject jsonObject = JSONObject.fromObject(jsonObjStr);
  164. Map map = new HashMap();
  165. for (Iterator iter = jsonObject.keys(); iter.hasNext();) {
  166. String key = (String) iter.next();
  167. map.put(key, jsonObject.get(key));
  168. }
  169. return map;
  170. }
  172. /**
  173. * 把json对象串转换成map对象，且map对象里存放的为其他实体Bean
  174. * @param jsonObjStr e.g. {'data1':{'name':'get'},'data2':{'name':'set'}}
  175. * @param clazz e.g. Person.class
  176. * @return Map
  177. */
  178. public static Map getMapFromJsonObjStr(String jsonObjStr, Class clazz) {
  179. JSONObject jsonObject = JSONObject.fromObject(jsonObjStr);
  181. Map map = new HashMap();
  182. for (Iterator iter = jsonObject.keys(); iter.hasNext();) {
  183. String key = (String) iter.next();
  184. map.put(key, JSONObject.toBean(jsonObject.getJSONObject(key), clazz));
  185. }
  186. return map;
  187. }
  189. /**
  190. * 把json对象串转换成map对象，且map对象里存放的其他实体Bean还含有另外实体Bean
  191. * @param jsonObjStr e.g. {'mybean':{'data':[{'name':'get'}]}}
  192. * @param clazz e.g. MyBean.class
  193. * @param classMap e.g. classMap.put("data", Person.class)
  194. * @return Map
  195. */
  196. public static Map getMapFromJsonObjStr(String jsonObjStr, Class clazz, Map classMap) {
  197. JSONObject jsonObject = JSONObject.fromObject(jsonObjStr);
  199. Map map = new HashMap();
  200. for (Iterator iter = jsonObject.keys(); iter.hasNext();) {
  201. String key = (String) iter.next();
  202. map.put(key, JSONObject
  203. .toBean(jsonObject.getJSONObject(key), clazz, classMap));
  204. }
  205. return map;
  206. }
  208. /**
  209. * 把实体Bean、Map对象、数组、列表集合转换成Json串
  210. * @param obj
  211. * @return
  212. * @throws Exception String
  213. */
  214. public static String getJsonStr(Object obj) {
  215. String jsonStr = null;
  216. //Json配置
  217. // JsonConfig jsonCfg = new JsonConfig();
  218. //
  219. // //注册日期处理器
  220. // jsonCfg.registerJsonValueProcessor(java.util.Date.class,
  221. // new JsonDateValueProcessor(YYYY_MM_DD_HH_MM_ss));
  222. if (obj == null) {
  223. return "{}";
  224. }
  226. if (obj instanceof Collection || obj instanceof Object[]) {
  227. jsonStr = JSONArray.fromObject(obj).toString();
  228. } else {
  229. jsonStr = JSONObject.fromObject(obj).toString();
  230. }
  232. return jsonStr;
  233. }
  235. /**
  236. * 把json串、数组、集合(collection map)、实体Bean转换成XML
  237. * XMLSerializer API：
  238. * http://json-lib.sourceforge.net/apidocs/net/sf/json/xml/XMLSerializer.html
  239. * 具体实例请参考：
  240. * http://json-lib.sourceforge.net/xref-test/net/sf/json/xml/TestXMLSerializer_writes.html
  241. * http://json-lib.sourceforge.net/xref-test/net/sf/json/xml/TestXMLSerializer_writes.html
  242. * @param obj
  243. * @return
  244. * @throws Exception String
  245. */
  246. public static String getXMLFromObj(Object obj) {
  247. XMLSerializer xmlSerial = new XMLSerializer();
  249. //Json配置
  250. JsonConfig jsonCfg = new JsonConfig();
  252. //注册日期处理器
  253. jsonCfg.registerJsonValueProcessor(java.util.Date.class,
  254. new JsonDateValueProcessor(YYYY_MM_DD_HH_MM_ss));
  256. if ((String.class.isInstance(obj) && String.valueOf(obj).startsWith( "["))
  257. || obj.getClass().isArray() || Collection.class.isInstance(obj)) {
  258. JSONArray jsonArr = JSONArray.fromObject(obj, jsonCfg);
  259. return xmlSerial.write(jsonArr);
  260. } else {
  261. JSONObject jsonObj = JSONObject.fromObject(obj, jsonCfg);
  262. return xmlSerial.write(jsonObj);
  263. }
  264. }
  266. /**
  267. * 从XML转json串
  268. * @param xml
  269. * @return String
  270. */
  271. public static String getJsonStrFromXML(String xml) {
  272. XMLSerializer xmlSerial = new XMLSerializer();
  273. return String.valueOf(xmlSerial.read(xml));
  274. }
  276. }
  278. /**
  279. *
  280. * 功能概要：json日期值处理器实现
  281. *
  282. * @author linbingwen
  283. * @since 2016年4月20日
  284. */
  285. class JsonDateValueProcessor implements JsonValueProcessor {
  287. private String format = "yyyy-MM-dd HH-mm-ss";
  289. public JsonDateValueProcessor() {
  291. }
  293. public JsonDateValueProcessor(String format) {
  294. this.format = format;
  295. }
  297. public Object processArrayValue(Object value, JsonConfig jsonConfig) {
  298. return process(value, jsonConfig);
  299. }
  301. public Object processObjectValue(String key, Object value, JsonConfig jsonConfig) {
  302. return process(value, jsonConfig);
  303. }
  305. private Object process(Object value, JsonConfig jsonConfig) {
  306. if (value instanceof Date) {
  307. String str = new SimpleDateFormat(format).format((Date) value);
  308. return str;
  309. }
  310. return value == null ? null : value.toString();
  311. }
  313. public String getFormat() {
  314. return format;
  315. }
  317. public void setFormat(String format) {
  318. this.format = format;
  319. }
  321. }

5、邮件发送处理工具

  1. import java.util.Properties;
  3. import javax.activation.DataHandler;
  4. import javax.activation.FileDataSource;
  5. import javax.mail.Address;
  6. import javax.mail.BodyPart;
  7. import javax.mail.Message;
  8. import javax.mail.Multipart;
  9. import javax.mail.PasswordAuthentication;
  10. import javax.mail.Session;
  11. import javax.mail.Transport;
  12. import javax.mail.internet.InternetAddress;
  13. import javax.mail.internet.MimeBodyPart;
  14. import javax.mail.internet.MimeMessage;
  15. import javax.mail.internet.MimeMultipart;
  16. import javax.mail.internet.MimeUtility;
  18. import org.slf4j.Logger;
  19. import org.slf4j.LoggerFactory;
  22. public class MailSendUtil {
  24. private static Logger logger = LoggerFactory.getLogger(MailSendUtil.class);
  26. private MimeMessage mimeMsg; // MIME邮件对象
  28. private Session session; // 邮件会话对象
  30. private Properties props; // 系统属性
  32. private boolean needAuth = false; // smtp是否需要认证
  34. private String username; // smtp认证用户名
  36. private String password; // smtp认证用户密码
  38. private Multipart mp; // 含标题，邮件内容,附件
  40. /**
  41. * Constructor
  42. *
  43. * @param smtp
  44. * 邮件发送服务器
  45. */
  46. public MailSendUtil(String smtp) {
  47. setSmtpHost(smtp);
  48. createMimeMessage();
  49. }
  51. /**
  52. * 设置邮件发送服务器
  53. *
  54. * @param hostName
  55. * String
  56. */
  57. public void setSmtpHost(String hostName) {
  58. logger.info( "设置系统属性：mail.smtp.host = " + hostName);
  59. if (props == null)
  60. props = System.getProperties(); // 获得系统属性对象
  61. props.put( "mail.smtp.host", hostName); // 设置SMTP主机
  62. }
  64. /**
  65. * 创建MIME邮件对象
  66. *
  67. * @return
  68. */
  69. public boolean createMimeMessage() {
  70. try {
  71. logger.info( "准备获取邮件会话对象！");
  73. session = Session.getDefaultInstance(props, new javax.mail.Authenticator() {
  75. protected PasswordAuthentication getPasswordAuthentication() {
  76. return new PasswordAuthentication(username, password);
  77. }
  78. }); // 获得邮件会话对象
  79. }
  80. catch (Exception e) {
  81. logger.error( "获取邮件会话对象时发生错误！" + e);
  82. return false;
  83. }
  85. logger.info( "准备创建MIME邮件对象！");
  86. try {
  87. mimeMsg = new MimeMessage(session); // 创建MIME邮件对象
  88. mp = new MimeMultipart();
  90. return true;
  91. }
  92. catch (Exception e) {
  93. logger.error( "创建MIME邮件对象失败！" + e);
  94. return false;
  95. }
  96. }
  98. /**
  99. * 设置SMTP是否需要验证
  100. *
  101. * @param need
  102. */
  103. public void setNeedAuth(boolean need) {
  104. logger.info( "设置smtp身份认证：mail.smtp.auth = " + need);
  105. if (props == null)
  106. props = System.getProperties();
  107. if (need) {
  108. props.put( "mail.smtp.auth", "true");
  109. }
  110. else {
  111. props.put( "mail.smtp.auth", "false");
  112. }
  113. }
  115. /**
  116. * 设置用户名和密码
  117. *
  118. * @param name
  119. * @param pass
  120. */
  121. public void setNamePass(String name, String pass) {
  122. username = name;
  123. password = pass;
  124. }
  126. /**
  127. * 设置邮件主题
  128. *
  129. * @param mailSubject
  130. * @return
  131. */
  132. public boolean setSubject(String mailSubject) {
  133. logger.info( "设置邮件主题！");
  134. try {
  135. mimeMsg.setSubject(mailSubject);
  136. return true;
  137. }
  138. catch (Exception e) {
  139. logger.error( "设置邮件主题发生错误！");
  140. return false;
  141. }
  142. }
  144. /**
  145. * 设置邮件正文
  146. *
  147. * @param mailBody
  148. * String
  149. */
  150. public boolean setBody(String mailBody) {
  151. try {
  152. BodyPart bp = new MimeBodyPart();
  153. bp.setContent( "" + mailBody, "text/html;charset=GBK");
  154. mp.addBodyPart(bp);
  155. return true;
  156. }
  157. catch (Exception e) {
  158. logger.error( "设置邮件正文时发生错误！" + e);
  159. return false;
  160. }
  161. }
  163. /**
  164. * 添加附件
  165. *
  166. * @param filename
  167. * String
  168. */
  169. public boolean addFileAffix(String filename) {
  170. if (filename == null) {
  171. return true;
  172. }
  174. logger.info( "增加邮件附件：" + filename);
  175. try {
  176. BodyPart bp = new MimeBodyPart();
  177. FileDataSource fileds = new FileDataSource(filename);
  178. bp.setDataHandler( new DataHandler(fileds));
  179. bp.setFileName(MimeUtility.encodeText(fileds.getName()));
  181. mp.addBodyPart(bp);
  183. return true;
  184. }
  185. catch (Exception e) {
  186. logger.error( "增加邮件附件：" + filename + "发生错误！" + e);
  187. return false;
  188. }
  189. }
  191. /**
  192. * 设置发信人
  193. *
  194. * @param from
  195. * String
  196. */
  197. public boolean setFrom(String from) {
  198. logger.info( "设置发信人！");
  199. try {
  200. mimeMsg.setFrom( new InternetAddress(from)); // 设置发信人
  201. return true;
  202. }
  203. catch (Exception e) {
  204. return false;
  205. }
  206. }
  208. /**
  209. * 设置收信人
  210. *
  211. * @param to
  212. * String
  213. */
  214. public boolean setTo(String to) {
  215. logger.info( "设置收件人:" + to);
  216. if (to == null)
  217. return false;
  218. try {
  219. mimeMsg.setRecipients(Message.RecipientType.TO, InternetAddress.parse(to));
  220. return true;
  221. }
  222. catch (Exception e) {
  223. return false;
  224. }
  225. }
  227. /**
  228. * 设置抄送人
  229. *
  230. * @param copyto
  231. * String
  232. */
  233. public boolean setCopyTo(String copyto) {
  234. if (copyto == null)
  235. return false;
  236. try {
  237. mimeMsg.setRecipients(Message.RecipientType.CC, (Address[]) InternetAddress.parse(copyto));
  239. return true;
  240. }
  241. catch (Exception e) {
  242. return false;
  243. }
  244. }
  246. /**
  247. * 发送邮件
  248. */
  249. public boolean sendOut() {
  250. try {
  251. mimeMsg.setContent(mp);
  252. mimeMsg.saveChanges();
  253. logger.info( "正在发送邮件....");
  254. Transport transport = session.getTransport( "smtp");
  255. transport.connect((String) props.get( "mail.smtp.host"), username, password);
  256. transport.sendMessage(mimeMsg, mimeMsg.getRecipients(Message.RecipientType.TO));
  257. // transport.sendMessage(mimeMsg, mimeMsg.getRecipients(Message.RecipientType.CC));
  258. // Transport.send(mimeMsg);
  260. logger.info( "发送邮件成功！");
  261. transport.close();
  263. return true;
  264. }
  265. catch (Exception e) {
  266. logger.error( "邮件发送失败！" + e);
  267. return false;
  268. }
  269. }
  271. /**
  272. * 调用sendOut方法完成邮件发送
  273. *
  274. * @param smtp
  275. * @param from
  276. * @param to
  277. * @param subject
  278. * @param content
  279. * @param username
  280. * @param password
  281. * @return boolean
  282. */
  283. public static boolean send(String smtp, String from, String to, String subject, String content, String username, String password) {
  284. MailSendUtil theMail = new MailSendUtil(smtp);
  285. theMail.setNeedAuth( true); // 需要验证
  287. if (!theMail.setSubject(subject))
  288. return false;
  289. if (!theMail.setBody(content))
  290. return false;
  291. if (!theMail.setTo(to))
  292. return false;
  293. if (!theMail.setFrom(from))
  294. return false;
  295. theMail.setNamePass(username, password);
  297. if (!theMail.sendOut())
  298. return false;
  299. return true;
  300. }
  302. /**
  303. * 调用sendOut方法完成邮件发送,带抄送
  304. *
  305. * @param smtp
  306. * @param from
  307. * @param to
  308. * @param copyto
  309. * @param subject
  310. * @param content
  311. * @param username
  312. * @param password
  313. * @return boolean
  314. */
  315. public static boolean sendAndCc(String smtp, String from, String to, String copyto, String subject, String content, String username, String password) {
  316. MailSendUtil theMail = new MailSendUtil(smtp);
  317. theMail.setNeedAuth( true); // 需要验证
  319. if (!theMail.setSubject(subject))
  320. return false;
  321. if (!theMail.setBody(content))
  322. return false;
  323. if (!theMail.setTo(to))
  324. return false;
  325. if (!theMail.setCopyTo(copyto))
  326. return false;
  327. if (!theMail.setFrom(from))
  328. return false;
  329. theMail.setNamePass(username, password);
  331. if (!theMail.sendOut())
  332. return false;
  333. return true;
  334. }
  336. /**
  337. * 调用sendOut方法完成邮件发送,带附件
  338. *
  339. * @param smtp
  340. * @param from
  341. * @param to
  342. * @param subject
  343. * @param content
  344. * @param username
  345. * @param password
  346. * @param filename
  347. * 附件路径
  348. * @return
  349. */
  350. public static boolean send(String smtp, String from, String to, String subject, String content, String username, String password, String filename) {
  351. MailSendUtil theMail = new MailSendUtil(smtp);
  352. theMail.setNeedAuth( true); // 需要验证
  353. logger.info( "发送邮件至：{} " + to);
  355. if (!theMail.setSubject(subject))
  356. return false;
  357. if (!theMail.setBody(content))
  358. return false;
  359. if (!theMail.addFileAffix(filename))
  360. return false;
  361. if (!theMail.setTo(to))
  362. return false;
  363. if (!theMail.setFrom(from))
  364. return false;
  365. theMail.setNamePass(username, password);
  367. if (!theMail.sendOut())
  368. return false;
  369. return true;
  370. }
  372. /**
  373. * 调用sendOut方法完成邮件发送,带附件和抄送
  374. *
  375. * @param smtp
  376. * @param from
  377. * @param to
  378. * @param copyto
  379. * @param subject
  380. * @param content
  381. * @param username
  382. * @param password
  383. * @param filename
  384. * @return
  385. */
  386. public static boolean sendAndCc(String smtp, String from, String to, String copyto, String subject, String content, String username, String password, String filename) {
  387. MailSendUtil theMail = new MailSendUtil(smtp);
  388. theMail.setNeedAuth( true); // 需要验证
  390. if (!theMail.setSubject(subject))
  391. return false;
  392. if (!theMail.setBody(content))
  393. return false;
  394. if (!theMail.addFileAffix(filename))
  395. return false;
  396. if (!theMail.setTo(to))
  397. return false;
  398. if (!theMail.setCopyTo(copyto))
  399. return false;
  400. if (!theMail.setFrom(from))
  401. return false;
  402. theMail.setNamePass(username, password);
  404. if (!theMail.sendOut())
  405. return false;
  406. return true;
  407. }
  409. public static void main(String[] args) {
  410. String smtp = "10.75.210.10";
  411. String from = "test1@xxxxx";
  412. String to = "liuqiuyun@xxxx";
  413. String subject = "管理系统";
  414. String content = "邮件内容";
  415. String username = "test1";
  416. String password = "Password1";
  417. String filename = "D:\\file\\ces\\INT_MMS_SETTLE_20150211_0001.DATA";
  418. try {
  419. MailSendUtil.send(smtp, from, to, subject, content, username, password, filename);
  420. }
  421. catch (Exception e) {
  422. e.printStackTrace();
  423. }
  424. }
  425. }

6、SFTP处理工具 

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.util.List;
import java.util.Vector;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.ChannelSftp.LsEntry;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import com.jcraft.jsch.SftpException;
import com.lz.lsf.exception.BusinessException;

/**
 * 
 * 功能概要：SFTP客户端
 * 
 * @author linbingwen
 * @since  2015年8月5日
 */
public class SftpClient {

    private String m_host = "127.0.0.1";

    private int m_port = 22;

    private String m_username = "ctsUser";

    private String m_password = "ctsUser";

    private Logger logger = LoggerFactory.getLogger(this.getClass());

    private Channel m_channel = null;

    public SftpClient(String host, int Port, String userName, String password) {
        this.m_host = host;
        this.m_port = Port;
        this.m_username = userName;
        this.m_password = password;
    }

    public void reConnect() {
        try {
            this.connect();
        }
        catch (Exception e) {
            logger.warn("m_channel disconnect fail!", e);
        }
    }

    public void connect() {
        JSch jsch = new JSch();
        try {
            jsch.getSession(m_username, m_host, m_port);
            Session sshSession = jsch.getSession(m_username, m_host, m_port);
            logger.info("username:" + m_username + ", host:" + m_host + ",port:" + m_port);
            java.util.Properties config = new java.util.Properties();
            config.put("StrictHostKeyChecking", "no");
            sshSession.setConfig(config);
            logger.debug("StrictHostKeyChecking", "no");
            sshSession.setPassword(m_password);
            sshSession.connect();
            logger.debug("Session connected.");
            m_channel = sshSession.openChannel("sftp");
            logger.debug("Opening Channel.");
            m_channel.connect();
            logger.info("Connected to {} success! ", m_host);
        }
        catch (JSchException e) {
            logger.error("connected to " + m_host + "Fail! ");
            throw new BusinessException(CommonErrorCode.ERROR_CONNECT_SFTP_FAIL, e, "connected to " + m_host + "Fail! ");
        }
    }

    public void disConnect() {
        try {
            if (m_channel == null)
                return;

            synchronized (m_channel) {
                if (m_channel.getSession().isConnected())
                    m_channel.getSession().disconnect();
            }

            m_channel.disconnect();

        }
        catch (JSchException e) {
            logger.warn("m_channel disconnect fail!", e);
        }
        finally {
            if (m_channel != null)
                m_channel = null;
        }
    }

    public boolean isTryConnect() {
        int tryConnectCount = 0;
        try {
            while (true) {
                tryConnectCount++;
                if (m_channel.getSession().isConnected())
                    return true;
                else {
                    if (tryConnectCount >= 3)
                        return false;
                    else {
                        this.reConnect();
                    }
                }
            }
        }
        catch (JSchException e) {
            logger.warn("m_channel isConnected fail!", e);
            return false;
        }
    }

    /**
     * 上传文件
     * 
     * @param directoryName
     *            上传的目录
     * @param uploadFileName
     *            要上传的文件
     * @param sftp
     * @throws SftpException
     * @throws FileNotFoundException
     * @throws JSchException
     */
    public void upload(String remotePathDirName, String uploadFileName) {
        ChannelSftp sftp = (ChannelSftp) m_channel;
        if (!this.isTryConnect()) {
            logger.error("尝试连接SFTP服务器失败！");
           throw new BusinessException(CommonErrorCode.ERROR_CONNECT_SFTP_FAIL);
        }
        try {
            sftp.cd(remotePathDirName);
            File uploadFile = new File(uploadFileName);
            sftp.put(new FileInputStream(uploadFile), uploadFile.getName());
            logger.debug("Upload file:{} to remote dir:{}", uploadFileName, remotePathDirName);
        }
        catch (FileNotFoundException e) {
            logger.error("download remote path({})FileNotFound{}", remotePathDirName, uploadFileName);
            throw new BusinessException(CommonErrorCode.NOT_EXISTS_PATH_SFTP_REMOTE, e, "FileNotFound:" + uploadFileName);
        }
        catch (SftpException e) {
            logger.error("download remote path({}) not exists!{}", remotePathDirName, e);
            throw new BusinessException(CommonErrorCode.NOT_EXISTS_PATH_SFTP_REMOTE, e, "remote path:" + remotePathDirName);
        }
    }

    public void uploadBatch(String directoryName, List<String> fileNameList) {
        for (String fileName : fileNameList) {
            this.upload(directoryName, fileName);
        }
    }

    /**
     * 下载文件
     * 
     * @param directoryName
     *            下载目录
     * @param downloadFileName
     *            下载的文件
     * @param saveFileName
     *            存在本地的路径
     * @param sftp
     * @throws SftpException
     * @throws FileNotFoundException
     * @throws JSchException
     */
    public void download(String remotePathDirName, String localPathDirName, String downloadFileName) {
        ChannelSftp sftp = (ChannelSftp) m_channel;
        if (!this.isTryConnect()) {
            logger.error("尝试连接SFTP服务器失败！");
          //  throw new BusinessException(ActErrorCode.ERROR_CONNECT_SFTP_FAIL);
        }
        try {
            sftp.cd(remotePathDirName);
            File saveFile = new File(localPathDirName + "//" + downloadFileName);
            sftp.get(downloadFileName, new FileOutputStream(saveFile));
            logger.debug("Download file:{} save as {}", downloadFileName, localPathDirName + "//" + downloadFileName);
        }
        catch (FileNotFoundException e) {
            e.printStackTrace();
            logger.error("download remote path{}//{}", remotePathDirName, downloadFileName);
            throw new BusinessException(CommonErrorCode.NOT_FINDFIELS_REMOTE_PATH, e, "FileNotFound:" + downloadFileName);
        }
        catch (SftpException e) {
            logger.error("download remote path({}) fail!{}", remotePathDirName + downloadFileName, e);
            throw new BusinessException(CommonErrorCode.NOT_EXISTS_PATH_SFTP_REMOTE, e, "remote path:" + remotePathDirName);
        }
    }

    public void downloadBatch(String directoryName, String localPathDirName, List<String> downloadFileNameList) {
        for (String fileName : downloadFileNameList) {
            this.download(directoryName, localPathDirName, fileName);
        }
    }

    public boolean isFileExists(String remotePathDirName) {
        ChannelSftp sftp = (ChannelSftp) m_channel;
        if (!this.isTryConnect()) {
            logger.error("尝试连接SFTP服务器失败！");
            throw new BusinessException(CommonErrorCode.ERROR_CONNECT_SFTP_FAIL);
        }
        try {
            Vector<LsEntry> filesName = sftp.ls(remotePathDirName);
            return filesName.size() > 0;
        }
        catch (SftpException e) {
            logger.warn("download remote path({}) not exists!{}", remotePathDirName, e);
            return false;
        }
    }

    /**
     * 删除文件
     * 
     * @param directory
     *            要删除文件所在目录
     * @param deleteFileName
     *            要删除的文件
     * @param sftp
     * @throws SftpException
     * @throws JSchException
     */
    public void delete(String directory, String deleteFileName) throws SftpException, JSchException {
        ChannelSftp sftp = (ChannelSftp) m_channel;
        if (!this.isTryConnect()) {
            logger.error("尝试连接SFTP服务器失败！");
           throw new BusinessException(CommonErrorCode.ERROR_CONNECT_SFTP_FAIL);
        }
        sftp.cd(directory);
        sftp.rm(deleteFileName);
        logger.info("Delete file:{} from remote dir:{}", deleteFileName, directory);
    }

    /**
     * 列出目录下的文件
     * 
     * @param directoryName
     *            要列出的目录
     * @param sftp
     * @return
     * @throws SftpException
     * @throws JSchException
     */
    @SuppressWarnings("unchecked")
    public Vector<LsEntry> listFiles(String directoryName) throws SftpException, JSchException {
        ChannelSftp sftp = (ChannelSftp) m_channel;
        if (!this.isTryConnect()) {
            logger.error("尝试连接SFTP服务器失败！");
           throw new BusinessException(CommonErrorCode.ERROR_CONNECT_SFTP_FAIL);
        }
        Vector<LsEntry> filesName = sftp.ls(directoryName);
        return filesName;
    }

    /**
     * 列出目录下符合要求的文件
     * 
     * @param directoryName
     *            要列出的目录
     * @param reg
     *            文件名前缀
     * @param postfix
     *            文件名后缀(格式)
     * @return
     * @throws SftpException
     * @throws JSchException
     */
    @SuppressWarnings("unchecked")
    public Vector<LsEntry> listFiles(String remotePathDirName, String reg, String postfix) {
        ChannelSftp sftp = (ChannelSftp) m_channel;
        if (!this.isTryConnect()) {
            logger.error("尝试连接SFTP服务器失败！");
           throw new BusinessException(CommonErrorCode.ERROR_CONNECT_SFTP_FAIL);
        }
        Vector<LsEntry> filesName;
        try {
            filesName = sftp.ls(remotePathDirName);
            Vector<LsEntry> filterFilesName = new Vector<LsEntry>();
            for (LsEntry lsEntry : filesName) {
                if (lsEntry.getFilename().indexOf(reg) > -1 && lsEntry.getFilename().endsWith(postfix)) {
                    filterFilesName.add(lsEntry);
                }
            }
            return filterFilesName;
        }
        catch (SftpException e) {
            logger.error("download remote path({}) not exists!{}", remotePathDirName, e);
            throw new BusinessException(CommonErrorCode.NOT_EXISTS_PATH_SFTP_REMOTE, e, "remote path" + remotePathDirName);
        }
	
    }

}

7、class工具

  1. import java.lang.reflect.Field;
  2. import java.lang.reflect.InvocationTargetException;
  3. import java.lang.reflect.Method;
  4. import java.lang.reflect.ParameterizedType;
  5. import java.lang.reflect.Type;
  6. import java.math.BigDecimal;
  7. import java.util.Date;
  8. import java.util.HashSet;
  9. import java.util.Set;
  11. import org.apache.commons.beanutils.BeanUtils;
  13. import com.lz.lsf.util.StringUtil;
  15. public class ClassUtil {
  17. static Set<Class> privateTypes = new HashSet<Class>();
  18. static {
  19. privateTypes.add( int.class);
  20. privateTypes.add( double.class);
  21. privateTypes.add( long.class);
  22. privateTypes.add( float.class);
  23. privateTypes.add( boolean.class);
  24. privateTypes.add(Integer.class);
  25. privateTypes.add(Double.class);
  26. privateTypes.add(Long.class);
  27. privateTypes.add(Float.class);
  28. privateTypes.add(String.class);
  29. privateTypes.add(Date.class);
  30. privateTypes.add(Boolean.class);
  31. }
  34. public static Class<?> getFieldGenricType(Field field, int index) {
  35. String signature = field.toGenericString();
  36. return getGenericeType(signature, index);
  37. }
  39. private static Class<?> getGenericeType(String signature, int index) {
  40. String genericStr = signature.substring(signature.indexOf( "<") + 1, signature.indexOf( ">"));
  41. String[] types = genericStr.split( ",");
  42. if (types.length > 0 && types.length > index) {
  43. try {
  44. return Class.forName(types[index]);
  45. }
  46. catch (ClassNotFoundException e) {
  47. throw new RuntimeException(e);
  48. }
  49. }
  50. else {
  51. return null;
  52. }
  53. }
  55. /**
  56. * 通过反射, 获得定义Class时声明的父类的泛型参数的类型. 如无法找到, 返回Object.class.
  57. *
  58. * @param clazz
  59. * clazz The class to introspect
  60. * @param index
  61. * the Index of the generic ddeclaration,start from 0.
  62. * @return the index generic declaration, or Object.class if cannot be determined
  63. */
  64. @SuppressWarnings( "unchecked")
  65. public static Class<?> getSuperClassGenricType( final Class clazz, final int index) {
  66. Class<?> ret = null;
  67. // 返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的直接超类的 Type。
  68. Type genType = clazz.getGenericSuperclass();
  69. ret = getGenericType(genType, index);
  71. if (ret == null) {
  72. for (Type t : clazz.getGenericInterfaces()) {
  73. ret = getGenericType(t, index);
  74. if (ret != null) {
  75. break;
  76. }
  77. }
  78. }
  80. return ret;
  81. }
  83. private static Class<?> getGenericType(Type type, int index) {
  84. if (!(type instanceof ParameterizedType)) {
  85. return null;
  86. }
  88. // 返回表示此类型实际类型参数的 Type 对象的数组。
  89. Type[] params = ((ParameterizedType) type).getActualTypeArguments();
  91. if (index >= params.length || index < 0) {
  92. return null;
  93. }
  94. if (!(params[index] instanceof Class)) {
  95. return null;
  96. }
  98. return (Class) params[index];
  99. }
  101. public static String getSetterMethod(String attrName) {
  102. String fst = attrName.substring( 0, 1).toUpperCase();
  103. attrName = fst + attrName.substring( 1);
  104. return "set" + attrName;
  105. }
  107. public static void setObjectValue(Object obj, String fieldName, Object value) {
  108. try {
  109. String methodName = getSetterMethod(fieldName);
  110. Method method = findMethod(obj.getClass(), methodName, String.class);
  111. if (method != null) {
  112. method.invoke(obj, value);
  113. }
  114. else {
  115. Field field = obj.getClass().getDeclaredField(fieldName);
  116. if (field != null) {
  117. field.setAccessible( true);
  118. field.set(obj, value);
  119. }
  120. else {
  121. throw new RuntimeException( "no field or set method found for field:" + fieldName);
  122. }
  123. }
  124. }
  125. catch (Exception e) {
  126. throw new RuntimeException(e);
  127. }
  128. }
  130. public static boolean isPriovateType(Class type) {
  131. return privateTypes.contains(type);
  132. }
  134. public static Object getPrivateTypeValue(Class type, String value) {
  135. if (String.class == type) {
  136. return value;
  137. }
  138. else if ( int.class == type) {
  139. return StringUtil.isEmpty(value) ? 0 : Integer.parseInt(value);
  140. }
  141. else if ( double.class == type) {
  142. return StringUtil.isEmpty(value) ? 0 : Double.parseDouble(value);
  143. }
  144. else if ( long.class == type) {
  145. return StringUtil.isEmpty(value) ? 0 : Long.parseLong(value);
  146. }
  147. else if ( float.class == type) {
  148. return StringUtil.isEmpty(value) ? 0 : Float.parseFloat(value);
  149. }
  150. else if (Integer.class == type) {
  151. return StringUtil.isEmpty(value) ? 0 : Integer.valueOf(value);
  152. }
  153. else if (Double.class == type) {
  154. return StringUtil.isEmpty(value) ? 0 : Double.valueOf(value);
  155. }
  156. else if (Long.class == type) {
  157. return StringUtil.isEmpty(value) ? 0 : Long.valueOf(value);
  158. }
  159. else if (Float.class == type) {
  160. return StringUtil.isEmpty(value) ? 0 : Float.valueOf(value);
  161. }
  162. else if (BigDecimal.class == type) {
  163. return StringUtil.isEmpty(value) ? BigDecimal.ZERO : BigDecimal.valueOf(Double.valueOf(value));
  164. }
  165. else if ( boolean.class == type || Boolean.class == type) {
  166. return StringUtil.isEmpty(value) ? false : Boolean.valueOf(value);
  167. }
  168. else {
  169. return null;
  170. }
  171. }
  173. public static void main(String[] args) {
  174. System.out.println( Boolean.valueOf( "true"));
  175. System.out.println( Boolean.valueOf( "false"));
  176. String[] sp = "|1|2|||| ".split( "\\|");
  177. System.out.println(sp);
  178. System.out.println( "|1|2||||".endsWith( "|"));
  179. }
  181. public static Method findMethod(Class<?> clazz, String methodName, Class<?> paramType) {
  182. Method ret = null;
  183. try {
  184. ret = clazz.getMethod(methodName, paramType);
  185. }
  186. catch (Exception e) {
  187. if (paramType.getSuperclass() != null) {
  188. ret = findMethod(clazz, methodName, paramType.getSuperclass());
  189. }
  190. if (ret == null) {
  191. for (Class _clazz : paramType.getInterfaces()) {
  192. ret = findMethod(clazz, methodName, _clazz);
  193. if (ret != null) {
  194. break;
  195. }
  196. }
  197. }
  198. }
  199. return ret;
  200. }
  202. @SuppressWarnings( "unchecked")
  203. public static <T> T cloneInstance(T obj) {
  204. T ret;
  205. try {
  206. ret = (T) BeanUtils.cloneBean(obj);
  207. }
  208. catch (Exception e) {
  209. throw new RuntimeException( "clone instance failed!", e);
  210. }
  212. return ret;
  213. }
  214. }

8、GET/POST请求工具
  1. import java.io.IOException;
  2. import java.util.ArrayList;
  3. import java.util.Date;
  4. import java.util.HashMap;
  5. import java.util.List;
  6. import java.util.Map;
  8. import org.apache.commons.lang3.StringUtils;
  9. import org.apache.http.Consts;
  10. import org.apache.http.HttpResponse;
  11. import org.apache.http.NameValuePair;
  12. import org.apache.http.client.CookieStore;
  13. import org.apache.http.client.config.RequestConfig;
  14. import org.apache.http.client.entity.UrlEncodedFormEntity;
  15. import org.apache.http.client.methods.HttpGet;
  16. import org.apache.http.client.methods.HttpPost;
  17. import org.apache.http.impl.client.BasicCookieStore;
  18. import org.apache.http.impl.client.CloseableHttpClient;
  19. import org.apache.http.impl.client.HttpClients;
  20. import org.apache.http.impl.cookie.BasicClientCookie;
  21. import org.apache.http.message.BasicNameValuePair;
  22. import org.apache.http.util.EntityUtils;
  23. import org.junit.Test;
  24. import org.slf4j.Logger;
  25. import org.slf4j.LoggerFactory;
  27. public class HttpClientUtil {
  29. static CookieStore cookieStore = null;
  31. private static Logger logger = LoggerFactory.getLogger(HttpClientUtil.class);
  33. public static void main(String[] args) {
  35. Map<String, String> map = new HashMap<String, String>();
  36. map.put( "pageIndex", "1");
  37. map.put( "pageSize", "20");
  38. String result = HttpClientUtil.post( "http://xxxxx/xxx/operator/menu/findByPage.json", map);
  39. logger.info( "post result:" + result);
  41. map = new HashMap<String, String>();
  42. map.put( "pageNumber", "1");
  43. map.put( "pageSize", "20");
  44. result = HttpClientUtil.get( "http://xxx/ftc-ump-mid/xxx/dict/condition.json", map);
  45. logger.info( "get result:" + result);
  47. }
  49. @Test
  50. public void postTest() {
  51. Map<String, String> map = new HashMap<String, String>();
  52. map.put( "pageIndex", "1");
  53. map.put( "pageSize", "20");
  54. String result = HttpClientUtil.post( "http:/xxxxx/findByPage.json", map);
  55. logger.info( "result:" + result);
  56. }
  58. @Test
  59. public void getTest() {
  60. Map<String, String> map = new HashMap<String, String>();
  61. map.put( "pageNumber", "1");
  62. map.put( "pageSize", "20");
  63. String result = HttpClientUtil.get( "http://xxxxor/dict/condition.json", map);
  64. logger.info( "result:" + result);
  65. }
  67. /**
  68. * 获取cookie的内容
  69. *
  70. * @param ck
  71. * @param name
  72. * @return
  73. */
  74. public static String retriveCkValue(String ck, String name) {
  75. if (StringUtils.isBlank(ck) || StringUtils.isBlank(name)) {
  76. return "";
  77. }
  79. final String delimChar = name + "=";
  80. int delimBegin = ck.indexOf(delimChar);
  81. if (delimBegin < 0) {
  82. return "";
  83. }
  85. String val = null;
  86. int delimEnd = ck.indexOf( ';', delimBegin);
  87. if (delimEnd < 0) {
  88. val = ck.substring(delimBegin + delimChar.length()).trim();
  89. } else {
  90. val = ck.substring(delimBegin + delimChar.length(), delimEnd).trim();
  91. }
  92. int idx = val.indexOf( '?');
  93. if (idx > 0) {
  94. val = val.substring( 0, idx);
  95. }
  97. return val;
  98. }
  100. /**
  101. * 将cookie保存到静态变量中供后续调用
  102. *
  103. * @param httpResponse
  104. */
  105. public static void setCookieStore(HttpResponse httpResponse) {
  106. logger.info( "-------setCookieStore---------");
  108. if (httpResponse.getFirstHeader( "Set-Cookie") != null) {
  109. cookieStore = new BasicCookieStore();
  110. org.apache.http.Header[] cookies = httpResponse.getHeaders( "Set-Cookie");
  111. // Expires=Fri, 14-Apr-2017 09:42:26 GMT;
  113. for ( int j = 0; j < cookies.length; j++) {
  114. String content = cookies[j].getValue();
  115. String cookName = content.substring( 0, content.indexOf( "="));
  117. String cookNameContent = retriveCkValue(content, cookName);
  118. String domain = retriveCkValue(content, "Domain");
  119. String path = retriveCkValue(content, "Path");
  121. String time = retriveCkValue(content, "Expires");
  122. Date expires = new Date(time);
  124. BasicClientCookie cookie = new BasicClientCookie(cookName, cookNameContent);
  125. cookie.setDomain(domain);
  126. cookie.setPath(path);
  127. cookie.setExpiryDate(expires);
  129. cookieStore.addCookie(cookie);
  130. logger.info(cookName + ":{},domain:{},path:{},expires", cookNameContent, domain, path, expires);
  132. }
  133. }
  134. }
  136. /**
  137. * 模拟登陆
  138. *
  139. * @param client
  140. * @return
  141. */
  142. private static String login(CloseableHttpClient client) {
  143. String path = "http://xxxxxx/operator.json";
  144. Map<String, String> params = new HashMap<String, String>();
  145. params.put( "userId", "ITADMIN2");
  146. params.put( "password", "123456");
  147. List<NameValuePair> list = new ArrayList<NameValuePair>();
  148. if (params != null && !params.isEmpty()) {
  149. for (Map.Entry<String, String> entry : params.entrySet()) {
  150. list.add( new BasicNameValuePair(entry.getKey(), entry.getValue()));
  151. }
  152. }
  153. HttpResponse httpResponse = null;
  154. try {
  155. // 实现将请求的参数封装到表单中，即请求体中
  156. UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, Consts.UTF_8);
  157. // 使用post方式提交数据
  158. HttpPost httpPost = new HttpPost(path);
  159. int connectionTimeout = 15000;
  160. int soTimeout = 15000;
  161. RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(connectionTimeout).setSocketTimeout(soTimeout).build();
  162. httpPost.setConfig(requestConfig);
  163. httpPost.setEntity(entity);
  165. httpResponse = client.execute(httpPost);
  166. // 获取服务器端返回的状态码和输入流，将输入流转换成字符串
  167. if (httpResponse.getStatusLine().getStatusCode() == 200) {
  168. // setCookieStore(httpResponse); // 设置cookie
  169. return EntityUtils.toString(httpResponse.getEntity(), Consts.UTF_8);
  170. }
  171. } catch (Exception e) {
  172. e.printStackTrace();
  173. } finally {
  174. if (httpResponse != null) {
  175. try {
  176. EntityUtils.consume(httpResponse.getEntity());
  177. } catch (IOException e) {
  178. e.printStackTrace();
  179. }
  180. }
  181. }
  183. return "";
  184. }
  186. /**
  187. * 模拟get
  188. *
  189. * @param path
  190. * @param params
  191. * @param encode
  192. * @return
  193. */
  194. public static String get(String path, Map<String, String> params) {
  195. List<NameValuePair> list = new ArrayList<NameValuePair>();
  196. if (params != null && !params.isEmpty()) {
  197. for (Map.Entry<String, String> entry : params.entrySet()) {
  198. list.add( new BasicNameValuePair(entry.getKey(), entry.getValue()));
  199. }
  200. }
  201. HttpResponse httpResponse = null;
  202. CloseableHttpClient client = null;
  203. try {
  204. // 实现将请求的参数封装到表单中，即请求体中
  205. UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, Consts.UTF_8);
  206. // 转换为键值对
  207. String str = EntityUtils.toString(entity);
  209. // 使用get方式提交数据
  210. HttpGet httpGet = new HttpGet(path + "?" + str);
  211. int connectionTimeout = 15000;
  212. int soTimeout = 15000;
  213. RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(connectionTimeout).setSocketTimeout(soTimeout).build();
  214. httpGet.setConfig(requestConfig);
  215. // 执行get请求，并获取服务器端的响应HttpResponse
  216. client = HttpClients.createDefault();
  218. // if (cookieStore != null) {
  219. // client =
  220. // HttpClients.custom().setDefaultCookieStore(cookieStore).build();
  221. // } else {
  222. // client = HttpClients.createDefault();
  223. // login(client);
  224. // }
  225. login(client);
  227. httpResponse = client.execute(httpGet);
  228. // 获取服务器端返回的状态码和输入流，将输入流转换成字符串
  229. if (httpResponse.getStatusLine().getStatusCode() == 200) {
  230. return EntityUtils.toString(httpResponse.getEntity(), Consts.UTF_8);
  231. }
  233. } catch (Exception e) {
  234. e.printStackTrace();
  235. } finally {
  236. if (httpResponse != null) {
  237. try {
  238. EntityUtils.consume(httpResponse.getEntity());
  239. } catch (IOException e) {
  240. logger.error( "", e);
  241. }
  242. }
  243. if (client != null) {
  244. try {
  245. client.close();
  246. } catch (IOException e) {
  247. logger.error( "", e);
  248. }
  249. }
  250. }
  252. return "";
  253. }
  255. /**
  256. * 模拟post
  257. *
  258. * @param path
  259. * @param params
  260. * @param encode
  261. * @return
  262. */
  263. public static String post(String path, Map<String, String> params) {
  264. List<NameValuePair> list = new ArrayList<NameValuePair>();
  265. if (params != null && !params.isEmpty()) {
  266. for (Map.Entry<String, String> entry : params.entrySet()) {
  267. list.add( new BasicNameValuePair(entry.getKey(), entry.getValue()));
  268. }
  269. }
  270. HttpResponse httpResponse = null;
  271. CloseableHttpClient client = null;
  272. try {
  273. // 实现将请求的参数封装到表单中，即请求体中
  274. UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, "utf-8");
  275. // 使用post方式提交数据
  276. HttpPost httpPost = new HttpPost(path);
  277. int connectionTimeout = 15000;
  278. int soTimeout = 15000;
  279. RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(connectionTimeout).setSocketTimeout(soTimeout).build();
  280. httpPost.setConfig(requestConfig);
  281. httpPost.setEntity(entity);
  282. // 执行post请求，并获取服务器端的响应HttpResponse
  283. HttpClients.createDefault();
  284. login(client);
  286. // if (cookieStore != null) {
  287. // client =
  288. // HttpClients.custom().setDefaultCookieStore(cookieStore).build();
  289. // } else {
  290. // client = HttpClients.createDefault();
  291. // login(client);
  292. // }
  294. httpResponse = client.execute(httpPost);
  295. // 获取服务器端返回的状态码和输入流，将输入流转换成字符串
  296. if (httpResponse.getStatusLine().getStatusCode() == 200) {
  297. return EntityUtils.toString(httpResponse.getEntity(), "utf-8");
  298. }
  300. } catch (Exception e) {
  301. logger.error( "", e);
  302. } finally {
  303. if (httpResponse != null) {
  304. try {
  305. EntityUtils.consume(httpResponse.getEntity());
  306. } catch (IOException e) {
  307. logger.error( "", e);
  308. }
  309. }
  311. if (client != null) {
  312. try {
  313. client.close();
  314. } catch (IOException e) {
  315. logger.error( "", e);
  316. }
  317. }
  318. }
  320. return "";
  321. }
  322. }

9、ES处理工具

  1. import com.alibaba.fastjson.JSONObject;
  2. import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest;
  3. import org.elasticsearch.action.bulk.BulkRequestBuilder;
  4. import org.elasticsearch.action.bulk.BulkResponse;
  5. import org.elasticsearch.action.count.CountRequestBuilder;
  6. import org.elasticsearch.action.count.CountResponse;
  7. import org.elasticsearch.action.delete.DeleteRequestBuilder;
  8. import org.elasticsearch.action.delete.DeleteResponse;
  9. import org.elasticsearch.action.get.GetResponse;
  10. import org.elasticsearch.action.index.IndexRequest;
  11. import org.elasticsearch.action.index.IndexRequestBuilder;
  12. import org.elasticsearch.action.index.IndexResponse;
  13. import org.elasticsearch.action.search.SearchRequestBuilder;
  14. import org.elasticsearch.action.search.SearchResponse;
  15. import org.elasticsearch.action.search.SearchType;
  16. import org.elasticsearch.action.update.UpdateRequest;
  17. import org.elasticsearch.action.update.UpdateResponse;
  18. import org.elasticsearch.client.Requests;
  19. import org.elasticsearch.client.transport.TransportClient;
  20. import org.elasticsearch.common.lang3.StringUtils;
  21. import org.elasticsearch.common.settings.ImmutableSettings;
  22. import org.elasticsearch.common.settings.Settings;
  23. import org.elasticsearch.common.transport.InetSocketTransportAddress;
  24. import org.elasticsearch.common.xcontent.XContentBuilder;
  25. import org.elasticsearch.index.query.FilterBuilder;
  26. import org.elasticsearch.index.query.QueryBuilder;
  27. import org.elasticsearch.search.SearchHit;
  28. import org.elasticsearch.search.SearchHits;
  29. import org.elasticsearch.search.aggregations.AbstractAggregationBuilder;
  30. import org.slf4j.Logger;
  31. import org.slf4j.LoggerFactory;
  33. import java.util.ArrayList;
  34. import java.util.HashMap;
  35. import java.util.List;
  36. import java.util.Map;
  39. public class ESClient {
  41. private static final Logger log = LoggerFactory.getLogger(ESClient.class);
  43. private TransportClient client;
  45. public ESClient() {
  46. this.init();
  47. }
  50. private void close() {
  51. if ( this.client != null) {
  52. this.client.close();
  53. }
  54. }
  56. @Override
  57. public void finalize() throws Throwable {
  58. this.close();
  59. super.finalize();
  60. }
  62. private void init() {
  63. try {
  64. Settings settings = ImmutableSettings.settingsBuilder().loadFromClasspath( "elasticsearch.yml")
  65. .put( "client.transport.sniff", true).build();
  66. this.client = new TransportClient(settings);
  68. int port = settings.getAsInt( "client.transport.port", 9900);
  69. String[] ips = settings.getAsArray( "client.transport.ip");
  71. for (String ip : ips) {
  72. log.info( "the ip is:" + ip);
  73. client.addTransportAddress( new InetSocketTransportAddress(ip, port));
  74. }
  75. log.info( "es连接成功:{},{}", client, JSONObject.toJSONString(client.listedNodes()));
  77. } catch (Exception e) {
  78. if (client != null) {
  79. client.close();
  80. }
  81. log.error( "连接es失败!", e);
  82. }
  83. }
  85. public void createIndex(String index) throws Exception {
  86. client.admin().indices().prepareCreate(index).execute().actionGet();
  87. }
  89. /**
  90. * 为一种类型建立mapping
  91. *
  92. * @param index 索引名，相当于关系型数据库的库名
  93. * @param type 文档类型，相当于关系型数据库的表名
  94. * @param builder mapping内容, 格式 { "properties": { "fieldName1": { "type":
  95. * "string", "analyzer": "ik" }, "fieldName2": { "type":
  96. * "string", "index": "not_analyzed" } } }
  97. */
  98. public void mappingDoc(String index, String type, XContentBuilder builder)
  99. throws Exception {
  100. // XContentBuilder builder = XContentFactory.jsonBuilder()
  101. // .startObject()
  102. // .startObject("properties")
  103. // .startObject("province")
  104. // .field("type", "string")
  105. // //.field("store", "yes")
  106. // .field("analyzer","ik")
  107. // .field("index","analyzed")
  108. // //.field("indexAnalyzer", "ik")
  109. // //.field("searchAnalyzer", "ik")
  110. // .endObject()
  111. // .endObject()
  112. // .endObject();
  114. PutMappingRequest mapping = Requests.putMappingRequest(index)
  115. .type(type).source(builder);
  116. client.admin().indices().putMapping(mapping).actionGet();
  117. }
  119. /**
  120. * 为一份文档建立索引,采用自生成id
  121. *
  122. * @param index 索引名，相当于关系型数据库的库名
  123. * @param type 文档类型，相当于关系型数据库的表名
  124. * @param json json格式的数据集
  125. * @return
  126. */
  127. public IndexResponse indexDoc(String index, String type, String json) throws Exception {
  128. IndexRequestBuilder builder = client.prepareIndex(index, type);
  129. IndexResponse response = builder.setSource(json)
  130. .execute()
  131. .actionGet();
  132. return response;
  133. }
  135. /**
  136. * 为一份文档建立索引,采用自生成id
  137. *
  138. * @param index 索引名，相当于关系型数据库的库名
  139. * @param type 文档类型，相当于关系型数据库的表名
  140. * @param kvMap 键值对形式的数据集
  141. * @return
  142. */
  143. public IndexResponse indexDoc(String index, String type, Map<String, Object> kvMap)
  144. throws Exception {
  145. IndexRequestBuilder builder = client.prepareIndex(index, type);
  146. IndexResponse response = builder.setSource(kvMap)
  147. .execute()
  148. .actionGet();
  149. return response;
  150. }
  152. /**
  153. * 为一份文档建立索引
  154. *
  155. * @param index 索引名，相当于关系型数据库的库名
  156. * @param type 文档类型，相当于关系型数据库的表名
  157. * @param id 文档id
  158. * @param json json格式的数据集
  159. * @return
  160. */
  161. public IndexResponse indexDoc(String index, String type, String id, String json)
  162. throws Exception {
  164. IndexRequestBuilder builder = client.prepareIndex(index, type, id);
  165. IndexResponse response = builder.setSource(json)
  166. .execute()
  167. .actionGet();
  168. return response;
  169. }
  171. /**
  172. * 为一份文档建立索引
  173. *
  174. * @param index 索引名，相当于关系型数据库的库名
  175. * @param type 文档类型，相当于关系型数据库的表名
  176. * @param id 文档id
  177. * @param kvMap 键值对形式的数据集
  178. * @return
  179. */
  180. public IndexResponse indexDoc(String index, String type, String id, Map<String, Object> kvMap)
  181. throws Exception {
  182. IndexRequestBuilder builder = client.prepareIndex(index, type, id);
  183. IndexResponse response = builder.setSource(kvMap)
  184. .execute()
  185. .actionGet();
  186. return response;
  187. }
  190. /**
  191. * 为多份文档建立索引,采用自生成id
  192. *
  193. * @param index 索引名，相当于关系型数据库的库名
  194. * @param type 文档类型，相当于关系型数据库的表名
  195. * @param jsonList json格式的文档数据: List<json>
  196. * @return
  197. */
  198. public BulkResponse batchIndexDocsForJson(String index, String type, List<String> jsonList)
  199. throws Exception {
  200. if (jsonList.isEmpty()) {
  201. throw new Exception( "批量创建索引时，传入的参数'jsonList'为空！");
  202. }
  204. List<IndexRequest> requestList = new ArrayList<IndexRequest>(jsonList.size());
  206. for (String json : jsonList) {
  207. IndexRequest request = client.prepareIndex(index, type)
  208. .setSource(json)
  209. .request();
  210. requestList.add(request);
  211. }
  213. BulkRequestBuilder bulkRequest = client.prepareBulk();
  214. for (IndexRequest request : requestList) {
  215. bulkRequest.add(request);
  216. }
  218. BulkResponse response = bulkRequest
  219. .execute()
  220. .actionGet();
  222. return response;
  223. }
  226. /**
  227. * 为多份文档建立索引,采用自生成id
  228. *
  229. * @param index 索引名，相当于关系型数据库的库名
  230. * @param type 文档类型，相当于关系型数据库的表名
  231. * @param kvList 键值对形式的文档数据:List<Map<field, value>>
  232. * @return
  233. */
  234. public BulkResponse batchIndexDocsForMap(String index, String type, List<Map<String, Object>> kvList)
  235. throws Exception {
  236. if (kvList.isEmpty()) {
  237. throw new Exception( "批量创建索引时，传入的参数'kvList'为空！");
  238. }
  240. List<String> jsonList = new ArrayList<String>(kvList.size());
  241. for (Map<String, Object> kvMap : kvList) {
  242. jsonList.add(JSONObject.toJSONString(kvMap));
  243. }
  245. BulkResponse response = this.batchIndexDocsForJson(index, type, jsonList);
  246. jsonList.clear();
  248. return response;
  249. }
  252. /**
  253. * 为多份文档建立索引
  254. *
  255. * @param index 索引名，相当于关系型数据库的库名
  256. * @param type 文档类型，相当于关系型数据库的表名
  257. * @param idJsonMap id及json格式的文档数据: Map<id,json>
  258. * @return
  259. */
  260. public BulkResponse batchIndexDocsForJson(String index, String type, Map<String, String> idJsonMap)
  261. throws Exception {
  262. if (idJsonMap.isEmpty()) {
  263. throw new Exception( "批量创建索引时，传入的参数'idJsonMap'为空！");
  264. }
  266. List<IndexRequest> requestList = new ArrayList<IndexRequest>(idJsonMap.size());
  268. for (String id : idJsonMap.keySet()) {
  269. String json = idJsonMap.get(id);
  270. IndexRequest request = client.prepareIndex(index, type, id)
  271. .setSource(json)
  272. .request();
  273. requestList.add(request);
  274. }
  276. BulkRequestBuilder bulkRequest = client.prepareBulk();
  277. for (IndexRequest request : requestList) {
  278. bulkRequest.add(request);
  279. }
  281. BulkResponse response = bulkRequest
  282. .execute()
  283. .actionGet();
  285. return response;
  286. }
  289. /**
  290. * 为多份文档建立索引
  291. *
  292. * @param index 索引名，相当于关系型数据库的库名
  293. * @param type 文档类型，相当于关系型数据库的表名
  294. * @param idKvMap id及键值对形式的文档数据:Map<id,Map<field, value>>
  295. * @return
  296. */
  297. public BulkResponse batchIndexDocsForMap(String index, String type, Map<String, Map<String, Object>> idKvMap)
  298. throws Exception {
  299. if (idKvMap.isEmpty()) {
  300. throw new Exception( "批量创建索引时，传入的参数'idKvMap'为空！");
  301. }
  303. Map<String, String> idJsonMap = new HashMap<String, String>(idKvMap.size());
  304. for (String id : idKvMap.keySet()) {
  305. Map<String, Object> kvMap = idKvMap.get(id);
  306. idJsonMap.put(id, JSONObject.toJSONString(kvMap));
  307. }
  309. BulkResponse response = this.batchIndexDocsForJson(index, type, idJsonMap);
  310. idJsonMap.clear();
  312. return response;
  313. }
  315. /**
  316. * 更新一个doc, 若不存在则插入
  317. *
  318. * @param index
  319. * @param type
  320. * @param id
  321. * @param json
  322. * @param script
  323. * @throws java.util.concurrent.ExecutionException
  324. * @throws InterruptedException
  325. */
  326. // public UpdateResponse upsertDoc(String index, String type, String id, String json, String script) throws Exception {
  327. // IndexRequest indexRequest = new IndexRequest(index, type, id).source(json);
  328. // UpdateRequest updateRequest = new UpdateRequest(index, type, id);
  329. // //updateRequest.doc();
  330. // updateRequest.upsert(indexRequest);
  331. // updateRequest.script(script);
  332. //
  333. // UpdateResponse response = client.update(updateRequest).get();
  334. //
  335. // return response;
  336. // }
  338. public UpdateResponse upsertDoc(String index, String type, String id, String insertJson, String updateJson) throws Exception {
  339. IndexRequest indexRequest = new IndexRequest(index, type, id).source(insertJson);
  340. UpdateRequest updateRequest = new UpdateRequest(index, type, id);
  341. updateRequest.doc(updateJson);
  342. updateRequest.upsert(indexRequest);
  344. UpdateResponse response = client.update(updateRequest).get();
  346. return response;
  347. }
  349. /**
  350. * 根据条件 统计个数
  351. *
  352. * @param queryBuilder 查詢條件
  353. * @param index 索引库名 相當於 数据库名
  354. * @param type 索引类型 相當於 表名
  355. * @return
  356. */
  357. public long countQuery(String index, String type, QueryBuilder queryBuilder) {
  358. CountRequestBuilder crb = client.prepareCount(index).setTypes(type);
  359. if (queryBuilder != null) {
  360. crb.setQuery(queryBuilder);
  361. }
  363. CountResponse response = crb.execute().actionGet();
  364. return response.getCount();
  365. }
  367. public SearchResponse searchAgg(String index, String type, String searchType, QueryBuilder queryBuilder,
  368. AbstractAggregationBuilder aggBuilder) {
  369. SearchRequestBuilder builder = client.prepareSearch(index).setTypes(type);
  371. if (!StringUtils.isEmpty(searchType)) {
  372. builder.setSearchType(SearchType.valueOf(searchType));
  373. }
  375. if (queryBuilder != null) {
  376. builder = builder.setQuery(queryBuilder);
  377. }
  378. if (aggBuilder != null) {
  379. builder = builder.addAggregation(aggBuilder);
  380. }
  382. SearchResponse searchResponse = builder.execute().actionGet();
  384. return searchResponse;
  385. }
  387. /**
  388. * 删除一个文档
  389. *
  390. * @param index 索引名，相当于关系型数据库的库名
  391. * @param type 文档类型，相当于关系型数据库的表名
  392. * @param id 键值对形式的数据集
  393. * @return
  394. */
  395. public DeleteResponse deleteDoc(String index, String type, String id) throws InterruptedException {
  396. DeleteRequestBuilder builder = client.prepareDelete(index, type, id);
  397. DeleteResponse response = builder
  398. .execute()
  399. .actionGet();
  400. return response;
  401. }
  403. /**
  404. * 根据条件删除多个文档
  405. *
  406. * @param index 索引名，相当于关系型数据库的库名
  407. * @param type 文档类型，相当于关系型数据库的表名
  408. * @param queryBuilder 查询器
  409. * @return
  410. */
  411. public void deleteDocsByQuery(String index, String type, QueryBuilder queryBuilder) {
  412. client.prepareDeleteByQuery(index).setTypes(type).setQuery(queryBuilder)
  413. .execute()
  414. .actionGet();
  415. }
  418. /**
  419. * 指定id获取文档
  420. *
  421. * @param index 索引名，相当于关系型数据库的库名
  422. * @param type 文档类型，相当于关系型数据库的表名
  423. * @param id 文档id
  424. * @return
  425. */
  426. public Map<String, Object> getDoc(String index, String type, String id) {
  427. GetResponse response = client.prepareGet(index, type, id)
  428. .execute()
  429. .actionGet();
  431. Map<String, Object> retMap = response.getSourceAsMap();
  432. return retMap;
  433. }
  436. public List<Map<String, Object>> search(String index, String type, QueryBuilder queryBuilder, FilterBuilder filterBuilder) {
  437. SearchRequestBuilder builder = client.prepareSearch(index).setTypes(type);
  439. if (queryBuilder != null) {
  440. builder = builder.setQuery(queryBuilder);
  441. }
  442. if (filterBuilder != null) {
  443. builder = builder.setPostFilter(filterBuilder);
  444. }
  446. SearchResponse searchResponse = builder.execute().actionGet();
  448. SearchHits hits = searchResponse.getHits();
  449. log.info( "Es Hits count: " + hits.getTotalHits());
  451. List<Map<String, Object>> kvList = new ArrayList<Map<String, Object>>();
  453. SearchHit[] hitArray = hits.getHits();
  454. if (hitArray.length > 0) {
  455. for (SearchHit hit : hitArray) {
  456. Map<String, Object> kvMap = hit.getSource();
  458. kvMap.put( "version", hit.getVersion());
  459. kvMap.put( "_id", hit.getId());
  460. kvList.add(kvMap);
  461. }
  462. }
  463. return kvList;
  464. }
  465. }

10、Hbase处理工具 

import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.CompareFilter;
import org.apache.hadoop.hbase.filter.Filter;
import org.apache.hadoop.hbase.filter.FilterList;
import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
import org.apache.hadoop.hbase.util.Bytes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.IOException;
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;


/**
 * 操作Hbase的常用方法
 * <p/>
 * Created by huqingmiao on 2015/4/14.
 */
public class HbaseUtil {

    private static final Logger log = LoggerFactory.getLogger(HbaseUtil.class);

    private static Configuration conf = null;

    private static HConnection conn = null;

    private static String HADOOP_HOME = "C:/hadoop";

    static {

//        try {
//            String hadoopHome = System.getProperties().getProperty("hadoop.home.dir"); //Windows下的HOME目录， 在unix下部署不需要设置
//            if (hadoopHome == null || "".equals(hadoopHome.trim())) {
//                hadoopHome = HADOOP_HOME;
//            }
//
//            File hadoopBinDir = new File(hadoopHome, "bin");      //HOME目录下的bin目录
//            if (!hadoopBinDir.exists()) {
//                hadoopBinDir.mkdirs();
//            }
//            File winExeFile = new File(hadoopBinDir.getCanonicalPath() + File.separator + "winutils.exe");
//            if (!winExeFile.exists()) {
//                winExeFile.createNewFile();
//            }
//
//            //设置环境变量
//            System.getProperties().put("hadoop.home.dir", hadoopHome);
//
//        } catch (IOException e) {
//            log.error("create ./bin/winutils.exe error.", e);
//        }

        //默认从hbase-site.xml读取配置信息
        conf = HBaseConfiguration.create();
//        conf.set("hbase.zookeeper.property.clientPort", "2181");
//        conf.set("hbase.zookeeper.quorum", "10.75.201.125");
//        conf.set("hbase.master", "10.75.201.125:60010");
        //conf.set("hbase.zookeeper.quorum", "hmaster");
        //与hbase/conf/hbase-site.xml中hbase.zookeeper.property.clientPort配置的值相同
      //  conf.set("hbase.zookeeper.property.clientPort", "2181");
    }


    public HbaseUtil() {
        try {
            //预先创建了一个连接，以后的访问都共享该连接
        	//conf.addResource("hbase-site.xml");
            conn = HConnectionManager.createConnection(conf);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
    }

    @Override
    public void finalize() throws Throwable {
        try {
            if (conn != null && !conn.isClosed()) {
                conn.close();
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
        super.finalize();
    }


    /**
     * 建表
     *
     * @param tableName     表名
     * @param columnFamilys 列簇名
     * @throws Exception
     */
    public void createTable(String tableName, String[] columnFamilys) throws Exception {
        HBaseAdmin hAdmin = null;
        try {
            hAdmin = new HBaseAdmin(conf);

            if (hAdmin.tableExists(tableName)) {
                log.info("已经存在要创建的表:" + tableName);

            } else {
                HTableDescriptor tableDesc = new HTableDescriptor(TableName.valueOf(tableName));

                //描述列族
                for (String columnFamily : columnFamilys) {
                    tableDesc.addFamily(new HColumnDescriptor(columnFamily));
                }

                //建表
                hAdmin.createTable(tableDesc);
                log.info("成功创建表:" + tableName);
            }
        } catch (IOException e) {
            log.error(e.getMessage(), e);
            throw e;
        } finally {
            try {
                if (hAdmin != null) {
                    hAdmin.close();
                }
            } catch (IOException e) {
                log.error(e.getMessage(), e);
            }
        }
    }


    /**
     * 删除表
     *
     * @param tableName 表名
     * @throws Exception
     */
    public void deleteTable(String tableName) throws Exception {
        HBaseAdmin hAdmin = null;
        try {
            hAdmin = new HBaseAdmin(conf);

            if (hAdmin.tableExists(tableName)) {
                hAdmin.disableTable(tableName);//禁用表
                hAdmin.deleteTable(tableName);// 删除表
                log.info("成功删除表:" + tableName);

            } else {
                log.info("要删除的表不存在:" + tableName);
            }

        } catch (IOException e) {
            log.error(e.getMessage(), e);
            throw e;
        } finally {
            try {
                if (hAdmin != null) {
                    hAdmin.close();
                }
            } catch (IOException e) {
                log.error(e.getMessage(), e);
            }
        }
    }


    /**
     * 向指定的行、列簇、列写入一项数据；如果该行不存在，则会插入一行。
     *
     * @param tableName 表名
     * @param rowkey    行键
     * @param colFamily 列簇名
     * @param column    列名
     * @param value     列值
     * @throws Exception
     */
    public void putData(String tableName, String rowkey,
                        String colFamily, String column, String value) throws Exception {

        HTableInterface table = null;
        try {
            //table = new HTable(conf, tableName);
            table = conn.getTable(tableName);
            Put put = new Put(Bytes.toBytes(rowkey));

            // 参数分别为：列族、列、值
            put.add(Bytes.toBytes(colFamily), Bytes.toBytes(column), Bytes.toBytes(value));

            table.put(put);
            log.info("成功写入1项数据到{}.", tableName);

        } catch (IOException e) {
            log.error(e.getMessage(), e);
            throw e;
        } finally {
            try {
                if (table != null) {
                    table.close();
                }
            } catch (IOException e) {
                log.error(e.getMessage(), e);
            }
        }
    }


    /**
     * 向指定的行、列簇、列写入一项数据；如果该行不存在，则会插入一行。
     *
     * @param tableName 表名
     * @param hbCell    存放行键、列簇、列名、列值的数据单元
     * @throws Exception
     */
    public void putData(String tableName, HbaseCell hbCell) throws Exception {
        HTableInterface table = null;
        try {
            //table = new HTable(conf, tableName);
            table = conn.getTable(tableName);
            Put put = new Put(convertToBytes(hbCell.getRowkey()));

            // 参数分别为：列族、列、值
            put.add(Bytes.toBytes(hbCell.getColFamily()), Bytes.toBytes(hbCell.getColName()), convertToBytes(hbCell.getColValue()));

            table.put(put);
            log.info("成功写入1项数据到{}.", tableName);

        } catch (IOException e) {
            log.error(e.getMessage(), e);
            throw e;
        } finally {
            try {
                if (table != null) {
                    table.close();
                }
            } catch (IOException e) {
                log.error(e.getMessage(), e);
            }
        }
    }


    /**
     * 写入多行、多列数据
     *
     * @param tableName  表名
     * @param hbCellList 存放行键、列簇、列名、列值的数据单元.
     * @throws Exception
     */
    public void putData(String tableName, List<HbaseCell> hbCellList) throws Exception {
        if (hbCellList.isEmpty()) {
            return;
        }
        HTableInterface table = null;
        try {
            //table = new HTable(conf, tableName);
            table = conn.getTable(tableName);

            List<Put> putList = new ArrayList<Put>();
            for (HbaseCell hbCell : hbCellList) {
                Put put = new Put(convertToBytes(hbCell.getRowkey()));
                put.add(Bytes.toBytes(hbCell.getColFamily()), Bytes.toBytes(hbCell.getColName()), convertToBytes(hbCell.getColValue()));

                putList.add(put);
            }

            table.put(putList);
            log.info("成功写入{}项数据到{}.", hbCellList.size(), tableName);

        } catch (IOException e) {
            log.error(e.getMessage(), e);
            throw e;
        } finally {
            try {
                if (table != null) {
                    table.close();
                }
            } catch (IOException e) {
                log.error(e.getMessage(), e);
            }
        }
    }

    /**
     * 写入多行、多列数据
     *
     * @param tableName  表名
     * @param hbCellList 存放行键、列簇、列名、列值的数据单元.
     * @throws Exception
     */
    public void putDataForNotNull(String tableName, List<HbaseCell> hbCellList) throws Exception {
        if (hbCellList.isEmpty()) {
            return;
        }
        HTableInterface table = null;
        try {
            //table = new HTable(conf, tableName);
            table = conn.getTable(tableName);

            List<Put> putList = new ArrayList<Put>();
            for (HbaseCell hbCell : hbCellList) {
                if (!StringUtils.isEmpty(hbCell.getColValue() + "")) {
                    Put put = new Put(convertToBytes(hbCell.getRowkey()));
                    put.add(Bytes.toBytes(hbCell.getColFamily()), Bytes.toBytes(hbCell.getColName()), convertToBytes(hbCell.getColValue()));
                    putList.add(put);
                }
            }
            table.put(putList);
            log.info("成功写入{}项数据到{}.", hbCellList.size(), tableName);

        } catch (IOException e) {
            log.error(e.getMessage(), e);
            throw e;
        } finally {
            try {
                if (table != null) {
                    table.close();
                }
            } catch (IOException e) {
                log.error(e.getMessage(), e);
            }
        }
    }

    /**
     * 删除一行
     *
     * @param tableName 表名
     * @param rowkey    行键
     * @throws Exception
     */

    public void delRow(String tableName, String rowkey) throws Exception {
        HTableInterface table = null;
        try {
            //table = new HTable(conf, tableName);
            table = conn.getTable(tableName);
            Delete del = new Delete(Bytes.toBytes(rowkey));

            table.delete(del);
            log.info("成功删除1行数据!");

        } catch (IOException e) {
            log.error(e.getMessage(), e);
            throw e;
        } finally {
            try {
                if (table != null) {
                    table.close();
                }
            } catch (IOException e) {
                log.error(e.getMessage(), e);
            }
        }
    }


    /**
     * 删除多行
     *
     * @param tableName 表名
     * @param rowkeys   行键
     * @throws Exception
     */
    public void delMulitRows(String tableName, List<String> rowkeys) throws Exception {
        HTableInterface table = null;
        try {
            //table = new HTable(conf, tableName);
            table = conn.getTable(tableName);

            List<Delete> delList = new ArrayList<Delete>();
            for (String rowkey : rowkeys) {
                Delete del = new Delete(Bytes.toBytes(rowkey));
                delList.add(del);
            }
            table.delete(delList);
            delList.clear();
            log.info("成功删除{}行数据.", delList.size());

        } catch (IOException e) {
            log.error(e.getMessage(), e);
            throw e;
        } finally {
            try {
                if (table != null) {
                    table.close();
                }
            } catch (IOException e) {
                log.error(e.getMessage(), e);
            }
        }
    }


    /**
     * 获取指定行的所有数据项
     *
     * @param tableName 表名
     * @param rowkey    行键
     * @return
     * @throws Exception
     */
    public Result getRow(String tableName, String rowkey) throws Exception {
        HTableInterface table = null;
        try {
            //table = new HTable(conf, tableName);
            table = conn.getTable(tableName);

            Get get = new Get(Bytes.toBytes(rowkey));
            Result rs = table.get(get);

//            for (Cell cell : result.rawCells()) {
//                System.out.print("Row Name: " + new String(CellUtil.cloneRow(cell)) + " ");
//                System.out.print("Timestamp: " + cell.getTimestamp() + " ");
//                System.out.print("column Family: " + new String(CellUtil.cloneFamily(cell)) + " ");
//                System.out.print("column Name:  " + new String(CellUtil.cloneQualifier(cell)) + " ");
//                System.out.println("Value: " + new String(CellUtil.cloneValue(cell)) + " ");
//            }

            return rs;

        } catch (IOException e) {
            log.error(e.getMessage(), e);
            throw e;
        } finally {
            try {
                if (table != null) {
                    table.close();
                }
            } catch (IOException e) {
                log.error(e.getMessage(), e);
            }
        }
    }


    /**
     * 获取指定表的所有行的数据项
     *
     * @param tableName 表名
     * @return
     * @throws Exception
     */
    public List<Result> findAllRows(String tableName) throws Exception {
        HTableInterface table = null;
        try {
            //table = new HTable(conf, tableName);
            table = conn.getTable(tableName);

            Scan scan = new Scan();
            ResultScanner results = table.getScanner(scan);

            List<Result> rsList = new ArrayList<Result>();
            for (Result rs : results) {
                rsList.add(rs);
            }
            return rsList;

        } catch (IOException e) {
            log.error(e.getMessage(), e);
            throw e;
        } finally {
            try {
                if (table != null) {
                    table.close();
                }
            } catch (IOException e) {
                log.error(e.getMessage(), e);
            }
        }
    }


    /**
     * 通用查询
     *
     * @param tableName 表名
     * @param filter    查询过滤器。单一条件查询可传Filter对象，组合条件查询可传FilterList, FilterList是Filter的子类。
     */
    public List<Result> findRow(String tableName, Filter filter) throws Exception {
        HTableInterface table = null;
        try {
            //table = new HTable(conf, tableName);
            table = conn.getTable(tableName);

            Scan scan = new Scan();
            scan.setFilter(filter);
            ResultScanner results = table.getScanner(scan);

            List<Result> rsList = new ArrayList<Result>();
            for (Result rs : results) {
                rsList.add(rs);
            }
            return rsList;

        } catch (IOException e) {
            log.error(e.getMessage(), e);
            throw e;
        } finally {
            try {
                if (table != null) {
                    table.close();
                }
            } catch (IOException e) {
                log.error(e.getMessage(), e);
            }
        }
    }


    /**
     * 打印、展示查询结果
     *
     * @param result
     */
    public void showData(Result result) {

        for (Cell cell : result.rawCells()) {
            log.info("Row: " + new String(CellUtil.cloneRow(cell)) + " ");
            log.info("Timestamp: " + cell.getTimestamp() + " ");
            log.info("Column Family: " + new String(CellUtil.cloneFamily(cell)) + " ");
            log.info("Column Name:  " + new String(CellUtil.cloneQualifier(cell)) + " ");
            log.info("Column Value: " + new String(CellUtil.cloneValue(cell)) + " ");
        }

    }

    /**
     * 打印、展示查询的各项列值
     *
     * @param rsList
     */
    public void showData(List<Result> rsList) {
        log.info(">>>总的数据条数：" + rsList.size());

        if (rsList.isEmpty()) {
            return;
        }
        for (Result rs : rsList) {
            Cell[] cells = rs.rawCells();
            for (Cell cell : rs.rawCells()) {
                log.info("Row: " + new String(CellUtil.cloneRow(cell)) + " ");
                log.info("Timestamp: " + cell.getTimestamp() + " ");
                log.info("Column Family: " + new String(CellUtil.cloneFamily(cell)) + " ");
                log.info("Column Name:  " + new String(CellUtil.cloneQualifier(cell)) + " ");
                log.info("Column Value: " + new String(CellUtil.cloneValue(cell)) + " ");
            }
        }
    }


    /**
     * 打印、展示查询的各项列值
     *
     * @param rsList
     */
    public void showRowkey(List<Result> rsList) {
        log.info(">>>总的数据条数：" + rsList.size());

        if (rsList.isEmpty()) {
            return;
        }
        for (Result rs : rsList) {
            log.info(new String(rs.getRow()));
        }
    }

    private byte[] convertToBytes(Object obj) throws Exception {
        if (obj == null) {
            return new byte[0];
        }
        if (obj instanceof String) {
            return Bytes.toBytes((String) obj);
        }
        if (obj instanceof Double) {
            return Bytes.toBytes((Double) obj);
        }
        if (obj instanceof Float) {
            return Bytes.toBytes((Float) obj);
        }
        if (obj instanceof Long) {
            return Bytes.toBytes((Long) obj);
        }
        if (obj instanceof Integer) {
            return Bytes.toBytes((Integer) obj);
        }
        if (obj instanceof Date) {
            return Bytes.toBytes(((Date) obj).getTime());
        }
        if (obj instanceof Timestamp) {
            return Bytes.toBytes(((Timestamp) obj).getTime());
        }
        if (obj instanceof BigDecimal) {
            return Bytes.toBytes((BigDecimal) obj);
        }
        throw new Exception("未能识别的数据类型: " + obj.getClass().getName());
    }


    // main
    public static void main(String[] args) {
        try {
        	HbaseUtil client = new HbaseUtil();

            String tableName = "testtable";

            // 创建数据库表：“studyinfo”
            String[] colFamilys = {"studyinfo", "course"};
            client.createTable(tableName, colFamilys);

            // 添加第一行数据
            client.putData(tableName, "ligan", "studyinfo", "age", "2333");
            client.putData(tableName, "ligan", "studyinfo", "sex", "boy");
            client.putData(tableName, "ligan", "course", "china", "97");
            client.putData(tableName, "ligan", "course", "math", "128");
            client.putData(tableName, "ligan", "course", "english", "85");

            // 添加第二行数据
            client.putData(tableName, "xiaoxue", "studyinfo", "age", "20");
            client.putData(tableName, "xiaoxue", "studyinfo", "sex", "boy");
            client.putData(tableName, "xiaoxue", "course", "china", "90");
            client.putData(tableName, "xiaoxue", "course", "math", "100");
            client.putData(tableName, "xiaoxue", "course", "english", "90");

            // 添加第三行数据，也可以这样写:
            HbaseCell hbCell1 = new HbaseCell("walker", "studyinfo", "age", "18");
            HbaseCell hbCell2 = new HbaseCell("walker", "studyinfo", "sex", "girl");
            HbaseCell hbCell3 = new HbaseCell("walker", "course", "math", "100");
            HbaseCell hbCell4 = new HbaseCell("walker", "course", "english", "30");
            List<HbaseCell> cellList = new ArrayList<HbaseCell>();
            cellList.add(hbCell1);
            cellList.add(hbCell2);
            cellList.add(hbCell3);
            cellList.add(hbCell4);
            client.putData(tableName, cellList);


            // 获取一条数据
            log.info("获取一条数据");
            Result rs = client.getRow(tableName, "ligan");
            client.showData(rs);


            //组合查询
            log.info("组合查询");
            List<Filter> filters = new ArrayList<Filter>();
            Filter filter1 = new SingleColumnValueFilter(Bytes
                    .toBytes("studyinfo"), Bytes.toBytes("age"), CompareFilter.CompareOp.GREATER, Bytes
                    .toBytes("18"));
            filters.add(filter1);

            Filter filter2 = new SingleColumnValueFilter(Bytes
                    .toBytes("course"), Bytes.toBytes("math"), CompareFilter.CompareOp.EQUAL, Bytes
                    .toBytes("100"));
            filters.add(filter2);

            FilterList filterList = new FilterList(filters);

            List<Result> rsList = client.findRow(tableName, filterList);
            log.info(">>>" + rsList.size());


            // 获取所有数据
            log.info("获取所有数据");
            rsList = client.findAllRows(tableName);
            log.info(">>>" + rsList.size());

            //删除一条数据
            log.info("删除一条数据");
            client.delRow(tableName, "tht");
            log.info(">>>" + rsList.size());

            //删除多条数据
            log.info("删除多条数据");
            List<String> rows = new ArrayList<String>();
            rows.add("xiaoxue");
            rows.add("walker");
            client.delMulitRows(tableName, rows);
            client.findAllRows(tableName);
            log.info(">>>" + rsList.size());


            //删除数据库
            log.info("删除表");
            client.deleteTable(tableName);


        } catch (Exception err) {
            err.printStackTrace();
        }
    }

}

11、mongodb处理工具 

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;
import org.bson.Document;

import com.alibaba.fastjson.JSONObject;
import com.github.walker.mybatis.paginator.PageList;
import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.Mongo;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;


public class MongoManager {
	
	 
	    private static MongoClient  client = null;  
	  
	    private MongoManager() 
	    { 
	    	
	    }  
	  
	    static {  
	        initDBPrompties();  
	    }  
	  	  
	    /** 
	     * 初始化连接池 
	     */  
	    private static void initDBPrompties() {  	    	    		
	    	 String url=PropertyHolder.getProperty("mongodb.url");
	    	 String dbName=PropertyHolder.getProperty("mongodb.dbName"); 
	    	 String userName=PropertyHolder.getProperty("mongodb.userName");
	    	 String password=PropertyHolder.getProperty("mongodb.password");
	    	 int connectionsPerHost = Integer.valueOf(PropertyHolder.getProperty("mongodb.connectionsPerHost"));
	    	 int threads = Integer.valueOf(PropertyHolder.getProperty("mongodb.threads"));
	    	 int maxWaitTime=Integer.valueOf(PropertyHolder.getProperty("mongodb.maxWaitTime"));
	    	 int socketTimeout=Integer.valueOf(PropertyHolder.getProperty("mongodb.socketTimeout"));
	    	 int maxConnectionLifeTime=Integer.valueOf(PropertyHolder.getProperty("mongodb.maxConnectionLifeTime"));
	    	 int connectTimeout = Integer.valueOf(PropertyHolder.getProperty("mongodb.connectTimeout"));
	    	 
	    	 List<MongoCredential> credentials = new ArrayList<MongoCredential>();
	    	 ServerAddress address = new ServerAddress(url);
	    	 MongoCredential credential = MongoCredential.createCredential(userName,dbName,password.toCharArray());
			 credentials.add(credential);
	    	 
	    	 MongoClientOptions.Builder build = new MongoClientOptions.Builder();  	         
	         build.connectionsPerHost(connectionsPerHost);
	         build.maxWaitTime(maxWaitTime);
	         build.maxConnectionLifeTime(maxConnectionLifeTime);
	         build.connectTimeout(connectTimeout);
	         build.threadsAllowedToBlockForConnectionMultiplier(threads);
	         build.socketTimeout(socketTimeout);
	         MongoClientOptions options = build.build();  
	         client = new MongoClient(address, credentials, options);  
	    }  
	    
	    /**
	     * 获取数据库
	     * @param dbName 数据库
	     * @return
	     */
		public static MongoDatabase getDB(String dbName) {  
	        return client.getDatabase(dbName);
	    }
	    
	    /**
	     * 获取表
	     * @param dbName 数据库
	     * @param collectionName 集合
	     * @return
	     */
	    public static MongoCollection<Document>  getCollection(String dbName,String collectionName)
	    {
	    	 MongoCollection<Document>  collection = getDB(dbName).getCollection(collectionName);
	    	 return collection;
	    }
	    
	    /**
	     * 插入表数据
	     * @param dbName 数据库
	     * @param collectionName 集合
	     * @param json 待入库json
	     */
	    public static void insert(String dbName,String collectionName,String json)
	    {
	    	MongoCollection<Document> collection = getCollection(dbName, collectionName);
	        Document document = Document.parse(json);
	    	collection.insertOne(document);
	    }
	    
	    /**
	     * 分页查询用户操作日志
	     * @param dbName 数据库
	     * @param collectionName 集合
	     * @param acctNo 账户号
	     * @param start 
	     * @param pageSize
	     * @return
	     */
	    public static PageList<UserOpLog> findUserOpLog(String dbName,String collectionName,String acctNo,String tenantId,String keyWord,String startDate,String endDate,int start,int pageSize)
	    {   
	    	List<UserOpLog> logList = new ArrayList<UserOpLog>();
	    	MongoCollection<Document> collection = getCollection(dbName, collectionName);
	        BasicDBObject queryObject = new BasicDBObject();
	        BasicDBObject tmpObject = new BasicDBObject();
	        BasicDBObject dateObject = new BasicDBObject();	       
	        if(StringUtils.isNotEmpty(acctNo))
	        {   
	        	
	        	queryObject.put("acctNo", acctNo);		        
	        }
	        if(tenantId!=null)
	        {
	        	queryObject.put("tenantId", tenantId);		        
	        }
	        if(StringUtils.isNotEmpty(keyWord))
	        {   
	        	Pattern pattern = Pattern.compile("^.*"+keyWord+".*$", Pattern.CASE_INSENSITIVE);
	        	queryObject.put("opDesc", pattern);		        
	        }
	        
	        tmpObject.put("$gte", startDate); //大于
	        dateObject = tmpObject.append("$lte", endDate);	//小于      	               	        
	        queryObject.put("opTime", dateObject);	      
	        FindIterable<Document> iterator= collection.find(queryObject).sort((new BasicDBObject("opTime",-1)));		       
	        int count = 0;
	        MongoCursor<Document> cursor= iterator.iterator();
	        while(cursor.hasNext()) { 
	        	Document doc = cursor.next();
	        	if(count>=start && count<=pageSize+start-1)
	        	{	        		
	                UserOpLog userOpLog = new UserOpLog();
	                userOpLog.setAcctNo(doc.getString("acctNo"));
	                userOpLog.setClasz(doc.getString("clasz"));
	                userOpLog.setErrorMsg(doc.getString("errorMsg"));
	                userOpLog.setMethod(doc.getString("method"));
	                userOpLog.setName(doc.getString("name"));
	                userOpLog.setOpDesc(doc.getString("opDesc"));
	                userOpLog.setOpResult(doc.getInteger("opResult"));
	                userOpLog.setOpTime(doc.getString("opTime"));
	                userOpLog.setUri(doc.getString("uri"));
	                userOpLog.setTenantId(doc.getString("tenantId"));
	                logList.add(userOpLog);
	        	}
                count++;
            }  
	        cursor.close();
	        PageList<UserOpLog> pageList = new PageList<UserOpLog>(logList,count);
	        return pageList;	        
	    }
	    
	    /**
	     * 分页查询接口调用日志
	     * @param dbName 数据库
	     * @param collectionName 集合
	     * @param tenantId 商户ID
	     * @param appId 应用ID
	     * @param startDate 开始日期
	     * @param endDate 结束日期
	     * @param start
	     * @param pageSize
	     * @return
	     */
	    public static PageList<UserCallLog> findUserCallLog(String dbName,String collectionName,String tenantId,String appId,String startDate,String endDate,int start,int pageSize)
	    {   
	    	List<UserCallLog> logList = new ArrayList<UserCallLog>();
	    	MongoCollection<Document> collection = getCollection(dbName, collectionName);
	        BasicDBObject queryObject = new BasicDBObject();
	        BasicDBObject tmpObject = new BasicDBObject();
	        BasicDBObject dateObject = new BasicDBObject();	       
	        if(StringUtils.isNotEmpty(tenantId))
	        {
	        	queryObject.put("tenantId", tenantId);	
	        	
	        }
	        if(StringUtils.isNotEmpty(appId))
	        {
	        	queryObject.put("appId", appId);		        
	        }	       
	        
	        tmpObject.put("$gte", startDate); //大于
	        dateObject = tmpObject.append("$lte", endDate);	//小于      	               	        
	        queryObject.put("reqTime", dateObject);	      
	        FindIterable<Document> iterator= collection.find(queryObject) ;		       
	        int count = 0;
	        MongoCursor<Document> cursor= iterator.iterator();
	        while(cursor.hasNext()) { 
	        	Document doc = cursor.next();
	        	if(count>=start && count<=pageSize+start-1)
	        	{	        		
	        		UserCallLog userCallLog = new UserCallLog();
	        		userCallLog.setAppId(doc.getString("appId"));
	                userCallLog.setClientHost(doc.getString("clientHost"));
	                userCallLog.setClientIp(doc.getString("clientIp"));
	                userCallLog.setClientPort(doc.getInteger("clientPort"));
	                userCallLog.setErrorCode(doc.getString("errorCode"));
	                userCallLog.setErrorMsg(doc.getString("errorMsg"));
	                userCallLog.setFlowNo(doc.getString("flowNo"));
	                userCallLog.setInterfaceClasz(doc.getString("interfaceClasz"));
	                userCallLog.setInterfaceId(doc.getString("interfaceId"));
	                userCallLog.setMethodId(doc.getString("methodId"));
	                userCallLog.setMethodName(doc.getString("methodName"));
	                userCallLog.setReqBytes(doc.getInteger("reqBytes"));
	                userCallLog.setReqTime(doc.getString("reqTime"));
	                userCallLog.setResBytes(doc.getInteger("resBytes"));
	                userCallLog.setResTime(doc.getString("resTime"));
	                userCallLog.setSvcId(doc.getString("svcId"));
	                userCallLog.setSvcInterface(doc.getString("svcInterface"));
	                userCallLog.setTenantId(doc.getString("tenantId"));
	                userCallLog.setToken(doc.getString("token"));
	                userCallLog.setUri(doc.getString("uri"));
	                logList.add(userCallLog);
	        	}
                count++;
            }  
	        cursor.close();
	        PageList<UserCallLog> pageList = new PageList<UserCallLog>(logList,count);
	        return pageList;	        
	    }
	    
	   
}

12、redis处理工具

  1. import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
  2. import org.slf4j.Logger;
  3. import org.slf4j.LoggerFactory;
  5. import redis.clients.jedis.Jedis;
  6. import redis.clients.jedis.JedisPool;
  8. import java.util.Map;
  9. import java.util.Properties;
  10. import java.util.concurrent.Executors;
  11. import java.util.concurrent.ScheduledExecutorService;
  12. import java.util.concurrent.TimeUnit;
  15. public class QCloudJedis {
  17. private static final Logger log = LoggerFactory.getLogger(QCloudJedis.class);
  19. private static final Properties properties = ClassesConfigLoader.getProperties();
  20. private static final String host = properties.getProperty( "redis.host");
  21. private static final int port = Integer.valueOf(properties.getProperty( "redis.port"));
  22. private static final String instanceid = properties.getProperty( "redis.instanceid");
  23. private static final String password = properties.getProperty( "redis.password");
  24. private static final int timeout = Integer.valueOf(properties.getProperty( "redis.timeout", "2000"));
  25. private static final int maxTotal = Integer.valueOf(properties.getProperty( "redis.maxTotal", "1024"));
  26. private static final int maxIdle = Integer.valueOf(properties.getProperty( "redis.maxIdle", "10"));
  27. private static final int maxWaitMillis = Integer.valueOf(properties.getProperty( "redis.maxWaitMillis", "3000"));
  28. private static final boolean testOnIdle = Boolean.valueOf(properties.getProperty( "redis.testOnIdle", "true")); //是否checkIdle
  29. private static final int timeCheckIdle = Integer.valueOf(properties.getProperty( "redis.timeCheckIdle", "60000")); //每隔多少秒check一次
  30. private static final int idleTimeout = Integer.valueOf(properties.getProperty( "redis.idleTimeout", "300000")); //超时时间
  31. private static final int numTestsPerEvictionRun = Integer.valueOf(properties.getProperty( "redis.numTestsPerEvictionRun", "1024")); //一次驱逐过程中，最多驱逐对象的个数
  33. private static JedisPool pool = null;
  34. //private static Jedis jedis = null;
  35. private static Object lock = new Object();
  38. static {
  39. init();
  40. }
  42. private static void init() {
  43. if ( null == pool) {
  44. GenericObjectPoolConfig config = new GenericObjectPoolConfig();
  45. config.setMaxTotal(maxTotal);
  46. config.setMaxIdle(maxIdle);
  47. config.setMaxWaitMillis(maxWaitMillis);
  49. config.setTestWhileIdle(testOnIdle);
  50. config.setTimeBetweenEvictionRunsMillis(timeCheckIdle);
  51. config.setMinEvictableIdleTimeMillis(idleTimeout);
  52. config.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
  53. synchronized (lock) {
  54. if ( null == pool) {
  55. try {
  57. pool = new JedisPool(config, host, port, timeout, instanceid + ":" + password);
  58. log.info( "init jedis pool successful!");
  59. } catch (Exception e) {
  60. log.error( "", e);
  61. }
  62. }
  63. }
  64. }
  66. }
  68. // public static Jedis getInstance() {
  69. // init();
  70. //
  71. // return jedis;
  72. // }
  74. /**
  75. * 获取一个jedis 对象
  76. *
  77. * @return
  78. */
  79. private static Jedis getJedis() {
  80. if (pool == null) {
  81. init();
  82. }
  83. return pool.getResource();
  84. }
  86. /**
  87. * 返还到连接池
  88. *
  89. * @param pool
  90. * @param redis
  91. */
  92. private static void returnResource(Jedis redis) {
  93. if (redis != null) {
  94. redis.close();
  95. }
  96. }
  98. // 删除key
  99. public static Long del(String key) {
  100. Jedis jedis = null;
  101. try {
  102. jedis = getJedis();
  103. return jedis.del(key);
  104. } catch (Exception e) {
  105. log.error( "操作Redis发生异常，异常详情：", e);
  106. return - 1L;
  107. } finally {
  108. // 返还到连接池
  109. returnResource(jedis);
  110. }
  112. }
  114. public static Boolean exists(String key) {
  115. Jedis jedis = null;
  116. Boolean flag = false;
  117. try {
  118. jedis = getJedis();
  119. flag = jedis.exists(key);
  120. } catch (Exception e) {
  121. log.error( "操作Redis发生异常，异常详情：", e);
  122. } finally {
  123. // 返还到连接池
  124. returnResource(jedis);
  125. }
  127. return flag;
  128. }
  130. /**
  131. * 获取数据
  132. *
  133. * @param key
  134. * @return
  135. */
  136. public static String get(String key) {
  137. String value = null;
  138. Jedis jedis = null;
  139. try {
  140. jedis = getJedis();
  141. value = jedis.get(key);
  142. } catch (Exception e) {
  143. log.error( "操作Redis发生异常，异常详情：", e);
  144. } finally {
  145. // 返还到连接池
  146. returnResource(jedis);
  147. }
  148. return value;
  149. }
  151. // 设置
  152. public static String set(String key, String value) {
  153. Jedis jedis = null;
  154. try {
  155. jedis = getJedis();
  156. return jedis.set(key, value);
  157. } catch (Exception e) {
  158. log.error( "操作Redis发生异常，异常详情：", e);
  159. return "";
  160. } finally {
  161. // 返还到连接池
  162. returnResource(jedis);
  163. }
  164. }
  166. // 获取Hash值
  167. public static String hget(String key, String field) {
  168. Jedis jedis = null;
  169. String value = null;
  170. try {
  171. jedis = getJedis();
  172. value = jedis.hget(key, field);
  173. } catch (Exception e) {
  174. log.error( "操作Redis发生异常，异常详情：", e);
  175. } finally {
  176. // 返还到连接池
  177. returnResource(jedis);
  178. }
  179. return value;
  180. }
  182. public static Map<String, String> hgetAll(String key) {
  183. Jedis jedis = null;
  184. Map<String, String> value = null;
  185. try {
  186. jedis = getJedis();
  187. value = jedis.hgetAll(key);
  188. } catch (Exception e) {
  189. log.error( "操作Redis发生异常，异常详情：", e);
  190. } finally {
  191. // 返还到连接池
  192. returnResource(jedis);
  193. }
  194. return value;
  195. }
  197. // 设置Hash值
  198. public static Long hset(String key, String field, String value) {
  199. Jedis jedis = null;
  200. try {
  201. jedis = getJedis();
  202. return jedis.hset(key, field, value);
  203. } catch (Exception e) {
  204. log.error( "操作Redis发生异常，异常详情：", e);
  205. return - 1L;
  206. } finally {
  207. // 返还到连接池
  208. returnResource(jedis);
  209. }
  210. }
  212. // 删除Hash值
  213. public static Long hdel(String key, String... fields) {
  214. Jedis jedis = null;
  215. try {
  216. jedis = getJedis();
  217. return jedis.hdel(key, fields);
  218. } catch (Exception e) {
  219. log.error( "操作Redis发生异常，异常详情：", e);
  220. return - 1L;
  221. } finally {
  222. // 返还到连接池
  223. returnResource(jedis);
  224. }
  225. }
  227. public static Long expire(String key, int seconds) {
  228. Jedis jedis = null;
  229. try {
  230. jedis = getJedis();
  231. return jedis.expire(key, seconds);
  232. } catch (Exception e) {
  233. log.error( "操作Redis发生异常，异常详情：", e);
  234. return - 1L;
  235. } finally {
  236. // 返还到连接池
  237. returnResource(jedis);
  238. }
  239. }
  241. public static void main(String[] args) {
  242. try {
  244. while ( true) {
  245. String key = "ftc-ump-mid";
  246. //System.out.println("before setting: " + jedis.hget(key, "attr"));
  247. System.out.println( ">>" + QCloudJedis.hset(key, "attr", "0"));
  248. QCloudJedis.expire(key, 5);
  250. System.out.println( "after setting: " + QCloudJedis.hget(key, "attr"));
  251. System.out.println( ">>" + QCloudJedis.hdel(key, "attr"));
  253. System.out.println( "after delete: " + QCloudJedis.hget(key, "attr"));
  255. Thread.sleep( 1000 * 10);
  256. }
  259. //关闭退出
  260. //jedis.quit();
  261. //jedis.close();
  264. } catch (Exception e) {
  265. e.printStackTrace();
  266. }
  267. }
  268. }



猜你喜欢

转载自blog.csdn.net/qq_28817739/article/details/80900481
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
记一下去大梅沙的准备（2018-05-26）
Spring 注解 事务
基于HTTP协议的客户端缓存
阿里云rds 备份和还原
[PHP] 几个拖慢 PHP 程序/API 运行速度的点
python 代码风格------------PEP8规则
js控制json生成菜单——自制菜单（一）
将字符串: 'k:1|k1:2|k2:3|k3:4 ' ,处理成 python 字典: {'k':1, 'k1':2, ...}
微信小程序转支付宝小程序
Qt551.窗口滚动条
每日归档
更多
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022