FileUpload上传文件及读取 .ini 文件内容

package cn.easted.edm.core.utils;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.Charset;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import java.util.zip.GZIPInputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

import javax.servlet.http.HttpServletRequest;

import org.apache.tools.tar.TarEntry;
import org.apache.tools.tar.TarInputStream;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;

import cn.easted.edm.core.generic.common.Constant;
import cn.easted.edm.web.exception.MyException;

public class FileOperateUtil {

    public static final String REALNAME = "realName";
    public static final String STORENAME = "storeName";
    public static final String PATH = "path";
    public static final String SIZE = "size";
    public static final String SUFFIX = "suffix";
    public static final String CONTENTTYPE = "contentType";
    public static final String UPLOADTIME = "uploadTime";
    public static final String UPLOADDIR = "uploadDir";
    public static final String PUBLISHTIME = "publishTime";
    public static final String VERSIONNUMBER = "versionnumber";
    public static final String SYSTEM = "system";
    public static final String FUNCTION = "function";
    private static Map<String,Object> iniMap = new HashMap<String, Object>();
    /**
     * 上传文件
     * 
     * @param request
     * @param params
     * @param values
     * @return List<Map<String,Object>>
     * @throws Exception
     * @author Wanghao
     */
    @SuppressWarnings("unused")
    public static Map<String, Object> upload(HttpServletRequest request) {

        Map<String, Object> map = new HashMap<String, Object>();
        MultipartHttpServletRequest mRequest = (MultipartHttpServletRequest) request;
        Map<String, MultipartFile> fileMap = mRequest.getFileMap();
        String uploadDir = request.getSession().getServletContext().getRealPath("/") + FileOperateUtil.UPLOADDIR;
        File file = new File(uploadDir);
        if (!file.exists()) {
            file.mkdir();
        }
        String fileName = null;
        int i = 0;
        for (Iterator<Map.Entry<String, MultipartFile>> it = fileMap.entrySet().iterator(); it.hasNext(); i++) {
            Map.Entry<String, MultipartFile> entry = it.next();
            MultipartFile mFile = entry.getValue();
            // 原始文件名
            fileName = mFile.getOriginalFilename();
            // 存储文件名
            String storeName = rename(fileName);
            String noZipName = uploadDir + storeName;
            // 压缩后的文件名
            String zipName = zipName(noZipName);
            // 存储路径
            String path = uploadDir + File.separator + storeName;
            // 上传成为压缩文件
            // ZipOutputStream outputStream = new ZipOutputStream(new
            // BufferedOutputStream(new FileOutputStream(zipName)));
            // outputStream.putNextEntry(new ZipEntry(fileName));
            // outputStream.setEncoding("GBK");
            File newFile = new File(path);
            try {
                FileCopyUtils.copy(mFile.getBytes(), newFile);
                // 解析文件
                String newPath = null;
                String system = null;
                if (".zip".equals(fileName.substring(fileName.lastIndexOf(".")))) {
                    newPath = path.substring(0, path.lastIndexOf("."));
                    system = Constant.SYSTEM_WINDOWS;
                    unZip(newFile, newPath);
                    traverseFolder(newPath);
                } else if (".gz".equals(fileName.substring(fileName.lastIndexOf(".")))) {
                    newPath = path.substring(0, path.length()-7);
                    system = Constant.SYSTEM_LINUX;
                    unTarGz(newFile, newPath);
                    traverseFolder(newPath);
                }
                // 固定参数值对
                map.put(FileOperateUtil.REALNAME, fileName);
                map.put(FileOperateUtil.STORENAME, storeName);
                map.put(FileOperateUtil.PATH, newPath + File.separator + fileName.substring(0, fileName.indexOf(".")));
                final long total = forkJoinPool.invoke(new FileSizeFinder(new File(newPath)));
                map.put(FileOperateUtil.SIZE, total);
                map.put(FileOperateUtil.SUFFIX, Constant.SYSTEM_WINDOWS.equals(system) ? ".zip" : ".tar.gz");
                map.put(FileOperateUtil.CONTENTTYPE, "application/octet-stream");
                map.put(FileOperateUtil.UPLOADTIME, new Date());
                String publishTime = (String)iniMap.get("publishTime");
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                map.put(FileOperateUtil.PUBLISHTIME, sdf.parse(publishTime));
                map.put(FileOperateUtil.VERSIONNUMBER, iniMap.get("versionNumber"));
                map.put(FileOperateUtil.SYSTEM, system);
                map.put(FileOperateUtil.FUNCTION, iniMap.get("function"));
            } catch (Exception e) {
                throw new MyException("100", e.getMessage());
            }
        }
        return map;
    }

