Java GzipUtils类代码示例

import org.apache.commons.compress.compressors.gzip.GzipUtils; //导入依赖的package包/类
/**
 * Compress a file
 * @param inFile
 * @param outFile
 * @throws FileNotFoundException
 * @throws IOException
 */
public static String compressFile(String inFile) throws FileNotFoundException, IOException {
    
    byte[] buffer = new byte[BUFFER_SIZE];
    
    String outFile = GzipUtils.getCompressedFilename(inFile);
    
    log.info("Compressing file: " + inFile + ", to file: " + outFile);
    
    try(GZIPOutputStream gzos = 
            new GZIPOutputStream(new FileOutputStream(outFile), Constants.GZIP_BUF_SIZE);
        FileInputStream in = new FileInputStream(inFile);) {
 
        int len;
        while ((len = in.read(buffer)) > 0) {
            gzos.write(buffer, 0, len);
        }
         
        gzos.finish();
    }
    
    return outFile;
}
 

import org.apache.commons.compress.compressors.gzip.GzipUtils; //导入依赖的package包/类
/**
 * Returns a reader for the given file.<br/>
 * In case of files with extensions: gz and zip the reader is
 * built upon {@link GZIPInputStream} and {@link ZipInputStream} respectively. <br/>
 * The reader gets/reads only first zip entry in case of zip files<br/>
 * The reader uses the UTF-8 encoding by default. It can be changed by {@link #setFileCharset(String)}.
 * 
 * @throws ImportException in case of any exception
 * 
 */
public Reader getReader(File file) throws ImportException {
    try {
        InputStream inputStream = new FileInputStream(file);
        if (GzipUtils.isCompressedFilename(file.getName())) {
            inputStream = new GZIPInputStream(inputStream);
        } else if (FilenameUtils.getExtension(file.getName()).equals("zip")) {
            inputStream = new ZipInputStream(inputStream);
            ((ZipInputStream)inputStream).getNextEntry();
            
        }
        
        return new InputStreamReader(inputStream, fileCharset);
        
    } catch (Exception e) {
        throw new ImportException(e);
    }
}
 

import org.apache.commons.compress.compressors.gzip.GzipUtils; //导入依赖的package包/类
private static void gzipFile(File file) throws IOException {
    if (file == null) {
        return;
    }
    String name = GzipUtils.getCompressedFilename(file.getName());
    File dest = new File(file.getParentFile(), name);
    try (FileOutputStream os = new FileOutputStream(dest)) {
        // read the contents
        String contents = FileUtils.readFileToString(file, Charsets.UTF_8);
        try (OutputStream gzip = new GzipCompressorOutputStream(os)) {
            // write / compress
            IOUtils.write(contents, gzip, Charsets.UTF_8);
        }

    } finally {
        file.delete(); // delete the file
    }
}
 

import org.apache.commons.compress.compressors.gzip.GzipUtils; //导入依赖的package包/类
/**
 * (Gzip) Uncompress a compressed file
 * @param filename
 * @return
 * @throws IOException
 */
public static String unCompressFile(String filename) throws IOException {
    
    
    byte[] buffer = new byte[BUFFER_SIZE];
    String outFile = GzipUtils.getUncompressedFilename(filename);
    
    log.info("Uncompressing file: " + filename + ", to file: " + outFile);
    
    try(GZIPInputStream gzis = 
            new GZIPInputStream(new FileInputStream(filename), Constants.GZIP_BUF_SIZE);
            BufferedOutputStream out = 
                    new BufferedOutputStream(new FileOutputStream(outFile), Constants.GZIP_BUF_SIZE);) {

        int len;
        while ((len = gzis.read(buffer)) > 0) {
            out.write(buffer, 0, len);
        }

    }
    /*
    FileInputStream fin = new FileInputStream(filename);
    BufferedInputStream in = new BufferedInputStream(fin);
    
    try(FileOutputStream out = new FileOutputStream(outFile);
            GzipCompressorInputStream gzIn = new GzipCompressorInputStream(in)) {
        final byte[] buffer = new byte[BUFFER];
        int n = 0;
        while (-1 != (n = gzIn.read(buffer))) {
            out.write(buffer, 0, n);
        }
    }*/
    return outFile;
}
 

import org.apache.commons.compress.compressors.gzip.GzipUtils; //导入依赖的package包/类
@Override
public void run() throws IOException {
	
	log.info("Processing schema terms");
	
	//String schemaFile = metadata.getValue(EcarfMetaData.ECARF_SCHEMA);
	//String bucket = metadata.getBucket();
	// check if we have a source bucket for backward compatibility
	if(StringUtils.isBlank(sourceBucket)) {
	    log.warn("sourceBucket is empty, using bucket: " + bucket);
	    this.sourceBucket = bucket;
	}
	
	String localSchemaFile = Utils.TEMP_FOLDER + schemaFile;
	// download the file from the cloud storage
	this.getCloudService().downloadObjectFromCloudStorage(schemaFile, localSchemaFile, sourceBucket);
	
	// uncompress if compressed
	if(GzipUtils.isCompressedFilename(schemaFile)) {
		localSchemaFile = GzipUtils.getUncompressedFilename(localSchemaFile);
	}
	
	Set<String> terms = TermUtils.getRelevantSchemaTerms(localSchemaFile, TermUtils.RDFS_TBOX);
	
	log.info("Total relevant schema terms: " + terms.size());
	
	String schemaTermsFile = Utils.TEMP_FOLDER + Constants.SCHEMA_TERMS_JSON;
	
	// save to file
	FileUtils.objectToJsonFile(schemaTermsFile, terms);
	
	// upload the file to cloud storage
	this.getCloudService().uploadFileToCloudStorage(schemaTermsFile, bucket);
	
	// add value to the output
	this.addOutput("schemaTermsFile", Constants.SCHEMA_TERMS_JSON);
	
	log.info("Successfully processed schema terms");
}
 

