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<File> list = new ArrayList<File>(0);
private static List<String> listImages = null;
private static List<String> listVideos = null;
private static List<String> listVoices = null;
private static List<String> listFiles = null;
private static List<String> listBooks = null;
private static SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMddHHmmssSS");
private static Date currentTime = new Date();
static {
        list = new ArrayList<File>(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<String, Object> 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<String> 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<String> commend = new java.util.ArrayList<String>();
        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<String> commend = new java.util.ArrayList<String>();
/*
 * 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<String> commend = new ArrayList<String>();
        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();  
    } 



}

“`