Java常用公共工具记录

电玩女神 2021-09-12 07:16 462阅读 0赞

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处理工具

  1. import java.io.File;
  2. import java.io.FileInputStream;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileOutputStream;
  5. import java.util.List;
  6. import java.util.Vector;
  8. import org.slf4j.Logger;
  9. import org.slf4j.LoggerFactory;
  11. import com.jcraft.jsch.Channel;
  12. import com.jcraft.jsch.ChannelSftp;
  13. import com.jcraft.jsch.ChannelSftp.LsEntry;
  14. import com.jcraft.jsch.JSch;
  15. import com.jcraft.jsch.JSchException;
  16. import com.jcraft.jsch.Session;
  17. import com.jcraft.jsch.SftpException;
  18. import com.lz.lsf.exception.BusinessException;
  20. /**
  21.  * 
  22.  * 功能概要：SFTP客户端
  23.  * 
  24.  * @author linbingwen
  25.  * @since  2015年8月5日
  26.  */
  27. public class SftpClient {
  29.     private String m_host = "127.0.0.1";
  31.     private int m_port = 22;
  33.     private String m_username = "ctsUser";
  35.     private String m_password = "ctsUser";
  37.     private Logger logger = LoggerFactory.getLogger(this.getClass());
  39.     private Channel m_channel = null;
  41.     public SftpClient(String host, int Port, String userName, String password) {
  42.         this.m_host = host;
  43.         this.m_port = Port;
  44.         this.m_username = userName;
  45.         this.m_password = password;
  46.     }
  48.     public void reConnect() {
  49.         try {
  50.             this.connect();
  51.         }
  52.         catch (Exception e) {
  53.             logger.warn("m_channel disconnect fail!", e);
  54.         }
  55.     }
  57.     public void connect() {
  58.         JSch jsch = new JSch();
  59.         try {
  60.             jsch.getSession(m_username, m_host, m_port);
  61.             Session sshSession = jsch.getSession(m_username, m_host, m_port);
  62.             logger.info("username:" + m_username + ", host:" + m_host + ",port:" + m_port);
  63.             java.util.Properties config = new java.util.Properties();
  64.             config.put("StrictHostKeyChecking", "no");
  65.             sshSession.setConfig(config);
  66.             logger.debug("StrictHostKeyChecking", "no");
  67.             sshSession.setPassword(m_password);
  68.             sshSession.connect();
  69.             logger.debug("Session connected.");
  70.             m_channel = sshSession.openChannel("sftp");
  71.             logger.debug("Opening Channel.");
  72.             m_channel.connect();
  73.             logger.info("Connected to {} success! ", m_host);
  74.         }
  75.         catch (JSchException e) {
  76.             logger.error("connected to " + m_host + "Fail! ");
  77.             throw new BusinessException(CommonErrorCode.ERROR_CONNECT_SFTP_FAIL, e, "connected to " + m_host + "Fail! ");
  78.         }
  79.     }
  81.     public void disConnect() {
  82.         try {
  83.             if (m_channel == null)
  84.                 return;
  86.             synchronized (m_channel) {
  87.                 if (m_channel.getSession().isConnected())
  88.                     m_channel.getSession().disconnect();
  89.             }
  91.             m_channel.disconnect();
  93.         }
  94.         catch (JSchException e) {
  95.             logger.warn("m_channel disconnect fail!", e);
  96.         }
  97.         finally {
  98.             if (m_channel != null)
  99.                 m_channel = null;
  100.         }
  101.     }
  103.     public boolean isTryConnect() {
  104.         int tryConnectCount = 0;
  105.         try {
  106.             while (true) {
  107.                 tryConnectCount++;
  108.                 if (m_channel.getSession().isConnected())
  109.                     return true;
  110.                 else {
  111.                     if (tryConnectCount >= 3)
  112.                         return false;
  113.                     else {
  114.                         this.reConnect();
  115.                     }
  116.                 }
  117.             }
  118.         }
  119.         catch (JSchException e) {
  120.             logger.warn("m_channel isConnected fail!", e);
  121.             return false;
  122.         }
  123.     }
  125.     /**
  126.      * 上传文件
  127.      * 
  128.      * @param directoryName
  129.      *            上传的目录
  130.      * @param uploadFileName
  131.      *            要上传的文件
  132.      * @param sftp
  133.      * @throws SftpException
  134.      * @throws FileNotFoundException
  135.      * @throws JSchException
  136.      */
  137.     public void upload(String remotePathDirName, String uploadFileName) {
  138.         ChannelSftp sftp = (ChannelSftp) m_channel;
  139.         if (!this.isTryConnect()) {
  140.             logger.error("尝试连接SFTP服务器失败！");
  141.            throw new BusinessException(CommonErrorCode.ERROR_CONNECT_SFTP_FAIL);
  142.         }
  143.         try {
  144.             sftp.cd(remotePathDirName);
  145.             File uploadFile = new File(uploadFileName);
  146.             sftp.put(new FileInputStream(uploadFile), uploadFile.getName());
  147.             logger.debug("Upload file:{} to remote dir:{}", uploadFileName, remotePathDirName);
  148.         }
  149.         catch (FileNotFoundException e) {
  150.             logger.error("download remote path({})FileNotFound{}", remotePathDirName, uploadFileName);
  151.             throw new BusinessException(CommonErrorCode.NOT_EXISTS_PATH_SFTP_REMOTE, e, "FileNotFound:" + uploadFileName);
  152.         }
  153.         catch (SftpException e) {
  154.             logger.error("download remote path({}) not exists!{}", remotePathDirName, e);
  155.             throw new BusinessException(CommonErrorCode.NOT_EXISTS_PATH_SFTP_REMOTE, e, "remote path:" + remotePathDirName);
  156.         }
  157.     }
  159.     public void uploadBatch(String directoryName, List<String> fileNameList) {
  160.         for (String fileName : fileNameList) {
  161.             this.upload(directoryName, fileName);
  162.         }
  163.     }
  165.     /**
  166.      * 下载文件
  167.      * 
  168.      * @param directoryName
  169.      *            下载目录
  170.      * @param downloadFileName
  171.      *            下载的文件
  172.      * @param saveFileName
  173.      *            存在本地的路径
  174.      * @param sftp
  175.      * @throws SftpException
  176.      * @throws FileNotFoundException
  177.      * @throws JSchException
  178.      */
  179.     public void download(String remotePathDirName, String localPathDirName, String downloadFileName) {
  180.         ChannelSftp sftp = (ChannelSftp) m_channel;
  181.         if (!this.isTryConnect()) {
  182.             logger.error("尝试连接SFTP服务器失败！");
  183.           //  throw new BusinessException(ActErrorCode.ERROR_CONNECT_SFTP_FAIL);
  184.         }
  185.         try {
  186.             sftp.cd(remotePathDirName);
  187.             File saveFile = new File(localPathDirName + "//" + downloadFileName);
  188.             sftp.get(downloadFileName, new FileOutputStream(saveFile));
  189.             logger.debug("Download file:{} save as {}", downloadFileName, localPathDirName + "//" + downloadFileName);
  190.         }
  191.         catch (FileNotFoundException e) {
  192.             e.printStackTrace();
  193.             logger.error("download remote path{}//{}", remotePathDirName, downloadFileName);
  194.             throw new BusinessException(CommonErrorCode.NOT_FINDFIELS_REMOTE_PATH, e, "FileNotFound:" + downloadFileName);
  195.         }
  196.         catch (SftpException e) {
  197.             logger.error("download remote path({}) fail!{}", remotePathDirName + downloadFileName, e);
  198.             throw new BusinessException(CommonErrorCode.NOT_EXISTS_PATH_SFTP_REMOTE, e, "remote path:" + remotePathDirName);
  199.         }
  200.     }
  202.     public void downloadBatch(String directoryName, String localPathDirName, List<String> downloadFileNameList) {
  203.         for (String fileName : downloadFileNameList) {
  204.             this.download(directoryName, localPathDirName, fileName);
  205.         }
  206.     }
  208.     public boolean isFileExists(String remotePathDirName) {
  209.         ChannelSftp sftp = (ChannelSftp) m_channel;
  210.         if (!this.isTryConnect()) {
  211.             logger.error("尝试连接SFTP服务器失败！");
  212.             throw new BusinessException(CommonErrorCode.ERROR_CONNECT_SFTP_FAIL);
  213.         }
  214.         try {
  215.             Vector<LsEntry> filesName = sftp.ls(remotePathDirName);
  216.             return filesName.size() > 0;
  217.         }
  218.         catch (SftpException e) {
  219.             logger.warn("download remote path({}) not exists!{}", remotePathDirName, e);
  220.             return false;
  221.         }
  222.     }
  224.     /**
  225.      * 删除文件
  226.      * 
  227.      * @param directory
  228.      *            要删除文件所在目录
  229.      * @param deleteFileName
  230.      *            要删除的文件
  231.      * @param sftp
  232.      * @throws SftpException
  233.      * @throws JSchException
  234.      */
  235.     public void delete(String directory, String deleteFileName) throws SftpException, JSchException {
  236.         ChannelSftp sftp = (ChannelSftp) m_channel;
  237.         if (!this.isTryConnect()) {
  238.             logger.error("尝试连接SFTP服务器失败！");
  239.            throw new BusinessException(CommonErrorCode.ERROR_CONNECT_SFTP_FAIL);
  240.         }
  241.         sftp.cd(directory);
  242.         sftp.rm(deleteFileName);
  243.         logger.info("Delete file:{} from remote dir:{}", deleteFileName, directory);
  244.     }
  246.     /**
  247.      * 列出目录下的文件
  248.      * 
  249.      * @param directoryName
  250.      *            要列出的目录
  251.      * @param sftp
  252.      * @return
  253.      * @throws SftpException
  254.      * @throws JSchException
  255.      */
  256.     @SuppressWarnings("unchecked")
  257.     public Vector<LsEntry> listFiles(String directoryName) throws SftpException, JSchException {
  258.         ChannelSftp sftp = (ChannelSftp) m_channel;
  259.         if (!this.isTryConnect()) {
  260.             logger.error("尝试连接SFTP服务器失败！");
  261.            throw new BusinessException(CommonErrorCode.ERROR_CONNECT_SFTP_FAIL);
  262.         }
  263.         Vector<LsEntry> filesName = sftp.ls(directoryName);
  264.         return filesName;
  265.     }
  267.     /**
  268.      * 列出目录下符合要求的文件
  269.      * 
  270.      * @param directoryName
  271.      *            要列出的目录
  272.      * @param reg
  273.      *            文件名前缀
  274.      * @param postfix
  275.      *            文件名后缀(格式)
  276.      * @return
  277.      * @throws SftpException
  278.      * @throws JSchException
  279.      */
  280.     @SuppressWarnings("unchecked")
  281.     public Vector<LsEntry> listFiles(String remotePathDirName, String reg, String postfix) {
  282.         ChannelSftp sftp = (ChannelSftp) m_channel;
  283.         if (!this.isTryConnect()) {
  284.             logger.error("尝试连接SFTP服务器失败！");
  285.            throw new BusinessException(CommonErrorCode.ERROR_CONNECT_SFTP_FAIL);
  286.         }
  287.         Vector<LsEntry> filesName;
  288.         try {
  289.             filesName = sftp.ls(remotePathDirName);
  290.             Vector<LsEntry> filterFilesName = new Vector<LsEntry>();
  291.             for (LsEntry lsEntry : filesName) {
  292.                 if (lsEntry.getFilename().indexOf(reg) > -1 && lsEntry.getFilename().endsWith(postfix)) {
  293.                     filterFilesName.add(lsEntry);
  294.                 }
  295.             }
  296.             return filterFilesName;
  297.         }
  298.         catch (SftpException e) {
  299.             logger.error("download remote path({}) not exists!{}", remotePathDirName, e);
  300.             throw new BusinessException(CommonErrorCode.NOT_EXISTS_PATH_SFTP_REMOTE, e, "remote path" + remotePathDirName);
  301.         }
  303.     }
  305. }

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处理工具

  1. import org.apache.commons.lang.StringUtils;
  2. import org.apache.hadoop.conf.Configuration;
  3. import org.apache.hadoop.hbase.*;
  4. import org.apache.hadoop.hbase.client.*;
  5. import org.apache.hadoop.hbase.filter.CompareFilter;
  6. import org.apache.hadoop.hbase.filter.Filter;
  7. import org.apache.hadoop.hbase.filter.FilterList;
  8. import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
  9. import org.apache.hadoop.hbase.util.Bytes;
  10. import org.slf4j.Logger;
  11. import org.slf4j.LoggerFactory;
  13. import java.io.File;
  14. import java.io.IOException;
  15. import java.math.BigDecimal;
  16. import java.sql.Timestamp;
  17. import java.util.ArrayList;
  18. import java.util.Date;
  19. import java.util.List;
  22. /**
  23.  * 操作Hbase的常用方法
  24.  * <p/>
  25.  * Created by huqingmiao on 2015/4/14.
  26.  */
  27. public class HbaseUtil {
  29.     private static final Logger log = LoggerFactory.getLogger(HbaseUtil.class);
  31.     private static Configuration conf = null;
  33.     private static HConnection conn = null;
  35.     private static String HADOOP_HOME = "C:/hadoop";
  37.     static {
  39. //        try {
  40. //            String hadoopHome = System.getProperties().getProperty("hadoop.home.dir"); //Windows下的HOME目录， 在unix下部署不需要设置
  41. //            if (hadoopHome == null || "".equals(hadoopHome.trim())) {
  42. //                hadoopHome = HADOOP_HOME;
  43. //            }
  44. //
  45. //            File hadoopBinDir = new File(hadoopHome, "bin");      //HOME目录下的bin目录
  46. //            if (!hadoopBinDir.exists()) {
  47. //                hadoopBinDir.mkdirs();
  48. //            }
  49. //            File winExeFile = new File(hadoopBinDir.getCanonicalPath() + File.separator + "winutils.exe");
  50. //            if (!winExeFile.exists()) {
  51. //                winExeFile.createNewFile();
  52. //            }
  53. //
  54. //            //设置环境变量
  55. //            System.getProperties().put("hadoop.home.dir", hadoopHome);
  56. //
  57. //        } catch (IOException e) {
  58. //            log.error("create ./bin/winutils.exe error.", e);
  59. //        }
  61.         //默认从hbase-site.xml读取配置信息
  62.         conf = HBaseConfiguration.create();
  63. //        conf.set("hbase.zookeeper.property.clientPort", "2181");
  64. //        conf.set("hbase.zookeeper.quorum", "10.75.201.125");
  65. //        conf.set("hbase.master", "10.75.201.125:60010");
  66.         //conf.set("hbase.zookeeper.quorum", "hmaster");
  67.         //与hbase/conf/hbase-site.xml中hbase.zookeeper.property.clientPort配置的值相同
  68.       //  conf.set("hbase.zookeeper.property.clientPort", "2181");
  69.     }
  72.     public HbaseUtil() {
  73.         try {
  74.             //预先创建了一个连接，以后的访问都共享该连接
  75.             //conf.addResource("hbase-site.xml");
  76.             conn = HConnectionManager.createConnection(conf);
  77.         } catch (Exception e) {
  78.             log.error(e.getMessage(), e);
  79.         }
  80.     }
  82.     @Override
  83.     public void finalize() throws Throwable {
  84.         try {
  85.             if (conn != null && !conn.isClosed()) {
  86.                 conn.close();
  87.             }
  88.         } catch (Exception e) {
  89.             log.error(e.getMessage(), e);
  90.         }
  91.         super.finalize();
  92.     }
  95.     /**
  96.      * 建表
  97.      *
  98.      * @param tableName     表名
  99.      * @param columnFamilys 列簇名
  100.      * @throws Exception
  101.      */
  102.     public void createTable(String tableName, String[] columnFamilys) throws Exception {
  103.         HBaseAdmin hAdmin = null;
  104.         try {
  105.             hAdmin = new HBaseAdmin(conf);
  107.             if (hAdmin.tableExists(tableName)) {
  108.                 log.info("已经存在要创建的表:" + tableName);
  110.             } else {
  111.                 HTableDescriptor tableDesc = new HTableDescriptor(TableName.valueOf(tableName));
  113.                 //描述列族
  114.                 for (String columnFamily : columnFamilys) {
  115.                     tableDesc.addFamily(new HColumnDescriptor(columnFamily));
  116.                 }
  118.                 //建表
  119.                 hAdmin.createTable(tableDesc);
  120.                 log.info("成功创建表:" + tableName);
  121.             }
  122.         } catch (IOException e) {
  123.             log.error(e.getMessage(), e);
  124.             throw e;
  125.         } finally {
  126.             try {
  127.                 if (hAdmin != null) {
  128.                     hAdmin.close();
  129.                 }
  130.             } catch (IOException e) {
  131.                 log.error(e.getMessage(), e);
  132.             }
  133.         }
  134.     }
  137.     /**
  138.      * 删除表
  139.      *
  140.      * @param tableName 表名
  141.      * @throws Exception
  142.      */
  143.     public void deleteTable(String tableName) throws Exception {
  144.         HBaseAdmin hAdmin = null;
  145.         try {
  146.             hAdmin = new HBaseAdmin(conf);
  148.             if (hAdmin.tableExists(tableName)) {
  149.                 hAdmin.disableTable(tableName);//禁用表
  150.                 hAdmin.deleteTable(tableName);// 删除表
  151.                 log.info("成功删除表:" + tableName);
  153.             } else {
  154.                 log.info("要删除的表不存在:" + tableName);
  155.             }
  157.         } catch (IOException e) {
  158.             log.error(e.getMessage(), e);
  159.             throw e;
  160.         } finally {
  161.             try {
  162.                 if (hAdmin != null) {
  163.                     hAdmin.close();
  164.                 }
  165.             } catch (IOException e) {
  166.                 log.error(e.getMessage(), e);
  167.             }
  168.         }
  169.     }
  172.     /**
  173.      * 向指定的行、列簇、列写入一项数据；如果该行不存在，则会插入一行。
  174.      *
  175.      * @param tableName 表名
  176.      * @param rowkey    行键
  177.      * @param colFamily 列簇名
  178.      * @param column    列名
  179.      * @param value     列值
  180.      * @throws Exception
  181.      */
  182.     public void putData(String tableName, String rowkey,
  183.                         String colFamily, String column, String value) throws Exception {
  185.         HTableInterface table = null;
  186.         try {
  187.             //table = new HTable(conf, tableName);
  188.             table = conn.getTable(tableName);
  189.             Put put = new Put(Bytes.toBytes(rowkey));
  191.             // 参数分别为：列族、列、值
  192.             put.add(Bytes.toBytes(colFamily), Bytes.toBytes(column), Bytes.toBytes(value));
  194.             table.put(put);
  195.             log.info("成功写入1项数据到{}.", tableName);
  197.         } catch (IOException e) {
  198.             log.error(e.getMessage(), e);
  199.             throw e;
  200.         } finally {
  201.             try {
  202.                 if (table != null) {
  203.                     table.close();
  204.                 }
  205.             } catch (IOException e) {
  206.                 log.error(e.getMessage(), e);
  207.             }
  208.         }
  209.     }
  212.     /**
  213.      * 向指定的行、列簇、列写入一项数据；如果该行不存在，则会插入一行。
  214.      *
  215.      * @param tableName 表名
  216.      * @param hbCell    存放行键、列簇、列名、列值的数据单元
  217.      * @throws Exception
  218.      */
  219.     public void putData(String tableName, HbaseCell hbCell) throws Exception {
  220.         HTableInterface table = null;
  221.         try {
  222.             //table = new HTable(conf, tableName);
  223.             table = conn.getTable(tableName);
  224.             Put put = new Put(convertToBytes(hbCell.getRowkey()));
  226.             // 参数分别为：列族、列、值
  227.             put.add(Bytes.toBytes(hbCell.getColFamily()), Bytes.toBytes(hbCell.getColName()), convertToBytes(hbCell.getColValue()));
  229.             table.put(put);
  230.             log.info("成功写入1项数据到{}.", tableName);
  232.         } catch (IOException e) {
  233.             log.error(e.getMessage(), e);
  234.             throw e;
  235.         } finally {
  236.             try {
  237.                 if (table != null) {
  238.                     table.close();
  239.                 }
  240.             } catch (IOException e) {
  241.                 log.error(e.getMessage(), e);
  242.             }
  243.         }
  244.     }
  247.     /**
  248.      * 写入多行、多列数据
  249.      *
  250.      * @param tableName  表名
  251.      * @param hbCellList 存放行键、列簇、列名、列值的数据单元.
  252.      * @throws Exception
  253.      */
  254.     public void putData(String tableName, List<HbaseCell> hbCellList) throws Exception {
  255.         if (hbCellList.isEmpty()) {
  256.             return;
  257.         }
  258.         HTableInterface table = null;
  259.         try {
  260.             //table = new HTable(conf, tableName);
  261.             table = conn.getTable(tableName);
  263.             List<Put> putList = new ArrayList<Put>();
  264.             for (HbaseCell hbCell : hbCellList) {
  265.                 Put put = new Put(convertToBytes(hbCell.getRowkey()));
  266.                 put.add(Bytes.toBytes(hbCell.getColFamily()), Bytes.toBytes(hbCell.getColName()), convertToBytes(hbCell.getColValue()));
  268.                 putList.add(put);
  269.             }
  271.             table.put(putList);
  272.             log.info("成功写入{}项数据到{}.", hbCellList.size(), tableName);
  274.         } catch (IOException e) {
  275.             log.error(e.getMessage(), e);
  276.             throw e;
  277.         } finally {
  278.             try {
  279.                 if (table != null) {
  280.                     table.close();
  281.                 }
  282.             } catch (IOException e) {
  283.                 log.error(e.getMessage(), e);
  284.             }
  285.         }
  286.     }
  288.     /**
  289.      * 写入多行、多列数据
  290.      *
  291.      * @param tableName  表名
  292.      * @param hbCellList 存放行键、列簇、列名、列值的数据单元.
  293.      * @throws Exception
  294.      */
  295.     public void putDataForNotNull(String tableName, List<HbaseCell> hbCellList) throws Exception {
  296.         if (hbCellList.isEmpty()) {
  297.             return;
  298.         }
  299.         HTableInterface table = null;
  300.         try {
  301.             //table = new HTable(conf, tableName);
  302.             table = conn.getTable(tableName);
  304.             List<Put> putList = new ArrayList<Put>();
  305.             for (HbaseCell hbCell : hbCellList) {
  306.                 if (!StringUtils.isEmpty(hbCell.getColValue() + "")) {
  307.                     Put put = new Put(convertToBytes(hbCell.getRowkey()));
  308.                     put.add(Bytes.toBytes(hbCell.getColFamily()), Bytes.toBytes(hbCell.getColName()), convertToBytes(hbCell.getColValue()));
  309.                     putList.add(put);
  310.                 }
  311.             }
  312.             table.put(putList);
  313.             log.info("成功写入{}项数据到{}.", hbCellList.size(), tableName);
  315.         } catch (IOException e) {
  316.             log.error(e.getMessage(), e);
  317.             throw e;
  318.         } finally {
  319.             try {
  320.                 if (table != null) {
  321.                     table.close();
  322.                 }
  323.             } catch (IOException e) {
  324.                 log.error(e.getMessage(), e);
  325.             }
  326.         }
  327.     }
  329.     /**
  330.      * 删除一行
  331.      *
  332.      * @param tableName 表名
  333.      * @param rowkey    行键
  334.      * @throws Exception
  335.      */
  337.     public void delRow(String tableName, String rowkey) throws Exception {
  338.         HTableInterface table = null;
  339.         try {
  340.             //table = new HTable(conf, tableName);
  341.             table = conn.getTable(tableName);
  342.             Delete del = new Delete(Bytes.toBytes(rowkey));
  344.             table.delete(del);
  345.             log.info("成功删除1行数据!");
  347.         } catch (IOException e) {
  348.             log.error(e.getMessage(), e);
  349.             throw e;
  350.         } finally {
  351.             try {
  352.                 if (table != null) {
  353.                     table.close();
  354.                 }
  355.             } catch (IOException e) {
  356.                 log.error(e.getMessage(), e);
  357.             }
  358.         }
  359.     }
  362.     /**
  363.      * 删除多行
  364.      *
  365.      * @param tableName 表名
  366.      * @param rowkeys   行键
  367.      * @throws Exception
  368.      */
  369.     public void delMulitRows(String tableName, List<String> rowkeys) throws Exception {
  370.         HTableInterface table = null;
  371.         try {
  372.             //table = new HTable(conf, tableName);
  373.             table = conn.getTable(tableName);
  375.             List<Delete> delList = new ArrayList<Delete>();
  376.             for (String rowkey : rowkeys) {
  377.                 Delete del = new Delete(Bytes.toBytes(rowkey));
  378.                 delList.add(del);
  379.             }
  380.             table.delete(delList);
  381.             delList.clear();
  382.             log.info("成功删除{}行数据.", delList.size());
  384.         } catch (IOException e) {
  385.             log.error(e.getMessage(), e);
  386.             throw e;
  387.         } finally {
  388.             try {
  389.                 if (table != null) {
  390.                     table.close();
  391.                 }
  392.             } catch (IOException e) {
  393.                 log.error(e.getMessage(), e);
  394.             }
  395.         }
  396.     }
  399.     /**
  400.      * 获取指定行的所有数据项
  401.      *
  402.      * @param tableName 表名
  403.      * @param rowkey    行键
  404.      * @return
  405.      * @throws Exception
  406.      */
  407.     public Result getRow(String tableName, String rowkey) throws Exception {
  408.         HTableInterface table = null;
  409.         try {
  410.             //table = new HTable(conf, tableName);
  411.             table = conn.getTable(tableName);
  413.             Get get = new Get(Bytes.toBytes(rowkey));
  414.             Result rs = table.get(get);
  416. //            for (Cell cell : result.rawCells()) {
  417. //                System.out.print("Row Name: " + new String(CellUtil.cloneRow(cell)) + " ");
  418. //                System.out.print("Timestamp: " + cell.getTimestamp() + " ");
  419. //                System.out.print("column Family: " + new String(CellUtil.cloneFamily(cell)) + " ");
  420. //                System.out.print("column Name:  " + new String(CellUtil.cloneQualifier(cell)) + " ");
  421. //                System.out.println("Value: " + new String(CellUtil.cloneValue(cell)) + " ");
  422. //            }
  424.             return rs;
  426.         } catch (IOException e) {
  427.             log.error(e.getMessage(), e);
  428.             throw e;
  429.         } finally {
  430.             try {
  431.                 if (table != null) {
  432.                     table.close();
  433.                 }
  434.             } catch (IOException e) {
  435.                 log.error(e.getMessage(), e);
  436.             }
  437.         }
  438.     }
  441.     /**
  442.      * 获取指定表的所有行的数据项
  443.      *
  444.      * @param tableName 表名
  445.      * @return
  446.      * @throws Exception
  447.      */
  448.     public List<Result> findAllRows(String tableName) throws Exception {
  449.         HTableInterface table = null;
  450.         try {
  451.             //table = new HTable(conf, tableName);
  452.             table = conn.getTable(tableName);
  454.             Scan scan = new Scan();
  455.             ResultScanner results = table.getScanner(scan);
  457.             List<Result> rsList = new ArrayList<Result>();
  458.             for (Result rs : results) {
  459.                 rsList.add(rs);
  460.             }
  461.             return rsList;
  463.         } catch (IOException e) {
  464.             log.error(e.getMessage(), e);
  465.             throw e;
  466.         } finally {
  467.             try {
  468.                 if (table != null) {
  469.                     table.close();
  470.                 }
  471.             } catch (IOException e) {
  472.                 log.error(e.getMessage(), e);
  473.             }
  474.         }
  475.     }
  478.     /**
  479.      * 通用查询
  480.      *
  481.      * @param tableName 表名
  482.      * @param filter    查询过滤器。单一条件查询可传Filter对象，组合条件查询可传FilterList, FilterList是Filter的子类。
  483.      */
  484.     public List<Result> findRow(String tableName, Filter filter) throws Exception {
  485.         HTableInterface table = null;
  486.         try {
  487.             //table = new HTable(conf, tableName);
  488.             table = conn.getTable(tableName);
  490.             Scan scan = new Scan();
  491.             scan.setFilter(filter);
  492.             ResultScanner results = table.getScanner(scan);
  494.             List<Result> rsList = new ArrayList<Result>();
  495.             for (Result rs : results) {
  496.                 rsList.add(rs);
  497.             }
  498.             return rsList;
  500.         } catch (IOException e) {
  501.             log.error(e.getMessage(), e);
  502.             throw e;
  503.         } finally {
  504.             try {
  505.                 if (table != null) {
  506.                     table.close();
  507.                 }
  508.             } catch (IOException e) {
  509.                 log.error(e.getMessage(), e);
  510.             }
  511.         }
  512.     }
  515.     /**
  516.      * 打印、展示查询结果
  517.      *
  518.      * @param result
  519.      */
  520.     public void showData(Result result) {
  522.         for (Cell cell : result.rawCells()) {
  523.             log.info("Row: " + new String(CellUtil.cloneRow(cell)) + " ");
  524.             log.info("Timestamp: " + cell.getTimestamp() + " ");
  525.             log.info("Column Family: " + new String(CellUtil.cloneFamily(cell)) + " ");
  526.             log.info("Column Name:  " + new String(CellUtil.cloneQualifier(cell)) + " ");
  527.             log.info("Column Value: " + new String(CellUtil.cloneValue(cell)) + " ");
  528.         }
  530.     }
  532.     /**
  533.      * 打印、展示查询的各项列值
  534.      *
  535.      * @param rsList
  536.      */
  537.     public void showData(List<Result> rsList) {
  538.         log.info(">>>总的数据条数：" + rsList.size());
  540.         if (rsList.isEmpty()) {
  541.             return;
  542.         }
  543.         for (Result rs : rsList) {
  544.             Cell[] cells = rs.rawCells();
  545.             for (Cell cell : rs.rawCells()) {
  546.                 log.info("Row: " + new String(CellUtil.cloneRow(cell)) + " ");
  547.                 log.info("Timestamp: " + cell.getTimestamp() + " ");
  548.                 log.info("Column Family: " + new String(CellUtil.cloneFamily(cell)) + " ");
  549.                 log.info("Column Name:  " + new String(CellUtil.cloneQualifier(cell)) + " ");
  550.                 log.info("Column Value: " + new String(CellUtil.cloneValue(cell)) + " ");
  551.             }
  552.         }
  553.     }
  556.     /**
  557.      * 打印、展示查询的各项列值
  558.      *
  559.      * @param rsList
  560.      */
  561.     public void showRowkey(List<Result> rsList) {
  562.         log.info(">>>总的数据条数：" + rsList.size());
  564.         if (rsList.isEmpty()) {
  565.             return;
  566.         }
  567.         for (Result rs : rsList) {
  568.             log.info(new String(rs.getRow()));
  569.         }
  570.     }
  572.     private byte[] convertToBytes(Object obj) throws Exception {
  573.         if (obj == null) {
  574.             return new byte[0];
  575.         }
  576.         if (obj instanceof String) {
  577.             return Bytes.toBytes((String) obj);
  578.         }
  579.         if (obj instanceof Double) {
  580.             return Bytes.toBytes((Double) obj);
  581.         }
  582.         if (obj instanceof Float) {
  583.             return Bytes.toBytes((Float) obj);
  584.         }
  585.         if (obj instanceof Long) {
  586.             return Bytes.toBytes((Long) obj);
  587.         }
  588.         if (obj instanceof Integer) {
  589.             return Bytes.toBytes((Integer) obj);
  590.         }
  591.         if (obj instanceof Date) {
  592.             return Bytes.toBytes(((Date) obj).getTime());
  593.         }
  594.         if (obj instanceof Timestamp) {
  595.             return Bytes.toBytes(((Timestamp) obj).getTime());
  596.         }
  597.         if (obj instanceof BigDecimal) {
  598.             return Bytes.toBytes((BigDecimal) obj);
  599.         }
  600.         throw new Exception("未能识别的数据类型: " + obj.getClass().getName());
  601.     }
  604.     // main
  605.     public static void main(String[] args) {
  606.         try {
  607.             HbaseUtil client = new HbaseUtil();
  609.             String tableName = "testtable";
  611.             // 创建数据库表：“studyinfo”
  612.             String[] colFamilys = {"studyinfo", "course"};
  613.             client.createTable(tableName, colFamilys);
  615.             // 添加第一行数据
  616.             client.putData(tableName, "ligan", "studyinfo", "age", "2333");
  617.             client.putData(tableName, "ligan", "studyinfo", "sex", "boy");
  618.             client.putData(tableName, "ligan", "course", "china", "97");
  619.             client.putData(tableName, "ligan", "course", "math", "128");
  620.             client.putData(tableName, "ligan", "course", "english", "85");
  622.             // 添加第二行数据
  623.             client.putData(tableName, "xiaoxue", "studyinfo", "age", "20");
  624.             client.putData(tableName, "xiaoxue", "studyinfo", "sex", "boy");
  625.             client.putData(tableName, "xiaoxue", "course", "china", "90");
  626.             client.putData(tableName, "xiaoxue", "course", "math", "100");
  627.             client.putData(tableName, "xiaoxue", "course", "english", "90");
  629.             // 添加第三行数据，也可以这样写:
  630.             HbaseCell hbCell1 = new HbaseCell("walker", "studyinfo", "age", "18");
  631.             HbaseCell hbCell2 = new HbaseCell("walker", "studyinfo", "sex", "girl");
  632.             HbaseCell hbCell3 = new HbaseCell("walker", "course", "math", "100");
  633.             HbaseCell hbCell4 = new HbaseCell("walker", "course", "english", "30");
  634.             List<HbaseCell> cellList = new ArrayList<HbaseCell>();
  635.             cellList.add(hbCell1);
  636.             cellList.add(hbCell2);
  637.             cellList.add(hbCell3);
  638.             cellList.add(hbCell4);
  639.             client.putData(tableName, cellList);
  642.             // 获取一条数据
  643.             log.info("获取一条数据");
  644.             Result rs = client.getRow(tableName, "ligan");
  645.             client.showData(rs);
  648.             //组合查询
  649.             log.info("组合查询");
  650.             List<Filter> filters = new ArrayList<Filter>();
  651.             Filter filter1 = new SingleColumnValueFilter(Bytes
  652.                     .toBytes("studyinfo"), Bytes.toBytes("age"), CompareFilter.CompareOp.GREATER, Bytes
  653.                     .toBytes("18"));
  654.             filters.add(filter1);
  656.             Filter filter2 = new SingleColumnValueFilter(Bytes
  657.                     .toBytes("course"), Bytes.toBytes("math"), CompareFilter.CompareOp.EQUAL, Bytes
  658.                     .toBytes("100"));
  659.             filters.add(filter2);
  661.             FilterList filterList = new FilterList(filters);
  663.             List<Result> rsList = client.findRow(tableName, filterList);
  664.             log.info(">>>" + rsList.size());
  667.             // 获取所有数据
  668.             log.info("获取所有数据");
  669.             rsList = client.findAllRows(tableName);
  670.             log.info(">>>" + rsList.size());
  672.             //删除一条数据
  673.             log.info("删除一条数据");
  674.             client.delRow(tableName, "tht");
  675.             log.info(">>>" + rsList.size());
  677.             //删除多条数据
  678.             log.info("删除多条数据");
  679.             List<String> rows = new ArrayList<String>();
  680.             rows.add("xiaoxue");
  681.             rows.add("walker");
  682.             client.delMulitRows(tableName, rows);
  683.             client.findAllRows(tableName);
  684.             log.info(">>>" + rsList.size());
  687.             //删除数据库
  688.             log.info("删除表");
  689.             client.deleteTable(tableName);
  692.         } catch (Exception err) {
  693.             err.printStackTrace();
  694.         }
  695.     }
  697. }

