[Java] दर्जनों जेएआर फाइलों के अंदर कहीं कक्षा खोजें?


Answers

यूनिक्स

jar (या unzip -v ), grep , और कमांड का प्रयोग करें।

उदाहरण के लिए, निम्नलिखित सभी वर्ग फ़ाइलों को सूचीबद्ध करेगा जो किसी दिए गए नाम से मेल खाते हैं:

for i in *.jar; do jar -tvf "$i" | grep -Hsi ClassName && echo "$i"; done

यदि आप उन जावा अभिलेखागार की पूरी सूची जानते हैं जिन्हें आप खोजना चाहते हैं, तो आप उन्हें सभी को एक ही निर्देशिका में (प्रतीकात्मक) लिंक का उपयोग करके रख सकते हैं।

या JAR फ़ाइल को खोजने के लिए find (केस संवेदनात्मक) का उपयोग करें जिसमें दिया गया क्लास नाम है:

find path/to/libs -name '*.jar' -exec grep -Hls ClassName {} \;

उदाहरण के लिए, IdentityHashingStrategy HashingStrategy युक्त संग्रह का नाम ढूंढने के लिए:

$ find . -name "*.jar" -exec grep -Hsli IdentityHashingStrategy {} \;
./trove-3.0.3.jar

यदि जेएआर सिस्टम में कहीं भी हो सकता है और locate कमांड उपलब्ध है:

for i in $(locate "*.jar");
  do echo $i; jar -tvf $i | grep -Hsi ClassName;
done

विंडोज

कमांड प्रॉम्प्ट खोलें, जेएआर फाइल वाली निर्देशिका (या पूर्वज निर्देशिका) में बदलें, फिर:

for /R %G in (*.jar) do @jar -tvf "%G" | find "ClassName" > NUL && echo %G

यहां देखिए यह कैसे काम करता है:

  1. for /R %G in (*.jar) do - सभी जेएआर फाइलों पर लूप, पुनरावर्ती निर्देशिकाओं को पार करना; फ़ाइल नाम को% जी में संग्रहीत करें।
  2. @jar -tvf "%G" | - दिए गए संग्रह में सभी फ़ाइल नामों को सूचीबद्ध करने के लिए जावा आर्काइव कमांड चलाएं, और परिणाम मानक आउटपुट में लिखें; @ प्रतीक कमांड के आमंत्रण को मुद्रित करता है।
  3. दिए गए वर्ग के नाम के find "ClassName" > NUL - जार कमांड के आउटपुट से पाइप किए गए मानक इनपुट को खोजें; यह ERRORLEVEL को 1 से सेट करेगा यदि कोई मैच है (अन्यथा 0)।
  4. && echo %G ERRORLEVEL && echo %G - iff ERRORLEVEL गैर-शून्य है, जावा संग्रह फ़ाइल नाम मानक आउटपुट (कंसोल) पर लिखें।

वेब

एक खोज इंजन का उपयोग करें जो JAR फ़ाइलों को स्कैन करता है

Question

आपको जार फ़ाइलों के अंदर एक विशेष श्रेणी का नाम कैसे मिलेगा?

(वास्तविक वर्ग का नाम खोज रहे हैं, न कि कक्षाएं जो इसका संदर्भ देती हैं।)







जब मैं इस समस्या से आया तो मुझे ऐसा करने के लिए उपयोगिता के बारे में पता नहीं था, इसलिए मैंने निम्नलिखित लिखा:

public class Main {

    /**
     * 
     */
    private static String CLASS_FILE_TO_FIND =
            "class.to.find.Here";
    private static List<String> foundIn = new LinkedList<String>();

    /**
     * @param args the first argument is the path of the file to search in. The second may be the
     *        class file to find.
     */
    public static void main(String[] args) {
        if (!CLASS_FILE_TO_FIND.endsWith(".class")) {
            CLASS_FILE_TO_FIND = CLASS_FILE_TO_FIND.replace('.', '/') + ".class";
        }
        File start = new File(args[0]);
        if (args.length > 1) {
            CLASS_FILE_TO_FIND = args[1];
        }
        search(start);
        System.out.println("------RESULTS------");
        for (String s : foundIn) {
            System.out.println(s);
        }
    }

    private static void search(File start) {
        try {
            final FileFilter filter = new FileFilter() {

                public boolean accept(File pathname) {
                    return pathname.getName().endsWith(".jar") || pathname.isDirectory();
                }
            };
            for (File f : start.listFiles(filter)) {
                if (f.isDirectory()) {
                    search(f);
                } else {
                    searchJar(f);
                }
            }
        } catch (Exception e) {
            System.err.println("Error at: " + start.getPath() + " " + e.getMessage());
        }
    }

