दर्जनों JAR फ़ाइलों के अंदर कहीं एक वर्ग का पता लगाएं?

Question

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

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

Comments

मैं इनमें से किसी भी उत्तर के बारे में नहीं जानता, लेकिन मेरे लिए क्या काम करता है अगर आप एक काम की परियोजना में कई JAR फ़ाइलों के साथ उपयोग किए जाने वाले वर्ग को देखते हैं, तो अपने कर्सर को वर्ग के नाम पर रखें, उस पर राइट क्लिक करें, और ओपन घोषणा पर क्लिक करें ( F3); फिर इसे JAR फ़ाइल को नए टैब के शीर्ष पर सूचीबद्ध करना चाहिए।

— एंड्रयू

Answer 1

ग्रहण इसे कर सकते हैं, बस एक (अस्थायी) परियोजना बनाएं और अपने पुस्तकालयों को परियोजनाओं के वर्गपथ पर रखें। तब आप आसानी से कक्षाएं पा सकते हैं।

एक और उपकरण, जो मेरे दिमाग में आता है, वह है जावा डिकम्पॉइलर। यह एक ही बार में बहुत सारे जार खोल सकता है और कक्षाओं को भी खोजने में मदद करता है।

Comments

और Ctrl + Shift + T की मदद से

— कृष्णप्रभाकर

Answer 2

यूनिक्स

लिनक्स पर, अन्य यूनिक्स वेरिएंट, विंडोज पर गेट बैश, या साइगविन, और jar(या unzip -v) grep, और findकमांड का उपयोग करते हैं ।

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

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

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

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

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

उदाहरण के लिए, संग्रह वाले नाम को खोजने के लिए IdentityHashingStrategy:

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

अगर JAR सिस्टम में कहीं भी हो सकता है और locateकमांड उपलब्ध है:

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

एक सिंटैक्स भिन्नता:

find path/to/libs -name '*.jar' -print | \
  while read i; do jar -tvf "$i" | grep -Hsi ClassName && echo "$i"; done 

खिड़कियाँ

एक कमांड प्रॉम्प्ट खोलें , निर्देशिका (या पूर्वज निर्देशिका) को JAR फ़ाइलों से युक्त करें, फिर:

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

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

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

वेब

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

Comments

हाँ -l आपको वह देगा, लेकिन बहुत उपयोगी नहीं है जब स्टड से इसका इनपुट मिल रहा हो।

— जॉर्ज आर्महोल्ड

Answer 3

कुछ समय पहले, मैंने इसके लिए एक कार्यक्रम लिखा: https://github.com/javalite/jar-explorer

Comments

किसी भी प्रकार की फ़ाइल पाता है, न कि केवल कक्षाएं। फ़ाइल सामग्री देखने के लिए डबल-क्लिक करें। हाँ, अब मैं अपने सभी वसंत-स्कीमाओं को देख सकता हूं।

— क्रिस नू

बहुत बढ़िया। धन्यवाद;)

— १२:०२ पर LppEdd

Answer 4

grep -l "classname" *.jar

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

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

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

Comments

यह grep -lir "classname" * होना चाहिए।।

— लियोनार्ड सेर्स

Answer 5

#!/bin/bash

pattern=$1
shift

for jar in $(find $* -type f -name "*.jar")
do
  match=`jar -tvf $jar | grep $pattern`
  if [ ! -z "$match" ]
  then
    echo "Found in: $jar"
    echo "$match"
  fi
done

Comments

महान ! मैं एक प्रणाली है कि जार नहीं था (रास्ते में नहीं, यह है कि) पर इसका इस्तेमाल करने की जगह तो मैं था jar -tvfके साथ unzip -l।

— ixe013

Answer 6

दिए गए तार से मेल खाने वाले जार का पता लगाने के लिए:

find . -name \*.jar -exec grep -l YOUR_CLASSNAME {} \;

Comments

यह केवल कक्षा ही नहीं, बल्कि कक्षा के संदर्भ भी पाता है।

— ट्रेवर रॉबिन्सन

Answer 7

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

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();
        }
    }

}

Answer 8

दो अलग-अलग उपयोगिताओं को भी "जारस्कैन" कहा जाता है जो वास्तव में आपके लिए पूछ रहे हैं: जारस्कैन (inetfeedback.com) और जारस्कैन (java.net)

