Java JarInputStream.getNextJarEntry方法代码示例

import java.util.jar.JarInputStream; //导入方法依赖的package包/类
/**
 * Store all class names found in this jar file
 */
private static LinkedList<String> processJar(File jarfile, String basepath) {
	// System.out.println("Processing JAR " + jarfile.getPath());
	LinkedList<String> addlist = new LinkedList<String>();
	try {
		JarInputStream jarIS = new JarInputStream(new FileInputStream(
				jarfile));

		JarEntry entry = null;
		while ((entry = jarIS.getNextJarEntry()) != null) {
			String name = entry.getName();
			if (name.endsWith(".class")) {
				// System.out.println( entry.getAttributes().toString() );
				if (!add(name, jarfile.getPath(), basepath).isEmpty())
					addlist.addAll(add(name, jarfile.getPath(), basepath));
			}
		}
	} catch (Exception e) {
	}
	return addlist;
}
 

import java.util.jar.JarInputStream; //导入方法依赖的package包/类
@SuppressWarnings("resource")
  private List<String> readFromJarFile(String jarPath, String splashedPackageName) throws IOException {
      if (logger.isDebugEnabled()) {
          logger.debug("从JAR包中读取类: {}", jarPath);
      }
      
JarInputStream jarIn = new JarInputStream(new FileInputStream(jarPath));
      JarEntry entry = jarIn.getNextJarEntry();

      List<String> nameList = new ArrayList<>();
      while (null != entry) {
          String name = entry.getName();
          if (name.startsWith(splashedPackageName) && isClassFile(name)) {
              nameList.add(name);
          }

          entry = jarIn.getNextJarEntry();
      }

      return nameList;
  }
 

