Szybki start: tworzenie aplikacji Java Spring przy użyciu usługi aplikacja systemu Azure Configuration

Artykuł
12/12/2024

W tym przewodniku Szybki start uwzględnisz aplikacja systemu Azure Configuration w aplikacji Java Spring, aby scentralizować magazyn i zarządzanie ustawieniami aplikacji niezależnie od kodu.

Wymagania wstępne

Konto platformy Azure z aktywną subskrypcją. Utwórz je bezpłatnie.
Magazyn usługi App Configuration. Utwórz magazyn.
Obsługiwany zestaw Java Development Kit (JDK) w wersji 11.
Apache Maven w wersji 3.0 lub nowszej.
Aplikacja Spring Boot. Jeśli go nie masz, utwórz projekt Maven za pomocą narzędzia Spring Initializr. Pamiętaj, aby wybrać pozycję Projekt Maven i w obszarze Zależności dodaj zależność Spring Web , a następnie wybierz pozycję Java w wersji 8 lub nowszej.

Dodawanie wartości klucza

Dodaj następującą wartość klucza do magazynu App Configuration i pozostaw wartości domyślne Etykieta i Typ zawartości. Aby uzyskać więcej informacji na temat dodawania wartości klucz-wartości do magazynu przy użyciu witryny Azure Portal lub interfejsu wiersza polecenia, przejdź do artykułu Create a key-value (Tworzenie wartości klucza).

Key	Wartość
/application/config.message	Hello (Cześć)

Nawiązywanie połączenia z magazynem usługi App Configuration

Teraz, gdy masz sklep App Configuration, możesz użyć szablonu startowego Spring Cloud Azure Config, aby aplikacja komunikowała się z utworzonym magazynem App Configuration.

Aby zainstalować moduł startowy Spring Cloud Azure Config, dodaj następującą zależność do pliku pom.xml :

<dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-appconfiguration-config-web</artifactId>
</dependency>

<dependencyManagement>
    <dependencies>
        <dependency>
        <groupId>com.azure.spring</groupId>
        <artifactId>spring-cloud-azure-dependencies</artifactId>
        <version>5.18.0</version>
        <type>pom</type>
        <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Kodowanie aplikacji

Aby użyć szablonu startowego Spring Cloud Azure Config, aby aplikacja komunikowała się z utworzonym magazynem App Configuration, skonfiguruj aplikację, wykonując następujące kroki.

Utwórz nowy plik Java o nazwie MyProperties.java i dodaj następujące wiersze:

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "config")
public class MyProperties {
    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

Utwórz nowy plik Java o nazwie HelloController.java i dodaj następujące wiersze:

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    private final MyProperties properties;

    public HelloController(MyProperties properties) {
        this.properties = properties;
    }

    @GetMapping
    public String getMessage() {
        return "Message: " + properties.getMessage();
    }
}

W głównym pliku Java aplikacji dodaj @EnableConfigurationProperties , aby umożliwić działanie klasy właściwości konfiguracji MyProperties.java i zarejestrować ją w kontenerze Spring.

import org.springframework.boot.context.properties.EnableConfigurationProperties;

@SpringBootApplication
@EnableConfigurationProperties(MyProperties.class)
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

Użyj polecenia DefaultAzureCredential , aby uwierzytelnić się w magazynie usługi App Configuration. Postępuj zgodnie z instrukcjami, aby przypisać poświadczenia roli Czytelnik danych konfiguracji aplikacji. Przed uruchomieniem aplikacji należy zezwolić na wystarczający czas na propagację uprawnień. Utwórz nowy plik o nazwie AppConfigCredential.java i dodaj następujące wiersze:

import org.springframework.stereotype.Component;

import com.azure.data.appconfiguration.ConfigurationClientBuilder;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.spring.cloud.appconfiguration.config.ConfigurationClientCustomizer;

@Component
public class AppConfigCredential implements ConfigurationClientCustomizer {

    @Override
    public void customize(ConfigurationClientBuilder builder, String endpoint) {
        builder.credential(new DefaultAzureCredentialBuilder().build());
    }
}