Answer 9

user1207523 की स्क्रिप्ट मेरे लिए ठीक काम करती है। यहां एक संस्करण है जो सरल विस्तार के बजाय खोज का उपयोग करके जार फ़ाइलों की खोज करता है;

#!/bin/bash
for i in `find . -name '*.jar'`; do jar -tf "$i" | grep $1 | xargs -I{} echo -e "$i : {}" ; done

Answer 10

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

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

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

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

आशा है कि यह किसी की मदद करता है।

Answer 11

एक bash scriptसमाधान का उपयोग कर unzip (zipinfo)। पर परीक्षण किया गया 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

Comments

यह स्क्रिप्ट संगत नहीं है

— kisp

Answer 12

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

ls *.jar | xargs grep -F MyClass

या, और भी सरल,

grep -F MyClass *.jar

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

Binary file foo.jar matches

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

Answer 13

मुझे यह नया तरीका लगा

bash $ ls -1  | xargs -i -t jar -tvf '{}'| grep Abstract
jar -tvf activation-1.1.jar
jar -tvf antisamy-1.4.3.jar
  2263 Thu Jan 13 21:38:10 IST 2011 org/owasp/validator/html/scan/AbstractAntiSamyScanner.class
...

यदि यह पाया जाता है तो जार और वर्ग को सूचीबद्ध करता है, यदि आप चाहते हैं कि आप ls -1 * .jar या xargs के इनपुट को कमांड HTH किसी के साथ दे सकते हैं।

Comments

धन्यवाद, मैं इसे इस तरह से सुधारता हूं: ls -1 * .jar | xargs -i -t jar -tvf '{}' | grep Abstract

— Jérôme B

Answer 14

क्लासफाइंडर एक ऐसा प्रोग्राम है जो इस समस्या को हल करने के लिए बनाया गया है। यह आपको एक पैटर्न से मेल खाते वर्ग के सभी उदाहरणों को खोजने के लिए निर्देशिकाओं और जार फ़ाइलों के माध्यम से पुन: खोज करने की अनुमति देता है। यह जावा में लिखा है, अजगर नहीं। यह एक अच्छा जीयूआई है जो इसे उपयोग करना आसान बनाता है। और यह तेजी से चलता है। यह रिलीज़ एक रन जार में precompiled है, इसलिए आपको इसे स्रोत से बनाने की आवश्यकता नहीं है।

इसे यहाँ डाउनलोड करें: ClassFinder 1.0

Answer 15

JBoss टैटलेट की जांच करें ; हालाँकि मैंने इसे कभी भी व्यक्तिगत रूप से उपयोग नहीं किया है, यह आपको आवश्यक उपकरण लगता है।

Answer 16

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

Answer 17

यकीन नहीं होता कि यहां की स्क्रिप्ट्स ने कभी मेरे लिए काम क्यों नहीं किया। यह काम:

#!/bin/bash
for i in *.jar; do jar -tf "$i" | grep $1 | xargs -I{} echo -e "$i : {}" ; done

Answer 18

जार फ़ाइल खोजने के लिए स्क्रिप्ट: find_jar.sh

IFS=$(echo -en "\n\b") # Set the field separator newline

for f in `find ${1} -iname *.jar`; do
  jar -tf ${f}| grep --color $2
  if [ $? == 0 ]; then
    echo -n "Match found: "
    echo -e "${f}\n"
  fi
done
unset IFS

उपयोग: ./find_jar.sh <शीर्ष-स्तरीय निर्देशिका जिसमें जार फाइलें> <वर्ग नाम खोजने के लिए> हैं

यह यहां दिए गए अधिकांश उत्तरों के समान है। लेकिन यह केवल फ़ाइल नाम को आउटपुट करता है, अगर grep कुछ पाता है। अगर आप grep आउटपुट को दबाना चाहते हैं, तो आप उसे / dev / null पर रीडायरेक्ट कर सकते हैं, लेकिन मैं grep के आउटपुट को देखना पसंद करता हूं, ताकि मैं आंशिक वर्ग के नाम का उपयोग कर सकूं और दिखाए गए आउटपुट की सूची में से सही का पता लगा सकूं।

