ที่รันไทม์ค้นหาคลาสทั้งหมดในแอ็พพลิเคชัน Java ที่ขยายคลาสฐาน

ฉันต้องการทำสิ่งนี้:

List<Animal> animals = new ArrayList<Animal>();

for( Class c: list_of_all_classes_available_to_my_app() )
   if (c is Animal)
      animals.add( new c() );

ดังนั้นฉันต้องการดูคลาสทั้งหมดในแอปพลิเคชันจักรวาลของฉันและเมื่อฉันพบสิ่งที่สืบทอดมาจาก Animal ฉันต้องการสร้างวัตถุใหม่ของประเภทนั้นและเพิ่มลงในรายการ สิ่งนี้ทำให้ฉันสามารถเพิ่มฟังก์ชันการทำงานโดยไม่ต้องอัปเดตรายการสิ่งต่าง ๆ ฉันสามารถหลีกเลี่ยงสิ่งต่อไปนี้:

List<Animal> animals = new ArrayList<Animal>();
animals.add( new Dog() );
animals.add( new Cat() );
animals.add( new Donkey() );
...

ด้วยวิธีการข้างต้นฉันสามารถสร้างคลาสใหม่ที่ขยายขอบเขตสัตว์และมันจะถูกเลือกโดยอัตโนมัติ

ปรับปรุง: 10/16/2008 9:00 น. เวลามาตรฐานแปซิฟิก:

คำถามนี้ได้สร้างคำตอบที่ดีมากขอบคุณ จากคำตอบและการวิจัยของฉันฉันพบว่าสิ่งที่ฉันต้องการทำจริงๆนั้นเป็นไปไม่ได้ภายใต้ Java มีวิธีการเช่นกลไก ServiceLoader ของ ddimitrov ที่สามารถทำงานได้ - แต่มันหนักมากสำหรับสิ่งที่ฉันต้องการและฉันเชื่อว่าฉันเพียงแค่ย้ายปัญหาจากรหัส Java ไปยังไฟล์การกำหนดค่าภายนอก อัปเดต 5/10/19 (11 ปีต่อมา!) ตอนนี้มีห้องสมุดหลายแห่งที่สามารถช่วยเหลือสิ่งนี้ได้ตามคำตอบ org.reflectionsของ @ IvanNik ที่ดูดี นอกจากนี้ยังClassGraphจาก @Luke ฮัทชิสันคำตอบที่ดูน่าสนใจ มีความเป็นไปได้อีกมากมายในคำตอบเช่นกัน

อีกวิธีหนึ่งในการระบุสิ่งที่ฉันต้องการ: ฟังก์ชั่นคงที่ในคลาส Animal ของฉันค้นหาและสร้างคลาสทั้งหมดที่สืบทอดจาก Animal - โดยไม่ต้องมีการกำหนดค่า / การเข้ารหัสเพิ่มเติมใด ๆ ถ้าฉันต้องกำหนดค่าฉันก็อาจยกตัวอย่างพวกมันในคลาสสัตว์ต่อไป ฉันเข้าใจว่าเนื่องจากโปรแกรม Java เป็นเพียงการรวมกลุ่มของไฟล์. class ที่หลวม

ที่น่าสนใจดูเหมือนว่านี่เป็นเรื่องเล็กน้อยใน C #

ฉันใช้org.reflections :

Reflections reflections = new Reflections("com.mycompany");    
Set<Class<? extends MyInterface>> classes = reflections.getSubTypesOf(MyInterface.class);

ตัวอย่างอื่น:

public static void main(String[] args) throws IllegalAccessException, InstantiationException {
    Reflections reflections = new Reflections("java.util");
    Set<Class<? extends List>> classes = reflections.getSubTypesOf(java.util.List.class);
    for (Class<? extends List> aClass : classes) {
        System.out.println(aClass.getName());
        if(aClass == ArrayList.class) {
            List list = aClass.newInstance();
            list.add("test");
            System.out.println(list.getClass().getName() + ": " + list.size());
        }
    }
}

วิธี Java ในการทำสิ่งที่คุณต้องการคือการใช้กลไกServiceLoader

ผู้คนจำนวนมากกลิ้งตัวเองโดยมีไฟล์ในตำแหน่ง classpath ที่รู้จักกันดี (เช่น /META-INF/services/myplugin.properties) จากนั้นใช้ClassLoader.getResources ()เพื่อระบุไฟล์ทั้งหมดที่มีชื่อนี้จากขวดทั้งหมด สิ่งนี้อนุญาตให้แต่ละ jar ส่งออกผู้ให้บริการของตนเองและคุณสามารถสร้างอินสแตนซ์ของพวกมันได้โดยใช้ Class.forName ()

คิดเกี่ยวกับสิ่งนี้จากมุมมองที่มุ่งเน้นในแง่มุม สิ่งที่คุณต้องการจะทำจริง ๆ ก็คือรู้ว่าทุกชั้นเรียนที่รันไทม์ที่มีการขยายชั้นเรียนสัตว์ (ฉันคิดว่านั่นเป็นคำอธิบายปัญหาของคุณที่แม่นยำกว่าชื่อของคุณเล็กน้อยมิฉะนั้นฉันไม่คิดว่าคุณจะมีคำถามแบบรันไทม์)

