Comment définir un en-tête sur une réponse avec Spring 5

1. Vue d'ensemble

Dans ce rapide didacticiel, nous allons passer en revue différentes façons de définir un en-tête sur une réponse de service , soit pour les points de terminaison non réactifs, soit pour les API utilisant le framework 5 WebFlux de Spring.

Nous pouvons trouver plus d'informations sur ce cadre dans les articles précédents.

2. En-têtes pour les composants non réactifs

Si nous voulons définir des en-têtes sur des réponses uniques, nous pouvons utiliser des objets HttpServletResponse ou ResponseEntity .

En revanche, si notre objectif est d'ajouter un filtre à toutes les réponses ou à plusieurs réponses, nous devrons configurer un filtre .

2.1. Utilisation de HttpServletResponse

Nous devons simplement ajouter l' objet HttpServletResponse à notre point de terminaison REST en tant qu'argument, puis utiliser la méthode addHeader () :

@GetMapping("/http-servlet-response") public String usingHttpServletResponse(HttpServletResponse response) { response.addHeader("Baeldung-Example-Header", "Value-HttpServletResponse"); return "Response with header using HttpServletResponse"; }

Comme indiqué dans l'exemple, nous n'avons pas à renvoyer l'objet de réponse.

2.2. Utilisation de ResponseEntity

Dans ce cas, utilisons le BodyBuilder fourni par la classe ResponseEntity :

@GetMapping("/response-entity-builder-with-http-headers") public ResponseEntity usingResponseEntityBuilderAndHttpHeaders() { HttpHeaders responseHeaders = new HttpHeaders(); responseHeaders.set("Baeldung-Example-Header", "Value-ResponseEntityBuilderWithHttpHeaders"); return ResponseEntity.ok() .headers(responseHeaders) .body("Response with header using ResponseEntity"); }

La classe HttpHeaders offre de nombreuses méthodes pratiques pour définir les en-têtes les plus courants.

Nous pouvons voir plus d'exemples illustrant ces points dans notre dépôt Github.

2.3. Ajout d'un en-tête pour toutes les réponses

Imaginons maintenant que nous voulions définir un en-tête particulier pour plusieurs de nos points de terminaison.

Bien sûr, il serait frustrant de devoir répliquer le code précédent sur chaque méthode de mappage.

Une meilleure approche pour y parvenir consiste à configurer un filtre dans notre service :

@WebFilter("/filter-response-header/*") public class AddResponseHeaderFilter implements Filter { @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { HttpServletResponse httpServletResponse = (HttpServletResponse) response; httpServletResponse.setHeader( "Baeldung-Example-Filter-Header", "Value-Filter"); chain.doFilter(request, response); } @Override public void init(FilterConfig filterConfig) throws ServletException { // ... } @Override public void destroy() { // ... } }

L' annotation @WebFilter nous permet d'indiquer les urlPatterns pour lesquels ce filtre deviendra effectif.

Comme nous l'avons souligné dans cet article, afin de rendre notre filtre détectable par Spring, nous devons ajouter l' annotation @ServletComponentScan à notre classe Spring Application:

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

Nous pouvons éviter cette dernière étape si nous n'avons besoin d'aucune des fonctionnalités fournies par @WebFilter , en utilisant plutôt l' annotation @Component dans notre classe Filter .

3. En-têtes pour les points de terminaison réactifs

Encore une fois, nous verrons comment définir des en-têtes sur des réponses de point de terminaison unique à l'aide des classes et des interfaces ServerHttpResponse , ResponseEntity ou ServerResponse (pour les points de terminaison fonctionnels).

Nous allons également apprendre à implémenter un WebFilter Spring 5 pour ajouter un en-tête à toutes nos réponses.

3.1. Utilisation de ServerHttpResponse

Cette approche est assez similaire à l' homologue HttpServletResponse :

@GetMapping("/server-http-response") public Mono usingServerHttpResponse(ServerHttpResponse response) { response.getHeaders().add("Baeldung-Example-Header", "Value-ServerHttpResponse"); return Mono.just("Response with header using ServerHttpResponse"); }

3.2. Utilisation de ResponseEntity

Nous pouvons utiliser la classe ResponseEntity exactement comme nous le faisons pour les points de terminaison non réactifs:

@GetMapping("/response-entity") public Mono
    
      usingResponseEntityBuilder() { String responseHeaderKey = "Baeldung-Example-Header"; String responseHeaderValue = "Value-ResponseEntityBuilder"; String responseBody = "Response with header using ResponseEntity (builder)"; return Mono.just(ResponseEntity.ok() .header(responseHeaderKey, responseHeaderValue) .body(responseBody)); }
    

3.3. Utilisation de ServerResponse

Les classes et interfaces introduites dans les deux dernières sous-sections peuvent être utilisées dans les classes annotées @Controller mais ne sont pas adaptées au nouveau Framework Web fonctionnel Spring 5.

Si nous voulons définir un en-tête sur une HandlerFunction, nous devrons mettre la main sur l' interface ServerResponse :

public Mono useHandler(final ServerRequest request) { return ServerResponse.ok() .header("Baeldung-Example-Header", "Value-Handler") .body(Mono.just("Response with header using Handler"),String.class); }

3.4. Ajout d'un en-tête pour toutes les réponses

Enfin, Spring 5 fournit une interface WebFilterpour définir un en-tête sur toutes les réponses récupérées par un service:

@Component public class AddResponseHeaderWebFilter implements WebFilter { @Override public Mono filter(ServerWebExchange exchange, WebFilterChain chain) { exchange.getResponse() .getHeaders() .add("Baeldung-Example-Filter-Header", "Value-Filter"); return chain.filter(exchange); } }

4. Conclusion

En conclusion, nous avons appris de nombreuses façons différentes de définir un en-tête sur une réponse, que ce soit si nous voulons le définir sur un seul point de terminaison ou si nous voulons configurer toutes nos API de repos, même si nous migrons vers la pile réactive , maintenant nous avons les connaissances nécessaires pour faire toutes ces choses.

Comme toujours, tous les exemples sont accessibles dans notre référentiel Github, à la fois ceux non réactifs et ceux utilisant les fonctionnalités spécifiques de Spring 5.