devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

企微群机器人推送文本+Excel_企微机器人发送文件

作者：知新_RL | 2024-05-06 05:38:55

赞

踩

企微机器人发送文件

例如，企微群定时推送：内容+表格

群机器人：学校基本信息：

[一个记录学校基本信息的excel表]

 excel表简单类似：

准备肯定先企微群创建一个机器人，获取到群webhook备用;

简易步骤比较简单，先分别获取老师、学生、职工的list信息->再把列表转化为excel表->推送消息

 一、推送工具类;（isNotBank之类的判空方法，可以自行重写）

  1.  
  2. import lombok.extern.slf4j.Slf4j;
  3. import okhttp3.*;
  4. import org.apache.poi.hssf.usermodel.HSSFWorkbook;
  5.  
  6. import java.io.File;
  7. import java.util.ArrayList;
  8. import java.util.List;
  9. import java.util.Map;
  10. import java.util.concurrent.TimeUnit;
  11.  
  12. /**
  13.  * @author yrl
  14.  * @date 2023/7/5 15:29
  15.  */
  16. @Slf4j
  17. public class WxPushUtil {
  18.  
  19.     /**
  20.      * 企业微信机器人api地址与key；webhook 截取
  21.      */
  22.     private final static String WECHAT_API_URL = "https://qyapi.weixin.qq.com/cgi-bin/webhook/";
  23.     private final static String WECHAT_API_KEY = "xxxxx-xxx-xxx-xxxxxxxxxxxxxxxxx";
  24.  
  25.  
  26.     /**
  27.      * 学生列表数据转化为 excel
  28.      *
  29.      * @param wb       Workbook
  30.      * @param student  学生
  31.      * @param dest     首栏提示 默认可空
  32.      * @param pageName 底部分页表名称
  33.      */
  34.     public static boolean studentFileBuild(HSSFWorkbook wb, List<student> student, String dest, String pageName) {
  35.         //
  36.         if (student == null || student.size() < 0) {
  37.             return false;
  38.         }
  39.         //表头字段，与对象一致
  40.         String[] titleArray = new String[]{"学生姓名", "年龄", "性别", "班级"};
  41.         String[] fieldArray = new String[]{"studentName", "age", "sex", "class"};
  42.         List<Map<String, Object>> list = new ArrayList<>();
  43.  
  44.         for (Student s : student) {
  45.             //转成map
  46.             Map<String, Object> map = BeanUtils.beanToMap(s);
  47.             list.add(map);
  48.         }
  49.  
  50.         if (list.size() > 0) {
  51.             //数据组合 到HSSFWorkbook
  52.             ExcelUtil.buildExcel(list, wb, pageName, titleArray, fieldArray, dest);
  53.             return true;
  54.         }
  55.         return false;
  56.     }
  57.  
  58.     /**
  59.      * 老师 数据转化为excel构建
  60.      *
  61.      * @param wb       Workbook
  62.      * @param teacher  老师
  63.      * @param dest     首栏提示 默认可空
  64.      * @param pageName 底部分页表名称
  65.      */
  66.     public static boolean teacherFileBuild(HSSFWorkbook wb, List<Teacher> teacher, String dest, String pageName) {
  67.         //
  68.         if (teacher == null || teacher.size() < 0) {
  69.             return false;
  70.         }
  71.         //表头字段，与对象一致
  72.         String[] titleArray = new String[]{"工号", "姓名", "性别", "职位"};
  73.         String[] fieldArray = new String[]{"number", "name", "sex", "lev"};
  74.         List<Map<String, Object>> list = new ArrayList<>();
  75.  
  76.         for (Teacher s : teacher) {
  77.             //转成map
  78.             Map<String, Object> map = BeanUtils.beanToMap(s);
  79.             list.add(map);
  80.         }
  81.  
  82.         if (list.size() > 0) {
  83.             //数据组合 到HSSFWorkbook
  84.             ExcelUtil.buildExcel(list, wb, pageName, titleArray, fieldArray, dest);
  85.             return true;
  86.         }
  87.         return false;
  88.     }
  89.  
  90.     /**
  91.      * 发送文件消息，需要先将文件上传到企业微信临时素材，再根据获取的media_id调用群机器人
  92.      *
  93.      * @param file      需要发送的文件
  94.      * @param text      发送附件的同时需要发送文字内容
  95.      * @param phoneList 需要@的群成员手机号
  96.      */
  97.     public static void sendFileMsg(File file, String text, List<String> phoneList) {
  98.         // 构造RequestBody对象，用来携带要提交的数据；需要指定MediaType，用于描述请求/响应 body 的内容类型
  99.         MediaType contentType = MediaType.parse("application/form-data; boundary");
  100.         RequestBody body = RequestBody.create(contentType, file);
  101.         RequestBody requestBody = new MultipartBody.Builder()
  102.                 .setType(MultipartBody.FORM)
  103.                 .addFormDataPart("file", file.getName(), body)
  104.                 .build();
  105.  
  106.         try {
  107.             //获取推送的群id，如果多个，推送多个
  108.             // 上传到临时素材
  109.             String mediaUrl = WECHAT_API_URL + "upload_media?type=file&key=" + WECHAT_API_KEY;
  110.             log.debug("将文件{}上传到临时素材：{}", file.getName(), mediaUrl);
  111.             String respMsg = okHttp(requestBody, mediaUrl);
  112.             log.debug("将文件{}上传到临时素材：{}, {}", file.getName(), mediaUrl, respMsg);
  113.  
  114.             // 获取临时素材id
  115.             JSONObject result = JSONUtil.parseObj(respMsg);
  116.             String mediaId = result.getStr("media_id");
  117.  
  118.             if (U.isNotBlank(text)) {
  119.                 JSONObject textJson = new JSONObject();
  120.                 textJson.set("content", text);
  121.                 JSONObject reqBody = new JSONObject();
  122.                 //先推文本
  123.                 reqBody.set("msgtype", "text");
  124.                 reqBody.set("text", textJson);
  125.                 //"mentioned_mobile_list":["13800001111","@all"]
  126.                 if (A.isNotEmpty(phoneList)) {
  127.                     System.out.println("推送的手机号：" + phoneList);
  128.                     reqBody.set("mentioned_mobile_list", phoneList);
  129.                 }
  130.  
  131.                 // 调用群机器人发送消息
  132.                 callWeChatBot(reqBody.toString(), WECHAT_API_KEY);
  133.             }
  134.  
  135.             JSONObject fileJson = new JSONObject();
  136.             fileJson.set("media_id", mediaId);
  137.             JSONObject reqBody = new JSONObject();
  138.             //再推文件
  139.             reqBody.set("msgtype", "file");
  140.             reqBody.set("file", fileJson);
  141.             reqBody.set("safe", 0);
  142.  
  143.             // 再调用群机器人发送文件消息
  144.             callWeChatBot(reqBody.toString(), WECHAT_API_KEY);
  145.         } catch (Exception e) {
  146.             log.error("文件推送异常:{}", file.getName(), e);
  147.         }
  148.     }
  149.  
  150.  
  151.     /**
  152.      * @param body 携带需要提交的数据（后续迁移）
  153.      * @param url  请求地址
  154.      * @throws Exception 异常
  155.      */
  156.     private static String okHttp(RequestBody body, String url) throws Exception {
  157.         // 构造和配置OkHttpClient
  158.         OkHttpClient client = new OkHttpClient.Builder()
  159.                 // 设置连接超时时间
  160.                 .connectTimeout(10, TimeUnit.SECONDS)
  161.                 // 设置读取超时时间
  162.                 .readTimeout(20, TimeUnit.SECONDS)
  163.                 .build();
  164.  
  165.         // 构造Request对象
  166.         Request request = new Request.Builder()
  167.                 .url(url)
  168.                 .post(body)
  169.                 // 响应消息不缓存
  170.                 .addHeader("cache-control", "no-cache")
  171.                 .build();
  172.  
  173.         // 构建Call对象，通过Call对象的execute()方法提交异步请求
  174.         Response response = client.newCall(request).execute();
  175.  
  176.         // 请求结果处理
  177.         assert response.body() != null;
  178.         byte[] datas = response.body().bytes();
  179.         return new String(datas);
  180.     }
  181.  
  182.     /**
  183.      * 调用群机器人
  184.      *
  185.      * @param reqBody 接口请求参数
  186.      * @throws Exception 异常
  187.      */
  188.     private static void callWeChatBot(String reqBody, String key) throws Exception {
  189.         log.debug("调用群机器人：{}", reqBody);
  190.         // 构造RequestBody对象，用来携带要提交的数据；需要指定MediaType，用于描述请求/响应 body 的内容类型
  191.         okhttp3.MediaType contentType = okhttp3.MediaType.parse("application/json; charset=utf-8");
  192.         RequestBody body = RequestBody.create(contentType, reqBody);
  193.  
  194.         String botUrl = WECHAT_API_URL + "send?key=" + key;
  195.         // 调用群机器人
  196.         String respMsg = okHttp(body, botUrl);
  197.         JSONObject result = JSONUtil.parseObj(respMsg);
  198.  
  199.         if ("0".equals(result.getStr("errcode"))) {
  200.             log.debug("调用群机器人发送消息成功, reqBody: {}, respMsg : {}", reqBody, respMsg);
  201.         } else {
  202.             log.error("调用群机器人发送消息失败, reqBody: {}, respMsg : {}", reqBody, respMsg);
  203.         }
  204.     }
  205. }

