Netflix Archaius mit verschiedenen Datenbankkonfigurationen

1. Überblick

Das Netflix Archaius bietet Bibliotheken und Funktionen zum Verbinden mit vielen Datenquellen.

  • In diesem Lernprogramm erfahren Sie, wie Sie Konfigurationen erhalten: **

  • Verwenden der JDBC-API zum Herstellen einer Verbindung mit einer Datenbank

  • Von Konfigurationen, die in einer DynamoDB-Instanz gespeichert sind

  • Durch Konfigurieren von Zookeeper als dynamische verteilte Konfiguration

Zur Einführung in Netflix Archaius siehe https://www.baeldung.com/netflix-archaius-spring-cloud-integration (bitte lesen Sie diesen Artikel)

2. Verwenden von Netflix Archaius mit einer JDBC-Verbindung

  • Wie wir im Einführungs-Tutorial erläutert haben, müssen wir immer, wenn Archaius die Konfigurationen handhaben soll, eine AbstractConfiguration -Bean von Apache erstellen. **

Die Bean wird automatisch von der Spring Cloud Bridge erfasst und zum Compai Configuration Stack des Archaius hinzugefügt.

2.1. Abhängigkeiten

Die gesamte Funktionalität, die zum Herstellen einer Verbindung mit einer Datenbank mithilfe von JDBC erforderlich ist, ist in der Kernbibliothek enthalten. Daher benötigen wir keine zusätzlichen Abhängigkeiten außer den im einführenden Tutorial genannten:

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-archaius</artifactId>
    </dependency>
</dependencies>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-netflix</artifactId>
            <version>2.0.1.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Wir können Maven Central überprüfen, um zu überprüfen, ob wir die neueste Version der https://search.maven.org/search?q=spring-cloud-starter-netflix-archaius [starter-Bibliothek verwenden.

2.2. So erstellen Sie das Configuration Bean

  • In diesem Fall müssen Sie das Bean AbstractConfiguration mit einer JDBCConfigurationSource -Instanz erstellen. **

Um anzugeben, wie die Werte aus der JDBC-Datenbank abgerufen werden können, müssen Sie Folgendes angeben:

  • ein javax.sql.Datasource -Objekt

  • eine SQL-Abfragezeichenfolge, mit der mindestens zwei Spalten abgerufen werden

Konfigurationsschlüssel und die entsprechenden Werte ** zwei Spalten, die jeweils die Eigenschaftsschlüssel und -werte angeben

Dann machen wir weiter und erstellen diese Bean:

@Autowired
DataSource dataSource;

@Bean
public AbstractConfiguration addApplicationPropertiesSource() {
    PolledConfigurationSource source =
      new JDBCConfigurationSource(dataSource,
        "select distinct key, value from properties",
        "key",
        "value");
    return new DynamicConfiguration(source, new FixedDelayPollingScheduler());
}

2.3. Ausprobieren

Um es einfach zu halten und dennoch ein praktisches Beispiel zu haben, werden wir eine H2-In-Memory-Datenbankinstanz mit einigen Anfangsdaten einrichten.

Um dies zu erreichen, fügen wir zunächst die notwendigen Abhängigkeiten hinzu:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
    <version>2.0.5.RELEASE</version>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <version>1.4.197</version>
    <scope>runtime</scope>
</dependency>

Hinweis: Wir können die neuesten Versionen von https://search.maven.org/search überprüfen. Q = g: com.h2database% 20a: h2[h2] und https://search.maven.org/search q = a: Spring-Boot-Starter-Data-Jpa% 20g: org.springframework.boot[Spring-Boot-Starter-Data-JPA] Bibliotheken in Maven Central.

Als Nächstes erklären wir die JPA-Entität, die unsere Eigenschaften enthält:

@Entity
public class Properties {
    @Id
    private String key;
    private String value;
}

Wir fügen eine data.sql -Datei in unsere Ressourcen ein, um die In-Memory-Datenbank mit einigen Anfangswerten aufzufüllen:

insert into properties
values('baeldung.archaius.properties.one', 'one FROM:jdbc__source');

Um den Wert der Eigenschaft an einem bestimmten Punkt zu prüfen, können Sie einen Endpunkt erstellen, der die von Archaius verwalteten Werte abruft:

@RestController
public class ConfigPropertiesController {

    private DynamicStringProperty propertyOneWithDynamic = DynamicPropertyFactory
      .getInstance()
      .getStringProperty("baeldung.archaius.properties.one", "not found!");

    @GetMapping("/properties-from-dynamic")
    public Map<String, String> getPropertiesFromDynamic() {
        Map<String, String> properties = new HashMap<>();
        properties.put(propertyOneWithDynamic.getName(), propertyOneWithDynamic.get());
        return properties;
    }
}

Wenn sich die Daten zu irgendeinem Zeitpunkt ändern, erkennt Archaius sie zur Laufzeit und beginnt mit dem Abrufen der neuen Werte.

