package com.lapel.activity.html;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

/**
 * 
 * @author ding 解压本地压缩文件
 * 
 */
public class UnZipLocal {
	/**
	 * 
	 * @param zipFileName
	 *            压缩文件所在  路径+文件名+后缀
	 * @param outputDirectory
	 *            解压之后路径
	 * @throws IOException
	 */
	@SuppressWarnings("unchecked")
	public static void unzip(String zipFileName, String outputDirectory) throws IOException {
		ZipFile zipFile = null;
		try {
			zipFile = new ZipFile(zipFileName);
			Enumeration e = zipFile.entries();
			ZipEntry zipEntry = null;
			File dest = new File(outputDirectory);
			dest.mkdirs();
			while (e.hasMoreElements()) {
				zipEntry = (ZipEntry) e.nextElement();
				String entryName = zipEntry.getName();
				InputStream in = null;
				FileOutputStream out = null;
				try {
					if (zipEntry.isDirectory()) {
						String name = zipEntry.getName();
						name = name.substring(0, name.length() - 1);
						File f = new File(outputDirectory + File.separator + name);
						f.mkdirs();
					} else {
						int index = entryName.lastIndexOf("\\");
						if (index != -1) {
							File df = new File(outputDirectory + File.separator + entryName.substring(0, index));
							df.mkdirs();
						}
						index = entryName.lastIndexOf("/");
						if (index != -1) {
							File df = new File(outputDirectory + File.separator + entryName.substring(0, index));
							df.mkdirs();
						}
						File f = new File(outputDirectory + File.separator + zipEntry.getName());
						// f.createNewFile();
						in = zipFile.getInputStream(zipEntry);
						out = new FileOutputStream(f);
						int c;
						byte[] by = new byte[1024];
						while ((c = in.read(by)) != -1) {
							out.write(by, 0, c);
						}
						out.flush();
					}
				} catch (IOException ex) {
					ex.printStackTrace();
					throw new IOException("解压失败：" + ex.toString());
				} finally {
					if (in != null) {
						try {
							in.close();
						} catch (IOException ex) {
						}
					}
					if (out != null) {
						try {
							out.close();
						} catch (IOException ex) {
						}
					}
				}
			}
		} catch (IOException ex) {
			ex.printStackTrace();
			throw new IOException("解压失败：" + ex.toString());
		} finally {
			if (zipFile != null) {
				try {
					zipFile.close();
				} catch (IOException ex) {
				}
			}
		}
	}

}

小程序对资源存储有限一般10M，不要超过限制

思路解析：将资源保存到本地，首先 需要获取到 本地路径 ，然后将文件下载（下载前需要判断文件是否更新，第一次和更新则需要下载，如果存在之前的资源则将其删除），解压（压缩包需要解压，解压完成将压缩包删除，非压缩包略过）， 保存到本地路径， （可以自行创建本地目录，把资源统一保存在改目录下），页面中使用本地路径中的资源。
小程序中获取用户本地路径 ： wx.env.USER_DATA_PATH      
let fm = wx.getFileSystemManager();    // 文件系统管理器
删除文件夹及文件下的文件使用 fm.rmdir()

下面为整个流程结构代码

一、判断资源是否更新
var isUpdate = '判断资源是否更新的字段';
 if (!isUpdate ) {  // 第一次进入程序
 		wx.setStorageSync('isUpdate', isUpdate );     //
      this.isFile()    //是否创建目录
    } else if (resourcesFileMd5 != newFileMd5) {  //资源更新了
     wx.setStorageSync('isUpdate', isUpdate );
      this.isFile()   
    }else{    // 没有更新，则还是用原来的路径
      var cachePath = '本地路径'
      this.setData({ cachePath: cachePath});
      return;
    }

二、创建本地保存资源的目录

本地目录有了之后，需要判断是否要重新下载资源
var savePath ='需要保存资源的本地目录'
isFile() {
    var that = this;
    fm.access({  //判断目录是否存在
      path: savePath,
      success: function (res) {  //存在
        //存在直接下载文件到该目录
        that.downloadFile()    
      },
      fail: function (err) { //不存在
        fm.mkdir({ //不存在就创建目录
          dirPath: savePath,
          recursive: true,
          success: function (res) {
            that.downloadFile()
          }
        });
      }
    });
  },

三、资源下载

下载前判断是否存在之前的资源，if 存在，则删除再下载
downloadFile() { //下载资源
    var that = this;
    let fileUrl = '下载资源的地址';
    wx.showLoading({
      title: '资源加载中...',
    })
    var unlinkUrl = '需要删除资源的路径'
    this.isUnlink(unlinkUrl);  //删除文件的方法

    wx.downloadFile({
      url: fileUrl,
      filePath: '下载后保存的地址',
      success: function (res) {
        // 压缩包需要解压，非则略过
        that.fileUnzip();  //解压
      },
      fail: function (err) {
        wx.hideLoading();
        wx.showToast({
          title: '下载失败，请稍后重新',
        })
      }
    });
  },

