Java'da belirli bir sınıfın tüm alt sınıflarını nasıl bulabilirsiniz?

Java'da belirli bir sınıfın tüm alt sınıflarını (veya belirli bir arabirimin tüm uygulayıcılarını) nasıl bulmaya çalışır? Şu andan itibaren bunu yapmak için bir yöntemim var, ama oldukça verimsiz buluyorum (en azından söylemek gerekirse). Yöntem:

1. Sınıf yolunda var olan tüm sınıf adlarının bir listesini alın
2. Her sınıfı yükleyin ve istenen sınıfın veya arayüzün bir alt sınıfı mı yoksa uygulayıcısı mı olduğunu test edin

Eclipse'de, bunu oldukça verimli bir şekilde göstermeyi başaran Tür Hiyerarşisi adı verilen hoş bir özellik var. Kişi nasıl programlanır?

Bunu tarif ettiğinizden başka yapmanın başka bir yolu yoktur. Bir düşünün - sınıfta her sınıfı taramadan hangi sınıfların ClassX'i genişlettiğini nasıl bilebilir?

Eclipse size yalnızca "verimli" bir süre gibi görünen süper ve alt sınıfları anlatabilir, çünkü "Tür Hiyerarşisinde Görüntüle" düğmesine bastığınız noktada zaten tüm tür verileri yüklüdür (çünkü sınıflarınızı sürekli derlemek, sınıf yolundaki her şeyi bilir, vb.).

Saf Java ile sınıfları taramak kolay değildir.

Yay çerçevesi, ihtiyacınız olanı yapabilen ClassPathScanningCandidateComponentProvider adlı bir sınıf sunar . Aşağıdaki örnek, Sınıfımın tüm alt sınıflarını org.example.package paketinde bulur

ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false);
provider.addIncludeFilter(new AssignableTypeFilter(MyClass.class));

// scan in org.example.package
Set<BeanDefinition> components = provider.findCandidateComponents("org/example/package");
for (BeanDefinition component : components)
{
    Class cls = Class.forName(component.getBeanClassName());
    // use class cls found
}

Bu yöntem o olur yani adayları bulmak için bir bayt kodu analiz cihazı kullanılarak ek yarar vardır değil o tarar tüm sınıfları yükleyin.

Bu, yalnızca yerleşik Java Reflections API'sını kullanarak yapmak mümkün değildir.

Bu bilgiye erişebilmeniz için sınıf yolunuzun gerekli taramasını ve dizine eklemesini yapan bir proje var ...

Yansımalar

Scannotations ruhu içinde bir Java çalışma zamanı meta veri analizi

Yansımalar sınıf yolunuzu tarar, meta verileri dizine ekler, çalışma zamanında sorgulamanıza olanak tanır ve bu bilgileri projenizdeki birçok modül için kaydedip toplayabilir.

Yansımalar'ı kullanarak meta verilerinizi aşağıdakiler için sorgulayabilirsiniz:

• bir türün tüm alt türlerini al
• bazı ek açıklamalarla her türe ek açıklama ekleyin
• ek açıklama parametreleri eşleşmesi de dahil olmak üzere tüm türlere bazı ek açıklamalarla ek açıklama ekleyin
• tüm yöntemlere bazı açıklamaları ekleyin

(sorumluluk reddi: Kullanmadım, ancak projenin açıklaması ihtiyaçlarınıza tam olarak uyuyor gibi görünüyor.)

Bir sınıf için oluşturulan Javadoc'un bilinen alt sınıfların (ve arabirimler için bilinen uygulama sınıfları) bir listesini içereceğini unutmayın .

