[JAVA] Introduction de la bibliothèque ff4j qui réalise le basculement de fonctionnalités avec Spring Boot

Qu'est-ce que le basculement de fonctionnalité?

• Ceci est une histoire de base, donc si vous la connaissez, veuillez la sauter. FeatureToggle est simplement une branche conditionnelle qui active et désactive une fonctionnalité. Il est également appelé indicateur de fonctionnalité.

Par exemple, comme indiqué ci-dessous, préparez une variable booléenne appelée ʻuseNewAlgorithm pour utiliser un nouvel algorithme, et utilisez-la dans des situations où le nouvel algorithme et l'ancien algorithme sont utilisés correctement selon le vrai / faux de ʻuseNewAlgorithm.

  function reticulateSplines(){
    var useNewAlgorithm = false;
    // useNewAlgorithm = true; // UNCOMMENT IF YOU ARE WORKING ON THE NEW SR ALGORITHM
  
    if( useNewAlgorithm ){
      return enhancedSplineReticulation();
    }else{
      return oldFashionedSplineReticulation();
    }
  }
  
  function oldFashionedSplineReticulation(){
    // current implementation lives here
  }
  
  function enhancedSplineReticulation(){
    // TODO: implement better SR algorithm
  }

L'indicateur de fonctionnalité est souvent utilisé lors de la fourniture de nouvelles fonctionnalités avec un calendrier de publication fixe, des versions Canary, des tests A / B, etc.

FF4J

https://ff4j.github.io/

FF4j est une bibliothèque Java qui peut facilement réaliser le basculement de fonctionnalités.

• Basculement en temps réel à l'aide de la console Web et de l'API REST --Persistance d'état utilisant divers stockages
• Surveillance de l'utilisation des fonctionnalités

Diverses fonctions telles que fournies.

Procédure d'installation

Créer un projet

Créez un projet en sélectionnant uniquement Spring Reactive Web, lombok de Spring Initializr que tout le monde aime.

Introduction de FF4j

Ajoutez une dépendance à pom.xml.

pom.xml

<dependency>
    <groupId>org.ff4j</groupId>
    <artifactId>ff4j-spring-boot-starter</artifactId>
    <version>1.8</version>
</dependency>

Créer une définition et une fonctionnalité de bean pour FF4j.

FF4JConfiguration.java

import org.ff4j.FF4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FF4JConfiguration {
    @Bean
    public FF4j ff4j() {
        FF4j ff4j = new FF4j()
                .createFeature(awesomeFeature())
                .createFeature(greatFeature())
                .createFeature(excellentFeature());
        return ff4j;
    }

    private Feature awesomeFeature() {
        return new Feature("AwesomeFeature", true);
    }

    private Feature greatFeature() {
        return new Feature("GreatFeature", false);
    }

    private Feature excellentFeature() {
        return new Feature("ExcellentFeature", false);
    }
}

Cette fois, nous avons défini trois fonctionnalités, ʻAwesomeFeature, GreatFeature et ʻExcellentFeature, et activé uniquement ʻAwesomeFeature`.

Mettre en œuvre le contrôleur à l'aide de FF4j. Dans le contrôleur qui ne renvoie qu'un simple message, si les trois fonctionnalités définies sont activées, il est ajouté au message en fonction des fonctionnalités.

GreetingController.java

@RestController
@RequiredArgsConstructor
public class GreetingController {

    //Injection de constructeur
    private final FF4j ff4j;

    @GetMapping
    public String greeting() {
        List<String> features = new ArrayList<>();
        addFeatures(features);
        String greeting = String.format("Hello, %s World!!", String.join(" ", features));

        return greeting;
    }

    //Traitement de chaque fonctionnalité
    private void addFeatures(List<String> features) {
        if(ff4j.check("AwesomeFeature")) {
            features.add("Awesome");
        }

        if(ff4j.check("GreatFeature")) {
            features.add("Great");
        }

        if(ff4j.check("ExcellentFeature")) {
            features.add("Excellent");
        }
    }
}

Lancez l'application et accédez à http: // localhost: 8080.

Par défaut, ʻAwesome Feature est activé, le message sera donc affiché comme Hello, Awesome World! `.

Présentation de la console Web

Ensuite, nous présenterons la console de gestion de FF4j. Dans l'état précédent, il était nécessaire d'activer / désactiver la fonctionnalité sur le code source, mais en utilisant WebConsole, il est possible d'activer / désactiver la fonctionnalité pendant que l'application est en cours d'exécution.

Ajoutez une dépendance à pom.xml.

<dependency>
	<groupId>org.ff4j</groupId>
	<artifactId>ff4j-web</artifactId>
	<version>1.8</version>
</dependency>
<dependency>
	<groupId>org.thymeleaf</groupId>
	<artifactId>thymeleaf</artifactId>
	<version>2.1.4.RELEASE</version>
</dependency>

Ajoutez une nouvelle définition de bean.

@Configuration
@ConditionalOnClass({ConsoleServlet.class, FF4jDispatcherServlet.class})
@AutoConfigureAfter(FF4JConfiguration.class)
public class FF4JWebConfiguration extends SpringBootServletInitializer {

    @Bean
    public ServletRegistrationBean<FF4jDispatcherServlet> ff4jDispatcherServletRegistrationBean(FF4jDispatcherServlet ff4jDispatcherServlet)
    {
        ServletRegistrationBean<FF4jDispatcherServlet> bean = new ServletRegistrationBean<>(ff4jDispatcherServlet, "/ff4j-web-console/*");
        bean.setName("ff4j-console");
        bean.setLoadOnStartup(1);
        return bean;
    }

    @Bean
    @ConditionalOnMissingBean
    public FF4jDispatcherServlet getFF4jDispatcherServlet(FF4j ff4j) {
        FF4jDispatcherServlet ff4jDispatcherServlet = new FF4jDispatcherServlet();
        ff4jDispatcherServlet.setFf4j(ff4j);
        return ff4jDispatcherServlet;
    }

}

Démarrez et accédez à http: // localhost: 8080 / ff4j-web-console.

Vous pouvez vérifier les fonctionnalités actuellement définies dans le menu "Fonctionnalités", La fonction est activée / désactivée lorsque la bascule est activée / désactivée.

Démo d'animation GIF

Je publierai également une démo du contenu expliqué ci-dessus pris avec une animation GIF. Pour votre information.

Résumé

J'ai donné une brève introduction de FF4j. La fonctionnalité Toggle est une technique puissante, mais si vous ne définissez pas de politique d'opération, une base de code chaotique sera créée, je veux donc être prudent lors de son utilisation. Il est nécessaire d'avoir un cadre tel que la séparation des caractéristiques à DI pour chaque profil et la définition des normes de codage et des points de révision.

référence

martinFowler.com - FeatureToggle: https://martinfowler.com/articles/feature-toggles.html FF4j: https://ff4j.github.io/ Référentiel utilisé cette fois: https://github.com/IshinFUKUOKA/ff4j-demo