删除文件的方法
isUnlink(unlinkUrl) { //删除文件
    fm.access({  //判断目录是否存在
      path: unlinkUrl,
      success: function (res) {  //存在之前的资源删除重新下载
        fm.rmdir({  //删除目录       删除文件夹及文件下的文件使用rmdir，unlink不能实现改功能
          dirPath: unlinkUrl,
          recursive:true,
          success(res) {
            console.log('旧资源删除成功')
          },
          fail(res) { 
            console.log(res);
          }
        })
      }
    })
  },

四，解压完之后，将资源保存在本地

解压的方法，解压完之后将压缩包删除
  fileUnzip() {  //解压
    var that = this;
    fm.unzip({
      zipFilePath: '需要解压的文件路径',
      targetPath: cashPath,   //解压后保存的地址
      success(res) {
        wx.setStorageSync('cashPath', cashPath)
        that.setData({ cachePath: cashPath});
        
        //解压成功后将压缩包删除
        fm.unlink({
          filePath: orginCachePath + '/' + id +'resource.zip',
          success(res) {
          },
          fail(res) {
            wx.showToast({
              title: '解压失败，请稍后重新',
            })
          }
        })
      }
      complete() {
        wx.hideLoading();
      }
    })
  },

到此，资源下载，解压，保存在本地已经完成，如何使用本地路径下的文件呢？
eg:   cachePath 是你保存在本地的路径地址 ，FileName 改文件下的内容
<image class='bg-pic' mode="widthFix"  src='{{cachePath}}/{{FileName}}'></image>

至此ok

如有不对的地方，望各路大神指点，小女子在此谢过O(∩_∩)O

点击此处下载demo,看完整代码，(*^__^*) 嘻嘻……

 

 

1.下载文件

  /**
     * 下载zip文件
     *
     * @param url
     */
    private void downloadFile(final String url) {
        OkHttpClient.Builder builder = new OkHttpClient.Builder().connectTimeout(20, TimeUnit.SECONDS)
                .writeTimeout(5, TimeUnit.SECONDS)
                .readTimeout(5, TimeUnit.SECONDS);
        Request request = new Request.Builder().url(url).build();
        builder.build().newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                InputStream is = null;
                byte[] buf = new byte[4096];
                int len = 0;
                FileOutputStream fos = null;
                // 储存下载文件的目录
                String savePath = Tools.isExistDir_html(filePath);
                try {

                    is = response.body().byteStream();
                    long total = response.body().contentLength();
//                    File file = new File(savePath, getNameFromUrl(url));
                    File file = new File(savePath, getNameFromUrl(fileName));
                    fos = new FileOutputStream(file);
                    long sum = 0;
                    while ((len = is.read(buf)) != -1) {
                        fos.write(buf, 0, len);
                        sum += len;
                        int progress = (int) (sum * 1.0f / total * 100);
                        // 下载中

                    }
                    fos.flush();
                } catch (Exception e) {
                    //
                    e.printStackTrace();
                } finally {
                    try {
                        if (is != null)
                            is.close();
                    } catch (IOException e) {
                    }
                    try {
                        if (fos != null)
                            fos.close();
                    } catch (IOException e) {
                    }
                }
                // 下载完成,解压zip
                //下载完成，先删除过时数据，并解压最新的热更新数据（必须这样操作 不然会导致无法覆盖旧数据，导致数据更新失败）
                deleteOldData();
            }
        });
    }

  删除旧数据deleteOldData

   private void deleteOldData() {
        String dirPath = Constants.BLACKTECH_HOT_UPDATE_FILE_PATH;
        List<File> files = CommandUtils.getFilesInDirectory(dirPath);
        for (File file : files) {
            String fileName = file.getName();
            if (fileName.endsWith(Constants.UXUE_TEMP_FILE_SUFFIX)) {
//                String type = fileName.substring(0, fileName.indexOf("_"));
//                CommandUtils.deleteDirectory(dirPath + fileName);
                CommandUtils.deleteDirectory(dirPath);
                try {
                    ZipFileUtil.upZipFile(file, dirPath);
                    file.delete();
                } catch (Exception e) {
                    e.printStackTrace();
//                    Logcat.e("解压文件失败：" + file.getPath());
                }
            }
        }
    }

 /**
     * 获取目录中的所有一级文件（不包括目录和嵌套文件）
     *
     * @param sPath
     * @return
     */
    public static List<File> getFilesInDirectory(String sPath) {
        List<File> result = new ArrayList<>();
        // 如果sPath不以文件分隔符结尾，自动添加文件分隔符
        if (!sPath.endsWith(File.separator)) {
            sPath = sPath + File.separator;
        }
        File dirFile = new File(sPath);
        // 如果dir对应的文件不存在，或者不是一个目录，则退出
        if (!dirFile.exists() || !dirFile.isDirectory()) {
            return result;
        }
        File[] files = dirFile.listFiles();
        for (File file : files) {
            if (file.isFile()) {
                result.add(file);
            }
        }
        return result;
    }

 

