DateUtils

代码：

  1. import org.joda.time.DateTime;
  2. import org.joda.time.Duration;
  3. import org.joda.time.format.DateTimeFormat;
  4. import org.joda.time.format.DateTimeFormatter;
  6. /**
  7.  * @author miaohuanju001
  8.  * @date 2021-06-18
  9.  * @description
  10.  */
  11. public class DateUtils {
  13.     public static final String DATE_PATTERN_1 = "yyyy-MM-dd";
  14.     public static final String DATE_PATTERN_2 = "yyyy-MM-dd HH:mm:ss";
  15.     public static final String DATE_PATTERN_3 = "yyyyMMdd";
  16.     public static final int WHOLE_DAY_MILLIS = 24 * 60 * 60 * 1000;
  17.     public static final int WHOLE_DAY_SECONDS = 24 * 60 * 60;
  19.     /**
  20.      * 获取当前时间戳
  21.      */
  22.     public static long getCurrentTimestamp() {
  23.         return System.currentTimeMillis();
  24.     }
  26.     /**
  27.      * 获取当前日期的格式化形式
  28.      * @param pattern "yyyy-MM-dd" / "yyyy-MM-dd HH:mm:ss" / ...
  29.      * @return 当前日期的格式化形式
  30.      */
  31.     public static String now(String pattern){
  32.         DateTime dateTime = DateTime.now();
  33.         DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(pattern);
  34.         return dateTimeFormatter.print(dateTime);
  35.     }
  37.     /**
  38.      * 获取当前日期 -1d 的格式化形式
  39.      * @param pattern "yyyy-MM-dd" / "yyyy-MM-dd HH:mm:ss" / ...
  40.      */
  41.     public static String yesterday(String pattern){
  42.         String now = now(pattern);
  43.         return datePlus(now, -1, pattern);
  44.     }
  46.     /**
  47.      * 获取当前日期 +1d 的格式化形式
  48.      * @param pattern "yyyy-MM-dd" / "yyyy-MM-dd HH:mm:ss" / ...
  49.      */
  50.     public static String tomorrow(String pattern){
  51.         String now = now(pattern);
  52.         return datePlus(now, 1, pattern);
  53.     }
  55.     /**
  56.      * 获取当前日期的格式化形式 ，格式为 "yyyy-MM-dd HH:mm:ss"
  57.      */
  58.     public static String now(){
  59.         return now(DATE_PATTERN_2);
  60.     }
  62.     /**
  63.      * 获取当前时间的指定格式化格式
  64.      *
  65.      * @param pattern "yyyy-MM-dd" / "yyyy-MM-dd HH:mm:ss" / ...
  66.      */
  67.     public static String getFormatCurrentTime(String pattern) {
  68.         DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(pattern);
  69.         DateTime dateTime = DateTime.now();
  70.         return dateTimeFormatter.print(dateTime);
  71.     }
  73.     /**
  74.      * 格式化的日期转换为时间戳
  75.      *
  76.      * @param formatTime 格式化的日期 
  77.      *                   如 2021-06-19 或 2021-06-19T00:00:00
  78.      * @param pattern "yyyy-MM-dd" / "yyyy-MM-dd HH:mm:ss" / ...
  79.      * @return 时间戳
  80.      */
  81.     public static long formatTime2Timestamp(String formatTime, String pattern) {
  82.         DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(pattern);
  83.         return DateTime.parse(formatTime, dateTimeFormatter).getMillis();
  84.     }
  86.     /**
  87.      * 时间戳转换为格式化的日期
  88.      *
  89.      * @param timestamp 时间戳
  90.      * @param pattern "yyyy-MM-dd" / "yyyy-MM-dd HH:mm:ss" 等
  91.      * @return 格式化的日期
  92.      */
  93.     public static String timestamp2FormatTime(long timestamp, String pattern) {
  94.         DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(pattern);
  95.         return dateTimeFormatter.print(timestamp);
  96.     }
  98.     /**
  99.      * 获取一天的最后一毫秒对应的时间戳
  100.      * @param formatTime 格式化的日期
  101.      * @param pattern "yyyy-MM-dd" / "yyyy-MM-dd HH:mm:ss" / ...
  102.      * @return 传入日期当天的最后一毫秒对应的时间戳
  103.      */
  104.     public static long getLastMillisOfDay(String formatTime, String pattern){
  105.         DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(pattern);
  106.         DateTime dateTime = DateTime.parse(formatTime, dateTimeFormatter);
  107.         return dateTime.millisOfDay().withMaximumValue().getMillis();
  108.     }
  110.     /**
  111.      * 获取一天的第一毫秒对应的时间戳
  112.      * @param formatTime 格式化的日期
  113.      * @param pattern "yyyy-MM-dd" / "yyyy-MM-dd HH:mm:ss" / ...
  114.      * @return 传入日期当天的第一毫秒对应的时间戳
  115.      */
  116.     public static long getFirstMillisOfDay(String formatTime, String pattern){
  117.         DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(pattern);
  118.         DateTime dateTime = DateTime.parse(formatTime, dateTimeFormatter);
  119.         return dateTime.millisOfDay().withMinimumValue().getMillis();
  120.     }
  122.     /**
  123.      * 判断 当前时间 是否达到(≥) 传入日期当日的开始时间
  124.      * @param formatTime 格式化的日期
  125.      * @param pattern "yyyy-MM-dd" / "yyyy-MM-dd HH:mm:ss" / ...
  126.      * @return true/false
  127.      */
  128.     public static boolean nowReachDayStart(String formatTime, String pattern){
  129.         return getCurrentTimestamp() >=  getFirstMillisOfDay(formatTime, pattern);
  130.     }
  132.     /**
  133.      * 判断 当前时间 是否达到(≥) 传入日期当日的结束时间
  134.      * @param formatTime 格式化的日期
  135.      * @param pattern "yyyy-MM-dd" / "yyyy-MM-dd HH:mm:ss" / ...
  136.      * @return true/false
  137.      */
  138.     public static boolean nowReachDayEnd(String formatTime, String pattern){
  139.         return getCurrentTimestamp() >= getLastMillisOfDay(formatTime, pattern);
  140.     }
  142.     /**
  143.      * 判断当前时间是否达到指定时间
  144.      * @param formatTime 格式化的日期
  145.      * @param pattern "yyyy-MM-dd" / "yyyy-MM-dd HH:mm:ss" / ...
  146.      * @return true/false
  147.      */
  148.     public static boolean nowReachSpecificTime(String formatTime, String pattern){
  149.         return getCurrentTimestamp() >= formatTime2Timestamp(formatTime, pattern);
  150.     }
  152.     /**
  153.      * formatTime2 - formatTime1 ，计算两者之间间隔多少天
  154.      * @param formatTime1 格式化的日期1
  155.      * @param formatTime2 格式化的日期2
  156.      * @param pattern "yyyy-MM-dd" / "yyyy-MM-dd HH:mm:ss" / ...
  157.      * @return 间隔天数
  158.      */
  159.     public static long dateDiff(String formatTime1, String formatTime2, String pattern){
  160.         DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(pattern);
  161.         DateTime dateTime1 = DateTime.parse(formatTime1, dateTimeFormatter);
  162.         DateTime dateTime2 = DateTime.parse(formatTime2, dateTimeFormatter);
  163.         long millisDiff = dateTime2.getMillis() - dateTime1.getMillis();
  164.         return millisDiff / WHOLE_DAY_MILLIS;
  165.     }
  167.     /**
  168.      * 
  169.      * @param formatTime 格式化的基础日期
  170.      * @param plusDays 在基础日期上 增加(+)/减去(-) 的天数
  171.      * @param pattern 输入及输出的日期格式 "yyyy-MM-dd" / "yyyy-MM-dd HH:mm:ss" / ...
  172.      * @return 基础日期增加后的日期
  173.      */
  174.     public static String datePlus(String formatTime, int plusDays, String pattern){
  175.         DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(pattern);
  176.         DateTime dateTime = DateTime.parse(formatTime, dateTimeFormatter);
  177.         DateTime newDateTime = dateTime.plusDays(plusDays);
  178.         return dateTimeFormatter.print(newDateTime);
  179.     }
  181.     /**
  182.      * 展示时间类的一些用法
  183.      */
  184.     private void demo(){
  185.         // 2021-06-19T09:38:08.963+08:00
  186.         DateTime dateTime_Now = DateTime.now();
  188.         /*
  189.             2021-06-19T00:00:00.000+08:00
  190.             如果不加pattern，日期之间必须用"-"分割
  191.         */
  192.         DateTime dateTime_0619_000000 = DateTime.parse("2021-06-19");
  194.         /*
  195.             2021-06-19T15:00:00.000+08:00
  196.             如果不加pattern，日期和时间之间必须有T
  197.         */
  198.         DateTime dateTime_0619_150000 = DateTime.parse("2021-06-19T15:00:00");
  200.         DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern("yyyy/MM/dd HH_mm_ss");
  201.         // 2021-06-19T22:22:22.000+08:00
  202.         DateTime dateTime_0619_222222 = DateTime.parse("2021/06/19 22_22_22", dateTimeFormatter);
  204.         // 2021-06-20T00:00:00.000+08:00
  205.         DateTime dateTime_0620_000000 = DateTime.parse("2021-06-19").plusDays(1);
  207.         // 2021-06-18T00:00:00.000+08:00
  208.         DateTime dateTime_0618_000000 = DateTime.parse("2021-06-19").minusDays(1);
  210.         // 获取长度为12个小时的duration
  211.         Duration duration_12h = Duration.standardHours(12);
  213.         // 获取长度为120分钟的duration
  214.         Duration duration_120m = Duration.standardMinutes(120);
  216.         // 获取 两个dateTime之间的duration
  217.         Duration duration_betweenDateTime = new Duration(dateTime_0618_000000, dateTime_0619_000000);
  219.         // 将duration转换为seconds 【86400】
  220.         long duration_seconds = duration_betweenDateTime.getStandardSeconds();
  222.         // 2021-06-19T12:00:00.000+08:00
  223.         DateTime dateTime_0619_120000 = DateTime.parse("2021-06-19").plus(duration_12h);
  225.         // 2021-06-19T02:00:00.000+08:00
  226.         DateTime dateTime_0619_020000 = DateTime.parse("2021-06-19").plus(duration_120m);
  229.         // 将 DateTime 转换为 时间戳
  230.         // 2021-06-19 00:00:00 对应的时间戳 【1624032000000】
  231.         long millis_0619_000000 = dateTime_0619_000000.getMillis();
  233.         // 将 时间戳 转换为 DateTime
  234.         // 时间戳 【1624032000000】 对应的 DateTime 为 2021-06-19T00:00:00.000+08:00
  235.         dateTime_0619_000000 = new DateTime(millis_0619_000000);
  237.         // 2021-06-19 00:00:00 对应的当天的时间戳 【0】
  238.         // 相当于 dateTime_0619_000000.millisOfDay().get()
  239.         int dayMillis_0619_000000 = dateTime_0619_000000.getMillisOfDay();
  241.         // 2021-06-19T23:59:59.999+08:00 ， 一天的最晚时间
  242.         DateTime dateTime_0619_235959 = dateTime_0619_000000.millisOfDay().withMaximumValue();
  244.         // 2021-06-19T00:00:00.000+08:00 ， 一天的最早时间
  245.         dateTime_0619_000000 = dateTime_0619_120000.millisOfDay().withMinimumValue();
  248.         dateTimeFormatter = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss:SSS");
  249.         // 2021-06-19 22:22:22:000
  250.         String str_0618_000000 = dateTimeFormatter.print(dateTime_0618_000000);
  252.         // 2021-06-19 00:00:00:000
  253.         String str_1624032000000L = dateTimeFormatter.print(1624032000000L);
  254.     }
  256. }

