src/org/objectweb/cjdbc/common/util/ZipMe.java

説明を見る。

package org.objectweb.cjdbc.common.util;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.Deflater;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.InflaterInputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

import org.objectweb.cjdbc.common.i18n.Translate;
import org.objectweb.cjdbc.common.log.Trace;

public class ZipMe
{
  // Buffers and streams
  private FileOutputStream     fos                        = null;
  private ZipOutputStream      zos                        = null;
  private ZipInputStream       zis                        = null;
  private FileInputStream      fis                        = null;
  private BufferedOutputStream dest;
  private String               rootDir;
  private String               zipPath;
  private boolean              useCompression             = true;

  static final int             BUFFER                     = 2048;
  public static final String   ZIP_EXT                    = ".cjdbc";

  // Store policy
  static final int             STORE_FULL_PATH_IN_ZIP     = 0;
  static final int             STORE_NAME_ONLY_IN_ZIP     = 1;
  static final int             STORE_RELATIVE_PATH_IN_ZIP = 2;
  static final int             STORE_PATH_FROM_ZIP_ROOT   = 3;
  static final int             STORE_POLICY               = STORE_PATH_FROM_ZIP_ROOT;

  static Trace                 logger                     = Trace
                                                              .getLogger(ZipMe.class
                                                                  .getName());

  public ZipMe()
  {
  }

  public void create(String zipname, String rootdir) throws Exception
  {
    if (zipname == null || rootdir == null)
      throw new Exception("Invalid arguments to create zip file");
    this.rootDir = rootdir;
    try
    {
      zipPath = zipname + ZIP_EXT;
      fos = new FileOutputStream(zipPath);
      if (useCompression)
        zos = new ZipOutputStream(new DeflaterOutputStream(fos, new Deflater(
            Deflater.BEST_COMPRESSION)));
      else
        zos = new ZipOutputStream(fos);

      dirFunc(rootdir);

      zos.flush();
      zos.close();
      fos.close();
    }
    catch (IOException e)
    {
      logger.error(e.getMessage());
      throw e;
    }
  }

  public void create(String zipname, String rootdir, String putMeThere)
      throws Exception
  {
    create(putMeThere + File.separator + zipname, rootdir);
  }

  public void expand(String zipname, String targetdir, String getMeThere)
      throws Exception
  {
    expand(getMeThere + File.separator + zipname, targetdir);
  }

  public long getZipSize()
  {
    File f = new File(zipPath);
    if (f.exists())
      return f.length();
    else
      return -1;
  }

  public void expand(String zipname, String targetdir) throws Exception
  {
    File ftargetDir = new File(targetdir);
    if (!ftargetDir.exists())
      ftargetDir.mkdirs();
    if (!ftargetDir.exists())
      throw new Exception(Translate.get("zip.invalid.target.directory"));

    zipPath = zipname + ZIP_EXT;
    File fzipname = new File(zipPath);
    if (!fzipname.exists())
      throw new Exception(Translate.get("zip.invalid.source.file"));

    try
    {
      fis = new FileInputStream(fzipname);
      if (useCompression)
        zis = new ZipInputStream(new InflaterInputStream(fis));
      else
        zis = new ZipInputStream(new BufferedInputStream(fis));

      ZipEntry entry;

      byte data[] = new byte[BUFFER];
      while ((entry = zis.getNextEntry()) != null)
      {
        int count;
        String target = targetdir + File.separator + entry.getName();
        File fget = new File(target);
        fget.mkdirs(); // create needed new directories
        fget.delete(); // delete directory but not parents
        if (logger.isDebugEnabled())
          logger.debug(Translate.get("zip.extracting", new String[]{
              String.valueOf(entry), fget.getAbsolutePath()}));
        fos = new FileOutputStream(target);

        dest = new BufferedOutputStream(fos, BUFFER);
        while ((count = zis.read(data, 0, BUFFER)) != -1)
        {
          dest.write(data, 0, count);
        }
        dest.flush();
        dest.close();
      }
      zis.close();
    }
    catch (Exception e)
    {
      e.printStackTrace();
      logger.error(e.getMessage());
      throw e;
    }
  }

  private void dirFunc(String dirName) throws IOException
  {
    File dirObj = new File(dirName);
    if (dirObj.exists() == true)
    {
      if (dirObj.isDirectory() == true)
      {

        File[] fileList = dirObj.listFiles();

        for (int i = 0; i < fileList.length; i++)
        {
          if (fileList[i].isDirectory())
          {
            dirFunc(fileList[i].getPath());
          }
          else if (fileList[i].isFile())
          {

            zipFunc(fileList[i].getPath());
          }
        }
      }
      else
      {
        if (logger.isDebugEnabled())
          logger.debug(Translate.get("zip.not.directory", dirName));
      }
    }
    else
    {
      if (logger.isDebugEnabled())
        logger.debug(Translate.get("zip.directory.not.found", dirName));
    }
  }

  private void zipFunc(String filePath) throws IOException
  {
    File ffilePath = new File(filePath);
    String path = "";
    switch (STORE_POLICY)
    {
      case STORE_FULL_PATH_IN_ZIP :
        path = ffilePath.getAbsolutePath();
        break;
      case STORE_NAME_ONLY_IN_ZIP :
        ffilePath.getName();
        break;
      case STORE_RELATIVE_PATH_IN_ZIP :
        File f = new File("");
        String pathToHere = f.getAbsolutePath();
        path = ffilePath.getAbsolutePath();
        path = path.substring(path.indexOf(pathToHere + File.separator)
            + pathToHere.length());
        break;
      case STORE_PATH_FROM_ZIP_ROOT :
        path = ffilePath.getAbsolutePath();
        String tmpDir = File.separator + rootDir + File.separator;
        path = rootDir + File.separator
            + path.substring(path.indexOf(tmpDir) + tmpDir.length());
        logger.debug(path);
        break;
      default :
        break;
    }

    FileInputStream fis = new FileInputStream(filePath);
    BufferedInputStream bis = new BufferedInputStream(fis);

    ZipEntry fileEntry = new ZipEntry(path);
    zos.putNextEntry(fileEntry);

    byte[] data = new byte[1024];
    int byteCount;
    while ((byteCount = bis.read(data, 0, 1024)) > -1)
    {
      zos.write(data, 0, byteCount);
    }

    logger.debug(filePath);
  }

  public boolean getUseCompression()
  {
    return useCompression;
  }

  public void setUseCompression(boolean useCompression)
  {
    this.useCompression = useCompression;
  }
}

---