Dieser Endpunkt kann natürlich auch in den nächsten Beispielen verwendet werden.

3. Erstellen einer Konfigurationsquelle mithilfe einer DynamoDB-Instanz

Wie im letzten Abschnitt erstellen wir ein voll funktionsfähiges Projekt, um richtig zu analysieren, wie Archaius Eigenschaften mit einer DynamoDB-Instanz als Konfigurationsquelle verwaltet.

3.1. Abhängigkeiten

Fügen wir der pom.xml -Datei die folgenden Bibliotheken hinzu:

<dependency>
    <groupId>com.amazonaws</groupId>
    <artifactId>aws-java-sdk-dynamodb</artifactId>
    <version>1.11.414</version>
</dependency>
<dependency>
    <groupId>com.github.derjust</groupId>
    <artifactId>spring-data-dynamodb</artifactId>
    <version>5.0.3</version>
</dependency>
<dependency>
    <groupId>com.netflix.archaius</groupId>
    <artifactId>archaius-aws</artifactId>
    <version>0.7.6</version>
</dependency>

Wir können Maven Central auf die neuesten Versionen der Abhängigkeiten überprüfen, aber für die Version archaius-aws empfehlen wir, die Version von https://github.com/spring-cloud/spring-cloud-netflix/blob/master/spring zu verwenden -cloud-netflix-dependencies/pom.xml[der Spring Cloud Netflix-Bibliothek].

Die Abhängigkeit von aws-java-sdk-dynamodb ermöglicht es uns, den DynamoDB-Client für die Verbindung zur Datenbank einzurichten.

Mit der Bibliothek spring-data-dynamodb werden wir das DynamoDB-Repository einrichten.

Und schließlich verwenden wir die Bibliothek archaius-aws , um die AbstractConfiguration zu erstellen.

3.2. Verwenden von DynamoDB als Konfigurationsquelle

Dieses Mal wird die _AbstractConfiguration mithilfe eines DynamoDbConfigurationSource_ -Objekts erstellt:

@Autowired
AmazonDynamoDB amazonDynamoDb;

@Bean
public AbstractConfiguration addApplicationPropertiesSource() {
    PolledConfigurationSource source = new DynamoDbConfigurationSource(amazonDynamoDb);
    return new DynamicConfiguration(
      source, new FixedDelayPollingScheduler());
}
  • Standardmäßig sucht Archaius nach einer Tabelle mit dem Namen "archaiusProperties", die ein Schlüssel- und ein Wertattribut in der Dynamo-Datenbank enthält, die als Quelle verwendet werden.

Wenn Sie diese Werte überschreiben möchten, müssen Sie die folgenden Systemeigenschaften angeben:

  • com.netflix.config.dynamo.tableName

  • com.netflix.config.dynamo.keyAttributeName

  • com.netflix.config.dynamo.valueAttributeName

3.3. Erstellen eines voll funktionsfähigen Beispiels

Wie in https://www.baeldung.com/spring-data-dynamodb#DynamoDB dieses DynamoDB-Handbuch], werden wir zunächst eine lokale DynamoDB-Instanz installieren, um die Funktionalität einfach zu testen.

Wir befolgen auch die Anweisungen des Handbuchs, um die AmazonDynamoDB -Instanz zu erstellen, die wir zuvor automatisch eingerichtet haben

Um die Datenbank mit einigen Anfangsdaten zu füllen, erstellen wir zuerst eine DynamoDBTable -Entität, um die Daten abzubilden:

@DynamoDBTable(tableName = "archaiusProperties")
public class ArchaiusProperties {

    @DynamoDBHashKey
    @DynamoDBAttribute
    private String key;

    @DynamoDBAttribute
    private String value;

   //...getters and setters...
}

Als Nächstes erstellen wir ein CrudRepository für diese Entität:

public interface ArchaiusPropertiesRepository extends CrudRepository<ArchaiusProperties, String> {}

Schließlich verwenden wir das Repository und die AmazonDynamoDB -Instanz, um die Tabelle zu erstellen und anschließend die Daten einzufügen:

@Autowired
private ArchaiusPropertiesRepository repository;

@Autowired
AmazonDynamoDB amazonDynamoDb;

private void initDatabase() {
    DynamoDBMapper mapper = new DynamoDBMapper(amazonDynamoDb);
    CreateTableRequest tableRequest = mapper
      .generateCreateTableRequest(ArchaiusProperties.class);
    tableRequest.setProvisionedThroughput(new ProvisionedThroughput(1L, 1L));
    TableUtils.createTableIfNotExists(amazonDynamoDb, tableRequest);

    ArchaiusProperties property = new ArchaiusProperties("baeldung.archaius.properties.one", "one FROM:dynamoDB");
    repository.save(property);
}

Wir können diese Methode direkt vor dem Erstellen der DynamoDbConfigurationSource aufrufen.