pom依赖：

  1. <dependency>
  2.   <groupId>joda-time</groupId>
  3.   <artifactId>joda-time</artifactId>
  4.   <version>2.9.4</version>
  5. </dependency>

HttpUtils

代码：

  1. import com.alibaba.fastjson.JSONObject;
  2. import org.springframework.http.*;
  3. import org.springframework.web.client.RestTemplate;
  5. import java.util.Map;
  7. /**
  8.  * @author miaohuanju001
  9.  * @date 2021-06-20
  10.  * @description 依赖fastJSON 和 spring-web
  11.  */
  12. public class HTTPUtils {
  13.     private static final JSONObject EMPTY_JSON_OBJECT = new JSONObject();
  15.     /**
  16.      * 发送request请求
  17.      *
  18.      * @param domain 域名，例：http://localhost:8080
  19.      * @param path 路径， 例：/api/addUser
  20.      * @param paramMap 请求参数
  21.      * @param httpMethod HttpMethod.POST/HttpMethod.GET/...
  22.      * @return res
  23.      */
  24.     public static JSONObject sendRequest(String domain, String path, Map<String, Object> paramMap, HttpMethod httpMethod) {
  25.         if (domain == null || "".equals(domain)){
  26.             return EMPTY_JSON_OBJECT;
  27.         }
  28.         if (path == null){
  29.             path = "";
  30.         }
  31.         String url = domain + path;
  32.         return sendRequest(url, paramMap, httpMethod);
  33.     }
  35.     /**
  36.      * 发送request请求
  37.      *
  38.      * @param url 请求url，例： http://localhost:8080/api/addUser
  39.      * @param paramMap 请求参数
  40.      * @param httpMethod HttpMethod.POST/HttpMethod.GET/...
  41.      * @return res
  42.      */
  43.     public static JSONObject sendRequest(String url, Map<String, Object> paramMap, HttpMethod httpMethod) {
  44.         if (url == null || "".equals(url)){
  45.             return EMPTY_JSON_OBJECT;
  46.         }
  47.         RestTemplate restTemplate = new RestTemplate();
  49.         // 请求头设置
  50.         HttpHeaders httpHeaders = new HttpHeaders();
  51.         httpHeaders.setContentType(MediaType.APPLICATION_JSON_UTF8); // 表示发送请求内容的格式
  52.         httpHeaders.set("ucid", String.valueOf(1000000026751020L)); // 想请求头中添加一些自定义参数
  53.         httpHeaders.set(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_UTF8_VALUE); // 设置接收的内容格式
  55.         HttpEntity<Map<String, Object>> httpEntity;
  56.         String requestUrl;
  57.         JSONObject resJson = null;
  58.         if (HttpMethod.GET == httpMethod) {
  59.             httpEntity = new HttpEntity<>(httpHeaders);
  60.             StringBuilder requestUrlBuilder = new StringBuilder(url);
  61.             requestUrlBuilder.append('?');
  62.             for (String key : paramMap.keySet()) {
  63.                 requestUrlBuilder.append(key).append('=').append(paramMap.get(key)).append('&');
  64.             }
  65.             requestUrlBuilder.deleteCharAt(requestUrlBuilder.length() - 1);
  66.             requestUrl =requestUrlBuilder.toString();
  67.             ResponseEntity<JSONObject> responseEntity = restTemplate.exchange(requestUrl, httpMethod, httpEntity, JSONObject.class);
  68.             resJson = responseEntity.getBody();
  70.         } else if (HttpMethod.POST == httpMethod) {
  71.             requestUrl = url;
  72.             httpEntity = new HttpEntity<>(paramMap, httpHeaders);
  73.             ResponseEntity<JSONObject> responseEntity = restTemplate.exchange(requestUrl, httpMethod, httpEntity, JSONObject.class);
  74.             resJson = responseEntity.getBody();
  75.         }
  77.         return resJson == null ? EMPTY_JSON_OBJECT : resJson;
  78.     }
  79. }

