Java JarOutputStream.close方法代码示例

import java.util.jar.JarOutputStream; //导入方法依赖的package包/类
public void createRealJarFile(File f) throws Exception {
        OutputStream os = new FileOutputStream(f);
        try {
            JarOutputStream jos = new JarOutputStream(os);
//            jos.setMethod(ZipEntry.STORED);
            JarEntry entry = new JarEntry("foo.txt");
//            entry.setSize(0L);
//            entry.setTime(System.currentTimeMillis());
//            entry.setCrc(new CRC32().getValue());
            jos.putNextEntry(entry);
            jos.flush();
            jos.close();
        } finally {
            os.close();
        }
    }
 

import java.util.jar.JarOutputStream; //导入方法依赖的package包/类
private File makeClassLoaderTestJar(String... clsNames) throws IOException {
  File jarFile = new File(TEST_ROOT_DIR, TEST_JAR_2_NAME);
  JarOutputStream jstream =
      new JarOutputStream(new FileOutputStream(jarFile));
  for (String clsName: clsNames) {
    String name = clsName.replace('.', '/') + ".class";
    InputStream entryInputStream = this.getClass().getResourceAsStream(
        "/" + name);
    ZipEntry entry = new ZipEntry(name);
    jstream.putNextEntry(entry);
    BufferedInputStream bufInputStream = new BufferedInputStream(
        entryInputStream, 2048);
    int count;
    byte[] data = new byte[2048];
    while ((count = bufInputStream.read(data, 0, 2048)) != -1) {
      jstream.write(data, 0, count);
    }
    jstream.closeEntry();
  }
  jstream.close();

  return jarFile;
}
 

import java.util.jar.JarOutputStream; //导入方法依赖的package包/类
private File copyJar(File file, String manifest) throws IOException {
    File ret = File.createTempFile(file.getName(), "2ndcopy", file.getParentFile());
    JarFile jar = new JarFile(file);
    JarOutputStream os = new JarOutputStream(new FileOutputStream(ret), new Manifest(
        new ByteArrayInputStream(manifest.getBytes())
    ));
    Enumeration<JarEntry> en = jar.entries();
    while (en.hasMoreElements()) {
        JarEntry elem = en.nextElement();
        if (elem.getName().equals("META-INF/MANIFEST.MF")) {
            continue;
        }
        os.putNextEntry(elem);
        InputStream is = jar.getInputStream(elem);
        copyStreams(is, os);
        is.close();
    }
    os.close();
    return ret;
}
 

import java.util.jar.JarOutputStream; //导入方法依赖的package包/类
public void testHandleSpaceInPathAsProducedByEclipse() throws Exception {
    File d = new File(getWorkDir(), "space in path");
    d.mkdirs();
    File f = new File(d, "x.jar");
    JarOutputStream os = new JarOutputStream(new FileOutputStream(f));
    os.putNextEntry(new JarEntry("test.txt"));
    os.write(10);
    os.close();
    
    URL u = new URL("jar:" + f.toURL() + "!/test.txt");
    DataInputStream is = new DataInputStream(u.openStream());
    byte[] arr = new byte[100];
    is.readFully(arr, 0, 1);
    assertEquals("One byte", 10, arr[0]);
    is.close();
}
 

import java.util.jar.JarOutputStream; //导入方法依赖的package包/类
public static void createJarArchive(JavaProjectFolder projectFolder) throws IOException {
    //input file
    File dirBuildClasses = projectFolder.getDirBuildClasses();
    File archiveFile = projectFolder.getOutJarArchive();


    // Open archive file
    FileOutputStream stream = new FileOutputStream(archiveFile);
    Manifest manifest = new Manifest();
    manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");

    //Create the jar file
    JarOutputStream out = new JarOutputStream(stream, manifest);

    //Add the files..
    if (dirBuildClasses.listFiles() != null) {
        for (File file : dirBuildClasses.listFiles()) {
            addzz(dirBuildClasses.getPath(), file, out);
        }
    }

    out.close();
    stream.close();
    System.out.println("Adding completed OK");
}
 

