Fingir es un cliente de servicio web declarativo. Facilita la escritura de clientes de servicios web. Para usar Fingir, cree una interfaz y anótela. Tiene soporte de anotación conectable que incluye anotaciones de Fingir y JAX-RS.

Spring Cloud agrega soporte para las anotaciones de Spring MVC y para usar los mismos HttpMessageConverters que se usan de forma predeterminada en Spring Web. Spring Cloud integra Ribbon y Eureka para proporcionar un cliente HTTP con equilibrio de carga cuando se usa Fingir. (https://cloud.spring.io)

Crear un cliente de Fingir en Spring Cloud es simple, todo lo que tiene que hacer es crear una interfaz y anotarla con @FeignClient .

Las solicitudes generadas por los clientes de Feign pueden tener configuraciones, por ejemplo, cómo codificar, decodificar e interceptar solicitudes.

Considere un cliente de Feign que debe usarse con diferentes configuraciones en diferentes lugares del código, o varios clientes de Feign que deben usarse con su propia configuración. Por ejemplo, el cliente A de Fingir debe configurarse con el decodificador A y el interceptor de solicitudes A y el cliente B de Fingir con el decodificador B y el interceptor B.

Un escenario posible es establecer diferentes enfoques de autenticación para diferentes clientes de Feign.

Ensuciémonos las manos:

Supongamos que hay dos API Rest, una para obtener objetos "Bar" en el servidor Bar y otra para obtener objetos "Foo" en el servidor Foo. El problema es que esos servicios tienen diferentes enfoques de autenticación.

Tenemos dos clientes de Feign para dos servicios, FooClient y BarClient. Estos clientes de Fingir necesitan adoptar una configuración de autenticación diferente.

Aquí está la clase FooClient . El FeignClient tiene un fooContextId , un valor y una URL específica y está configurado en la clase FooConfig .

 @FeignClient (contextId = "fooContextId" , value = "fooValue" , url = "http://foo-server.com/services" , configuration = FooConfig.class) public interface FooFeignClient { @GetMapping ( "{id}/foo" ) void getFoo (@PathVariable( "id" ) Long id) ; }

Y esta es la clase BarClient . Nuevamente, tiene su propio contextId , value , url y BarConfig específicos .

 @FeignClient (contextId = "barContextId" , value = "barValue" , url = "http://bar-server.com/services" , configuration = BarConfig.class) public interface BarFeignClient { @GetMapping ( "{id}/bar" ) void getBar (@PathVariable( "id" ) Long id) ; }

BarConfig y FooConfig no deben anotarse con @Component ni con ninguna otra anotación de Spring Bean.

A continuación, debemos instanciar los beans BarRequestInterceptor y FooRequestInterceptor en estas clases de configuración.

 public class BarConfig { @Bean public BarRequestInterceptor barRequestInterceptor () { return new BarRequestInterceptor(); } } public class FooConfig { @Bean public FooRequestInterceptor fooRequestInterceptor () { return new FooRequestInterceptor(); } }

Tanto las clases BarRequestInterceptor como FooRequestInterceptor implementan RequestInterceptor y deben anular el método apply para especificar sus propios enfoques de autenticación.

 public class BarRequestInterceptor implements RequestInterceptor { private static final Logger LOGGER = LoggerFactory.getLogger(BarRequestInterceptor.class); @Override public void apply (RequestTemplate template) { template.header( "authorization" , "auth-bar" ); LOGGER.info( "bar authentication applied" ); } } public class FooRequestInterceptor implements RequestInterceptor { private static final Logger LOGGER = LoggerFactory.getLogger(FooRequestInterceptor.class); @Override public void apply (RequestTemplate template) { template.header( "authorization" , "auth-foo" ); LOGGER.info( "foo authentication applied" ); } }

Finalmente, cree un método para llamar a estos clientes de Fingir:

 @RestController public class HomeController { private static final Logger LOGGER = LoggerFactory.getLogger(HomeController.class); @Autowired private FooFeignClient fooFeignClient; @Autowired private BarFeignClient barFeignClient; @GetMapping ( "test" ) public void home () { try { LOGGER.info( "calling getFoo" ); fooFeignClient.getFoo( 100L ); } catch (Exception e) { } try { LOGGER.info( "calling getBar" ); barFeignClient.getBar( 100L ); } catch (Exception e) { } } }

Si ejecutamos la aplicación y llamamos al controlador de inicio, primero se invocará el método "getFoo" de FooClient con FooConfiguration y luego el método "bar" de BarClient con BarConfiguration . Este es el registro de salida de esta solicitud:

 2019 - 11 - 28 22 : 33 : 17.041 INFO 18208 --- [nio- 8080 -exec- 1 ] com.example.feignconfig.HomeController : calling getFoo 2019 - 11 - 28 22 : 33 : 17.046 INFO 18208 --- [nio- 8080 -exec- 1 ] ceffoo.FooRequestInterceptor : foo authentication applied 2019 - 11 - 28 22 : 33 : 17.472 INFO 18208 --- [nio- 8080 -exec- 1 ] com.example.feignconfig.HomeController : calling getBar 2019 - 11 - 28 22 : 33 : 17.473 INFO 18208 --- [nio- 8080 -exec- 1 ] cefbar.BarRequestInterceptor : bar authentication applied

Puede encontrar el código fuente de este tutorial en mi repositorio de GitHub:

https://github.com/shokri4971/multiple-feign-config