Maison > Java > javaDidacticiel > le corps du texte

Comment implémenter le mécanisme SpringBoot SPI et le démarreur personnalisé

WBOY
Libérer: 2023-05-16 19:58:10
avant
1537 Les gens l'ont consulté

    1. Le mécanisme SPI dans SpringBoot

    Qu'est-ce que spi Le nom complet est Service Provider Interface. En traduction simple, il s'agit de l'interface du fournisseur de services, qui est un mécanisme permettant de trouver des implémentations de services. <code>Service Provider Interface。简单翻译的话,就是服务提供者接口,是一种寻找服务实现的机制。

    其实就是一个规范定义、或者说是实现的标准。

    用生活中的例子说就是,你买了一台小米的手机。

    但是你用的充电器并不一定非要是小米充电器,你可以拿其他厂商的充电器来进行充电,只要满足协议、端口等要求,那么就是可以充电的。这也是一种热拔插的思想,并不是固定死的。

    换成代码来说也是一样的,我定义了一个接口,但是不想固定死具体的实现类,因为那样如果要更换实现类就要改动源代码,这往往是不合适的。

    那么我也可以定义一个规范,在之后需要更换实现类或增加其他实现类时,遵守这个规范,我也可以动态的去发现这些实现类。

    换在SpringBoot中,就是现在的SpringBoot这个平台定义了一些规范和标准,我现在想要让SpringBoot平台接纳我。

    我该如何做呢?

    很简单,按照它的标准和规范做事

    SpringBoot在启动的时候,会扫描所有jar包resource/META-INF/spring.factories文件,依据类的全限定名,利用反射机制将Bean

    est en fait une définition standard, ou une norme de mise en œuvre.

    Pour prendre un exemple dans la vie, vous achetez un téléphone mobile Xiaomi.

    Mais le chargeur que vous utilisez ne doit pas nécessairement être un chargeur Xiaomi. Vous pouvez utiliser des chargeurs d'autres fabricants pour charger. Tant qu'il répond au protocole, au port et aux autres exigences, il peut être chargé. . Il s'agit également d'une idée remplaçable à chaud, qui n'est pas corrigée.

    C'est la même chose en termes de code. J'ai défini une interface, mais je ne voulais pas corriger la classe d'implémentation spécifique, car si je veux changer la classe d'implémentation, je dois le faire. changer le code source, ce qui est souvent inapproprié.

    Ensuite, je peux également définir une spécification. Lorsque j'ai besoin de changer la classe d'implémentation ou d'ajouter d'autres classes d'implémentation plus tard, je peux également découvrir dynamiquement ces classes d'implémentation.
    • Dans SpringBoot, la plateforme SpringBoot actuelle a défini certaines normes et standards. Je souhaite maintenant que la plateforme SpringBoot m'accepte.

      Comment dois-je faire ?
    • C'est très simple, faire les choses selon ses normes et cahier des charges

      .
    • Lorsque SpringBoot démarre, il analysera tous les fichiers du package jar resource/META-INF/spring.factories et utilisera le mécanisme de réflexion pour convertir Bean est chargé dans le conteneur.

      2. Démarreur personnalisé

      Laissez-moi vous parler de ma petite pratique :

      • Dans ce démarreur, Implémentez # 🎜🎜#

      • Modèle pour l'envoi de lignes courtes
      • Modèle pour le stockage d'objets
      • # Le L'assemblage automatique de 🎜🎜#

        ~
      • se déroule en gros en quatre étapes :

      est utilisé La classe xxxxProperties

      Comment implémenter le mécanisme SpringBoot SPI et le démarreur personnalisé

      est utilisée pour faire fonctionner l'interface et le client de xxxx, etc., comme OssTemplate

      dans cet article #🎜🎜 #

      Configurez automatiquement la classe xxxxAutoConfiguration et injectez xxxxTemplate dans le conteneur

      Comment implémenter le mécanisme SpringBoot SPI et le démarreur personnaliséAjoutez xxxxAutoConfiguration à la collection vaule d'EnableAutoConfiguration dans spring.factories# 🎜🎜##🎜 🎜#

      J'utilise le système d'exploitation d'Alibaba Cloud pour le stockage d'objets, et les configurations qu'il contient sont toutes utilisables Pour les messages texte, c'est juste une simulation~, ne me blâmez pas#🎜🎜 ##🎜🎜. #

      2.1. Préparez un projet Maven

      Supprimez le répertoire src,

      Puis créez deux autres projets Maven (Mon habitude personnelle est de créer des projets Maven vides. En fait, il en va de même pour la création de projets SpringBoot)

      Outermost
       <parent>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-parent</artifactId>
           <version>2.5.2</version>
           <relativePath/>
       </parent>
      
       <properties>
           <maven.compiler.source>8</maven.compiler.source>
           <maven.compiler.target>8</maven.compiler.target>
       </properties>
      
      
       <dependencies>
           <dependency>
               <groupId>org.projectlombok</groupId>
               <artifactId>lombok</artifactId>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-web</artifactId>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter</artifactId>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-test</artifactId>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-configuration-processor</artifactId>
               <optional>true</optional>
           </dependency>
       </dependencies>
      Copier après la connexion

      2.2. La classe de propriétés

      est utilisée pour mapper le fichier de configuration~

       /**
        * @author Ning Zaichun
        */
       @Data
       @ConfigurationProperties(prefix = "nzc.oss")
       public class OssProperties {
      
           private String accessKey; 
           private String secret;
           private String bucketName;
           private String url;
           private String endpoint;
       }
      Copier après la connexion
       @Data
       @ConfigurationProperties(prefix = "nzc.sms")
       public class SmsProperties {
      
           private String name;
       }
      Copier après la connexion

      2.3 Préparer la classe à injecter

      C'est la classe que nous allons injecter. enfin injecter dans le fonctionnement de SpringBoot via l'assemblage automatique, écrivez spring.factories

      Créez un dossier META-INF dans le répertoire des ressources,

      Créez un fichier spring.factories sous le META. -Dossier INF#🎜🎜 #Le contenu est

       /**
        * @author Ning Zaichun
        */
       public class OssTemplate {
      
           private OssProperties ossProperties;
      
           public OssTemplate(OssProperties ossProperties) {
               this.ossProperties = ossProperties;
           }
      
           public String test() {
               System.out.println(ossProperties.getBucketName());
               return "test";
           }
           public String upload(String filename, InputStream is) {
               // yourEndpoint填写Bucket所在地域对应的Endpoint。以华东1(杭州)为例,Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。
               String endpoint = ossProperties.getEndpoint();
               // 阿里云主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM账号进行API访问或日常运维,请登录 https://ram.console.aliyun.com 创建RAM账号。
               String accessKeyId = ossProperties.getAccessKey();
               String accessKeySecret = ossProperties.getSecret();
      
               // 创建OSSClient实例。
               OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
      
               String storePath = new SimpleDateFormat("yyyy/MM/dd").format(new Date()) + "/" + UUID.randomUUID() + filename.substring(filename.lastIndexOf("."));
      
               System.out.println(storePath);
               // 依次填写Bucket名称(例如examplebucket)和Object完整路径(例如exampledir/exampleobject.txt)。Object完整路径中不能包含Bucket名称。
               ossClient.putObject(ossProperties.getBucketName(), storePath, is);
      
               String url = ossProperties.getUrl() + storePath;
      
               // 关闭OSSClient。
               ossClient.shutdown();
               return url + "#" + storePath;
          }
      
           public void remove(String fileUrl) {
               // yourEndpoint填写Bucket所在地域对应的Endpoint。以华东1(杭州)为例,Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。
               String endpoint = ossProperties.getEndpoint();
               // 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
               String accessKeyId = ossProperties.getAccessKey();
               String accessKeySecret = ossProperties.getSecret();
               // 填写Bucket名称。
               String bucketName = ossProperties.getBucketName();
               // 填写文件完整路径。文件完整路径中不能包含Bucket名称。
               //2022/01/21/f0870eb3-4714-4fae-9fc3-35e72202f193.jpg
               String objectName = fileUrl;
      
               // 创建OSSClient实例。
               OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
      
               // 删除文件或目录。如果要删除目录,目录必须为空。
               ossClient.deleteObject(bucketName, objectName);
      
               // 关闭OSSClient。
               ossClient.shutdown();
           }
       }
      Copier après la connexion

      Comment implémenter le mécanisme SpringBoot SPI et le démarreur personnaliséS'il y en a plusieurs :

       public class SmsTemplate {
      
           private SmsProperties properties;
      
           public SmsTemplate(SmsProperties properties) {
               this.properties = properties;
           }
      
           public void sendSms(String mobile, String code){
               System.out.println(properties.getName()+"=="+mobile+"===="+code);
           }
       }
      Copier après la connexion

      Comment implémenter le mécanisme SpringBoot SPI et le démarreur personnalisé#🎜🎜 #Après avoir atteint cette étape, nous allons convertir ce projet en package Jar, puis l'introduire dans le projet à utiliser.

      • 2.6. Test d'application

      • 1. Il faut démarrer la classe pour tester, sinon il n'y aura pas de contexte~

      2 Écrivez le fichier de configuration

       @EnableConfigurationProperties({
           SmsProperties.class,
           OssProperties.class
               })
       public class CommonAutoConfig {
      
           @Bean
           public SmsTemplate smsTemplate(SmsProperties smsProperties){
               return new SmsTemplate(smsProperties);
           }
      
           @Bean
           public OssTemplate ossTemplate(OssProperties ossProperties){
               return new OssTemplate(ossProperties);
           }
      
       }
      Copier après la connexion
      #. 🎜🎜#will Si la configuration oss est modifiée correctement, elle peut être utilisée~

      Écrivez une classe de test :

       org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
         com.nzc.CommonAutoConfig
      Copier après la connexion

      Prouvez-le peut être utilisé~Comment implémenter le mécanisme SpringBoot SPI et le démarreur personnalisé# 🎜🎜#

      #🎜🎜#

      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!

      Étiquettes associées:
      source:yisu.com
      Déclaration de ce site Web
      Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
      Tutoriels populaires
      Plus>
      Derniers téléchargements
      Plus>
      effets Web
      Code source du site Web
      Matériel du site Web
      Modèle frontal