SpringBoot集成Poi导出Excel

最新推荐文章于 2024-09-02 13:36:16 发布

weixin_38828866

最新推荐文章于 2024-09-02 13:36:16 发布

阅读量1k

点赞数

本文链接：https://blog.csdn.net/weixin_38828866/article/details/79927607

版权

//POI在pom文件中的依赖坐标
<dependency>
 <groupId>org.apache.poi</groupId>
 <artifactId>poi-scratchpad</artifactId>
 <version>3.12</version>
</dependency>

// 相关的C层
@RequestMapping(/testpoi)
public void projectCapacityExport(final HttpServletResponse response, HttpSession httpSession) {
 // 将查询到结果遍历
 List<ProjectCapacityData> projectCapacityData = ALi_FastJson.JsonTOList(dataJson, ProjectCapacityData.class);
 for (ProjectCapacityData projectCapacityDatum : projectCapacityData) {
 List<DeviceProjectCapacity> deviceList = projectCapacityDatum.getDeviceList();
 ExportExcel<DeviceProjectCapacity> ex = new ExportExcel();
 List<String> fieldlist = new ArrayList<>();
 String[] headers = {"建设日期", "项目名称", "泛能机台数", "统计维度", "统计周期", "累计发电量(KWh)", "发电收入(元)", "售热水(吨)", "热水收入(元)", "耗气量(方)", "耗气成本(元)"};
 // 对应实体类的属性名 必须与实体类保持一致 顺序也不能颠倒
 fieldlist.add("constructionDate");
 fieldlist.add("projectDepict");
 fieldlist.add("machineNum");
 fieldlist.add("statisticDimensionality");
 fieldlist.add("statisticalPeriod");
 fieldlist.add("generatedEnergy");
 fieldlist.add("generatingIncome");
 fieldlist.add("hotWater");
 fieldlist.add("hotWaterIncome");
 fieldlist.add("gasConsumption");
 fieldlist.add("gasConsumptionCost");
 String title = "项目产能分析报表" + new SimpleDateFormat("yyyy-MM-dd").format(new Date());
 Map map_key = null;
 List<String> noexistlist = new ArrayList<>();
 OutputStream out = ExportExcel.getout(response, title);
 ex.exportExcel(headers, deviceList, out, title, fieldlist, map_key, noexistlist);
 }
}

// 对应的实体类
public class DeviceProjectCapacity {

    private String statisticDimensionality; // 统计维度
    private String constructionDate; // 建设日期
    private String projectDepict; // 项目名称
    private Integer machineNum; // 泛能机台数
    private String statisticalPeriod; // 统计周期
    private Double generatedEnergy; // 发电量(kwh)
    private Double generatingIncome; // 发电收入(元)
    private Double hotWater; // 售热水(吨)
    private Double hotWaterIncome; // 热水收入(元)
    private Double gasConsumption; // 耗气量(方)
    private Double gasConsumptionCost; // 耗气成本(元)

    public String getStatisticDimensionality() {
        return statisticDimensionality;
    }

    public void setStatisticDimensionality(String statisticDimensionality) {
        this.statisticDimensionality = statisticDimensionality;
    }

    public String getConstructionDate() {
        return constructionDate;
    }

    public void setConstructionDate(String constructionDate) {
        this.constructionDate = constructionDate;
    }

    public String getProjectDepict() {
        return projectDepict;
    }

    public void setProjectDepict(String projectDepict) {
        this.projectDepict = projectDepict;
    }

    public Integer getMachineNum() {
        return machineNum;
    }

    public void setMachineNum(Integer machineNum) {
        this.machineNum = machineNum;
    }

    public String getStatisticalPeriod() {
        return statisticalPeriod;
    }

    public void setStatisticalPeriod(String statisticalPeriod) {
        this.statisticalPeriod = statisticalPeriod;
    }

    public Double getGeneratedEnergy() {
        return generatedEnergy;
    }

    public void setGeneratedEnergy(Double generatedEnergy) {
        this.generatedEnergy = generatedEnergy;
    }

    public Double getGeneratingIncome() {
        return generatingIncome;
    }

    public void setGeneratingIncome(Double generatingIncome) {
        this.generatingIncome = generatingIncome;
    }

    public Double getHotWater() {
        return hotWater;
    }

    public void setHotWater(Double hotWater) {
        this.hotWater = hotWater;
    }

