下面列出了java.util.logging.ErrorManager#java.util.zip.ZipOutputStream 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
/**
* 压缩一个文件
*/
public static void output1(String filepath, String zipfilepath) throws Exception {
// 1.使用 File 类绑定一个文件
// 定义要压缩的文件
File file = new File(filepath);
// 定义压缩文件名称
File zipFile = new File(zipfilepath);
// 2.把 File 对象绑定到流对象上
InputStream input = new FileInputStream(file);
ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(zipFile));
// 3.进行读或写操作
zipOut.putNextEntry(new ZipEntry(file.getName()));
zipOut.setComment("This is a zip file.");
int temp = 0;
while ((temp = input.read()) != -1) { // 读取内容
zipOut.write(temp); // 压缩输出
}
// 4.关闭流
input.close();
zipOut.close();
}
private static void addFileToZip(ZipOutputStream zos, File base, File file)
throws IOException {
byte[] buffer = new byte[1024];
try (FileInputStream fis = new FileInputStream(file)) {
String name = base.toURI().relativize(file.toURI()).getPath();
LOG.info("Adding file {} to zip", name);
zos.putNextEntry(new ZipEntry(name));
int length;
while ((length = fis.read(buffer)) > 0) {
zos.write(buffer, 0, length);
}
zos.flush();
} finally {
zos.closeEntry();
}
}
private boolean addUrlItemRecursively(ZipOutputStream zout, String root, String item, Predicate<? super String> filter) throws IOException {
InputStream itemFound = null;
try {
itemFound = resources.getResourceFromUrl(item);
} catch (Exception e) {
Exceptions.propagateIfFatal(e);
return false;
}
try {
// can't reliably tell if item a file or a folder (listing files), esp w classpath where folder is treated as a list of files,
// so if we can't tell try it as a list of files; not guaranteed, and empty dir and a file of size 0 will appear identical, but better than was
// (mainly used for tests)
if (isKnownNotToBeADirectoryListing(item) || !addUrlDirToZipRecursively(zout, root, item, itemFound, filter)) {
addUrlFileToZip(zout, root, item, filter);
}
return true;
} finally {
Streams.closeQuietly(itemFound);
}
}
/**
* Iterates the collection.getMembers() and streams content resources recursively to the ZipOutputStream
*
* @param rootId
* @param collection
* @param out
* @throws Exception
*/
private void storeContentCollection(String rootId, ContentCollection collection, ZipOutputStream out) throws Exception {
List<String> members = collection.getMembers();
if (members.isEmpty()) storeEmptyFolder(rootId,collection,out);
else {
for (String memberId: members) {
if (memberId.endsWith(Entity.SEPARATOR)) {
ContentCollection memberCollection = ContentHostingService.getCollection(memberId);
storeContentCollection(rootId,memberCollection,out);
}
else {
ContentResource resource = ContentHostingService.getResource(memberId);
storeContentResource(rootId, resource, out);
}
}
}
}
@Test
public void testLoadLoinc() throws Exception {
ourLog.info("TEST = testLoadLoinc()");
ByteArrayOutputStream bos1 = new ByteArrayOutputStream();
ZipOutputStream zos1 = new ZipOutputStream(bos1);
addEntry(zos1, "/loinc/", "loinc.csv");
zos1.close();
ourLog.info("ZIP file has {} bytes", bos1.toByteArray().length);
ByteArrayOutputStream bos2 = new ByteArrayOutputStream();
ZipOutputStream zos2 = new ZipOutputStream(bos2);
addEntry(zos2, "/loinc/", "LOINC_2.54_MULTI-AXIAL_HIERARCHY.CSV");
zos2.close();
ourLog.info("ZIP file has {} bytes", bos2.toByteArray().length);
RequestDetails details = mock(RequestDetails.class);
when(codeSvc.findBySystem("http://loinc.org")).thenReturn(new CodeSystemEntity());
mySvc.loadLoinc(list(bos1.toByteArray(), bos2.toByteArray()), details);
verify(codeSvc).storeNewCodeSystemVersion( myCsvCaptor.capture(), any(RequestDetails.class));
CodeSystemEntity ver = myCsvCaptor.getValue();
ConceptEntity code = ver.getConcepts().iterator().next();
assertEquals("10013-1", code.getCode());
}
private static void writeJar(String jarFile, Manifest manifest, String classes[], int from, int to) throws Exception {
if (DEBUG) {
System.out.println("ClassFileInstaller: Writing to " + getJarPath(jarFile));
}
(new File(jarFile)).delete();
FileOutputStream fos = new FileOutputStream(jarFile);
ZipOutputStream zos = new ZipOutputStream(fos);
// The manifest must be the first or second entry. See comments in JarInputStream
// constructor and JDK-5046178.
if (manifest != null) {
writeToDisk(zos, "META-INF/MANIFEST.MF", manifest.getInputStream());
}
for (int i=from; i<to; i++) {
writeClassToDisk(zos, classes[i]);
}
zos.close();
fos.close();
}
/**
* Creates a zip archive from the provided list of files
*
* @param zipFile absolute path to the zip file which needs to be created
* @param fileList list of files
* @throws APIManagementException when error occurred while creating the zip file
*/
public static void zipFiles(String zipFile, Collection<File> fileList) throws APIManagementException {
byte[] buffer = new byte[1024];
try (FileOutputStream fos = new FileOutputStream(zipFile);
ZipOutputStream zos = new ZipOutputStream(fos)) {
for (File file : fileList) {
String path = file.getAbsolutePath().substring(
file.getAbsolutePath().indexOf(APIConstants.API_WSDL_EXTRACTED_DIRECTORY)
+ APIConstants.API_WSDL_EXTRACTED_DIRECTORY.length() + 1);
ZipEntry ze = new ZipEntry(path);
zos.putNextEntry(ze);
try (FileInputStream in = new FileInputStream(file)) {
int len;
while ((len = in.read(buffer)) > 0) {
zos.write(buffer, 0, len);
}
}
}
} catch (IOException e) {
throw new APIManagementException("Error occurred while creating the ZIP file: " + zipFile, e);
}
}
/**
* 通过流打包下载文件
*
* @param out
* @param fileName
* @param
*/
public static void zipFilesByInputStream(ZipOutputStream out, String fileName, InputStream is) throws Exception {
byte[] buf = new byte[1024];
try {
out.putNextEntry(new ZipEntry(fileName));
int len;
while ((len = is.read(buf)) > 0) {
out.write(buf, 0, len);
}
is.close();
} catch (Exception e) {
throw e;
} finally {
if (is != null) {
is.close();
}
}
}
/**
* Generates a JaxRs project and streams the generated ZIP to the given
* output stream.
* @param output
* @throws IOException
*/
public final void generate(OutputStream output) throws IOException {
StringBuilder log = new StringBuilder();
try (ZipOutputStream zos = new ZipOutputStream(output)) {
try {
CodegenInfo info = getInfoFromApiDoc();
generateAll(info, log, zos);
} catch (Exception e) {
// If we get an error, put an PROJECT_GENERATION_ERROR file into the ZIP.
zos.putNextEntry(new ZipEntry("PROJECT_GENERATION_FAILED.txt"));
zos.write("An unexpected server error was encountered while generating the project. See\r\n".getBytes());
zos.write("the details of the error below.\r\n\r\n".getBytes());
zos.write("Generation Log:\r\n\r\n".getBytes());
zos.write(log.toString().getBytes(utf8));
zos.write("\r\n\r\nServer Stack Trace:\r\n".getBytes());
PrintWriter writer = new PrintWriter(zos);
e.printStackTrace(writer);
writer.flush();
zos.closeEntry();
}
}
}
/**
* Loop over each input dataset name (or pattern) given and
* add entries for it to the Zip file.
* If an exception occurs processing one entry, try to clean it
* up and continue with the next entry.
* The {@link ZipDatasetSource} class does all of the real work.
* <p/>
* @param zipOutStream
*/
private void processInputFiles(ZipOutputStream zipOutStream) {
for (int i=0; i<indsnames.length; i++) {
String inputName = indsnames[i];
ZipDatasetSource source = new ZipDatasetSource(inputName);
try {
source.addTo(zipOutStream, targetEncoding);
} catch( Throwable t) {
errors++;
try {
zipOutStream.closeEntry();
} catch (IOException ignore) {}
System.out.println(">>> Error occuring processing input dataset: " + inputName);
System.err.println(">>> Error occuring processing input dataset: " + inputName);
t.printStackTrace();
}
}
}
/**
* Return InputStream from which a new generated resource bundle can be retrieved.
*/
public SupportBundle generateNewBundle(List<String> generatorNames, BundleType bundleType) throws IOException {
List<BundleContentGeneratorDefinition> defs = getRequestedDefinitions(generatorNames);
PipedInputStream inputStream = new PipedInputStream();
PipedOutputStream outputStream = new PipedOutputStream();
inputStream.connect(outputStream);
ZipOutputStream zipOutputStream = new ZipOutputStream(outputStream);
executor.submit(() -> generateNewBundleInternal(defs, bundleType, zipOutputStream));
String bundleName = generateBundleName(bundleType);
String bundleKey = generateBundleDate(bundleType) + "/" + bundleName;
return new SupportBundle(
bundleKey,
bundleName,
inputStream
);
}
/**
* Add an single {@link ZipEntry} for a single dataset or member.
*
* @param zipOutStream the target ZipOutputStream
* @param targetEncoding the target text encoding
* @param ddname the DD allocated to the dataset or member
* @param memberName the member name; used to create the entry name
* @throws IOException
*/
private void addDatasetOrMember(ZipOutputStream zipOutStream, String targetEncoding,
String ddname, String memberName) throws IOException {
Reader reader = null;
try {
reader = openInputFile(ddname, memberName);
// Construct the name of the Zip entry that we will add
String entryName = memberName == null
? name
: name + "/" + memberName;
// Start a new ZipEntry in the Zip file,
// copy the dataset/member data into the Zip entry,
// and close the entry
ZipEntry entry = new ZipEntry(entryName);
zipOutStream.putNextEntry(entry);
copyData(reader, zipOutStream, targetEncoding);
zipOutStream.closeEntry();
System.out.println(" added: " + entryName
+ " (" + entry.getSize() + " -> " + entry.getCompressedSize() + ")");
} finally {
closeInputFile(reader);
freeDD(ddname);
}
}
public void buildUnknownFiles(File appDir, File outFile, MetaInfo meta)
throws AndrolibException {
if (meta.unknownFiles != null) {
LOGGER.info("Copying unknown files/dir...");
Map<String, String> files = meta.unknownFiles;
File tempFile = new File(outFile.getParent(), outFile.getName() + ".apktool_temp");
boolean renamed = outFile.renameTo(tempFile);
if (!renamed) {
throw new AndrolibException("Unable to rename temporary file");
}
try (
ZipFile inputFile = new ZipFile(tempFile);
ZipOutputStream actualOutput = new ZipOutputStream(new FileOutputStream(outFile))
) {
copyExistingFiles(inputFile, actualOutput);
copyUnknownFiles(appDir, actualOutput, files);
} catch (IOException | BrutException ex) {
throw new AndrolibException(ex);
}
// Remove our temporary file.
tempFile.delete();
}
}
/**
* Create a generic zip that is a valid extension archive.
*
* @param zipName name of the zip to create
* @return a zip file
* @throws IOException if there's an error creating the zip
*/
private File createExtensionZip(String zipName) throws IOException {
File f = new File(gLayout.getExtensionArchiveDir().getFile(false), zipName + ".zip");
try (ZipOutputStream out = new ZipOutputStream(new FileOutputStream(f))) {
out.putNextEntry(new ZipEntry(zipName + "/"));
out.putNextEntry(new ZipEntry(zipName + "/extension.properties"));
StringBuilder sb = new StringBuilder();
sb.append("name:" + zipName);
byte[] data = sb.toString().getBytes();
out.write(data, 0, data.length);
out.closeEntry();
}
return f;
}
public void zip(File zipFile, List<File> files) throws IOException {
final int BUFFER_SIZE = 2048;
ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(zipFile)));
for (File file : files) {
byte[] data = new byte[BUFFER_SIZE];
try(FileInputStream fileInputStream = new FileInputStream( file )) {
try(BufferedInputStream origin = new BufferedInputStream(fileInputStream, BUFFER_SIZE)) {
ZipEntry entry = new ZipEntry(file.getName());
out.putNextEntry(entry);
int count;
while ((count = origin.read(data, 0, BUFFER_SIZE)) != -1) {
out.write(data, 0, count);
}
}
}
}
out.close();
}
@Test
public void shouldBeAbleToAddASingleNonZeroLengthFile() throws IOException {
File reference = File.createTempFile("reference", ".zip");
try (CustomZipOutputStream out = ZipOutputStreams.newOutputStream(output, mode);
ZipOutputStream ref = new ZipOutputStream(new FileOutputStream(reference))) {
byte[] bytes = "cheese".getBytes();
ZipEntry entry = new ZipEntry("example.txt");
entry.setTime(System.currentTimeMillis());
out.putNextEntry(entry);
ref.putNextEntry(entry);
out.write(bytes);
ref.write(bytes);
}
byte[] seen = Files.readAllBytes(output);
byte[] expected = Files.readAllBytes(reference.toPath());
assertArrayEquals(expected, seen);
}
static private void addFolderToZip(String path, String srcFolder, ZipOutputStream zip, String... excludeNames)
throws IOException {
if (isInArray(srcFolder, excludeNames)) {
// jump folder if excluded
return;
}
File folder = new File(srcFolder);
String listOfFiles[] = folder.list();
for (int i = 0; i < listOfFiles.length; i++) {
if (isInArray(listOfFiles[i], excludeNames)) {
// jump if excluded
continue;
}
String folderPath = null;
if (path.length() < 1) {
folderPath = folder.getName();
} else {
folderPath = path + File.separator + folder.getName();
}
String srcFile = srcFolder + File.separator + listOfFiles[i];
addToZip(folderPath, srcFile, zip, excludeNames);
}
}
public static void zipFiles(Collection<File> resFileList, File zipFile, String comment, FeedBackServcie.Callback callback)
throws IOException {
final int BUFF_SIZE = 2048;
ZipOutputStream zipout = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(
zipFile), BUFF_SIZE));
int i = 0;
for (File resFile : resFileList) {
zipFile(resFile, zipout, "");
if(callback != null){
i++;
callback.showFeedProgress(i,resFileList.size(), FeedBackServcie.FeedType.ZIP);
}
}
zipout.setComment(comment);
zipout.close();
}
public File toJar(final String prefix, final String suffix) throws IOException {
final File file = File.createTempFile(prefix, suffix);
file.deleteOnExit();
// Create the ZIP file
final ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(file)));
for (final Map.Entry<String, byte[]> entry : entries().entrySet()) {
out.putNextEntry(new ZipEntry(entry.getKey()));
out.write(entry.getValue());
}
// Complete the ZIP file
out.close();
return file;
}
/**
* Compresses a list of files to a destination zip file
*
* @param listFiles A collection of files and directories
* @param destZipFile The path of the destination zip file
* @throws FileNotFoundException
* @throws IOException
*/
public void zip(List<File> listFiles, String destZipFile) throws FileNotFoundException,
IOException
{
ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(destZipFile));
for(File file : listFiles)
{
if(file.isDirectory())
{
zipDirectory(file, file.getName(), zos);
}
else
{
zipFile(file, zos);
}
}
zos.flush();
zos.close();
}
public static Path compressDirectory(Path directory, Path target) throws IOException {
FileSystem sourceFs = directory.getFileSystem();
FileSystem targetFs = target.getFileSystem();
try (ZipOutputStream out = new ZipOutputStream(targetFs.create(target, FileSystem.WriteMode.NO_OVERWRITE))) {
addToZip(directory, sourceFs, directory.getParent(), out);
}
return target;
}
private byte[] zipCode(SysGen sysGen) throws IOException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ZipOutputStream zos = new ZipOutputStream(bos);
for (String ftl : ftls) {
String content = FreeMarkerUtils.renderTemplate(ftl, sysGen);
logger.info("ftl {}:\r\n{}",ftl,content);
zos.putNextEntry(new ZipEntry(this.getZipEntryName(ftl,sysGen)));
IOUtils.write(content, zos);
zos.closeEntry();
}
//这个地方有点反人类,按道理应该在取到byte[] 后关闭,测试,zos.flush 也无效,顾提前关闭,将流都刷入到数组中。
zos.close();
byte[] byteArray = bos.toByteArray();
return byteArray;
}
/**
* Compresses a collection of files to a destination zip file.
*
* @param listFiles A collection of files and directories
* @param destZipFile The path of the destination zip file
* @throws FileNotFoundException if file not found
* @throws IOException if IO exception occurs
*/
public void compressFiles(List<File> listFiles, String destZipFile)
throws IOException {
try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(destZipFile))) {
for (File file : listFiles) {
if (file.isDirectory()) {
addFolderToZip(file, file.getName(), zos);
} else {
addFileToZip(file, zos);
}
}
zos.flush();
}
}
static void addEntries(ZipOutputStream zos, File dir, String dbName, int old) throws Exception {
String[] list = dir.list();
for (int i = 0; i < list.length; i++) {
File f = new File(dir, list[i]);
if (f.isDirectory()) {
addEntries(zos, f, dbName, old);
} else {
addFile(zos, f, dbName, old);
}
}
}
public void compress(OutputStream out) throws IOException {
ZipOutputStream zOut = new ZipOutputStream(out);
// zOut.setLevel(Deflater.BEST_SPEED);
zOut.putNextEntry(new ZipEntry("A"));
DataOutputStream dOut = new DataOutputStream(zOut);
dOut.writeInt(mUnits.length);
for (int ii = 0; ii < mUnits.length; ii++) {
dOut.writeLong(mUnits[ii]);
}
dOut.flush();
zOut.closeEntry();
zOut.flush();
}
private static void writeClassToDisk(ZipOutputStream zos, String className, byte[] bytecode, String prependPath) throws Exception {
// Convert dotted class name to a path to a class file
String pathName = className.replace('.', '/').concat(".class");
if (prependPath.length() > 0) {
pathName = prependPath + "/" + pathName;
}
writeToDisk(zos, pathName, new ByteArrayInputStream(bytecode));
}
public @Nonnull ZipOutputStream getZipOutputFile(String path) {
ZipOutputStream result = analysisOutputFiles.get(path);
if (result != null) {
return result;
}
SortedMap<String, ZipOutputStream> head = analysisOutputFiles.headMap(path);
String matchingPath = head.lastKey();
result = analysisOutputFiles.get(matchingPath);
if (result == null) {
throw new IllegalArgumentException("No zip output file for " + path);
}
return result;
}
public static Path compressDirectory(Path directory, Path target) throws IOException {
FileSystem sourceFs = directory.getFileSystem();
FileSystem targetFs = target.getFileSystem();
Path absolutePath = absolutizePath(directory);
Path absoluteTargetPath = absolutizePath(target);
try (ZipOutputStream out = new ZipOutputStream(targetFs.create(absoluteTargetPath, FileSystem.WriteMode.NO_OVERWRITE))) {
addToZip(absolutePath, sourceFs, absolutePath.getParent(), out);
}
return target;
}
@Test
public void testZipFileInput() throws Exception {
ByteArrayOutputStream err = new ByteArrayOutputStream();
helper.redirectLog( err, LogLevel.ERROR );
final String input = getBasicTestJson();
try ( FileObject fileObj = KettleVFS.getFileObject( BASE_RAM_DIR + "test.zip" ) ) {
fileObj.createFile();
try ( OutputStream out = fileObj.getContent().getOutputStream() ) {
try ( ZipOutputStream zipOut = new ZipOutputStream( out ) ) {
ZipEntry jsonFile = new ZipEntry( "test.json" );
zipOut.putNextEntry( jsonFile );
zipOut.write( input.getBytes() );
zipOut.closeEntry();
zipOut.flush();
}
}
JsonInputField price = new JsonInputField();
price.setName( "price" );
price.setType( ValueMetaInterface.TYPE_NUMBER );
price.setPath( "$..book[*].price" );
JsonInputMeta meta = createSimpleMeta( "in file", price );
meta.setIsAFile( true );
meta.setRemoveSourceField( true );
JsonInput jsonInput = createJsonInput( "in file", meta, new Object[][] {
new Object[] { "zip:" + BASE_RAM_DIR + "test.zip!/test.json" }
} );
RowComparatorListener rowComparator = new RowComparatorListener(
new Object[] { 8.95d },
new Object[] { 12.99d },
new Object[] { 8.99d },
new Object[] { 22.99d } );
jsonInput.addRowListener( rowComparator );
processRows( jsonInput, 5 );
Assert.assertEquals( err.toString(), 0, jsonInput.getErrors() );
} finally {
deleteFiles();
}
}
public Ziper(String zipFilename, Project project) {
try {
this.root = project.getBasePath();
this.fos = new FileOutputStream(zipFilename);
this.zos = new ZipOutputStream(fos);
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
}
}