pom依赖：

  1. <dependency>
  2.   <groupId>org.springframework.boot</groupId>
  3.   <artifactId>spring-boot-starter-web</artifactId>
  4.   <version>2.1.9.RELEASE</version>
  5. </dependency>
  7. <dependency>
  8.   <groupId>com.alibaba</groupId>
  9.   <artifactId>fastjson</artifactId>
  10.   <version>1.2.28</version>
  11. </dependency>

JSONUtils

代码：

  1. import com.alibaba.fastjson.JSONObject;
  3. /**
  4.  * @author miaohuanju001
  5.  * @date 2021-07-07
  6.  * @description
  7.  */
  8. public class JSONUtils {
  10.     public static final JSONObject EMPTY_JSON_OBJECT = new JSONObject();
  12.     public static JSONObject javaObject2JsonObject(Object object){
  13.         return (JSONObject)JSONObject.toJSON(object);
  14.     }
  16.     public static <T> T jsonObject2JavaObject(JSONObject jsonObject, Class<T> clazz) {
  17.         return jsonObject.toJavaObject(clazz);
  18.     }
  20.     public static String object2JsonStr(Object object){
  21.         return JSONObject.toJSONString(object);
  22.     }
  24.     public static JSONObject jsonStr2JsonObject(String jsonStr){
  25.         return (JSONObject)(JSONObject.parse(jsonStr));
  26.     }
  27. }

pom依赖：

  1. <dependency>
  2.   <groupId>com.alibaba</groupId>
  3.   <artifactId>fastjson</artifactId>
  4.   <version>1.2.28</version>
  5. </dependency>

OfficialAccountsUtils

发送企微公众号，只适用于**贝壳找房**

