首先用office建一个word文档
参数写自己查询出来的字段，我在这里房里图片是方便找到位置替换为64位编码

模板创建好之后，另存为Word 2003 XML文档(*.xml) 存储为别的可能会报错，我只用这一种
存储为xml之后千万不要用word打开，最好用notpad++打开，复制里面的数据到格式化xml工具在线格式化工具格式化一下（注：该工具有弊端，会把定义的参数打散，需要自己手动修改一下）
比如这里我定义的是${about}，他给分开，只需要删除多余的<w:r>标签即可

修改后

图片导出的只需要把我的那些数据复制替换一下就可以了，记住自己逻辑里面写的集合名称就ok了，
详情点击下面的标题
templates
找到我的<#list>判断
1175-1232行

里面的参数都是和逻辑处理那边对应的
导出后截图

application.yml

spring:
  profiles:
    active: dev
  servlet:
    multipart:
      max-file-size: 102400MB
      max-request-size: 102400MB
mybatis-plus:
  configuration:
    # 不打印sql
#    log-impl: org.apache.ibatis.logging.nologging.NoLoggingImpl
    # 打印sql
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    # map集合值为null时也返回
    call-setters-on-nulls: true
multipart:
  enabled: true
  max-file-size: 100MB
  max-request-size: 100MB

application-dev.yml

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/word
    username: postgres
    password: 
    driver-class-name: org.postgresql.Driver
server:
  port: 8799
  servlet:
    context-path: /ftl
uploadFilePath: E:\apache-tomcat-9.0.41\apache-tomcat-9.0.41\webapps\rfwg_files

pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.lxl</groupId>
    <artifactId>mybatisplus</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mybatisplus</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.1.tmp</version>
        </dependency>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.28</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.58</version>
        </dependency>
        <!--io流转换-->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>
        <!--添加本地的jacob.jar包 -->
        <dependency>
            <groupId>jacob</groupId>
            <artifactId>jacob</artifactId>
            <version>1.19</version>
        </dependency>
        <!--word转pdf-->
        <dependency>
            <groupId>e-iceblue</groupId>
            <artifactId>spire.doc.free</artifactId>
            <version>3.9.0</version>
        </dependency>
        <!--io流转换-->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>
    </dependencies>
    <build>
        <finalName>manage-application</finalName>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>*</include>
                    <include>*/*</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>rc/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.ftl</include>
                </includes>
            </resource>
        </resources>
    </build>
</project>

utils

这里我先把工具类放在上面是为了防止下面类里面数据会被错

package com.cao.ftlword.utils;
import java.io.Serializable;
/**
 * 消息对象
 */