import java.util.jar.JarInputStream; //导入方法依赖的package包/类
protected void scanJar(URL jarUrl, Map<String, ResourceInfo> resInfos) throws IOException {
  JarInputStream jarInput = new JarInputStream(jarUrl.openStream(), false);
  JarEntry entry = null;
  while((entry = jarInput.getNextJarEntry()) != null) {
    String entryName = entry.getName();
    if(entryName != null && entryName.endsWith(".class")) {
      final String className = entryName.substring(0,
               entryName.length() - 6).replace('/', '.');
      if(!resInfos.containsKey(className)) {
        ClassReader classReader = new ClassReader(jarInput);
        ResourceInfo resInfo = new ResourceInfo(null, className, null);
        ResourceInfoVisitor visitor = new ResourceInfoVisitor(resInfo);

        classReader.accept(visitor, ClassReader.SKIP_CODE |
            ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
        if(visitor.isCreoleResource()) {
          resInfos.put(className, resInfo);
        }
      }
    }
  }

  jarInput.close();
}
 

import java.util.jar.JarInputStream; //导入方法依赖的package包/类
/**
 * Dumps the entries of a jar and return them as a String. This method can
 * be memory expensive depending on the jar size.
 * 
 * @param jis
 * @return
 * @throws Exception
 */
public static String dumpJarContent(JarInputStream jis) {
	StringBuilder buffer = new StringBuilder();

	try {
		JarEntry entry;
		while ((entry = jis.getNextJarEntry()) != null) {
			buffer.append(entry.getName());
			buffer.append("\n");
		}
	}
	catch (IOException ioException) {
		buffer.append("reading from stream failed");
	}
	finally {
		closeStream(jis);
	}

	return buffer.toString();
}
 

import java.util.jar.JarInputStream; //导入方法依赖的package包/类
static void copyJarFile(JarInputStream in, JarOutputStream out) throws IOException {
    if (in.getManifest() != null) {
        ZipEntry me = new ZipEntry(JarFile.MANIFEST_NAME);
        out.putNextEntry(me);
        in.getManifest().write(out);
        out.closeEntry();
    }
    byte[] buffer = new byte[1 << 14];
    for (JarEntry je; (je = in.getNextJarEntry()) != null; ) {
        out.putNextEntry(je);
        for (int nr; 0 < (nr = in.read(buffer)); ) {
            out.write(buffer, 0, nr);
        }
    }
    in.close();
    markJarFile(out);  // add PACK200 comment
}
 

import java.util.jar.JarInputStream; //导入方法依赖的package包/类
private static Set<Class<?>> getFromJARFile(final String jar, final String packageName)
        throws ClassNotFoundException, IOException {

    final Set<Class<?>> classes = new HashSet<Class<?>>();
    final JarInputStream jarFile = new JarInputStream(new FileInputStream(jar));
    JarEntry jarEntry;
    do {
        jarEntry = jarFile.getNextJarEntry();
        if (jarEntry != null) {
            String className = jarEntry.getName();
            if (className.endsWith(".class")) {
                className = stripFilenameExtension(className);
                if (className.startsWith(packageName)) {
                    classes.add(Class.forName(className.replace('/', '.')));
                }
            }
        }
    }
    while (jarEntry != null);
    jarFile.close();
    return classes;
}
 

import java.util.jar.JarInputStream; //导入方法依赖的package包/类
private ArrayList<String> getClasses(File jar) {
    ArrayList<String> classes = new ArrayList<String>();
    try {
        JarInputStream jarStream = new JarInputStream(new FileInputStream(jar));
        JarEntry jarEntry;
        while (true) {
            jarEntry = jarStream.getNextJarEntry();
            if (jarEntry == null)
                break;
            if (jarEntry.getName().endsWith(".class")) {
                classes.add(jarEntry.getName());
            }
        }
        jarStream.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return classes;
}
 

import java.util.jar.JarInputStream; //导入方法依赖的package包/类
private List<String> jar(JarInputStream jarStream) throws IOException {
    List<String> classNames = new ArrayList<>();

    JarEntry entry;
    while ((entry = jarStream.getNextJarEntry()) != null) {
        if (entry.isDirectory() || !entry.getName().endsWith(".class")) {
            continue;
        }
        String className = entry.getName();
        className = className.replaceFirst(".class$", "");

        //war files are treated as .jar files, so takeout WEB-INF/classes
        className = StringUtils.removeStart(className, "WEB-INF/classes/"); 

        className = className.replace('/', '.');
        classNames.add(className);
    }

    return classNames;
}
 

import java.util.jar.JarInputStream; //导入方法依赖的package包/类
/**
 * @return The list of paths of files stored in this Jar.
 */
public List<String> getContentsFromJarfile() {
    JarInputStream jarIn = JarReader.openJar(m_jarPath);
    List<String> files = new ArrayList<String>();
    try {
        JarEntry catEntry = null;
        while ((catEntry = jarIn.getNextJarEntry()) != null) {
            files.add(catEntry.getName());
        }
    } catch (Exception ex) {
        return null;
    }
    return files;
}
 

import java.util.jar.JarInputStream; //导入方法依赖的package包/类
/**
 * List the names of the entries in the given {@link JarInputStream} that begin with the
 * specified {@code path}. Entries will match with or without a leading slash.
 *
 * @param jar  The JAR input stream
 * @param path The leading path to match
 * @return The names of all the matching entries
 * @throws IOException If I/O errors occur
 */
protected List<String> listResources(JarInputStream jar, String path) throws IOException {
    // Include the leading and trailing slash when matching names
    if (!path.startsWith("/")) {
        path = "/" + path;
    }
    if (!path.endsWith("/")) {
        path = path + "/";
    }

    // Iterate over the entries and collect those that begin with the requested path
    List<String> resources = new ArrayList<String>();
    for (JarEntry entry; (entry = jar.getNextJarEntry()) != null; ) {
        if (!entry.isDirectory()) {
            // Add leading slash if it's missing
            String name = entry.getName();
            if (!name.startsWith("/")) {
                name = "/" + name;
            }

            // Check file name
            if (name.startsWith(path)) {
                if (log.isDebugEnabled()) {
                    log.debug("Found resource: " + name);
                }
                // Trim leading slash
                resources.add(name.substring(1));
            }
        }
    }
    return resources;
}
 

import java.util.jar.JarInputStream; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private static List<Class<Class>> extractClassesFromJAR(File jar, ClassLoader cl) throws IOException { 
    List<Class<Class>> classes = new ArrayList<Class<Class>>();
    JarInputStream jaris = new JarInputStream(new FileInputStream(jar));
    JarEntry ent = null;
    while ((ent = jaris.getNextJarEntry()) != null) {
        if (ent.getName().toLowerCase().endsWith(".class")) {
            try {
                Class<Class> cls = (Class<Class>) cl.loadClass(ent.getName().substring(0, ent.getName().length() - 6).replace('/', '.'));
                if (JPluginLoader.isPluggableClass(cls)) {
                    classes.add((Class<Class>)cls);
                }
            } catch (ClassNotFoundException e) {
                String msg = "";
                if(lang != null) {
                    msg = String.format(lang.getProperty("cant_load_class", "Could not load Class \"%s\""), ent.getName());
                } else {
                    msg = "Can't load Class " + ent.getName();
                }
                if(logger != null) {
                    logger.logErr(msg, false);
                } else {
                    System.err.println(msg);
                }
                e.printStackTrace();
            }
        }
    }
    jaris.close();
    return classes;
}
 

import java.util.jar.JarInputStream; //导入方法依赖的package包/类
public static List<String> findFile(String fileName, URL url) throws Exception {
    JarInputStream jarInputStream = new JarInputStream(url.openStream());
    for (JarEntry e; (e = jarInputStream.getNextJarEntry()) != null;) {
        Path path = Paths.get(e.getName());
        if (path.getFileName().toString().equals(fileName)) {
            List<String> lines = new ArrayList<>();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader
                    (jarInputStream));
            lines.addAll(bufferedReader.lines().collect(Collectors.toList()));
            return lines;
        }
    }
    return new ArrayList<>();
}
 

import java.util.jar.JarInputStream; //导入方法依赖的package包/类
static boolean jarContains(JarInputStream jis, String entryName)
    throws IOException
{
    JarEntry e;
    boolean found = false;
    while((e = jis.getNextJarEntry()) != null) {
        if (e.getName().equals(entryName))
            return true;
    }
    return false;
}
 

import java.util.jar.JarInputStream; //导入方法依赖的package包/类
static boolean jarContains(JarInputStream jis, String entryName)
    throws IOException
{
    JarEntry e;
    while((e = jis.getNextJarEntry()) != null) {
        if (e.getName().equals(entryName))
            return true;
    }
    return false;
}
 

import java.util.jar.JarInputStream; //导入方法依赖的package包/类
/**
 * Write the required spring-boot-loader classes to the JAR.
 * @throws IOException if the classes cannot be written
 */
public void writeLoaderClasses() throws IOException {
	URL loaderJar = getClass().getClassLoader().getResource(NESTED_LOADER_JAR);
	JarInputStream inputStream = new JarInputStream(
			new BufferedInputStream(loaderJar.openStream()));
	JarEntry entry;
	while ((entry = inputStream.getNextJarEntry()) != null) {
		if (entry.getName().endsWith(".class")) {
			writeEntry(entry, new InputStreamEntryWriter(inputStream, false));
		}
	}
	inputStream.close();
}