FileUtile(文件操作工具包)

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.text.NumberFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Random;
import java.util.Set;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import org.apache.commons.io.FileUtils;
import org.springframework.web.multipart.MultipartFile;


/**
 * @ClassName: FileUtile
 * @Description: TODO(文件操作工具包)
 * 
 */
public class FileUtil {



    private static List list = new ArrayList(0);
    private static List listImages = null;
    private static List listVideos = null;
    private static List listVoices = null;
    private static List listFiles = null;
    private static List listBooks = null;
    private static SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMddHHmmssSS");
    private static Date currentTime = new Date();
    static {
        list = new ArrayList(0);
        String imageTypes = "gif,jpg,jpeg,png,bmp";
        String videosTypes = "swf,flv,mp4,wav,wma,wmv,mid,avi,mpg,asf,rm,rmvb";
        String voiceTypes = "mp3,aac,wav,wma,cda,flac,m4a,mid,mka,mp2,mpa,mpc,ape,ofr,ogg,ra,wv,tta,ac3,dts,m4r";
        String fileTypes = "doc,docx,xls,xlsx,ppt,htm,html,txt,zip,rar,gz,bz2";
        String bookTypes = "epub,xml,pdf";
        listBooks = Arrays.asList(bookTypes.split(","));
        listImages = Arrays.asList(imageTypes.split(","));
        listVideos = Arrays.asList(videosTypes.split(","));
        listVoices = Arrays.asList(voiceTypes.split(","));
        listFiles = Arrays.asList(fileTypes.split(","));
    }

    /**
     * 获取系统信息
     * 
     * @Title: getSystemInfo
     * @Description: TODO(这里用一句话描述这个方法的作用)
     * @return
     * @return String 返回类型
     */
    public static String getSystemInfo() {
        Properties props = System.getProperties(); // 获得系统属性集
        String osName = props.getProperty("os.name"); // 操作系统名称
        String osArch = props.getProperty("os.arch"); // 操作系统构架
        String osVersion = props.getProperty("os.version"); // 操作系统版本
        return osName + osArch + osVersion;
    }

