Thread: JarInputStream

I'm confused with the JarInputStream class.

JarInputStream takes in an InputStream, but an InputStream of what? Is it the Jar file as an InputStream? It cant be the files inside as an InputStream because isnt that what getNextEntry() and getNextJarEntry() methods are for?

If it is supposed to be an InputStream of the Jar, how the heck to I get that? Specifically, I am trying to get the InputStream of the Jar that is being executed to run the program so I can get particular JarEntries inside of it.

I could use some quick help. Any information is appreciated.

Not sure what you are asking. You don't execute a jar, you execute a class file that is in a jar

Ok, I meant the I want to access files within the Jar that contains the class that is being executed. I am attempting to access some .class files that will be used to create 3 unique Jars. In order to do that, I believe I need to be able to access those class files as a Stream, as I think that is the only way. From there, I am wanting to grab predetermined class files from the jar is has the class that is being executed and create executable jars with them.

I'll review the code you posted when I get to work in an hour and I have time to really analyze it.

Ok, I'm completely confused about the whole getResource(String) method. I attempted what you did with the getClass().getResource(args[0]); but I got an index out of bounds exception.

Ok, I actually figured some of this out. Here is the method I made that at least appears to work small-scale, but I can't test it full-scale until I figure out my next problem:

    public void addStream(String source, JarOutputStream target) throws IOException
    {
    	JarEntry t = new JarEntry(source);
		target.putNextEntry(t);
        BufferedInputStream in = new BufferedInputStream(getClass().getResourceAsStream(source));
        byte[] buffer = new byte[1024];
        while (true)
        {
        	int count = in.read(buffer);
        	if (count == -1)
        		break;
       		target.write(buffer, 0, count);
       	}
        target.closeEntry();
        in.close();
    }

My next issue is: How can I get a list or something of the .class files in the jar that I am getting my class files from? The reason I need that is because I need to be able to find the unknown amount of .class files that contain the name of: Class$X$X.class where X a random number. For the usual directory, I just used the file.list() method and went through the String[] it returned. But I don't know how to do the same for a .jar or .zip directory. It wouldn't be an issue if I knew every time where the .jar file would be (I could use the JarFile(String) constructor and methods), but it could be located anywhere and that can change.

I attempted what you did with the getClass().getResource(args[0]);

Look at the commented out main method. It shows how to use the class.


I wrote a project for searching thru the contents of a jar file for entries containing a String. I had a Search program for files in folders and I wanted to use the same code for searching in a jar file without having to change any logic. So I put this together so the search code would think the jar was a folder with subfolders.

Here's a class that may have some ideas for you:

// JarTreeElement - Defines objects to hold contents of a jar in a folder hierarchy
/*  Changes
*  31 July 2005 - Require both debug switches for Added ... message
    6 Aug  2005 - Added debug info
*/
 
package NormsTools.InJar;
 
 
import java.util.*;
import java.util.jar.*;
import java.io.*;
 
public class JarTreeElement {
 
   public final static String Version = "JarTreeElement 6 Aug 2005";
 
   final public static String PathSep = "/";
   final public static char PathSepChar = '/';
 
   // Define properties
   String   name;
   String   pathToFile = "";
   boolean  isDirectory;
   long     size;
   long     dateLastModified;
 
   public JarTreeElement root;
   public JarFile jarFile;             // Only in root??
   TreeMap  contents;
 
   final static boolean debug = false; //true;               // Control debug output
 
   //Constructors ------------------------------------------------------------
   public JarTreeElement(String name) {
      this.name = name;
   } // end Constructor
   public JarTreeElement(String name, String path) throws Exception {
      this.name = name;
      loadTree(this, path);
   } // end Constructors
 