    public Double getHotWaterIncome() {
        return hotWaterIncome;
    }

    public void setHotWaterIncome(Double hotWaterIncome) {
        this.hotWaterIncome = hotWaterIncome;
    }

    public Double getGasConsumption() {
        return gasConsumption;
    }

    public void setGasConsumption(Double gasConsumption) {
        this.gasConsumption = gasConsumption;
    }

    public Double getGasConsumptionCost() {
        return gasConsumptionCost;
    }

    public void setGasConsumptionCost(Double gasConsumptionCost) {
        this.gasConsumptionCost = gasConsumptionCost;
    }
}

// POI导出的工具类
public class ExportExcel<T> {
 public boolean exportExcel(String sheetName, String[] headers, List<T> dataset,
 OutputStream out) throws IOException {
 return exportExcel(sheetName, headers, dataset, "yyyy-MM-dd", out);
 }

 public void exportExcel(String[] headers, Collection<T> dataset, OutputStream out, String sheetname,
 List<String> fieldlist, Map map, List<String> wxgshlist) {
 exportExcel(sheetname, headers, dataset, out, "yyyy-MM-dd", fieldlist, map, wxgshlist);

 }

 public void exportExcel(String[] headers, Collection<T> dataset, OutputStream out, String pattern, String sheetname,
 List<String> fieldlist, Map map, List<String> wxgshlist) {
 exportExcel(sheetname, headers, dataset, out, pattern, fieldlist, map, wxgshlist);
 }