    /**
     * 遍历文件夹下文件找到.ini结尾文件并读取内容
     * @param path
     *            文件路径
     * @author Wanghao
     * @return 
     * @throws Exception
     */
    private static Map<String, Object> traverseFolder(String path) throws Exception {
        System.out.println(path);

        File file = new File(path);
        if (file.exists()) {
            //判断ini文件是否存在
            MyFilter filter = new MyFilter(".ini");
            File[] iniFiles = file.listFiles(filter);
            if(iniFiles.length == 0){
                throw new MyException("100", "ini文件不存在!");
            }
            File[] files = file.listFiles();
            if (files.length == 0) {
                throw new Exception("文件夹是空的!");
            } else {
                for (File file2 : files) {
                    if (file2.isDirectory()) {
                        System.out.println("文件夹:" + file2.getAbsolutePath());
                        traverseFolder(file2.getAbsolutePath());
                    } else {
                        // System.out.println("文件:" + file2.getAbsolutePath());
                        System.out.println("文件:" + file2.getName());
                        if (file2.getName().lastIndexOf(".") != -1
                                && ".ini".equals(file2.getName().substring(file2.getName().lastIndexOf(".")))) {
                            setValue(file2);
                            return iniMap;
                        }
                    }
                }
            }
        } else {
            throw new MyException("100", "文件不存在!");
        }
        return iniMap;
    }

    /**
     * 赋值
    * @param file2 文件
    * void
    * @author Wanghao
     */
    @SuppressWarnings("unchecked")
    private static void setValue(File file2) {
        Map<String, Object> ini = IniFileReadUtil.readIniFile(file2.getAbsolutePath());
        for (String k : ini.keySet()) {
            System.out.println(k + ini.get(k));
        }
        // System.out.println(((Map<String,
        // String>)ini.get("owner")).get("name"));
        String versionName = ((Map<String, String>) ini.get("global")).get("versionName");
        String versionNumber = ((Map<String, String>) ini.get("global")).get("versionNumber");
        String function = ((Map<String, String>) ini.get("global")).get("function");
        String publishTime = ((Map<String, String>) ini.get("global")).get("publishTime");

        iniMap.put("versionName", versionName);
        iniMap.put("versionNumber", versionNumber);
        iniMap.put("function", function);
        iniMap.put("publishTime", publishTime);
    }

    public static void main(String[] args) throws Exception {
        File file = new File("E:\\Document\\ee.zip");
        unZip(file, "E:\\Document");
        traverseFolder("E:\\Document\\ee");
    }