   public String getPath() {
      if(name.equals(FileInJar.RootName))
         return "";                    //Don't want path to jar file!  
      else
         return pathToFile;
   }
 
 
   //-------------------------------------------------------------------------
   // Parse jar file entries into a tree structure
   public static void loadTree(JarTreeElement root, String path) throws Exception {
      root.contents = new TreeMap();
      root.pathToFile = path;          // NB root has path to jar file!
      root.isDirectory = true;
      root.contents.put(FileInJar.RootName, root); // pointer to self
 
      try{
         JarFile jf = new JarFile(path);
         root.jarFile = jf;            // Save in root!
         File f = new File(path);
         root.dateLastModified = f.lastModified();
         root.size = jf.size();        // Number of entries
 
 
         // Go thru all the elements in the Jar and place them in tree
         Enumeration jfEn = jf.entries();
         while(jfEn.hasMoreElements()) {
            JarEntry jarEnt = (JarEntry)jfEn.nextElement();
            String jarEntNm = jarEnt.getName();
            if(debug && false)
               System.out.println(jarEntNm);   
               /*
               META-INF/
               META-INF/MANIFEST.MF
               xxx/Hello.class
               xxx/Hello.java
               xxx/xxx/
               xxx/xxx/Hello.class
               xxx/xxx/Moved.java
               xxx/yyy/
               xxx/yyy/Hello.java
               xxx/yyy/Hello.class
               */         
            JarTreeElement thisJTE = null,
                           currJTE = root;  // Start at top level
            String pPath = "";         // Partial path that will be built
            boolean isDir = jarEntNm.endsWith(PathSep);
            StringTokenizer st = new StringTokenizer(jarEntNm, PathSep);
 
            while(st.hasMoreTokens()) {
               String nxtNm = st.nextToken();
               pPath += nxtNm + PathSep;
               // Now add this to contents
               thisJTE = (JarTreeElement)currJTE.contents.get(nxtNm);
               if(thisJTE == null) {
                  thisJTE = new JarTreeElement(nxtNm);
                  thisJTE.root = root;
                  if(isDir || st.hasMoreTokens()) {
                     // its a directory
                     thisJTE.pathToFile = pPath;
                     thisJTE.isDirectory = true;
                     thisJTE.contents = new TreeMap(); // we'll need this
                     if(FileInJar.debug && debug)
                        System.out.println("loadTree()-Added dir " + nxtNm + " to " + currJTE.name);
                  }else {
                     // Not a directory - must be a file
                     thisJTE.pathToFile = jarEntNm;
                     thisJTE.size = jarEnt.getSize();
                     thisJTE.dateLastModified = jarEnt.getTime();
                     if(FileInJar.debug && debug)
                        System.out.println("loadTree()-Added file " + nxtNm + " to " + currJTE.name);
                  }
                  currJTE.contents.put(nxtNm, thisJTE);  // put new entry in table
 
               } else {
                  // found JTE
                  if(!st.hasMoreTokens()) {
                     System.err.println("loadTree()-Duplicate path to " + jarEntNm + " " + pPath);
                  }
               }
               currJTE = thisJTE;      // Advance down path
            } // end while() thru tokens
 
         } // end while() thru jar elements
      }catch(Exception ex) {
         ex.printStackTrace();
         throw ex;
      }
      return;
   } // end loadTree()
 
   //---------------------------------------------------------------------------
   public static JarTreeElement findJTE(JarTreeElement rootJTE, String path) {
      JarTreeElement currJTE = rootJTE;
      StringTokenizer st = new StringTokenizer(path, PathSep);
      while(st.hasMoreTokens()) {
         String nxtPE = st.nextToken(); // next path element
         if(currJTE.contents == null) {
            System.err.println("findJTE() null contents for " + currJTE.name + " with path>" + path);
            return null;
         }
         JarTreeElement nxtJTE = (JarTreeElement)currJTE.contents.get(nxtPE);
         if (nxtJTE == null) {
            System.err.println("findJTE()>>Element not found: " + nxtPE +  " in path " + path
                              + "\n    looking in: " + rootJTE);
            return null;
         }
         currJTE = nxtJTE;
      } // end while()
      return currJTE;
   } // end findJTE()
 