 /**
 * 这是一个通用的方法，利用了JAVA的反射机制，可以将放置在JAVA集合中并且符号一定条件的数据以EXCEL 的形式输出到指定IO设备上
 *
 * @param title 表格标题名
 * @param headers 表格属性列名数组
 * @param dataset 需要显示的数据集合,集合中一定要放置符合javabean风格的类的对象。此方法支持的
 * javabean属性的数据类型有基本数据类型及String,Date,byte[](图片数据)
 * @param out 与输出设备关联的流对象，可以将EXCEL文档导出到本地文件或者网络中
 * @param pattern 如果有时间数据，设定输出格式。默认为"yyy-MM-dd"
 */
 @SuppressWarnings({"unchecked", "deprecation", "resource", "rawtypes"})
 public boolean exportExcel(String title, String[] headers,
 List<T> dataset, String pattern,
 OutputStream out) throws IOException {
 byte[] b;
 // 声明一个工作薄
 HSSFWorkbook workbook = new HSSFWorkbook();
 // 生成一个样式
 HSSFCellStyle style = workbook.createCellStyle();
 // 设置这些样式
 style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
 style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
 style.setBorderRight(HSSFCellStyle.BORDER_THIN);
 style.setBorderTop(HSSFCellStyle.BORDER_THIN);
 style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
 // 生成一个字体
 HSSFFont font = workbook.createFont();
 font.setFontHeightInPoints((short) 12); // 字体高度
 font.setFontName("黑体"); // 字体
 font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD); // 宽度 
 // 把字体应用到当前的样式
 style.setFont(font);
 // 生成并设置另一个样式
 HSSFCellStyle style2 = workbook.createCellStyle();
 style2.setBorderBottom(HSSFCellStyle.BORDER_THIN);
 style2.setBorderLeft(HSSFCellStyle.BORDER_THIN);
 style2.setBorderRight(HSSFCellStyle.BORDER_THIN);
 style2.setBorderTop(HSSFCellStyle.BORDER_THIN);
 style2.setAlignment(HSSFCellStyle.ALIGN_CENTER);
 style2.setVerticalAlignment(HSSFCellStyle.ALIGN_CENTER);
 // 生成另一个字体
 HSSFFont font2 = workbook.createFont();
 font2.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
 // 把字体应用到当前的样式
 style2.setFont(font2);
 int index = 0;
 HSSFFont font3 = workbook.createFont();//内容字体
 T t;
 Field[] fields;
 HSSFCell cell;
 Field field;
 String fieldName;
 String getMethodName;
 Class tCls;
 Method getMethod;
 Object value;
 String textValue;
 Pattern p = Pattern.compile("^//d+(//.//d+)?$");
 Matcher matcher;
 HSSFRichTextString richString1;
 Collection<T> newdata = null;
 if (dataset != null && dataset.size() > 0) {
 int num = dataset.size();
 int start = 0;
 int end = 0;
 for (int i = 0; i < num; ) {
 start = i;
 if ((num - i) > 60000) {
 i += 60000;
 } else {
 i = num;
 }
 end = i;
 newdata = dataset.subList(start, end);//截取数据源
 Iterator<T> it = newdata.iterator();//操作数据
 // 生成一个表格
 HSSFSheet sheet = workbook.createSheet(title + "(" + (end - start) + "条)" + (end % 60000 == 0 ? end / 60000 : end / 60000 + 1));
 HSSFRow row = sheet.createRow(0);
 row.setHeight((short) 450);
 // 产生表格标题行
 for (short k = 0; k < headers.length; k++) {
 HSSFCell cell1 = row.createCell(k);
 HSSFRichTextString text = new HSSFRichTextString(headers[k]);
 cell1.setCellValue(text);
 cell1.setCellStyle(style);//表头单元格样式
 cell1.setCellType(HSSFCell.CELL_TYPE_STRING);
 //sheet.setColumnWidth(k,4000);//设置表头的宽度
 }
 while (it.hasNext()) {
 index++;
 row = sheet.createRow(index);
 row.setHeight((short) 300);//目的是想把行高设置成25px
 t = (T) it.next();
 // 利用反射，根据javabean属性的先后顺序，动态调用getXxx()方法得到属性值
 fields = t.getClass().getDeclaredFields();
 for (short j = 0; j < headers.length; j++) {
 cell = row.createCell(j);
 cell.setCellStyle(style2);//原来用的他
 field = fields[j];
 fieldName = field.getName();
 getMethodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
 try {
 tCls = t.getClass();
 getMethod = tCls.getMethod(getMethodName, new Class[]{});
 value = getMethod.invoke(t, new Object[]{});
 if (value == null) {
 value = "";
 }
 // 判断值的类型后进行强制类型转换
 textValue = value.toString();
 // 如果不是图片数据，就利用正则表达式判断textValue是否全部由数字组成
 if (textValue != null) {
 matcher = p.matcher(textValue);
 if (matcher.matches()) {
 // 是数字当作double处理
 cell.setCellValue(Double.parseDouble(textValue));
 } else {
 richString1 = new HSSFRichTextString(textValue);
 richString1.applyFont(font3);
 cell.setCellValue(richString1);
 }
 }
 } catch (SecurityException e) {
 e.printStackTrace();
 } catch (NoSuchMethodException e) {
 e.printStackTrace();
 } catch (IllegalArgumentException e) {
 e.printStackTrace();
 } catch (IllegalAccessException e) {
 e.printStackTrace();
 } catch (InvocationTargetException e) {
 e.printStackTrace();
 }
 }
 }

 for (int j = 0; j < headers.length; j++) {
// sheet.autoSizeColumn(j); //调整第j列宽度
 sheet.setColumnWidth(j, headers[j].getBytes().length * 512);
 }

 index = 0;
 }
 workbook.write(out);
 return true;


 } else {
 }

