Birçok jar dosyasının içinde belirli bir sınıf adını nasıl bulursunuz?

(Referans veren sınıfları değil, gerçek sınıf adını arıyorum.)

Eclipse bunu yapabilir, sadece (geçici) bir proje oluşturun ve kütüphanelerinizi projeler sınıf yoluna koyun. Sonra sınıfları kolayca bulabilirsiniz.

Aklıma gelen başka bir araç Java Decompiler. Aynı anda çok sayıda kavanoz açabilir ve sınıfları bulmaya da yardımcı olur.

Unix

Linux'ta, diğer Unix varyantları, Windows'ta Git Bash veya Cygwin, jar(veya unzip -v) grep, ve findkomutlarını kullanır.

Aşağıda, belirli bir adla eşleşen tüm sınıf dosyaları listelenir:

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

Aramak istediğiniz Java arşivlerinin tam listesini biliyorsanız, (sembolik) bağlantıları kullanarak hepsini aynı dizine yerleştirebilirsiniz.

Veya findbelirli bir sınıf adı içeren JAR dosyasını bulmak için (büyük / küçük harfe duyarlı olarak) kullanın:

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

Örneğin, aşağıdakileri içeren arşivin adını bulmak için IdentityHashingStrategy:

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

JAR sistemin herhangi bir yerinde olabilir ve locatekomut kullanılabilirse:

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

Bir sözdizimi varyasyonu:

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

pencereler

Bir komut istemi açın , JAR dosyalarını içeren dizine (veya ata dizinine) geçin, sonra:

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

Şöyle çalışır:

1. for /R %G in (*.jar) do- yinelenen dizinleri tüm JAR dosyaları üzerinde döngü; dosya adını saklayın %G.
2. @jar -tvf "%G" |- verilen arşivdeki tüm dosya adlarını listelemek ve sonuçları standart çıktıya yazmak için Java Archive komutunu çalıştırın; @komutası çağırma baskı sembol bastırır.
3. find "ClassName" > NUL- verilen sınıf adı için jar komutunun çıktısından alınan standart girdi araması; ERRORLEVELbir eşleşme varsa 1'e ayarlanır (aksi takdirde 0).
4. && echo %G- iff ERRORLEVELsıfırdan farklıysa , Java arşiv dosyasının adını standart çıktıya (konsol) yazın.

ağ

JAR dosyalarını tarayan bir arama motoru kullanın .

bir süre önce, sadece bunun için bir program yazdım: https://github.com/javalite/jar-explorer

grep -l "classname" *.jar

size kavanozun adını verir

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

size sınıfın paketini veriyor

#!/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

Belirli bir dizeyle eşleşen kavanozları bulmak için:

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

Bu sorunla karşılaştığımda bunu yapacak bir yardımcı program bilmiyordum, bu yüzden aşağıdakileri yazdım:

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

}

Ayrıca "JarScan" adı verilen ve tam olarak istediğinizi yapan iki farklı yardımcı program vardır: JarScan (inetfeedback.com) ve JarScan (java.net)

user1207523'nin senaryosu benim için iyi çalışıyor. İşte basit genişletme yerine find kullanarak jar dosyalarını tekrar tekrar arayan bir varyant;

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

Bunu her zaman Windows'ta kullandım ve son derece iyi çalıştı.

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

findstr.exe dosyası Windows ve parametrelerle standart olarak gelir:

• / s = özyinelemeli
• / m = bir eşleşme varsa yalnızca dosya adını yazdır
• / c = değişmez dize (bu durumda paket adınız + '/' ile ayrılmış sınıf adları)

Umarım bu birine yardımcı olur.

bash scriptKullanarak bir çözüm unzip (zipinfo). Üzerinde test edildi 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

Belirli bir dizindeki belirli bir sınıftaki tüm jar dosyalarını aramak için şunları yapabilirsiniz:

ls *.jar | xargs grep -F MyClass

veya daha da basit,

grep -F MyClass *.jar

Çıktı şöyle görünür:

Binary file foo.jar matches

Çok hızlıdır, çünkü -F seçeneği Sabit dize araması anlamına gelir, bu nedenle her grep çağrısı için normal ifade motorunu yüklemez. Gerekirse, -F seçeneğini her zaman atlayabilir ve normal ifadeleri kullanabilirsiniz.

Bu yeni yolu buldum

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
...

Yani bu kavanoz ve sınıfı bulursa, isterseniz ls -1 * .jar verebilir veya HTH Someone find komutuyla xargs girişini yapabilirsiniz.