ClassGraph'ı deneyin . (Feragat, ben yazarım). ClassGraph, belirli bir sınıfın alt sınıflarının taranmasını çalışma zamanında veya derleme zamanında değil, aynı zamanda çok daha fazlasını destekler. ClassGraph, bellekteki tüm sınıf grafiğinin (tüm sınıflar, detaylandırmalar, yöntemler, yöntem parametreleri ve alanlar) soyut bir temsilini oluşturabilir, sınıf yolundaki tüm sınıflar veya beyaz listedeki paketlerdeki sınıflar için, ancak bu sınıf grafiğini sorgulayabilirsiniz. İstediğiniz. ClassGraph, diğer tarayıcılardan daha fazla sınıf yolu spesifikasyon mekanizmasını ve sınıf yükleyiciyi destekler ve ayrıca yeni JPMS modül sistemi ile sorunsuz çalışır, bu nedenle kodunuzu ClassGraph'a dayandırırsanız, kodunuz maksimum taşınabilir olacaktır. API'ya buradan bakın.

Bunu birkaç yıl önce yaptım. Bunu yapmanın en güvenilir yolu (yani resmi Java API'leri ve harici bağımlılık olmadan) çalışma zamanında okunabilecek bir liste oluşturmak için özel bir kitapçık yazmaktır.

Komut satırından şu şekilde çalıştırabilirsiniz:

javadoc -d build -doclet com.example.ObjectListDoclet -sourcepath java/src -subpackages com.example

veya şöyle karıncadan çalıştırın:

<javadoc sourcepath="${src}" packagenames="*" >
  <doclet name="com.example.ObjectListDoclet" path="${build}"/>
</javadoc>

Temel kod şöyledir:

public final class ObjectListDoclet {
    public static final String TOP_CLASS_NAME =  "com.example.MyClass";        

    /** Doclet entry point. */
    public static boolean start(RootDoc root) throws Exception {
        try {
            ClassDoc topClassDoc = root.classNamed(TOP_CLASS_NAME);
            for (ClassDoc classDoc : root.classes()) {
                if (classDoc.subclassOf(topClassDoc)) {
                    System.out.println(classDoc);
                }
            }
            return true;
        }
        catch (Exception ex) {
            ex.printStackTrace();
            return false;
        }
    }
}

Basit olması için, komut satırı bağımsız değişkenini ayrıştırmayı kaldırdım ve bir dosya yerine System.out'a yazıyorum.

Bu partiye birkaç yıl geç kaldığımı biliyorum, ama aynı soruyu çözmeye çalışırken bu soruya rastladım. Bir Eclipse Eklentisi yazıyorsanız (ve böylece önbelleklemelerinden, vb.) Bir arayüz uygulayan sınıfları bulmak için Eclipse'nin dahili aramasını programlı olarak kullanabilirsiniz. İşte benim (çok kaba) ilk kesimim:

  protected void listImplementingClasses( String iface ) throws CoreException
  {
    final IJavaProject project = <get your project here>;
    try
    {
      final IType ifaceType = project.findType( iface );
      final SearchPattern ifacePattern = SearchPattern.createPattern( ifaceType, IJavaSearchConstants.IMPLEMENTORS );
      final IJavaSearchScope scope = SearchEngine.createWorkspaceScope();
      final SearchEngine searchEngine = new SearchEngine();
      final LinkedList<SearchMatch> results = new LinkedList<SearchMatch>();
      searchEngine.search( ifacePattern, 
      new SearchParticipant[]{ SearchEngine.getDefaultSearchParticipant() }, scope, new SearchRequestor() {

        @Override
        public void acceptSearchMatch( SearchMatch match ) throws CoreException
        {
          results.add( match );
        }

      }, new IProgressMonitor() {

        @Override
        public void beginTask( String name, int totalWork )
        {
        }

        @Override
        public void done()
        {
          System.out.println( results );
        }

        @Override
        public void internalWorked( double work )
        {
        }

        @Override
        public boolean isCanceled()
        {
          return false;
        }

        @Override
        public void setCanceled( boolean value )
        {
        }

        @Override
        public void setTaskName( String name )
        {
        }

        @Override
        public void subTask( String name )
        {
        }

        @Override
        public void worked( int work )
        {
        }

      });

    } catch( JavaModelException e )
    {
      e.printStackTrace();
    }
  }

Şimdiye kadar gördüğüm ilk sorun, sadece tüm alt sınıflarını değil, arayüzü doğrudan uygulayan sınıfları yakalamaktır - ancak küçük bir özyineleme kimseye zarar vermez.

Diğer cevaplarda belirtilen sınırlamaları göz önünde bulundurarak, openpojo'larıPojoClassFactory ( Maven'de mevcuttur ) aşağıdaki şekilde de kullanabilirsiniz:

