Implementieren Sie die Feature-Flag-Verwaltung in Ihrer Spring Boot-Anwendung mithilfe von API-Aufrufen und der Benutzeroberfläche mit Togglz

In der modernen Softwareentwicklung ist die Fähigkeit, Funktionen in einer Live-Anwendung zu steuern, ohne neuen Code bereitzustellen, von entscheidender Bedeutung. Diese als Feature-Flag-Management bekannte Funktion ermöglicht es Teams, Funktionen in Echtzeit zu aktivieren oder zu deaktivieren und so kontinuierliche Bereitstellung, A/B-Tests und Canary-Releases zu ermöglichen. Es spielt auch eine wichtige Rolle bei der Reduzierung der mit neuen Bereitstellungen verbundenen Risiken, indem es die Offenlegung neuer Funktionen für Benutzer kontrolliert.

In diesem Artikel gehen wir durch den Prozess der Implementierung der Feature-Flag-Verwaltung in einer Spring Boot-Anwendung mithilfe von Togglz. Wir erfahren, wie Sie Togglz konfigurieren, Feature-Flags definieren und deren Verhalten in Ihrer Anwendung steuern.

1. Einrichten von Togglz in Ihrer Spring Boot-Anwendung

Um mit Togglz zu beginnen, müssen Sie die erforderlichen Abhängigkeiten zu Ihrem Spring Boot-Projekt hinzufügen. Öffnen Sie Ihre build.gradle- oder pom.xml-Datei und fügen Sie die folgenden Abhängigkeiten hinzu:

implementation 'org.togglz:togglz-spring-boot-starter:3.1.2'
implementation 'org.togglz:togglz-console:3.3.3'

Diese Abhängigkeiten umfassen die Kernfunktionalität von Togglz und eine optionale webbasierte Konsole zum Verwalten Ihrer Feature-Flags.

2. Konfigurieren von Togglz

Als nächstes müssen Sie Togglz in Ihrer Spring Boot-Anwendung konfigurieren. Dazu gehört das Einrichten einer FeatureManager-Bean, die Togglz zum Verwalten Ihrer Feature-Flags verwendet.

So können Sie es machen:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.togglz.core.manager.FeatureManager;
import org.togglz.core.manager.FeatureManagerBuilder;
import org.togglz.core.repository.jdbc.JdbcStateRepository;
import org.togglz.core.user.NoOpUserProvider;

import javax.sql.DataSource;

@Configuration
public class TogglzConfiguration {

    private final DataSource dataSource;

    @Autowired
    public TogglzConfiguration(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    @Bean
    public FeatureManager featureManager() {
        return new FeatureManagerBuilder()
                .featureEnum(ProductCheckFeature.class)
                .stateRepository(new JdbcStateRepository(dataSource))
                .userProvider(new NoOpUserProvider())
                .build();
    }
}

Erklärung:

• DataSource: Die DataSource wird zur Verwendung durch das JdbcStateRepository injiziert. Dadurch kann Togglz Feature-Flag-Status in einer Datenbank beibehalten.
• FeatureManager: Der FeatureManager wird mit einem FeatureManagerBuilder erstellt. Wir geben die Enumeration an, die die Features definiert (ProductCheckFeature.class), verwenden ein JdbcStateRepository zum Speichern von Feature-Status und einen NoOpUserProvider, da wir in diesem Beispiel keine Benutzer mit Features verknüpfen.

3. Definieren von Feature-Flags mit Enums

Togglz verwendet Enumerationen, um Feature-Flags zu definieren. Jede Konstante in der Enumeration stellt eine Funktion dar, die ein- oder ausgeschaltet werden kann. Hier ist ein Beispiel:

import org.togglz.core.Feature;
import org.togglz.core.annotation.Label;

public enum ProductCheckFeature implements Feature {

    @Label("product-check")
    PRODUCT_CHECK,

}

Erklärung:

Label: Die @Label-Annotation stellt einen für Menschen lesbaren Namen für die Funktion bereit. Dieser Name wird in der Togglz-Konsole angezeigt, wenn Sie sich entscheiden, ihn zu verwenden.

4. Verwenden von Feature Flags in Ihrer Anwendung

Sobald die Feature-Flags definiert und die Konfiguration vorhanden ist, können Sie sie in Ihrer Anwendung verwenden. Hier ist ein Beispiel dafür, wie Sie prüfen können, ob eine Funktion aktiv ist, bevor Sie bestimmten Code ausführen:

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.togglz.core.manager.FeatureManager;
import reactor.core.publisher.Mono;

import javax.servlet.http.HttpServletRequest;

@RestController
@RequestMapping("/api/products")
public class ProductController {

    private final FeatureManager featureManager;
    private final ProductService productService;

    public ProductController(FeatureManager featureManager, ProductService productService) {
        this.featureManager = featureManager;
        this.productService = productService;
    }

    @GetMapping("/check")
    public Mono<ResponseEntity<?>> checkProduct(@RequestParam String isbn, HttpServletRequest httpServletRequest) {
        if (featureManager.isActive(ProductCheckFeature.PRODUCT_CHECK)) {
            return productService
                    .productCheck(isbn, JwtUtils.getUserJwt(httpServletRequest), Boolean.FALSE)
                    .flatMap(response -> Mono.just(ResponseEntity.ok(response)));
        } 
        return Mono.just(ResponseEntity.status(HttpStatus.NOT_IMPLEMENTED).body("Feature is disabled"));
    }
}

Erklärung:

• FeatureManager: Der FeatureManager wird in den Controller eingefügt und verwendet, um zu prüfen, ob die PRODUCT_CHECK-Funktion aktiv ist.
• Bedingte Logik: Wenn die Funktion aktiv ist, wird die Produktprüfung durchgeführt; andernfalls wird die Meldung „Funktion ist deaktiviert“ zurückgegeben.

5. Feature-Flags über die Togglz-Konsole verwalten

Die Togglz-Konsole ist ein leistungsstarkes Tool, mit dem Sie Ihre Feature-Flags über eine Weboberfläche verwalten können. Um die Togglz-Konsole zu aktivieren, fügen Sie einfach die folgende Eigenschaft zu Ihrer application.properties- oder application.yml-Datei hinzu:

implementation 'org.togglz:togglz-spring-boot-starter:3.1.2'
implementation 'org.togglz:togglz-console:3.3.3'

Sie können auf die Konsole zugreifen, indem Sie in Ihrem Webbrowser zu /togglz-console navigieren. Die Konsole bietet eine benutzerfreundliche Oberfläche zum Ein- und Ausschalten von Funktionen, zum Ändern ihrer Strategien und zum Anzeigen ihres aktuellen Status.

Fazit

Die Implementierung der Feature-Flag-Verwaltung mit Togglz in Ihrer Spring Boot-Anwendung ist ein unkomplizierter Prozess, der eine leistungsstarke Kontrolle über Ihre Funktionen bietet. Indem Sie die in diesem Artikel beschriebenen Schritte befolgen, können Sie Feature-Flags einfach konfigurieren, definieren und verwalten und so neue Funktionen sicher und flexibel veröffentlichen.

Ob Sie eine neue Funktion schrittweise einführen, A/B-Tests durchführen oder einfach nur Bereitstellungsrisiken minimieren möchten, Togglz bietet eine robuste Lösung, die sich nahtlos in Ihre Spring Boot-Anwendung integriert.

Viel Spaß beim Codieren! ?

Das obige ist der detaillierte Inhalt vonImplementieren Sie die Feature-Flag-Verwaltung in Ihrer Spring Boot-Anwendung mithilfe von API-Aufrufen und der Benutzeroberfläche mit Togglz. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!