ClassFinder bu sorunu çözmek için tasarlanmış bir programdır. Bir desenle eşleşen bir sınıfın tüm örneklerini bulmak için dizinler ve jar dosyaları arasında özyinelemeli olarak arama yapmanızı sağlar. Python değil, Java ile yazılmıştır. Kullanımı kolay hale getiren güzel bir GUI'ye sahiptir. Ve hızlı çalışır. Bu sürüm, çalıştırılabilir bir kavanozda önceden derlenmiştir, böylece onu kaynaktan oluşturmak zorunda kalmazsınız.

Buradan indirin: ClassFinder 1.0

JBoss Tattletale'i kontrol edin ; kişisel olarak hiç kullanmamış olmama rağmen, ihtiyacınız olan araç gibi görünüyor.

Sadece FindClassInJars util kullanın, basit bir salıncak programı, ama yararlı. Kaynak kodunu kontrol edebilir veya http://code.google.com/p/find-class-in-jars/ adresinden jar dosyasını indirebilirsiniz.

Buradaki senaryoların neden benim için gerçekten işe yaramadığından emin değilim. Bu çalışıyor:

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

Jar dosyasını bulmak için komut dosyası: 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

Kullanım: ./find_jar.sh <kavanoz dosyalarını içeren üst düzey dizin> <Bulunacak sınıf adı>

Bu, burada verilen cevapların çoğuna benzer. Ancak yalnızca grep bir şey bulursa dosya adını verir. Eğer grep çıktısını bastırmak istiyorsanız bunu / dev / null'a yönlendirebilirsiniz, ancak grep çıktısını görmeyi tercih ederim, böylece kısmi sınıf isimlerini kullanabilir ve gösterilen çıktı listesinden doğru olanı anlayabilirim.

Sınıf adı hem "String" gibi basit bir sınıf adı ya da "java.lang.String" gibi tam nitelikli bir ad olabilir

Başka bir araç eklemek için ... bu, pencereler için çok basit ve kullanışlı bir araçtır. Tıkladığınız basit bir exe dosyası, arama yapmak için bir dizin, bir sınıf adı verin ve o sınıfı içeren jar dosyasını bulacaktır. Evet, özyinelemeli.

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

Bir grup JAR klasöründe (ve alt klasörlerinde) bir sınıf bulmak için: 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

Misal:

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

Biraz kabuklu kavanozlarla dolu bir dizinde bir sınıf bulabilirsiniz:

"FooBar" sınıfını arıyorsunuz:

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

Yukarıdakilerin tümüne eklenecek bir şey var: jar çalıştırılabilir dosyanız yoksa (JDK ile birlikte gelir ancak JRE ile birlikte gelmezse), aynı şeyi gerçekleştirmek için unzip (veya WinZip veya her neyse) kullanabilirsiniz.

utanmaz öz tanıtım, ancak yazdığım bir yardımcı programı deneyebilirsiniz: http://sourceforge.net/projects/zfind

En yaygın arşiv / sıkıştırılmış dosyaları (kavanoz, zip, katran, tar.gz vb) destekler ve diğer birçok kavanoz / zip bulucunun aksine, sınırsız derinliğe kadar iç içe zip dosyalarını (zip içinde zip, kavanoz vb.) Destekler.

Partiye biraz geç ama yine de ...

Kullanıyorum JarBrowser'ı hangi kavanozun belirli bir sınıfta olduğunu bulmak . Seçilen yoldaki tüm kavanozların içeriğine göz atmanızı sağlayan GUI kullanımı kolaydır.

Aşağıdaki komut dosyası size yardımcı olacaktır

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

Bu bir MinGW (windows bash ortamı) iyi çalışıyor ~ gitbash

Bu işlevi HOME dizininizdeki .bashrc dosyanıza koyun:

# 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
}

Grepj , jar dosyaları içindeki sınıfları aramak için kullanılan bir komut satırı yardımcı programıdır. Yardımcı programın yazarıyım.

Yardımcı programı şu şekilde çalıştırabilirsiniz: grepj package.Class my1.jar my2.war my3.ear

Birden fazla kavanoz, kulak, savaş dosyaları sağlanabilir. Gelişmiş kullanım için aranacak kavanozların listesini sağlamak için find kullanın.

Bu eklentiyi aradığınız işi yapabilen tutulma için kontrol edin.

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

Bir Linux ortamında şunları yapabilirsiniz:

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

Burada ad , base_dir dizininde bulunan dizin hiyerarşisinde dağıtılan kavanozların içine baktığınız sınıf dosyasının adıdır .

Sen kullanabilirsiniz locateve grep:

locate jar | xargs grep 'my.class'

updatedbKullanmadan önce koştuğunuzdan emin olun locate.