for(PojoClass pojoClass : PojoClassFactory.enumerateClassesByExtendingType(packageRoot, Superclass.class, null)) {
    System.out.println(pojoClass.getClazz());
}

packageRootArama yapmak istediğiniz paketlerin kök dizesi nerede (örneğin , "com.mycompany"hatta sadece "com") ve Superclasssüper tipiniz (bu arabirimler üzerinde de çalışır).

Sadece org.reflections.Reflectionssoyut sınıfın alt sınıflarını almak için kullanmak için basit bir demo yazıyorum :

https://github.com/xmeng1/ReflectionsDemo

Özel gereksinimlerinize bağlı olarak, bazı durumlarda Java'nın hizmet yükleyici mekanizması peşinde olduğunuz şeyi başarabilir.

Kısacası, geliştiricilerin bir sınıfın JAR / WAR dosyasının META-INF/servicesdizinindeki bir dosyada listelenerek başka bir sınıfın alt sınıflarını (veya bazı arabirimleri uyguladığını) açıkça bildirmesine izin verir . Daha sonra java.util.ServiceLoader, bir Classnesne verildiğinde , o sınıfın bildirilen tüm alt sınıflarının (ya da Classbir arabirimi temsil ediyorsa, o arabirimi uygulayan tüm sınıfların) örneklerini oluşturacak sınıf kullanılarak keşfedilebilir .

Bu yaklaşımın temel avantajı, tüm sınıfyolunu alt sınıflar için manuel olarak taramaya gerek olmamasıdır - tüm keşif mantığı ServiceLoadersınıf içinde bulunur ve yalnızca META-INF/servicesdizinde açıkça belirtilen sınıfları yükler (sınıf yolundaki her sınıf değil) .

Bununla birlikte, bazı dezavantajlar vardır:

• Tüm alt sınıfları bulamaz , yalnızca açıkça beyan edilenleri bulur . Bu nedenle, tüm alt sınıfları gerçekten bulmanız gerekiyorsa, bu yaklaşım yetersiz olabilir.
• Geliştiricinin sınıfı META-INF/servicesdizinin altında açıkça belirtmesini gerektirir . Bu geliştirici üzerinde ek bir yüktür ve hataya açık olabilir.
• ServiceLoader.iterator()Alt sınıf örneklerini değil onların oluşturduğu Classnesneler. Bu iki soruna neden olur:
  • Alt sınıfların nasıl oluşturulduğu hakkında herhangi bir söz almazsınız - argüman oluşturucu örnekleri oluşturmak için kullanılır.
  • Bu nedenle, alt sınıfların varsayılan bir kurucuya sahip olması ya da açıklamanın arg olmayan bir kurucu bildirmesi gerekir.

Görünüşe göre Java 9 bu eksikliklerin bazılarını (özellikle alt sınıfların somutlaştırılmasıyla ilgili) ele alacaktır.

Bir örnek

Bir arayüz uygulayan sınıflar bulmakla ilgilendiğinizi varsayalım com.example.Example:

package com.example;

public interface Example {
    public String getStr();
}

Sınıf com.example.ExampleImplbu arayüzü uygular:

package com.example;

public class ExampleImpl implements Example {
    public String getStr() {
        return "ExampleImpl's string.";
    }
}

Metni içeren bir dosya oluşturarak sınıfın ExampleImplbir uygulaması olduğunu beyan edersiniz .ExampleMETA-INF/services/com.example.Examplecom.example.ExampleImpl

Ardından, her uygulamasının Examplebir örneğini (bir örneği dahil ExampleImpl) aşağıdaki gibi alabilirsiniz:

ServiceLoader<Example> loader = ServiceLoader.load(Example.class)
for (Example example : loader) {
    System.out.println(example.getStr());
}

// Prints "ExampleImpl's string.", plus whatever is returned
// by other declared implementations of com.example.Example.

Bunun elbette sadece mevcut sınıf yolunuzda var olan tüm alt sınıfları bulacağına dikkat edilmelidir. Muhtemelen bu şu anda baktığınız şey için sorun değil ve bunu dikkate aldınız mı, ancak herhangi bir noktada finalvahşi olmayan bir sınıf ( eğer "vahşi" seviyeleri için) serbest bıraktıysanız , o zaman tamamen mümkündür. başkası bilmediğiniz kendi alt sınıfını yazdı.

Bu nedenle, tüm alt sınıfları görmek istemişseniz, çünkü bir değişiklik yapmak istediğiniz ve alt sınıfların davranışlarını nasıl etkilediğini göreceksiniz - o zaman göremediğiniz alt sınıfları aklınızda bulundurun. İdeal olarak tüm özel olmayan yöntemleriniz ve sınıfın kendisi iyi belgelenmelidir; yöntemlerin / özel olmayan alanların anlamlarını değiştirmeden bu belgelere göre değişiklik yapın ve değişikliklerinizin en azından üst sınıf tanımınızı izleyen alt sınıflar için geriye dönük olarak uyumlu olması gerekir.

Uygulamanız ve Eclipse arasında bir fark görmenizin nedeni, her seferinde taramanız, Eclipse (ve diğer araçlar) yalnızca bir kez (proje yüklemesi sırasında) çoğu zaman taranması ve bir dizin oluşturmasıdır. Bir dahaki sefere veri istediğinde veri yeniden taranmaz, ancak dizine bakın.

Sınıf yolunuzu tüm alt sınıflar için tarayan bir yansıma kütüphanesi kullanıyorum: https://github.com/ronmamo/reflections

Böyle yapılırdı:

Reflections reflections = new Reflections("my.project");
Set<Class<? extends SomeType>> subTypes = reflections.getSubTypesOf(SomeType.class);

Bunları, üst sınıf yapıcısının (this.getClass (). GetName ()) içindeki statik bir haritaya ekleyin (veya varsayılan bir tane oluşturun), ancak bu çalışma zamanında güncellenecektir. Tembel başlatma bir seçenekse bu yaklaşımı deneyebilirsiniz.

Org.reflections kitaplığını kullanabilir ve ardından Reflections sınıfının bir nesnesini oluşturabilirsiniz. Bu nesneyi kullanarak, verilen sınıfın tüm alt sınıflarının listesini alabilirsiniz. https://www.javadoc.io/doc/org.reflections/reflections/0.9.10/org/reflections/Reflections.html

    Reflections reflections = new Reflections("my.project.prefix");
    System.out.println(reflections.getSubTypesOf(A.class)));

Yeni sınıflar koda eklenmiş olup olmadığını görmek için bunu bir test durumda yapmak gerekiyordu. Ben de öyle yaptım

final static File rootFolder = new File(SuperClass.class.getProtectionDomain().getCodeSource().getLocation().getPath());
private static ArrayList<String> files = new ArrayList<String>();
listFilesForFolder(rootFolder); 

@Test(timeout = 1000)
public void testNumberOfSubclasses(){
    ArrayList<String> listSubclasses = new ArrayList<>(files);
    listSubclasses.removeIf(s -> !s.contains("Superclass.class"));
    for(String subclass : listSubclasses){
        System.out.println(subclass);
    }
    assertTrue("You did not create a new subclass!", listSubclasses.size() >1);     
}

public static void listFilesForFolder(final File folder) {
    for (final File fileEntry : folder.listFiles()) {
        if (fileEntry.isDirectory()) {
            listFilesForFolder(fileEntry);
        } else {
            files.add(fileEntry.getName().toString());
        }
    }
}