FreeMaker导出word

public void exportWord(String baseInfoId, HttpServletResponse response) {
        //导出word
        AccidentReport accidentReport = accidentReportMapper.getAccidentReport(baseInfoId);
        AccidentBaseinfo baseinfo = accidentBaseinfoMapper.getAccidentBaseinfoById(baseInfoId);
        List dutyAnalysisList = accidentPersonnelDisposaMapper.AccidentPersonnelDisposaByBaseInfoId(baseInfoId); //得到责任人员
        List accidentRectifyList = accidentRectifyMapper.getAccidentRectify(baseInfoId);
        accidentRectifyList.stream().forEach(item->item.setId(changeLevelName(item.getLevelId())));

        //追责企业 追加到责任人员,一起展示
        List dutyAnalysisQyList=accidentQyDisposaMapper.AccidentQyDisposaByBaseInfoId(baseInfoId);
        List accidentRectifyList1 =new ArrayList<>();
        BeanUtils.copyProperties(dutyAnalysisQyList,accidentRectifyList1);
        accidentRectifyList.addAll(accidentRectifyList1);

        SimpleDateFormat stf = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat stf2 =new SimpleDateFormat("yyyyMMdd");
        String nowTime =stf.format(new Date());
        Map map = new HashMap<>();
        map.put("qyName",baseinfo.getQyName()); //企业名称
        map.put("createTime",stf2.format(baseinfo.getOccurrenceTime())); //事故时间
        map.put("describe",accidentReport.getDescribe()); //描述
        map.put("immediateCause",accidentReport.getImmediateCause()); //直接原因
        map.put("indirectCause",accidentReport.getIndirectCause()); //事故经过
        map.put("nature",accidentReport.getNature()); //事故性质
        map.put("dutyAnalysisList",dutyAnalysisList); //责任认定及处理
        map.put("rectifyMeasureList",accidentRectifyList);
        map.put("rectifyMeasure",accidentReport.getRectifyMeasure()); //事故整改措施
        map.put("nowTime",nowTime);
        FreeMarkerUtil.crateFile(map,"新事故报告导出模板.ftl","事故报告"+nowTime+".doc",response);
    }

调用FreeMakerUtil

package com.zhjt.utils;

import freemarker.template.Configuration;
import freemarker.template.DefaultObjectWrapper;
import freemarker.template.Template;
import freemarker.template.TemplateExceptionHandler;
import sun.misc.BASE64Encoder;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLEncoder;
import java.util.*;

/***
 * 时间:2020年3月19日10:18:32
 * 作者:lth
 * 说明:
 */
public class FreeMarkerUtil {

      private static final String ENCODING = "UTF-8";
      private static Configuration cfg = new Configuration();



      //初始化cfg
              static {
                 //设置模板所在文件夹
                 cfg.setClassForTemplateLoading(FreeMarkerUtil.class, "/templates/");
                 // setEncoding这个方法一定要设置国家及其编码,不然在ftl中的中文在生成html后会变成乱码
                 cfg.setEncoding(Locale.getDefault(), ENCODING);
                 // 设置对象的包装器
                 cfg.setObjectWrapper(new DefaultObjectWrapper());
                 // 设置异常处理器,这样的话就可以${a.b.c.d}即使没有属性也不会出错
                 cfg.setTemplateExceptionHandler(TemplateExceptionHandler.IGNORE_HANDLER);

             }

              //获取模板对象
              public static Template getTemplate(String templateFileName) throws IOException {
                 return cfg.getTemplate(templateFileName, ENCODING);
            }




          /**
      45      * 据数据及模板生成文件 --> 修改为将流写入response 传给前端
      46      * @param data             Map的数据结果集
      47      * @param templateFileName ftl模版文件名
      48      * @param outFilePath      生成文件名称(可带路径)
      49      */
          public   static void   crateFile(Map data, String templateFileName,String fileName, HttpServletResponse response) {
              OutputStream outputStream =null;
              try {
                         // 获取模板,并设置编码方式,这个编码必须要与页面中的编码格式一致
                         Template template = getTemplate(templateFileName);
                          outputStream = response.getOutputStream();  //获得输出流
                        //设置响应头格式
                         response.setContentType("application/octet-stream");
                         response.setHeader("content-Type", "application/msword");
                  // 设置下载文件名
                      response.addHeader("Content-Disposition",
                            "attachment; filename=\"" + URLEncoder.encode(fileName, "UTF-8") + "\"");
                    // 向客户端输出文件

                       // 处理模版
                         template.process(data,new BufferedWriter(new  OutputStreamWriter(outputStream)));
                    outputStream.flush();
                       System.out.println("由模板文件" + templateFileName + "生成" + templateFileName + "成功.");
                     } catch (Exception e) {
                         System.out.println("由模板文件" + templateFileName + "生成" + templateFileName + "出错");
                         e.printStackTrace();
                     } finally {
                         try {
                                 if (outputStream != null) {
                                     outputStream.close();
                                     }
                             } catch (IOException e) {
                             System.out.println("关闭Write对象出错"+e);
                                 e.printStackTrace();
                             }
                     }
             }