    /**
     * 将map中的值存在属性文件中
     * 
     * @param map
     * @param outFile
     *            生成的目标属性文件
     */
    public static void storePropertiesToFile(Map map,
            File outFile) {
        try {
            if (!map.isEmpty()) {
                if (!outFile.exists()) { // 如果目标文件不存在则创建
                    outFile.getParentFile().mkdirs();
                    outFile.createNewFile();
                }
                // outFile.createNewFile();
                OutputStream out = new FileOutputStream(outFile);
                Properties properties = new Properties();
                Set keys = map.keySet();
                for (String key : keys) {
                    properties.setProperty(key, map.get(key).toString());
                }
                properties.store(out, "这是是提示");
                out.close();
                System.out.println("创建属性文件完成");
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取属性文件中制定的键值
     * 
     * @param key
     *            键名
     * @param filePath
     *            属性文件的路径
     * @return
     */
    public static Object getPropertyValueByKey(String key, String filePath) {
        Object value = null;
        try {
            InputStream in = new FileInputStream(filePath);
            Properties properties = new Properties();
            properties.load(in);
            value = properties.getProperty(key);
            in.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return value;
    }




    /**
     * 获取
     * 
     * @Title: getUrlCallBackInfo
     * @Description: TODO(这里用一句话描述这个方法的作用)
     * @param fileurl
     * @return
     */
    public static String getUrlCallBackInfo(String fileurl, String charset) {
        StringBuffer sb = new StringBuffer();
        try {
            URL url = new URL(fileurl);
            URLConnection conn = url.openConnection();
            conn.setDoOutput(true);
            InputStream bis = url.openStream();
            StringBuffer s = new StringBuffer();
            if (charset == null || "".equals(charset)) {
                charset = "utf-8";
            }
            String rLine = null;
            BufferedReader bReader = new BufferedReader(new InputStreamReader(
                    bis, charset));
            PrintWriter pw = null;

            FileOutputStream fo = new FileOutputStream("../index.html");
            OutputStreamWriter writer = new OutputStreamWriter(fo, "utf-8");
            pw = new PrintWriter(writer);
            while ((rLine = bReader.readLine()) != null) {
                String tmp_rLine = rLine;
                int str_len = tmp_rLine.length();
                if (str_len > 0) {
                    s.append(tmp_rLine);
                    pw.println(tmp_rLine);
                    pw.flush();
                }
                tmp_rLine = null;
            }
            bis.close();
            pw.close();
            return s.toString();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return sb.toString();
    }


    /**
     * 上传文件
     * 
     * @Title: uploadFile
     * @Description: TODO(这里用一句话描述这个方法的作用)
     * @param file
     * @param fileName
     * @return void 返回类型
     */
    public static void uploadFile(File file, String fileName) {
        try {
            if (!file.exists()) { // 如果文件的路径不存在就创建路径
                file.getParentFile().mkdirs();
            }
            InputStream bis = new FileInputStream(file);
            uploadFile(bis, fileName);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 上传文件
     * 
     * @Title: uploadFile
     * @Description: TODO(这里用一句话描述这个方法的作用)
     * @param in
     * @param fileName
     * @return void 返回类型
     */
    public static void uploadFile(InputStream in, String fileName) {
        if (in == null || fileName == null || fileName.equals("")) {
            return;
        }
        try {
            File uploadFile = new File(fileName);
            if (!uploadFile.exists()) { // 如果文件的路径不存在就创建路径
                uploadFile.getParentFile().mkdirs();
            }
            OutputStream out = new FileOutputStream(fileName);
            byte[] buffer = new byte[2048];
            int temp = 0;
            while ((temp = in.read(buffer)) != -1) {
                out.write(buffer, 0, temp);
            }
            in.close();
            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    /*
     * 获得指定长度的随机数
     */
    public static String getRandomString(int length) {
        String str = "abcdef0123456789";
        Random random = new Random();
        StringBuffer sf = new StringBuffer();
        for (int i = 0; i < length; i++) {
            int number = random.nextInt(16);// 0~16
            sf.append(str.charAt(number));
        }
        return sf.toString();
    }

    /**
     * 将字符串输出到文件中
    * @Title: wireStringToFile 
    * @Description: TODO(这里用一句话描述这个方法的作用) 
    * @return void    返回类型 
     */
    public static String  wireStringToFile(String content,String filePath,String fileName){
        if(filePath==null || filePath.equals("")){
            return null;
        }
        BufferedWriter out=null;
        try {
            File uploadFile = new File(filePath);
            if (!uploadFile.exists()) { // 如果文件的路径不存在就创建路径
                uploadFile.mkdirs();
            }
            String file=filePath+ File.separator +fileName;
            out=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file),"utf-8"));
            out.write(content);
            out.flush();
            return file;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                if(out!=null){
                    out.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * 文件上传方法
     * 
     * @author peng
     * @param file
     *            上传的文件
     * @param uploadPath
     *            上传的文件路径
     * @param fileName
     *            双传的文件名称
     */
    public static void uploadFile(File file, String uploadPath, String fileName) {
        try {
            File uploadFile = new File(uploadPath);
            if (!uploadFile.exists()) { // 如果文件的路径不存在就创建路径
                uploadFile.mkdirs();
            }
            InputStream bis = new FileInputStream(file);
            uploadFile(bis, uploadPath + File.separator + fileName);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 
     * @param fileName
     *            文件的名称
     * @return 文件的后缀名(即格式名称)
     */
    public static String getSuffix(String fileName) {
        if (fileName == null || "".equals(fileName)) {
            return "";
        }
        if (fileName.contains(".")) {
            String[] temp = fileName.split("\\.");
            return temp[temp.length - 1];
        }
        return null;
    }
/*
    *//**
     * 将字符串保存到指定的文件中
     * 
     * @Title: createFile
     * @Description: TODO(这里用一句话描述这个方法的作用)
     * @param fileContent
     * @param fileName
     * @return void 返回类型
     */
    /*
    public static void createFile(String fileContent, String fileName) {
        try {
            File file = new File(fileName);
            if (!file.exists()) {
                file.getParentFile().mkdirs();
            }
            PrintWriter out = new PrintWriter(file, "UTF-8");
            out.write(fileContent);
            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
*/
    // 清空文件夹以及文件夹里面的所有文件
    public static void delFolder(String folderPath) {
        try {
            delAllFile(folderPath); // 删除完里面所有内容
            String filePath = folderPath;
            filePath = filePath.toString();
            java.io.File myFilePath = new java.io.File(filePath);
            myFilePath.delete(); // 删除空文件夹
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 删除指定文件夹下所有文件
    public static boolean delAllFile(String path) {
        boolean flag = false;
        File file = new File(path);
        if (!file.exists()) {
            return flag;
        }
        if (!file.isDirectory()) {
            return flag;
        }
        String[] tempList = file.list();
        File temp = null;
        for (int i = 0; i < tempList.length; i++) {
            if (path.endsWith(File.separator)) {
                temp = new File(path + tempList[i]);
            } else {
                temp = new File(path + File.separator + tempList[i]);
            }
            if (temp.isFile()) {
                temp.delete();
            }
            if (temp.isDirectory()) {
                delAllFile(path + "/" + tempList[i]);// 先删除文件夹里面的文件
                delFolder(path + "/" + tempList[i]);// 再删除空文件夹
                flag = true;
            }
        }
        return flag;
    }

    // 压缩文件或文件夹
    static byte[] buffer = new byte[204800];

    public static void zip(File[] files, String baseFolder, ZipOutputStream zos)
            throws Exception {
        FileInputStream fis = null;
        ZipEntry entry = null;
        int count = 0;
        for (File file : files) {
            if (file.isDirectory()) {
                zip(file.listFiles(), file.getName() + File.separator, zos);
                continue;
            }
            entry = new ZipEntry(baseFolder + file.getName());
            zos.putNextEntry(entry);
            fis = new FileInputStream(file);
            while ((count = fis.read(buffer, 0, buffer.length)) != -1)
                zos.write(buffer, 0, count);
        }
    }





    /**
     * 获取文件的名称
     * 
     * @Title: getFileName
     * @Description: TODO(这里用一句话描述这个方法的作用)
     * @return
     * @return String 返回类型
     */
    public static String getFileName() {
        SimpleDateFormat sdf = new SimpleDateFormat("hhmmssSSS");
        return sdf.format(new Date()) + getRandomString(4);
    }





    /**
     * 列出某个目录下的所有文件
     * 
     * @param sourceFile
     */
    public static void listAllFiles(File sourceFile) {
        try {
            if (sourceFile.isDirectory()) {
                for (File file : sourceFile.listFiles()) {
                    listAllFiles(file);
                }
            } else {
                list.add(sourceFile);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 获取文件大小
     * 
     * @Title: getFileSizes
     * @Description: TODO(这里用一句话描述这个方法的作用)
     * @param f
     * @return
     * @throws Exception
     * @return long 返回类型
     */
    public static long getFileSizes(File f) throws Exception {// 取得文件大小
        long s = 0;
        if (f.exists()) {
            FileInputStream fis = null;
            fis = new FileInputStream(f);
            s = fis.available();
        } else {
            f.createNewFile();
            System.out.println("文件不存在");
        }
        return s;
    }

    /**
     * 视频格式转换
     * 
     * @Title: getFileSizes
     * @Description: TODO(视频格式转换)
     * @param f
     * @return
     * @throws Exception
     * @return long 返回类型
     */
    public static int checkContentType(String type) {
        // ffmpeg能解析的格式：（asx，asf，mpg，wmv，3gp，mp4，mov，avi，flv等）
        if (type.equals("avi")) {
            return 0;
        } else if (type.equals("mpg")) {
            return 0;
        } else if (type.equals("wmv")) {
            return 0;
        } else if (type.equals("3gp")) {
            return 0;
        } else if (type.equals("mov")) {
            return 0;
        } else if (type.equals("asf")) {
            return 0;
        } else if (type.equals("mp4")) {
            return 0;
        } else if (type.equals("asx")) {
            return 0;
        } else if (type.equals("flv")) {
            return 2;
        }
        // 对ffmpeg无法解析的文件格式(wmv9，rm，rmvb等),
        // 可以先用别的工具（mencoder）转换为avi(ffmpeg能解析的)格式.
        else if (type.equals("wmv9")) {
            return 1;
        } else if (type.equals("rm")) {
            return 1;
        } else if (type.equals("rmvb")) {
            return 1;
        }
        return 9;
    }

    // ffmpeg能解析的格式：（asx，asf，mpg，wmv，3gp，mp4，mov，avi，flv等）
    public static boolean processFLV(String oldfilepath, String outPath,
            String ffmpegPath) {
        List commend = new java.util.ArrayList();
        commend.add(ffmpegPath);
        commend.add("-i");
        commend.add(oldfilepath);
        commend.add("-ab");
        commend.add("128");
        commend.add("-acodec");
        commend.add("libmp3lame");
        commend.add("-ac");
        commend.add("1");
        commend.add("-ar");
        commend.add("22050");
        commend.add("-qscale");
        commend.add("6");
        commend.add("-r");
        commend.add("29.97");
        commend.add("-b");
        commend.add("512");
        commend.add("-y");
        commend.add(outPath);

        try {
            ProcessBuilder builder = new ProcessBuilder();
            builder.command(commend);
            Process p = builder.start();
            ioWrite(p.getInputStream(), p.getErrorStream());
            p.waitFor();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    // 将rmvb转换成avi
    public static String processAVI(String path, String outPath,
            String mencoderPath) {
        List commend = new java.util.ArrayList();
        /*
         * commend.add("f:\\mencoder"); commend.add(PATH); commend.add("-oac");
         * commend.add("lavc"); commend.add("-lavcopts");
         * commend.add("acodec=mp3:abitrate=64"); commend.add("-ovc");
         * commend.add("xvid"); commend.add("-xvidencopts");
         * commend.add("bitrate=600"); commend.add("-of"); commend.add("avi");
         * commend.add("-o"); commend.add("f:\\rmvb.avi");
         */
        commend.add(mencoderPath);
        commend.add(path);
        commend.add("-oac");
        commend.add("mp3lame");
        commend.add("-lameopts");
        commend.add("preset=64");
        commend.add("-ovc");
        commend.add("xvid");
        commend.add("-xvidencopts");
        commend.add("bitrate=600");
        commend.add("-of");
        commend.add("avi");
        commend.add("-o");
        commend.add(outPath);
        // 命令类型：mencoder 1.rmvb -oac mp3lame -lameopts preset=64 -ovc xvid
        // -xvidencopts bitrate=600 -of avi -o rmvb.avi
        try {
            ProcessBuilder builder = new ProcessBuilder();
            builder.command(commend);
            Process p = builder.start();
            ioWrite(p.getInputStream(), p.getErrorStream());
            // 等Mencoder进程转换结束，再调用ffmepg进程
            p.waitFor();
            return outPath;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void ioWrite(final InputStream is1, final InputStream is2) {
        new Thread() {
            public void run() {
                BufferedReader br = new BufferedReader(new InputStreamReader(
                        is1));
                try {
                    String lineB = null;
                    while ((lineB = br.readLine()) != null) {
                        if (lineB != null)
                            System.out.println(lineB);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    System.out.println("报错了！123");
                }
            }
        }.start();

        new Thread() {
            public void run() {
                BufferedReader br2 = new BufferedReader(new InputStreamReader(
                        is2));
                try {
                    String lineC = null;
                    while ((lineC = br2.readLine()) != null) {
                        if (lineC != null)
                            System.out.println(lineC);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                    System.out.println("报错了！456");
                }
            }
        }.start();
    }

    // 截图
    public static boolean screenshot(String Path, String outPicPath,
            String ffmpegPath) throws IOException {
        List commend = new ArrayList();
        commend.add(ffmpegPath);
        commend.add("-i");
        commend.add(Path);
        commend.add("-y");
        commend.add("-f");
        commend.add("image2");
        commend.add("-ss");
        commend.add("8");
        commend.add("-t");
        commend.add("0.001");
        commend.add("-s");
        commend.add("420x320");
        commend.add(outPicPath);
        ProcessBuilder builder = new ProcessBuilder(commend);
        builder.command(commend);
        builder.start();
        return true;
    }

    /**
     * 获取文件的大小
     * 
     * @Title: floatFormart
     * @Description: TODO(这里用一句话描述这个方法的作用)
     * @param f
     * @return
     * @throws NumberFormatException
     * @throws Exception
     * @return String 返回类型
     */
    public static String floatFormart(File f) {
        String str = "0K";
        try {
            NumberFormat numFormat = NumberFormat.getNumberInstance();
            numFormat.setMaximumFractionDigits(2);
            str = numFormat.format(Float.parseFloat(String.valueOf(FileUtil
                    .getFileSizes(f))) / 1024 / 1024) + "M";
        } catch (NumberFormatException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return str;
    }


    /**
     * 获取上传时文件夹名称
    * @Title: getFolderName 
    * @Description: TODO(这里用一句话描述这个方法的作用) 
    * @return
    * @return String    返回类型 
    * @date 2015-6-17 上午11:26:15
     */
    public static String getFolderName(){
        String folderName = formatter.format(currentTime).toString().substring(0,8);
        return folderName;
    }

    /**
     * 获取转码后文件名称（实体文件存储名称）
    * @Title: getNewFileName 
    * @Description: TODO(这里用一句话描述这个方法的作用) 
    * @return
    * @return String    返回类型 
     */
    public static String getNewFileName(){
        String newFileName = formatter.format(currentTime).toString().substring(8,formatter.format(currentTime).toString().length());
        return newFileName;
    }

     /**
      * 创建文件夹
     * @Title: createFile 
     * @Description: TODO(这里用一句话描述这个方法的作用) 
     * @param realpath   ip地址加端口号
     * @param resourcePath    对应资源所保存的文件夹结构
     * @param data  当前时间作为文件夹
     * @return
     * @return File    返回类型 
      */
    public static File createFile(String resourcePath, String data){
        String path = FileUtil.class.getProtectionDomain().getCodeSource().getLocation().getPath();
        int index=path.indexOf("WEB-INF");
        if(index>0){
            path=path.substring(0, index);
        }
        System.out.println("path"+path);
        File file=new File(path);
        String savepath = file.getAbsolutePath()+File.separator+resourcePath+File.separator+data;

        System.out.println("savepath"+savepath);
        File savedir=new File(savepath);
        if(!savedir.exists())
            savedir.mkdirs();
        return savedir;
   }


    /**
     * 获取项目根目录
    * @Title: getProjectPath 
    * @Description: TODO(这里用一句话描述这个方法的作用) 
    * @return
    * @return String    返回类型 
     */
    public static String getProjectPath(){
        String path = FileUtil.class.getProtectionDomain().getCodeSource().getLocation().getPath();
        int index=path.indexOf("WEB-INF");
        if(index>0){
            path=path.substring(0, index);
        }
        File file=new File(path);
        String savepath = file.getAbsolutePath()+File.separator;


        return savepath;
    }

    /**
     * 上传临时文件...
    * @Title: uploadTemp 
    * @Description:  
    * @param file
    * @return
    * @throws Exception
    * @return String    返回类型 
    * @date 2015-9-1 上午9:37:06
     */
    public static String uploadTemp(MultipartFile file,String userId) throws Exception{
            //文件全名
            String fileName = file.getOriginalFilename();
            String suffix = fileName.substring(fileName.lastIndexOf(".")+1).toLowerCase();
            String coverNewName = userId+"."+suffix;
            //文件保存路径 (使用随机名称: 项目名/WEB-INF/temp_file/随机数.jpg)
            File saveFile =new File(createFile("/resource/temp_file/"+userId,"").getPath()+"/"+coverNewName);
            //获取上传文件流
            InputStream in = file.getInputStream();

            //上传文件(复制)
            FileUtils.copyInputStreamToFile(in, saveFile);

            return coverNewName;

    }


    /**
     * 上传文件(Book)
    * @Title: uplodFile 
    * @Description: TODO(这里用一句话描述这个方法的作用) 
    * @param file
    * @return
    * @return String    返回类型 
    * @date 2015-7-1 上午11:43:16
     */
    public static String uplodFile(MultipartFile file){

        //文件输入流
        InputStream in = null;
        //创建一个文件保存路径
        File filePath = null;
        //原文件全名
        String fileName = null;
        //文件名
        String fName = null;
        //保存文件对象
        File saveFile= null;
            try {
                //文件全名
                fileName = file.getOriginalFilename();
                //文件名
                fName = fileName.substring(0,fileName.lastIndexOf("."));

                //文件后缀名,没有 '.'
                String suffix = fileName.substring(fileName.lastIndexOf(".")+1).toLowerCase();

                //图片资源保存路径
                if(listImages.contains(suffix)){
                    filePath = createFile("pic",getFolderName());
                }
                if(filePath == null){
                    return "errorType";
                }
                //创建要保存的文件的对象                                                            
                saveFile= new File(filePath.getPath()+File.separator+getFileName()+"."+suffix);
                //获取上传文件流
                in = file.getInputStream();

                //上传文件(复制)
                FileUtils.copyInputStreamToFile(in, saveFile);


            } catch (Exception  e1) {
                System.out.println("上传失败!");
                e1.printStackTrace();
                try {
                    in.close();
                } catch (IOException e2) {
                    e2.printStackTrace();
                }
                return "fail";

            }
        String relaPath = saveFile.getPath().replaceAll("\\\\", "/");

        return relaPath;
    }

    /**
     * 根据绝对磁盘路径获取相对路径
    * @Title: getRelativePath 
    * @Description: TODO(这里用一句话描述这个方法的作用) 
    * @param realPath
    * @return
    * @return String    返回类型 
    * @date 2015-7-16 下午5:14:45
     */
    public static String getRelativePath(String realPath){
        String relativePath = realPath;
        if(!realPath.equals("fail") && !realPath.equals("errorType")){
            relativePath= "/"+realPath.substring(realPath.indexOf("image"));
        }
        return relativePath;
    }


    /**
     * 上传头像
    * @Title: uploadHeadPortrait 
    * @Description: TODO(这里用一句话描述这个方法的作用) 
    * @param file
    * @return
    * @return String    返回类型 
     */
    public static String uploadHeadPortrait(MultipartFile file){

        //文件输入流
        InputStream in = null;
        //创建一个文件保存路径
        File filePath = null;
        //原文件全名
        String fileName = null;
        //文件名
        String fName = null;
        //保存文件对象
        File saveFile= null;
            try {
                //文件全名
                fileName = file.getOriginalFilename();
                //文件名
                fName = fileName.substring(0,fileName.lastIndexOf("."));

                //文件后缀名,没有 '.'
                String suffix = fileName.substring(fileName.lastIndexOf(".")+1).toLowerCase();
                //图片资源保存路径
                filePath = FileUtil.createFile("image",getFolderName());
                if(filePath == null){
                    return "errorType";
                }
                long filerandomname=System.currentTimeMillis();
                //创建要保存的文件的对象                                                            
                saveFile= new File(filePath.getPath()+File.separator+filerandomname+"."+suffix);
                //获取上传文件流
                in = file.getInputStream();
                //上传文件(复制)
                FileUtils.copyInputStreamToFile(in, saveFile);

            } catch (Exception  e1) {
                System.out.println("上传失败!");
                e1.printStackTrace();
                try {
                    in.close();
                } catch (IOException e2) {
                    e2.printStackTrace();
                }
                return "fail";

            }
        String relaPath = saveFile.getPath().replaceAll("\\\\", "/");

        return relaPath;
    }






    /**
     * 获取文件前6位16进制，用于过滤
    * @Title: bytesToHexString 
    * @Description: TODO(这里用一句话描述这个方法的作用) 
    * @param file
    * @return
    * @return String    返回类型 
    * @date 2015-9-21 上午11:20:40
     */
    public static String bytesToHexString(File file) {  
        StringBuilder stringBuilder = new StringBuilder();  
        byte[] bt;
        try {
            InputStream is = new FileInputStream(file);
            bt = new byte[3];  
            is.read(bt);
            if (bt == null || bt.length <= 0) {  
                return null;  
            }  
            for (int i = 0; i < bt.length; i++) {  
                int v = bt[i] & 0xFF;  
                String hv = Integer.toHexString(v);  
                if (hv.length() < 2) {  
                    stringBuilder.append(0);  
                }  
                stringBuilder.append(hv);  
            }  
        } catch (Exception e) {
            e.printStackTrace();
        } 

        return stringBuilder.toString();  
    } 



}

“`