import org.apache.commons.compress.compressors.gzip.GzipUtils; //导入依赖的package包/类
/**
 * Detect the compression format from the filename, or null in case auto-detection failed.
 * @param file
 * @return
 */
private String detectCompression(File file) {
    if(BZip2Utils.isCompressedFilename(file.getName())) {
        return CompressorStreamFactory.BZIP2;
    } else if(GzipUtils.isCompressedFilename(file.getName())) {
        return CompressorStreamFactory.GZIP;
    } else if(XZUtils.isCompressedFilename(file.getName())) {
        return CompressorStreamFactory.XZ;
    } else {
        return null;
    }
}
 

import org.apache.commons.compress.compressors.gzip.GzipUtils; //导入依赖的package包/类
private String uncompressedName(File file) {
    if(BZip2Utils.isCompressedFilename(file.getAbsolutePath())) {
        return BZip2Utils.getUncompressedFilename(file.getName());
    } else if(GzipUtils.isCompressedFilename(file.getAbsolutePath())) {
        return GzipUtils.getUncompressedFilename(file.getName());
    } else if(XZUtils.isCompressedFilename(file.getAbsolutePath())) {
        return XZUtils.getUncompressedFilename(file.getName());
    } else {
        return file.getName();
    }
}
 

import org.apache.commons.compress.compressors.gzip.GzipUtils; //导入依赖的package包/类
private InputStream openStream(Path file) throws IOException {
    final String fName = file.getFileName().toString();
    final FileInputStream fis = new FileInputStream(file.toFile());
    
    if (GzipUtils.isCompressedFilename(fName)) {
        log.trace("{} looks GZIP compressed,", file);
        return new GZIPInputStream(fis);
    } else if (BZip2Utils.isCompressedFilename(fName)) {
        log.trace("{} looks BZ2 compressed", file);
        return new BZip2CompressorInputStream(fis);
    } else {
        return fis;
    }
}
 

import org.apache.commons.compress.compressors.gzip.GzipUtils; //导入依赖的package包/类
private static boolean fileExists(File file) {
    if (!file.exists()) {
        String gzip = GzipUtils.getCompressedFilename(file.getName());
        file = new File(file.getParentFile(), gzip);
    }
    return file.exists();
}
 

import org.apache.commons.compress.compressors.gzip.GzipUtils; //导入依赖的package包/类
public void initializeFileValues(FileDescriptor src) {
  	this.ufile = new FileDescriptor();
  	
if (StringUtil.isNotEmpty(this.nameHint)) 
	this.ufile.setPath("/" +  this.nameHint);
else if (src.hasPath()) 
	this.ufile.setPath("/" +  GzipUtils.getUncompressedFilename(src.path().getFileName()));
else
	this.ufile.setPath("/" + FileUtil.randomFilename("bin"));    	

this.ufile.setModTime(src.getModTime());
this.ufile.setPermissions(src.getPermissions());
  }
 

import org.apache.commons.compress.compressors.gzip.GzipUtils; //导入依赖的package包/类
protected BinaryReader(@NonNull File file) {
    try {
        stream = new DataInputStream(new BufferedInputStream(GzipUtils.isCompressedFilename(file.getName())
                        ? new GZIPInputStream(new FileInputStream(file)) : new FileInputStream(file)));

        numWords = Integer.parseInt(readString(stream));
        vectorLength = Integer.parseInt(readString(stream));
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

import org.apache.commons.compress.compressors.gzip.GzipUtils; //导入依赖的package包/类
/**
 * Carryout the setup of the schema terms
 * @param cloud
 * @throws IOException
 */
private void setup(GoogleCloudService cloud) throws IOException {
    
    Set<String> termsSet;
       
       if(terms == null) {
           // too large, probably saved as a file

           log.info("Using json file for terms: " + termsFile);
           Validate.notNull(termsFile);
           
           String localTermsFile = Utils.TEMP_FOLDER + termsFile;
           cloud.downloadObjectFromCloudStorage(termsFile, localTermsFile, bucket);

           // convert from JSON
           termsSet = io.cloudex.framework.utils.FileUtils.jsonFileToSet(localTermsFile);
           
       } else {
           termsSet = ObjectUtils.csvToSet(terms);
       }
       
       String localSchemaFile = Utils.TEMP_FOLDER + schemaFile;
       // download the file from the cloud storage
       cloud.downloadObjectFromCloudStorage(schemaFile, localSchemaFile, bucket);

       // uncompress if compressed
       if(GzipUtils.isCompressedFilename(schemaFile)) {
           localSchemaFile = GzipUtils.getUncompressedFilename(localSchemaFile);
       }

       Map<Long, Set<Triple>> allSchemaTriples = 
               TripleUtils.getRelevantSchemaETriples(localSchemaFile, TermUtils.RDFS_TBOX);

       // get all the triples we care about
       schemaTerms = new HashMap<>();

       for(String termStr: termsSet) {
           
           Long term = Long.parseLong(termStr);
           
           if(allSchemaTriples.containsKey(term)) {
               schemaTerms.put(term, allSchemaTriples.get(term));
           }
       }
    
}
 

import org.apache.commons.compress.compressors.gzip.GzipUtils; //导入依赖的package包/类
public static boolean isCompressed (String name) {
	return GzipUtils.isCompressedFilename(name) || BZip2Utils.isCompressedFilename(name) || XZUtils.isCompressedFilename(name);
}