Tabla de contenido
¿Cómo usar fingir para lograr la verificación de permisos entre servicios?
¿Qué es fingir?
Feign es un cliente de servicio web declarativo. El uso de Feign facilita la escritura de un cliente de servicio web. Su método de uso es definir una interfaz y luego agregarle anotaciones. También admite anotaciones estándar JAX-RS. Feign también admite plug-in conectables codificador y decodificador, fingir se pueden usar por separado, y luego, después de que springcloud integra fingir, para hacer que el estilo de uso fingido sea consistente con el de springmvc, fingir se encapsula para que fingir admita getmapping y postmapping Tal método de llamada anotado hace que el método de llamada más uniforme.
¿Por qué fingir?
Cuando llamamos a la interfaz remota, primero usamos el método de solicitud como httpclient y httpurlconnection. Por ejemplo, hay un marco en el lado de Android llamado okhttp. Esto es para ayudarnos a llamar a la interfaz de servicio más amigable, entonces, ¿qué finge hacer? fingir se basa en estos, se ha creado otra capa de encapsulación para que podamos llamar a servicios remotos de forma declarativa. Después de que springcloud encapsula fingir, puede hacer que su estilo de llamada sea consistente con springmvc, y también integra implícitamente el equilibrio de carga del cliente (cinta), por lo que El uso de fingir como cliente de descanso nos permite concentrarnos en escribir nuestras interfaces y lógica de negocios, sin perder tiempo en el tema de las llamadas entre interfaces.
Empiece rápidamente a fingir
El proyecto aún depende del proyecto anterior. Siga la cuenta pública de WeChat "Le Zai Code Farmer" y responda "eureka" para recibirlo.
Agregue un nuevo módulo "feign-api" sobre la base del proyecto
Agregar dependencia
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
</dependencies>Debido a que uso el método heredado para usar fingir, lo que se hereda, es decir, escribo una interfaz por separado, uso la anotación fingir para marcar, y luego el proveedor de servicios hereda directamente esta interfaz e implementa los métodos en el interior, de modo que cuando la URL está modificado En ese momento, solo necesito modificar el módulo de simulación que extraje. Ahora que puede haber un poco de abstracción, configuremos el estante para que todos lo vean.
Agregar una interfaz fingida
@FeignClient(value = "eureka-client-order-service")
public interface UserFeign {
@GetMapping("/user/get")
User getUser(@RequestParam("name") String name);
@PostMapping("/user/getMap")
User getUser(@RequestParam Map<String,String> param);
@PostMapping("/user/add")
User addUser(@RequestParam("name") String name, @RequestParam("email")String email);
@PostMapping("/user/addBody")
User addUser(@RequestBody User user);
}public class User {
private String name;
private String email;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}Descripción de parámetros
@FeignClient (value = "eureka-client-order-service") Esto indica que se trata de una interfaz fingida, el valor "eureka-client-order-service" indica qué servicio se utilizará mediante proxy, el nombre del servicio y el servicio dentro Spring.application.name del proveedor sigue siendo el mismo, requestmapping es el mismo que springmvc, solo miramos la primera interfaz, / user / get después del empalme de URL, es el / user / get que llama al eureka-client-order-service interfaz de servicio
Es necesario prestar atención al paso de parámetros: pasar el objeto del modelo debe estar decorado con @requestBody, y debe agregarse en la clase de implementación. La transferencia del mapa es la misma, y la clase de implementación también debe usar @requestParam.
La interfaz fingida está escrita, ahora implementamos esta interfaz en el proveedor de servicios y agregamos dependencias en el proveedor de servicios.
<dependency>
<groupId>com.yangle</groupId>
<artifactId>feign-api</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>@RestController
public class UserService implements UserFeign {
@Override
public User getUser(String name) {
User user=new User();
user.setName(name);
user.setEmail("[email protected]");
return user;
}
@Override
public User getUser(@RequestParam Map<String, String> param) {
User user=new User();
user.setName(param.get("name"));
user.setEmail("[email protected]");
return user;
}
@Override
public User addUser(String name, String email) {
User user=new User();
user.setName(name);
user.setEmail(email);
return user;
}
@Override
public User addUser(@RequestBody User user) {
return user;
}
}UserService implementa la interfaz UserFeign y agrega la anotación restcontoller, que está marcada como una interfaz de reposo. Debido a que cada método en UserFeign tiene una anotación de mapeo, está directamente integrado en el servicio de usuario, y no hay necesidad de reescribirlo nuevamente, al igual que el arriba, Una nota es pasar los parámetros del objeto de modelo y mapa, y las anotaciones de los parámetros deben escribirse en la clase de implementación.
En el consumidor del servicio de edición, agregue una dependencia y abra feignclient
<dependency>
<groupId>com.yangle</groupId>
<artifactId>feign-api</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>@SpringBootApplication
@EnableFeignClients(basePackages ="com.yangle.feign" )
public class EurekaClientConsumerApplication {
basePackages especifica el paquete donde se encuentra feignclient para escanear feignclient
Agregue la interfaz de consumo de servicios, use UserFeignClient
@RestController
@RequestMapping("consumer")
public class UserConsumerService {
@Autowired
private UserFeign userFeign;
@GetMapping("/user/get")
public User getUser(@RequestParam("name") String name){
return userFeign.getUser(name);
}
@GetMapping("/user/getMap")
public User getUser(@RequestParam Map<String,String> param){
return userFeign.getUser(param);
}
@PostMapping("/user/add")
public User addUser(@RequestParam("name") String name, @RequestParam("email")String email){
return userFeign.addUser(name,email);
}
@PostMapping("/user/addBody")
public User addUser(@RequestBody User user){
return userFeign.addUser(user);
}
}Todos los preparativos están completos y ahora puede reiniciar el consumidor y el proveedor de servicios para realizar la prueba.
¿Cómo usar fingir para lograr la verificación de permisos entre servicios?
Se requiere verificación de permisos en nuestros proyectos, y también se requiere en microservicios. En springcloud, como puerta de entrada de la entrada unificada, se puede realizar la verificación de permisos. Entonces, ¿cómo verificar antes de microservicios? Ahora existe tal escenario
El cliente solicita el servicio A, y luego el servicio A necesita solicitar el servicio B. Definitivamente haremos una capa de verificación cuando el cliente solicite el servicio A, pero cuando el servicio A llama al servicio B, también necesita traer información de autenticación. Al servicio B , por lo que debemos implementar dicha función cuando usamos fingir para llamar al servicio
¿Como alcanzar?
Dicho interceptor se proporciona fingiendo, que se ejecuta antes de que llamemos al servicio de destino. Podemos extraer la información de autenticación de nuestra solicitud y ponerla en nuestro fingir, y fingir autenticará La información se lleva al servicio de destino y la autorización La operación de autenticación está completa, ahora solo necesitamos modificar un poco en base a nuestro código.
En el módulo feign-api, agregue una clase de configuración
@Configuration
public class FeignConfig {
@Bean
Logger.Level feignLoggerLevel() {
return Logger.Level.FULL;
}
@Bean
public FeignBasicAuthRequestInterceptor basicAuthRequestInterceptor(){
return new FeignBasicAuthRequestInterceptor();
}
class FeignBasicAuthRequestInterceptor implements RequestInterceptor{
@Override
public void apply(RequestTemplate requestTemplate) {
HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
String token = request.getHeader("token");
requestTemplate.header("token",token);
Map<String, Collection<String>> headers= requestTemplate.headers();
}
}
}El interceptor FeignBasicAuthRequestInterceptor implementa directamente la interfaz requestinterceptor. En el método de aplicación, ponga la información de autenticación en falso. La clase de configuración está ahí. Ahora tenemos que hacer que surta efecto. Reescribimos la anotación en la interfaz UserFeign como esta, e inyectamos el clase de configuración en feignclient Puede tener efecto, ahora reiniciamos el servicio para ver si entra en vigor.
@FeignClient(value = "eureka-client-order-service",configuration = FeignConfig.class)para resumir
Después de estudiar este capítulo, creo que todo el mundo debería tener una cierta comprensión de fingir. Al usar fingir, la forma en que llamamos a servicios remotos se puede simplificar enormemente. Al mismo tiempo, usar llamadas fingidas entre servicios para aprender cómo pasar la autenticación información para lograr autoridad El efecto de la autenticación, pero los servicios entre diferentes procesos fallarán inevitablemente cuando se llamen entre sí, así que en la siguiente sección aprenderemos cómo usar hystrix para proteger nuestros servicios.
Bienvenidos a todos para que presten atención a mi cuenta oficial, respondan a "recibir información", obtengan más materiales de video de aprendizaje como inteligencia artificial, big data, etc. Si hay alguna infracción, comuníquese con el autor para eliminarla de inmediato.