        //获得图片的base64码
                public static String getImageBase(String src) throws Exception {
                 if (src == null || src == "") {
                         return "";
                     }File file = new File(src);
                 if (!file.exists()) {
                        return "";
                     }
                 InputStream in = null;
                 byte[] data = null;
                try {
                         in = new FileInputStream(file);
                         data = new byte[in.available()];
                         in.read(data);
                         in.close();
                     } catch (IOException e) {
                         e.printStackTrace();
                     }
                 BASE64Encoder encoder = new BASE64Encoder();
                 return encoder.encode(data);
             }

    public static void main(String[] args) throws Exception{

        Map data = new HashMap();
        data.put("name", "段然涛");
        data.put("sex", "男");
        data.put("birthday", "1994-03-14");
        data.put("phone", "17737138812");
        data.put("data", "河南省许昌市");
        data.put("school", "江西科技师范大学");
        List> educations = new ArrayList>();
        Map paramsMap = new HashMap();
        paramsMap.put("school", "禹州一高");
        paramsMap.put("startDate", "2008-09");
        paramsMap.put("endDate", "2012-06");
        paramsMap.put("person", "李磊");
        Map paramsMap2 = new HashMap();
        paramsMap2.put("school", "江西科技师范大学");
        paramsMap2.put("startDate", "2012-09");
        paramsMap2.put("endDate", "2016-07");
        paramsMap2.put("person", "李杰");
        educations.add(paramsMap);
        educations.add(paramsMap2);
        data.put("educations", educations);
        List images = new ArrayList();
        images.add(getImageBase("C:/Users/Administrator/Desktop/图片/timg.jpg"));
        images.add(getImageBase("C:/Users/Administrator/Desktop/图片/timg11.jpg"));
        data.put("images", images);
        FreeMarkerUtil.crateFile(data, "测试模板.ftl",null, null);
    }
}

