1.修改包结构为cn.keking,

jodconverter-core/pom.xml

@@ -3,7 +3,7 @@
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
-    <groupId>com.yudianbank</groupId>
+    <groupId>cn.keking</groupId>
     <artifactId>jodconverter-core</artifactId>
     <version>1.0-SNAPSHOT</version>
     <packaging>jar</packaging>

jodconverter-web/pom.xml

@@ -48,7 +48,7 @@
             <scope>test</scope>
         </dependency>
         <dependency>
-            <groupId>com.yudianbank</groupId>
+            <groupId>cn.keking</groupId>
             <artifactId>jodconverter-core</artifactId>
             <version>1.0-SNAPSHOT</version>
             <exclusions>

jodconverter-web/src/main/java/cn/keking/FilePreviewApplication.java

+package cn.keking;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.scheduling.annotation.EnableScheduling;
+import java.util.Properties;
+
+@SpringBootApplication
+@EnableScheduling
+@ComponentScan(value = "cn.keking.*")
+public class FilePreviewApplication {
+	public static void main(String[] args) {
+        Properties properties = System.getProperties();
+        System.out.println(properties.get("user.dir"));
+        SpringApplication.run(FilePreviewApplication.class, args);
+	}
+}

jodconverter-web/src/main/java/cn/keking/config/RedissonConfig.java

+package cn.keking.config;
+
+import io.netty.channel.nio.NioEventLoopGroup;
+import org.redisson.Redisson;
+import org.redisson.api.RedissonClient;
+import org.redisson.client.codec.Codec;
+import org.redisson.config.Config;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.util.ClassUtils;
+
+/**
+ * Created by kl on 2017/09/26.
+ * redisson 客户端配置
+ */
+@ConfigurationProperties(prefix = "spring.redisson")
+@Configuration
+public class RedissonConfig {
+
+    private String address;
+    private int connectionMinimumIdleSize = 10;
+    private int idleConnectionTimeout=10000;
+    private int pingTimeout=1000;
+    private int connectTimeout=10000;
+    private int timeout=3000;
+    private int retryAttempts=3;
+    private int retryInterval=1500;
+    private int reconnectionTimeout=3000;
+    private int failedAttempts=3;
+    private String password = null;
+    private int subscriptionsPerConnection=5;
+    private String clientName=null;
+    private int subscriptionConnectionMinimumIdleSize = 1;
+    private int subscriptionConnectionPoolSize = 50;
+    private int connectionPoolSize = 64;
+    private int database = 0;
+    private boolean dnsMonitoring = false;
+    private int dnsMonitoringInterval = 5000;
+
+    private int thread; //当前处理核数量 * 2
+
+    private String codec="org.redisson.codec.JsonJacksonCodec";
+
+    @Bean(destroyMethod = "shutdown")
+    RedissonClient redisson() throws Exception {
+        Config config = new Config();
+        config.useSingleServer().setAddress(address)
+                .setConnectionMinimumIdleSize(connectionMinimumIdleSize)
+                .setConnectionPoolSize(connectionPoolSize)
+                .setDatabase(database)
+                .setDnsMonitoring(dnsMonitoring)
+                .setDnsMonitoringInterval(dnsMonitoringInterval)
+                .setSubscriptionConnectionMinimumIdleSize(subscriptionConnectionMinimumIdleSize)
+                .setSubscriptionConnectionPoolSize(subscriptionConnectionPoolSize)
+                .setSubscriptionsPerConnection(subscriptionsPerConnection)
+                .setClientName(clientName)
+                .setFailedAttempts(failedAttempts)
+                .setRetryAttempts(retryAttempts)
+                .setRetryInterval(retryInterval)
+                .setReconnectionTimeout(reconnectionTimeout)
+                .setTimeout(timeout)
+                .setConnectTimeout(connectTimeout)
+                .setIdleConnectionTimeout(idleConnectionTimeout)
+                .setPingTimeout(pingTimeout)
+                .setPassword(password);
+        Codec codec=(Codec) ClassUtils.forName(getCodec(), ClassUtils.getDefaultClassLoader()).newInstance();
+        config.setCodec(codec);
+        config.setThreads(thread);
+        config.setEventLoopGroup(new NioEventLoopGroup());
+        config.setUseLinuxNativeEpoll(false);
+        return Redisson.create(config);
+    }
+
+    public int getThread() {
+        return thread;
+    }
+
+    public void setThread(int thread) {
+        this.thread = thread;
+    }
+
+    public String getAddress() {
+        return address;
+    }
+
+    public void setAddress(String address) {
+        this.address = address;
+    }
+
+    public int getIdleConnectionTimeout() {
+        return idleConnectionTimeout;
+    }
+
+    public void setIdleConnectionTimeout(int idleConnectionTimeout) {
+        this.idleConnectionTimeout = idleConnectionTimeout;
+    }
+
+    public int getPingTimeout() {
+        return pingTimeout;
+    }
+
+    public void setPingTimeout(int pingTimeout) {
+        this.pingTimeout = pingTimeout;
+    }
+
+    public int getConnectTimeout() {
+        return connectTimeout;
+    }
+
+    public void setConnectTimeout(int connectTimeout) {
+        this.connectTimeout = connectTimeout;
+    }
+
+    public int getTimeout() {
+        return timeout;
+    }
+
+    public void setTimeout(int timeout) {
+        this.timeout = timeout;
+    }
+
+    public int getRetryAttempts() {
+        return retryAttempts;
+    }
+
+    public void setRetryAttempts(int retryAttempts) {
+        this.retryAttempts = retryAttempts;
+    }
+
+    public int getRetryInterval() {
+        return retryInterval;
+    }
+
+    public void setRetryInterval(int retryInterval) {
+        this.retryInterval = retryInterval;
+    }
+
+    public int getReconnectionTimeout() {
+        return reconnectionTimeout;
+    }
+
+    public void setReconnectionTimeout(int reconnectionTimeout) {
+        this.reconnectionTimeout = reconnectionTimeout;
+    }
+
+    public int getFailedAttempts() {
+        return failedAttempts;
+    }
+
+    public void setFailedAttempts(int failedAttempts) {
+        this.failedAttempts = failedAttempts;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public int getSubscriptionsPerConnection() {
+        return subscriptionsPerConnection;
+    }
+
+    public void setSubscriptionsPerConnection(int subscriptionsPerConnection) {
+        this.subscriptionsPerConnection = subscriptionsPerConnection;
+    }
+
+    public String getClientName() {
+        return clientName;
+    }
+
+    public void setClientName(String clientName) {
+        this.clientName = clientName;
+    }
+
+    public int getSubscriptionConnectionMinimumIdleSize() {
+        return subscriptionConnectionMinimumIdleSize;
+    }
+
+    public void setSubscriptionConnectionMinimumIdleSize(int subscriptionConnectionMinimumIdleSize) {
+        this.subscriptionConnectionMinimumIdleSize = subscriptionConnectionMinimumIdleSize;
+    }
+
+    public int getSubscriptionConnectionPoolSize() {
+        return subscriptionConnectionPoolSize;
+    }
+
+    public void setSubscriptionConnectionPoolSize(int subscriptionConnectionPoolSize) {
+        this.subscriptionConnectionPoolSize = subscriptionConnectionPoolSize;
+    }
+
+    public int getConnectionMinimumIdleSize() {
+        return connectionMinimumIdleSize;
+    }
+
+    public void setConnectionMinimumIdleSize(int connectionMinimumIdleSize) {
+        this.connectionMinimumIdleSize = connectionMinimumIdleSize;
+    }
+
+    public int getConnectionPoolSize() {
+        return connectionPoolSize;
+    }
+
+    public void setConnectionPoolSize(int connectionPoolSize) {
+        this.connectionPoolSize = connectionPoolSize;
+    }
+
+    public int getDatabase() {
+        return database;
+    }
+
+    public void setDatabase(int database) {
+        this.database = database;
+    }
+
+    public boolean isDnsMonitoring() {
+        return dnsMonitoring;
+    }
+
+    public void setDnsMonitoring(boolean dnsMonitoring) {
+        this.dnsMonitoring = dnsMonitoring;
+    }
+
+    public int getDnsMonitoringInterval() {
+        return dnsMonitoringInterval;
+    }
+
+    public void setDnsMonitoringInterval(int dnsMonitoringInterval) {
+        this.dnsMonitoringInterval = dnsMonitoringInterval;
+    }
+
+    public String getCodec() {
+        return codec;
+    }
+
+    public void setCodec(String codec) {
+        this.codec = codec;
+    }
+}

jodconverter-web/src/main/java/cn/keking/filters/ChinesePathFilter.java

+package cn.keking.filters;
+
+import javax.servlet.*;
+import javax.servlet.http.HttpServletRequest;
+import java.io.IOException;
+
+/**
+ *
+ * @author yudian-it
+ * @date 2017/11/30
+ */
+public class ChinesePathFilter implements Filter {
+
+    @Override
+    public void init(FilterConfig filterConfig) throws ServletException {
+    }
+
+    @Override
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
+        request.setCharacterEncoding("UTF-8");
+        response.setCharacterEncoding("UTF-8");
+        StringBuilder pathBuilder = new StringBuilder();
+        pathBuilder.append(request.getScheme()).append("://").append(request.getServerName()).append(":")
+                .append(request.getServerPort()).append(((HttpServletRequest)request).getContextPath()).append("/");
+        request.setAttribute("baseUrl", pathBuilder.toString());
+        chain.doFilter(request, response);
+    }
+
+    @Override
+    public void destroy() {
+
+    }
+}