/**
     * 删除目录（文件夹）以及目录下的文件
     *
     * @param sPath 被删除目录的文件路径
     * @return 目录删除成功返回true，否则返回false
     */
    public static boolean deleteDirectory(String sPath) {
        // 如果sPath不以文件分隔符结尾，自动添加文件分隔符
        if (!sPath.endsWith(File.separator)) {
            sPath = sPath + File.separator;
        }
        File dirFile = new File(sPath);
        // 如果dir对应的文件不存在，或者不是一个目录，则退出
        if (!dirFile.exists() || !dirFile.isDirectory()) {
            return false;
        }
        boolean flag = true;
        // 删除文件夹下的所有文件(包括子目录)
        File[] files = dirFile.listFiles();
        for (int i = 0; files != null && i < files.length; i++) {
            if (files[i].getName().equals("YJHtml.zip")){
                continue;
            }
            // 删除子文件
            if (files[i].isFile()) {
                flag = deleteFile(files[i].getAbsolutePath());
                if (!flag)
                    break;
            } // 删除子目录
            else {
                flag = deleteDirectory(files[i].getAbsolutePath());
                if (!flag)
                    break;
            }
        }
        if (!flag)
            return false;
        // 删除当前目录
        if (dirFile.delete()) {
            return true;
        } else {
            return false;
        }
    }


 /**
     * 删除单个文件
     *
     * @param sPath 被删除文件的文件名
     * @return 单个文件删除成功返回true，否则返回false
     */
    public static boolean deleteFile(String sPath) {
        boolean flag = false;
        File file = new File(sPath);
        // 路径为文件且不为空则进行删除
        if (file.isFile() && file.exists()) {
            file.delete();
            flag = true;
        }
        return flag;
    }

 

解压zip

 /**
     * 解压缩功能.
     * 将zipFile文件解压到folderPath目录下.
     *
     * @throws Exception
     */
    public static int upZipFile(File zipFile, String folderPath) throws Exception {
        try {
            ZipFile zfile = new ZipFile(zipFile);
            Enumeration zList = zfile.entries();
            ZipEntry ze = null;
            byte[] buf = new byte[1024];
            while (zList.hasMoreElements()) {
                ze = (ZipEntry) zList.nextElement();
                if (ze.isDirectory()) {
                    //Logcat.d("upZipFile", "ze.getName() = " + ze.getName());
                    String dirstr = folderPath + ze.getName();
                    //dirstr.trim();
                    dirstr = new String(dirstr.getBytes("8859_1"), "GB2312");
                    //Logcat.d("upZipFile", "str = " + dirstr);
                    File f = new File(dirstr);
                    f.mkdir();
                    continue;
                }
                //Logcat.d("upZipFile", "ze.getName() = " + ze.getName());
                OutputStream os = new BufferedOutputStream(new FileOutputStream(getRealFileName(folderPath, ze.getName())));
                InputStream is = new BufferedInputStream(zfile.getInputStream(ze));
                int readLen = 0;
                while ((readLen = is.read(buf, 0, 1024)) != -1) {
                    os.write(buf, 0, readLen);
                }
                is.close();
                os.close();
            }
            zfile.close();

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

        return 0;
    }

 

 

注意：解压时一定要先删除之前本地的文件里的数据，然后再进行解压，不然会导致无法覆盖的情况

 

有一个需求，HTTP获取到zip文件的byte数组，需要转为本地的zip或是解压zip文件。


1. 用到的class

import java.io.FileOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
import java.io.ByteArrayInputStream;


2 获取解压后的文件


private static void getTxtFile(byte[] data) throws Exception {
		ZipInputStream zipStream = new ZipInputStream(new ByteArrayInputStream(data));
		ZipEntry entry = null;
		while ((entry = zipStream.getNextEntry()) != null) {

			String entryName = entry.getName();

			FileOutputStream out = new FileOutputStream("/log/111/" + entryName);

			byte[] byteBuff = new byte[4096];
			int bytesRead = 0;
			while ((bytesRead = zipStream.read(byteBuff)) != -1) {
				out.write(byteBuff, 0, bytesRead);
			}

			out.close();
			zipStream.closeEntry();
		}
		zipStream.close();
}


3. 转存zip文件，（可修改zip内的文件名）


private static void getZipFile(byte[] data) throws Exception {
		String filename = "/log/111/111.zip";
		FileOutputStream fileOutputStream = new FileOutputStream(filename);
		ZipOutputStream zos = new ZipOutputStream(fileOutputStream);

		ZipInputStream zipStream = new ZipInputStream(new ByteArrayInputStream(data));
		ZipEntry entry;
		while ((entry = zipStream.getNextEntry()) != null) {
			ZipEntry entry1 = new ZipEntry(entry.getName());
			zos.putNextEntry(entry1);
			zipStream.closeEntry();
		}
		zos.write(data);
		zos.flush();
		zos.closeEntry();
		zos.close();
		zipStream.close();
}

或者简单粗暴的直接将其保存到本地文件
private static void getZipFile(byte[] data) throws Exception {
		String filename = "/log/111/111.zip";
		File targetFile = new File(filename);
		OutputStream outStream = new FileOutputStream(targetFile);
		outStream.write(data);
		outStream.flush();
		outStream.close();
}