*.ftl 模板




    
        
            
                
                
                
                
            
        
    
    
        
            
                
                    
                        
                            
                            
                                
                                
                                
                            
                        
                        
                        
                    
                    
                        
                            
                            
                            
                            
                            
                                
                                
                            
                        
                        
                            
                                
                                
                                
                                
                                
                            
                            ${qyName} ${createTime}
                        
                        
                            
                                
                                
                                
                                
                                
                            
                            事故报告
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                    
                        
                            
                            
                            
                            
                                
                                
                            
                        
                        
                            
                                
                                
                                
                            
                            一、事故经过
                        
                    
                    
                        
                            
                            
                            
                            
                                
                                
                                
                            
                        
                        
                            
                                
                                
                                
                            
                            ${describe}
                        
                    
                    
                        
                            
                            
                                
                                
                                
                            
                        
                        
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                    
                        
                            
                            
                            
                            
                                
                                
                            
                        
                        
                            
                                
                                
                                
                            
                            二、事故原因
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                    
                        
                            
                            
                            
                            
                                
                                
                            
                        
                        
                            
                                
                                
                                
                            
                            (一)直接原因
                        
                    
                    
                        
                            
                            
                            
                            
                                
                                
                                
                            
                        
                        
                            
                                
                                
                                
                            
                            ${immediateCause}
                        
                    
                    
                        
                            
                            
                                
                                
                                
                            
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                    
                        
                            
                            
                            
                            
                                
                                
                            
                        
                        
                            
                                
                                
                                
                            
                            (二)间接原因
                        
                    
                    
                        
                            
                            
                            
                            
                                
                                
                                
                            
                        
                        
                            
                                
                                
                                
                            
                            ${indirectCause}
                        
                    
                    
                        
                            
                            
                                
                                
                                
                            
                        
                        
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                    
                        
                            
                            
                            
                            
                                
                                
                            
                        
                        
                            
                                
                                
                                
                            
                            三、事故性质
                        
                    
                    
                        
                            
                            
                            
                            
                                
                                
                                
                            
                        
                        
                            
                                
                                
                                
                            
                            ${nature}
                        
                    
                    
                        
                            
                            
                            
                            
                                
                                
                                
                            
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                    
                        
                            
                            
                            
                            
                                
                                
                            
                        
                        
                            
                                
                                
                                
                            
                            四、责任认定及处理
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                     <#list dutyAnalysisList as duty>
                    
                        
                            
                            
                            
                            
                                
                                
                                
                            
                        
                        
                        
                        
                            
                                
                                
                                
                            
                            ${duty.name} : ${duty.shoulderDuty}
                        
                    
                  
                
                        
                            
                            
                            
                            
                                
                                
                                
                            
                        
                    
                    
                        
                            
                            
                            
                            
                                
                                
                                
                            
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                    
                        
                            
                            
                            
                            
                                
                                
                            
                        
                        
                            
                                
                                
                                
                            
                            五、事故整改措施
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                     <#list rectifyMeasureList as data>
                    
                        
                            
                            
                            
                            
                                
                                
                                
                            
                        
                        
                        
                        
                            
                                
                                
                                
                            
                            ${data.id} : ${data.rectifyMeasure}
                        
                    
                    
                    
                        
                            
                            
                            
                                
                                
                                
                            
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                    
                        
                            
                            
                            
                                
                                
                            
                        
                    
                    
                        
                            
                            
                            
                                
                                
                                
                            
                        
                    
                    
                        
                            
                            
                            
                                
                                
                                
                            
                        
                        
                            
                                
                                
                                
                            
                            特此通报。
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                    
                        
                            
                            
                                
                                
                                
                            
                        
                    
                    
                        
                            
                            
                            
                            
                                
                                
                            
                        
                        
                            
                                
                                
                                
                            
                            ${nowTime}
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                    
                        
                            
                            
                                
                                
                                
                            
                        
                    
                    
                        
                            
                            
                            
                            
                                
                                
                            
                        
                        
                            
                                
                                
                                
                            
                            发文范围:集团各单位(
                        
                        
                            
                                
                                
                                
                            
                             
                        
                        
                            
                                
                                
                                
                            
                            全体员工
                        
                        
                            
                                
                                
                                
                            
                             
                        
                        
                            
                                
                                
                                
                            
                            
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                    
                        
                            
                            
                            
                            
                                
                                
                            
                        
                        
                            
                                
                                
                                
                            
                            
                            抄报:
                        
                    
                    
                        
                            
                            
                                
                                
                            
                        
                    
                    
                        
                            
                            
                            
                            
                                
                                
                                
                            
                        
                        
                            
                                
                                
                                
                            
                            发文日期:
                        
                        
                            
                                
                                
                                
                            
                            ${nowTime}
                        
                    
                    
                    
                        
                        
                        
                        
                    
                
            
        
    
    
        
            
                
                
                
                
                
            
        
    
    
        
            
                
                    
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                    
                    
                        
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                        
                        
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                        
                    
                    
                        
                            
                                
                            
                            
                                
                                    
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                    
                                
                                
                            
                            
                                
                                    
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                    
                                
                                
                            
                        
                        
                            
                                
                                    
                                
                                
                                
                            
                            
                                
                                    
                                
                                
                                
                            
                            
                                
                                    
                                
                                
                                
                            
                        
                        
                            
                                
                            
                            
                                
                            
                            
                                
                                    
                                        
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                            
                            
                                
                                    
                                    
                                
                            
                            
                                
                                    
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                        
                                    
                                
                                
                            
                        
                    
                
                
                
                
                    
                        
                    
                
            
        
    
    
        
            
                
                
                
                
                
                
                
                
                
                
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                
                
                
                
                
                    
                    
                        
                    
                
                
                
                
                
            
        
    
    
        
            
                
                    
                        
                            
                            
                        
                    
                    
                
                
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                        
                        
                    
                
                
                    
                    
                
                
                    
                    
                    
                        
                            
                            
                            
                            
                        
                    
                
                
                    
                    
                    
                    
                
            
        
    
    
        
            
                
                
                
            
        
    
    
        
            
                
                    
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                
            
        
    
    
        
            
                
                
                DongxuPeng
                
                DongxuPeng
                2
                2020-03-23T04:26:00Z
                2020-03-23T04:26:00Z
            
        
    
    
        
            
                
                0
                2
                37
                213
                Microsoft Office Word
                0
                1
                1
                false
                
                false
                249
                false
                false
                16.0000
            
        
    
    
        
            
                
                    2052-11.1.0.9513
                
            
        
    

你可能感兴趣的:(工具类)