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

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

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

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>

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;
 }

 @Data
 @ConfigurationProperties(prefix = "nzc.sms")
 public class SmsProperties {

     private String name;
 }

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();
     }
 }

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);
     }
 }

#🎜🎜 #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);
     }

 }

#. 🎜🎜#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

Prouvez-le peut être utilisé~# 🎜🎜#

#🎜🎜#

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!