代码：

  1. import com.alibaba.fastjson.JSONObject;
  2. import lombok.Data;
  3. import org.springframework.http.HttpMethod;
  4. import org.springframework.http.MediaType;
  5. import org.springframework.util.DigestUtils;
  6. import org.springframework.util.LinkedMultiValueMap;
  7. import org.springframework.util.MultiValueMap;
  9. import java.util.ArrayList;
  10. import java.util.List;
  11. import java.util.Map;
  13. /**
  14.  * @author miaohuanju001
  15.  * @date 2021-07-10
  16.  * @description 发送消息到企微公众号
  17.  * https://wiki.lianjia.com/pages/viewpage.action?pageId=499305440
  18.  */
  19. public class OfficialAccountsUtils {
  20.     private static final String OFFICIAL_ACCOUNTS_URL = "https://wxwork.ke.com/api/v1/wechat/message/news";
  21.     private static final String ODIN_APPID = "odin_notice";
  22.     private static final String ODIN_TOKEN = "F6_Ibms5bx63rIBnDz5_dVhrQDGFAzo1G28lcwXopwQ=";
  24.     /**
  25.      * 发送到自定义企微公众号
  26.      *
  27.      * @param title        title
  28.      * @param usercodeList 工号list
  29.      * @param appId        公众号唯一appId
  30.      * @param token        公众号token
  31.      * @param url          点击图片后的跳转链接
  32.      * @param picurl       图片链接
  33.      * @return 成功/错误信息
  34.      */
  35.     public static String sendToCustomOfficialAccounts(String title, List<String> usercodeList,
  36.                                                       String appId, String token,
  37.                                                       String url, String picurl) {
  38.         StringBuilder sb = new StringBuilder();
  39.         String touser;
  40.         for (String usercode : usercodeList) {
  41.             if (usercode.startsWith("10000000")) {
  42.                 String usercode1 = usercode.replace("10000000", "");
  43.                 sb.append(usercode1).append('|');
  44.             } else {
  45.                 sb.append(usercode).append('|');
  46.             }
  47.         }
  48.         if (sb.length() > 0) {
  49.             touser = sb.deleteCharAt(sb.length() - 1).toString();
  50.         } else {
  51.             return "touser is invalid";
  52.         }
  54.         OfficialAccountsMessage officialAccountsMessage = createParam(title, touser, appId, token, url, picurl);
  55.         MultiValueMap<String, Object> paramMap = new LinkedMultiValueMap<>();
  56.         JSONObject messageJson = JSONObject.parseObject(JSONObject.toJSONString(officialAccountsMessage));
  57.         paramMap.setAll(messageJson.toJavaObject(Map.class));
  60.         JSONObject jsonObject = HttpUtils2.sendRequest(OFFICIAL_ACCOUNTS_URL, paramMap, HttpMethod.POST, MediaType.APPLICATION_FORM_URLENCODED);
  61.         String errorMsg = jsonObject.getString("errmsg");
  62.         if (!Constants.OK.equals(errorMsg)) {
  63.             return errorMsg;
  64.         }
  65.         return Constants.SUCCESS;
  66.     }
  68.     /**
  69.      * 发送到奥丁企微公众号
  70.      */
  71.     public static String sendToOdinOfficialAccounts(String title, List<String> usercodeList, String url, String picurl) {
  72.         return sendToCustomOfficialAccounts(title, usercodeList, ODIN_APPID, ODIN_TOKEN, url, picurl);
  73.     }
  75.     /**
  76.      * 构建 参数
  77.      * 公众号 发送图文消息
  78.      *
  79.      * @param url    点击图片后的跳转链接
  80.      * @param picurl 图片地址链接
  81.      * @param touser 用  | 分割的系统号
  82.      */
  83.     private static OfficialAccountsMessage createParam(String title, String touser,
  84.                                                        String appId, String token,
  85.                                                        String url, String picurl) {
  87.         if (title == null || "".equals(title) ) {
  88.             title = "title";
  89.         }
  90.         OfficialAccountsMessage officialAccountsMessage = new OfficialAccountsMessage();
  91.         StringBuilder builder = new StringBuilder();
  92.         long timestamp = DateUtils.getCurrentTimestamp(DateUtils.UNIT_SECOND);
  93.         builder.append(timestamp);
  94.         builder.append(appId);
  95.         builder.append(token);
  96.         String signature = DigestUtils.md5DigestAsHex(builder.toString().getBytes());
  97.         officialAccountsMessage.setTouser(touser);
  98.         officialAccountsMessage.setAppId(appId);
  99.         officialAccountsMessage.setTimestamp(timestamp);
  100.         officialAccountsMessage.setSignature(signature);
  101.         officialAccountsMessage.setUrl(url);
  102.         officialAccountsMessage.setTitle(title);
  103.         officialAccountsMessage.setPicurl(picurl);
  104.         return officialAccountsMessage;
  105.     }
  107.     /**
  108.      * 企微公众号的消息内容
  109.      */
  110.     @Data
  111.     public static class OfficialAccountsMessage {
  113.         /**
  114.          * 企微公众号唯一标识
  115.          * 必填
  116.          */
  117.         private String appId;
  119.         /**
  120.          * 时间戳到秒
  121.          * 必填
  122.          */
  123.         private long timestamp;
  125.         /**
  126.          * 签名：MD5(时间戳+appId+messageToken)
  127.          * 必填
  128.          */
  129.         private String signature;
  131.         /**
  132.          * 接收人的链家系统号，比如：23009448，多个接收者用"|"分隔，最多支持1000个，特殊情况：指定为@all，则向该企业应用的全部成员发送
  133.          * 非必填
  134.          */
  135.         private String touser;
  137.         /**
  138.          * 部门ID列表，多个用"|"分隔，最多支持100个，消息会发送给该部门及其所有子部门的员工。当touser为@all时忽略本参数
  139.          * 非必填
  140.          */
  141.         private String toparty;
  143.         /**
  144.          * 标签ID列表，多个用"|"分隔，最多支持100个。当touser为@all时忽略本参数
  145.          * 非必填
  146.          */
  147.         private String totag;
  149.         /**
  150.          * 点击图片后的跳转链接
  151.          * 必填
  152.          */
  153.         private String url;
  155.         /**
  156.          * 图片链接
  157.          * 必填
  158.          */
  159.         private String picurl;
  161.         /**
  162.          * title
  163.          * 必填
  164.          */
  165.         private String title;
  166.     }
  167. }

