A postagem anterior do blog construiu uma estrutura Eureka+Ribbon+Hystrix. Embora possa basicamente atender às chamadas entre os serviços, o código parece realmente feio. O cliente precisa escrever um Resttemplate todas as vezes. Para tornar as ligações mais bonitas e legíveis, agora estamos aprendendo a usar o Feign.
O Feign inclui fita e Hystrix, que estão gradualmente experimentando seu significado no combate real. A chamada inclusão não é a inclusão física dos pacotes JAR da Feign, incluindo pacotes de fita e JAR da Hystrix, mas a inclusão lógica das funções de Feign, incluindo as funções dos outros dois. Em resumo: Feign pode fazer coisas sobre fita e hystrix, mas, para usar as anotações trazidas por fita e hystrix, o pacote JAR correspondente deve ser introduzido.
Caso 1:
Centro de Registro Eureka: https://github.com/yejingtao/forblog/tree/master/demo-eureka-register
Provedor de serviços: https://github.com/yejingtao/forblog/tree/master/demo-feign-freeserservice
Chamador de serviço: https://github.com/yejingtao/forblog/tree/master/demo-feign-freeconsumer
O provedor de serviços é um simples aplicativo Eurekaclient+Web, fornecendo os seguintes métodos
@RestController @ReQuestMapping ("/Feign-Service") Public Classe HelloserviceContorller {Private Logger Logger = LoggerFactory.getLogger (thisgetClass ()); Sono de vazio privado (String MethodName) {Int SleepMintime = new Random (). NextInt (3000); Logger.info ("Helloservice"+MethodName+"SleepMintime:"+SleepMintime); tente {thread.sleep (sleepmintime); } catch (interruptedException e) {e.printStackTrace (); }} @RequestMapping (value = "/ServiceGet", Method = requestMethod.get) public String Helloservice (@RequestParam String Name) {Sleep ("Get"); retornar "HelloserviceImpl Nome:"+Nome; } @ReQuestMapping (value = "/serviceHead", método = requestMethod.head) public string heloservice (@RequestHeader String Name, @RequestHester String senha) {Sleep ("Header"); Retorne "Helloservicehead Name:"+Name+"Senha:"+Senha; } @RequestMapping (value = "/ServicePost", Method = requestMethod.post) public string helloservice (@requestbody userDemo userDemo) {sleep ("post"); return userDemo.toString (); }} As anotações a seguir que precisam receber atenção não podem ser omitidas.
@RequestParam: anotação que indica que o parâmetro do método deve estar vinculado a um parâmetro de solicitação da Web
@Requestbody: Anotation indicando um MethodParameter deve estar vinculado ao corpo da solicitação da Web.
@RequestHeader: Anotação que indica que o parâmetro do método deve estar vinculado a um cabeçalho de solicitação da Web.
Se as anotações acima estiverem ausentes, embora o serviço não relate um erro após a execução, ele não poderá obter os parâmetros de entrada.
Projeto de Chamador de Serviço:
<Depencency> <PuerpId> org.springframework.cloud </frugiD> <ArtifactId> Spring-cloud-starter-fEIGN </starfactId> </dependency>
Feign só depende aqui, não fita e hystrix.
Application.yml:
Servidor: Porta: 9051 Spring: Aplicação: Nome: Demo-Feign-Freeconsumer Eureka: Cliente: ServiceUrl: DefaultZone: http: // peer1: 1111/eureka/, Http: // peer2: 1112/Eureka/Feign: Hystrix: ENFILTP: #RIBBON: Settour2: 1112/Eureka/Feign: Hystrix: VERDADO #RIBBON: Timeout 2: Settime Settleout 2: 1112/Eureka/Feign: Hystrix: # True #Ribbon
A configuração do Hystrix me enganou há muito tempo. A nuvem de primavera que usei é a versão Dalston SR1, que é mais recente que as versões de outros materiais na Internet. Porque na nova versão, o suporte da Feign ao Hystrix é desligado por padrão, então você precisa ativar manualmente o Feign.hystrix.enabled = true por meio da configuração, para que o downgrade de serviço e outras funções sejam eficazes.
Programa de iniciação de aplicativos
@SpringbooTApplication @enableeurekaclient @enableFeignClients classe public DemofeignApplication {public static void main (string [] args) {springApplication.run (DemofeignApplication.class, args); }} Observe que há outra armadilha aqui. Estou usando o @SpringBootApplication+ @EnableeureKaclient em vez do @springcloudApplication, porque o último contém @enablecircuitbreaker, e @enablecircuitbreaker é o conteúdo no pacote Hystrix. Meu POM não introduz o Hystrix. Portanto, a Spring Cloud ainda tem deficiências a esse respeito. Você não relatará um erro compilando diretamente com o @springcloudApplication, mas ele não pode ser iniciado. Obviamente, o protagonista aqui ainda é a anotação @enableFeignClient.
Código do cliente central
@FeignClient (name = "Demo-Feign-FreeService", Fallback = DemofeignFallback.class) Interface pública DemofeInService {@ReQuestMapping (value = "/Feign-Service/ServiceGet", Method = requestMethod.get) String Helloserice (@RequestParam ("Nome"); @RequestMapping (Value = "/Feign-Service/ServiceHead", Method = requestMethod.head) String Helloservice (@RequestHeader ("Nome") Nome da String, @RequestHeader ("senha") String senha); @RequestMapping (Value = "/Feign-Service/ServicePost", Method = requestMethod.post) String Helloservice (@RequestBody UserDemo UserDemo); } A anotação @FeignClient define que a interface é um cliente Feign, o nome especifica o nome do serviço registrado no Eureka e o Fallback é a classe de implementação da interface após o rebaixamento do serviço.
@RequestMapping Especifica os métodos de solicitação URL e HTTP relativos da solicitação, que corresponde ao servidor um por um. @RequestParam,
As anotações @RequestBody e @RequestHeader têm mais atributos de valor do que os servidores. Eles não podem ser omitidos aqui. Eles precisam informar explicitamente o cliente Feign como corresponder aos parâmetros.
Código de serviço do rebaixamento:
@Component public class Demofeignfallback implementa DemofeInService {@Override public String Helloservice (Nome da String) {return "Get Error"; } @Override public String Helloservice (nome da string, senha da string) {return "Head Error"; } @Override public string Helloservice (userDemo userDemo) {return "Post Error"; }} Descobri que removi deliberadamente as anotações @RequestParam, @RequestBody e @RequestHeader nos parâmetros de entrada aqui, porque o significado essencial dessas anotações é que o Feign usa para passar os parâmetros para HTTP ao fazer o Microservice, mas o serviço de que é o serviço não será atribuído.
Código do controlador:
@RestController Classe public DemofeignController {@AUTOWIRED PRIVADO DEMOFEIGNSERVICE DEMOFEIRVICE; @RequestMapping (value = "/teste", método = requestMethod.get) public String DemosServiceTest () {StringBuffer sb = new StringBuffer (); sb.append (DemofeIGNService.Helloservice ("Yuanyuan")); sb.append ("/n"); sb.append (DemofeIGNService.Helloservice ("YJT", "XIXIHAHA")); sb.append ("/n"); sb.append (DemofeIGNService.Helloservice (novo UserDemo ("Yejingtao", "123456"))); return sb.toString (); }}Vamos ver o efeito:
Nosso serviço não foi de tempo limitado, todos os três métodos eram normais, mas a solicitação da cabeça não obteve o valor de retorno. Isso é determinado pelas características da solicitação HTTP do método da cabeça. A cabeça não retorna o corpo da resposta e geralmente é usada para testes de conectividade.
Vejamos outro conjunto:
Os métodos de cabeça e solicitação de postagem foram processados por mais de 2000ms e o serviço é rebaixado e a implementação é substituída pela classe de processamento de fallback.
No caso um, sempre temos a sensação de que há código duplicado entre o provedor de serviços e o chamador de serviço. Pode ser otimizado? Por favor, veja o caso 2.
Caso 2:
Centro de Registro Eureka: https://github.com/yejingtao/forblog/tree/master/demo-eureka-register
API da interface: https://github.com/yejingtao/forblog/tree/master/demo-feign-servepiEapi
Provedor de serviços: https://github.com/yejingtao/forblog/tree/master/demo-feign-serviceImpl
Chamador de serviço: https://github.com/yejingtao/forblog/tree/master/demo-feign-apicconsumer
A maior mudança no Caso 2 é escrever recursos de serviço separadamente em um projeto de API, e o chamador e o provedor POM confiam nessa API.
API:
interface pública Heloservice {@RequestMapping (value = "/Feign-Service/ServiceGet", Method = requestMethod.get) String Heloservice (@RequestParam ("Nome") Nome da String); @RequestMapping (Value = "/Feign-Service/ServiceHead", Method = requestMethod.head) String Helloservice (@RequestHeader ("Nome") Nome da String, @RequestHeader ("senha") String senha); @RequestMapping (Value = "/Feign-Service/ServicePost", Method = requestMethod.post) String Helloservice (@RequestBody UserDemo UserDemo); } Provedor de serviços:
@RestController classe pública HeloserviceContorller implementa Heloservice {private logger logger = LoggerFactory.getLogger (this.getClass ()); Sono de vazio privado (String MethodName) {Int SleepMintime = new Random (). NextInt (3000); Logger.info ("Helloservice"+MethodName+"SleepMintime:"+SleepMintime); tente {thread.sleep (sleepmintime); } catch (interruptedException e) {e.printStackTrace (); }} @Override public String Helloservice (@RequestParam ("Nome") Nome da String) {Sleep ("Get"); retornar "HelloserviceImpl Nome:"+Nome; } @Override public String Helloservice (@RequestHeader ("Nome") Nome da String, @RequestHeader ("Senha") String senha) {Sleep ("Header"); Retorne "Helloservicehead Name:"+Name+"Senha:"+Senha; } @Override Public String Helloservice (@RequestBody UserDemo UserDemo) {Sleep ("Post"); return userDemo.toString (); }} Chamador de serviço:
@FeignClient (name = "Demo-feign-serviceImpl", Fallback = FeigNServiceFallback.Class) FeigNService da interface pública estende Heloservice {}Outros códigos permanecem basicamente inalterados e o efeito é o mesmo.
Os dois estilos têm suas próprias vantagens e desvantagens: o estilo livre é mais gratuito e o novo método adicionado ao servidor não afetará o código do cliente. A desvantagem é que os recursos de serviço não são sincronizados e as mudanças nos recursos de serviço causarão anormalidades; Os recursos de atendimento ao cliente do servidor de formato API são sincronizados, mas as alterações na interface requerem modificação do código de ambos os lados, e você deve considerá -lo claramente ao construí -las.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.