import java.util.jar.JarOutputStream; //导入方法依赖的package包/类
public void writeIndexJar() throws IOException, XmlPullParserException, LocalRepoKeyStore.InitException {
    BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream(xmlIndexJarUnsigned));
    JarOutputStream jo = new JarOutputStream(bo);
    JarEntry je = new JarEntry("index.xml");
    jo.putNextEntry(je);
    new IndexXmlBuilder().build(context, apps, jo);
    jo.close();
    bo.close();

    try {
        LocalRepoKeyStore.get(context).signZip(xmlIndexJarUnsigned, xmlIndexJar);
    } catch (LocalRepoKeyStore.InitException e) {
        throw new IOException("Could not sign index - keystore failed to initialize");
    } finally {
        attemptToDelete(xmlIndexJarUnsigned);
    }

}
 

import java.util.jar.JarOutputStream; //导入方法依赖的package包/类
@Override
public void write(File file) throws IOException {
    JarOutputStream jos = new JarOutputStream(new FileOutputStream(file));
    try {
        for (Iterator<ClassNode> itr = iterator(); itr.hasNext(); ) {
            ClassNode   node   = itr.next();
            ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS);
            node.accept(new CheckClassAdapter(writer, true));
            byte[] bytes = writer.toByteArray();
            jos.putNextEntry(new JarEntry(node.name.concat(".class")));
            jos.write(bytes);
        }
    } finally {
        jos.close();
    }
}
 

import java.util.jar.JarOutputStream; //导入方法依赖的package包/类
private void assertEnableModule(String req, boolean enable) throws Exception {
    Manifest man = new Manifest ();
    man.getMainAttributes ().putValue ("Manifest-Version", "1.0");
    man.getMainAttributes ().putValue ("OpenIDE-Module", "org.test.PlatformDependency/1");
    man.getMainAttributes ().putValue ("OpenIDE-Module-Public-Packages", "-");
    
    man.getMainAttributes ().putValue ("OpenIDE-Module-Requires", req);
    
    JarOutputStream os = new JarOutputStream (new FileOutputStream (moduleJarFile), man);
    os.putNextEntry (new JarEntry ("empty/test.txt"));
    os.close ();
    
    final MockEvents ev = new MockEvents();
    NbInstaller installer = new NbInstaller(ev);
    ModuleManager mgr = new ModuleManager(installer, ev);
    ModuleFormatSatisfiedTest.addOpenideModules(mgr);
    installer.registerManager(mgr);
    mgr.mutexPrivileged().enterWriteAccess();
    try {
        Module m1 = mgr.create(moduleJarFile, null, false, false, false);
        if (enable) {
            assertEquals(Collections.EMPTY_SET, m1.getProblems());
            mgr.enable(m1);
            mgr.disable(m1);
        } else {
            assertFalse("We should not be able to enable the module", m1.getProblems().isEmpty());
        }
        mgr.delete(m1);
    } finally {
        mgr.mutexPrivileged().exitWriteAccess();
    }
}
 

import java.util.jar.JarOutputStream; //导入方法依赖的package包/类
static void createJAR(File cluster, String moduleName, Class metaInfHandler) 
    throws IOException {
        File xml = new File(new File(new File(cluster, "config"), "Modules"), moduleName + ".xml");
        File jar = new File(new File(cluster, "modules"), moduleName + ".jar");
        
        xml.getParentFile().mkdirs();
        jar.getParentFile().mkdirs();
        
        
        Manifest mf = new Manifest();
        mf.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");
        mf.getMainAttributes().putValue("OpenIDE-Module", moduleName.replace('-', '.'));
        mf.getMainAttributes().putValue("OpenIDE-Module-Public-Packages", "-");
        
        JarOutputStream os = new JarOutputStream(new FileOutputStream(jar), mf);
        os.putNextEntry(new JarEntry("META-INF/services/org.netbeans.CLIHandler"));
        os.write(metaInfHandler.getName().getBytes());
        os.close();
        
        FileWriter w = new FileWriter(xml);
        w.write(            
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<!DOCTYPE module PUBLIC \"-//NetBeans//DTD Module Status 1.0//EN\"\n" +
"                        \"http://www.netbeans.org/dtds/module-status-1_0.dtd\">\n" +
"<module name=\"" + moduleName.replace('-', '.') + "\">\n" +
"    <param name=\"autoload\">false</param>\n" +
"    <param name=\"eager\">false</param>\n" +
"    <param name=\"enabled\">true</param>\n" +
"    <param name=\"jar\">modules/" + moduleName + ".jar</param>\n" +
"    <param name=\"release\">2</param>\n" +
"    <param name=\"reloadable\">false</param>\n" +
"    <param name=\"specversion\">3.4.0.1</param>\n" +
"</module>\n");
        w.close();
    }
 