वर्ग का नाम सरल वर्ग का नाम हो सकता है जैसे "स्ट्रिंग" या "java.lang.String" जैसे पूरी तरह से योग्य नाम।

Answer 19

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

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

Answer 20

JARs के एक फ़ोल्डर (और सबफ़ोल्डर) गुच्छा में एक वर्ग खोजने के लिए: https://jarscan.com/

Usage: java -jar jarscan.jar [-help | /?]
                    [-dir directory name]
                    [-zip]
                    [-showProgress]
                    <-files | -class | -package>
                    <search string 1> [search string 2]
                    [search string n]

Help:
  -help or /?           Displays this message.

  -dir                  The directory to start searching
                        from default is "."

  -zip                  Also search Zip files

  -showProgress         Show a running count of files read in

  -files or -class      Search for a file or Java class
                        contained in some library.
                        i.e. HttpServlet

  -package              Search for a Java package
                        contained in some library.
                        i.e. javax.servlet.http

  search string         The file or package to
                        search for.
                        i.e. see examples above

उदाहरण:

java -jar jarscan.jar -dir C:\Folder\To\Search -showProgress -class GenericServlet

Answer 21

आप शेल के एक बिट के साथ जार से भरी निर्देशिका में एक वर्ग पा सकते हैं:

वर्ग "FooBar" की तलाश में:

LIB_DIR=/some/dir/full/of/jarfiles
for jarfile in $(find $LIBDIR -name "*.jar"); do
   echo "--------$jarfile---------------"
   jar -tvf $jarfile | grep FooBar
done

Answer 22

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

Answer 23

बेशर्म आत्म संवर्धन, लेकिन आप लिखी गई उपयोगिता की कोशिश कर सकते हैं: http://sourceforge.net/projects/zfind

यह सबसे आम आर्काइव / कंप्रेस्ड फाइल्स (जार, जिप, टार, टैरगेज आदि) को सपोर्ट करता है और कई अन्य जार / जिप फाइंडर्स के विपरीत, नेस्टेड जिप फाइल्स (जिप के भीतर जिप, जार के भीतर जिप आदि) को अनलिमिटेड डेप्थ के लिए सपोर्ट करता है।

Answer 24

पार्टी में थोड़ा देर से, लेकिन फिर भी ...

मैं जारब्रोसर का उपयोग कर रहा हूं ताकि यह पता लगाया जा सके कि जार किस वर्ग में मौजूद है। GUI का उपयोग करना आसान हो गया है जो आपको चयनित मार्ग में सभी जार की सामग्री के माध्यम से ब्राउज़ करने की अनुमति देता है।

Answer 25

स्क्रिप्ट का पालन करने से आपको मदद मिलेगी

for file in *.jar
do
  # do something on "$file"
  echo "$file"
  /usr/local/jdk/bin/jar -tvf "$file" | grep '$CLASSNAME'
done

Answer 26

यह MinGW (विंडोज़ बैश वातावरण) ~ gitbash में अच्छी तरह से काम करता है

इस कार्य को अपनी। निर्देशिका में अपने .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
}

Answer 27

Grepj एक कमांड लाइन उपयोगिता है जो जार फ़ाइलों के भीतर कक्षाओं की खोज करने के लिए है। मैं उपयोगिता का लेखक हूं।

आप जैसे उपयोगिता को चला सकते हैं grepj package.Class my1.jar my2.war my3.ear

एकाधिक जार, कान, युद्ध फ़ाइलें प्रदान की जा सकती हैं। उन्नत उपयोग के लिए खोजे जाने वाले जार की सूची प्रदान करने के लिए खोज करें।

Answer 28

ग्रहण के लिए इस प्लगइन की जाँच करें जो आप जिस नौकरी की तलाश में हैं वह कर सकते हैं।

https://marketplace.eclipse.org/content/jarchiveexplorer

Answer 29

लिनक्स पर्यावरण के तहत आप निम्नलिखित कार्य कर सकते हैं:

$ find <base_dir> -name *.jar -print0 | xargs -0 -l jar tf | grep <name>

जहाँ नाम उस वर्ग फ़ाइल का नाम है जिसे आप base_dir पर निहित निर्देशिकाओं के पदानुक्रम में वितरित जार के अंदर देख रहे हैं ।

Answer 30

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

locate jar | xargs grep 'my.class'

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