    private static void searchJar(File f) {
        try {
            System.out.println("Searching: " + f.getPath());
            JarFile jar = new JarFile(f);
            ZipEntry e = jar.getEntry(CLASS_FILE_TO_FIND);
            if (e == null) {
                e = jar.getJarEntry(CLASS_FILE_TO_FIND);
                if (e != null) {
                    foundIn.add(f.getPath());
                }
            } else {
                foundIn.add(f.getPath());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}



grep -l "classname" *.jar

आपको जार का नाम देता है

find . -name "*.jar" -exec jar -t -f {} \; | grep  "classname"

आपको कक्षा का पैकेज देता है




यह मिनीगब्लू (विंडोज़ बैश पर्यावरण) ~ गीटबैश में अच्छी तरह से काम करता है

इस कार्य को अपनी होम निर्देशिका में अपनी .bashrc फ़ाइल में रखें:

# this function helps you to find a jar file for the class
function find_jar_of_class() {
  OLD_IFS=$IFS
  IFS=$'\n'
  jars=( $( find -type f -name "*.jar" ) )
  for i in ${jars[*]} ; do 
    if [ ! -z "$(jar -tvf "$i" | grep -Hsi $1)" ] ; then
      echo "$i"
    fi
   done 
  IFS=$OLD_IFS
}






किसी विशेष श्रेणी के लिए किसी दिए गए निर्देशिका में सभी जार फ़ाइलों को खोजने के लिए, आप यह कर सकते हैं:

ls *.jar | xargs grep -F MyClass

या, भी सरल,

grep -F MyClass *.jar

आउटपुट इस तरह दिखता है:

Binary file foo.jar matches

यह बहुत तेज़ है क्योंकि -एफ विकल्प का अर्थ निश्चित स्ट्रिंग के लिए खोज है, इसलिए यह प्रत्येक grep आमंत्रण के लिए रेगेक्स इंजन लोड नहीं करता है। यदि आपको आवश्यकता है, तो आप हमेशा -F विकल्प को छोड़ सकते हैं और regexes का उपयोग कर सकते हैं।




unzip (zipinfo) का उपयोग कर एक bash script समाधान। Ubuntu 12 पर परीक्षण किया गया।

#!/bin/bash

# ./jarwalker.sh "/a/Starting/Path" "aClassName"

IFS=$'\n'
jars=( $( find -P "$1" -type f -name "*.jar" ) )

for jar in ${jars[*]}
    do
        classes=( $( zipinfo -1 ${jar} | awk -F '/' '{print $NF}' | grep .class | awk -F '.' '{print $1}' ) )
        if [ ${#classes[*]} -ge 0 ]; then
            for class in ${classes[*]}
                do
                    if [ ${class} == "$2" ]; then
                        echo "Found in ${jar}"
                    fi
                done
        fi
    done



अभी तक एक और उपकरण जोड़ने के लिए ... यह विंडोज के लिए एक बहुत ही सरल और उपयोगी उपकरण है। एक साधारण एक्सई फ़ाइल जिस पर आप क्लिक करते हैं, इसे एक क्लास नाम में खोजने के लिए एक निर्देशिका दें और उसे उस कक्षा में जार फ़ाइल मिलेगी। हाँ, यह रिकर्सिव है।

http://sourceforge.net/projects/jarfinder/




मैंने हमेशा विंडोज़ पर इसका इस्तेमाल किया है और यह असाधारण रूप से अच्छी तरह से काम करता है।

findstr /s /m /c:"package/classname" *.jar, where

findstr.exe विंडोज और पैराम्स के साथ मानक आता है:

  • / एस = recursively
  • / m = यदि कोई मिलान होता है तो केवल फ़ाइल नाम मुद्रित करें
  • / सी = शाब्दिक स्ट्रिंग (इस मामले में आपके पैकेज का नाम + वर्ग नाम '/' से अलग होता है)

उम्मीद है कि यह किसी की मदद करता है।




बस FindClassInJars उपयोग का उपयोग करें, यह एक साधारण स्विंग प्रोग्राम है, लेकिन उपयोगी है। आप http://code.google.com/p/find-class-in-jars/ पर स्रोत कोड देख सकते हैं या जार फ़ाइल डाउनलोड कर सकते हैं




उपरोक्त सभी में जोड़ने के लिए एक बात: यदि आपके पास जार निष्पादन योग्य उपलब्ध नहीं है (यह जेडीके के साथ आता है लेकिन जेआरई के साथ नहीं), तो आप एक ही चीज़ को पूरा करने के लिए अनजिप (या विनज़िप, या जो भी) का उपयोग कर सकते हैं।




पार्टी के लिए थोड़ा देर हो चुकी है, लेकिन फिर भी ...

मैं JarBrowser का उपयोग कर रहा हूं यह JarBrowser के लिए कि कौन सा जार एक विशेष वर्ग मौजूद है। इसे जीयूआई का उपयोग करना आसान हो गया है जो आपको चयनित पथ में सभी जारों की सामग्री को ब्राउज़ करने की अनुमति देता है।




आप locate और grep उपयोग कर सकते हैं:

locate jar | xargs grep 'my.class'

सुनिश्चित करें कि आप locate से पहले updatedb चलाते हैं।




ग्रहण में आप पुराने लेकिन अभी भी प्रयोग योग्य प्लगइन jarsearch उपयोग कर सकते हैं






Links