WeChatRobotUtils

发送企微群机器人消息

代码：

  1. import com.alibaba.fastjson.JSONObject;
  2. import lombok.Data;
  3. import org.codehaus.plexus.util.Base64;
  4. import org.springframework.http.*;
  5. import org.springframework.util.DigestUtils;
  6. import org.springframework.web.client.RestTemplate;
  8. import java.io.ByteArrayOutputStream;
  9. import java.io.File;
  10. import java.io.FileInputStream;
  11. import java.util.ArrayList;
  12. import java.util.List;
  14. /**
  15.  * @author miaohuanju001
  16.  * @date 2021-07-06
  17.  * @description
  18. /**
  19.  * 纯文本类型:
  20.  * {
  21.  *     "msgtype": "text",
  22.  *     "text": {
  23.  *         "content": "广州今日天气：29度，大部分多云，降雨概率：60%",
  24.  *         "mentioned_list":["wangqing","@all"],
  25.  *         "mentioned_mobile_list":["13800001111","@all"]
  26.  *     }
  27.  * }
  28.  *
  29.  * markdown类型：
  30.  * {
  31.  *     "msgtype": "markdown",
  32.  *     "markdown": {
  33.  *         "content": "实时新增用户反馈<font color=\"warning\">132例</font>，请相关同事注意。\n
  34.  *          >类型:<font color=\"comment\">用户反馈</font>
  35.  *          >普通用户反馈:<font color=\"comment\">117例</font>
  36.  *          >VIP用户反馈:<font color=\"comment\">15例</font>"
  37.  *     }
  38.  * }
  39.  *
  40.  * 图文类型：
  41.  * {
  42.  *     "msgtype": "news",
  43.  *     "news": {
  44.  *        "articles" : [
  45.  *            {
  46.  *                "title" : "中秋节礼品领取",
  47.  *                "description" : "今年中秋节公司有豪礼相送",
  48.  *                "url" : "www.qq.com",
  49.  *                "picurl" : "http://res.mail.qq.com/node/ww/wwopenmng/images/independent/doc/test_pic_msg1.png"
  50.  *            }
  51.  *         ]
  52.  *     }
  53.  * }
  54.  *
  55.  * 图片类型
  56.  * {
  57.  *     "msgtype": "image",
  58.  *     "image": {
  59.  *         "base64": "DATA",
  60.  *         "md5": "MD5"
  61.  *     }
  62.  * }
  63.  */
  65. public class WeChatRobotUtils {
  67.     private static RestTemplate restTemplate = new RestTemplate();
  69.     /**
  70.      * 发送图片
  71.      */
  72.     public static String sendPicture(File file, String webhookurl) {
  73.         RobotMessage robotMessage = generatePicture(file);
  74.         if (robotMessage == null){
  75.             return "error";
  76.         }
  77.         return send(robotMessage,webhookurl);
  78.     }
  80.     /**
  81.      * 发送图文类消息
  82.      */
  83.     public static String sendRobotNews(List<Article> articleList, String webhookurl) {
  84.         RobotMessage robotMessage = generateNews(articleList);
  85.         return send(robotMessage, webhookurl);
  86.     }
  88.     /**
  89.      * 发送图文类消息
  90.      */
  91.     public static String sendRobotNews(Article article, String webhookurl) {
  92.         RobotMessage robotMessage = generateNews(article);
  93.         return send(robotMessage, webhookurl);
  94.     }
  96.     /**
  97.      * 发送图文类消息
  98.      */
  99.     public static String sendRobotNews(String title, String description, String url, String picturl, String webhookurl) {
  100.         Article article = new Article();
  101.         article.setTitle(title);
  102.         article.setDescription(description);
  103.         article.setUrl(url);
  104.         article.setPicurl(picturl);
  105.         RobotMessage robotMessage = generateNews(article);
  106.         return send(robotMessage, webhookurl);
  107.     }
  109.     /**
  110.      * 发送markdown消息
  111.      */
  112.     public static String sendRobotMarkdown(String content, String webhookurl) {
  113.         RobotMessage robotMessage = generateMarkdown(content);
  114.         return send(robotMessage, webhookurl);
  115.     }
  117.     /**
  118.      * 发送text消息, 不@任何人
  119.      */
  120.     public static String sendRobotText(String content, String webhookurl) {
  121.         RobotMessage robotMessage = generateText(content);
  122.         return send(robotMessage, webhookurl);
  123.     }
  125.     /**
  126.      * 发送text消息，@人
  127.      */
  128.     public static String sendRobotText(String content, List<String> mentionedList, List<String> mentionedMobileList, String webhookurl) {
  129.         RobotMessage robotMessage = generateText(content, mentionedList, mentionedMobileList);
  130.         return send(robotMessage, webhookurl);
  131.     }
  133.     /**
  134.      * 生成 图文类型的robot消息
  135.      */
  136.     private static RobotMessage generateNews(List<Article> articleList) {
  137.         RobotMessage robotMessage = new RobotMessage();
  138.         robotMessage.setMsgtype(RobotMessage.TYPE_NEWS);
  139.         JSONObject jsonObject = new JSONObject();
  140.         jsonObject.put("articles", articleList);
  141.         robotMessage.setNews(jsonObject);
  142.         return robotMessage;
  143.     }
  145.     /**
  146.      * 生成 图文类型的robot消息
  147.      */
  148.     private static RobotMessage generateNews(Article article) {
  149.         List<Article> articleList = new ArrayList<>();
  150.         articleList.add(article);
  151.         return generateNews(articleList);
  152.     }
  154.     /**
  155.      * 生成 text消息
  156.      *
  157.      * @param content             消息内容
  158.      * @param mentionedList       @哪些人，传miaohuanju001这种
  159.      * @param mentionedMobileList @哪些人，传手机号
  160.      */
  161.     private static RobotMessage generateText(String content, List<String> mentionedList, List<String> mentionedMobileList) {
  162.         RobotMessage robotMessage = new RobotMessage();
  163.         robotMessage.setMsgtype(RobotMessage.TYPE_TEXT);
  164.         JSONObject jsonObject = new JSONObject();
  165.         jsonObject.put("content", content);
  166.         jsonObject.put("mentioned_list", mentionedList);
  167.         jsonObject.put("mentioned_mobile_list", mentionedMobileList);
  168.         robotMessage.setText(jsonObject);
  169.         return robotMessage;
  170.     }
  172.     /**
  173.      * 生成 text消息
  174.      *
  175.      * @param content 消息内容
  176.      */
  177.     private static RobotMessage generateText(String content) {
  178.         return generateText(content, null, null);
  179.     }
  181.     /**
  182.      * 生成 markdown消息
  183.      *
  184.      * @param content 消息内容
  185.      */
  186.     private static RobotMessage generateMarkdown(String content) {
  187.         RobotMessage robotMessage = new RobotMessage();
  188.         robotMessage.setMsgtype(RobotMessage.TYPE_TEXT);
  189.         JSONObject jsonObject = new JSONObject();
  190.         jsonObject.put("content", content);
  191.         robotMessage.setMarkdown(jsonObject);
  192.         return robotMessage;
  193.     }
  195.     private static RobotMessage generatePicture(File file){
  196.         byte[] data;
  197.         try {
  198.             FileInputStream fis = new FileInputStream(file);
  199.             ByteArrayOutputStream bos = new ByteArrayOutputStream(1024*1000*1000);
  200.             byte[] b = new byte[1024*200];
  201.             int n;
  202.             while ((n = fis.read(b)) != -1) {
  203.                 bos.write(b, 0, n);
  204.             }
  205.             fis.close();
  206.             data = bos.toByteArray();
  207.             bos.close();
  208.             String md5 = DigestUtils.md5DigestAsHex(data);
  209.             String base64 = new String(Base64.encodeBase64(data));
  211.             RobotMessage robotMessage = new RobotMessage();
  212.             robotMessage.setMsgtype(RobotMessage.TYPE_IMAGE);
  213.             JSONObject imageJson = new JSONObject();
  214.             imageJson.put("md5",md5);
  215.             imageJson.put("base64",base64);
  216.             robotMessage.setImage(imageJson);
  217.             return robotMessage;
  218.         } catch (Exception e) {
  219.             e.printStackTrace();
  220.             return null;
  221.         }
  223.     }
  225.     /**
  226.      * 发送robot消息
  227.      */
  228.     private static String send(RobotMessage robotMessage, String webhookurl) {
  229.         String jsonMessage = JSONObject.toJSONString(robotMessage);
  230.         HttpHeaders httpHeaders = new HttpHeaders();
  231.         httpHeaders.setContentType(MediaType.APPLICATION_JSON_UTF8); //发送内容的类型为 json
  232.         HttpEntity<String> entity = new HttpEntity<>(jsonMessage, httpHeaders);
  233.         ResponseEntity<String> resp = restTemplate.exchange(webhookurl, HttpMethod.POST, entity, String.class);
  234.         String body = resp.getBody();
  235.         JSONObject bodyJson = (JSONObject) (JSONObject.parse(body));
  236.         String errorMsg = bodyJson.getString("errmsg");
  237.         if (!"ok".equals(errorMsg)) {
  238.             return errorMsg;
  239.         }
  240.         return "success";
  241.     }
  243.     @Data
  244.     public static class Article {
  245.         private String title;
  247.         private String description;
  249.         /**
  250.          * 点击图片后的跳转链接
  251.          */
  252.         private String url;
  254.         /**
  255.          * 图片链接
  256.          */
  257.         private String picurl;
  258.     }
  261.     /**
  262.      * 纯文本类型:
  263.      * {
  264.      *     "msgtype": "text",
  265.      *     "text": {
  266.      *         "content": "广州今日天气：29度，大部分多云，降雨概率：60%",
  267.      *         "mentioned_list":["wangqing","@all"],
  268.      *         "mentioned_mobile_list":["13800001111","@all"]
  269.      *     }
  270.      * }
  271.      *
  272.      * markdown类型：
  273.      * {
  274.      *     "msgtype": "markdown",
  275.      *     "markdown": {
  276.      *         "content": "实时新增用户反馈<font color=\"warning\">132例</font>，请相关同事注意。\n
  277.      *          >类型:<font color=\"comment\">用户反馈</font>
  278.      *          >普通用户反馈:<font color=\"comment\">117例</font>
  279.      *          >VIP用户反馈:<font color=\"comment\">15例</font>"
  280.      *     }
  281.      * }
  282.      *
  283.      * 图文类型：
  284.      * {
  285.      *     "msgtype": "news",
  286.      *     "news": {
  287.      *        "articles" : [
  288.      *            {
  289.      *                "title" : "中秋节礼品领取",
  290.      *                "description" : "今年中秋节公司有豪礼相送",
  291.      *                "url" : "www.qq.com",
  292.      *                "picurl" : "http://res.mail.qq.com/node/ww/wwopenmng/images/independent/doc/test_pic_msg1.png"
  293.      *            }
  294.      *         ]
  295.      *     }
  296.      * }
  297.      * 
  298.      * 图片类型
  299.      * {
  300.      *     "msgtype": "image",
  301.      *     "image": {
  302.      *         "base64": "DATA",
  303.      *         "md5": "MD5"
  304.      *     }
  305.      * }
  306.      */
  307.     @Data
  308.     public static class RobotMessage {
  311.         public static final String TYPE_TEXT = "text";
  313.         public static final String TYPE_MARKDOWN = "markdown";
  316.         /**
  317.          * 图文类型
  318.          */
  319.         public static final String TYPE_NEWS = "news";
  321.         public static final String TYPE_IMAGE = "image";
  323.         /**
  324.          * 消息类型，
  325.          * 文本：text
  326.          * markdown
  327.          * 图文：news
  328.          */
  329.         private String msgtype;
  331.         private JSONObject text;
  333.         private JSONObject markdown;
  335.         /**
  336.          * "base64"
  337.          * "md5"
  338.          */
  339.         private JSONObject image;
  341.         /**
  342.          * "news":{"articles": [{article1},{article1}]   }
  343.          */
  344.         private JSONObject news;
  346.         public void makeNews(List<Article> articleList) {
  347.             this.news = new JSONObject();
  348.             news.put("articles", articleList);
  349.         }
  350.     }
  351. }

