本文目录
另外一种实现方式,更加简单,代码粘下来就可以用:【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("&", "&");
}
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;
/**
* <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;
}
}