【Java用法】使用Java开发连接钉钉应用实现钉钉通知的功能

简介: 【Java用法】使用Java开发连接钉钉应用实现钉钉通知的功能

另外一种实现方式,更加简单,代码粘下来就可以用:【Java用法】拿来即用--使用Java开发连接钉钉H5微应用实现钉钉通知提醒的功能(方式二)

项目背景

springboot  + maven + mybatis-plus + jdk1.8

步骤一、添加依赖

<!--钉钉通知使用-->
<dependency>
  <groupId>com.aliyun</groupId>
  <artifactId>taobao-dingding</artifactId>
  <version>1.0.0</version>
</dependency>

步骤二、添加使用的工具类

参考本文拓展里的内容

步骤三、添加配置文件config.properties

步骤四、在业务中添加发送钉钉通知的代码

    /**
     * 保存考试人员或者部门后,如果开启钉钉通知,则开始开启另一条线程执行钉钉通知
     *
     * @param dingUserIdList 人员列表
     * @param deptList       部门列表
     * @param exam           考试实例
     */
    private void executeDingDingInform(List<String> dingUserIdList, List<String> deptList, Exam exam) {
        ThreadUtil.excAsync(new Runnable() {
            @Override
            public void run() {
                StringBuilder sb = new StringBuilder();
                if (dingUserIdList != null && dingUserIdList.size() > 0) {
                    for (String dingUserId : dingUserIdList) {
                        sb.append(dingUserId).append(",");
                    }
                }
                if (deptList != null && deptList.size() > 0) {
                    sb = getDeptAllDingUserId(deptList);
                }
                if (StrUtil.isNotBlank(sb)) {
                    // 删除最后一个逗号
                    sb.deleteCharAt(sb.lastIndexOf(","));
                    List<Map<String, Object>> mapList = this.getDingDingInformContent(exam);
                    DingTalkUtil.sendDingMsg("考试通知", sb.toString(), "",
                            mapList, new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
                }
            }
            private List<Map<String, Object>> getDingDingInformContent(Exam exam) {
                List<Map<String, Object>> collectList = new ArrayList<>();
                Date startTime = exam.getStartTime();
                Date endTime = exam.getEndTime();
                String title = exam.getTitle();
                Integer totalTime = exam.getTotalTime();
                String content = exam.getContent();
                if (startTime != null && endTime != null) {
                    collectList = DingDingMsg.create("考试名称:", title)
                            .builder("考试时长:", totalTime.toString() + "分钟")
                            .builder("开始时间:", DateUtil.format(startTime, "yyyy-MM-dd"))
                            .builder("结束时间:", DateUtil.format(endTime, "yyyy-MM-dd"))
                            .builder("考试描述:", content)
                            .collect();
                } else {
                    collectList = DingDingMsg.create("考试名称:", title)
                            .builder("考试时长:", totalTime.toString() + "分钟")
                            .builder("考试描述:", content)
                            .collect();
                }
                return collectList;
            }
        }, true);
    }

拓展:

步骤二中使用的工具类有以下几个(Util.class,Properties.class,JsonUtils.class,DingTalkUtil.class,DingDingMsg.class)

package com.soft.exam.utility;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.math.BigDecimal;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.DecimalFormat;
import java.util.*;
/**
 * <p>Util.java此类用于工具组件</p>
 * <p>@author:hhh</p>
 * <p>@date:2012-2-23</p>
 * <p>@remark:提供一些常用的时间和字符串方法</p>
 */
public class Util implements Serializable{
    /**
     *
     */
    private static final long serialVersionUID = 1L;
    private final static Logger log = LoggerFactory.getLogger(Util.class);
    /**
     * 向HttpServletResponse中写数据,设置ContentType为html/txt;charset=utf-8
     * @param response
     * @param text 要写入的数据
     */
    public static void writeUtf8Text(HttpServletResponse response, String text){
        //response 相关处理
        response.setContentType("html/text;charset=utf-8");
        response.setHeader("Pragma", "no-cache");
        response.setHeader("Cache-Control", "no-cache, must-revalidate");
        response.setHeader("Pragma", "no-cache");
        try {
            response.getWriter().write(text);
            response.getWriter().flush();
            response.getWriter().close();
        } catch (IOException e) {
          log.error("修改数据流编码格式出错", e);
        }
    }
    /**
     * 向HttpServletResponse中写数据,设置ContentType为html/txt;charset=utf-8
     * @param response
     * @param text 要写入的数据
     */
    public static void writeUtf8Html(HttpServletResponse response, String text){
        //response 相关处理
        response.setContentType("text/html;charset=utf-8");
        response.setHeader("Pragma", "no-cache");
        response.setHeader("Cache-Control", "no-cache, must-revalidate");
        response.setHeader("Pragma", "no-cache");
        try {
            response.getWriter().write(text);
            response.getWriter().flush();
            response.getWriter().close();
        } catch (IOException e) {
          log.error("修改数据流编码格式出错", e);
        }
    }
    /**
     * 向HttpServletResponse中写数据,设置ContentType为application/json;charset=utf-8
     * @param response
     * @param text 要写入的数据
     */
    public static void writeUtf8Json(HttpServletResponse response, String text){
        //response 相关处理
        response.setContentType("application/json;charset=utf-8");
        response.setHeader("Pragma", "no-cache");
        response.setHeader("Cache-Control", "no-cache, must-revalidate");
        response.setHeader("Pragma", "no-cache");
        try {
            response.getWriter().write(text);
            response.getWriter().flush();
            response.getWriter().close();
        } catch (IOException e) {
          log.error("修改数据流编码格式出错", e);
        }
    }
    /**
     * 从输入流中获取数据
     * @param inStream 输入流
     * @return 读取输入流的byte数组结果
     * @throws Exception
     */
    public static byte[] readInputStream(InputStream inStream) throws Exception{
        ByteArrayOutputStream outStream = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int len = 0;
        while( (len=inStream.read(buffer)) != -1 ){
            outStream.write(buffer, 0, len);
        }
        inStream.close();
        return outStream.toByteArray();
    }
    /**
     * 安全分隔字符串方法
     * @param s 字符串
     * @param regex 分隔正则表达式
     * @return 分割后的字符数组
     */
    public static String[] split(String s, String regex) {
        return split(s, regex, -1);
    }
    /**
     * 在第几位分隔字符串方法
     * @param s 字符串
     * @param regex 分隔正则表达式
     * @param limit 限定起始下标
     * @return 分割后字符数组
     */
    public static String[] split(String s, String regex, int limit) {
        if (null == s) {
            return null;
        } else {
            return s.split(regex, limit);
        }
    }
    /**
     * 处理字符串空指针
     * @param s 字符串
     */
    public static String varFormat(String s) {
        if(s == null) {
            s = "";
        }
        return s;
    }
    public static String varFormat(Object s) {
        if(s == null) {
            s = "";
        }
        return s.toString();
    }
    /**
     * 获取主机唯一标示,返回的格式为:H_123 ,123为主机的主键
     * @param regSnId 主机主键Id
     * @return 返回处理后的主机主键格式
     */
    public static String getHostUq(Object regSnId){
        return "H_"+varFormat(regSnId);
    }
    public static String getVoicUq(Object voicBxoId){
        return "V_"+varFormat(voicBxoId);
    }
    /**
     * 获取主机名称 格式:SHCS_HOST_NAME_123,123为主机主键
     * @param regSnId 主机主键Id
     * @return 返回处理后的主机名称
     */
    public static String getHostName(String regSnId){
        return "SHCS_HOST_NAME_"+regSnId;
    }
    /**
     * 转换字符串为大写
     * @param s 处理后字符串
     */
    public static String toUpperCase(String s) {
        return varFormat(s).toUpperCase();
    }
    /**
     * 转换字符串为小写
     * @param s 处理后的字符串
     */
    public static String toLowerCase(String s) {
        return varFormat(s).toLowerCase();
    }
    /**
     * 获取固定长度字符串
     * @param s 字符串
     * @param len 长度
     * @return 截取后的字符
     */
    public static String limitFormat(String s, int len) {
        return limitFormat(s, len, true, "");
    }
    /**
     * 获取固定长度字符串
     * @param s 字符串
     * @param len 长度
     * @param c 后缀
     * @return 截取后的字符
     */
    public static String limitFormat(String s, int len, String c) {
        return limitFormat(s, len, true, c);
    }
    /**
     * 获取固定长度字符串
     * @param s 字符串
     * @param len 长度
     * @param b 方向
     * @return 截取后字符串
     */
    public static String limitFormat(String s, int len, boolean b) {
        return limitFormat(s, len, b, "");
    }
    /**
     * 获取固定长度字符串
     * @param s 字符串
     * @param len 长度
     * @param b 方向
     * @param c 前/后缀
     * @return 截取后字符串
     */
    public static String limitFormat(String s, int len, boolean b, String c) {
        s = varFormat(s);
        c = varFormat(c);
        if(s.length() > len) {
            //需要截取
            if(b) {
                //从前向后截取
                if("".equals(c)) {
                    return (s.substring(0, len));
                } else {
                    //加后缀
                    return (s.substring(0, len)+c);
                }
            } else {
                //从后向前截取
                if("".equals(c)) {
                    return (s.substring(s.length()-len, s.length()));
                } else {
                    //加前缀
                    return (c+s.substring(s.length()-len, s.length()));
                }
            }
        } else {
            //不需要截取
            return (s);
        }
    }
    /**
     * 处理字符串符合URL格式
     * @param s 字符串
     * @return 处理后字符串
     */
    public static String urlFormat(String s) {
        return varFormat(s).replaceAll("&", "%26");
    }
    /**
     * 处理字符串符合XML格式
     * @param s 字符串
     * @param c 需要编码字符
     * @return 处理后字符串
     */
    public static String xmlFormat(String s, String c) {
        s = varFormat(s);
        c = varFormat(c);
        if (c.indexOf("&") != -1) {
            s = s.replaceAll("&", "&amp;");
        }
        if (c.indexOf("<") != -1) {
            s = s.replaceAll("<", "&lt;");
        }
        if (c.indexOf(">") != -1) {
            s = s.replaceAll(">", "&gt;");
        }
        if (c.indexOf("\"") != -1) {
            s = s.replaceAll("\"", "&quot;");
        }
        if (c.indexOf("'") != -1) {
            s = s.replaceAll("'", "&#39;");
        }
        if (c.indexOf(" ") != -1) {
            s = s.replaceAll(" ", "&nbsp;");
        }
        return s;
    }
    /**
     * 处理字符串符合XML格式
     * @param s 字符串
     * @return 处理后字符串
     */
    public static String xmlFormat(String s) {
        return xmlFormat(s, "<'&\">");
    }
    /**
     * 处理字符串符合XML格式且不生成空字符串
     * @param s 字符串
     * @param c 需要编码字符
     * @return 处理后字符串
     */
    public static String xmlSpanFormat(String s, String c) {
        s = xmlFormat(s, c);
        if("".equals(s)) {
            s = " ";
        }
        return s;
    }
    /**
     * 处理字符串符合XML格式且不生成空字符串
     * @param s 字符串
     * @return 处理后字符串
     */
    public static String xmlSpanFormat(String s) {
        s = xmlFormat(s);
        if("".equals(s)) {
            s = " ";
        }
        return s;
    }
    /**
     * 处理字符串符合JavaScript的字符串格式
     * @param s 字符串
     * @return 处理后字符串
     */
    public static String jsStringFormat(String s) {
        if(s == null) {
            s = "";
        } else {
            s = s.trim();
            s = s.replaceAll("\\\\", "\\\\\\\\");
            s = s.replaceAll("\b", "\\\\b");
            s = s.replaceAll("\f", "\\\\f");
            s = s.replaceAll("\n", "\\\\n");
            s = s.replaceAll("\r", "\\\\r");
            s = s.replaceAll("\t", "\\\\t");
            s = s.replaceAll("'", "\\\\'");
            s = s.replaceAll("\"", "\\\\\"");
        }
        return s;
    }
    /**
     * 处理符合SQL字符格式由12,33转变为:'12','34'
     * @param s
     * @return 处理后字符串
     */
    public static String sqlStrFormat(String s) {
        if ("".equals(varFormat(s))) {
            return null;
        }
        String str[] = s.split(",");
        StringBuffer sql = new StringBuffer();
        for(int i=0;i<str.length;i++){
            sql.append("'");
            sql.append(str[i]);
            sql.append("'");
            //最后一个不在添加","
            if(i!=(str.length-1)){
                sql.append(",");
            }
        }
        return sql.toString();
    }
    /**
     * 获取当前年份
     * @return 返回年份
     */
    public static String getYear(){
        Calendar cal = Calendar.getInstance();
        int year = cal.get(Calendar.YEAR)+1;
        return year+"";
    }
    /**
     * 将十六进制字符串转行成字节
     * @param hexString 十六进制字符串
     * @return 处理后的字节数组
     */
    public  static byte[] hexStringToBytes(String hexString) {
        if (hexString == null || "".equals(hexString)) {
            return null;
        }
        hexString = hexString.toUpperCase();
        int length = hexString.length() / 2;
        char[] hexChars = hexString.toCharArray();
        byte[] d = new byte[length];
        for (int i = 0; i < length; i++) {
            int pos = i * 2;
            d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
        }
        return d;
    }
   /**
    * char 转换byte字节
    * @param c char类型
    * @return 处理后的字节
    */
   public static byte charToByte(char c) {
        return (byte) "0123456789ABCDEF".indexOf(c);
    }
   /**
    * 将字节转行成十六进制字符串
    * @param src 字节数组
    * @return 处理后的十六进制字符串
    */
   public static String bytesToHexString(byte[] src){
       StringBuffer stringBuilder = new StringBuffer(500);
        if (src == null || src.length <= 0) {
            return null;
        }
        for (int i = 0; i < src.length; i++) {
            int v = src[i] & 0xFF;
            String hv = Integer.toHexString(v);
            if (hv.length() < 2) {
                stringBuilder.append(0);
            }
            stringBuilder.append(hv);
        }
        return stringBuilder.toString();
    }
 /**
  * 16进制转换10进制
  * @param str16 十六进制字符串
  * @return  处理后的十进制类型
  */
   public static Integer getFrom16ToData(String str16){
       return Integer.valueOf(str16.trim(),16);
   }
   /**
    * 将字符串转换字节
    * @param str 字符串
    * @return 处理后的byte数组
    */
   public static byte[] stringToBytes(String str){
       byte[] buf = null;
       if("".equals(varFormat(str))){
           buf = new byte[0];
           return buf;
       }
        try {
            buf = str.getBytes("UTF-8");
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
           return buf;
   }
   /**
    * 将字节转换字符串
    * @param data 字节数组
    * @param charset 转换字符串格式 utf-8 、gbk等等
    * @return 转换后的字符串
    */
   public static String  byteToString(byte[] data, String charset){
       if(isEmpty(data)){
           return "";
       }
       if(isEmpty(charset)){
           return new String(data);
       }
       try {
           return new String(data, charset);
       } catch (UnsupportedEncodingException e) {
           System.out.println("byteToString:"+e);
           return new String(data);
       }
   }
   /**
    * 判断输入的字节数组是否为空
    *
    * @param  bytes 字节数组
    * @return boolean 空则返回true,非空则flase
    */
   public static boolean isEmpty(byte[] bytes){
       return null==bytes || 0==bytes.length;
   }
    /**
     * 判断输入的字符串参数是否为空
     *
     * @param input 字符串
     * @return boolean 空则返回true,非空则flase
     */
   public static boolean isEmpty(String input) {
       return null==input || 0==input.length() || 0==input.replaceAll("\\s", "").length();
   }
   /**
    * 保留几位小数
    * @param number
    * @param formNum 要保留的个数
    * @return 返回doble类型
    */
   public static double getDobuleNumber(double number, int formNum){
       BigDecimal T = new BigDecimal(number);
       double  formartNumber = T.setScale(formNum,BigDecimal.ROUND_HALF_UP).doubleValue();
       return formartNumber;
   }
   /**
    * 字节转换bite
    * @param b
    * @return byte转换字符串
    */
   public static String byteToBit(byte b) {
       return "" +(byte)((b >> 7) & 0x1) +
               (byte)((b >> 6) & 0x1) +
               (byte)((b >> 5) & 0x1) +
               (byte)((b >> 4) & 0x1) +
               (byte)((b >> 3) & 0x1) +
               (byte)((b >> 2) & 0x1) +
               (byte)((b >> 1) & 0x1) +
               (byte)((b >> 0) & 0x1);
   }
   /**
    * short 类型转换byte数组
    * @param s
    * @return 返回byte数组
    */
   public static byte[] shortToByteArray(short s) {
       /*      byte[] targets = new byte[2];
       for (int i = 0; i < 2; i++) {
           int offset = (targets.length - 1 - i) * 8;
           targets[i] = (byte) ((s >>> offset) & 0xff);
       }  */
     //小端
       byte[] targets = new byte[2];
       targets[0] = (byte) (0xff & s);
       targets[1] = (byte) ((0xff00 & s) >> 8);
       return targets;
   }
   /**
    * 根据short类型转换btye数组
    * @param number
    * @return 返回byte数组
    */
   public static byte[] shortToByte(short number) {
       int temp = number;
       byte[] b = new byte[2];
       for (int i = 0; i < b.length; i++) {
           b[i] = new Integer(temp & 0xff).byteValue();// 将最低位保存在最低位
           temp = temp >> 8; // 向右移8位
       }
       return b;
   }
   /**
    * int 类型转换byte数组
    * @param intValue
    * @return 返回btye数组
    */
   public static byte[] int2Byte(int intValue) {
       byte[] b = new byte[4];
      /* for (int i = 0; i < 4; i++) {
           b[i] = (byte) (intValue >> 8 * (3 - i) & 0xFF);
           //System.out.print(Integer.toBinaryString(b[i])+" ");
           //System.out.print((b[i] & 0xFF) + " ");
       }*/
       b[0] = (byte) (intValue & 0xff);
       b[1] = (byte) (intValue >> 8 & 0xff);
       b[2] = (byte) (intValue >> 16 & 0xff);
       b[3] = (byte) (intValue >> 24 & 0xff);
       return b;
   }
   /**
    * 4位字节数组转换为整型
    * @param b
    * @return 返回int类型
    */
   public static int byte2Int(byte[] b) {
      /* int intValue = 0;
       for (int i = 0; i < b.length; i++) {
           intValue += (b[i] & 0xFF) << (8 * (3 - i));
       }
       return intValue;*/
       int resInt = 0;//结合变量
       byte btemp;
       for (int i = 0; i < 4; i++) {
           btemp = b[i];
           resInt += (btemp & 0xFF) << (8 * i);
       }
       return resInt;
   }
   /**
    * 转换为short类型
    * @param b
    * @return 返回short类型
    */
   public static short byte2Short(byte[] b) {
       return (short) (((b[0 + 1] << 8) | b[0 + 0] & 0xff));
      // return (short) (((b[0] << 8) | b[0 + 1] & 0xff));
       // 大端
       /*short res;
       res = (short) (b[0] & 0xff);
       res |= ((b[1] << 8) & 0xff);
       return res;*/
   }
   /**
    * 根据传过来5个int参数转换成short类型 ,此方法适合前导数据,数据标示类型转换成short
    * @param dataType 数据类型
    * @param protocolType  协议类性
    * @param senderType 发送类型
    * @param enType 是否加密
    * @param coType 是否压缩
    * @return 根据移位返回short类型
    */
   public static short buildShort(int dataType, int protocolType, int senderType, int enType, int coType) {
       short type = 0;//数据类型
       //移位操作 左移n int 左侧高位丢丢失几位,右侧高位就 补几个0
       type |= (dataType << 0);
       type |= (protocolType << 4);
       type |= (senderType << 8);
       type |= (enType << 12);
       type |= (coType << 14);
       return type;
   }
   /**
    * 把ip地址存入到4个字节里面,如:192.168.1.123
    * @param IP1 如第一位192
    * @param IP2  如ip第二位168
    * @param IP3  1
    * @param IP4  如123
    * @return 根据移为把ip地址存储4个字节里面
    */
   public static int buildIPAddr(int IP1, int IP2, int IP3, int IP4) {
       int type = 0;//数据类型
       //移位操作 左移n int 左侧高位丢丢失几位,右侧高位就 补几个0
       type |= (IP1 << 0);
       type |= (IP2 << 8);
       type |= (IP3 << 16);
       type |= (IP4 << 24);
       return type;
   }
   /**
    * 骆驼峰结构: 比如gmt_modify ==> gmtModify
    * @param columName
    * @return 返回骆驼峰结构字符串
    */
   public static String camelName(String columName) {
       columName = columName.toLowerCase();
        char[] chars = columName.toCharArray();
        char[] result = new char[chars.length];
        int curpos = 0;
        boolean upperCaseNext = false;
        for(char ch:chars){
            if(ch == '_'){
                upperCaseNext = true;
            }else if(upperCaseNext){
                result[curpos++] = Character.toUpperCase(ch);
                upperCaseNext = false;
            }else{
                result[curpos++] = ch;
            }
        }
        return new String(result,0,curpos);
   }
   /**
    * 除去数组中的空值和签名参数
    * @param sArray 签名参数组
    * @return 去掉空值与签名参数后的新签名参数组
    */
   public static Map<String, Object> paraFilter(Map<String, Object> sArray) {
       Map<String, Object> result = new HashMap<String, Object>();
       if (sArray == null || sArray.size() <= 0) {
           return result;
       }
       for (String key : sArray.keySet()) {
           String value = Util.varFormat(sArray.get(key));
           if (value == null || "".equals(value)) {
               continue;
           }
           result.put(key, value);
       }
       return result;
   }
   /**
    * 把数组所有元素排序,并按照“参数=参数值”的模式用“&”字符拼接成字符串
    * @param params 需要排序并参与字符拼接的参数组
    * @return 拼接后字符串
    */
   public static String createLinkString(Map<String, Object> params) {
       List<String> keys = new ArrayList<String>(params.keySet());
       Collections.sort(keys);
       String prestr = "";
       for (int i = 0; i < keys.size(); i++) {
           String key = keys.get(i);
           String value = Util.varFormat(params.get(key));
           if (i == keys.size() - 1) {//拼接时,不包括最后一个&字符
               prestr = prestr + key + "=" + value;
           } else {
               prestr = prestr + key + "=" + value + "&";
           }
       }
       return prestr;
   }
   /**
    * MD5加密,可返回32位、16位根据需要调整
    * @param sourceStr
    * @return 返回32位的md5值
    */
   public static String strToMd5(String sourceStr) {
       String result = "";
       try {
           MessageDigest md = MessageDigest.getInstance("MD5");
           md.update(sourceStr.getBytes());
           byte b[] = md.digest();
           int i;
           StringBuffer buf = new StringBuffer(100);
           for (int offset = 0; offset < b.length; offset++) {
               i = b[offset];
               if (i < 0) {
                   i += 256;
               }
               if (i < 16) {
                   buf.append("0");
               }
               buf.append(Integer.toHexString(i));
           }
           result = buf.toString();
           System.out.println("MD5(" + sourceStr + ",32) = " + result);
           System.out.println("MD5(" + sourceStr + ",16) = " + buf.toString().substring(8, 24));
       } catch (NoSuchAlgorithmException e) {
           System.out.println(e);
       }
       return result;
   }
   /**
    * 将指定字符串src,以每两个字符分割转换为16进制形式 如:"2B44EFD9" –> byte[]{0x2B, 0×44, 0xEF,
    * 0xD9}
    * @param src
    *            String
    * @return byte[]
    */
   public static byte[] HexString2Bytes(String src) {
       if (null == src || 0 == src.length()) {
           return null;
       }
       byte[] ret = new byte[src.length() / 2];
       byte[] tmp = src.getBytes();
       for (int i = 0; i < (tmp.length / 2); i++) {
           ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
       }
       return ret;
   }
   /**
    * 将两个ASCII字符合成一个字节; 如:"EF"–> 0xEF
    * @param src0
    *            byte
    * @param src1
    *            byte
    * @return byte
    */
   public static byte uniteBytes(byte src0, byte src1) {
       byte _b0 = Byte.decode("0x" + new String(new byte[] {src0})).byteValue();
       _b0 = (byte) (_b0 << 4);
       byte _b1 = Byte.decode("0x" + new String(new byte[] { src1 })).byteValue();
       byte ret = (byte) (_b0 ^ _b1);
       return ret;
   }
   /**
    *
    * 保留2位有效数据
    * @param data
    * @return 获取保留2位的字符串
    */
   public static String getTwoDoble(double data){
       DecimalFormat    df   = new DecimalFormat("######0.00");
       return df.format(data);
   }
    //implements Serializable
/*    private void writeObject(ObjectOutputStream oos) throws IOException {
        oos.defaultWriteObject();
    }
    private void readObject(ObjectInputStream ois) throws ClassNotFoundException,IOException {
        ois.defaultReadObject();
    }*/
    /**
     * 拼接日志字符串
     * @param fieldsMap
     * @param map
     * @param valueMap
     * @return
     */
    public static String jointLogContent(Map fieldsMap,Map<String, String> map,Map<String, String> valueMap){
        StringBuilder content = new StringBuilder();
        if (map.size() > 0) {
            for (Map.Entry<String, String> entry : map.entrySet()) {
                if (null != fieldsMap.get(entry.getKey())) {
                    content.append(fieldsMap.get(entry.getKey()));
                    content.append(entry.getValue());
                    content.append(valueMap.get(entry.getKey()));
                    content.append(";");
                }
            }
        }
        return content.toString();
    }
}
package com.soft.exam.utility;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.util.Properties;
/**
 * <p>PropertiesUtil.java此类用于加载系统属性文件</p>
 * <p>@author:hhh</p>
 * <p>@date:2015年11月23日</p>
 * <p>@remark:</p>
 */
public class PropertiesUtil {
    public static final Logger logger = LoggerFactory.getLogger(PropertiesUtil.class);
    static Properties prop = new Properties();
    static{
      try
      {
        // path 不以’/'开头时默认是从此类所在的包下取资源,以’/'开头则是从ClassPath根下获
        prop.load(PropertiesUtil.class.getResourceAsStream("/config.properties"));
      } catch (IOException e) {
          logger.error("加载系统属性文件失败", e);
      }
    }
    public static String getValue(String key){
      String str = prop.getProperty(key);
      if (str == null) {
        str = "";
      }
      return str;
    }
}
package com.soft.exam.utility;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * @author <a href="https://github.com/binarywang">Binary Wang</a>
 */
public class JsonUtils {
    private static Logger logger = LogManager.getLogger(JsonUtil.class);
    private static ObjectMapper objectMapper = new ObjectMapper();
    public static String objectTojson(Object object) {
        return JSON.toJSONString(object, SerializerFeature.WriteMapNullValue, SerializerFeature.WriteNullStringAsEmpty, SerializerFeature.WriteNullNumberAsZero, SerializerFeature.WriteDateUseDateFormat);
    }
    public static String listTojson(List list) {
        return JSON.toJSONString(list, SerializerFeature.WriteDateUseDateFormat);
    }
    /**
     * 把json数据转换成类 T
     *
     * @param json
     * @param clazz
     * @return
     */
    public static <T> T fromJson(String json, Class<T> clazz) {
        return JSON.parseObject(json, clazz);
    }
    /**
     * 把json数据转换成 list<T> 类型
     *
     * @param json
     * @param clazz
     * @return
     */
    public static <T> List<T> fromJsonToList(String json, Class<T> clazz) {
        return JSON.parseArray(json, clazz);
    }
    /**
     * 字符串Json格式转换为对象Map
     *
     * @param strJson {"username":"sxb"}
     * @return
     */
    public static Map<String, Object> jsonToMap(String strJson) {
        Map<String, Object> jsoMap = new HashMap<String, Object>();
        try {
            jsoMap = JSONObject.parseObject(strJson, Map.class);
            //jsoMap =  JSONArray.parseObject(strJson,Map.class);
        } catch (JSONException e) {
            logger.error("Json格式转换为对象Map入参strJson打印:{}", strJson);
            logger.error("Json格式转换为对象Map异常", e);
        }
        return jsoMap;
    }
    /**
     * 字符串Json 转换为对象List
     *
     * @param strJson [{"username":"sxb"}]
     * @return
     */
    public static List<Map<String, Object>> jsonToList(String strJson) {
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
        try {
            list = JSONObject.parseObject(strJson, List.class);
        } catch (JSONException e) {
            logger.error("Json转换为对象List入参strJson打印:{}", strJson);
            logger.error("Json转换为对象List异常", e);
        }
        return list;
    }
    /**
     * Json字符数组  转换为对象list
     *
     * @param
     * @return
     */
    public static List<Map<String, Object>> jsonarrToList(String strJson) {
        List<Map<String, Object>> listObjectSec = new ArrayList<Map<String, Object>>();
        try {
            listObjectSec = JSONArray.parseObject(strJson, List.class);
        } catch (JSONException e) {
            logger.error("Json转换为对象List入参strJson打印:{}", strJson);
            logger.error("Json转换为对象List异常", e);
        }
        System.out.println(listObjectSec);
        return listObjectSec;
    }
    /**
     * 将json转换成对象Class
     *
     * @param src
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T jsonToObject(String src, Class<T> clazz) {
        if (src == null || src == "" || clazz == null) {
            return null;
        }
        try {
            return clazz.equals(String.class) ? (T) src : objectMapper.readValue(src, clazz);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    public static void main(String[] args) {
        String strArr = "[{\"0\":\"zhangsan\",\"1\":\"lisi\",\"2\":\"wangwu\",\"3\":\"maliu\"}," +
                "{\"00\":\"zhangsan\",\"11\":\"lisi\",\"22\":\"wangwu\",\"33\":\"maliu\"}]";
        //jsonarrToList(strArr);
        jsonarrToList(strArr);
    }
}
package com.soft.exam.utility;
import cn.hutool.core.util.StrUtil;
import com.dingtalk.api.DefaultDingTalkClient;
import com.dingtalk.api.DingTalkClient;
import com.dingtalk.api.request.CorpMessageCorpconversationAsyncsendRequest;
import com.dingtalk.api.response.CorpMessageCorpconversationAsyncsendResponse;
import com.taobao.api.ApiException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * <p>DingTalkUtil.java此类用于钉钉自定义机器人</p>
 * <p>@author:hhh</p>
 * <p>@date:2018年8月20日</p>
 * <p>@remark:</p>
 */
public class DingTalkUtil {
    private final static Logger log = LoggerFactory.getLogger(DingTalkUtil.class);
    private static long agentId;
    private static String corpId;
    private static String corpSecret;
    private static String serverUrl;
    static {
        agentId = Long.parseLong(PropertiesUtil.getValue("dingtalk.agentid"));
        corpId = PropertiesUtil.getValue("dingtalk.corpid");
        corpSecret = PropertiesUtil.getValue("dingtalk.corpsecret");
        serverUrl = PropertiesUtil.getValue("dingtalk.serverurl");
    }
    /**
     * 向钉钉发送消息
     *
     * @param title    标题
     * @param userList 用户Id 多个人用逗号隔开 333,444
     * @param connect  内容
     * @param author   发送的作者,如果无 可为空""
     */
    public static void sendDingMsg(String title, String userList, String connect, List<Map<String, Object>> fromList, String author) {
        DingTalkClient client = new DefaultDingTalkClient(serverUrl);
        CorpMessageCorpconversationAsyncsendRequest req = new CorpMessageCorpconversationAsyncsendRequest();
        req.setMsgtype("oa");
        // 188915017L
        req.setAgentId(agentId);
        req.setUseridList(userList);
        req.setToAllUser(false);
        Map<String, Object> msgMap = new HashMap<>();
        msgMap.put("message_url", "");
        Map<String, Object> headMap = new HashMap<>();
        headMap.put("bgcolor", "FFBBBBBB");
        headMap.put("text", title);
        msgMap.put("head", headMap);
        Map<String, Object> bodyMap = new HashMap<>();
        bodyMap.put("title", title);
        bodyMap.put("form", fromList);
        bodyMap.put("content", connect);
        bodyMap.put("author", author);
        msgMap.put("body", bodyMap);
        req.setMsgcontentString(JsonUtils.objectTojson(msgMap));
        CorpMessageCorpconversationAsyncsendResponse rsp;
        try {
            // 是否开启钉钉提醒
            String isOpen = PropertiesUtil.getValue("dingtalk.isopen");
            if (StrUtil.isNotBlank(isOpen) && "true".equals(isOpen)) {
                rsp = client.execute(req, getDingToken());
                log.info(rsp.getBody());
            }
        } catch (ApiException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            log.error("sendDingMsg=-", e);
        }
    }
    /**
     * 向钉钉发送消息
     *
     * @param title    标题
     * @param userList 用户Id 多个人用逗号隔开 333,444
     * @param connect  内容
     * @param author   发送的作者,如果无 可为空""
     * @param token    令牌,减少令牌调用次数
     */
    public static void sendDingMsg(String title, String userList, String connect, List<Map<String, Object>> fromList, String author, String token) {
        DingTalkClient client = new DefaultDingTalkClient(serverUrl);
        CorpMessageCorpconversationAsyncsendRequest req = new CorpMessageCorpconversationAsyncsendRequest();
        req.setMsgtype("oa");
        req.setAgentId(agentId);
        req.setUseridList(userList);
        req.setToAllUser(false);
        Map<String, Object> msgMap = new HashMap<>();
        msgMap.put("message_url", "");
        Map<String, Object> headMap = new HashMap<>();
        headMap.put("bgcolor", "FFBBBBBB");
        headMap.put("text", title);
        msgMap.put("head", headMap);
        Map<String, Object> bodyMap = new HashMap<>();
        bodyMap.put("title", title);
        bodyMap.put("form", fromList);
        bodyMap.put("content", connect);
        bodyMap.put("author", author);
        msgMap.put("body", bodyMap);
        req.setMsgcontentString(JsonUtils.objectTojson(msgMap));
        CorpMessageCorpconversationAsyncsendResponse rsp;
        try {
            // 是否开启钉钉提醒
            String isOpen = PropertiesUtil.getValue("dingtalk.isopen");
            if (StrUtil.isNotBlank(isOpen) && "true".equals(isOpen)) {
                rsp = client.execute(req, token);
                log.info(rsp.getBody());
            }
        } catch (ApiException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            log.error("sendDingMsg=-", e);
        }
    }
    /**
     * 获取叮叮令牌
     *
     * @return
     */
    public static String getDingToken() {
        String result = "";
        String line;
        StringBuffer sb = new StringBuffer();
        BufferedReader in = null;
        Map<String, Object> rMap = new HashMap<>();
        try {
            String url = "https://oapi.dingtalk.com/gettoken?corpid=" + corpId + "&corpsecret=" + corpSecret;
            URL realUrl = new URL(url);
            // 打开和URL之间的连接
            URLConnection conn = realUrl.openConnection();
            // 设置通用的请求属性 设置请求格式
            conn.setRequestProperty("contentType", "utf-8");
            conn.setRequestProperty("content-type", "application/x-www-form-urlencoded");
            //设置超时时间
            conn.setConnectTimeout(6000);
            conn.setReadTimeout(6000);
            // 建立实际的连接
            conn.connect();
            // 定义 BufferedReader输入流来读取URL的响应,设置接收格式
            in = new BufferedReader(new InputStreamReader(
                    conn.getInputStream(), "utf-8"));
            while ((line = in.readLine()) != null) {
                sb.append(line);
            }
            result = sb.toString();
            rMap = JsonUtils.jsonToMap(result);
        } catch (Exception e) {
            System.out.println("发送GET请求出现异常!" + e);
            e.printStackTrace();
        }
        // 使用finally块来关闭输入流
        finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
        return Util.varFormat(rMap.get("access_token"));
    }
    public static void main(String[] args) {
        DingTalkUtil dingTalkUtil = new DingTalkUtil();
//        System.out.println(dingTalkUtil.getDingToken());
    }
}
package com.soft.exam.utility;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * 构建钉钉发送消息
 *
 * @author hhh
 * @date 2019-04-24
 */
public class DingDingMsg {
    private List<Map<String, Object>> mapList = new ArrayList<>();
    private DingDingMsg() {
    }
    public static DingDingMsg create(String key, String value) {
        return (new DingDingMsg()).builder(key, value);
    }
    public DingDingMsg builder(String key, String value) {
        Map<String, Object> map = new HashMap<>();
        map.put("key", key);
        map.put("value", value);
        mapList.add(map);
        return this;
    }
    public List<Map<String, Object>> collect() {
        return this.mapList;
    }
}


相关文章
|
14天前
|
Java
Java中的抽象类:深入了解抽象类的概念和用法
Java中的抽象类是一种不能实例化的特殊类,常作为其他类的父类模板,定义子类行为和属性。抽象类包含抽象方法(无实现)和非抽象方法。定义抽象类用`abstract`关键字,子类继承并实现抽象方法。抽象类适用于定义通用模板、复用代码和强制子类实现特定方法。优点是提供抽象模板和代码复用,缺点是限制继承灵活性和增加类复杂性。与接口相比,抽象类可包含成员变量和单继承。使用时注意设计合理的抽象类结构,谨慎使用抽象方法,并遵循命名规范。抽象类是提高代码质量的重要工具。
26 1
|
19天前
|
监控 JavaScript 前端开发
《理解 WebSocket:Java Web 开发的实时通信技术》
【4月更文挑战第4天】WebSocket是Java Web实时通信的关键技术,提供双向持久连接,实现低延迟、高效率的实时交互。适用于聊天应用、在线游戏、数据监控和即时通知。开发涉及服务器端实现、客户端连接及数据协议定义,注意安全、错误处理、性能和兼容性。随着实时应用需求增加,WebSocket在Java Web开发中的地位将更加重要。
|
1月前
|
前端开发 Java
java中的Queue队列的用法
java中的Queue队列的用法
19 1
|
1月前
|
XML Java 编译器
java aspectjrt AOP 用法
java aspectjrt AOP 用法
21 0
|
4天前
|
IDE Java 数据库连接
使用 Java 进行桌面应用开发
【4月更文挑战第19天】Java 是一款广泛应用于企业级、网络和桌面应用开发的编程语言。其跨平台特性使Java程序能在不同操作系统上运行,而JDK提供了开发所需工具和库。使用Swing等GUI库构建用户界面,结合JDBC进行数据库操作,Socket实现网络通信。虽然面临性能和用户体验的挑战,但通过优化和选用合适的IDE,Java仍能开发出高效稳定的桌面应用。
|
4天前
|
JSON Java 数据格式
Java QueryWrapper基本用法
Java QueryWrapper基本用法
12 2
|
4天前
|
前端开发 Java Go
开发语言详解(python、java、Go(Golong)。。。。)
开发语言详解(python、java、Go(Golong)。。。。)
|
4天前
|
前端开发 NoSQL JavaScript
java域控连接AD遇到的问题
java域控连接AD遇到的问题
|
5天前
|
人工智能 前端开发 Java
Java语言开发的AI智慧导诊系统源码springboot+redis 3D互联网智导诊系统源码
智慧导诊解决盲目就诊问题,减轻分诊工作压力。降低挂错号比例,优化就诊流程,有效提高线上线下医疗机构接诊效率。可通过人体画像选择症状部位,了解对应病症信息和推荐就医科室。
30 10
|
5天前
|
Java 关系型数据库 MySQL
一套java+ spring boot与vue+ mysql技术开发的UWB高精度工厂人员定位全套系统源码有应用案例
UWB (ULTRA WIDE BAND, UWB) 技术是一种无线载波通讯技术,它不采用正弦载波,而是利用纳秒级的非正弦波窄脉冲传输数据,因此其所占的频谱范围很宽。一套UWB精确定位系统,最高定位精度可达10cm,具有高精度,高动态,高容量,低功耗的应用。
一套java+ spring boot与vue+ mysql技术开发的UWB高精度工厂人员定位全套系统源码有应用案例

热门文章

最新文章