ดังนั้นสิ่งที่ฉันคิดว่าคุณต้องการคือการสร้างตัวสร้างคลาสพื้นฐานของคุณ (สัตว์) ซึ่งเพิ่มไปยังอาเรย์แบบคงที่ของคุณ (ฉันชอบ ArrayLists ตัวเอง แต่สำหรับแต่ละตัวเอง) ประเภทของคลาสปัจจุบันที่กำลังอินสแตนซ์

ดังนั้นประมาณ;

public abstract class Animal
    {
    private static ArrayList<Class> instantiatedDerivedTypes;
    public Animal() {
        Class derivedClass = this.getClass();
        if (!instantiatedDerivedClass.contains(derivedClass)) {
            instantiatedDerivedClass.Add(derivedClass);
        }
    }

แน่นอนคุณจะต้องมีคอนสตรัคเตอร์แบบคงที่ใน Animal เพื่อเริ่มต้น instantiateDerivedClass ... ฉันคิดว่านี่จะทำสิ่งที่คุณต้องการ โปรดทราบว่าสิ่งนี้ขึ้นอยู่กับเส้นทางการดำเนินการ หากคุณมีคลาสสุนัขที่มาจากสัตว์ที่ไม่เคยถูกเรียกคุณจะไม่ได้ในรายการ Animal Class

น่าเสียดายที่สิ่งนี้ไม่สามารถทำได้โดยสิ้นเชิงเนื่องจาก ClassLoader จะไม่บอกคุณว่ามีคลาสใดบ้าง อย่างไรก็ตามคุณสามารถทำสิ่งนี้ได้อย่างใกล้ชิด:

for (String classpathEntry : System.getProperty("java.class.path").split(System.getProperty("path.separator"))) {
    if (classpathEntry.endsWith(".jar")) {
        File jar = new File(classpathEntry);

        JarInputStream is = new JarInputStream(new FileInputStream(jar));

        JarEntry entry;
        while( (entry = is.getNextJarEntry()) != null) {
            if(entry.getName().endsWith(".class")) {
                // Class.forName(entry.getName()) and check
                //   for implementation of the interface
            }
        }
    }
}

แก้ไข: johnstok ถูกต้อง (ในความคิดเห็น) ซึ่งใช้งานได้กับแอปพลิเคชัน Java แบบสแตนด์อโลนเท่านั้นและจะไม่ทำงานภายใต้แอปพลิเคชันเซิร์ฟเวอร์

คุณสามารถใช้ResolverUtil ( แหล่งข้อมูลดิบ ) จากFrameworkes Stripes
หากคุณต้องการบางสิ่งที่ง่ายและรวดเร็วโดยไม่ต้องเปลี่ยนรหัสที่มีอยู่

นี่เป็นตัวอย่างง่ายๆที่ไม่ได้โหลดคลาสใด ๆ :

package test;

import java.util.Set;
import net.sourceforge.stripes.util.ResolverUtil;

public class BaseClassTest {
    public static void main(String[] args) throws Exception {
        ResolverUtil<Animal> resolver = new ResolverUtil<Animal>();
        resolver.findImplementations(Animal.class, "test");
        Set<Class<? extends Animal>> classes = resolver.getClasses();

        for (Class<? extends Animal> clazz : classes) {
            System.out.println(clazz);
        }
    }
}

class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}
class Donkey extends Animal {}

สิ่งนี้ยังใช้งานได้ในแอปพลิเคชันเซิร์ฟเวอร์เช่นกันเนื่องจากเป็นที่ที่มันถูกออกแบบมาให้ทำงาน;)

รหัสโดยทั่วไปแล้วจะทำสิ่งต่อไปนี้:

• วนซ้ำทรัพยากรทั้งหมดในแพ็คเกจที่คุณระบุ
• เก็บเฉพาะทรัพยากรที่ลงท้ายด้วย. class
• โหลดคลาสเหล่านั้นโดยใช้ ClassLoader#loadClass(String fullyQualifiedName)
• ตรวจสอบว่า Animal.class.isAssignableFrom(loadedClass);

กลไกที่แข็งแกร่งที่สุดสำหรับการแสดงรายการคลาสย่อยทั้งหมดของคลาสที่กำหนดอยู่ในขณะนี้ ClassGraphเนื่องจากมันจัดการกับอาร์เรย์ของข้อมูลจำเพาะคลาสพา ธ ที่กว้างที่สุดเท่าที่จะเป็นไปได้รวมถึงระบบโมดูล JPMS ใหม่ (ฉันเป็นผู้เขียน)

List<Class<Animal>> animals;
try (ScanResult scanResult = new ClassGraph().whitelistPackages("com.zoo.animals")
        .enableClassInfo().scan()) {
    animals = scanResult
        .getSubclasses(Animal.class.getName())
        .loadClasses(Animal.class);
}

