Comment puis-je récupérer dynamiquement les implémentations de l'interface Java ?

Récupération dynamique des implémentations d'une interface en Java

En programmation orientée objet, il peut être avantageux d'obtenir une liste d'implémentations pour un interface donnée par programme. En Java, cela peut être réalisé grâce à diverses techniques, telles que les réflexions.

Une approche consiste à utiliser la bibliothèque Reflections, qui fournit un mécanisme pratique pour introspecter les classes et extraire les informations sur les classes. Voici comment y parvenir à l'aide de Reflections :

import org.reflections.Reflections;
import org.reflections.SubTypesScanner;

// Define the interface of interest
interface Pet {}

// Implementations of the Pet interface
class Dog implements Pet {}
class Cat implements Pet {}

// Use Reflections to get a list of Pet implementations
Reflections reflections = new Reflections("package.containing.implementations");
Set<class extends pet>> petImplementations = reflections.getSubTypesOf(Pet.class);

// Iterate over and display the implementations
for (Class extends Pet> implementation : petImplementations) {
    System.out.println(implementation.getSimpleName()); // prints Dog, Cat
}</class>

Vous pouvez également utiliser la fonction ServiceLoader de Java pour découvrir les implémentations d'une interface de fournisseur de services (SPI).

import java.util.ServiceLoader;

// Define the Pet interface as an SPI
interface Pet {}

// Implementations of the Pet interface
class Dog implements Pet {}
class Cat implements Pet {}

// Use ServiceLoader to load implemented services
ServiceLoader<pet> loader = ServiceLoader.load(Pet.class);

// Iterate over and display the implementations
for (Pet implementation : loader) {
    System.out.println(implementation.getClass().getSimpleName()); // prints Dog, Cat
}</pet>

Notez que pour cette approche, vous devez spécifier votre interface en tant que SPI en créant un fichier dans le répertoire resources/META-INF/services avec le nom complet de l'interface et en répertoriant les implémentations à l'intérieur.

Une autre option consiste à définir une annotation au niveau du package.

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

// Package-level annotation to define implementations
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PACKAGE)
public @interface MyPackageAnnotation {
    Class>[] implementationsOfPet() default {};
}

// Implementations of the Pet interface
class Dog implements Pet {}
class Cat implements Pet {}

// Define the package-level annotation in a package-info.java file
@MyPackageAnnotation(implementationsOfPet = {Dog.class, Cat.class})
package package.containing.implementations;

// Iterate over and display the implementations
Package[] packages = Package.getPackages();
for (Package p : packages) {
    MyPackageAnnotation annotation = p.getAnnotation(MyPackageAnnotation.class);
    if (annotation != null) {
        Class>[] implementations = annotation.implementationsOfPet();
        for (Class> implementation : implementations) {
            System.out.println(implementation.getSimpleName());
        }
    }
}

Gardez à l'esprit que cette approche ne fonctionnera que pour les packages déjà connus du ClassLoader. Pour une recherche plus exhaustive, pensez aux URLClassLoaders, mais soyez conscient des limitations spécifiques aux classes chargées.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!