public class AjaxObj implements Serializable {
	private static final long serialVersionUID = 4806448810229890854L;
	private int code;
	private String msg;
	private String token;
	private Object data;
	private Boolean flag;
	public AjaxObj() {
	}
	public Boolean getFlag() {
		return flag;
	}
	public void setFlag(Boolean flag) {
		this.flag = flag;
	}
	public AjaxObj(int code, String msg) {
		this.code = code;
		this.msg = msg;
	}
	public AjaxObj(int code, String msg, Object data) {
		this.code = code;
		this.msg = msg;
		this.data = data;
	}
	public AjaxObj(int code, String msg, Object data, Boolean flag) {
		this.code = code;
		this.msg = msg;
		this.data = data;
		this.flag = flag;
	}
	public int getCode() {
		return code;
	}
	public void setCode(int code) {
		this.code = code;
	}
	public String getMsg() {
		return msg;
	}
	public void setMsg(String msg) {
		this.msg = msg;
	}
	public String getToken() {
		return token;
	}
	public void setToken(String token) {
		this.token = token;
	}
	public Object getData() {
		return data;
	}
	public void setData(Object data) {
		this.data = data;
	}
}

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.util.DigestUtils;
import org.springframework.util.ObjectUtils;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;
public class CommUtils {
    /**
     * 判断一个对象(包括String、以及Collection下的各个子类集合) 是否为空, 为空则返回true, 否则会返回false
     */
    @SuppressWarnings("rawtypes")
    public static boolean isEmpty(Object obj) {
        if (obj == null)
            return true;
        if (obj instanceof String) {
            if (((String) obj).equals(""))
                return true;
        }
        if (obj instanceof Collection<?>) {
            if (((Collection) obj).size() <= 0)
                return true;
        }
        if (obj instanceof String[]) {
            if (((String[]) obj).length <= 0) {
                return true;
            }
        }
        if (obj instanceof Object[]) {
            if (((Object[]) obj).length <= 0) {
                return true;
            }
        }
        return false;
    }
    /**
     * 生成uuid
     *
     * @return
     */
    public static String getUUID() {
        return UUID.randomUUID().toString().replace("-", "");
    }
    /**
     * 将指定日期按照指定的格式以字符串的形式进行返回
     */
    public static String getDate(String pattern, Date date) {
        SimpleDateFormat format = new SimpleDateFormat(pattern);
        return format.format(date);
    }
    /**
     * 将当前日期按照 "年-月-日 时:分:秒" 的日期格式以字符串的形式返回
     */
    public static String getDate() {
        return getDate("yyyy-MM-dd HH:mm:ss", new Date());
    }
    public static String getMD5(String str) {
        return DigestUtils.md5DigestAsHex(str.getBytes());
    }
    /**
     * 下载文件
     */
    public static void downloadFile(String path, HttpServletResponse response) {
        File file = new File(path);
        byte[] buffer = new byte[(int) file.length()];
        FileInputStream fis = null; //文件输入流
        BufferedInputStream bis = null;
        OutputStream os = null; //输出流
        try {
            os = response.getOutputStream();
            fis = new FileInputStream(file);
            bis = new BufferedInputStream(fis);
            int i = bis.read(buffer);
            while (i != -1) {
                os.write(buffer);
                i = bis.read(buffer);
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("----------file download----------" + path);
        try {
            bis.close();
            fis.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    //递归删文件
    public static boolean delAllFile(File file) {
        if (!file.exists()) {
            return false;
        }
        if (file.isDirectory()) {
            File[] files = file.listFiles();
            if (files != null) {
                for (File f : files) {
                    delAllFile(f);
                }
            }
        }
        return file.delete();
    }
    public static void delDiskFile(String filePath) {
        //删除磁盘上的附件文件
        try {
            File file = new File(filePath);
            if (file.exists()) {
                CommUtils.delAllFile(new File(filePath));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static File multipartFileToFile(MultipartFile multipartFile) {
        try {
            // 获取文件名
            String fileName = multipartFile.getOriginalFilename();
            // 获取文件后缀
            String prefix = fileName.substring(fileName.lastIndexOf("."));
            // 用uuid作为文件名，防止生成的临时文件重复
            File tempFile = File.createTempFile(CommUtils.getUUID(), prefix);
            multipartFile.transferTo(tempFile);
            return tempFile;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    // 逆向递归删除空目录
    public void delEmptyPath(String path) {
        File file = new File(path);
        if (file.exists() && file.isDirectory()) {
            File[] files = file.listFiles();
            if (files != null && files.length > 0)
                return;
            if (file.delete()) {
                delEmptyPath(file.getParent());
            }
        }
    }
    //拷贝到临时文件夹
    public static void copyDir(String sourcePath, String newPath) throws IOException {
        File file = new File(sourcePath);
        String[] filePath = file.list();
        if (!(new File(newPath)).exists()) {
            (new File(newPath)).mkdir();
        } else {
            delAllFile(new File(newPath));
            (new File(newPath)).mkdir();
        }
        if (filePath != null) {
            for (int i = 0; i < filePath.length; i++) {
                if ((new File(sourcePath + file.separator + filePath[i])).isDirectory()) {
                    copyDir(sourcePath + file.separator + filePath[i], newPath + file.separator + filePath[i]);
                }
                if (new File(sourcePath + file.separator + filePath[i]).isFile() && !new File(sourcePath + file.separator + filePath[i]).getName().contains("ys_")) {
                    copyFile(sourcePath + file.separator + filePath[i], newPath + file.separator + filePath[i]);
                }
            }
        }
    }
    public static void copyFile(String oldPath, String newPath) throws IOException {
        File oldFile = new File(oldPath);
        File file = new File(newPath);
        FileInputStream in = new FileInputStream(oldFile);
        FileOutputStream out = new FileOutputStream(file);
        byte[] buffer = new byte[2097152];
        while ((in.read(buffer)) != -1) {
            out.write(buffer);
        }
        out.close();
        in.close();
    }
    public static File getTemplateFile(String templatePath) throws Exception {
        File file = File.createTempFile("temp", null);
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        Resource[] resources = resolver.getResources(templatePath);
        if (resources.length == 1) {
            InputStream inputStream = resources[0].getInputStream();
            inputStreamToFile(inputStream, file);
        } else {
            System.out.println("请检查模板文件是否存在");
        }
        return file;
    }
    public static void inputStreamToFile(InputStream ins, File file) {
        try {
            OutputStream os = new FileOutputStream(file);
            int bytesRead = 0;
            byte[] buffer = new byte[8192];
            while ((bytesRead = ins.read(buffer, 0, 8192)) != -1) {
                os.write(buffer, 0, bytesRead);
            }
            os.close();
            ins.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static File searchFile(File dir) {
        File[] subFiles = dir.listFiles();       //获取e盘下所有的文件或文件夹对象
        File resFile = dir;
        if (null != subFiles) {
            for (File subFile : subFiles) {
                if (subFile.isDirectory()) {        //文件夹则递归寻找，后缀为jpg文件则输出名字
                    resFile = searchFile(subFile);
                } else if (subFile.isFile() && subFile.getName().endsWith(".shp")) {
                    resFile = subFile;
                    break;
                }
            }
        }
        return resFile;
    }
    /**
     * byte数组转换成16进制字符串
     */
    public static String bytesToHexString(byte[] src) {
        StringBuilder stringBuilder = new StringBuilder();
        if (src == null || src.length <= 0) {
            return null;
        }
        for (int i = 0; i < src.length; i++) {
            int v = src[i] & 0xFF;
            String hv = Integer.toHexString(v);
            if (hv.length() < 2) {
                stringBuilder.append(0);
            }
            stringBuilder.append(hv);
        }
        return stringBuilder.toString();
    }
    /**
     * 根据文件流判断图片类型
     */
    public static String getPicType(FileInputStream fis) {
        //读取文件的前几个字节来判断图片格式
        byte[] b = new byte[4];
        try {
            fis.read(b, 0, b.length);
            String type = bytesToHexString(b).toUpperCase();
            if (type.contains("FFD8FF")) {
                return "jpg";
            } else if (type.contains("89504E47")) {
                return "png";
            } else if (type.contains("47494638")) {
                return "gif";
            } else if (type.contains("424D")) {
                return "bmp";
            } else {
                return "unknown";
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }
    public static boolean isPicBySuffix(String suffix) {
        if (".JPG".equals(suffix.toUpperCase()) || ".PNG".equals(suffix.toUpperCase())
                || ".JPEG".equals(suffix.toUpperCase()) || ".GIF".equals(suffix.toUpperCase())
                || ".BMP".equals(suffix.toUpperCase())) {
            return true;
        }
        return false;
    }
    public static boolean isWordBySuffix(String suffix) {
        if (".DOC".equals(suffix.toUpperCase()) || ".DOCX".equals(suffix.toUpperCase())) {
            return true;
        }
        return false;
    }
    public static boolean isDxfBySuffix(String suffix) {
        if (".DXF".equals(suffix.toUpperCase())) {
            return true;
        }
        return false;
    }
    public static boolean isZipBySuffix(String suffix) {
        if (".ZIP".equals(suffix.toUpperCase())) {
            return true;
        }
        return false;
    }
    public static boolean isExcelBySuffix(String suffix) {
        if (".XLS".equals(suffix.toUpperCase()) || ".XLSX".equals(suffix.toUpperCase())) {
            return true;
        }
        return false;
    }
    public static JSONObject xAxisSeries(List<Object> xAxisDataList, List<Object> seriesDataList) {
        JSONObject jsonObject = new JSONObject();
        JSONObject xAxisData = new JSONObject();
        xAxisData.put("data", xAxisDataList);
        jsonObject.put("xAxis", xAxisData);
        JSONObject dd = new JSONObject();
        dd.put("data", seriesDataList);
        JSONArray jsonArray = new JSONArray();
        jsonArray.add(dd);
        jsonObject.put("series", jsonArray);
        return jsonObject;
    }
    public static JSONObject legendSeries(List<Object> legendDataList, List<Object> seriesDataList) {
        JSONObject jsonObject = new JSONObject();
        JSONObject legendData = new JSONObject();
        legendData.put("data", legendDataList);
        jsonObject.put("legend", legendData);
        JSONObject dd = new JSONObject();
        JSONArray ja = new JSONArray();
        for (int i = 0; i < seriesDataList.size(); i++) {
            JSONObject jo = new JSONObject();
            jo.put("name", legendDataList.get(i));
            jo.put("value", seriesDataList.get(i));
            ja.add(jo);
        }
        dd.put("data", ja);
        JSONArray jsonArray = new JSONArray();
        jsonArray.add(dd);
        jsonObject.put("series", jsonArray);
        return jsonObject;
    }
    public static void getSignPIdAndIndex(JSONArray jsonArray, String suuid, Map<String, Integer> map) {
        for (int i = 0; i < jsonArray.size(); i++) {
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            JSONArray children = jsonObject.getJSONArray("children");
            if (!ObjectUtils.isEmpty(children) && children.size() > 0) {
                getSignPIdAndIndex(children, suuid, map);
            } else {
                if (suuid.equals(jsonObject.getString("id"))) {
                    map.put(jsonObject.getString("parentTId"), i);
                }
            }
        }
    }
    public static String getIpAddress(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_CLIENT_IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_X_FORWARDED_FOR");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        return ip;
    }
    public static String toUTF8(String str) {
        if (isEmpty(str)) {
            return "";
        }
        try {
            if (str.equals(new String(str.getBytes("GB2312"), "GB2312"))) {
                str = new String(str.getBytes("GB2312"), "utf-8");
                return str;
            }
        } catch (Exception exception) {
        }
        try {
            if (str.equals(new String(str.getBytes("ISO-8859-1"), "ISO-8859-1"))) {
                str = new String(str.getBytes("ISO-8859-1"), "utf-8");
                return str;
            }
        } catch (Exception exception1) {
        }
        try {
            if (str.equals(new String(str.getBytes("GBK"), "GBK"))) {
                str = new String(str.getBytes("GBK"), "utf-8");
                return str;
            }
        } catch (Exception exception3) {
        }
        return str;
    }
    // 文件和视频
    public static boolean suffixName(String suffixName) {
        if ((".txt").equalsIgnoreCase(suffixName) || (".dwg").equalsIgnoreCase(suffixName)
                || (".jpg").equalsIgnoreCase(suffixName) || (".jpeg").equalsIgnoreCase(suffixName) || (".png").equalsIgnoreCase(suffixName)
                || (".bmp").equalsIgnoreCase(suffixName) || (".gif").equalsIgnoreCase(suffixName)
                || (".mp4").equalsIgnoreCase(suffixName) || (".avi").equalsIgnoreCase(suffixName)
                || (".3gp").equalsIgnoreCase(suffixName) || (".flv").equalsIgnoreCase(suffixName)
                || (".rar").equalsIgnoreCase(suffixName) || (".zip").equalsIgnoreCase(suffixName)
                || (".doc").equalsIgnoreCase(suffixName) || (".docx").equalsIgnoreCase(suffixName)
                || (".xlsx").equalsIgnoreCase(suffixName) || (".xls").equalsIgnoreCase(suffixName) || (".pdf").equalsIgnoreCase(suffixName)
                || (".ppt").equalsIgnoreCase(suffixName) || (".pps").equalsIgnoreCase(suffixName) || (".pptx").equalsIgnoreCase(suffixName)) {
            return true;
        } else {
            return false;
        }
    }
    // 图片
    public static boolean suffixNameImage(String suffixName) {
        if ((".tiff").equalsIgnoreCase(suffixName) || (".pjp").equalsIgnoreCase(suffixName)
                || (".jfif").equalsIgnoreCase(suffixName) || (".gif").equalsIgnoreCase(suffixName) || (".svg").equalsIgnoreCase(suffixName)
                || (".bmp").equalsIgnoreCase(suffixName) || (".png").equalsIgnoreCase(suffixName)
                || (".jpeg").equalsIgnoreCase(suffixName) || (".svgz").equalsIgnoreCase(suffixName)
                || (".jpg").equalsIgnoreCase(suffixName) || (".webp").equalsIgnoreCase(suffixName)
                || (".ico").equalsIgnoreCase(suffixName) || (".xbm").equalsIgnoreCase(suffixName)
                || (".dib").equalsIgnoreCase(suffixName) || (".tif").equalsIgnoreCase(suffixName)
                || (".pjpeg").equalsIgnoreCase(suffixName) || (".avif").equalsIgnoreCase(suffixName)) {
            return true;
        } else {
            return false;
        }
    }
    // 文件不包含视频
    public static boolean suffixNameFile(String suffixName) {
        if ((".txt").equalsIgnoreCase(suffixName) || (".dwg").equalsIgnoreCase(suffixName)
                || (".jpg").equalsIgnoreCase(suffixName) || (".jpeg").equalsIgnoreCase(suffixName) || (".png").equalsIgnoreCase(suffixName)
                || (".bmp").equalsIgnoreCase(suffixName) || (".gif").equalsIgnoreCase(suffixName)
                || (".rar").equalsIgnoreCase(suffixName) || (".zip").equalsIgnoreCase(suffixName)
                || (".doc").equalsIgnoreCase(suffixName) || (".docx").equalsIgnoreCase(suffixName)
                || (".xlsx").equalsIgnoreCase(suffixName) || (".xls").equalsIgnoreCase(suffixName) || (".pdf").equalsIgnoreCase(suffixName)
                || (".ppt").equalsIgnoreCase(suffixName) || (".pps").equalsIgnoreCase(suffixName) || (".pptx").equalsIgnoreCase(suffixName)) {
            return true;
        } else {
            return false;
        }
    }
    // 文件不包含视频
    public static boolean suffixNameExcel(String suffixName) {
        if ((".xlsx").equalsIgnoreCase(suffixName) || (".xls").equalsIgnoreCase(suffixName) || (".pdf").equalsIgnoreCase(suffixName)) {
            return true;
        } else {
            return false;
        }
    }
}

import org.springframework.beans.factory.annotation.Value;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLDecoder;
import java.util.UUID;
public class FileUtil {
    @Value("${uploadFilePath}")
    private String uploadFilePath;
    private FileUtil() {
    }
    /**
     * File转换为byte[]
     */
    public static byte[] getBytesByFile(File file) {
        try {
            //获取输入流
            FileInputStream fis = new FileInputStream(file);
            //新的 byte 数组输出流，缓冲区容量1024byte
            ByteArrayOutputStream bos = new ByteArrayOutputStream(1024);
            //缓存
            byte[] b = new byte[1024];
            int n;
            while ((n = fis.read(b)) != -1) {
                bos.write(b, 0, n);
            }
            fis.close();
            //改变为byte[]
            byte[] data = bos.toByteArray();
            //
            bos.close();
            return data;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    public static void uploadFile(byte[] file, String filePath, String fileName) throws IOException {
        File targetFile = new File(filePath);
        if (!targetFile.exists()) {
            if (!targetFile.mkdirs()) {
                throw new IOException();
            }
        }
        FileOutputStream out = null;
        try {
            out = new FileOutputStream(filePath + "/" + fileName);
            out.write(file);
            out.flush();
        } catch (IOException e) {
            throw new IOException();
        } finally {
            if (out != null) {
                out.close();
            }
        }
    }
    public static boolean deleteFile(String fileName) {
        File file = new File(fileName);
        // 如果文件路径所对应的文件存在，并且是一个文件，则直接删除
        if (file.exists() && file.isFile()) {
            if (file.delete()) {
                return true;
            } else {
                return false;
            }
        }
        return false;
    }
    public static String renameToUUID(String fileName) {
        return UUID.randomUUID() + "." + fileName.substring(fileName.lastIndexOf(".") + 1);
    }
    /**
     * 文件删除方法
     */
    public static boolean deleteQuietly(String fileAddress) {
        File file = new File(fileAddress);
        if (file == null) {
            return false;
        } else {
            try {
                if (file.isDirectory()) {
//                    cleanDirectory(file);
                }
            } catch (Exception var3) {
                ;
            }
            try {
                return file.delete();
            } catch (Exception var2) {
                return false;
            }
        }
    }
    /**
     * 下载本地文件
     */
    public static void downloadLocal(HttpServletResponse response, String filePath,String encode) {
        response.setContentType("text/html;charset=" + encode);
        try {
            // 读到流中
            InputStream inStream = new FileInputStream(filePath); // 文件的存放路径
            // path是指欲下载的文件的路径
            File file = new File(filePath);
            // 取得文件名
            String fileName = file.getName();
            // 设置输出的格式
            response.reset();
            response.setContentType("bin");
            response.addHeader("Content-Disposition", "attachment; filename=\"" + new String(fileName.getBytes(encode), "ISO8859-1") + "\"");
            // 循环取出流中的数据
            byte[] b = new byte[100];
            int len;
            while ((len = inStream.read(b)) > 0) {
                response.getOutputStream().write(b, 0, len);
            }
            inStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /**
     * 通过文件路径直接修改文件名
     *
     * @param filePath    需要修改的文件的完整路径
     * @param newFileName 需要修改的文件的名称
     * @return
     */
    public static String FixFileName(String filePath, String newFileName) {
        File f = new File(filePath);
        if (!f.exists()) { // 判断原文件是否存在（防止文件名冲突）
            return null;
        }
        newFileName = newFileName.trim();
        if ("".equals(newFileName) || newFileName == null) // 文件名不能为空
            return null;
        String newFilePath = null;
        if (f.isDirectory()) { // 判断是否为文件夹
            newFilePath = filePath.substring(0, filePath.lastIndexOf("/")) + "/" + newFileName;
        } else {
            newFilePath = filePath.substring(0, filePath.lastIndexOf("/")) + "/" + newFileName;
        }
        File nf = new File(newFilePath);
        try {
            f.renameTo(nf); // 修改文件名
        } catch (Exception err) {
            err.printStackTrace();
            return null;
        }
        return newFilePath;
    }
    /*
     *写文件
     */
    public static boolean write(String filePath, String fileName, String fileContent) throws IOException {
        boolean result = false;
        File targetFile = new File(filePath);
        if (!targetFile.exists()) {
            if (!targetFile.mkdirs()) {
                throw new IOException();
            }
        }
        try {
            FileOutputStream fs = new FileOutputStream(filePath+"/"+fileName);
            //byte[] b = fileContent.getBytes();
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(fs, "UTF-8"));
          /*
            带bom的utf8
            fs.write( 0xef );
            fs.write( 0xbb);
            fs.write( 0xbf);*/
            writer.write(fileContent);
            writer.flush();
            writer.close();
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    //需要注意的是当删除某一目录时，必须保证该目录下没有其他文件才能正确删除，否则将删除失败。
    public static boolean  deleteFolder(File folder) throws Exception {
        boolean flag = false;
        if (!folder.exists()) {
            throw new Exception("文件不存在");
        }
        File[] files = folder.listFiles();
        if (files != null) {
            for (File file : files) {
                if (file.isDirectory()) {
                    //递归直到目录下没有文件
                    deleteFolder(file);
//                    System.err.println("删除目录下所有文件");
                    flag=true;
                } else {
                    //删除
                    file.delete();
//                    System.err.println("删除文件夹里面的文件");
                    flag=true;
                }
            }
        }
        //删除
        folder.delete();
        return flag;
    }
    public static void downloadFile(HttpServletResponse resp, String downloadPath) throws IOException {
        String filePath = null;
        try {
            filePath= URLDecoder.decode(downloadPath,"UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        //String realPath = "D:" + File.separator + "apache-tomcat-8.5.15" + File.separator + "files";
        String realPath=filePath;//项目路径下你存放文件的地方
        File file = new File(realPath);
        if(!file.exists()){
            throw new IOException("文件不存在");
        }
        String name = new String(file.getName().getBytes("GBK"), "ISO-8859-1");
        resp.reset();
        /*
         * 跨域配置
         * */
        resp.addHeader("Access-Control-Allow-Origin", "*");
        resp.addHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE");
        resp.addHeader("Access-Control-Allow-Headers", "Content-Type");
        resp.setContentType("application/octet-stream");
        resp.setCharacterEncoding("utf-8");
        resp.setContentLength((int) file.length());
        resp.setHeader("Content-Disposition", "attachment;filename=" + name);
        byte[] buff = new byte[1024];
        BufferedInputStream bis = null;
        OutputStream os = null;
        try {
            os = resp.getOutputStream();
            bis = new BufferedInputStream(new FileInputStream(file));
            int i = 0;
            while ((i = bis.read(buff)) != -1) {
                os.write(buff, 0, i);
                os.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}