ZKUtils

代码：

  1. package zk;
  3. import org.apache.curator.RetryPolicy;
  4. import org.apache.curator.framework.CuratorFramework;
  5. import org.apache.curator.framework.CuratorFrameworkFactory;
  6. import org.apache.curator.framework.imps.CuratorFrameworkState;
  7. import org.apache.curator.framework.recipes.locks.InterProcessMutex;
  8. import org.apache.curator.retry.ExponentialBackoffRetry;
  9. import org.apache.zookeeper.CreateMode;
  10. import org.apache.zookeeper.KeeperException;
  11. import org.apache.zookeeper.data.Stat;
  12. import org.slf4j.Logger;
  13. import org.slf4j.LoggerFactory;
  15. import java.nio.charset.StandardCharsets;
  16. import java.util.ArrayList;
  17. import java.util.List;
  19. /**
  20.  * @author miaohuanju001
  21.  * @date 2021-07-20
  22.  * @description zk对节点操作的api封装
  23.  */
  24. public class ZKUtils {
  26.     private static final Logger logger = LoggerFactory.getLogger(ZKUtils.class);
  28.     public static int baseSleepTimeMs = 10; // 初始sleep时间
  30.     public static int maxRetry = 3; // 最大重试次数
  32.     public static String zkUrl = "zk01-test.xxx.com:2181"; // zk集群url
  34.     public static String scheme = "digest"; // addauth digest #{auth}
  36.     public static String auth = "xxxxxxxx"; // 为节点增加权限
  38.     public static int sessionTimeoutMs = 20000; // 会话超时时间 20000ms
  40.     public static int connectTimeoutMs = 15000; // 连接超时时间 15000ms
  42.     public static CuratorFramework zkClient;
  44.     static {
  45.         RetryPolicy retryPolicy = new ExponentialBackoffRetry(baseSleepTimeMs, maxRetry);
  47.         zkClient = CuratorFrameworkFactory.builder()
  48.                 .connectString(zkUrl)
  49.                 .authorization(scheme, auth.getBytes())
  50.                 .sessionTimeoutMs(sessionTimeoutMs)
  51.                 .connectionTimeoutMs(connectTimeoutMs)
  52.                 .retryPolicy(retryPolicy).build();
  53.         zkClient.start();
  54.     }
  56.     /**
  57.      * 获取 zk客户端的状态
  58.      *
  59.      * @return LATENT、STARTED、STOPPED
  60.      */
  61.     public static CuratorFrameworkState getZKClientState() {
  62.         return zkClient.getState();
  63.     }
  66.     /**
  67.      * 获取指定路径对应节点的信息
  68.      *
  69.      * @param path 节点路径，例如 /testZK/push/resource/10.224.65.216
  70.      * @return 节点信息
  71.      */
  72.     public static String getNodeMessage(final String path) {
  73.         try {
  74.             byte[] bytes = zkClient.getData().forPath(path);
  75.             return new String(bytes, StandardCharsets.UTF_8);
  76.         } catch (Exception ex) {
  77.             logger.error("get key : {}", path, ex);
  78.         }
  79.         return null;
  80.     }
  82.     /**
  83.      * 获取指定路径下的子节点
  84.      *
  85.      * @param path 节点路径，例如 /testZK/push/resource
  86.      * @return 指定节点的子节点信息
  87.      */
  88.     public static List<String> getChildrenNode(final String path) {
  89.         try {
  90.             return zkClient.getChildren().forPath(path);
  91.         } catch (KeeperException.NoNodeException ex) {
  92.             return new ArrayList<>();
  93.         } catch (InterruptedException ex) {
  94.             logger.error("getChildrenKeys path : {} InterruptedException", path);
  95.             throw new IllegalStateException(ex);
  96.         } catch (Exception ex) {
  97.             logger.error("getChildrenKeys path : {}", path, ex);
  98.             throw new RuntimeException(ex);
  99.         }
  100.     }
  102.     /**
  103.      * 判断指定路径下是否有节点
  104.      *
  105.      * @param path 指定路径
  106.      */
  107.     public static boolean hasChildren(final String path) {
  108.         Stat stat;
  109.         try {
  110.             stat = zkClient.checkExists().forPath(path);
  111.             return stat.getNumChildren() >= 1;
  112.         } catch (Exception ex) {
  113.             throw new IllegalStateException(ex);
  114.         }
  115.     }
  117.     /**
  118.      * 判断指定路径对应的节点是否存在
  119.      *
  120.      * @param path 指定的节点路径
  121.      */
  122.     public static boolean isExisted(final String path) {
  123.         try {
  124.             return zkClient.checkExists().forPath(path) != null;
  125.         } catch (Exception ex) {
  126.             logger.error("isExisted key : {}", path, ex);
  127.         }
  128.         return false;
  129.     }
  131.     /**
  132.      * 创建永久节点，如果节点已存在则用输入信息覆盖
  133.      *
  134.      * @param path        指定的节点路径
  135.      * @param nodeMessage 节点信息
  136.      */
  137.     public static void createPersistNode(final String path, final String nodeMessage) {
  138.         try {
  139.             if (!isExisted(path)) {
  140.                 zkClient.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT).forPath(path, nodeMessage.getBytes(StandardCharsets.UTF_8));
  141.             } else {
  142.                 update(path, nodeMessage);
  143.             }
  144.         } catch (Exception ex) {
  145.             logger.error("persist path : {} , nodeMessage : {}", path, nodeMessage, ex);
  146.         }
  147.     }
  149.     /**
  150.      * 创建临时节点
  151.      *
  152.      * @param path        指定的节点路径
  153.      * @param nodeMessage 节点信息
  154.      * @param overwrite   如果指定路径已存在，是否覆盖原有节点 true-覆盖 / false-不覆盖
  155.      */
  156.     public static void createEphemeralNode(final String path, final String nodeMessage, final boolean overwrite) {
  157.         try {
  158.             if (overwrite) {
  159.                 createEphemeralNode(path, nodeMessage);
  160.             } else {
  161.                 if (!isExisted(path)) {
  162.                     zkClient.create().creatingParentsIfNeeded().withMode(CreateMode.EPHEMERAL).forPath(path, nodeMessage.getBytes(StandardCharsets.UTF_8));
  163.                 }
  164.             }
  165.         } catch (final Exception ex) {
  166.             logger.error("persistEphemeral path : {} , nodeMessage : {}, overwrite : {}", path, nodeMessage, overwrite, ex);
  167.         }
  168.     }
  170.     /**
  171.      * 更新节点信息，只更新节点本身存储的信息，不改变节点的子节点
  172.      * 如果节点不存在就会抓到exception
  173.      *
  174.      * @param path        指定的节点路径
  175.      * @param nodeMessage 节点信息
  176.      */
  177.     public static void update(final String path, final String nodeMessage) {
  178.         try {
  179.             zkClient.inTransaction().check().forPath(path).and().setData().forPath(path, nodeMessage.getBytes(StandardCharsets.UTF_8)).and().commit();
  180.         } catch (Exception ex) {
  181.             logger.error("update path : {} , nodeMessage : {}", path, nodeMessage, ex);
  182.         }
  183.     }
  185.     /**
  186.      * 创建带序列号的临时节点
  187.      * <p>
  188.      * exam: ("/zk/testNode", "this is a serial Ephemeral node") 以该入参执行3次会创建如下节点
  189.      * [/zk/testNode0000000001, /zk/testNode0000000002, /zk/testNode0000000003]
  190.      *
  191.      * @param path        指定的节点路径
  192.      * @param nodeMessage 节点信息
  193.      */
  194.     public static void persistEphemeralSequential(final String path, String nodeMessage) {
  195.         try {
  196.             zkClient.create().creatingParentsIfNeeded().withMode(CreateMode.EPHEMERAL_SEQUENTIAL).forPath(path, nodeMessage.getBytes(StandardCharsets.UTF_8));
  197.         } catch (final Exception ex) {
  198.             logger.error("persistEphemeralSequential path : {}", path, ex);
  199.         }
  200.     }
  202.     /**
  203.      * 删除指定节点
  204.      *
  205.      * @param path 指定的节点路径
  206.      */
  207.     public static void remove(final String path) {
  208.         try {
  209.             if (isExisted(path)) {
  210.                 zkClient.delete().deletingChildrenIfNeeded().forPath(path);
  211.             }
  212.         } catch (KeeperException.NoNodeException ignore) {
  213.             //NOP
  214.         } catch (final Exception ex) {
  215.             logger.error("remove path : {}", path, ex);
  216.         }
  217.     }
  219.     /**
  220.      * 创建临时节点
  221.      *
  222.      * @param path        指定的节点路径
  223.      * @param nodeMessage 节点信息
  224.      */
  225.     private static void createEphemeralNode(final String path, final String nodeMessage) {
  226.         try {
  227.             if (isExisted(path)) {
  228.                 try {
  229.                     zkClient.delete().deletingChildrenIfNeeded().forPath(path);
  230.                 } catch (KeeperException.NoNodeException ignore) {
  231.                     //NOP
  232.                 }
  233.             }
  234.             zkClient.create().creatingParentsIfNeeded().withMode(CreateMode.EPHEMERAL).forPath(path, nodeMessage.getBytes(StandardCharsets.UTF_8));
  235.         } catch (final Exception ex) {
  236.             logger.error("persistEphemeral path : {} , nodeMessage : {}", path, nodeMessage, ex);
  237.         }
  238.     }
  240.     /**
  241.      * 在指定节点下生成serial节点的方式获取锁，
  242.      * 持有锁的线程可重入，其余抢锁线程会在 mutex.acquire() 后阻塞
  243.      * 调用该方法后需要在finally中 mutex.release()释放锁
  244.      *
  245.      * @param path 指定的节点路径
  246.      * @return InterProcessMutex mutex
  247.      */
  248.     public static InterProcessMutex getMasterBlockMutex(String path){
  249.         InterProcessMutex mutex = null;
  250.         try {
  251.             mutex = new InterProcessMutex(zkClient, path);
  252.             mutex.acquire();
  253.         } catch (Exception e) {
  254.             e.printStackTrace();
  255.         }
  256.         return  mutex;
  257.     }
  259.     public static void main(String[] args) {
  260.         remove("/testZK/asdfasfasdf");
  261.         int x = 0;
  263.     }
  265. }

pom依赖：

  1. <dependency>
  2.   <groupId>org.apache.curator</groupId>
  3.   <artifactId>curator-recipes</artifactId>
  4.   <version>2.13.0</version>
  5. </dependency>