import java.util.jar.JarOutputStream; //导入方法依赖的package包/类
private File makeTestJar() throws IOException {
  File jarFile = new File(testDir, "test.jar");
  JarOutputStream out = new JarOutputStream(new FileOutputStream(jarFile));
  ZipEntry entry = new ZipEntry("resource.txt");
  out.putNextEntry(entry);
  out.write("hello".getBytes());
  out.closeEntry();
  out.close();
  return jarFile;
}
 

import java.util.jar.JarOutputStream; //导入方法依赖的package包/类
/**
 * Generate output JAR-file and packages
 */
public void outputToJar() throws IOException {
    // create the manifest
    final Manifest manifest = new Manifest();
    final java.util.jar.Attributes atrs = manifest.getMainAttributes();
    atrs.put(java.util.jar.Attributes.Name.MANIFEST_VERSION, "1.2");

    final Map<String, Attributes> map = manifest.getEntries();
    // create manifest
    final String now = (new Date()).toString();
    final java.util.jar.Attributes.Name dateAttr =
        new java.util.jar.Attributes.Name("Date");

    final File jarFile = new File(_destDir, _jarFileName);
    final JarOutputStream jos =
        new JarOutputStream(new FileOutputStream(jarFile), manifest);

    for (JavaClass clazz : _bcelClasses) {
        final String className = clazz.getClassName().replace('.', '/');
        final java.util.jar.Attributes attr = new java.util.jar.Attributes();
        attr.put(dateAttr, now);
        map.put(className + ".class", attr);
        jos.putNextEntry(new JarEntry(className + ".class"));
        final ByteArrayOutputStream out = new ByteArrayOutputStream(2048);
        clazz.dump(out); // dump() closes it's output stream
        out.writeTo(jos);
    }
    jos.close();
}
 

import java.util.jar.JarOutputStream; //导入方法依赖的package包/类
@SuppressWarnings("CallToThreadDumpStack")
public static boolean unpackInternally(final File source,
        final File target) throws IOException {
    try {
        JarOutputStream os = new JarOutputStream(new FileOutputStream(target));
        unpacker.unpack(source, os);
        os.close();
        target.setLastModified(source.lastModified());
    } catch (IOException exc) {
        exc.printStackTrace();
        return false;
    }
    return true;
}
 

import java.util.jar.JarOutputStream; //导入方法依赖的package包/类
/** Creates a fake bundle definition that represents one NetBeans module
 *
 * @param m the module
 * @return the stream to read the definition from or null, if it does not
 *   make sense to represent this module as bundle
 */
private static InputStream fakeBundle(Module m) throws IOException {
    String netigsoExp = (String) m.getAttribute("Netigso-Export-Package"); // NOI18N
    String exp = (String) m.getAttribute("OpenIDE-Module-Public-Packages"); // NOI18N
    if (netigsoExp == null) {
        if ("-".equals(exp) || m.getAttribute("OpenIDE-Module-Friends") != null) { // NOI18N
            return null;
        }
    }
    ByteArrayOutputStream os = new ByteArrayOutputStream();
    Manifest man = new Manifest();
    man.getMainAttributes().putValue("Manifest-Version", "1.0"); // workaround for JDK bug
    man.getMainAttributes().putValue("Bundle-ManifestVersion", "2"); // NOI18N
    man.getMainAttributes().putValue("Bundle-SymbolicName", m.getCodeNameBase()); // NOI18N

    if (m.getSpecificationVersion() != null) {
        String spec = threeDotsWithMajor(m.getSpecificationVersion().toString(), m.getCodeName());
        man.getMainAttributes().putValue("Bundle-Version", spec.toString()); // NOI18N
    }
    if (netigsoExp != null) {
        man.getMainAttributes().putValue("Export-Package", netigsoExp); // NOI18N
    } else if (exp != null) {
        man.getMainAttributes().putValue("Export-Package", substitutePkg(m)); // NOI18N
    } else {
        man.getMainAttributes().putValue("Export-Package", m.getCodeNameBase()); // NOI18N
    }        
    JarOutputStream jos = new JarOutputStream(os, man);
    jos.close();
    return new ByteArrayInputStream(os.toByteArray());
}
 