   //----------------------------------------------------------------------
   public String[] listContents() {
      if(contents == null) {
         System.out.println("listContents() ????contents are null");
         return null;
      }
      Set aSet = contents.keySet();
//      System.out.println("aSet " + aSet);
      aSet.remove(FileInJar.RootName);  // don't want this returned
      return (String[])aSet.toArray(new String[0]);
   } // end listContents
 
   //---------------------------------------------------------------------
   public String toString() {
      return name + " <path=" + pathToFile + ">";
   }
 
   //-----------------------------------------
   public static String showContents(JarTreeElement root) {
      if(root.contents == null)
         return "No contents";
 
      String leadPad = "  ";
      String retStr = "";
      String[] ent = root.listContents();
 
      for(int i=0; i < ent.length; i++) {
         retStr += ent[i] + "\n";
         JarTreeElement jte = findJTE(root, ent[i]);
         if(jte.contents != null) {
            String[] ent1 = jte.listContents();
            retStr += leadPad + NormsTools.ArrayUtil.toString(ent1) + "\n";
         }
      } // end for(i) 
      return retStr;
   } // end showContents()
 
   // internal method for building path display
   private String showContents(String[] ents, String lPad) {
      String retStr = "";
      return retStr;
   }
 
   //----------------------------------------------------
   // Following for testing - Comment out when done
/*   public static void main(String[] args) {
      JarTreeElement root = null;
      try {
         root = new JarTreeElement("<Root>", "Testing.jar");
      }catch(Exception ex) { 
         ex.printStackTrace();
      }
//      loadTree(root, "Testing.jar");
      System.out.println(" Show contents\n" + showContents(root));
      System.out.println("List for xxx/xxx/:" 
               + NormsTools.ArrayUtil.toString(findJTE(root, "xxx/xxx/").listContents()));
      JarTreeElement jte = findJTE(root, "xxx/xxx/Movedxx.java");
      System.out.println("full path " + jte.getPath());
      System.exit(0);
   } // end main */
} // end class
/*   Output >>>>>>>>.
Running: java NormsTools.InJar.JarTreeElement 
 
 Show contents
META-INF
  [MANIFEST.MF]
xxx
  [Hello.class, Hello.java, xxx, yyy]
 
List for xxx/xxx/:[Helloxx.class, Movedxx.java]
full path xxx/xxx/Movedxx.java
 
0 error(s)
*/

It uses this class:

// FileInJar - wraps File class for files in Jars
/*  Changes
  5 Aug 2005 - New Constructor (File, String)
  6 Aug 2005 - Changed toString() to use ourJTE; Added getJTE()
  5 Oct 2006 - Added lastModified()
*/
 
package NormsTools.InJar;
 
import java.io.*;
import java.util.*;
 
public class FileInJar extends File {
 
   public final static String Version = "FileInJar 5 Oct 2006";
 
   // Global - defines location of all files from now on
   final public static String RootName = "<root>";
 
   public static JarTreeElement root;  // If we're in a jar file
   public static boolean inJar = false;
 
   //----------------------------------------------------
   // Save the root of tree of jar files
   public static void setRoot(JarTreeElement rt) {
      root = rt;                       // Save address
      inJar = true;
   }  // end setRoot()
 
   JarTreeElement ourJTE;              // Our subtree
 
   public static boolean debug = false;  // globally control debug output
 
   //-------------------------------------------------
   // Get an object to read file, depending on ...
   public static File getFile(String fn) {
      if(inJar)
         return new FileInJar(fn);
      else 
         return new File(fn);
   } // end getFile()
   public static File getFile(String dir, String fn) {
      if(inJar)
         return new FileInJar(dir, fn);
      else 
         return new File(dir, fn);
   } // end getFile()
 