    /**
     * 返回当前目录下以某一字母结尾的文件
    * @ClassName: MyFilter
    * @author Wanghao
    * @date 2017年6月23日 下午2:53:56
     */
    static class MyFilter implements FilenameFilter{  
        private String type;  
        public MyFilter(String type){  
            this.type = type;  
        }  
        public boolean accept(File dir,String name){  
            //return name.endsWith(type);  
             File f = new File(dir.getPath() + File.separator + name);  
             if(name.endsWith(type) || f.isDirectory()){  
                 return true;  
             }  
             return false;  
        }  
    }  
    /**
     * 解压缩zip文件
     * 
     * @param file
     *            要解压的zip文件对象
     * @param outputDir
     *            要解压到某个指定的目录下
     * @throws IOException
     * @author Wanghao
     */
    public static void unZip(File file, String outputDir) throws IOException {
        ZipFile zipFile = null;
        try {
            Charset CP866 = Charset.forName("CP866");
            zipFile = new ZipFile(file, CP866);
            // 创建输出目录
            createDirectory(outputDir, null);
            Enumeration<?> enums = zipFile.entries();
            while (enums.hasMoreElements()) {
                ZipEntry entry = (ZipEntry) enums.nextElement();
                System.out.println("解压." + entry.getName());
                // 如果是目录
                if (entry.isDirectory()) {
                    // 创建空目录
                    createDirectory(outputDir, entry.getName());
                } else {
                    // 是文件
                    File tmpFile = new File(outputDir + File.separator + entry.getName());
                    // 创建输出目录
                    createDirectory(tmpFile.getParent() + File.separator, null);
                    InputStream in = null;
                    OutputStream out = null;
                    try {
                        in = zipFile.getInputStream(entry);
                        ;
                        out = new FileOutputStream(tmpFile);
                        int length = 0;
                        byte[] b = new byte[2048];
                        while ((length = in.read(b)) != -1) {
                            out.write(b, 0, length);
                        }
                    } catch (IOException ex) {
                        throw ex;
                    } finally {
                        if (in != null)
                            in.close();
                        if (out != null)
                            out.close();
                    }
                }
            }
        } catch (IOException e) {
            throw new MyException("100", "解压缩文件出现异常");
        } finally {
            try {
                if (zipFile != null) {
                    zipFile.close();
                }
            } catch (IOException ex) {
                throw new MyException("100", "关闭zipFile出现异常");
            }
        }
    }

    /**
     * 解压tar.gz 文件
     * 
     * @param file
     *            要解压的tar.gz文件对象
     * @param outputDir
     *            要解压到某个指定的目录下
     * @throws IOException
     * @author Wanghao
     */
    public static void unTarGz(File file, String outputDir) throws IOException {
        TarInputStream tarIn = null;
        try {
            tarIn = new TarInputStream(new GZIPInputStream(new BufferedInputStream(new FileInputStream(file))),
                    1024 * 2);
            // 创建输出目录
            createDirectory(outputDir, null);
            TarEntry entry = null;
            while ((entry = tarIn.getNextEntry()) != null) {
                // 是目录
                if (entry.isDirectory()) {
                    entry.getName();
                    // 创建空目录
                    createDirectory(outputDir, entry.getName());
                } else {// 是文件
                    File tmpFile = new File(outputDir + File.separator + entry.getName());
                    // 创建输出目录
                    createDirectory(tmpFile.getParent() + File.separator, null);
                    OutputStream out = null;
                    try {
                        out = new FileOutputStream(tmpFile);
                        int length = 0;
                        byte[] b = new byte[2048];
                        while ((length = tarIn.read(b)) != -1) {
                            out.write(b, 0, length);
                        }
                    } catch (IOException ex) {
                        throw ex;
                    } finally {
                        if (out != null)
                            out.close();
                    }
                }
            }
        } catch (IOException ex) {
            throw new IOException("解压归档文件出现异常", ex);
        } finally {
            try {
                if (tarIn != null) {
                    tarIn.close();
                }
            } catch (IOException ex) {
                throw new IOException("关闭tarFile出现异常", ex);
            }
        }
    }

    /**
     * 将上传的文件进行重命名
     * 
     * @param name
     *            文件名
     * @return String
     * @author Wanghao
     */
    private static String rename(String name) {

        Long now = Long.parseLong(new SimpleDateFormat("yyyyMMddHHmmss").format(new Date()));
        Long random = (long) (Math.random() * now);
        String fileName = now + "" + random;
        if (name.lastIndexOf(".") != -1 && ".gz".equals(name.substring(name.lastIndexOf(".")))) {
            fileName += ".tar.gz";
        } else {
            if (name.indexOf(".") != -1) {
                fileName += name.substring(name.lastIndexOf("."));
            }
        }
        return fileName;
    }

    /**
     * 压缩后的文件名
     * 
     * @param name
     *            文件名
     * @return String
     * @author Wanghao
     */
    private static String zipName(String name) {
        String prefix = "";
        if (name.indexOf(".") != -1) {
            prefix = name.substring(0, name.lastIndexOf("."));
        } else {
            prefix = name;
        }
        return prefix + ".zip";
    }