Następnie utwórz konfigurację Bootstrap Configuration, tworząc plik w resources/META-INF katalogu i dodaj następujące wiersze i aktualizując spring.factories com.example.MyApplication przy użyciu nazwy aplikacji i pakietu:
```
org.springframework.cloud.bootstrap.BootstrapConfiguration=\
com.example.MyApplication
```

Otwórz automatycznie wygenerowany test jednostkowy i zaktualizuj go, aby wyłączyć aplikacja systemu Azure Configuration lub spróbuje załadować z usługi podczas uruchamiania testów jednostkowych.

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest(properties = "spring.cloud.azure.appconfiguration.enabled=false")
class DemoApplicationTests {

    @Test
    void contextLoads() {
    }

}

Utwórz nowy plik o nazwie bootstrap.properties w katalogu resources aplikacji i dodaj następujący wiersz do pliku.
```
spring.cloud.azure.appconfiguration.stores[0].endpoint= ${APP_CONFIGURATION_ENDPOINT}
```
Ustaw zmienną środowiskową o nazwie APP_CONFIGURATION_ENDPOINT i ustaw ją na klucz dostępu do magazynu usługi App Configuration. W wierszu polecenia uruchom następujące polecenie i uruchom ponownie wiersz polecenia, aby umożliwić wprowadzenie zmiany:
```
setx APP_CONFIGURATION_ENDPOINT "endpoint-of-your-app-configuration-store"
```
Jeśli używasz programu Windows PowerShell, uruchom następujące polecenie:
```
$Env:APP_CONFIGURATION_ENDPOINT = "endpoint-of-your-app-configuration-store"
```
Jeśli używasz systemu macOS lub Linux, uruchom następujące polecenie:
```
export APP_CONFIGURATION_ENDPOINT='endpoint-of-your-app-configuration-store'
```

Lokalne kompilowanie i uruchamianie aplikacji

Otwórz wiersz polecenia w katalogu głównym i uruchom następujące polecenia, aby skompilować aplikację Spring Boot za pomocą narzędzia Maven i uruchomić ją.
```
mvn clean package
mvn spring-boot:run
```
Po uruchomieniu aplikacji użyj narzędzia curl , aby przetestować aplikację, na przykład:
```
curl -X GET http://localhost:8080/
```
Zostanie wyświetlony komunikat wprowadzony w magazynie App Configuration.

Czyszczenie zasobów

Jeśli nie chcesz nadal korzystać z zasobów utworzonych w tym artykule, usuń utworzoną tutaj grupę zasobów, aby uniknąć naliczania opłat.

Ważne

Usunięcie grupy zasobów jest nieodwracalne. Grupa zasobów i wszystkie zasoby w niej są trwale usuwane. Upewnij się, że nie usuniesz przypadkowo nieprawidłowej grupy zasobów ani zasobów. Jeśli zasoby dla tego artykułu zostały utworzone w grupie zasobów zawierającej inne zasoby, które chcesz zachować, usuń każdy zasób oddzielnie z odpowiedniego okienka zamiast usuwać grupę zasobów.

Zaloguj się do witryny Azure Portal i wybierz pozycję Grupy zasobów.
W polu Filtruj według nazwy wprowadź nazwę grupy zasobów.
Na liście wyników wybierz nazwę grupy zasobów, aby wyświetlić przegląd.
Wybierz pozycję Usuń grupę zasobów.
Zobaczysz prośbę o potwierdzenie usunięcia grupy zasobów. Wprowadź nazwę grupy zasobów, aby potwierdzić, a następnie wybierz pozycję Usuń.

Po kilku chwilach grupa zasobów i wszystkie jej zasoby zostaną usunięte.

Następne kroki

W tym przewodniku Szybki start utworzono nowy magazyn App Configuration i użyto go z aplikacją Java Spring. Aby uzyskać więcej informacji, zobacz Spring on Azure (Platforma Spring na platformie Azure). Aby uzyskać więcej pytań, zobacz dokumentację referencyjną, zawiera ona wszystkie szczegółowe informacje na temat działania biblioteki konfiguracji spring cloud aplikacja systemu Azure. Aby dowiedzieć się, jak umożliwić aplikacji Java Spring dynamiczne odświeżanie ustawień konfiguracji, przejdź do następnego samouczka.

Włączanie konfiguracji dynamicznej

Udostępnij za pośrednictwem