jodconverter-web/src/main/java/cn/keking/filters/FilterConfiguration.java

+package cn.keking.filters;
+
+import org.springframework.boot.web.servlet.FilterRegistrationBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+
+/**
+ *
+ * @author yudian-it
+ * @date 2017/11/30
+ */
+@Configuration
+public class FilterConfiguration {
+
+    @Bean
+    public FilterRegistrationBean getChinesePathFilter(){
+        ChinesePathFilter filter = new ChinesePathFilter();
+        FilterRegistrationBean registrationBean = new FilterRegistrationBean();
+        registrationBean.setFilter(filter);
+        return registrationBean;
+    }
+}

jodconverter-web/src/main/java/cn/keking/param/ReturnResponse.java

+package cn.keking.param;
+
+import java.io.Serializable;
+
+/**
+ * 接口返回值结构
+ * @author yudian-it
+ * @date 2017/11/17
+ */
+public class ReturnResponse<T> implements Serializable{
+    private static final long serialVersionUID = 313975329998789878L;
+    /**
+     * 返回状态
+     * 0. 成功
+     * 1. 失败
+     */
+    private int code;
+
+    /**
+     * 返回状态描述
+     * XXX成功
+     * XXX失败
+     */
+    private String msg;
+
+    private T content;
+
+    public ReturnResponse(int code, String msg, T content) {
+        this.code = code;
+        this.msg = msg;
+        this.content = content;
+    }
+
+    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 T getContent() {
+        return content;
+    }
+
+    public void setContent(T content) {
+        this.content = content;
+    }
+}

jodconverter-web/src/main/java/cn/keking/utils/ConverterUtils.java

+package cn.keking.utils;
+
+import com.sun.star.document.UpdateDocMode;
+import cn.keking.extend.ControlDocumentFormatRegistry;
+import org.artofsolving.jodconverter.OfficeDocumentConverter;
+import org.artofsolving.jodconverter.office.DefaultOfficeManagerConfiguration;
+import org.artofsolving.jodconverter.office.OfficeManager;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import java.nio.charset.Charset;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 创建文件转换器
+ *
+ * @author yudian-it
+ * @date 2017/11/13
+ */
+@Component
+public class ConverterUtils {
+
+    @Value("${office.home}")
+    String officeHome;
+//    OpenOfficeConnection connection;
+    OfficeManager officeManager;
+
+    @PostConstruct
+    public void initOfficeManager() {
+        ////            connection = new SocketOpenOfficeConnection(host,8100);
+////            connection.connect();
+        DefaultOfficeManagerConfiguration configuration = new DefaultOfficeManagerConfiguration();
+        configuration.setOfficeHome(officeHome);
+        configuration.setPortNumber(8100);
+        officeManager = configuration.buildOfficeManager();
+        officeManager.start();
+        // 设置任务执行超时为5分钟
+        // configuration.setTaskExecutionTimeout(1000 * 60 * 5L);//
+        // 设置任务队列超时为24小时
+        // configuration.setTaskQueueTimeout(1000 * 60 * 60 * 24L);//
+    }
+
+    public OfficeDocumentConverter getDocumentConverter() {
+        OfficeDocumentConverter converter = new OfficeDocumentConverter(officeManager, new ControlDocumentFormatRegistry());
+        converter.setDefaultLoadProperties(getLoadProperties());
+        return converter;
+    }
+
+    private Map<String,?> getLoadProperties() {
+        Map<String,Object> loadProperties = new HashMap<>(10);
+        loadProperties.put("Hidden", true);
+        loadProperties.put("ReadOnly", true);
+        loadProperties.put("UpdateDocMode", UpdateDocMode.QUIET_UPDATE);
+        loadProperties.put("CharacterSet", Charset.forName("UTF-8").name());
+        return loadProperties;
+    }
+
+    @PreDestroy
+    public void destroyOfficeManager(){
+        if (null != officeManager && officeManager.isRunning()) {
+            officeManager.stop();
+        }
+    }
+
+}