Java โหลดคลาสแบบไดนามิกดังนั้นจักรวาลของคลาสของคุณจะเป็นเฉพาะคลาสที่โหลดแล้ว (และยังไม่ได้ยกเลิกการโหลด) บางทีคุณสามารถทำอะไรกับตัวโหลดคลาสแบบกำหนดเองที่สามารถตรวจสอบชนิดของแต่ละคลาสที่โหลด ฉันไม่คิดว่าจะมี API เพื่อสอบถามชุดคลาสที่โหลด

ใช้สิ่งนี้

public static Set<Class> getExtendedClasses(Class superClass)
{
    try
    {
        ResolverUtil resolver = new ResolverUtil();
        resolver.findImplementations(superClass, superClass.getPackage().getName());
        return resolver.getClasses();  
    }
    catch(Exception e)
    {Log.d("Log:", " Err: getExtendedClasses() ");}

    return null;
}

getExtendedClasses(Animals.class);

แก้ไข:

• ไลบรารี่สำหรับ (ResolverUtil): Stripes

ขอบคุณทุกคนที่ตอบคำถามนี้

ดูเหมือนว่านี่จะเป็นถั่วที่แข็งแกร่งที่จะร้าว ฉันสิ้นสุดการยอมแพ้และสร้างอาร์เรย์แบบสแตติกและทะเยอทะยานใน baseclass ของฉัน

public abstract class Animal{
    private static Animal[] animals= null;
    public static Animal[] getAnimals(){
        if (animals==null){
            animals = new Animal[]{
                new Dog(),
                new Cat(),
                new Lion()
            };
        }
        return animals;
    }
}

ดูเหมือนว่า Java ไม่ได้ตั้งค่าสำหรับการค้นพบตัวเองในแบบที่ C # เป็น ฉันคิดว่าปัญหาคือเนื่องจากแอพ Java เป็นเพียงชุดของไฟล์. class ในไฟล์ directory / jar ที่ไหนสักแห่งรันไทม์ไม่ทราบเกี่ยวกับชั้นเรียนจนกว่าจะมีการอ้างอิง ในเวลานั้นโหลดโหลด - สิ่งที่ฉันพยายามทำคือค้นพบก่อนที่ฉันจะอ้างอิงซึ่งไม่สามารถทำได้โดยไม่ต้องออกไปที่ระบบไฟล์และค้นหา

ฉันมักจะชอบโค้ดที่สามารถค้นพบตัวเองแทนที่จะบอกฉันเกี่ยวกับตัวเอง แต่ก็ใช้งานได้เช่นกัน

ขอบคุณอีกครั้ง!

การใช้OpenPojoคุณสามารถทำสิ่งต่อไปนี้:

String package = "com.mycompany";
List<Animal> animals = new ArrayList<Animal>();

for(PojoClass pojoClass : PojoClassFactory.enumerateClassesByExtendingType(package, Animal.class, null) {
  animals.add((Animal) InstanceFactory.getInstance(pojoClass));
}

นี่เป็นปัญหาที่ยากและคุณจะต้องค้นหาข้อมูลนี้โดยใช้การวิเคราะห์แบบสแตติกซึ่งไม่สามารถใช้งานได้ง่ายในขณะใช้งานจริง โดยทั่วไปจะรับ classpath ของแอพและสแกนผ่านคลาสที่มีอยู่และอ่านข้อมูล bytecode ของคลาสที่คลาสนั้นสืบทอดมา โปรดทราบว่าสุนัขคลาสอาจไม่ได้รับการสืบทอดโดยตรงจากสัตว์ แต่อาจสืบทอดมาจากสัตว์เลี้ยงซึ่งเป็นสิ่งที่สืบทอดมาจากสัตว์ดังนั้นคุณจะต้องติดตามลำดับชั้นนั้น

วิธีหนึ่งคือการทำให้คลาสใช้ initializers คงที่ ... ฉันไม่คิดว่าสิ่งเหล่านี้จะสืบทอดมา (มันจะไม่ทำงานหากเป็น):

public class Dog extends Animal{

static
{
   Animal a = new Dog();
   //add a to the List
}

มันต้องการให้คุณเพิ่มรหัสนี้ลงในคลาสที่เกี่ยวข้องทั้งหมด แต่มันก็เป็นการหลีกเลี่ยงการวนรอบที่น่าเกลียดมาก ๆ ทดสอบกับทุกชั้นเพื่อค้นหาเด็กสัตว์

ฉันแก้ไขปัญหานี้ได้อย่างสวยงามโดยใช้คำอธิบายประกอบระดับแพคเกจแล้วทำให้คำอธิบายประกอบนั้นเป็นอาร์กิวเมนต์ของรายการคลาส

ค้นหาคลาส Java ที่ใช้อินเตอร์เฟส

การติดตั้งใช้งานเพียงแค่สร้าง package-info.java และใส่หมายเหตุประกอบแบบเวทมนต์ลงในรายการคลาสที่ต้องการสนับสนุน