   // Constructors ----------------- -----------------------------
   public FileInJar(File dir, String fn) {
      super(dir, fn);
      if(debug)
         System.out.println("FIJ3 for " + dir + " <> " + fn);
      if(inJar) {
         String newDir = fixDir(dir.getAbsolutePath());
         if(newDir.length() > 0 && !newDir.endsWith(JarTreeElement.PathSep)) {
            newDir += JarTreeElement.PathSep;
         }
         ourJTE = JarTreeElement.findJTE(root, newDir+fn);
         if(debug || ourJTE == null) {
            System.out.println("FIJ3-ourJTE: " + ourJTE + " for " + newDir+fn 
                                             + " (" + dir + ")");
         }
      }
   } // end Constructor3
   public FileInJar(String dir, String fn) {
      super(dir, fn);
      if(debug)
         System.out.println("FIJ2 for " + dir + " <> " + fn);
      if(inJar) {
         String newDir = fixDir(dir);
         if(newDir.length() > 0 && !newDir.endsWith(JarTreeElement.PathSep)) {
            newDir += JarTreeElement.PathSep;
         }
         ourJTE = JarTreeElement.findJTE(root, newDir+fn);
         if(debug || ourJTE == null) {
            System.out.println("FIJ2-ourJTE: " + ourJTE + " for " + newDir+fn 
                                             + " (" + dir + ")");
         }
      }
   } // end Constructor1
   public FileInJar(String s) {
      super(s);
      if(debug)
         System.out.println("FIJ1 for " + s);
      if(inJar) {
         String newS = fixDir(s);
         ourJTE = JarTreeElement.findJTE(root, newS);
         if(debug || ourJTE == null)
            System.out.println("FIJ1-ourJTE: " + ourJTE + " for " + newS + " (" + s + ")");
      }
   } // end Constructor2
 
   // Strip leading <root> and trailing \
   private String fixDir(String dir) {
      if(dir.startsWith(RootName))
         dir = dir.substring(RootName.length()); // strip rootname
      if(dir.endsWith(File.separator))
         dir = dir.substring(0, dir.length()-1);
      return dir.replace(File.separatorChar, JarTreeElement.PathSepChar);
   }
 
   public JarTreeElement getJTE() {
      return ourJTE;
   }
   //- - - - - - - - - - - - - - - - - - - - - - - - -
   // Override the File methods we use that are different for in jar
   public String[] list() {
      if(inJar) {
         return ourJTE.listContents();
      }else {
         return super.list();
      }
   } // end list()
   public String[] list(FilenameFilter ff) {
      if(inJar) {
         // Following copied from Sun's File.java
      	String names[] = ourJTE.listContents();
      	if ((names == null) || (ff == null)) {
      	    return names;
      	}
      	ArrayList v = new ArrayList();
      	for (int i = 0 ; i < names.length ; i++) {
      	    if (ff.accept(this, names[i])) {
      		    v.add(names[i]);
      	    }
      	}
      	return (String[])(v.toArray(new String[0]));
      }else {
         return super.list(ff);
      }
   } // end list(ff)
 
   public long lastModified() {
      if(inJar) {
         return ourJTE.dateLastModified;
      }else {
         return super.lastModified();
      }
   } // end lastModified()
 
   public boolean isFile() {
      if(inJar) {
         return !ourJTE.isDirectory;
      }else
         return super.isFile();
   }
 
   public boolean isDirectory() {
      if(inJar) {
         return ourJTE.isDirectory;
      }else
         return super.isDirectory();
   }
 
   public boolean exists() {
      if(inJar) {
         return ourJTE != null;        // If found in tree
      }else
         return super.exists();
   }
 
   public String toString() {
      if(inJar)
         return "<InJar> " + ourJTE;
      else
         return super.toString();
   }
 
   public String getAbsolutePath() {
      if(inJar)
         return ourJTE.getPath().replace(File.separatorChar, JarTreeElement.PathSepChar);
      else 
         return super.getAbsolutePath();
   }
} // end class FileInJar