jodconverter-web/src/main/java/cn/keking/utils/DeleteFileUtil.java

+package cn.keking.utils;
+
+import java.io.File;
+
+public class DeleteFileUtil {
+    /**
+     * 删除单个文件
+     *
+     * @param fileName
+     *            要删除的文件的文件名
+     * @return 单个文件删除成功返回true，否则返回false
+     */
+    public static boolean deleteFile(String fileName) {
+        File file = new File(fileName);
+        // 如果文件路径所对应的文件存在，并且是一个文件，则直接删除
+        if (file.exists() && file.isFile()) {
+            if (file.delete()) {
+                System.out.println("删除单个文件" + fileName + "成功！");
+                return true;
+            } else {
+                System.out.println("删除单个文件" + fileName + "失败！");
+                return false;
+            }
+        } else {
+            System.out.println("删除单个文件失败：" + fileName + "不存在！");
+            return false;
+        }
+    }
+
+
+    /**
+     * 删除目录及目录下的文件
+     *
+     * @param dir
+     *            要删除的目录的文件路径
+     * @return 目录删除成功返回true，否则返回false
+     */
+    public static boolean deleteDirectory(String dir) {
+        // 如果dir不以文件分隔符结尾，自动添加文件分隔符
+        if (!dir.endsWith(File.separator)) {
+            dir = dir + File.separator;
+        }
+        File dirFile = new File(dir);
+        // 如果dir对应的文件不存在，或者不是一个目录，则退出
+        if ((!dirFile.exists()) || (!dirFile.isDirectory())) {
+            System.out.println("删除目录失败：" + dir + "不存在！");
+            return false;
+        }
+        boolean flag = true;
+        // 删除文件夹中的所有文件包括子目录
+        File[] files = dirFile.listFiles();
+        for (int i = 0; i < files.length; i++) {
+            // 删除子文件
+            if (files[i].isFile()) {
+                flag = DeleteFileUtil.deleteFile(files[i].getAbsolutePath());
+                if (!flag)
+                    break;
+            }
+            // 删除子目录
+            else if (files[i].isDirectory()) {
+                flag = DeleteFileUtil.deleteDirectory(files[i]
+                        .getAbsolutePath());
+                if (!flag)
+                    break;
+            }
+        }
+        if (!flag) {
+            System.out.println("删除目录失败！");
+            return false;
+        }
+        return true;
+    }
+
+}

jodconverter-web/src/main/java/cn/keking/utils/DownloadUtils.java

+package cn.keking.utils;
+
+import cn.keking.param.ReturnResponse;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+import java.io.*;
+import java.net.*;
+import java.nio.charset.Charset;
+import java.util.UUID;
+
+/**
+ * @author yudian-it
+ */
+@Component
+public class DownloadUtils {
+
+    @Value("${file.dir}")
+    String fileDir;
+
+    /**
+     * 一开始测试的时候发现有些文件没有下载下来，而有些可以；当时也是郁闷了好一阵，但是最终还是不得解
+     * 再次测试的时候，通过前台对比url发现，原来参数中有+号特殊字符存在，但是到后之后却变成了空格，突然恍然大悟
+     * 应该是转义出了问题，url转义中会把+号当成空格来计算，所以才会出现这种情况，遂想要通过整体替换空格为加号，因为url
+     * 中的参数部分是不会出现空格的，但是文件名中就不好确定了，所以只对url参数部分做替换
+     * 注: 针对URLEncoder.encode(s,charset)会将空格转成+的情况需要做下面的替换工作
+     * @param urlAddress
+     * @param type
+     * @return
+     */
+    public ReturnResponse<String> downLoad(String urlAddress, String type, String fileName){
+        ReturnResponse<String> response = new ReturnResponse<>(0, "下载成功!!!", "");
+        URL url = null;
+        try {
+            urlAddress = replacePlusMark(urlAddress);
+            urlAddress = encodeUrlParam(urlAddress);
+            // 因为tomcat不能处理'+'号，所以讲'+'号替换成'%20%'
+            urlAddress = urlAddress.replaceAll("\\+", "%20");
+            url = new URL(urlAddress);
+        } catch (MalformedURLException e) {
+            e.printStackTrace();
+        }
+        UUID uuid = UUID.randomUUID();
+        if (null == fileName) {
+            fileName = uuid+ "."+type;
+        }else { // 文件后缀不一致时，以type为准(针对simText【将类txt文件转为txt】)
+            fileName = fileName.replace(fileName.substring(fileName.lastIndexOf(".") + 1), type);
+        }
+        String realPath = fileDir + fileName;
+        File dirFile = new File(fileDir);
+        if (!dirFile.exists()) {
+            dirFile.mkdirs();
+        }
+        try {
+            URLConnection connection = url.openConnection();
+            InputStream in = connection.getInputStream();
+
+            FileOutputStream os = new FileOutputStream(realPath);
+            byte[] buffer = new byte[4 * 1024];
+            int read;
+            while ((read = in.read(buffer)) > 0) {
+                os.write(buffer, 0, read);
+            }
+            os.close();
+            in.close();
+            response.setContent(realPath);
+            // 同样针对类txt文件，如果成功msg包含的是转换后的文件名
+            response.setMsg(fileName);
+
+             // txt转换文件编码为utf8
+            if("txt".equals(type)){
+                convertTextPlainFileCharsetToUtf8(realPath);
+            }
+
+            return response;
+        } catch (IOException e) {
+            e.printStackTrace();
+            response.setCode(1);
+            response.setContent(null);
+            if (e instanceof FileNotFoundException) {
+                response.setMsg("文件不存在!!!");
+            }else {
+                response.setMsg(e.getMessage());
+            }
+            return response;
+        }
+    }
+
+    /**
+     * 注:可能是原来因为前端通过encodeURI来编码的，因为通过encodeURI编码+会被转成+号(亦即没有转)，
+     * 而通过encodeURIComponent则会转成%2B，这样URLDecoder是可以正确处理的，所以也就没有必要在这里替换了
+     * 转换url参数部分的空格为加号(因为在url编解码的过程中出现+转为空格的情况)
+     * @param urlAddress
+     * @return
+     */
+    private String replacePlusMark(String urlAddress) {
+        if (urlAddress.contains("?")) {
+            String nonParamStr = urlAddress.substring(0,urlAddress.indexOf("?") + 1);
+            String paramStr = urlAddress.substring(nonParamStr.length());
+            return nonParamStr + paramStr.replace(" ", "+");
+        }
+        return urlAddress;
+    }
+
+    /**
+     * 对最有一个路径进行转码
+     * @param urlAddress
+     *          http://192.168.2.111:8013/demo/Handle中文.zip
+     * @return
+     */
+    private String encodeUrlParam(String urlAddress) {
+        String newUrl = "";
+        try {
+            String path = "";
+            String param = "";
+            if (urlAddress.contains("?")) {
+                path = urlAddress.substring(0, urlAddress.indexOf("?"));
+                param = urlAddress.substring(urlAddress.indexOf("?"));
+            }else {
+                path = urlAddress;
+            }
+            String lastPath = path.substring(path.lastIndexOf("/") + 1);
+            String leftPath = path.substring(0, path.lastIndexOf("/") + 1);
+            String encodeLastPath = URLEncoder.encode(lastPath, "UTF-8");
+            newUrl += leftPath + encodeLastPath;
+            if (urlAddress.contains("?")) {
+                newUrl += param;
+            }
+        } catch (UnsupportedEncodingException e) {
+            e.printStackTrace();
+        }
+        return newUrl;
+    }
+
+
+
+    /**
+     * 因为jodConvert2.1不支持ms2013版本的office转换，这里偷懒，尝试看改一下文件类型，让jodConvert2.1去
+     * 处理ms2013，看结果如何，如果问题很大的话只能采取其他方式，如果没有问题，暂时使用该版本来转换
+     * @param type
+     * @return
+     */
+    private String dealWithMS2013(String type) {
+        String newType = null;
+        switch (type){
+            case "docx":
+                newType = "doc";
+            break;
+            case "xlsx":
+                newType = "doc";
+            break;
+            case "pptx":
+                newType = "ppt";
+            break;
+            default:
+                newType = type;
+            break;
+        }
+        return newType;
+    }
+
+  /**
+   * 转换文本文件编码为utf8
+   * 探测源文件编码,探测到编码切不为utf8则进行转码
+   * @param filePath 文件路径
+   */
+  private static void convertTextPlainFileCharsetToUtf8(String filePath) throws IOException {
+    File sourceFile = new File(filePath);
+    if(sourceFile.exists() && sourceFile.isFile() && sourceFile.canRead()) {
+      String encoding = null;
+      try {
+        FileCharsetDetector.Observer observer = FileCharsetDetector.guessFileEncoding(sourceFile);
+        // 为准确探测到编码,不适用猜测的编码
+        encoding = observer.isFound()?observer.getEncoding():null;
+        // 为准确探测到编码,可以考虑使用GBK  大部分文件都是windows系统产生的
+      } catch (IOException e) {
+        // 编码探测失败,
+        e.printStackTrace();
+      }
+      if(encoding != null && !"UTF-8".equals(encoding)){
+        // 不为utf8,进行转码
+        File tmpUtf8File = new File(filePath+".utf8");
+        Writer writer = new OutputStreamWriter(new FileOutputStream(tmpUtf8File),"UTF-8");
+        Reader reader = new BufferedReader(new InputStreamReader(new FileInputStream(sourceFile),encoding));
+        char[] buf = new char[1024];
+        int read;
+        while ((read = reader.read(buf)) > 0){
+          writer.write(buf, 0, read);
+        }
+        reader.close();
+        writer.close();
+        // 删除源文件
+        sourceFile.delete();
+        // 重命名
+        tmpUtf8File.renameTo(sourceFile);
+      }
+    }
+  }
+}

