有一个好的工具，会让你的开发事半功倍。上传，可以说是下载的逆过程。
1 import java.io.File;
2 import java.io.IOException;
3 import java.text.SimpleDateFormat;
4 import java.util.ArrayList;
5 import java.util.Arrays;
6 import java.util.Date;
7 import java.util.HashMap;
8 import java.util.Iterator;
9 import java.util.List;
10 import java.util.Map;
11 import java.util.Random;
12
13 import javax.servlet.http.HttpServletRequest;
14
15 import org.apache.commons.fileupload.FileItem;
16 import org.apache.commons.fileupload.FileUploadException;
17 import org.apache.commons.fileupload.disk.DiskFileItemFactory;
18 import org.apache.commons.fileupload.servlet.ServletFileUpload;
19
20 /**
21 * 文件上传工具类
22 *
23 */
24 public class UploadUtils {
25 /**
26 * 表单字段常量
27 */
28 public static final String FORM_FIELDS = "form_fields";
29 /**
30 * 文件域常量
31 */
32 public static final String FILE_FIELDS = "file_fields";
33
34 // 最大文件大小
35 private long maxSize = 1000000;
36 // 定义允许上传的文件扩展名
37 private Map<String, String> extMap = new HashMap<String, String>();
38 // 文件保存目录相对路径
39 private String basePath = "upload";
40 // 文件的目录名
41 private String dirName = "images";
42 // 上传临时路径
43 private static final String TEMP_PATH = "/temp";
44 private String tempPath = basePath + TEMP_PATH;
45 // 若不指定则文件名默认为 yyyyMMddHHmmss_xyz
46 private String fileName;
47
48 // 文件保存目录路径
49 private String savePath;
50 // 文件保存目录url
51 private String saveUrl;
52 // 文件最终的url包括文件名
53 private String fileUrl;
54
55 public UploadUtils() {
56 // 其中images,flashs,medias,files,对应文件夹名称,对应dirName
57 // key文件夹名称
58 // value该文件夹内可以上传文件的后缀名
59 extMap.put("images", "gif,jpg,jpeg,png,bmp");
60 extMap.put("flashs", "swf,flv");
61 extMap.put("medias", "swf,flv,mp3,wav,wma,wmv,mid,avi,mpg,asf,rm,rmvb");
62 extMap.put("files", "doc,docx,xls,xlsx,ppt,htm,html,txt,zip,rar,gz,bz2");
63 }
64
65 /**
66 * 文件上传
67 *
68 * @param request
69 * @return infos info[0] 验证文件域返回错误信息 info[1] 上传文件错误信息 info[2] savePath info[3] saveUrl info[4] fileUrl
70 */
71 @SuppressWarnings("unchecked")
72 public String[] uploadFile(HttpServletRequest request) {
73 String[] infos = new String[5];
74 // 验证
75 infos[0] = this.validateFields(request);
76 // 初始化表单元素
77 Map<String, Object> fieldsMap = new HashMap<String, Object>();
78 if (infos[0].equals("true")) {
79 fieldsMap = this.initFields(request);
80 }
81 // 上传
82 List<FileItem> fiList = (List<FileItem>) fieldsMap.get(UploadUtils.FILE_FIELDS);
83 if (fiList != null) {
84 for (FileItem item : fiList) {
85 infos[1] = this.saveFile(item);
86 }
87 infos[2] = savePath;
88 infos[3] = saveUrl;
89 infos[4] = fileUrl;
90 }
91 return infos;
92 }
93
94 /**
95 * 上传验证,并初始化文件目录
96 *
97 * @param request
98 */
99 private String validateFields(HttpServletRequest request) {
100 String errorInfo = "true";
101 // boolean errorFlag = true;
102 // 获取内容类型
103 String contentType = request.getContentType();
104 int contentLength = request.getContentLength();
105 // 文件保存目录路径
106 savePath = request.getSession().getServletContext().getRealPath("/") + basePath + "/";
107 // 文件保存目录URL
108 saveUrl = request.getContextPath() + "/" + basePath + "/";
109 File uploadDir = new File(savePath);
110 if (contentType == null || !contentType.startsWith("multipart")) {
111 // TODO
112 System.out.println("请求不包含multipart/form-data流");
113 errorInfo = "请求不包含multipart/form-data流";
114 } else if (maxSize < contentLength) {
115 // TODO
116 System.out.println("上传文件大小超出文件最大大小");
117 errorInfo = "上传文件大小超出文件最大大小[" + maxSize + "]";
118 } else if (!ServletFileUpload.isMultipartContent(request)) {
119 // TODO
120 errorInfo = "请选择文件";
121 } else if (!uploadDir.isDirectory()) {// 检查目录
122 // TODO
123 errorInfo = "上传目录[" + savePath + "]不存在";
124 } else if (!uploadDir.canWrite()) {
125 // TODO
126 errorInfo = "上传目录[" + savePath + "]没有写权限";
127 } else if (!extMap.containsKey(dirName)) {
128 // TODO
129 errorInfo = "目录名不正确";
130 } else {
131 // .../basePath/dirName/
132 // 创建文件夹
133 savePath += dirName + "/";
134 saveUrl += dirName + "/";
135 File saveDirFile = new File(savePath);
136 if (!saveDirFile.exists()) {
137 saveDirFile.mkdirs();
138 }
139 // .../basePath/dirName/yyyyMMdd/
140 SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
141 String ymd = sdf.format(new Date());
142 savePath += ymd + "/";
143 saveUrl += ymd + "/";
144 File dirFile = new File(savePath);
145 if (!dirFile.exists()) {
146 dirFile.mkdirs();
147 }
148
149 // 获取上传临时路径
150 tempPath = request.getSession().getServletContext().getRealPath("/") + tempPath + "/";
151 File file = new File(tempPath);
152 if (!file.exists()) {
153 file.mkdirs();
154 }
155 }
156
157 return errorInfo;
158 }
159
160 /**
161 * 处理上传内容
162 *
163 * @param request
164 * @param maxSize
165 * @return
166 */
167 // @SuppressWarnings("unchecked")
168 private Map<String, Object> initFields(HttpServletRequest request) {
169
170 // 存储表单字段和非表单字段
171 Map<String, Object> map = new HashMap<String, Object>();
172
173 // 第一步：判断request
174 boolean isMultipart = ServletFileUpload.isMultipartContent(request);
175 // 第二步：解析request
176 if (isMultipart) {
177 // Create a factory for disk-based file items
178 DiskFileItemFactory factory = new DiskFileItemFactory();
179
180 // 阀值,超过这个值才会写到临时目录,否则在内存中
181 factory.setSizeThreshold(1024 * 1024 * 10);
182 factory.setRepository(new File(tempPath));
183
184 // Create a new file upload handler
185 ServletFileUpload upload = new ServletFileUpload(factory);
186
187 upload.setHeaderEncoding("UTF-8");
188
189 // 最大上传限制
190 upload.setSizeMax(maxSize);
191
192 /* FileItem */
193 List<FileItem> items = null;
194 // Parse the request
195 try {
196 items = upload.parseRequest(request);
197 } catch (FileUploadException e) {
198 // TODO Auto-generated catch block
199 e.printStackTrace();
200 }
201
202 // 第3步：处理uploaded items
203 if (items != null && items.size() > 0) {
204 Iterator<FileItem> iter = items.iterator();
205 // 文件域对象
206 List<FileItem> list = new ArrayList<FileItem>();
207 // 表单字段
208 Map<String, String> fields = new HashMap<String, String>();
209 while (iter.hasNext()) {
210 FileItem item = iter.next();
211 // 处理所有表单元素和文件域表单元素
212 if (item.isFormField()) { // 表单元素
213 String name = item.getFieldName();
214 String value = item.getString();
215 fields.put(name, value);
216 } else { // 文件域表单元素
217 list.add(item);
218 }
219 }
220 map.put(FORM_FIELDS, fields);
221 map.put(FILE_FIELDS, list);
222 }
223 }
224 return map;
225 }
226
227 /**
228 * 保存文件
229 *
230 * @param obj
231 * 要上传的文件域
232 * @param file
233 * @return
234 */
235 private String saveFile(FileItem item) {
236 String error = "true";
237 String fileName = item.getName();
238 String fileExt = fileName.substring(fileName.lastIndexOf(".") + 1).toLowerCase();
239
240 if (item.getSize() > maxSize) { // 检查文件大小
241 // TODO
242 error = "上传文件大小超过限制";
243 } else if (!Arrays.<String> asList(extMap.get(dirName).split(",")).contains(fileExt)) {// 检查扩展名
244 error = "上传文件扩展名是不允许的扩展名。
只允许" + extMap.get(dirName) + "格式。";
245 } else {
246 String newFileName;
247 if ("".equals(fileName.trim())) {
248 SimpleDateFormat df = new SimpleDateFormat("yyyyMMddHHmmss");
249 newFileName = df.format(new Date()) + "_" + new Random().nextInt(1000) + "." + fileExt;
250 } else {
251 newFileName = fileName + "." + fileExt;
252 }
253 // .../basePath/dirName/yyyyMMdd/yyyyMMddHHmmss_xxx.xxx
254 fileUrl = saveUrl + newFileName;
255 try {
256 File uploadedFile = new File(savePath, newFileName);
257
258 item.write(uploadedFile);
259
260 /*
261 * FileOutputStream fos = new FileOutputStream(uploadFile); // 文件全在内存中 if (item.isInMemory()) { fos.write(item.get()); } else { InputStream is = item.getInputStream(); byte[] buffer =
262 * new byte[1024]; int len; while ((len = is.read(buffer)) > 0) { fos.write(buffer, 0, len); } is.close(); } fos.close(); item.delete();
263 */
264 } catch (IOException e) {
265 e.printStackTrace();
266 System.out.println("上传失败了！！！");
267 } catch (Exception e) {
268 e.printStackTrace();
269 }
270 }
271 return error;
272 }
273
274 /** **********************get/set方法********************************* */
275
276 public String getSavePath() {
277 return savePath;
278 }
279
280 public String getSaveUrl() {
281 return saveUrl;
282 }
283
284 public long getMaxSize() {
285 return maxSize;
286 }
287
288 public void setMaxSize(long maxSize) {
289 this.maxSize = maxSize;
290 }
291
292 public Map<String, String> getExtMap() {
293 return extMap;
294 }
295
296 public void setExtMap(Map<String, String> extMap) {
297 this.extMap = extMap;
298 }
299
300 public String getBasePath() {
301 return basePath;
302 }
303
304 public void setBasePath(String basePath) {
305 this.basePath = basePath;
306 tempPath = basePath + TEMP_PATH;
307 }
308
309 public String getDirName() {
310 return dirName;
311 }
312
313 public void setDirName(String dirName) {
314 this.dirName = dirName;
315 }
316
317 public String getTempPath() {
318 return tempPath;
319 }
320
321 public void setTempPath(String tempPath) {
322 this.tempPath = tempPath;
323 }
324
325 public String getFileUrl() {
326 return fileUrl;
327 }
328
329 public String getFileName() {
330 return fileName;
331 }
332
333 public void setFileName(String fileName) {
334 this.fileName = fileName;
335 }
336
337 }
既然你要上传，那对文件的操作就不可避免了。
1 import java.io.File;
2 import java.io.FileInputStream;
3 import java.io.FileOutputStream;
4 import java.io.IOException;
5 import java.io.InputStream;
6 import java.io.OutputStream;
7 import java.util.Enumeration;
8
9 import org.apache.tools.zip.ZipEntry;
10 import org.apache.tools.zip.ZipFile;
11 import org.apache.tools.zip.ZipOutputStream;
12 import org.slf4j.Logger;
13 import org.slf4j.LoggerFactory;
14
15 /**
16 * 文件操作工具类
17 * 实现文件的创建、删除、复制、压缩、解压以及目录的创建、删除、复制、压缩解压等功能
18 */
19 public class FileUtils extends org.apache.commons.io.FileUtils {
20
21 private static Logger log = LoggerFactory.getLogger(FileUtils.class);
22
23 /**
24 * 复制单个文件，如果目标文件存在，则不覆盖
25 * @param srcFileName 待复制的文件名
26 * @param descFileName 目标文件名
27 * @return 如果复制成功，则返回true，否则返回false
28 */
29 public static boolean copyFile(String srcFileName, String descFileName) {
30 return FileUtils.copyFileCover(srcFileName, descFileName, false);
31 }
32
33 /**
34 * 复制单个文件
35 * @param srcFileName 待复制的文件名
36 * @param descFileName 目标文件名
37 * @param coverlay 如果目标文件已存在，是否覆盖
38 * @return 如果复制成功，则返回true，否则返回false
39 */
40 public static boolean copyFileCover(String srcFileName,
41 String descFileName, boolean coverlay) {
42 File srcFile = new File(srcFileName);
43 // 判断源文件是否存在
44 if (!srcFile.exists()) {
45 log.debug("复制文件失败，源文件 " + srcFileName + " 不存在!");
46 return false;
47 }
48 // 判断源文件是否是合法的文件
49 else if (!srcFile.isFile()) {
50 log.debug("复制文件失败，" + srcFileName + " 不是一个文件!");
51 return false;
52 }
53 File descFile = new File(descFileName);
54 // 判断目标文件是否存在
55 if (descFile.exists()) {
56 // 如果目标文件存在，并且允许覆盖
57 if (coverlay) {
58 log.debug("目标文件已存在，准备删除!");
59 if (!FileUtils.delFile(descFileName)) {
60 log.debug("删除目标文件 " + descFileName + " 失败!");
61 return false;
62 }
63 } else {
64 log.debug("复制文件失败，目标文件 " + descFileName + " 已存在!");
65 return false;
66 }
67 } else {
68 if (!descFile.getParentFile().exists()) {
69 // 如果目标文件所在的目录不存在，则创建目录
70 log.debug("目标文件所在的目录不存在，创建目录!");
71 // 创建目标文件所在的目录
72 if (!descFile.getParentFile().mkdirs()) {
73 log.debug("创建目标文件所在的目录失败!");
74 return false;
75 }
76 }
77 }
78
79 // 准备复制文件
80 // 读取的位数
81 int readByte = 0;
82 InputStream ins = null;
83 OutputStream outs = null;
84 try {
85 // 打开源文件
86 ins = new FileInputStream(srcFile);
87 // 打开目标文件的输出流
88 outs = new FileOutputStream(descFile);
89 byte[] buf = new byte[1024];
90 // 一次读取1024个字节，当readByte为-1时表示文件已经读取完毕
91 while ((readByte = ins.read(buf)) != -1) {
92 // 将读取的字节流写入到输出流
93 outs.write(buf, 0, readByte);
94 }
95 log.debug("复制单个文件 " + srcFileName + " 到" + descFileName
96 + "成功!");
97 return true;
98 } catch (Exception e) {
99 log.debug("复制文件失败：" + e.getMessage());
100 return false;
101 } finally {
102 // 关闭输入输出流，首先关闭输出流，然后再关闭输入流
103 if (outs != null) {
104 try {
105 outs.close();
106 } catch (IOException oute) {
107 oute.printStackTrace();
108 }
109 }
110 if (ins != null) {
111 try {
112 ins.close();
113 } catch (IOException ine) {
114 ine.printStackTrace();
115 }
116 }
117 }
118 }
119
120 /**
121 * 复制整个目录的内容，如果目标目录存在，则不覆盖
122 * @param srcDirName 源目录名
123 * @param descDirName 目标目录名
124 * @return 如果复制成功返回true，否则返回false
125 */
126 public static boolean copyDirectory(String srcDirName, String descDirName) {
127 return FileUtils.copyDirectoryCover(srcDirName, descDirName,
128 false);
129 }
130
131 /**
132 * 复制整个目录的内容
133 * @param srcDirName 源目录名
134 * @param descDirName 目标目录名
135 * @param coverlay 如果目标目录存在，是否覆盖
136 * @return 如果复制成功返回true，否则返回false
137 */
138 public static boolean copyDirectoryCover(String srcDirName,
139 String descDirName, boolean coverlay) {
140 File srcDir = new File(srcDirName);
141 // 判断源目录是否存在
142 if (!srcDir.exists()) {
143 log.debug("复制目录失败，源目录 " + srcDirName + " 不存在!");
144 return false;
145 }
146 // 判断源目录是否是目录
147 else if (!srcDir.isDirectory()) {
148 log.debug("复制目录失败，" + srcDirName + " 不是一个目录!");
149 return false;
150 }
151 // 如果目标文件夹名不以文件分隔符结尾，自动添加文件分隔符
152 String descDirNames = descDirName;
153 if (!descDirNames.endsWith(File.separator)) {
154 descDirNames = descDirNames + File.separator;
155 }
156 File descDir = new File(descDirNames);
157 // 如果目标文件夹存在
158 if (descDir.exists()) {
159 if (coverlay) {
160 // 允许覆盖目标目录
161 log.debug("目标目录已存在，准备删除!");
162 if (!FileUtils.delFile(descDirNames)) {
163 log.debug("删除目录 " + descDirNames + " 失败!");
164 return false;
165 }
166 } else {
167 log.debug("目标目录复制失败，目标目录 " + descDirNames + " 已存在!");
168 return false;
169 }
170 } else {
171 // 创建目标目录
172 log.debug("目标目录不存在，准备创建!");
173 if (!descDir.mkdirs()) {
174 log.debug("创建目标目录失败!");
175 return false;
176 }
177
178 }
179
180 boolean flag = true;
181 // 列出源目录下的所有文件名和子目录名
182 File[] files = srcDir.listFiles();
183 for (int i = 0; i < files.length; i++) {
184 // 如果是一个单个文件，则直接复制
185 if (files[i].isFile()) {
186 flag = FileUtils.copyFile(files[i].getAbsolutePath(),
187 descDirName + files[i].getName());
188 // 如果拷贝文件失败，则退出循环
189 if (!flag) {
190 break;
191 }
192 }
193 // 如果是子目录，则继续复制目录
194 if (files[i].isDirectory()) {
195 flag = FileUtils.copyDirectory(files[i]
196 .getAbsolutePath(), descDirName + files[i].getName());
197 // 如果拷贝目录失败，则退出循环
198 if (!flag) {
199 break;
200 }
201 }
202 }
203
204 if (!flag) {
205 log.debug("复制目录 " + srcDirName + " 到 " + descDirName + " 失败!");
206 return false;
207 }
208 log.debug("复制目录 " + srcDirName + " 到 " + descDirName + " 成功!");
209 return true;
210
211 }
212
213 /**
214 *
215 * 删除文件，可以删除单个文件或文件夹
216 *
217 * @param fileName 被删除的文件名
218 * @return 如果删除成功，则返回true，否是返回false
219 */
220 public static boolean delFile(String fileName) {
221 File file = new File(fileName);
222 if (!file.exists()) {
223 log.debug(fileName + " 文件不存在!");
224 return true;
225 } else {
226 if (file.isFile()) {
227 return FileUtils.deleteFile(fileName);
228 } else {
229 return FileUtils.deleteDirectory(fileName);
230 }
231 }
232 }
233
234 /**
235 *
236 * 删除单个文件
237 *
238 * @param fileName 被删除的文件名
239 * @return 如果删除成功，则返回true，否则返回false
240 */
241 public static boolean deleteFile(String fileName) {
242 File file = new File(fileName);
243 if (file.exists() && file.isFile()) {
244 if (file.delete()) {
245 log.debug("删除文件 " + fileName + " 成功!");
246 return true;
247 } else {
248 log.debug("删除文件 " + fileName + " 失败!");
249 return false;
250 }
251 } else {
252 log.debug(fileName + " 文件不存在!");
253 return true;
254 }
255 }
256
257 /**
258 *
259 * 删除目录及目录下的文件
260 *
261 * @param dirName 被删除的目录所在的文件路径
262 * @return 如果目录删除成功，则返回true，否则返回false
263 */
264 public static boolean deleteDirectory(String dirName) {
265 String dirNames = dirName;
266 if (!dirNames.endsWith(File.separator)) {
267 dirNames = dirNames + File.separator;
268 }
269 File dirFile = new File(dirNames);
270 if (!dirFile.exists() || !dirFile.isDirectory()) {
271 log.debug(dirNames + " 目录不存在!");
272 return true;
273 }
274 boolean flag = true;
275 // 列出全部文件及子目录
276 File[] files = dirFile.listFiles();
277 for (int i = 0; i < files.length; i++) {
278 // 删除子文件
279 if (files[i].isFile()) {
280 flag = FileUtils.deleteFile(files[i].getAbsolutePath());
281 // 如果删除文件失败，则退出循环
282 if (!flag) {
283 break;
284 }
285 }
286 // 删除子目录
287 else if (files[i].isDirectory()) {
288 flag = FileUtils.deleteDirectory(files[i]
289 .getAbsolutePath());
290 // 如果删除子目录失败，则退出循环
291 if (!flag) {
292 break;
293 }
294 }
295 }
296
297 if (!flag) {
298 log.debug("删除目录失败!");
299 return false;
300 }
301 // 删除当前目录
302 if (dirFile.delete()) {
303 log.debug("删除目录 " + dirName + " 成功!");
304 return true;
305 } else {
306 log.debug("删除目录 " + dirName + " 失败!");
307 return false;
308 }
309
310 }
311
312 /**
313 * 创建单个文件
314 * @param descFileName 文件名，包含路径
315 * @return 如果创建成功，则返回true，否则返回false
316 */
317 public static boolean createFile(String descFileName) {
318 File file = new File(descFileName);
319 if (file.exists()) {
320 log.debug("文件 " + descFileName + " 已存在!");
321 return false;
322 }
323 if (descFileName.endsWith(File.separator)) {
324 log.debug(descFileName + " 为目录，不能创建目录!");
325 return false;
326 }
327 if (!file.getParentFile().exists()) {
328 // 如果文件所在的目录不存在，则创建目录
329 if (!file.getParentFile().mkdirs()) {
330 log.debug("创建文件所在的目录失败!");
331 return false;
332 }
333 }
334
335 // 创建文件
336 try {
337 if (file.createNewFile()) {
338 log.debug(descFileName + " 文件创建成功!");
339 return true;
340 } else {
341 log.debug(descFileName + " 文件创建失败!");
342 return false;
343 }
344 } catch (Exception e) {
345 e.printStackTrace();
346 log.debug(descFileName + " 文件创建失败!");
347 return false;
348 }
349
350 }
351
352 /**
353 * 创建目录
354 * @param descDirName 目录名,包含路径
355 * @return 如果创建成功，则返回true，否则返回false
356 */
357 public static boolean createDirectory(String descDirName) {
358 String descDirNames = descDirName;
359 if (!descDirNames.endsWith(File.separator)) {
360 descDirNames = descDirNames + File.separator;
361 }
362 File descDir = new File(descDirNames);
363 if (descDir.exists()) {
364 log.debug("目录 " + descDirNames + " 已存在!");
365 return false;
366 }
367 // 创建目录
368 if (descDir.mkdirs()) {
369 log.debug("目录 " + descDirNames + " 创建成功!");
370 return true;
371 } else {
372 log.debug("目录 " + descDirNames + " 创建失败!");
373 return false;
374 }
375
376 }
377
378 /**
379 * 写入文件
380 * @param file 要写入的文件
381 */
382 public static void writeToFile(String fileName, String content, boolean append) {
383 try {
384 FileUtils.write(new File(fileName), content, "utf-8", append);
385 log.debug("文件 " + fileName + " 写入成功!");
386 } catch (IOException e) {
387 log.debug("文件 " + fileName + " 写入失败! " + e.getMessage());
388 }
389 }
390
391 /**
392 * 写入文件
393 * @param file 要写入的文件
394 */
395 public static void writeToFile(String fileName, String content, String encoding, boolean append) {
396 try {
397 FileUtils.write(new File(fileName), content, encoding, append);
398 log.debug("文件 " + fileName + " 写入成功!");
399 } catch (IOException e) {
400 log.debug("文件 " + fileName + " 写入失败! " + e.getMessage());
401 }
402 }
403
404 /**
405 * 压缩文件或目录
406 * @param srcDirName 压缩的根目录
407 * @param fileName 根目录下的待压缩的文件名或文件夹名，其中*或""表示跟目录下的全部文件
408 * @param descFileName 目标zip文件
409 */
410 public static void zipFiles(String srcDirName, String fileName,
411 String descFileName) {
412 // 判断目录是否存在
413 if (srcDirName == null) {
414 log.debug("文件压缩失败，目录 " + srcDirName + " 不存在!");
415 return;
416 }
417 File fileDir = new File(srcDirName);
418 if (!fileDir.exists() || !fileDir.isDirectory()) {
419 log.debug("文件压缩失败，目录 " + srcDirName + " 不存在!");
420 return;
421 }
422 String dirPath = fileDir.getAbsolutePath();
423 File descFile = new File(descFileName);
424 try {
425 ZipOutputStream zouts = new ZipOutputStream(new FileOutputStream(
426 descFile));
427 if ("*".equals(fileName) || "".equals(fileName)) {
428 FileUtils.zipDirectoryToZipFile(dirPath, fileDir, zouts);
429 } else {
430 File file = new File(fileDir, fileName);
431 if (file.isFile()) {
432 FileUtils.zipFilesToZipFile(dirPath, file, zouts);
433 } else {
434 FileUtils
435 .zipDirectoryToZipFile(dirPath, file, zouts);
436 }
437 }
438 zouts.close();
439 log.debug(descFileName + " 文件压缩成功!");
440 } catch (Exception e) {
441 log.debug("文件压缩失败：" + e.getMessage());
442 e.printStackTrace();
443 }
444
445 }
446
447 /**
448 * 解压缩ZIP文件，将ZIP文件里的内容解压到descFileName目录下
449 * @param zipFileName 需要解压的ZIP文件
450 * @param descFileName 目标文件
451 */
452 public static boolean unZipFiles(String zipFileName, String descFileName) {
453 String descFileNames = descFileName;
454 if (!descFileNames.endsWith(File.separator)) {
455 descFileNames = descFileNames + File.separator;
456 }
457 try {
458 // 根据ZIP文件创建ZipFile对象
459 ZipFile zipFile = new ZipFile(zipFileName);
460 ZipEntry entry = null;
461 String entryName = null;
462 String descFileDir = null;
463 byte[] buf = new byte[4096];
464 int readByte = 0;
465 // 获取ZIP文件里所有的entry
466 @SuppressWarnings("rawtypes")
467 Enumeration enums = zipFile.getEntries();
468 // 遍历所有entry
469 while (enums.hasMoreElements()) {
470 entry = (ZipEntry) enums.nextElement();
471 // 获得entry的名字
472 entryName = entry.getName();
473 descFileDir = descFileNames + entryName;
474 if (entry.isDirectory()) {
475 // 如果entry是一个目录，则创建目录
476 new File(descFileDir).mkdirs();
477 continue;
478 } else {
479 // 如果entry是一个文件，则创建父目录
480 new File(descFileDir).getParentFile().mkdirs();
481 }
482 File file = new File(descFileDir);
483 // 打开文件输出流
484 OutputStream os = new FileOutputStream(file);
485 // 从ZipFile对象中打开entry的输入流
486 InputStream is = zipFile.getInputStream(entry);
487 while ((readByte = is.read(buf)) != -1) {
488 os.write(buf, 0, readByte);
489 }
490 os.close();
491 is.close();
492 }
493 zipFile.close();
494 log.debug("文件解压成功!");
495 return true;
496 } catch (Exception e) {
497 log.debug("文件解压失败：" + e.getMessage());
498 return false;
499 }
500 }
501
502 /**
503 * 将目录压缩到ZIP输出流
504 * @param dirPath 目录路径
505 * @param fileDir 文件信息
506 * @param zouts 输出流
507 */
508 public static void zipDirectoryToZipFile(String dirPath, File fileDir,
509 ZipOutputStream zouts) {
510 if (fileDir.isDirectory()) {
511 File[] files = fileDir.listFiles();
512 // 空的文件夹
513 if (files.length == 0) {
514 // 目录信息
515 ZipEntry entry = new ZipEntry(getEntryName(dirPath, fileDir));
516 try {
517 zouts.putNextEntry(entry);
518 zouts.closeEntry();
519 } catch (Exception e) {
520 e.printStackTrace();
521 }
522 return;
523 }
524
525 for (int i = 0; i < files.length; i++) {
526 if (files[i].isFile()) {
527 // 如果是文件，则调用文件压缩方法
528 FileUtils
529 .zipFilesToZipFile(dirPath, files[i], zouts);
530 } else {
531 // 如果是目录，则递归调用
532 FileUtils.zipDirectoryToZipFile(dirPath, files[i],
533 zouts);
534 }
535 }
536
537 }
538
539 }
540
541 /**
542 * 将文件压缩到ZIP输出流
543 * @param dirPath 目录路径
544 * @param file 文件
545 * @param zouts 输出流
546 */
547 public static void zipFilesToZipFile(String dirPath, File file,
548 ZipOutputStream zouts) {
549 FileInputStream fin = null;
550 ZipEntry entry = null;
551 // 创建复制缓冲区
552 byte[] buf = new byte[4096];
553 int readByte = 0;
554 if (file.isFile()) {
555 try {
556 // 创建一个文件输入流
557 fin = new FileInputStream(file);
558 // 创建一个ZipEntry
559 entry = new ZipEntry(getEntryName(dirPath, file));
560 // 存储信息到压缩文件
561 zouts.putNextEntry(entry);
562 // 复制字节到压缩文件
563 while ((readByte = fin.read(buf)) != -1) {
564 zouts.write(buf, 0, readByte);
565 }
566 zouts.closeEntry();
567 fin.close();
568 System.out
569 .println("添加文件 " + file.getAbsolutePath() + " 到zip文件中!");
570 } catch (Exception e) {
571 e.printStackTrace();
572 }
573 }
574
575 }
576
577 /**
578 * 获取待压缩文件在ZIP文件中entry的名字，即相对于跟目录的相对路径名
579 * @param dirPat 目录名
580 * @param file entry文件名
581 * @return
582 */
583 private static String getEntryName(String dirPath, File file) {
584 String dirPaths = dirPath;
585 if (!dirPaths.endsWith(File.separator)) {
586 dirPaths = dirPaths + File.separator;
587 }
588 String filePath = file.getAbsolutePath();
589 // 对于目录，必须在entry名字后面加上"/"，表示它将以目录项存储
590 if (file.isDirectory()) {
591 filePath += "/";
592 }
593 int index = filePath.indexOf(dirPaths);
594
595 return filePath.substring(index + dirPaths.length());
596 }
597
598 /**
599 * 修复路径，将 \ 或 / 等替换为 File.separator
600 * @param path
601 * @return
602 */
603 public static String path(String path){
604 String p = StringUtils.replace(path, "\", "/");
605 p = StringUtils.join(StringUtils.split(p, "/"), "/");
606 if (!StringUtils.startsWithAny(p, "/") && StringUtils.startsWithAny(path, "\", "/")){
607 p += "/";
608 }
609 if (!StringUtils.endsWithAny(p, "/") && StringUtils.endsWithAny(path, "\", "/")){
610 p = p + "/";
611 }
612 return p;
613 }
614
615 }
转载请注明出处！
http://www.cnblogs.com/libingbin/
感谢您的阅读。如果文章对您有用，那么请轻轻点个赞，以资鼓励。