    /**
     * 构建目录
     * 
     * @param outputDir
     *            输出目录路径
     * @param subDir
     *            子目录路径
     * @author Wanghao
     */
    private static void createDirectory(String outputDir, String subDir) {
        File file = new File(outputDir);
        if (!(subDir == null || subDir.trim().equals(""))) {// 子目录不为空
            file = new File(outputDir + File.separator + subDir);
        }
        if (!file.exists()) {
            if (!file.getParentFile().exists())
                file.getParentFile().mkdirs();
            file.mkdirs();
        }
    }
     private final static ForkJoinPool forkJoinPool = new ForkJoinPool();
     /**
      * 获取文件夹大小
     * @ClassName: FileSizeFinder
     * @author Wanghao
     * @date 2017年6月26日 下午3:23:22
      */
     private static class FileSizeFinder extends RecursiveTask<Long> {
         /**
          * 序列化
          */
         private static final long serialVersionUID = 1L;
         final File file;
         /**
          * 获取文件夹大小
          * @param theFile 目录文件
          */
         public FileSizeFinder(final File theFile) {
             file = theFile;
         }

         @Override
         public Long compute() {
             long size = 0;
             if (file.isFile()) {
                 size = file.length();
             } else {
                 final File[] children = file.listFiles();
                 if (children != null) {
                     List<ForkJoinTask<Long>> tasks = new ArrayList<ForkJoinTask<Long>>();
                     for (final File child : children) {
                         if (child.isFile()) {
                             size += child.length();
                         } else {
                             tasks.add(new FileSizeFinder(child));
                         }
                     }
                     for (final ForkJoinTask<Long> task : invokeAll(tasks)) {
                         size += task.join();
                     }
                 }
             }
             return size;
         }
     }

    /**
     * 删除文件
     * @param fileName 文件名
     * @param path 路径
     * @return
     */
    public static Boolean deleteFile(String path) {
        File file = new File(path);
        if (file.exists()){
            if (file.delete()){
                return true;
            }
        }
        return false;
    }
    /**
     * 删除服务器上解压文件夹
     * @param fileName
     * @param path
     * @return
     * @author wangdn
     */
    public static Boolean deleteFolder(String fileName,String path){
        //解析文件
        if (".zip".equals(fileName.substring(fileName.lastIndexOf(".")))){
            String newDicPath = path.substring(0, path.lastIndexOf("."));
            File file = new File(newDicPath);
            Boolean bd = deleteAllFilesOfDir(file);
            return bd;
        }else if (".gz".equals(fileName.substring(fileName.lastIndexOf(".")))){
            String newTarPath = path.substring(0,path.length()-7);
            File file = new File(newTarPath);
            Boolean bd = deleteAllFilesOfDir(file);
            return bd;
        }
        return false;

    }

    /**
     * 删除文件夹的办法
     * @param path 文件夹路径
     * @author wangdn
     */
     public static Boolean deleteAllFilesOfDir(File path) {
        if (!path.exists())  
            return false;  
        if (path.isFile()) {  

            if (path.delete()){
                return true;
            }
            return false;  
        }  
        File[] files = path.listFiles();  
        for (int i = 0; i < files.length; i++) {  
            deleteAllFilesOfDir(files[i]);  
        }  
        if (path.delete()){
            return true;
        }else{
            return false;
        }
    }  
}


package cn.easted.edm.core.utils;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.io.input.BOMInputStream;

/**
 * 读取ini文件工具类
 * @ClassName: IniFileReadUtil
 * @author Wanghao
 * @date 2017年6月22日 下午5:55:06
 */
