Desta vez, estamos compartilhando conteúdo sobre o registro e a descoberta do SpringClcloud, que serão explicados pelos centros de serviços de construção, registro de serviços e descoberta de serviços, respectivamente. Agora, muitas startups em Pequim começaram a confiar no SpringCloud. Pode ser por causa dos documentos e componentes ricos. Afinal, é uma arquitetura de microsserviço relativamente completa no momento. Espero que esse compartilhamento possa trazer uma boa ajuda a todos;
Centro de Serviço Eureka
Até onde eu sei e uso muitos centros de registro incluem Zookeeper e Eureka. Meu artigo anterior compartilhou o Dubbo+Zookeeper para construir serviços, então desta vez eu uso Eureka. A estrutura SpringCloud também o recomenda como um centro de registro. Obviamente, pode ser integrado a outros centros de registro de serviços. Afinal, o Springcloud depende do Springboot para criar projetos, por isso é muito rápido integrar outros componentes. Primeiro, crie o projeto do Centro de Registro Eureka_server e apresente dependências através do seguinte:
<Depencency> <PuerpId> org.springframework.cloud </frugiD> <TRATIFACTID> Spring-cloud-starter-eureka-server </artifactId> </dependency>
Em seguida, adicione itens de configuração ao arquivo Application.yml:
Servidor: Porta: 2001Spring: Aplicação: Nome: Eureka-Serveureureka: Cliente: Registro-With-Eureka: False #Força-se para se registrar como um serviço de busca de serviço: False #Mask Registration Information Instância: Prefere-Ip-Address: True Instância: $ {spring.application.name}: $ {Server.port}Após a conclusão da configuração, você precisa iniciar a classe e adicionar anotação @enableeurekaserver. As configurações são basicamente concluídas e executadas. Visite http: // localhost: 2001/ Para obter a seguinte interface:
Serviço de registro de provedores
Com o Centro de Registro de Serviços, também precisamos fornecer alguns serviços e registrar esses serviços no centro de serviço. Para facilitar isso, primeiro criamos um projeto de módulo de interface eureka_api que é usado pelos provedores de serviços e consumidores e criamos a seguinte interface e solicitação de retorno de retorno da classe de entidade:
Public Interface UserInterface {@PostMapping ("/Usuários") MORP <LIST <MUSER>> getUsers (Morq rq); @GetMapping ("/msg") string getmsg ();}Entidade Mouser:
classe pública mouser {private longo id; Nome de usuário privado de string; String privada Userpwd; public Long getId () {return id; } public void setId (longo id) {this.id = id; } public string getUserName () {return userName; } public void setUserName (string userName) {this.username = nome de usuário; } public string getUserpwd () {return userpwd; } public void setUserpwd (string userpwd) {this.userpwd = userpwd; }}Em seguida, crie o módulo Eureka_provider no lado do nosso provedor de serviços e também apresente dependências de Eureka, mas há uma pequena diferença entre ele e o lado do servidor:
<Depencency> <PuerpId> org.springframework.cloud </frugiD> <TRATIFACTID> Spring-cloud-starter-eureka </sutifactId> </pendence>
Em seguida, crie o serviço UserController a ser fornecido pelo provedor de serviços e implemente a interface do userInterface em nosso módulo Eureka_api. O código é o seguinte:
@RestControllerPublic Classe UserController implementa o UserInterface {@AUTOWIRED PRIVADO HTTPSERVletRequest solicitação; @Override public morp <list <Mouser>> getUsers (morq rq) {morp <list <Mouser>> rp = new MORP <> (); List <Mouser> List = new ArrayList <> (); for (int i = 0; i <5; i ++) {mouser mouser = new mouser (); mouser.setId (i); mouser.setUsername ("shenniu" + i); list.add (mouser); } rp.sett (list); rp.setStatus (list.size ()> = 1? 1: 0); rp.setMessage (list.size ()> = 1? "": "Sem dados ainda"); retornar rp; } @Override public String getMsg () {return "Aqui está um provedor, porta:"+ request.getServerport (); }}Deve -se notar aqui que não há pós -mapeamento ou getMaping adicionado às duas interfaces de serviço do controlador, porque isso é declarado pela interface implementada; Após definir os usuários e os serviços de MSG, também precisamos ser capazes de injetar -os no Centro de Registro de Serviços, para que seja necessária a seguinte configuração do Application.yml:
Spring: Aplicação: Nome: Eureka-Provider #Nome do Serviço Eureka: Cliente: Serviço-URL: DefaultZone: http: // localhost: 2001/eureka/#Service Center Endereço Instância de Endereço: Prefere-Ip-Address: True Instância: ID: $ {Spring.Application.name}: $ {Server.port}Também precisamos adicionar a seguinte tag @enableeurekaclient à classe de inicialização, o que significa iniciar o cliente Eureka, porque o provedor de serviços pertence ao cliente em comparação com o centro de serviço; Ao executar o projeto Eureka_provider, podemos ver as seguintes informações no Centro de Registro:
Para garantir que a interface do provedor de serviços seja boa, podemos clicar diretamente a Eureka-Provider: 2004 e, em seguida, aumentar o caminho para a interface a ser usada. Aqui está: http://192.168.153.148:2004/msg, e podemos obter as seguintes informações retornadas pela interface de acesso normal:
Serviço de descoberta de consumidores
Com os serviços de interface, também precisamos consumir serviços, por isso criamos o projeto do módulo Eureka_Consumer, porque o método pseudo-cliente FEGIN é usado para acessar nosso provedor de serviços e também precisamos introduzir as dependências da Eureka:
<Depencency> <PuerpId> org.springframework.cloud </frugiD> <ArtifactId> Spring-cloud-starter-eureka </stutifactId> </dependency> <pendesency> <voundid> org.springframework.cloud </groupid> <Artifactid> Spring-starter-flect </Artif
Em seguida, defina o serviço de serviço de usuários na camada de serviço e implemente a interface no módulo de interface pública eureka_api, o código é o seguinte:
@FeignClient (Value = "Eureka-provider") Interface pública UserService estende o UserInterface {}Através da FeignClient, especifique o nome do servidor chamado Eureka-Provider. Este nome corresponde ao diretório de aplicativos registrado no centro de serviço. Crie uma resposta UserController de saída na camada do controlador e forneça duas interfaces exibidas, códigos como:
@RestControllerPublic Classe UserController {@AUTOWIRED PRIVADO UserService UserService; @GetMapping ("/Usuários") public MORP } @GetMapping ("/msg") public string getMsg () {return userservice.getmsg (); }}Da mesma forma, o lado do consumidor também precisa configurar algumas informações no Application.yml:
Spring: Aplicação: Nome: Eureka-ConsumeRereureka: Cliente: Serviço-URL: DefaultZone: http: // localhost: 2001/Eureka/#Register Center Endereço Center Instância: Prefere-Ip-Address: True Instância-Id: $ {Spring.Application.name}: $ {Server} Server: Port: 2005A configuração é semelhante à do provedor. Finalmente, você precisa declarar as seguintes anotações na aula de inicialização:
@SpringbooTApplication@habilablediscoveryclient // consumer client@enableFeignClients // Feign Client public Class EurekaconsumerApplication {public static void main (string [] args) {springapplication.run (eurekaconsumerApplication.class, args); }}Depois de iniciar o projeto Eureka_Consumer, podemos ver as informações que ele registrou no Centro de Registro:
Em seguida, acessando a interface do consumidor eureka_consumer, teste os dados da interface do provedor de serviços eureka_provider para ver se ele pode responder normalmente. O endereço da interface é http: // 192.168.153.148:2005/msg:
O resultado do provedor é obtido acessando o consumidor, que é o processo de teste básico para registro e descoberta de serviços; Quanto à forma como o consumidor solicita a interface do provedor, podemos resolvê -lo através do seguinte diagrama manual:
Eureka Service Center altamente disponível
A julgar pelo desenho manual acima, o centro de serviço desempenha um papel muito importante. Geralmente, esse tipo de centro de serviço não apenas constrói um, por isso é necessário criar um conjunto de centros de serviço altamente disponíveis; De fato, é muito simples que a configuração do provedor e do consumidor não precise ser feita. Precisamos apenas configurá-lo no Application.yml do projeto Eureka-Server no primeiro nó e iniciar vários serviços com portas diferentes (o mesmo servidor possui várias portas e portas de servidor diferentes podem ser as mesmas):
Servidor: Porta: 2001Spring: Aplicação: Nome: Eureka-Serveureureka: Cliente: Registro-With-Eureka: True # Ao configurar alta disponibilidade, você precisa abrir e registrar-se buscando-se-registry: True Service-Url: DefulZone: http: // localhost: 2002/Eureneka/#Register in eure http: // localhost: 2001/eureka/instância: prefer-ip-address: true instância-id: $ {spring.application.name}: $ {server.port} servidor: despettion-interval-timer-in-ms: 2000 #exclude intervalos de serviço falhadosOs seguintes pontos devem receber atenção em configurações altamente disponíveis:
Aqui, criei dois endereços de registro: http: // localhost: 2001/e http: // localhost: 2002/; Como os endereços do registro configurados pelo provedor e pelo consumidor são os dois port 2001, a fim de verificar a alta disponibilidade, precisamos acessar o Centro de Registro de Portas de 2002, os efeitos são os seguintes:
Você pode ver que a porta de 2002 possui as mesmas informações de registro da porta 2001. Quando fecho a aplicação da porta de 2001, ainda posso encontrar as informações do provedor e do consumidor em 2002. Para uma configuração mais detalhada, consulte a descrição oficial do site.
Endereço Git: https://github.com/shenniubuxing3
Pacote de liberação do NUGET: https://www.nuget.org/profiles/shenniubuxing3
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.