11、mongodb处理工具

  1. import java.util.ArrayList;
  2. import java.util.Date;
  3. import java.util.List;
  4. import java.util.regex.Pattern;
  6. import org.apache.commons.lang.StringUtils;
  7. import org.bson.Document;
  9. import com.alibaba.fastjson.JSONObject;
  10. import com.github.walker.mybatis.paginator.PageList;
  11. import com.mongodb.BasicDBObject;
  12. import com.mongodb.DB;
  13. import com.mongodb.DBCollection;
  14. import com.mongodb.DBCursor;
  15. import com.mongodb.Mongo;
  16. import com.mongodb.MongoClient;
  17. import com.mongodb.MongoClientOptions;
  18. import com.mongodb.MongoCredential;
  19. import com.mongodb.ServerAddress;
  20. import com.mongodb.client.FindIterable;
  21. import com.mongodb.client.MongoCollection;
  22. import com.mongodb.client.MongoCursor;
  23. import com.mongodb.client.MongoDatabase;
  26. public class MongoManager {
  29.         private static MongoClient  client = null;  
  31.         private MongoManager() 
  32.         { 
  34.         }  
  36.         static {  
  37.             initDBPrompties();  
  38.         }  
  40.         /** 
  41.          * 初始化连接池 
  42.          */  
  43.         private static void initDBPrompties() {                          
  44.              String url=PropertyHolder.getProperty("mongodb.url");
  45.              String dbName=PropertyHolder.getProperty("mongodb.dbName"); 
  46.              String userName=PropertyHolder.getProperty("mongodb.userName");
  47.              String password=PropertyHolder.getProperty("mongodb.password");
  48.              int connectionsPerHost = Integer.valueOf(PropertyHolder.getProperty("mongodb.connectionsPerHost"));
  49.              int threads = Integer.valueOf(PropertyHolder.getProperty("mongodb.threads"));
  50.              int maxWaitTime=Integer.valueOf(PropertyHolder.getProperty("mongodb.maxWaitTime"));
  51.              int socketTimeout=Integer.valueOf(PropertyHolder.getProperty("mongodb.socketTimeout"));
  52.              int maxConnectionLifeTime=Integer.valueOf(PropertyHolder.getProperty("mongodb.maxConnectionLifeTime"));
  53.              int connectTimeout = Integer.valueOf(PropertyHolder.getProperty("mongodb.connectTimeout"));
  55.              List<MongoCredential> credentials = new ArrayList<MongoCredential>();
  56.              ServerAddress address = new ServerAddress(url);
  57.              MongoCredential credential = MongoCredential.createCredential(userName,dbName,password.toCharArray());
  58.              credentials.add(credential);
  60.              MongoClientOptions.Builder build = new MongoClientOptions.Builder();               
  61.              build.connectionsPerHost(connectionsPerHost);
  62.              build.maxWaitTime(maxWaitTime);
  63.              build.maxConnectionLifeTime(maxConnectionLifeTime);
  64.              build.connectTimeout(connectTimeout);
  65.              build.threadsAllowedToBlockForConnectionMultiplier(threads);
  66.              build.socketTimeout(socketTimeout);
  67.              MongoClientOptions options = build.build();  
  68.              client = new MongoClient(address, credentials, options);  
  69.         }  
  71.         /**
  72.          * 获取数据库
  73.          * @param dbName 数据库
  74.          * @return
  75.          */
  76.         public static MongoDatabase getDB(String dbName) {  
  77.             return client.getDatabase(dbName);
  78.         }
  80.         /**
  81.          * 获取表
  82.          * @param dbName 数据库
  83.          * @param collectionName 集合
  84.          * @return
  85.          */
  86.         public static MongoCollection<Document>  getCollection(String dbName,String collectionName)
  87.         {
  88.              MongoCollection<Document>  collection = getDB(dbName).getCollection(collectionName);
  89.              return collection;
  90.         }
  92.         /**
  93.          * 插入表数据
  94.          * @param dbName 数据库
  95.          * @param collectionName 集合
  96.          * @param json 待入库json
  97.          */
  98.         public static void insert(String dbName,String collectionName,String json)
  99.         {
  100.             MongoCollection<Document> collection = getCollection(dbName, collectionName);
  101.             Document document = Document.parse(json);
  102.             collection.insertOne(document);
  103.         }
  105.         /**
  106.          * 分页查询用户操作日志
  107.          * @param dbName 数据库
  108.          * @param collectionName 集合
  109.          * @param acctNo 账户号
  110.          * @param start 
  111.          * @param pageSize
  112.          * @return
  113.          */
  114.         public static PageList<UserOpLog> findUserOpLog(String dbName,String collectionName,String acctNo,String tenantId,String keyWord,String startDate,String endDate,int start,int pageSize)
  115.         {   
  116.             List<UserOpLog> logList = new ArrayList<UserOpLog>();
  117.             MongoCollection<Document> collection = getCollection(dbName, collectionName);
  118.             BasicDBObject queryObject = new BasicDBObject();
  119.             BasicDBObject tmpObject = new BasicDBObject();
  120.             BasicDBObject dateObject = new BasicDBObject();           
  121.             if(StringUtils.isNotEmpty(acctNo))
  122.             {   
  124.                 queryObject.put("acctNo", acctNo);                
  125.             }
  126.             if(tenantId!=null)
  127.             {
  128.                 queryObject.put("tenantId", tenantId);                
  129.             }
  130.             if(StringUtils.isNotEmpty(keyWord))
  131.             {   
  132.                 Pattern pattern = Pattern.compile("^.*"+keyWord+".*$", Pattern.CASE_INSENSITIVE);
  133.                 queryObject.put("opDesc", pattern);                
  134.             }
  136.             tmpObject.put("$gte", startDate); //大于
  137.             dateObject = tmpObject.append("$lte", endDate);    //小于                                     
  138.             queryObject.put("opTime", dateObject);          
  139.             FindIterable<Document> iterator= collection.find(queryObject).sort((new BasicDBObject("opTime",-1)));               
  140.             int count = 0;
  141.             MongoCursor<Document> cursor= iterator.iterator();
  142.             while(cursor.hasNext()) { 
  143.                 Document doc = cursor.next();
  144.                 if(count>=start && count<=pageSize+start-1)
  145.                 {                    
  146.                     UserOpLog userOpLog = new UserOpLog();
  147.                     userOpLog.setAcctNo(doc.getString("acctNo"));
  148.                     userOpLog.setClasz(doc.getString("clasz"));
  149.                     userOpLog.setErrorMsg(doc.getString("errorMsg"));
  150.                     userOpLog.setMethod(doc.getString("method"));
  151.                     userOpLog.setName(doc.getString("name"));
  152.                     userOpLog.setOpDesc(doc.getString("opDesc"));
  153.                     userOpLog.setOpResult(doc.getInteger("opResult"));
  154.                     userOpLog.setOpTime(doc.getString("opTime"));
  155.                     userOpLog.setUri(doc.getString("uri"));
  156.                     userOpLog.setTenantId(doc.getString("tenantId"));
  157.                     logList.add(userOpLog);
  158.                 }
  159.                 count++;
  160.             }  
  161.             cursor.close();
  162.             PageList<UserOpLog> pageList = new PageList<UserOpLog>(logList,count);
  163.             return pageList;            
  164.         }
  166.         /**
  167.          * 分页查询接口调用日志
  168.          * @param dbName 数据库
  169.          * @param collectionName 集合
  170.          * @param tenantId 商户ID
  171.          * @param appId 应用ID
  172.          * @param startDate 开始日期
  173.          * @param endDate 结束日期
  174.          * @param start
  175.          * @param pageSize
  176.          * @return
  177.          */
  178.         public static PageList<UserCallLog> findUserCallLog(String dbName,String collectionName,String tenantId,String appId,String startDate,String endDate,int start,int pageSize)
  179.         {   
  180.             List<UserCallLog> logList = new ArrayList<UserCallLog>();
  181.             MongoCollection<Document> collection = getCollection(dbName, collectionName);
  182.             BasicDBObject queryObject = new BasicDBObject();
  183.             BasicDBObject tmpObject = new BasicDBObject();
  184.             BasicDBObject dateObject = new BasicDBObject();           
  185.             if(StringUtils.isNotEmpty(tenantId))
  186.             {
  187.                 queryObject.put("tenantId", tenantId);    
  189.             }
  190.             if(StringUtils.isNotEmpty(appId))
  191.             {
  192.                 queryObject.put("appId", appId);                
  193.             }           
  195.             tmpObject.put("$gte", startDate); //大于
  196.             dateObject = tmpObject.append("$lte", endDate);    //小于                                     
  197.             queryObject.put("reqTime", dateObject);          
  198.             FindIterable<Document> iterator= collection.find(queryObject) ;               
  199.             int count = 0;
  200.             MongoCursor<Document> cursor= iterator.iterator();
  201.             while(cursor.hasNext()) { 
  202.                 Document doc = cursor.next();
  203.                 if(count>=start && count<=pageSize+start-1)
  204.                 {                    
  205.                     UserCallLog userCallLog = new UserCallLog();
  206.                     userCallLog.setAppId(doc.getString("appId"));
  207.                     userCallLog.setClientHost(doc.getString("clientHost"));
  208.                     userCallLog.setClientIp(doc.getString("clientIp"));
  209.                     userCallLog.setClientPort(doc.getInteger("clientPort"));
  210.                     userCallLog.setErrorCode(doc.getString("errorCode"));
  211.                     userCallLog.setErrorMsg(doc.getString("errorMsg"));
  212.                     userCallLog.setFlowNo(doc.getString("flowNo"));
  213.                     userCallLog.setInterfaceClasz(doc.getString("interfaceClasz"));
  214.                     userCallLog.setInterfaceId(doc.getString("interfaceId"));
  215.                     userCallLog.setMethodId(doc.getString("methodId"));
  216.                     userCallLog.setMethodName(doc.getString("methodName"));
  217.                     userCallLog.setReqBytes(doc.getInteger("reqBytes"));
  218.                     userCallLog.setReqTime(doc.getString("reqTime"));
  219.                     userCallLog.setResBytes(doc.getInteger("resBytes"));
  220.                     userCallLog.setResTime(doc.getString("resTime"));
  221.                     userCallLog.setSvcId(doc.getString("svcId"));
  222.                     userCallLog.setSvcInterface(doc.getString("svcInterface"));
  223.                     userCallLog.setTenantId(doc.getString("tenantId"));
  224.                     userCallLog.setToken(doc.getString("token"));
  225.                     userCallLog.setUri(doc.getString("uri"));
  226.                     logList.add(userCallLog);
  227.                 }
  228.                 count++;
  229.             }  
  230.             cursor.close();
  231.             PageList<UserCallLog> pageList = new PageList<UserCallLog>(logList,count);
  232.             return pageList;            
  233.         }
  236. }

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. }

发表评论

表情：
评论列表 （有 0 条评论，462人围观）

还没有评论，来说两句吧...

相关阅读