文件操作续——文件上传

原创 于 2008-03-18 09:47:00 发布 · 995 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#import #exception #file #string #null #buffer

最近在写一个导入上传系统，发现smartupload他只有上传一些小的文件，一但大的文件就反应很慢，上传速度也很慢，后来又在网上找了，commons-fileupload这个上传文件，看了不少人写的代码，那我总结了一下，试着写了一个，如哪里不好，请朋友们给我指出来。
代码如下：
Java代码 复制代码
  1. import java.io.File;   
  2. import java.util.ArrayList;   
  3. import java.util.Iterator;   
  4. import java.util.List;   
  5.   
  6. import javax.servlet.http.HttpServletRequest;   
  7.   
  8. import org.apache.commons.fileupload.DiskFileUpload;   
  9. import org.apache.commons.fileupload.FileItem;   
  10.   
  11. /**  
  12.  * commons-fileupload 文件上传，同时可以上传多个文件<br />  
  13.  * <li>使用：FileUpload.getInstance.getUploadFile(HttpServletRequest request);</li>  
  14.  *   
  15.  * @author HuangFeng  
  16.  *   
  17.  */  
  18. public class FileUpload {   
  19.   
  20.     private static FileUpload fileupload = null;   
  21.   
  22.     private FileUpload() {   
  23.     }   
  24.   
  25.     /**  
  26.      * 获得上传文件实例  
  27.      *   
  28.      * @return 实例  
  29.      */  
  30.     public static FileUpload getInstance() {   
  31.         if (null == fileupload) {   
  32.             return new FileUpload();   
  33.         } else {   
  34.             return fileupload;   
  35.         }   
  36.     }   
  37.   
  38.     /** 上传目录 */  
  39.     private String uploadDir = "/uploadMdb/file/";   
  40.   
  41.     /** 上传文件最大限制 */  
  42.     private long fileMaxSize = 100 * 1024 * 1024;   
  43.        
  44.     /** 文件磁盘存在真实目录 */  
  45.     private String fileRealPath = "";   
  46.        
  47.     /** 文件列表 */  
  48.     private List<String> fileList = new ArrayList<String>();   
  49.        
  50.     /**  
  51.      * 上传文件  
  52.      * @param request  
  53.      */  
  54.     public boolean getUploadFile(HttpServletRequest request) {   
  55.         try {   
  56.             DiskFileUpload fu = new DiskFileUpload();   
  57.                
  58.             // 设置允许用户上传文件大小,单位:字节   
  59.             fu.setSizeMax(fileMaxSize);   
  60.                
  61.             // 设置最多只允许在内存中存储的数据,单位:字节   
  62.             fu.setSizeThreshold(4096);   
  63.                
  64.             // 设置一旦文件大小超过getSizeThreshold()的值时数据存放在硬盘的目录   
  65.             fu.setRepositoryPath("/temp");   
  66.                
  67.             // 开始读取上传信息   
  68.             List fileItems = fu.parseRequest(request);   
  69.   
  70.             // 依次处理每个上传的文件   
  71.             Iterator iter = fileItems.iterator();   
  72.                
  73.             // 创建文件目录   
  74.             // 不管目录是否存在   
  75.             String filepath = request.getSession().getServletContext().getRealPath(uploadDir);   
  76.             FileUtil.getInstance().createFolder(filepath);   
  77.             fileRealPath = filepath;   
  78.             while (iter.hasNext()) {   
  79.                 FileItem item = (FileItem) iter.next();   
  80.                 // 忽略其他不是文件域的所有表单信息   
  81.                 if (!item.isFormField()) {   
  82.                     String name = item.getName();   
  83.                     long size = item.getSize();   
  84.                     if ((name == null || name.equals("")) && size == 0) {   
  85.                         continue;   
  86.                     }   
  87.                     // 注意item.getName()   
  88.                     // 会返回上载文件在客户端的完整路径名称，这似乎是一个BUG。   
  89.                     // 为解决这个问题，这里使用了fullFile.getName()。   
  90.                     name = name.replace('//', '/');   
  91.                     File fullFile = new File(name);   
  92.                     File savedFile = new File(filepath, fullFile.getName());   
  93.                     fileList.add(fullFile.getName());   
  94.                     item.write(savedFile);   
  95.                 }   
  96.             }   
  97.             return true;   
  98.         } catch (Exception e) {   
  99.             e.printStackTrace();   
  100.             return false;   
  101.         }   
  102.     }   
  103.   
  104.     public long getFileMaxSize() {   
  105.         return fileMaxSize;   
  106.     }   
  107.   
  108.     /** 上传文件最大限制 */  
  109.     public void setFileMaxSize(long fileMaxSize) {   
  110.         this.fileMaxSize = fileMaxSize;   
  111.     }   
  112.   
  113.     public String getUploadDir() {   
  114.         return uploadDir;   
  115.     }   
  116.   
  117.     /** 上传目录 */  
  118.     public void setUploadDir(String uploadDir) {   
  119.         this.uploadDir = uploadDir;   
  120.     }   
  121.        
  122.     /** 文件列表 */  
  123.     public List getFileList() {   
  124.         return fileList;   
  125.     }   
  126.   
  127.     /** 文件磁盘存在真实目录 */  
  128.     public String getFileRealPath() {   
  129.         return fileRealPath;   
  130.     }   
  131.   
  132. }  