public class IniFileReadUtil {
    /** 
     * 读取 INI 文件，存放到Map中 
     *  
     * 支持以‘#’或‘;’开头的注释； 
     * 支持行连接符（行末的'\'标记）； 
     * 支持缺省的global properties； 
     * 支持list格式（非name=value格式处理为list格式）； 
     * 支持空行、name/value前后的空格； 
     * 如果有重名，取最后一个； 
     * 格式（例子）如下 
     * # 我是注释 
     * ; 我也是注释 
     *  
     * name0=value0  # 我是global properties 
     * name10=value10 
     *  
     * [normal section] # 我是普通的section 
     * name1=value1 # 我是name和value 
     * [list section] # 我是只有value的section，以第一个是否包含'='为判断标准 
     * value1 
     * value2 
     *  
     * @param fileName 文件名
     * @return Map<sectionName, object> object是一个Map（存放name=value对）或List（存放只有value的properties） 
     */  
    public static Map<String, Object> readIniFile(String fileName){  
        Map<String, List<String>> listResult = new HashMap<>();  
        Map<String, Object> result = new HashMap<>();  

        String globalSection = "global"; //Map中存储的global properties的key  

        File file = new File(fileName);  
        BufferedReader reader = null;  
        try {  
            //使用BOMInputStream自动去除UTF-8中的BOM
            reader = new BufferedReader(new InputStreamReader(new BOMInputStream(new FileInputStream(file)), "UTF-8"));  
            String str = null;  
            String currentSection = globalSection; //处理缺省的section  
            List<String> currentProperties = new ArrayList<>();  
            boolean lineContinued = false;  
            String tempStr = null;  
            //一次读入一行（非空），直到读入null为文件结束 ,先全部放到listResult<String, List>中  
            while ((str = reader.readLine()) != null) {  
                str = removeIniComments(str).trim(); //去掉尾部的注释、去掉首尾空格  
                if ("".equals(str) || str == null){  
                    continue;  
                }  
                //如果前一行包括了连接符'\'  
                if (lineContinued == true){  
                    str = tempStr + str;  
                }  
                //处理行连接符'\'  
                if (str.endsWith("\\")){  
                    lineContinued = true;  
                    tempStr = str.substring(0,str.length() - 1);  
                    continue;  
                }else {  
                    lineContinued = false;  
                }  
                //是否一个新section开始了  
                if (str.startsWith("[") && str.endsWith("]")){  
                    String newSection = str.substring(1, str.length() - 1).trim();  
                    //如果新section不是现在的section，则把当前section存进listResult中  
                    if (!currentSection.equals(newSection)){  
                        listResult.put(currentSection, currentProperties);  
                        currentSection = newSection;  
                        //新section是否重复的section,如果是，则使用原来的list来存放properties,如果不是，则new一个List来存放properties  
                        currentProperties=listResult.get(currentSection);  
                        if (currentProperties==null){  
                            currentProperties = new ArrayList<>();  
                        }  
                    }  
                }else{  
                    currentProperties.add(str);  
                }  
            }  
            //把最后一个section存进listResult中  
            listResult.put(currentSection, currentProperties);  
            reader.close();  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
            if (reader != null) {  
                try {  
                    reader.close();  
                } catch (IOException e1) {  
                }  
            }  
        }  
        //整理拆开name=value对，并存放到MAP中：  
        //从listResult<String, List>中，看各个list中的元素是否包含等号“=”，如果包含，则拆开并放到Map中  
        //整理后，把结果放进result<String, Object>中  
        for(String key : listResult.keySet()){  
            List<String> tempList = listResult.get(key);  
            //空section不放到结果里面  
            if(tempList==null||tempList.size()==0){  
                continue;  
            }  
            if(tempList.get(0).contains("=")){ //name=value对，存放在MAP里面  
                Map<String, String> properties = new HashMap<>();  
                for (String s : tempList){  
                    int delimiterPos = s.indexOf("=");  
                    //处理等号前后的空格  
                    properties.put(s.substring(0,delimiterPos).trim(), s.substring(delimiterPos+1, s.length()).trim());  
                }  
                result.put(key, properties);  
            }else{ //只有value，则获取原来的list  
                result.put(key, listResult.get(key));  
            }  
        }  
        return result;  
    }  

    /** 
     * 去除ini文件中的注释，以";"或"#"开头，顺便去除UTF-8等文件的BOM头 
     * @param source 
     * @return 
     */  
    private static String removeIniComments(String source){  
        String result = source;  

        if(result.contains(";")){  
            result = result.substring(0, result.indexOf(";"));  
        }  

        if(result.contains("#")){  
            result = result.substring(0, result.indexOf("#"));  
        }  
        return result.trim();  
    }  
}