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

柔情只为你懂 2022-12-24 01:51 546阅读 0赞

**本文目录**

项目背景

步骤一、添加依赖

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

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

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

--------------------

另外一种实现方式，更加简单，代码粘下来就可以用：[【Java用法】拿来即用--使用Java开发连接钉钉H5微应用实现钉钉通知提醒的功能（方式二）][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 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDI5OTAyNw_size_16_color_FFFFFF_t_70][]

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

/**
 * 保存考试人员或者部门后，如果开启钉钉通知，则开始开启另一条线程执行钉钉通知
 *
 * @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.*;
 
 
 /**
 * Util.java此类用于工具组件
 * @author:hhh
 * @date:2012-2-23
 * @remark:提供一些常用的时间和字符串方法
 */
 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("&", "&");
 }
 if (c.indexOf("<") != -1) {
 s = s.replaceAll("<", "<");
 }
 if (c.indexOf(">") != -1) {
 s = s.replaceAll(">", ">");
 }
 if (c.indexOf("\"") != -1) {
 s = s.replaceAll("\"", """);
 }
 if (c.indexOf("'") != -1) {
 s = s.replaceAll("'", "'");
 }
 if (c.indexOf(" ") != -1) {
 s = s.replaceAll(" ", " ");
 }
 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;
 
 /**
 * PropertiesUtil.java此类用于加载系统属性文件
 * @author:hhh
 * @date:2015年11月23日
 * @remark:
 */
 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;
 
 /**
 * DingTalkUtil.java此类用于钉钉自定义机器人
 * @author:hhh
 * @date:2018年8月20日
 * @remark:
 */
 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;
 }
 
 }

[Java_--_Java_H5]: https://blog.csdn.net/weixin_44299027/article/details/117714100
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDI5OTAyNw_size_16_color_FFFFFF_t_70]: /images/20221120/d02c4d2c14d640cc8d61f2aa26597973.png