Utiliser Feign pour effectuer des appels HTTP dans le développement d'API Java

Utilisez Feign pour effectuer des appels HTTP dans le développement d'API Java

Dans le développement d'applications Java, les appels HTTP sont souvent effectués pour obtenir des données de services externes ou appeler des API distantes. À l’heure actuelle, nous devons généralement choisir une bibliothèque client HTTP pour gérer ces requêtes. Dans ce domaine, Feign est sans aucun doute un bon choix.

Feign est une bibliothèque client HTTP déclarative qui simplifie l'appel des API RESTful. Il s'inspire du style d'annotation de Retrofit. En utilisant Feign, les développeurs peuvent facilement effectuer des requêtes HTTP sans connaître les détails d'implémentation du client HTTP sous-jacent.

Dans cet article, nous présenterons l'utilisation de base et quelques exemples d'utilisation de Feign pour effectuer des appels HTTP. Avant de commencer, nous devons importer la bibliothèque de Feign. Dans le projet Maven, nous pouvons ajouter les dépendances suivantes dans le fichier pom.xml :

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
    <version>2.2.2.RELEASE</version>
</dependency>

Ensuite, nous expliquerons comment l'utiliser.

Utilisation de base

Tout d'abord, nous devons définir une interface de service à distance. Cette interface doit contenir des méthodes pour chaque point de terminaison HTTP que nous souhaitons appeler. Pour chaque méthode, nous pouvons utiliser les annotations fournies par Feign pour définir divers aspects de la requête HTTP que nous souhaitons envoyer, tels que l'URL, la méthode HTTP, le corps de la requête, les en-têtes de requête, etc. L'exemple de code est le suivant :

@FeignClient(name = "github", url = "https://api.github.com")
public interface GitHubApiClient {
    @RequestMapping(value = "/users/{username}", method = RequestMethod.GET)
    GitHubUser getUserByName(@PathVariable("username") String username);
}

Dans cet exemple, nous définissons une interface client Feign GitHubApiClient, qui utilise l'annotation @FeignClient pour interagir avec le service distant nommé "github", et l'URL du service est https:// API.github.com. Il existe une méthode getUserByName dans l'interface. Sur cette méthode, nous utilisons les annotations @RequestMapping et @PathVariable pour spécifier les paramètres URL et chemin de la requête HTTP GET que nous souhaitons envoyer.

Ensuite, nous pouvons injecter l'interface dans notre code et faire des requêtes HTTP en appelant ses méthodes. L'exemple de code est le suivant :

@RestController
public class GitHubUserController {
    @Autowired
    private GitHubApiClient gitHubApiClient;

    @GetMapping("/users/{username}")
    public GitHubUser getUserByName(@PathVariable("username") String username) {
        return gitHubApiClient.getUserByName(username);
    }
}

Dans cet exemple, nous injectons GitHubApiClient dans GitHubUserController et utilisons cette interface dans la méthode getUserByName pour obtenir les informations utilisateur de GitHub. Cette méthode renverra l'objet de réponse renvoyé par Feign. Dans ce cas, la classe concrète est GitHubUser.

Configuration personnalisée de Feign

Parfois, nous devons personnaliser le comportement de Feign. Par exemple, nous devrons peut-être ajouter un intercepteur de requêtes, modifier le délai d'expiration ou modifier le niveau de journalisation. Dans ce cas, nous pouvons ajouter la configuration correspondante pour implémenter ces comportements personnalisés.

Pour configurer Feign, nous pouvons utiliser les annotations @ConfigurationProperties et @Bean fournies par Spring Cloud pour définir notre classe de configuration. Voici un exemple de configuration de Feign :

@ConfigurationProperties("feign.client.config.github")
public class GitHubFeignConfiguration {
    @Bean
    public RequestInterceptor requestInterceptor() {
        return new BasicAuthRequestInterceptor("username", "password");
    }
}

Dans cet exemple, nous ajoutons un intercepteur de requêtes utilisant la classe BasicAuthRequestInterceptor de Feign. De plus, nous avons utilisé l'annotation @ConfigurationProperties pour mapper notre configuration personnalisée avec les propriétés du fichier de propriétés.

Pour connecter cette configuration à notre interface client Feign, nous devons y utiliser les annotations @Configuration et @Import. L'exemple de code est le suivant :

@Configuration
@Import({GitHubFeignConfiguration.class})
public class GitHubApiConfiguration {
    @Bean
    public GitHubApiClient gitHubApiClient() {
        return Feign.builder()
                .decoder(new JacksonDecoder())
                .encoder(new JacksonEncoder())
                .contract(new SpringMvcContract())
                .target(GitHubApiClient.class, "https://api.github.com");
    }
}

Dans cet exemple, nous utilisons le modèle de générateur de Feign pour créer un objet GitHubApiClient. Sur la méthode build(), nous définissons l'encodeur, le décodeur et le contrat pour l'objet client Feign renvoyé. De plus, nous définissons l'adresse cible du type GitHubApiClient sur https://api.github.com.

Résumé

Dans cet article, nous avons présenté l'utilisation de la bibliothèque client Feign et quelques exemples. En utilisant Feign, nous pouvons facilement effectuer des appels HTTP de manière déclarative. Dans le développement quotidien, nous pouvons personnaliser le comportement de Feign en fonction des besoins spécifiques de l'entreprise. Si vous n'avez pas encore utilisé Feign pour le développement, autant l'essayer, je pense que cela vous apportera une expérience de développement plus pratique et plus efficace.

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!