Construire des applications extensibles avec l'interface de service de service Java (SPI)

Java SPI est un mécanisme de découverte de service intégré dans JDK et met en œuvre une expansion dynamique axée sur l'interface via ServiceLoader. 1. Définissez l'interface de service et créez un fichier avec le nom complet de l'interface sous Meta-Inf / Services /, et écrivez le nom entièrement qualifié de la classe d'implémentation; 2. Chargez la classe d'implémentation à l'aide de ServiceLoader.Load (), et le JVM lira automatiquement la configuration et l'instanciera; 3. Le contrat d'interface doit être clarifié lors de la conception, de la priorité de support et du chargement conditionnel et fournit une implémentation par défaut; 4. Les scénarios d'application incluent l'accès au canal multi-paiement et la vérification du plug-in; 5. Faites attention aux performances, à ClassPath, à l'isolement des exceptions, à la sécurité des fils et à la compatibilité des versions; 6. Dans Java 9, vous pouvez utiliser les fournisseurs ... avec ... déclarer explicitement les services pour améliorer la sécurité. L'utilisation correcte de SPI peut atteindre le découplage et l'expansion à chaud, ce qui rend le système très évolutif.

Le mécanisme de l'interface du fournisseur de services de Java (SPI) est un outil important pour construire des applications évolutives. Il permet aux développeurs de définir les interfaces et permet aux tiers de fournir des implémentations spécifiques sans modifier le code de base. Cette architecture "plugin" est largement utilisée dans le chargement du pilote de base de données, les cadres journaux, les bibliothèques de sérialisation et autres scénarios. Par exemple, JDBC est un cas d'utilisation SPI typique.

L'idée principale de SPI est: la programmation orientée vers l'interface et l'implémentation de découverte dynamique à l'exécution . Grâce à ce mécanisme, les applications peuvent charger automatiquement les classes d'implémentation conformes aux conventions pendant le démarrage ou l'opération, permettant ainsi une expansion flexible des fonctions.

Qu'est-ce que Java Spi?

Java SPI est un mécanisme de découverte de service intégré à JDK, situé dans java.util.ServiceLoader . Son flux de travail de base est le suivant:

1. Définissez une interface ou une classe abstraite (service).
2. Créez un fichier avec le nom complet de l'interface sous META-INF/services/ répertoire.
3. Le contenu du fichier est le nom entièrement qualifié d'une ou plusieurs classes d'implémentation de l'interface, une par ligne.
4. Chargez ces implémentations à l'aide de ServiceLoader .

Par exemple, définissez une interface de service de journal:

 Enregistreur d'interface publique {
    VOID LOG (Message de chaîne);
}

Créez ensuite le fichier META-INF/services/com.example.Logger avec le contenu:

 com.example.impl.consolelogger
com.example.impl.filelogger

Utilisation dans le code:

 ServiceLoader <ogger> chargeurs = ServiceLoader.Load (logger.class);
pour (journaliste logique: chargeurs) {
    Logger.log ("Hello, Spi!");
}

Le JVM lit automatiquement le fichier de configuration et instancie toutes les classes d'implémentation répertoriées.

Comment concevoir des applications évolutives?

La clé de l'utilisation de SPI pour créer un système évolutif est de découpler la logique de base et les implémentations spécifiques . Voici quelques suggestions de conception pratiques:

1. Clarifier le contrat de service (conception d'interface)

L'interface doit être suffisamment universelle pour éviter d'exposer des détails de mise en œuvre spécifiques. Envisagez d'ajouter des paramètres de configuration ou des objets contextuels pour améliorer la flexibilité.

 Interface publique DataSerializer {
    octet [] serialize (objet obj);
    <T> T Desérialiser (octet [] Data, Class <T> Type);
}

2. Priorité à la priorité et à la charge conditionnelle

ServiceLoader charge toutes les implémentations dans l'ordre de configuration par défaut. Si vous devez sélectionner la mise en œuvre optimale, vous pouvez introduire des mécanismes de détection de poids ou de capacité:

 Interface publique DataSerializer {
    int getPriority (); // utilise des supports booléens (classe <?> Type); // un certain type est-il pris en charge}

Puis filtrez le chargement:

 DataSerializer sélectionné = ServiceLoader.Load (DataSerializer.class)
    .flux()
    .map (fournisseur :: get)
    .filter (s -> s.supports (mydata.class))
    .max (comparateur.compartingInt (DataSerializer :: getPriority))
    .OrelSethrow (() -> New illégalStateException ("Aucun sérialiseur trouvé"));

3. Autoriser les implémentations par défaut et les extensions facultatives

Une implémentation par défaut (telle que DefaultLogger ) peut être fournie dans le module de base, tout en permettant des remplacements ou des ajoutes externes. Cela garantit que le système peut fonctionner normalement même sans implémentation tiers.

Exemples de scénarios d'application pratiques

Scénario 1: accès à canal multi-paiement

Les plates-formes de commerce électronique doivent se connecter à des méthodes de paiement telles que WeChat, Alipay, UnionPay, etc. Utilisation de SPI Can:

• Définir l'interface PaymentProcessor
• Chaque canal fournit son propre package .jar et la configuration META-INF/services
• Le programme principal appelle ServiceLoader pour obtenir tous les canaux disponibles

De cette façon, l'ajout de nouvelles méthodes de paiement ne nécessite que l'introduction de nouveaux pots sans modifier la logique principale.

Scénario 2: périphérique de vérification des données plug-in

Le système doit effectuer plusieurs vérifications sur l'entrée utilisateur (numéro de téléphone mobile, adresse e-mail, carte d'identité, etc.). Chaque règle de vérification est mise en œuvre comme un SPI:

 Validateur d'interface publique {
    Boolean Validate (entrée de chaîne);
    String getType (); // par exemple, "e-mail", "téléphone"
}

Tous les vérificateurs sont chargés dynamiquement au moment de l'exécution et appelés à la demande.

Notes et meilleures pratiques

Bien que SPI soit simple et facile à utiliser, il y a certaines choses à noter:

• Problèmes de performances : ServiceLoader est un chargement paresseux et le premier appel peut être légèrement plus lent. S'il existe de nombreuses classes de mise en œuvre ou des coûts de construction élevés, il est recommandé de mettre en cache les résultats.

• ClassPath Dependency : vous devez vous assurer que META-INF/services est emballé dans le pot et que le chemin est correct. Maven est facilement manqué dans des projets multi-modules.

• Gestion des exceptions : une certaine implémentation lance une exception ne doit pas affecter d'autres implémentations. Des coups d'œil doivent être ajoutés lors de la traversée:

   pour (journaliste logique: chargeurs) {
      essayer {
          logger.log ("message");
      } catch (exception e) {
          // Enregistrez l'erreur mais continuez}
  }

• Sécurité du thread : assurez-vous que les classes d'implémentation sont en filetage, en particulier lorsqu'elles sont partagées par plusieurs endroits.

• Compatibilité de la version : soyez prudent lorsque vous modifiez les interfaces pour éviter de nuire aux implémentations existantes.

Avancé: combiné avec le système de modules (Java 9)

Dans un projet modulaire, vous pouvez utiliser provides ... with ... Syntaxe pour déclarer explicitement l'implémentation du service:

 // module-info.java
module com.example.logger {
    fournir com.example.logger avec com.example.impl.consolelogger;
}

Ceci est plus sûr que les fichiers de configuration purs, et les liaisons de service peuvent être vérifiées pendant la compilation.

Fondamentalement, c'est tout. SPI n'est pas compliqué, mais il peut rendre le système très flexible s'il est utilisé correctement. La clé est de bien concevoir l'interface, de conclure des accords clairs et de coopérer avec une stratégie de chargement raisonnable pour réaliser facilement l'expansion de la fonction "swap à chaud".

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!