jodconverter-web/src/main/java/cn/keking/utils/FileCharsetDetector.java

+package cn.keking.utils;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+import org.mozilla.intl.chardet.nsDetector;
+import org.mozilla.intl.chardet.nsICharsetDetectionObserver;
+
+/**
+ * 文本文件编码探测工具类
+ *
+ * @author HWliao
+ * @date 2017-12-24
+ */
+public class FileCharsetDetector {
+
+  /**
+   * 传入一个文件(File)对象，检查文件编码
+   *
+   * @param file File对象实例
+   * @return 文件编码，若无，则返回null
+   * @throws FileNotFoundException
+   * @throws IOException
+   */
+  public static Observer guessFileEncoding(File file)
+      throws FileNotFoundException, IOException {
+    return guessFileEncoding(file, new nsDetector());
+  }
+
+  /**
+   * <pre>
+   * 获取文件的编码
+   * @param file
+   *            File对象实例
+   * @param languageHint
+   *            语言提示区域代码 @see #nsPSMDetector ,取值如下：
+   *             1 : Japanese
+   *             2 : Chinese
+   *             3 : Simplified Chinese
+   *             4 : Traditional Chinese
+   *             5 : Korean
+   *             6 : Dont know(default)
+   * </pre>
+   *
+   * @return 文件编码，eg：UTF-8,GBK,GB2312形式(不确定的时候，返回可能的字符编码序列)；若无，则返回null
+   * @throws FileNotFoundException
+   * @throws IOException
+   */
+  public static Observer guessFileEncoding(File file, int languageHint)
+      throws FileNotFoundException, IOException {
+    return guessFileEncoding(file, new nsDetector(languageHint));
+  }
+
+  /**
+   * 获取文件的编码
+   *
+   * @param file
+   * @param det
+   * @return
+   * @throws FileNotFoundException
+   * @throws IOException
+   */
+  private static Observer guessFileEncoding(File file, nsDetector det)
+      throws FileNotFoundException, IOException {
+    // new Observer
+    Observer observer = new Observer();
+    // set Observer
+    // The Notify() will be called when a matching charset is found.
+    det.Init(observer);
+
+    BufferedInputStream imp = new BufferedInputStream(new FileInputStream(
+        file));
+    byte[] buf = new byte[1024];
+    int len;
+    boolean done = false;
+    boolean isAscii = false;
+
+    while ((len = imp.read(buf, 0, buf.length)) != -1) {
+      // Check if the stream is only ascii.
+      isAscii = det.isAscii(buf, len);
+      if (isAscii) {
+        break;
+      }
+      // DoIt if non-ascii and not done yet.
+      done = det.DoIt(buf, len, false);
+      if (done) {
+        break;
+      }
+    }
+    imp.close();
+    det.DataEnd();
+
+    if (isAscii) {
+      observer.encoding = "ASCII";
+      observer.found = true;
+    }
+
+    if (!observer.isFound()) {
+      String[] prob = det.getProbableCharsets();
+      // // 这里将可能的字符集组合起来返回
+      // for (int i = 0; i < prob.length; i++) {
+      // if (i == 0) {
+      // encoding = prob[i];
+      // } else {
+      // encoding += "," + prob[i];
+      // }
+      // }
+      if (prob.length > 0) {
+        // 在没有发现情况下,去第一个可能的编码
+        observer.encoding = prob[0];
+      } else {
+        observer.encoding = null;
+      }
+    }
+    return observer;
+  }
+
+  /**
+   * @author liaohongwei
+   * @Description: 文件字符编码观察者, 但判断出字符编码时候调用
+   * @date 2016年6月20日 下午2:27:06
+   */
+  public static class Observer implements nsICharsetDetectionObserver {
+
+    /**
+     * @Fields encoding : 字符编码
+     */
+    private String encoding = null;
+    /**
+     * @Fields found : 是否找到字符集
+     */
+    private boolean found = false;
+
+    @Override
+    public void Notify(String charset) {
+      this.encoding = charset;
+      this.found = true;
+    }
+
+    public String getEncoding() {
+      return encoding;
+    }
+
+    public boolean isFound() {
+      return found;
+    }
+
+    @Override
+    public String toString() {
+      return "Observer [encoding=" + encoding + ", found=" + found + "]";
+    }
+  }
+
+}