Wir sind jetzt bereit, die Anwendung auszuführen.

4. Einrichten einer Dynamic Zookeeper Distributed Configuration

  • Wie wir bereits vor https://www.baeldung.com/java-zookeeper} im einführenden Zookeeper-Artikel]gesehen haben, ist der Vorteil dieses Tools die Möglichkeit, es als verteilter Konfigurationsspeicher zu verwenden.

Wenn wir es mit Archaius kombinieren, erhalten wir eine flexible und skalierbare Lösung für das Konfigurationsmanagement.

4.1. Abhängigkeiten

Folgen Sie http://cloud.spring.io/spring-cloud-zookeeper/single/spring-cloud-zookeeper.html#spring-cloud-zookeeper-install (die offiziellen Spring Cloud-Anweisungen), um die stabilere Version von zu installieren Apaches Zookeeper.

Der einzige Unterschied ist, dass wir nur einen Teil der von Zookeeper bereitgestellten Funktionalität benötigen. Daher können wir die Abhängigkeit von spring-cloud-starter-zookeeper-config anstelle der im offiziellen Leitfaden verwendeten verwenden:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zookeeper-config</artifactId>
    <version>2.0.0.RELEASE</version>
    <exclusions>
        <exclusion>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.4.13</version>
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </exclusion>
    </exclusions>
</dependency>

Auch hier können wir die neuesten Versionen von spring-cloud-starter-zookeeper-config und https://überprüfen . search.maven.org/search?q=g:org.apache.zookeeper%20a:zookeeper[ zookeeper ]Abhängigkeiten in Maven Central.

Bitte vermeiden Sie die zookeeper Beta-Versionen.

4.2. Spring Clouds automatische Konfiguration

  • Wie in der offiziellen Dokumentation erläutert, reicht die Abhängigkeit von spring-cloud-starter-zookeeper-config aus, um die Zookeeper-Eigenschaftsquellen einzurichten. **

Standardmäßig wird nur eine Quelle automatisch konfiguriert, wobei die Eigenschaften unter dem Zookeeper-Knoten config/application gesucht werden. Dieser Knoten wird daher als gemeinsam genutzte Konfigurationsquelle zwischen verschiedenen Anwendungen verwendet.

Wenn wir außerdem einen Anwendungsnamen mit der Eigenschaft spring.application.name angeben, wird automatisch eine andere Quelle konfiguriert. Diesmal werden die Eigenschaften im Knoten config/<Anwendungsname> durchsucht.

  • Jeder Knotenname unter diesen übergeordneten Knoten gibt einen Eigenschaftsschlüssel an, und ihre Daten sind der Eigenschaftswert. **

Glücklicherweise, da Spring Cloud diese Eigenschaftsquellen zum Kontext hinzufügt, werden sie von Archaius automatisch verwaltet. Es ist nicht erforderlich, eine AbstractConfiguration programmgesteuert zu erstellen.

4.3. Vorbereiten der Ausgangsdaten

In diesem Fall benötigen wir auch einen lokalen Zookeeper-Server, um die Konfigurationen als Knoten zu speichern. Wir können https://zookeeper.apache.org/doc/r3.1.2/zookeeperStarted.html#sc__InstallingSingleMode (Apache-Handbuch) folgen, um einen eigenständigen Server einzurichten, der auf Port 2181 ausgeführt wird.

Um eine Verbindung zum Zookeeper-Dienst herzustellen und erste Daten zu erstellen, verwenden wir den Apache-Curator-Client :

@Component
public class ZookeeperConfigsInitializer {

    @Autowired
    CuratorFramework client;

    @EventListener
    public void appReady(ApplicationReadyEvent event) throws Exception {
        createBaseNodes();
        if (client.checkExists().forPath("/config/application/baeldung.archaius.properties.one") == null) {
            client.create()
              .forPath("/config/application/baeldung.archaius.properties.one",
              "one FROM:zookeeper".getBytes());
        } else {
            client.setData()
              .forPath("/config/application/baeldung.archaius.properties.one",
              "one FROM:zookeeper".getBytes());
        }
    }

    private void createBaseNodes() throws Exception {
        if (client.checkExists().forPath("/config") == null) {
            client.create().forPath("/config");
        }
        if (client.checkExists().forPath("/config/application") == null) {
            client.create().forPath("/config/application");
        }
    }
}

Wir können die Protokolle überprüfen, um die Eigenschaftsquellen anzuzeigen, um zu überprüfen, ob Netflix Archaius die Eigenschaften aktualisiert hat, sobald sie geändert wurden.

5. Schlussfolgerung

In diesem Artikel haben wir erfahren, wie wir mit Netflix Archaius erweiterte Konfigurationsquellen einrichten können. Es muss berücksichtigt werden, dass auch andere Quellen wie Etcd, Typesafe, AWS S3-Dateien und JClouds unterstützt werden.

Wie immer können wir alle Beispiele in our Github repo nachlesen.