import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.fileupload.DiskFileUpload;
import org.apache.commons.fileupload.FileItem;

/**
 * commons-fileupload 文件上传，同时可以上传多个文件<br />
 * <li>使用：FileUpload.getInstance.getUploadFile(HttpServletRequest request);</li>
 * 
 * @author HuangFeng
 * 
 */
public class FileUpload {

	private static FileUpload fileupload = null;

	private FileUpload() {
	}

	/**
	 * 获得上传文件实例
	 * 
	 * @return 实例
	 */
	public static FileUpload getInstance() {
		if (null == fileupload) {
			return new FileUpload();
		} else {
			return fileupload;
		}
	}

	/** 上传目录 */
	private String uploadDir = "/uploadMdb/file/";

	/** 上传文件最大限制 */
	private long fileMaxSize = 100 * 1024 * 1024;
	
	/** 文件磁盘存在真实目录 */
	private String fileRealPath = "";
	
	/** 文件列表 */
	private List<String> fileList = new ArrayList<String>();
	
	/**
	 * 上传文件
	 * @param request
	 */
	public boolean getUploadFile(HttpServletRequest request) {
		try {
			DiskFileUpload fu = new DiskFileUpload();
			
			// 设置允许用户上传文件大小,单位:字节
			fu.setSizeMax(fileMaxSize);
			
			// 设置最多只允许在内存中存储的数据,单位:字节
			fu.setSizeThreshold(4096);
			
			// 设置一旦文件大小超过getSizeThreshold()的值时数据存放在硬盘的目录
			fu.setRepositoryPath("/temp");
			
			// 开始读取上传信息
			List fileItems = fu.parseRequest(request);

			// 依次处理每个上传的文件
			Iterator iter = fileItems.iterator();
			
			// 创建文件目录
			// 不管目录是否存在
			String filepath = request.getSession().getServletContext().getRealPath(uploadDir);
			FileUtil.getInstance().createFolder(filepath);
			fileRealPath = filepath;
			while (iter.hasNext()) {
				FileItem item = (FileItem) iter.next();
				// 忽略其他不是文件域的所有表单信息
				if (!item.isFormField()) {
					String name = item.getName();
					long size = item.getSize();
					if ((name == null || name.equals("")) && size == 0) {
						continue;
					}
					// 注意item.getName()
					// 会返回上载文件在客户端的完整路径名称，这似乎是一个BUG。
					// 为解决这个问题，这里使用了fullFile.getName()。
					name = name.replace('//', '/');
					File fullFile = new File(name);
					File savedFile = new File(filepath, fullFile.getName());
					fileList.add(fullFile.getName());
					item.write(savedFile);
				}
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	public long getFileMaxSize() {
		return fileMaxSize;
	}

	/** 上传文件最大限制 */
	public void setFileMaxSize(long fileMaxSize) {
		this.fileMaxSize = fileMaxSize;
	}

	public String getUploadDir() {
		return uploadDir;
	}

	/** 上传目录 */
	public void setUploadDir(String uploadDir) {
		this.uploadDir = uploadDir;
	}
	
	/** 文件列表 */
	public List getFileList() {
		return fileList;
	}

	/** 文件磁盘存在真实目录 */
	public String getFileRealPath() {
		return fileRealPath;
	}

}


上传这后文件就需要解压，解压时老是报错，后来发现是中文问题，网上找了很多的解决方法，感觉还是有点麻烦，由于在赶进度就没有解决中文问题，但以后有空的话，我就会去研究一下，试着解决这个问题。
代码如下：
Java代码 复制代码
  1. import java.io.File;   
  2. import java.io.FileInputStream;   
  3. import java.io.FileNotFoundException;   
  4. import java.io.FileOutputStream;   
  5. import java.io.IOException;   
  6. import java.io.UnsupportedEncodingException;   
  7. import java.util.ArrayList;   
  8. import java.util.List;   
  9. import java.util.zip.ZipEntry;   
  10. import java.util.zip.ZipException;   
  11. import java.util.zip.ZipFile;   
  12. import java.util.zip.ZipInputStream;   
  13.   
  14. /**  
  15.  * File ：<b>解压zip文件操作类</b><br/> Time ：Oct 19, 2007 <br />  
  16.  * Note ：remark...<br />  
  17.  *   
  18.  * @author ：HuangFeng  
  19.  * @version ：1.0  
  20.  */  
  21. public class UnZipper {   
  22.     private static UnZipper unzipper = null;   
  23.        
  24.     private UnZipper() {}   
  25.        
  26.     /**  
  27.      * @return 解压zip文件操作类 实例  
  28.      */  
  29.     public static UnZipper getInstance() {   
  30.         if (null == unzipper) {   
  31.             return new UnZipper();   
  32.         } else {   
  33.             return unzipper;   
  34.         }   
  35.     }   
  36.        
  37.     /** 解压文件列表信息 */  
  38.     private List<String> msg = null;   
  39.        
  40.     /**  
  41.      * 创建字符内容8858-1到GB2312  
  42.      *   
  43.      * @param str  
  44.      *            内容  
  45.      * @return 创建后的内容  
  46.      */  
  47.     private String make8859toGB(String str) {   
  48.         try {   
  49.             String str8859 = new String(str.getBytes("ISO-8859-1"), "GB2312");   
  50.             return str8859;   
  51.         } catch (UnsupportedEncodingException ioe) {   
  52.             return str;   
  53.         }   
  54.     }   
  55.   
  56.     /**  
  57.      * 解压到当前文件夹  
  58.      *   
  59.      * @param fileName  
  60.      *            需要解压的zip文件  
  61.      * @return 解压后的文件个数  
  62.      */  
  63.     public int UnZip(String fileName) {   
  64.         File infile = new File(fileName);   
  65.         return UnZip(fileName, infile.getParent());   
  66.     }   
  67.   
  68.     /**  
  69.      * 解压到指定文件夹  
  70.      *   
  71.      * @param fileName  
  72.      *            需要解压的zip文件  
  73.      * @param outDir  
  74.      *            解压到的目录  
  75.      * @return 解压后的文件个数  
  76.      */  
  77.     public int UnZip(String fileName, String outDir) {   
  78.         File infile = new File(fileName);   
  79.         int num = 0;   
  80.         msg = new ArrayList<String>();   
  81.         try {   
  82.             if (!infile.exists()) {   
  83.                 throw new IOException(fileName + "文件不存在?");   
  84.             }   
  85.             // 检查是否是ZIP文件   
  86.             ZipFile zip = new ZipFile(infile);   
  87.             zip.close();   
  88.             // 建立与目标文件的输入连接   
  89.             ZipInputStream in = new ZipInputStream(new FileInputStream(infile));   
  90.             //如果压缩包里文件有中文名称文件名读取会报错   
  91.             ZipEntry file = in.getNextEntry();   
  92.             int i = infile.getAbsolutePath().lastIndexOf('.');   
  93.             String dirname = outDir;   
  94.             File newdir = new File(dirname);   
  95.             newdir.mkdir();   
  96.             byte[] c = new byte[1024];   
  97.             int slen;   
  98.             while (file != null) {   
  99.                 System.out.println(file.getName().replace('/', '//'));   
  100.                 msg.add(file.getName().replace('/', '//'));   
  101.                 i = make8859toGB(file.getName()).replace('/', '//').lastIndexOf('//');   
  102.                 if (i != -1) {   
  103.                     File dirs = new File(dirname + File.separator + make8859toGB(file.getName()).replace('/', '//').substring(0, i));   
  104.                     dirs.mkdirs();   
  105.                     dirs = null;   
  106.                 }   
  107.                 if (file.isDirectory()) {   
  108.                     File dirs = new File(dirname + File.separator + make8859toGB(file.getName()).replace('/', '//'));   
  109.                     dirs.mkdir();   
  110.                     dirs = null;   
  111.                 } else {   
  112.                     FileOutputStream out = new FileOutputStream(dirname + File.separator + make8859toGB(file.getName()).replace('/', '//'));   
  113.                     while ((slen = in.read(c, 0, c.length)) != -1) {   
  114.                         out.write(c, 0, slen);   
  115.                     }   
  116.                     out.close();   
  117.                 }   
  118.                 num++;   
  119.                 file = in.getNextEntry();   
  120.             }   
  121.             in.close();   
  122.         } catch (ZipException zipe) {   
  123.             zipe.printStackTrace();   
  124.             System.out.println(fileName + "不是一个ZIP文件！");   
  125.         } catch (IOException ioe) {   
  126.             ioe.printStackTrace();   
  127.             System.out.println("读取" + fileName + "时错误！");   
  128.         } catch (Exception i) {   
  129.             i.printStackTrace();   
  130.             new FileNotFoundException("拒绝访问：" + fileName );   
  131.         }   
  132.         return num;   
  133.     }   
  134.   
  135.     /** 解压文件下的列表信息 */  
  136.     public List getMsg() {   
  137.         return msg;   
  138.     }   
  139. }  
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;

/**
 * File ：<b>解压zip文件操作类</b><br/> Time ：Oct 19, 2007 <br />
 * Note ：remark...<br />
 * 
 * @author ：HuangFeng
 * @version ：1.0
 */
public class UnZipper {
	private static UnZipper unzipper = null;
	
	private UnZipper() {}
	
	/**
	 * @return 解压zip文件操作类 实例
	 */
	public static UnZipper getInstance() {
		if (null == unzipper) {
			return new UnZipper();
		} else {
			return unzipper;
		}
	}
	
	/** 解压文件列表信息 */
	private List<String> msg = null;
	
	/**
	 * 创建字符内容8858-1到GB2312
	 * 
	 * @param str
	 *            内容
	 * @return 创建后的内容
	 */
	private String make8859toGB(String str) {
		try {
			String str8859 = new String(str.getBytes("ISO-8859-1"), "GB2312");
			return str8859;
		} catch (UnsupportedEncodingException ioe) {
			return str;
		}
	}

	/**
	 * 解压到当前文件夹
	 * 
	 * @param fileName
	 *            需要解压的zip文件
	 * @return 解压后的文件个数
	 */
	public int UnZip(String fileName) {
		File infile = new File(fileName);
		return UnZip(fileName, infile.getParent());
	}

	/**
	 * 解压到指定文件夹
	 * 
	 * @param fileName
	 *            需要解压的zip文件
	 * @param outDir
	 *            解压到的目录
	 * @return 解压后的文件个数
	 */
	public int UnZip(String fileName, String outDir) {
		File infile = new File(fileName);
		int num = 0;
		msg = new ArrayList<String>();
		try {
			if (!infile.exists()) {
				throw new IOException(fileName + "文件不存在?");
			}
			// 检查是否是ZIP文件
			ZipFile zip = new ZipFile(infile);
			zip.close();
			// 建立与目标文件的输入连接
			ZipInputStream in = new ZipInputStream(new FileInputStream(infile));
			//如果压缩包里文件有中文名称文件名读取会报错
			ZipEntry file = in.getNextEntry();
			int i = infile.getAbsolutePath().lastIndexOf('.');
			String dirname = outDir;
			File newdir = new File(dirname);
			newdir.mkdir();
			byte[] c = new byte[1024];
			int slen;
			while (file != null) {
				System.out.println(file.getName().replace('/', '//'));
				msg.add(file.getName().replace('/', '//'));
				i = make8859toGB(file.getName()).replace('/', '//').lastIndexOf('//');
				if (i != -1) {
					File dirs = new File(dirname + File.separator + make8859toGB(file.getName()).replace('/', '//').substring(0, i));
					dirs.mkdirs();
					dirs = null;
				}
				if (file.isDirectory()) {
					File dirs = new File(dirname + File.separator + make8859toGB(file.getName()).replace('/', '//'));
					dirs.mkdir();
					dirs = null;
				} else {
					FileOutputStream out = new FileOutputStream(dirname + File.separator + make8859toGB(file.getName()).replace('/', '//'));
					while ((slen = in.read(c, 0, c.length)) != -1) {
						out.write(c, 0, slen);
					}
					out.close();
				}
				num++;
				file = in.getNextEntry();
			}
			in.close();
		} catch (ZipException zipe) {
			zipe.printStackTrace();
			System.out.println(fileName + "不是一个ZIP文件！");
		} catch (IOException ioe) {
			ioe.printStackTrace();
			System.out.println("读取" + fileName + "时错误！");
		} catch (Exception i) {
			i.printStackTrace();
			new FileNotFoundException("拒绝访问：" + fileName );
		}
		return num;
	}

	/** 解压文件下的列表信息 */
	public List getMsg() {
		return msg;
	}
}


解压后，要把解压的数据展现给B端看，并且分析解压的数据，进行业务处理，这里处理业务这一块就不贴出来了，但这些数据分析需要时时更新给B端，显示进度，唉，真烦啊，等数据分析完成并再把相应的文件进行拷贝，删除上传的压缩包等等。最后再给一个处理结果，其实在这里最难的还是处理进度的显示。唉，老要命啊！
下面是文件操作类，拷贝，删除等。
代码如下：
Java代码 复制代码
  1. import java.io.File;   
  2. import java.io.FileInputStream;   
  3. import java.io.FileNotFoundException;   
  4. import java.io.FileOutputStream;   
  5. import java.io.FileWriter;   
  6. import java.io.IOException;   
  7. import java.io.PrintWriter;   
  8.   
  9. /**  
  10.  * File ：<b>File.java</b><br/>   
  11.  * Time ：Oct 19, 2007 <br />  
  12.  * Note ：文件基本操作类.使用方法：FileUnit.getInstance().XX  
  13.  *      <li>1、创建文件目录</li>  
  14.  *      <li>2、创建相应文件</li>  
  15.  *      <li>3、删除目录和文件</li>  
  16.  *      <li>4、文件重命名</li>  
  17.  *      <li>5、将内容写入文件中</li>  
  18.  *   
  19.  * @author ：HuangFeng  
  20.  * @version ：1.0  
  21.  */  
  22. public class FileUtil {   
  23.        
  24.     private static FileUtil fileunit = null;   
  25.   
  26.     private FileUtil() {   
  27.   
  28.     }   
  29.   
  30.     /**  
  31.      * @return 文件基本操作类实例  
  32.      */  
  33.     public static FileUtil getInstance() {   
  34.         if (null == fileunit) {   
  35.             return new FileUtil();   
  36.         } else {   
  37.             return fileunit;   
  38.         }   
  39.     }   
  40.        
  41.     /**  
  42.      * 创建文件  
  43.      *   
  44.      * @param filepath 文件所在目录路径,比如:c:/test/test.txt  
  45.      * @return 操作  
  46.      */  
  47.     public boolean makeFile(String filepath) throws IOException {   
  48.         try {   
  49.             File file = new File(filepath);   
  50.             return file.createNewFile();   
  51.         } catch (Exception e) {   
  52.             e.printStackTrace();   
  53.             return false;   
  54.         }   
  55.     }   
  56.   
  57.   
  58.     /**  
  59.      * 创建目录  
  60.      *   
  61.      * @param folderPath:目录路径  
  62.      * @return 操作  
  63.      * @throws IOException 创建错误  
  64.      */  
  65.     public boolean createFolder(String folderPath) {   
  66.         try {   
  67.             File f = new File(folderPath);   
  68.             return f.mkdirs();   
  69.         } catch (Exception e) {   
  70.             e.printStackTrace();   
  71.             return false;   
  72.         }   
  73.     }   
  74.   
  75.     /**  
  76.      * 删除指定路径下的文件<br>  
  77.      * －　有时希望删除文件，比如：图片，文档等．使用方法：removeFile('test.jpg',true);　删除一个文件时flag为true <br>  
  78.      * －　有时希望删除某个目录下的所有文件，使用方法:removeFile('C://temp//',false); <br>  
  79.      * －　注意：如果在删除所有文件的同时也希望删除此目录的话，那么flag = true - removeFile('C://temp//',true);  
  80.      * @param fileUrl 文件或是目录  
  81.      * @param flag 是否删除本目录  
  82.      * @throws Exception 文件不存在．　或是　文件拒绝访问．  
  83.      */  
  84.     public void removeFile(String fileUrl , boolean flag) throws Exception {   
  85.         File file = new File(fileUrl);   
  86.         //文件或目录是否存在．   
  87.         if (!file.exists()) {   
  88.             throw new FileNotFoundException("指定目录不存在:" + file.getName());   
  89.         }   
  90.         // 保存中间结果   
  91.         boolean rslt = true;           
  92.         //先尝试直接删除，此文件或是目录   
  93.         //若是文件则直接删除，不能删除文件为拒绝访问．   
  94.         //若文件夹且非空。枚举、递归删除里面内容   
  95.         if (!(rslt = file.delete())) {   
  96.             File[] subs = file.listFiles();   
  97.             if (null == subs ) {   
  98.                 //有些系统文件无法删除，　也不是文件夹，所以获得文件列表是空的．   
  99.                 throw new Exception("文件拒绝访问:" + file.getName());   
  100.             }   
  101.             for (int i = 0; i <= subs.length - 1; i++) {   
  102.                 if (subs[i].isDirectory()){   
  103.                     //递归删除子文件夹内容   
  104.                     removeFile(subs[i].toString() , flag);   
  105.                 }   
  106.                 // 删除子文件夹本身   
  107.                 rslt = subs[i].delete();   
  108.             }   
  109.             //删除文件: flag = false　| flag = true 都可以   
  110.             //删除目录:    
  111.             //flag = false　则删除目录下所有的文件，不包括目录   
  112.             //flag = true　 则删除目录下所有的文件及目录本身   
  113.             if (flag) {   
  114.                 rslt = file.delete();   
  115.             }   
  116.         }   
  117.         if (!rslt) {   
  118.             throw new Exception("无法删除:" + file.getName());   
  119.         }   
  120.     }   
  121.   
  122.     /**拷贝文件<br >  
  123.      * 拷贝文件时只拷贝文件，而不会自动创建目录，文件目录一定要存在，  
  124.      * 否则　throws FileNotFoundException(); - 找不到文件目录．  
  125.      * @param copyPath 拷贝源文件的目录  
  126.      * @param copyToPath 需要拷贝到哪个目录  
  127.      * @return 拷贝是否成功  
  128.      * @throws FileNotFoundException   
  129.      */  
  130.     public boolean copyFile(String copyFile , String copyToFile) throws FileNotFoundException {   
  131.         try {   
  132.             //建立目标文件   
  133.             File file = new File(copyFile);   
  134.                
  135.             // 把文件读入   
  136.             FileInputStream fileIO = new FileInputStream(file);   
  137.                
  138.             /*  
  139.              * 建立一个文件的输出流 如果是linux系统请把Files后的"//"换成"/"  
  140.              */  
  141.             FileOutputStream fileOUT = new FileOutputStream(copyToFile);   
  142.             int bytesRead = 0;   
  143.             byte[] buffer = new byte[8192];   
  144.             while ((bytesRead = fileIO.read(buffer, 0, 8192)) != -1) {   
  145.                 // 将文件写入服务器   
  146.                 fileOUT.write(buffer, 0, bytesRead);   
  147.             }   
  148.             fileOUT.close();   
  149.             fileIO.close();   
  150.             return true;   
  151.         } catch (FileNotFoundException fe) {   
  152.             throw new FileNotFoundException (copyToFile + "此文件目录找不到!");   
  153.         } catch (Exception e) {   
  154.             e.printStackTrace();   
  155.             return false;   
  156.         }   
  157.     }   
  158.        
  159.     /**  
  160.      * 文件重命名<br/>  
  161.      * <li>需要重命名的文件路径filePath一定要存在，否则报FileNotFoundException找不到文件</li>  
  162.      * <li>新文件名，不能与同目录下的文件名同名，否则报Exception－文件已存在或文件拒绝访问。</li>  
  163.      * @param filePath 需要重命名的文件路径 － “C：/1.txt”  
  164.      * @param newName 新文件名  
  165.      * @return 操作是否成功  
  166.      */  
  167.     public boolean renameFile(String filePath, String newName) {   
  168.         try {   
  169.             File f = new File(filePath);   
  170.             //判断文件是否存在   
  171.             if (f.exists()) {   
  172.                 //获得目录   
  173.                 String fileParent = f.getParent();   
  174.                 //创建新文件名   
  175.                 File rf = new File(fileParent + "//" + newName);   
  176.                 if (f.renameTo(rf)) {   
  177.                     return true;   
  178.                 } else {   
  179.                     throw new Exception(rf + "文件已存在或文件拒绝访问。");   
  180.                 }   
  181.             } else {   
  182.                 throw new FileNotFoundException(filePath + "文件不存在。");   
  183.             }   
  184.         } catch (Exception e) {   
  185.             e.printStackTrace();   
  186.             return false;   
  187.         }   
  188.     }   
  189.   
  190.     /**  
  191.      * 将内容写入文件中  
  192.      *   
  193.      * @param filepath 文件所在物理路径  
  194.      * @param content 写入内容  
  195.      */  
  196.     public void WriteFile(String filepath, String content) {   
  197.         try {   
  198.             FileWriter filewriter = new FileWriter(filepath, true);   
  199.             PrintWriter printwriter = new PrintWriter(filewriter);   
  200.             printwriter.println(content);   
  201.             printwriter.flush();   
  202.             printwriter.close();   
  203.             filewriter.close();   
  204.         } catch (Exception e) {   
  205.             e.printStackTrace();   
  206.         }   
  207.     }   
  208.        
  209.     public static void main(String[] args) {   
  210.         FileUtil.getInstance().WriteFile("C://log.text", "我试试");   
  211.   
  212.     }   
  213. }  
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * File ：<b>File.java</b><br/> 
 * Time ：Oct 19, 2007 <br />
 * Note ：文件基本操作类.使用方法：FileUnit.getInstance().XX
 * 		<li>1、创建文件目录</li>
 *  	<li>2、创建相应文件</li>
 *  	<li>3、删除目录和文件</li>
 *   	<li>4、文件重命名</li>
 * 		<li>5、将内容写入文件中</li>
 * 
 * @author ：HuangFeng
 * @version ：1.0
 */
public class FileUtil {
	
	private static FileUtil fileunit = null;

	private FileUtil() {

	}

	/**
	 * @return 文件基本操作类实例
	 */
	public static FileUtil getInstance() {
		if (null == fileunit) {
			return new FileUtil();
		} else {
			return fileunit;
		}
	}
	
	/**
	 * 创建文件
	 * 
	 * @param filepath 文件所在目录路径,比如:c:/test/test.txt
	 * @return 操作
	 */
	public boolean makeFile(String filepath) throws IOException {
		try {
			File file = new File(filepath);
			return file.createNewFile();
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}


	/**
	 * 创建目录
	 * 
	 * @param folderPath:目录路径
	 * @return 操作
	 * @throws IOException 创建错误
	 */
	public boolean createFolder(String folderPath) {
		try {
			File f = new File(folderPath);
			return f.mkdirs();
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 删除指定路径下的文件<br>
	 * －　有时希望删除文件，比如：图片，文档等．使用方法：removeFile('test.jpg',true);　删除一个文件时flag为true <br>
	 * －　有时希望删除某个目录下的所有文件，使用方法:removeFile('C://temp//',false); <br>
	 * －　注意：如果在删除所有文件的同时也希望删除此目录的话，那么flag = true - removeFile('C://temp//',true);
	 * @param fileUrl 文件或是目录
	 * @param flag 是否删除本目录
	 * @throws Exception 文件不存在．　或是　文件拒绝访问．
	 */
	public void removeFile(String fileUrl , boolean flag) throws Exception {
		File file = new File(fileUrl);
		//文件或目录是否存在．
		if (!file.exists()) {
			throw new FileNotFoundException("指定目录不存在:" + file.getName());
		}
		// 保存中间结果
		boolean rslt = true;		
		//先尝试直接删除，此文件或是目录
		//若是文件则直接删除，不能删除文件为拒绝访问．
		//若文件夹且非空。枚举、递归删除里面内容
		if (!(rslt = file.delete())) {
			File[] subs = file.listFiles();
			if (null == subs ) {
				//有些系统文件无法删除，　也不是文件夹，所以获得文件列表是空的．
				throw new Exception("文件拒绝访问:" + file.getName());
			}
			for (int i = 0; i <= subs.length - 1; i++) {
				if (subs[i].isDirectory()){
					//递归删除子文件夹内容
					removeFile(subs[i].toString() , flag);
				}
				// 删除子文件夹本身
				rslt = subs[i].delete();
			}
			//删除文件: flag = false　| flag = true 都可以
			//删除目录: 
			//flag = false　则删除目录下所有的文件，不包括目录
			//flag = true　 则删除目录下所有的文件及目录本身
			if (flag) {
				rslt = file.delete();
			}
		}
		if (!rslt) {
			throw new Exception("无法删除:" + file.getName());
		}
	}

	/**拷贝文件<br >
	 * 拷贝文件时只拷贝文件，而不会自动创建目录，文件目录一定要存在，
	 * 否则　throws FileNotFoundException(); - 找不到文件目录．
	 * @param copyPath 拷贝源文件的目录
	 * @param copyToPath 需要拷贝到哪个目录
	 * @return 拷贝是否成功
	 * @throws FileNotFoundException 
	 */
	public boolean copyFile(String copyFile , String copyToFile) throws FileNotFoundException {
		try {
			//建立目标文件
			File file = new File(copyFile);
			
			// 把文件读入
			FileInputStream fileIO = new FileInputStream(file);
			
			/*
			 * 建立一个文件的输出流 如果是linux系统请把Files后的"//"换成"/"
			 */
			FileOutputStream fileOUT = new FileOutputStream(copyToFile);
			int bytesRead = 0;
			byte[] buffer = new byte[8192];
			while ((bytesRead = fileIO.read(buffer, 0, 8192)) != -1) {
				// 将文件写入服务器
				fileOUT.write(buffer, 0, bytesRead);
			}
			fileOUT.close();
			fileIO.close();
			return true;
		} catch (FileNotFoundException fe) {
			throw new FileNotFoundException (copyToFile + "此文件目录找不到!");
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}
	
	/**
	 * 文件重命名<br/>
	 * <li>需要重命名的文件路径filePath一定要存在，否则报FileNotFoundException找不到文件</li>
	 * <li>新文件名，不能与同目录下的文件名同名，否则报Exception－文件已存在或文件拒绝访问。</li>
	 * @param filePath 需要重命名的文件路径 － “C：/1.txt”
	 * @param newName 新文件名
	 * @return 操作是否成功
	 */
	public boolean renameFile(String filePath, String newName) {
		try {
			File f = new File(filePath);
			//判断文件是否存在
			if (f.exists()) {
				//获得目录
				String fileParent = f.getParent();
				//创建新文件名
				File rf = new File(fileParent + "//" + newName);
				if (f.renameTo(rf)) {
					return true;
				} else {
					throw new Exception(rf + "文件已存在或文件拒绝访问。");
				}
			} else {
				throw new FileNotFoundException(filePath + "文件不存在。");
			}
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将内容写入文件中
	 * 
	 * @param filepath 文件所在物理路径
	 * @param content 写入内容
	 */
	public void WriteFile(String filepath, String content) {
		try {
			FileWriter filewriter = new FileWriter(filepath, true);
			PrintWriter printwriter = new PrintWriter(filewriter);
			printwriter.println(content);
			printwriter.flush();
			printwriter.close();
			filewriter.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		FileUtil.getInstance().WriteFile("C://log.text", "我试试");

	}
}


好了任务完成。  
wang102010
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值