 return false;

 }

 public static String toUtf8String(String s) {
 StringBuffer sb = new StringBuffer();
 for (int i = 0; i < s.length(); i++) {
 char c = s.charAt(i);
 if (c >= 0 && c <= 255) {
 sb.append(c);
 } else {
 byte[] b;
 try {
 b = Character.toString(c).getBytes("utf-8");
 } catch (Exception ex) {
 b = new byte[0];
 }
 for (int j = 0; j < b.length; j++) {
 int k = b[j];
 if (k < 0) k += 256;
 sb.append("%" + Integer.toHexString(k).toUpperCase());
 }
 }
 }
 return sb.toString();
 }

 @SuppressWarnings("unchecked")
 public void exportExcel(String title, String[] headers, Collection<T> dataset, OutputStream out, String pattern,
 List<String> fieldlist, Map map, List<String> wxgshlist) {
 String returnstr = "";
 // 声明一个工作薄
 HSSFWorkbook workbook = new HSSFWorkbook();
 try {
 // 生成一个表格
 HSSFSheet sheet = workbook.createSheet(title);

 sheet.createFreezePane(0, 1, 0, 1);// 冻结表头
 // 设置表格默认列宽度为15个字节
// sheet.setColumnWidth(0, 60 * 60);// 设置第一列宽度
 sheet.setColumnWidth(1, 60 * 100);
 sheet.setDefaultColumnWidth(15);
 // 生成一个样式
 HSSFCellStyle style = workbook.createCellStyle();
 // 设置这些样式
 style.setFillForegroundColor(HSSFColor.SKY_BLUE.index);
 style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
 style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
 style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
 style.setBorderRight(HSSFCellStyle.BORDER_THIN);
 style.setBorderTop(HSSFCellStyle.BORDER_THIN);
 style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
 // 生成一个字体
 HSSFFont font = workbook.createFont();
 font.setColor(HSSFColor.VIOLET.index);
 font.setFontHeightInPoints((short) 10);// 字体高度
 font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
 // 把字体应用到当前的样式
 style.setFont(font);
 // 生成并设置另一个样式
 HSSFCellStyle style2 = workbook.createCellStyle();
 style2.setFillForegroundColor(HSSFColor.LIGHT_YELLOW.index);
 style2.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
 style2.setBorderBottom(HSSFCellStyle.BORDER_THIN);
 style2.setBorderLeft(HSSFCellStyle.BORDER_THIN);
 style2.setBorderRight(HSSFCellStyle.BORDER_THIN);
 style2.setBorderTop(HSSFCellStyle.BORDER_THIN);
 style2.setAlignment(HSSFCellStyle.ALIGN_CENTER);
 style2.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
 // 生成另一个字体
 HSSFFont font2 = workbook.createFont();
 font2.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
 // 把字体应用到当前的样式
 style2.setFont(font2);

 // 声明一个画图的顶级管理器
 HSSFPatriarch patriarch = sheet.createDrawingPatriarch();
 // 定义注释的大小和位置,详见文档
 // HSSFComment comment = patriarch.createComment(new
 // HSSFClientAnchor(0, 0, 0, 0, (short) 4, 2, (short) 6, 5));
 // 设置注释内容
 // comment.setString(new HSSFRichTextString("注释！"));
 // 设置注释作者，当鼠标移动到单元格上是可以在状态栏中看到该内容.
 // comment.setAuthor("");

 // 产生表格标题行
 HSSFRow row = sheet.createRow(0);
 for (short i = 0; i < headers.length; i++) {
 HSSFCell cell = row.createCell(i);
 cell.setCellStyle(style);
 HSSFRichTextString text = new HSSFRichTextString(headers[i]);
 cell.setCellValue(text);
 }

 // 遍历集合数据，产生数据行
 Iterator<T> it = dataset.iterator();
 int index = 0;
 HSSFFont font3 = workbook.createFont();
 while (it.hasNext()) {
 index++;
 row = sheet.createRow(index);
 T t = (T) it.next();
 String result = "";
 if (t instanceof Map) {
 if (t != null) {
 Iterator<Entry<String, String>> itor = ((Map<String, String>) t).entrySet().iterator();
 while (itor.hasNext()) {
 Entry<String, String> entry = itor.next();
 if (fieldlist.contains(entry.getKey().toLowerCase())) {
 int idf = fieldlist.indexOf(entry.getKey().toLowerCase());
 HSSFCell cell = row.createCell(idf);
 cell.setCellStyle(style2);
 cell.setCellValue(entry.getValue());
 result += entry.getKey().toLowerCase() + ",";
 }
 }
 }
 } else {
 // 利用反射，根据javabean属性的先后顺序，动态调用getXxx()方法得到属性值
 Field[] fields = t.getClass().getDeclaredFields();

 for (short i = 0; i < fields.length; i++) {
 Field field = fields[i];
 String fieldName = field.getName();
 if (fieldlist.contains(fieldName)) {
 String res = "";
 int idf = fieldlist.indexOf(fieldName);
 HSSFCell cell = row.createCell(idf);
 cell.setCellStyle(style2);
 String getMethodName = "get" + fieldName.substring(0, 1).toUpperCase()
 + fieldName.substring(1);
 try {
 Class tCls = t.getClass();
 Method getMethod = tCls.getMethod(getMethodName, new Class[]{});
 Object value = getMethod.invoke(t, new Object[]{});

 // 判断值的类型后进行强制类型转换
 String textValue = null;
 if (value instanceof Integer) {
 int intValue = (Integer) value;
 textValue = intValue + "";
 cell.setCellValue(textValue);
 } else if (value instanceof Float) {
 float fValue = (Float) value;
 textValue = fValue + "";
 cell.setCellValue(textValue);
 } else if (value instanceof Double) {
 double dValue = (Double) value;
 textValue = dValue + "";
 cell.setCellValue(textValue);
 } else if (value instanceof Long) {
 long longValue = (Long) value;
 cell.setCellValue(longValue);
 } else {
 // 其它数据类型都当作字符串简单处理
 if (value != null) {
 textValue = value.toString();
 res = GeneratedValue(fieldName, textValue, map);
 if (res.contains("图片url")) {
 String fileurl = res.substring(6, res.length());
 File jpgfile = new File(fileurl);// barName
 // 为统计图片在服务器上的路径
 ByteArrayOutputStream byteArrayOut = new ByteArrayOutputStream();// 字节输出流，用来写二进制文件
 BufferedImage bufferImg = ImageIO.read(jpgfile);
 ImageIO.write(bufferImg, "png", byteArrayOut);
 // 有图片时，设置行高为60px;
 row.setHeightInPoints(30);
 // 设置图片所在列宽度为80px,注意这里单位的一个换算
 sheet.setColumnWidth(i, (short) (35.7 * 80));
 // sheet.autoSizeColumn(i);

 // HSSFClientAnchor(dx1,dy1,dx2,dy2,col1,row1,col2,row2)的参数，有必要在这里说明一下：
 // dx1：起始单元格的x偏移量，如例子中的255表示直线起始位置距A1单元格左侧的距离；
 // dy1：起始单元格的y偏移量，如例子中的125表示直线起始位置距A1单元格上侧的距离；
 // dx2：终止单元格的x偏移量，如例子中的1023表示直线起始位置距C3单元格左侧的距离；
 // dy2：终止单元s格的y偏移量，如例子中的150表示直线起始位置距C3单元格上侧的距离；
 // col1：起始单元格列序号，从0开始计算；
 // row1：起始单元格行序号，从0开始计算，如例子中col1=0,row1=0就表示起始单元格为A1；
 // col2：终止单元格列序号，从0开始计算；
 // row2：终止单元格行序号，从0开始计算，如例子中col2=2,row2=2就表示起始单元格为C3；
 HSSFClientAnchor anchor = new HSSFClientAnchor(350, 50, 800, 230,
 (short) idf, index, (short) idf, index);
 // anchor.setAnchorType(2);
 patriarch.createPicture(anchor, workbook.addPicture(
 byteArrayOut.toByteArray(), HSSFWorkbook.PICTURE_TYPE_JPEG));// 将统计图片添加到Excel文件中
 } else if (res.contains("imageid") || res.contains("origin_photos")) {
 textValue = "http://10.37.47.49:8080/ImageUpload/imageinfo/" + textValue;

 cell.setCellValue(textValue);
 } else {
 cell.setCellValue(res);
 }
 } else if (value == null) {
 textValue = "";
 cell.setCellValue(textValue);
 }
 }
 // 如果不是图片数据，就利用正则表达式判断textValue是否全部由数字组成
 if (textValue != null) {
 Pattern p = Pattern.compile("^//d+(//.//d+)?$");
 Matcher matcher = p.matcher(textValue);
 if (matcher.matches()) {
 // 是数字当作double处理
 cell.setCellValue(Double.parseDouble(textValue));
 } else if (!res.contains("图片url")) {
 HSSFRichTextString richString = new HSSFRichTextString(textValue);
 font3.setColor(HSSFColor.BLACK.index);
 richString.applyFont(font3);
 cell.setCellValue(richString);
 }
 }
 } catch (SecurityException e) {
 e.printStackTrace();
 } catch (NoSuchMethodException e) {
 e.printStackTrace();
 } catch (IllegalArgumentException e) {
 e.printStackTrace();
 } catch (IllegalAccessException e) {
 e.printStackTrace();
 } catch (InvocationTargetException e) {
 e.printStackTrace();
 } finally {
 // 清理资源
 }
 }
 result += fieldName + ",";
 }
 }
 setValue(fieldlist, result, wxgshlist, row, style2);
 }

 try {
 workbook.write(out);
 out.close();
 } catch (IOException e) {
 e.printStackTrace();
 }
 } catch (Exception e) {
 }
 }

 public void setValue(List<String> fieldlist, String result, List<String> wxgshlist, HSSFRow row,
 HSSFCellStyle style2) {
 if (wxgshlist.size() > 0) {
 for (int j = 0; j < fieldlist.size(); j++) {
 if (!result.contains(fieldlist.get(j))) {
 try {
 if (wxgshlist.contains(fieldlist.get(j))) {
 HSSFCell cell = row.createCell(5);
 cell.setCellStyle(style2);
 String star = row.getCell(3).getStringCellValue();
 String endstr = row.getCell(4).getStringCellValue();
 if (!star.equals("") && !endstr.equals("")) {
 star = star.replaceAll("-", ".");
 endstr = endstr.replaceAll("-", ".");
 cell.setCellValue(getday(star, endstr) + "");
 }
 } else {
 int idf = fieldlist.indexOf(fieldlist.get(j));
 HSSFCell cell = row.createCell(idf);
 cell.setCellStyle(style2);
 }
 } catch (Exception e) {
 }
 }
 }
 } else {
 for (int j = 0; j < fieldlist.size(); j++) {
 if (!result.contains(fieldlist.get(j))) {
 try {
 if (!wxgshlist.contains(fieldlist.get(j))) {
 int idf = fieldlist.indexOf(fieldlist.get(j));
 HSSFCell cell = row.createCell(idf);
 cell.setCellStyle(style2);
 }
 } catch (Exception e) {
 }
 }
 }
 }
 }

 public static int getday(String str, String end) {
 int day = 0;
 Calendar calendar = new GregorianCalendar();
 Calendar calendar2 = Calendar.getInstance();
 // 通过SimpleDateFormat将字符串解析为Date类型
 SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd");
 try {
 sdf.parse(str);
 sdf.parse(end);
 // 将Date类型放入Calendar
 calendar.setTime(sdf.parse(str));
 calendar2.setTime(sdf.parse(end));
 calendar2.add(Calendar.DATE, 1);
 while (calendar2.compareTo(calendar) > 0) {
 // Calendar类型中的日期+1
 calendar.add(Calendar.DATE, 1);
 day++;
 }
 } catch (ParseException e) {
 // TODO Auto-generated catch block
 e.printStackTrace();
 }
 return day;
 }

 public String GeneratedValue(String fieldName, String value, Map map) {
 String retval = "";
 // -----------------------------------值类型转换比如数据库中存的是1页面显示“是”------------------------------------------------
 if (map != null) {
 Iterator<Entry<String, Map>> itor = map.entrySet().iterator();
 while (itor.hasNext()) {
 Entry<String, Map> entry = itor.next();
 if (fieldName.equals(entry.getKey().toString())) {
 Map<String, String> secd = entry.getValue();
 Iterator<Entry<String, String>> secditor = secd.entrySet().iterator();
 while (secditor.hasNext()) {
 Entry<String, String> secdentry = secditor.next();
 if (value != null) {
 if (secdentry.getKey().equals(value)) {
 retval = secdentry.getValue();
 }
 if (retval.equals("") && !secdentry.getKey().equals(value)) {
 retval = secdentry.getKey();
 }
 }
 }
 }
 }
 } else {
 retval = value;
 }
 // -----------------------------------------------------------------------------------
 return retval;
 }

 public static OutputStream getout(HttpServletResponse response, String filename) {
 OutputStream out = null;
 try {
 try {
 filename = new String((filename + ".xls").getBytes(), "iso-8859-1");
 } catch (UnsupportedEncodingException e1) {
 // TODO Auto-generated catch block
 e1.printStackTrace();
 } // 中文文件名必须使用此句话
 response.setContentType("application/octet-stream");
 response.setContentType("application/vnd.ms-execl");
 response.setHeader("Content-Disposition", "attachment;filename=" + filename);
 out = new BufferedOutputStream(response.getOutputStream());
 } catch (FileNotFoundException e) {
 e.printStackTrace();
 } catch (IOException e) {
 e.printStackTrace();
 }
 return out;
 }
}

本条目发布于 2018年1月29日。属于未分类分类。编辑

时间戳 date 和 String之间的转换

发表评论

将时间戳转换成date

//获的当前的时间戳
String key = "1517191927";
// 设置时间格式
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 将之间戳转换成Date类型
long lt = new Long(key);
Date date = new Date(lt);

将Date转换成String类型

// 获得当前时间
Date date = new Date();
//设置自己想要的格式
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 将date转换成Stirng
String format = formatter.format(date);