jodconverter-web/src/main/java/cn/keking/utils/FileUtils.java

+package cn.keking.utils;
+
+import com.google.common.collect.Lists;
+import org.redisson.api.RMapCache;
+import org.redisson.api.RedissonClient;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.io.*;
+import java.nio.charset.Charset;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+/**
+ *
+ * @author yudian-it
+ * @date 2017/11/13
+ */
+@Component
+public class FileUtils {
+
+    final String REDIS_FILE_PREVIEW_PDF_KEY = "converted-preview-pdf-file";
+    final String REDIS_FILE_PREVIEW_IMGS_KEY = "converted-preview-imgs-file";//压缩包内图片文件集合
+    @Autowired
+    RedissonClient redissonClient;
+    @Value("${file.dir}")
+    String fileDir;
+
+    @Value("${converted.file.charset}")
+    String charset;
+
+    @Value("${simText}")
+    String[] simText;
+    /**
+     * 已转换过的文件集合(redis缓存)
+     * @return
+     */
+    public Map<String, String> listConvertedFiles() {
+        RMapCache<String, String> convertedList = redissonClient.getMapCache(REDIS_FILE_PREVIEW_PDF_KEY);
+        return convertedList;
+    }
+
+    /**
+     * 已转换过的文件，根据文件名获取
+     * @return
+     */
+    public String getConvertedFile(String key) {
+        RMapCache<String, String> convertedList = redissonClient.getMapCache(REDIS_FILE_PREVIEW_PDF_KEY);
+        return convertedList.get(key);
+    }
+
+    /**
+     * 查看文件类型(防止参数中存在.点号或者其他特殊字符，所以先抽取文件名，然后再获取文件类型)
+     *
+     * @param url
+     * @return
+     */
+    public String typeFromUrl(String url) {
+        String nonPramStr = url.substring(0, url.indexOf("?") != -1 ? url.indexOf("?") : url.length());
+        String fileName = nonPramStr.substring(nonPramStr.lastIndexOf("/") + 1);
+        String fileType = fileName.substring(fileName.lastIndexOf(".") + 1);
+        if (listPictureTypes().contains(fileType.toLowerCase())) {
+            fileType = "picture";
+        }
+        if (listArchiveTypes().contains(fileType.toLowerCase())) {
+            fileType = "compress";
+        }
+        if (listOfficeTypes().contains(fileType.toLowerCase())) {
+            fileType = "office";
+        }
+        if (Arrays.asList(simText).contains(fileType.toLowerCase())) {
+            fileType = "simText";
+        }
+        return fileType;
+    }
+    /**
+     * 从url中剥离出文件名
+     * @param url
+     *      格式如：http://keking.ufile.ucloud.com.cn/20171113164107_月度绩效表模板(新).xls?UCloudPublicKey=ucloudtangshd@weifenf.com14355492830001993909323&Expires=&Signature=I D1NOFtAJSPT16E6imv6JWuq0k=
+     * @return
+     */
+    public String getFileNameFromURL(String url) {
+        // 因为url的参数中可能会存在/的情况，所以直接url.lastIndexOf("/")会有问题
+        // 所以先从？处将url截断，然后运用url.lastIndexOf("/")获取文件名
+        String noQueryUrl = url.substring(0, url.indexOf("?") != -1 ? url.indexOf("?"): url.length());
+        String fileName = noQueryUrl.substring(noQueryUrl.lastIndexOf("/") + 1);
+        return fileName;
+    }
+
+    /**
+     * 获取文件后缀
+     * @param fileName
+     * @return
+     */
+    public String getSuffixFromFileName(String fileName) {
+        String suffix = fileName.substring(fileName.lastIndexOf("."));
+        return suffix;
+    }
+
+    /**
+     * 从路径中获取
+     * @param path
+     *      类似这种：C:\Users\yudian-it\Downloads
+     * @return
+     */
+    public String getFileNameFromPath(String path) {
+        return path.substring(path.lastIndexOf(File.separator) + 1);
+    }
+
+    public List<String> listPictureTypes(){
+        List<String> list = Lists.newArrayList();
+        list.add("jpg");
+        list.add("jpeg");
+        list.add("png");
+        list.add("gif");
+        list.add("bmp");
+        return list;
+    }
+
+    public List<String> listArchiveTypes(){
+        List<String> list = Lists.newArrayList();
+        list.add("rar");
+        list.add("zip");
+        list.add("jar");
+        list.add("7-zip");
+        list.add("tar");
+        list.add("gzip");
+        list.add("7z");
+        return list;
+    }
+
+    public List<String> listOfficeTypes() {
+        List<String> list = Lists.newArrayList();
+        list.add("docx");
+        list.add("doc");
+        list.add("xls");
+        list.add("xlsx");
+        list.add("ppt");
+        list.add("pptx");
+        return list;
+    }
+
+    /**
+     * 获取相对路径
+     * @param absolutePath
+     * @return
+     */
+    public String getRelativePath(String absolutePath) {
+        return absolutePath.substring(fileDir.length());
+    }
+
+    public void addConvertedFile(String fileName, String value){
+        RMapCache<String, String> convertedList = redissonClient.getMapCache(REDIS_FILE_PREVIEW_PDF_KEY);
+        convertedList.fastPut(fileName, value);
+    }
+
+    /**
+     * 获取redis中压缩包内图片文件
+     * @param fileKey
+     * @return
+     */
+    public List getRedisImgUrls(String fileKey){
+        RMapCache<String, List> convertedList = redissonClient.getMapCache(REDIS_FILE_PREVIEW_IMGS_KEY);
+        return convertedList.get(fileKey);
+    }
+
+    /**
+     * 设置redis中压缩包内图片文件
+     * @param fileKey
+     * @param imgs
+     */
+    public void setRedisImgUrls(String fileKey,List imgs){
+        RMapCache<String, List> convertedList = redissonClient.getMapCache(REDIS_FILE_PREVIEW_IMGS_KEY);
+         convertedList.fastPut(fileKey,imgs);
+    }
+    /**
+     * 判断文件编码格式
+     * @param path
+     * @return
+     */
+    public String getFileEncodeUTFGBK(String path){
+        String enc = Charset.forName("GBK").name();
+        File file = new File(path);
+        InputStream in= null;
+        try {
+            in = new FileInputStream(file);
+            byte[] b = new byte[3];
+            in.read(b);
+            in.close();
+            if (b[0] == -17 && b[1] == -69 && b[2] == -65) {
+                enc = Charset.forName("UTF-8").name();
+            }
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        System.out.println("文件编码格式为:" + enc);
+        return enc;
+    }
+
+    /**
+     * 对转换后的文件进行操作(改变编码方式)
+     * @param outFilePath
+     */
+    public void doActionConvertedFile(String outFilePath) {
+        StringBuffer sb = new StringBuffer();
+        try (InputStream inputStream = new FileInputStream(outFilePath);
+            BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, charset))){
+            String line;
+            while(null != (line = reader.readLine())){
+                if (line.contains("charset=gb2312")) {
+                    line = line.replace("charset=gb2312", "charset=utf-8");
+                }
+                sb.append(line);
+            }
+            // 添加sheet控制头
+            sb.append("<script src=\"js/jquery-3.0.0.min.js\" type=\"text/javascript\"></script>");
+            sb.append("<script src=\"js/excel.header.js\" type=\"text/javascript\"></script>");
+            sb.append("<link rel=\"stylesheet\" href=\"http://cdn.static.runoob.com/libs/bootstrap/3.3.7/css/bootstrap.min.css\">");
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        // 重新写入文件
+        try(FileOutputStream fos = new FileOutputStream(outFilePath);
+            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(fos))){
+            writer.write(sb.toString());
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}

jodconverter-web/src/main/java/cn/keking/utils/OfficeToPdf.java

+package cn.keking.utils;
+import org.artofsolving.jodconverter.OfficeDocumentConverter;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import java.io.File;
+
+/**
+ * @author yudian-it
+ */
+@Component
+public class OfficeToPdf {
+    /**
+     * 获取OpenOffice.org 3的安装目录
+     *
+     * @return OpenOffice.org 3的安装目录
+     */
+    @Autowired
+    ConverterUtils converterUtils;
+    /**
+     * 使Office2003-2007全部格式的文档(.doc|.docx|.xls|.xlsx|.ppt|.pptx) 转化为pdf文件<br>
+     *
+     * @param inputFilePath
+     *            源文件路径，如："e:/test.docx"
+     * @param outputFilePath
+     *            目标文件路径，如："e:/test_docx.pdf"
+     * @return
+     */
+    public  boolean openOfficeToPDF(String inputFilePath, String outputFilePath) {
+        return office2pdf(inputFilePath, outputFilePath);
+    }
+
+
+    /**
+     * 转换文件
+     *
+     * @param inputFile
+     * @param outputFilePath_end
+     * @param inputFilePath
+     * @param outputFilePath
+     * @param converter
+     */
+    public static void converterFile(File inputFile, String outputFilePath_end,
+                                     String inputFilePath, String outputFilePath,
+                                     OfficeDocumentConverter converter) {
+        File outputFile = new File(outputFilePath_end);
+        // 假如目标路径不存在,则新建该路径
+        if (!outputFile.getParentFile().exists()) {
+            outputFile.getParentFile().mkdirs();
+        }
+        converter.convert(inputFile, outputFile);
+    }
+
+    /**
+     * 使Office2003-2007全部格式的文档(.doc|.docx|.xls|.xlsx|.ppt|.pptx) 转化为pdf文件
+     *
+     * @param inputFilePath
+     *            源文件路径，如："e:/test.docx"
+     * @param outputFilePath
+     *            目标文件路径，如："e:/test_docx.pdf"
+     * @return
+     */
+    public  boolean office2pdf(String inputFilePath, String outputFilePath) {
+        boolean flag = false;
+        OfficeDocumentConverter converter = converterUtils.getDocumentConverter();
+        if (null != inputFilePath) {
+            File inputFile = new File(inputFilePath);
+            // 判断目标文件路径是否为空
+            if (null == outputFilePath) {
+                // 转换后的文件路径
+                String outputFilePath_end = getOutputFilePath(inputFilePath);
+                if (inputFile.exists()) {// 找不到源文件, 则返回
+                    converterFile(inputFile, outputFilePath_end, inputFilePath,
+                            outputFilePath, converter);
+                    flag = true;
+                }
+            } else {
+                if (inputFile.exists()) {// 找不到源文件, 则返回
+                    converterFile(inputFile, outputFilePath, inputFilePath,
+                            outputFilePath, converter);
+                    flag = true;
+                }
+            }
+//            officeManager.stop();
+        } else {
+            flag = false;
+        }
+        return flag;
+    }
+
+    /**
+     * 获取输出文件
+     *
+     * @param inputFilePath
+     * @return
+     */
+    public static String getOutputFilePath(String inputFilePath) {
+        String outputFilePath = inputFilePath.replaceAll("."
+                + getPostfix(inputFilePath), ".pdf");
+        return outputFilePath;
+    }
+
+    /**
+     * 获取inputFilePath的后缀名，如："e:/test.pptx"的后缀名为："pptx"
+     *
+     * @param inputFilePath
+     * @return
+     */
+    public static String getPostfix(String inputFilePath) {
+        return inputFilePath.substring(inputFilePath.lastIndexOf(".") + 1);
+    }
+
+}

jodconverter-web/src/main/java/cn/keking/utils/ShedulerClean.java

+package cn.keking.utils;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+@Component
+public class ShedulerClean {
+    @Value("${file.dir}")
+    String fileDir;
+
+//    @Scheduled(cron = "0 0 23 * * ?")   //每晚23点执行一次
+    public void clean(){
+        System.out.println("执行一次清空文件夹");
+        DeleteFileUtil.deleteDirectory(fileDir);
+    }
+}

jodconverter-web/src/main/java/cn/keking/utils/SimTextUtil.java

+package cn.keking.utils;
+
+import cn.keking.param.ReturnResponse;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+/**
+ *  读取类文本文件
+ * @author yudian-it
+ * @date 2017/12/13
+ */
+@Component
+public class SimTextUtil {
+    @Value("${file.dir}")
+    String fileDir;
+    @Autowired
+    DownloadUtils downloadUtils;
+
+    public ReturnResponse<String> readSimText(String url, String fileName){
+        ReturnResponse<String> response = downloadUtils.downLoad(url, "txt", fileName);
+        return response;
+    }
+}

jodconverter-web/src/main/java/cn/keking/web/controller/FileController.java

+package cn.keking.web.controller;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Lists;
+import cn.keking.param.ReturnResponse;
+import cn.keking.utils.FileUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
+
+import javax.servlet.http.HttpServletRequest;
+import java.io.*;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ *
+ * @author yudian-it
+ * @date 2017/12/1
+ */
+@RestController
+public class FileController {
+    @Value("${file.dir}")
+    String fileDir;
+    @Autowired
+    FileUtils fileUtils;
+    String demoDir = "demo";
+    String demoPath = demoDir + File.separator;
+
+    @RequestMapping(value = "fileUpload", method = RequestMethod.POST)
+    public String fileUpload(@RequestParam("file") MultipartFile file,
+                             HttpServletRequest request) throws JsonProcessingException {
+        String fileName = file.getOriginalFilename();
+        // 判断该文件类型是否有上传过，如果上传过则提示不允许再次上传
+        if (existsTypeFile(fileName)) {
+            return new ObjectMapper().writeValueAsString(new ReturnResponse<String>(1, "每一种类型只可以上传一个文件，请先删除原有文件再次上传", null));
+        }
+        File outFile = new File(fileDir + demoPath);
+        if (!outFile.exists()) {
+            outFile.mkdirs();
+        }
+        try(InputStream in = file.getInputStream();
+            OutputStream ot = new FileOutputStream(fileDir + demoPath + fileName)){
+            byte[] buffer = new byte[1024];
+            int len;
+            while ((-1 != (len = in.read(buffer)))) {
+                ot.write(buffer, 0, len);
+            }
+            return new ObjectMapper().writeValueAsString(new ReturnResponse<String>(0, "SUCCESS", null));
+        } catch (IOException e) {
+            e.printStackTrace();
+            return new ObjectMapper().writeValueAsString(new ReturnResponse<String>(1, "FAILURE", null));
+        }
+    }
+
+    @RequestMapping(value = "deleteFile", method = RequestMethod.GET)
+    public String deleteFile(String fileName) throws JsonProcessingException {
+        if (fileName.contains("/")) {
+            fileName = fileName.substring(fileName.lastIndexOf("/") + 1);
+        }
+        File file = new File(fileDir + demoPath + fileName);
+        if (file.exists()) {
+            file.delete();
+        }
+        return new ObjectMapper().writeValueAsString(new ReturnResponse<String>(0, "SUCCESS", null));
+    }
+
+    @RequestMapping(value = "listFiles", method = RequestMethod.GET)
+    public String getFiles() throws JsonProcessingException {
+        List<Map<String, String>> list = Lists.newArrayList();
+        File file = new File(fileDir + demoPath);
+        if (file.exists()) {
+            Arrays.stream(file.listFiles()).forEach(file1 -> list.add(ImmutableMap.of("fileName", demoDir + "/" + file1.getName())));
+        }
+        return new ObjectMapper().writeValueAsString(list);
+    }
+
+    private String getFileName(String name) {
+        String suffix = name.substring(name.lastIndexOf("."));
+        String nameNoSuffix = name.substring(0, name.lastIndexOf("."));
+        String uuid = UUID.randomUUID().toString();
+        return uuid + "-" + nameNoSuffix + suffix;
+    }
+
+    /**
+     * 是否存在该类型的文件
+     * @return
+     * @param fileName
+     */
+    private boolean existsTypeFile(String fileName) {
+        boolean result = false;
+        String suffix = fileUtils.getSuffixFromFileName(fileName);
+        File file = new File(fileDir + demoPath);
+        if (file.exists()) {
+            for(File file1 : file.listFiles()){
+                String existsFileSuffix = fileUtils.getSuffixFromFileName(file1.getName());
+                if (suffix.equals(existsFileSuffix)) {
+                    result = true;
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+}

jodconverter-web/src/main/java/cn/keking/web/controller/IndexController.java

+package cn.keking.web.controller;
+
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+
+/**
+ *  页面跳转
+ * @author yudian-it
+ * @date 2017/12/27
+ */
+@Controller
+public class IndexController {
+
+    @RequestMapping(value = "index", method = RequestMethod.GET)
+    public String go2Index(){
+        return "index";
+    }
+
+    @RequestMapping(value = "/", method = RequestMethod.GET)
+    public String root() {
+        return "redirect:/index";
+    }
+}

jodconverter-web/src/main/java/cn/keking/web/controller/OnlinePreviewController.java

+package cn.keking.web.controller;
+
+import com.google.common.collect.Lists;
+import cn.keking.param.ReturnResponse;
+import cn.keking.utils.*;
+import org.apache.commons.io.IOUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.util.StringUtils;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLDecoder;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author yudian-it
+ */
+@Controller
+public class OnlinePreviewController {
+    @Autowired
+    private OfficeToPdf officeToPdf;
+    @Autowired
+    FileUtils fileUtils;
+    @Autowired
+    DownloadUtils downloadUtils;
+    @Autowired
+    ZipReader zipReader;
+    @Autowired
+    SimTextUtil simTextUtil;
+    @Value("${file.dir}")
+    String fileDir;
+
+
+    /**
+     * @param url
+     * @param model
+     * @return
+     */
+    @RequestMapping(value = "onlinePreview", method = RequestMethod.GET)
+    public String onlinePreview(String url, Model model, HttpServletRequest req) throws UnsupportedEncodingException {
+        // 路径转码
+        String decodedUrl = URLDecoder.decode(url, "utf-8");
+        String type = fileUtils.typeFromUrl(url);
+        String suffix = suffixFromUrl(url);
+        // 抽取文件并返回文件列表
+        String fileName = fileUtils.getFileNameFromURL(decodedUrl);
+        model.addAttribute("fileType", suffix);
+        if (type.equalsIgnoreCase("picture")) {
+            List imgUrls = Lists.newArrayList(url);
+            try{
+                String fileKey = req.getParameter("fileKey");
+                imgUrls.clear();
+                imgUrls.addAll(fileUtils.getRedisImgUrls(fileKey));
+            }catch (Exception e){
+                imgUrls = Lists.newArrayList(url);
+            }
+            model.addAttribute("imgurls", imgUrls);
+            model.addAttribute("currentUrl",url);
+            return "picture";
+        } else if (type.equalsIgnoreCase("simText")) {
+            ReturnResponse<String> response = simTextUtil.readSimText(decodedUrl, fileName);
+            if (0 != response.getCode()) {
+                model.addAttribute("msg", response.getMsg());
+                return "fileNotSupported";
+            }
+            model.addAttribute("ordinaryUrl", response.getMsg());
+            return "txt";
+        } else if (type.equalsIgnoreCase("pdf")) {
+            model.addAttribute("pdfUrl", url);
+            return "pdf";
+        } else if (type.equalsIgnoreCase("compress")) {
+            String fileTree = null;
+            // 判断文件名是否存在(redis缓存读取)
+            if (!StringUtils.hasText(fileUtils.getConvertedFile(fileName))) {
+                ReturnResponse<String> response = downloadUtils.downLoad(decodedUrl, suffix, fileName);
+                if (0 != response.getCode()) {
+                    model.addAttribute("msg", response.getMsg());
+                    return "fileNotSupported";
+                }
+                String filePath = response.getContent();
+                if ("zip".equalsIgnoreCase(suffix) || "jar".equalsIgnoreCase(suffix) || "gzip".equalsIgnoreCase(suffix)) {
+                    fileTree = zipReader.readZipFile(filePath, fileName);
+                } else if ("rar".equalsIgnoreCase(suffix)) {
+                    fileTree = zipReader.unRar(filePath, fileName);
+                }
+                fileUtils.addConvertedFile(fileName, fileTree);
+            } else {
+                fileTree = fileUtils.getConvertedFile(fileName);
+            }
+            if (null != fileTree) {
+                model.addAttribute("fileTree", fileTree);
+                return "compress";
+            } else {
+                model.addAttribute("msg", "压缩文件类型不受支持，尝试在压缩的时候选择RAR4格式");
+                return "fileNotSupported";
+            }
+        } else if ("office".equalsIgnoreCase(type)) {
+            boolean isHtml = suffix.equalsIgnoreCase("xls")
+                    || suffix.equalsIgnoreCase("xlsx");
+            String pdfName = fileName.substring(0, fileName.lastIndexOf(".") + 1) + (isHtml ? "html" : "pdf");
+            // 判断之前是否已转换过，如果转换过，直接返回，否则执行转换
+            if (!fileUtils.listConvertedFiles().containsKey(pdfName)) {
+                String filePath = fileDir + fileName;
+                if (!new File(filePath).exists()) {
+                    ReturnResponse<String> response = downloadUtils.downLoad(decodedUrl, suffix, null);
+                    if (0 != response.getCode()) {
+                        model.addAttribute("msg", response.getMsg());
+                        return "fileNotSupported";
+                    }
+                    filePath = response.getContent();
+                }
+                String outFilePath = fileDir + pdfName;
+                if (StringUtils.hasText(outFilePath)) {
+                    officeToPdf.openOfficeToPDF(filePath, outFilePath);
+                    File f = new File(filePath);
+                    if (f.exists()) {
+                        f.delete();
+                    }
+                    if (isHtml) {
+                        // 对转换后的文件进行操作(改变编码方式)
+                        fileUtils.doActionConvertedFile(outFilePath);
+                    }
+                    // 加入缓存
+                    fileUtils.addConvertedFile(pdfName, fileUtils.getRelativePath(outFilePath));
+                }
+            }
+            model.addAttribute("pdfUrl", pdfName);
+            return isHtml ? "html" : "pdf";
+        } else {
+            model.addAttribute("msg", "系统还不支持该格式文件的在线预览，" +
+                    "如有需要请按下方显示的邮箱地址联系系统维护人员");
+            return "fileNotSupported";
+        }
+    }
+
+    /**
+     * 多图片切换预览
+     *
+     * @param model
+     * @param req
+     * @return
+     * @throws UnsupportedEncodingException
+     */
+    @RequestMapping(value = "picturesPreview", method = RequestMethod.GET)
+    public String picturesPreview(String urls, Model model, HttpServletRequest req) throws UnsupportedEncodingException {
+        // 路径转码
+        String decodedUrl = URLDecoder.decode(urls, "utf-8");
+        // 抽取文件并返回文件列表
+        String[] imgs = decodedUrl.split("|");
+        List imgurls = Arrays.asList(imgs);
+        model.addAttribute("imgurls", imgurls);
+        return "picture";
+    }
+
+
+    private String suffixFromUrl(String url) {
+        String nonPramStr = url.substring(0, url.indexOf("?") != -1 ? url.indexOf("?") : url.length());
+        String fileName = nonPramStr.substring(nonPramStr.lastIndexOf("/") + 1);
+        String fileType = fileName.substring(fileName.lastIndexOf(".") + 1);
+        return fileType;
+    }
+
+    /**
+     * 根据url获取文件内容
+     * 当pdfjs读取存在跨域问题的文件时将通过此接口读取
+     *
+     * @param urlPath
+     * @param resp
+     */
+    @RequestMapping(value = "/getCorsFile", method = RequestMethod.GET)
+    public void getCorsFile(String urlPath, HttpServletResponse resp) {
+        InputStream inputStream = null;
+        try {
+            String strUrl = urlPath.trim();
+            URL url = new URL(strUrl);
+            //打开请求连接
+            URLConnection connection = url.openConnection();
+            HttpURLConnection httpURLConnection = (HttpURLConnection) connection;
+            httpURLConnection.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 5.0; Windows NT; DigExt)");
+            inputStream = httpURLConnection.getInputStream();
+            byte[] bs = new byte[1024];
+            int len;
+            while (-1 != (len = inputStream.read(bs))) {
+                resp.getOutputStream().write(bs, 0, len);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        } finally {
+            if (inputStream != null) {
+                IOUtils.closeQuietly(inputStream);
+            }
+        }
+    }
+
+}

jodconverter-web/src/test/java/com/yudianbank/FilePreviewApplicationTests.java

-package com.yudianbank;
+package cn.keking;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;

pom.xml

@@ -3,7 +3,7 @@
          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>
 
-    <groupId>com.yudianbank</groupId>
+    <groupId>cn.keking</groupId>
     <artifactId>filepreview</artifactId>
     <version>0.0.1-SNAPSHOT</version>
     <modules>