import java.util.jar.JarOutputStream; //导入方法依赖的package包/类
public void testLazyOpen() throws Exception {
    File f = new File(getWorkDir(), "ok.jar");
    JarOutputStream jos = new JarOutputStream(new FileOutputStream(f));
    jos.putNextEntry(new JarEntry("one"));
    jos.putNextEntry(new JarEntry("two.txt"));
    jos.putNextEntry(new JarEntry("3.txt"));
    jos.close();

    CharSequence log = Log.enable(JarFileSystem.class.getName(), Level.FINE);
    JarFileSystem fs = new JarFileSystem(f);
    final String match = "opened: " + f.getAbsolutePath();
    if (log.toString().contains(match)) {
        fail("The file " + f + " shall not be opened when fs created:\n" + log);
    }

    URL u = fs.getRoot().toURL();
    assertNotNull("URL is OK", u);
    if (!u.toExternalForm().startsWith("jar:file") || !u.toExternalForm().endsWith("ok.jar!/")) {
        fail("Unexpected URL: " + u);
    }
    if (log.toString().contains(match)) {
        fail("The file " + f + " shall not be opened yet:\n" + log);
    }
    assertEquals("Three files", 3, fs.getRoot().getChildren().length);
    if (!log.toString().contains(match)) {
        fail("The file " + f + " shall be opened now:\n" + log);
    }
}
 

import java.util.jar.JarOutputStream; //导入方法依赖的package包/类
/**
 * Check that jar: URLs are correctly mapped back into JarFileSystem resources.
 * @see "#39190"
 */
public void testJarMapping() throws Exception {
    clearWorkDir();
    File workdir = getWorkDir();
    File jar = new File(workdir, "test.jar");
    String textPath = "x.txt";
    OutputStream os = new FileOutputStream(jar);
    try {
        JarOutputStream jos = new JarOutputStream(os);
        jos.setMethod(ZipEntry.STORED);
        JarEntry entry = new JarEntry(textPath);
        entry.setSize(0L);
        entry.setTime(System.currentTimeMillis());
        entry.setCrc(new CRC32().getValue());
        jos.putNextEntry(entry);
        jos.flush();
        jos.close();
    } finally {
        os.close();
    }
    assertTrue("JAR was created", jar.isFile());
    assertTrue("JAR is not empty", jar.length() > 0L);
    JarFileSystem jfs = new JarFileSystem();
    jfs.setJarFile(jar);
    Repository.getDefault().addFileSystem(jfs);
    FileObject rootFO = jfs.getRoot();
    FileObject textFO = jfs.findResource(textPath);
    assertNotNull("JAR contains a/b.txt", textFO);
    String rootS = "jar:" + BaseUtilities.toURI(jar) + "!/";
    URL rootU = new URL(rootS);
    URL textU = new URL(rootS + textPath);
    assertEquals("correct FO -> URL for root", rootU, URLMapper.findURL(rootFO, URLMapper.EXTERNAL));
    assertEquals("correct FO -> URL for " + textPath, textU, URLMapper.findURL(textFO, URLMapper.EXTERNAL));
    assertTrue("correct URL -> FO for root", Arrays.asList(URLMapper.findFileObjects(rootU)).contains(rootFO));
    assertTrue("correct URL -> FO for " + textPath, Arrays.asList(URLMapper.findFileObjects(textU)).contains(textFO));
}