二、EXCEL工具类（list转化等）有些方法可能用不到

  1.  
  2. import org.apache.commons.lang3.StringUtils;
  3. import org.apache.poi.hssf.usermodel.*;
  4. import org.apache.poi.hssf.util.HSSFColor;
  5. import org.apache.poi.ss.usermodel.*;
  6. import org.apache.poi.ss.util.CellRangeAddress;
  7. import org.apache.poi.ss.util.CellRangeAddressList;
  8. import org.apache.poi.xssf.usermodel.XSSFCell;
  9. import org.apache.poi.xssf.usermodel.XSSFRow;
  10. import org.apache.poi.xssf.usermodel.XSSFSheet;
  11. import org.apache.poi.xssf.usermodel.XSSFWorkbook;
  12. import org.springframework.web.multipart.MultipartFile;
  13.  
  14. import java.io.IOException;
  15. import java.lang.reflect.Field;
  16. import java.math.BigDecimal;
  17. import java.text.NumberFormat;
  18. import java.text.SimpleDateFormat;
  19. import java.time.LocalDate;
  20. import java.time.LocalDateTime;
  21. import java.time.format.DateTimeFormatter;
  22. import java.util.*;
  23.  
  24. /**
  25.  * Excel工具类
  26.  */
  27. public class ExcelUtil<T> {
  28.  
  29.     public Class<T> clazz;
  30.  
  31.     public ExcelUtil(Class<T> clazz) {
  32.         this.clazz = clazz;
  33.     }
  34.  
  35.  
  36.     /**
  37.      * 读取Excel内容转为List
  38.      */
  39.     public List<T> importExcel(MultipartFile file) throws Exception {
  40.         return importExcel(StringUtils.EMPTY, file);
  41.     }
  42.  
  43.  
  44.     /**
  45.      * 读取Excel内容转为List
  46.      */
  47.     public List<T> importExcel(String sheetName, MultipartFile file) throws Exception {
  48.         U.assertException(U.isBlank(file), "上传的文件为空");
  49.         //获取文件名
  50.         String fileName = file.getOriginalFilename();
  51.         U.assertException(!(fileName.endsWith(".xls") || fileName.endsWith(".xlsx")), "请选择Excel文件上传");
  52.         //
  53.         List<T> list = new ArrayList<>();
  54.         Workbook workbook = WorkbookFactory.create(file.getInputStream());
  55.         Sheet sheet;
  56.         if (StringUtils.isNotEmpty(sheetName)) {
  57.             // 如果指定sheet名,则取指定sheet中的内容.
  58.             sheet = workbook.getSheet(sheetName);
  59.         } else {
  60.             // 如果传入的sheet名不存在则默认指向第1个sheet.
  61.             sheet = workbook.getSheetAt(0);
  62.         }
  63.         if (sheet == null) {
  64.             throw new IOException("文件sheet不存在");
  65.         }
  66.         //获取数据
  67.         int rows = sheet.getLastRowNum();
  68.         if (rows == 0) {
  69.             U.assertException("当前工作簿没数据");
  70.         }
  71.         //行号从0开始，所以需要+1
  72.         rows = rows + 1;
  73.         // 默认序号
  74.         int serialNum = 0;
  75.         // 有数据时才处理 得到类的所有field.
  76.         Field[] allFields = clazz.getDeclaredFields();
  77.         //用于校验是否存在某些字段
  78.         Map<String, Field> fieldNameMap = new HashMap<>();
  79.         // 定义一个map用于存放列的序号和field.
  80.         Map<Integer, Field> fieldsMap = new HashMap<>();
  81.         for (Field field : allFields) {
  82.             // 设置类的私有字段属性可访问.
  83.             field.setAccessible(true);
  84.             fieldsMap.put(++serialNum, field);
  85.             fieldNameMap.put(field.getName(), field);
  86.         }
  87.         //
  88.         DateTimeFormatter dtf = DateTimeFormatter.ofPattern(DateFormatType.YYYY_MM_DD_HH_MM_SS.getValue());
  89.         DateTimeFormatter df = DateTimeFormatter.ofPattern(DateFormatType.YYYY_MM_DD.getValue());
  90.         SimpleDateFormat sdf = new SimpleDateFormat(DateFormatType.YYYY_MM_DD_HH_MM_SS.getValue());
  91.         //
  92.         Row row = null;
  93.         Cell cell = null;
  94.         try {
  95.             // 从第2行开始取数据,默认第一行是表头.
  96.             for (int i = 1; i < rows; i++) {
  97.                 row = sheet.getRow(i);
  98.                 if (row == null) {
  99.                     continue;
  100.                 }
  101.                 T entity = clazz.newInstance();
  102.                 for (int j = 0; j < serialNum; j++) {
  103.                     cell = row.getCell(j);
  104.                     if (cell == null) {
  105.                         continue;
  106.                     }
  107.  
  108.                     // 从map中得到对应列的field.
  109.                     Field field = fieldsMap.get(j + 1);
  110.                     // 取得类型,并根据对象类型设置值.
  111.                     Class<?> fieldType = field.getType();
  112.  
  113.                     String c;
  114.                     //excel数字精度问题：如果是数字类型,转化
  115.                     if (cell.getCellTypeEnum().equals(CellType.NUMERIC) && fieldType != Date.class) {
  116.                         NumberFormat numberFormat = NumberFormat.getNumberInstance();
  117.                         double d = cell.getNumericCellValue();
  118.                         // 关键在这里！
  119.                         c = numberFormat.format(d);
  120.                     } else {
  121.                         // 先设置Cell的类型，然后就可以把纯数字作为String类型读进来了（这里数字类型 c可能存在精度问题）
  122.                         cell.setCellType(CellType.STRING);
  123.                         c = cell.getStringCellValue();
  124.                     }
  125.  
  126.                     if (StringUtils.isEmpty(c)) {
  127.                         continue;
  128.                     }
  129.                     if (String.class == fieldType) {
  130.                         field.set(entity, c);
  131.                     } else if ((Integer.TYPE == fieldType) || (Integer.class == fieldType)) {
  132.                         field.set(entity, Integer.parseInt(c));
  133.                     } else if ((Long.TYPE == fieldType) || (Long.class == fieldType)) {
  134.                         field.set(entity, Long.valueOf(c));
  135.                     } else if ((Float.TYPE == fieldType) || (Float.class == fieldType)) {
  136.                         field.set(entity, Float.valueOf(c));
  137.                     } else if ((Short.TYPE == fieldType) || (Short.class == fieldType)) {
  138.                         field.set(entity, Short.valueOf(c));
  139.                     } else if ((Double.TYPE == fieldType) || (Double.class == fieldType)) {
  140.                         field.set(entity, Double.valueOf(c));
  141.                     } else if (Character.TYPE == fieldType) {
  142.                         if (c.length() > 0) {
  143.                             field.set(entity, c.charAt(0));
  144.                         }
  145.                     } else if (Date.class == fieldType) {
  146.                         if (cell.getCellTypeEnum() == CellType.NUMERIC) {
  147.                             cell.setCellValue(sdf.format(cell.getNumericCellValue()));
  148.                             c = sdf.format(cell.getNumericCellValue());
  149.                         } else {
  150.                             c = cell.getStringCellValue();
  151.                         }
  152.                     } else if (BigDecimal.class == fieldType) {
  153.                         try {
  154.                             field.set(entity, NumberUtil.toBigDecimal(c));
  155.                         } catch (Exception ex) {
  156.                             U.assertException("数值类型转换失败，请检查单元格值是否符合规范");
  157.                         }
  158.                     } else if (LocalDateTime.class == fieldType) {
  159.                         field.set(entity, LocalDateTime.parse(excelDoubleToDate(c, DateFormatType.YYYY_MM_DD_HH_MM_SS), dtf));
  160.                     } else if (LocalDate.class == fieldType) {
  161.                         field.set(entity, LocalDate.parse(excelDoubleToDate(c, DateFormatType.YYYY_MM_DD), df));
  162.                     }
  163.                 }
  164.                 if (BeanUtil.isNotEmpty(entity)) {
  165.                     //判断是否有行号字段，有的话赋值
  166.                     if (fieldNameMap.containsKey("rowNum")) {
  167.                         //记录一下行数
  168.                         fieldNameMap.get("rowNum").set(entity, row.getRowNum() + 1);
  169.                     }
  170.                     list.add(entity);
  171.                 }
  172.             }
  173.         } catch (Exception ex) {
  174.             ex.printStackTrace();
  175.             U.assertException(StrUtil.format("解析第{}行，第{}列时出错，错误原因：{}",
  176.                     row == null ? "null" : row.getRowNum() + 1,
  177.                     cell == null ? "null" : cell.getColumnIndex() + 1,
  178.                     ex.getMessage()));
  179.         }
  180.         return list;
  181.     }
  182.  
  183.     //解析Excel日期格式
  184.     public static String excelDoubleToDate(String strDate, DateFormatType dateFormatType) {
  185.         try {
  186.             SimpleDateFormat sdf = new SimpleDateFormat(dateFormatType.getValue());
  187.             Date tDate = doubleToDate(Double.parseDouble(strDate));
  188.             return sdf.format(tDate);
  189.         } catch (Exception e) {
  190.             //e.printStackTrace();
  191.             return strDate;
  192.         }
  193.     }
  194.  
  195.     //解析Excel日期格式
  196.     public static Date doubleToDate(Double dVal) {
  197.         Date tDate = new Date();
  198.         long localOffset = tDate.getTimezoneOffset() * 60000; //系统时区偏移 1900/1/1 到 1970/1/1 的 25569 天
  199.         tDate.setTime((long) ((dVal - 25569) * 24 * 3600 * 1000 + localOffset));
  200.         return tDate;
  201.     }
  202.  
  203.  
  204.     /**
  205.      * 常规字体-微软雅黑-12号
  206.      */
  207.     public static HSSFFont getFont(HSSFWorkbook wb) {
  208.         HSSFFont font = wb.createFont();
  209.         font.setFontHeightInPoints((short) 12);//设置字体大小
  210.         font.setFontName("微软雅黑");
  211.         return font;
  212.     }
  213.  
  214.     /**
  215.      * 白色字体-微软雅黑-12号
  216.      */
  217.     public static HSSFFont getWhiteFont(HSSFWorkbook wb) {
  218.         HSSFFont font = wb.createFont();
  219.         font.setFontHeightInPoints((short) 12);//设置字体大小
  220.         font.setFontName("微软雅黑");
  221.         font.setColor(HSSFColor.HSSFColorPredefined.WHITE.getIndex());
  222.         font.setBold(true);
  223.         return font;
  224.     }
  225.  
  226.     /**
  227.      * 标题字体-微软雅黑-12号-加粗
  228.      */
  229.     public static HSSFFont getTitleFont(HSSFWorkbook wb) {
  230.         HSSFFont font = getFont(wb);
  231.         font.setBold(true);
  232.         return font;
  233.     }
  234.  
  235.     /**
  236.      * 常规字体-微软雅黑-12号-红色
  237.      */
  238.     public static HSSFFont getRedFont(HSSFWorkbook wb) {
  239.         HSSFFont font = getFont(wb);
  240.         font.setColor(Font.COLOR_RED);
  241.         return font;
  242.     }
  243.  
  244.     /**
  245.      * 单元格样式-自动换行-全边框-左右垂直居中
  246.      */
  247.     public static CellStyle getCellStyle(HSSFWorkbook wb, HSSFFont font) {
  248.         CellStyle style = wb.createCellStyle();//新建样式对象
  249.         style.setWrapText(true);//设置自动换行
  250.         style.setAlignment(HorizontalAlignment.CENTER);//居中
  251.         style.setVerticalAlignment(VerticalAlignment.CENTER);//居中
  252.         style.setBorderBottom(BorderStyle.THIN);//下边框
  253.         style.setBorderLeft(BorderStyle.THIN);//左边框
  254.         style.setBorderRight(BorderStyle.THIN);//右边框
  255.         style.setBorderTop(BorderStyle.THIN);//上边框
  256.         style.setFont(font);
  257.         return style;
  258.     }
  259.  
  260.     /**
  261.      * 单元格样式-自动换行-全边框-左右垂直居中-背景颜色
  262.      */
  263.     public static CellStyle getCellStyle(HSSFWorkbook wb, HSSFFont font, short bg) {
  264.         CellStyle style = getCellStyle(wb, font);
  265.         //设置背景色
  266.         style.setFillForegroundColor(bg);
  267.         //设置填充样式
  268.         style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
  269.         return style;
  270.     }
  271.  
  272.  
  273.     /**
  274.      * 设置下拉框(注意单元格内的字符不能超过255)
  275.      *
  276.      * @param sheet    指定sheet页
  277.      * @param values   下拉框的值
  278.      * @param firstRow 起始行号
  279.      * @param lastRow  起始行号
  280.      * @param firstCol 起始列号
  281.      * @param lastCol  终止列号
  282.      */
  283.     public static void setDropDownBox(HSSFSheet sheet, String[] values, Integer firstRow, Integer lastRow, Integer firstCol, Integer lastCol) {
  284.         // 加载下拉列表内容
  285.         DVConstraint constraint = DVConstraint.createExplicitListConstraint(values);
  286.         // 设置数据有效性加载在哪个单元格上,四个参数分别是：起始行、终止行、起始列、终止列
  287.         CellRangeAddressList regions = new CellRangeAddressList(firstRow, lastRow, firstCol, lastCol);
  288.         // 数据有效性对象
  289.         HSSFDataValidation data_validation_list = new HSSFDataValidation(regions, constraint);
  290.         sheet.addValidationData(data_validation_list);
  291.     }
  292.  
  293.  
  294.     /**
  295.      * sheet合并, 合并后删除数据源sheet
  296.      *
  297.      * @param workbook
  298.      * @param sourceSheet 数据源
  299.      * @param targetSheet 合并到
  300.      * @return
  301.      * @throws IOException
  302.      */
  303.     public static void mergeSheet(XSSFWorkbook workbook, int sourceSheet, int targetSheet) throws IOException {
  304.         final XSSFSheet target = workbook.getSheetAt(targetSheet);
  305.         final XSSFSheet source = workbook.getSheetAt(sourceSheet);
  306.         int lastRowNum = target.getLastRowNum();
  307.  
  308.         final List<CellRangeAddress> mergedRegions = source.getMergedRegions();
  309.  
  310.         //处理合并后的mergedRegion
  311.         for (CellRangeAddress mergedRegion : mergedRegions) {
  312.             mergedRegion.setFirstRow(mergedRegion.getFirstRow() + lastRowNum + 1);
  313.             mergedRegion.setLastRow(mergedRegion.getLastRow() + lastRowNum + 1);
  314.  
  315.         }
  316.  
  317.         //逐行复制
  318.         for (int i = 0; i <= source.getLastRowNum(); i++) {
  319.             final XSSFRow row = source.getRow(i);
  320.             if (row == null) {
  321.                 target.createRow(++lastRowNum);
  322.                 continue;
  323.             }
  324.             final Iterator<Cell> cellIterator = row.cellIterator();
  325.             final XSSFRow s1Row = target.createRow(++lastRowNum);
  326.             while (cellIterator.hasNext()) {
  327.                 final Cell next = cellIterator.next();
  328.                 final CellStyle cellStyle = next.getCellStyle();
  329.                 final XSSFCell cell = s1Row.createCell(next.getColumnIndex());
  330.                 final CellType cellType = next.getCellType();
  331.                 cell.setCellStyle(cellStyle);
  332.  
  333.                 switch (cellType) {
  334.                     case STRING:
  335.                         cell.setCellValue(next.getStringCellValue());
  336.                         break;
  337.                     case FORMULA:
  338.                         cell.setCellFormula(next.getCellFormula());
  339.                         continue;
  340.                     case NUMERIC:
  341.                         cell.setCellValue(next.getNumericCellValue());
  342.                         break;
  343.                     case BOOLEAN:
  344.                         cell.setCellValue(next.getBooleanCellValue());
  345.                 }
  346.                 cell.setCellType(cellType);
  347.             }
  348.         }
  349.  
  350.         for (CellRangeAddress mergedRegion : mergedRegions) {
  351.             target.addMergedRegion(mergedRegion);
  352.         }
  353.         //移除sourceSheet
  354.         workbook.removeSheetAt(sourceSheet);
  355.     }
  356.  
  357.     public static void buildExcel(List<Map<String, Object>> list, HSSFWorkbook wb, String sheetName, String[] titleArray, String[] fieldArray, String dest) {
  358.  
  359.         HSSFSheet sheet = wb.createSheet(sheetName);
  360.         //样式
  361.         //设置默认行高、列宽
  362.         sheet.setDefaultRowHeight((short) 500);
  363.         sheet.setDefaultColumnWidth(30);
  364.         //字体
  365.         HSSFFont font = getFont(wb);
  366.         //标题字体
  367.         HSSFFont titleFont = getWhiteFont(wb);
  368.         titleFont.setColor(HSSFColor.HSSFColorPredefined.BLACK.getIndex());
  369.         //标题样式
  370.         CellStyle titleStyle = getCellStyle(wb, titleFont, IndexedColors.GREY_25_PERCENT.getIndex());
  371.         //基础样式
  372.         CellStyle style = getCellStyle(wb, font);
  373.         style.setAlignment(HorizontalAlignment.LEFT);
  374.  
  375.         int firstRowNum = 0;
  376.         if (StringUtils.isNotBlank(dest)) {
  377.             HSSFFont destFont = getRedFont(wb);
  378.             CellStyle destStyle = getCellStyle(wb, destFont);
  379.             destStyle.setAlignment(HorizontalAlignment.LEFT);
  380.             Row rowDest = sheet.createRow(firstRowNum);
  381.             Cell bigDetailTitleCell = rowDest.createCell(0);
  382.             bigDetailTitleCell.setCellStyle(destStyle);
  383.             bigDetailTitleCell.setCellValue(dest);
  384.             sheet.addMergedRegion(new CellRangeAddress(firstRowNum, firstRowNum, 0, fieldArray.length - 1));
  385.  
  386.             firstRowNum++;
  387.         }
  388.  
  389.         //第一行，标题
  390.         Row row0 = sheet.createRow(firstRowNum);
  391.         for (int i = 0; i < titleArray.length; i++) {
  392.             Cell cell = row0.createCell(i);
  393.             cell.setCellStyle(titleStyle);
  394.             cell.setCellValue(titleArray[i]);
  395.         }
  396.         //第2行开始填充数据
  397.         for (int i = 0; i < list.size(); i++) {
  398.             //从第2行开始
  399.             Row row = sheet.createRow(i + 1 + firstRowNum);
  400.             for (int j = 0; j < fieldArray.length; j++) {
  401.                 Cell cell = row.createCell(j);
  402.                 cell.setCellStyle(style);
  403.                 cell.setCellValue(MapUtil.getStr(list.get(i), fieldArray[j], StringUtils.EMPTY));
  404.             }
  405.         }
  406.     }
  407. }

 三、实际业务方法

  1.   /**allInfo 所有信息 包括学生、老师、职工的数据List;phoneList 就是需要@的手机号**/
  2. public void receiptDuePaymentReminderPushMsg(AllInfo allInfo, List<String> phoneList) {
  3.        //创建一个HSSFWorkbook 
  4.         HSSFWorkbook wb = new HSSFWorkbook();
  5.         // 是否有数据需要构建excel推送
  6.         boolean flag0 = studentFileBuild(wb, allInfo.getStudentList(), "", "学生信息");
  7.         boolean flag1 = teacherFileBuild(wb, allInfo.getTeacherList(), "", "老师信息");
  8.         //TODO 职工可自行补充
  9.         boolean flag2 = zhigongFileBuild(wb, allInfo.getZhigongList(), "", "职工信息");
  10.  
  11.  
  12.         //只要有一个通过就要发送
  13.         if (!flag0 && !flag1 && !flag2) {
  14.             log.debug("没有需要提醒的数据");
  15.             return;
  16.         }
  17.  
  18.          //文件名
  19.         String fileName = LocalDate.now() + "学校信息汇总.xlsx";
  20.         File file = new File(fileName);
  21.         try {
  22.             // 上传文件
  23.             wb.write(file);
  24.  
  25.             // 推送消息：
  26.             String text = "【学校通知】\n请查收学校信息汇总表。";
  27.             //发送文本消息+excel文件到群
  28.             WxPushUtil.sendFileMsg(file, text, phoneList);
  29.         } catch (Exception e) {
  30.             log.error("发送异常", e);
  31.         } finally {
  32.             if (file.exists()) {
  33.                 boolean deleteFlag = file.delete();
  34.                 log.debug("wxPushMsg delete tmp file: {}", fileName);
  35.             }
  36.         }
  37.  
  38.     }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/542729
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号