精华内容
下载资源
问答
  • Spring cloud服务的注册和发现

    千次阅读 2018-01-07 19:45:50
    Spring cloud服务的注册和发现   可参考:http://blog.csdn.net/liaomin416100569/article/details/78059174 服务(service) 发送邮件 服务的概念:   服务注册和发现     地址:...

    Spring cloud服务的注册和发现

     

    可参考:http://blog.csdn.net/liaomin416100569/article/details/78059174

    服务(service) 发送邮件


    服务的概念:

     

    服务注册和发现

     

     

    地址:https://cloud.spring.io/spring-cloud-netflix/

    配置注册中心:

    eurekaserver中加入依赖

    <parent>
    
        <groupId>org.springframework.boot</groupId>
    
        <artifactId>spring-boot-starter-parent</artifactId>
    
        <version>1.5.9.RELEASE</version>
    
    </parent>
    
    <dependencyManagement>
    
        <dependencies>
    
            <dependency>
    
                <groupId>org.springframework.cloud</groupId>
    
                <artifactId>spring-cloud-dependencies</artifactId>
    
                <version>Dalston.SR4</version>
    
                <type>pom</type>
    
                <scope>import</scope>
    
            </dependency>
    
        </dependencies>
    
    </dependencyManagement>
    
    <dependencies>
    
        <dependency>
    
            <groupId>org.springframework.cloud</groupId>
    
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
    
        </dependency>
    
       
    
    </dependencies>

    注册中心的资源文件application.yml

    server:

      port: 8761#eureka默认端口

     

    eureka:

      instance:

    hostname: localhost#主机名

      client:

        registerWithEureka: false

        fetchRegistry: false

        serviceUrl:

          defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

    网址:

    http://cloud.spring.io/spring-cloud-static/Dalston.SR5/single/spring-cloud.html#spring-cloud-eureka-server

     

    注册中心的启动类(EnableEurekaServer)

    package cn.et;
    
     
    
    import org.springframework.boot.SpringApplication;
    
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
    
     
    
    @SpringBootApplication
    
    @EnableEurekaServer
    
    public class Main {
    
    public static void main(String[] args) {
    
    SpringApplication.run(Main.class, args);
    
    }
    
    }



    eurekaServer的访问地址:localhost:8761  出现界面

     

    eureka client 的配置(客户端)

    spring.mail.host=smtp.163.com
    
    Spring.mail.password=123456
    
    spring.mail.port=25
    
    spring.mail.protocol=smtp
    
    spring.mail.username=raya_l@163.com
    
    eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka/
    
    spring.application.name=email
    
    server.port=8081
    
     
    
    在注册中的main方法上加@EnableEurekaClient启动自动注册


     

     

    Eureka客户端启动类

    package cn.et;
    
     
    
    import org.springframework.boot.SpringApplication;
    
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    
    @EnableEurekaClient
    
    @SpringBootApplication
    
    public class Main {
    
    public static void main(String[] args) {
    
    SpringApplication.run(Main.class, args);
    
    }
    
    }



    Ribbon

      

    <dependency>
    
        	<groupId>org.springframework.cloud</groupId>
    
        	<artifactId>spring-cloud-starter-ribbon</artifactId>
    
    </dependency>
    

     

    @EnableEurekaClient@EnableDiscoveryClient是一样的

    Ribbonmain方法

    @SpringBootApplication
    
    @EnableEurekaClient
    
    @RibbonClient(value="EMAIL")
    
    /**
    
     * 表示当前这个服务需要调用其他的服务的名称
    
     * @author Administrator
    
     *
    
     */
    
    @Configuration
    
    public class Main {
    
      @LoadBalanced
    
        @Bean
    
        RestTemplate restTemplate() {
    
            return new RestTemplate();
    
        }
    
    public static void main(String[] args) {
    
    SpringApplication.run(Main.class, args);
    
    }


    Ribbonget发送和post发送

     

    package cn.et;
    
     
    
    import java.util.HashMap;
    
    import java.util.Map;
    
     
    
    import org.springframework.beans.factory.annotation.Autowired;
    
    import org.springframework.cloud.client.ServiceInstance;
    
    import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
    
    import org.springframework.http.HttpEntity;
    
    import org.springframework.http.HttpHeaders;
    
    import org.springframework.stereotype.Controller;
    
    import org.springframework.web.bind.annotation.GetMapping;
    
    import org.springframework.web.bind.annotation.PostMapping;
    
    import org.springframework.web.bind.annotation.RequestMapping;
    
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import org.springframework.web.client.RestClientException;
    
    import org.springframework.web.client.RestTemplate;
    
     
    
     
    
    @Controller
    
    public class SendController {
    
    @Autowired
    
    private RestTemplate restTemplate;//通过restTemplate来调用ribbon
    
    @Autowired  
    
        private LoadBalancerClient loadBalancer;
    
    /**  
    
         * 启动多个发布者 端口不一致 程序名相同   
    
         * 使用  
    
         * @LoadBalanced必须添加  
    
         * @return  
    
         */  
    
    @ResponseBody
    
        @RequestMapping("/choosePub")  
    
        public String choosePub() {  
    
            StringBuffer sb=new StringBuffer();  
    
            for(int i=0;i<=10;i++) {  
    
                ServiceInstance ss=loadBalancer.choose("EMAILSERVER");//从两个idserver中选择一个 这里涉及到选择算法  
    
                sb.append(ss.getUri().toString()+"<br/>");
    
            }  
    
            return sb.toString();  
    
        }    
    
    @GetMapping("/sendClient")
    
    public String send(String email_to,String email_subject ,String email_content){
    
    //调用email服务
    
    String controller="/send";
    
    //通过注册中心客户端负载均衡  获取一台主机来调用
    
    try {
    
    controller += "?email_to="+email_to+"&email_subject="+email_subject+"&email_content="+email_content;
    
    String result=restTemplate.getForObject("http://EMAILSERVER"+controller, String.class);
    
    } catch (RestClientException e) {
    
    // TODO Auto-generated catch block
    
    e.printStackTrace();
    
    return "redirect:/error.html";
    
    }
    
     
    
    //通过redirect返回string类型跳转,不允许spring控制器用@ResponseBody
    
    return "redirect:/suc.html";
    
    }
    
    /**
    
     * 演示post
    
     * @param email_to
    
     * @param email_subject
    
     * @param email_content
    
     * @return
    
     */
    
    @PostMapping("/sendClientpost")
    
    public String postsend(String email_to,String email_subject ,String email_content){
    
    try {
    
    //
    
    HttpHeaders headers=new HttpHeaders();
    
    Map<String,Object> map=new HashMap<String,Object>();
    
    map.put("email_to",email_to );
    
    map.put("email_subject", email_subject);
    
    map.put("email_content", email_content);
    
    HttpEntity<Map> request=new HttpEntity<Map>(map, headers);
    
    String result=restTemplate.postForObject("http://EMAILSERVER/send",request, String.class);
    
    } catch (RestClientException e) {
    
    // TODO Auto-generated catch block
    
    e.printStackTrace();
    
    return "redirect:/error.html";
    
    }
    
    return "redirect:/suc.html";
    
    }
    
    /**
    
     * 演示调用sendmail的/user/这个请求
    
     * @return
    
     */
    
    @ResponseBody
    
    @GetMapping("/invokeUser")
    
    public String invokeUser(String id){
    
    String resul=restTemplate.getForObject("http://EMAILSERVER/user/{id}",String.class,id);
    
    return resul;
    
    }
    
    }


     

     

     

     

    发送邮件的控制类

     

    package cn.et;
    
     
    
    import java.util.HashMap;
    
    import java.util.Map;
    
     
    
    import org.springframework.beans.factory.annotation.Autowired;
    
    import org.springframework.mail.SimpleMailMessage;
    
    import org.springframework.mail.javamail.JavaMailSender;
    
    import org.springframework.web.bind.annotation.GetMapping;
    
    import org.springframework.web.bind.annotation.PathVariable;
    
    import org.springframework.web.bind.annotation.PostMapping;
    
    import org.springframework.web.bind.annotation.RequestBody;
    
    import org.springframework.web.bind.annotation.RestController;
    
     
    
    @RestController
    
    public class MailController {
    
    @Autowired
    
    private JavaMailSender jms;
    
    @PostMapping("/send")
    
    public String send(@RequestBody Map<String,Object> map){
    
    SimpleMailMessage mailMessage=new SimpleMailMessage();
    
    mailMessage.setFrom("raya_l@163.com");
    
    mailMessage.setTo(map.get("email_to").toString());
    
    mailMessage.setSubject(map.get("email_subject").toString());
    
    mailMessage.setText(map.get("email_content").toString());
    
    jms.send(mailMessage);
    
    return "1";
    
    }
    
    @GetMapping("/a")
    
    public String a(){
    
    return "2";
    
    }
    
    @GetMapping("/user/{userId}")
    
    public Map getUser(@PathVariable String userId){
    
    Map map=new HashMap();
    
    map.put("id", userId);
    
    map.put("name", "zs_"+userId);
    
    return map;
    
    }
    
    }


     

     

    启动MailController

    package cn.et;
    
     
    
    import org.springframework.boot.SpringApplication;
    
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    import org.springframework.cloud.client.loadbalancer.LoadBalanced;
    
    import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    
    import org.springframework.cloud.netflix.ribbon.RibbonClient;
    
    import org.springframework.context.annotation.Bean;
    
    import org.springframework.context.annotation.Configuration;
    
    import org.springframework.web.client.RestTemplate;
    
     
    
    @SpringBootApplication
    
    @EnableEurekaClient
    
    @RibbonClient(value = "EMAILSERVER")
    
    /**
    
     * 表示当前这个服务需要调用其他的服务的名称
    
     *
    
     * @author Administrator
    
     *
    
     */
    
    @Configuration
    
    public class Main {
    
    @LoadBalanced//启动负载均衡
    
    @Bean
    
    RestTemplate restTemplate() {
    
    return new RestTemplate();
    
    }
    
     
    
    public static void main(String[] args) {
    
    SpringApplication.run(Main.class, args);
    
    }
    
     
    
    }


     

    定义LoadBalancerClient 可以用于测试选择的服务器的算法 负载的算法的类需要实现 IRule 接口 以下列表摘自网络

    策略名

    策略描述

    BestAvailableRule

    选择一个最小的并发请求的server

    AvailabilityFilteringRule

    过滤掉那些因为一直连接失败的被标记为circuit tripped的后端server,并过滤掉那些高并发的的后端server(active connections 超过配置的阈值)

    WeightedResponseTimeRule

    根据相应时间分配一个weight,相应时间越长,weight越小,被选中的可能性越低。

    RetryRule

    对选定的负载均衡策略机上重试机制。

    RoundRobinRule

    roundRobin方式轮询选择server

    RandomRule

    随机选择一个server

    ZoneAvoidanceRule

    复合判断server所在区域的性能和server的可用性选择server

    ribbon默认的配置类为 RibbonClientConfiguration 其中配置IRule的bean为

     

    负载均衡的规则配置:

    EMAILSERVER:用户名

    EMAILSERVER.ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RandomRule

     

    Feign(面向接口式)

    加入依赖:

    <dependency>
    
        	<groupId>org.springframework.cloud</groupId>
    
        	<artifactId>spring-cloud-starter-feign</artifactId>
    
    </dependency>


     

    配置文件:

    spring.application.name=EMAIL
    
    server.port=8888
    
    eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka/
    
    #服务器的算法(随机)
    
    EMAILSERVER.ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RandomRule


     

    接口

    package cn.et;
    
     
    
    import java.util.Map;
    
     
    
    import org.springframework.cloud.netflix.feign.FeignClient;
    
    import org.springframework.web.bind.annotation.GetMapping;
    
    import org.springframework.web.bind.annotation.PathVariable;
    
    import org.springframework.web.bind.annotation.PostMapping;
    
    import org.springframework.web.bind.annotation.RequestBody;
    
     
    
    @FeignClient("EMAILSERVER")
    
    public interface IsendMail {
    
    @GetMapping("/user/{userId}")
    
    public Map getUser(@PathVariable("userId") String userId);
    
    @PostMapping("/send")
    
    public String send(@RequestBody Map<String,Object> map);
    
    }

    控制类

    package cn.et;
    
    
    
    import java.util.HashMap;
    
    import java.util.Map;
    
     
    
    import org.springframework.beans.factory.annotation.Autowired;
    
    import org.springframework.http.HttpEntity;
    
    import org.springframework.http.HttpHeaders;
    
    import org.springframework.stereotype.Controller;
    
    import org.springframework.web.bind.annotation.GetMapping;
    
    import org.springframework.web.bind.annotation.PostMapping;
    
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import org.springframework.web.client.RestClientException;
    
     
    
     
    
    @Controller
    
    public class SendController {
    
     
    
    @Autowired
    
    private IsendMail sendMail;
    
    @GetMapping("/sendClient")
    
    public String send(String email_to,String email_subject ,String email_content){
    
    //调用email服务
    
    String controller="/send";
    
    //通过注册中心客户端负载均衡  获取一台主机来调用
    
    try {
    
    controller += "?email_to="+email_to+"&email_subject="+email_subject+"&email_content="+email_content;
    
    //String result=restTemplate.getForObject("http://EMAILSERVER"+controller, String.class);
    
    } catch (RestClientException e) {
    
    // TODO Auto-generated catch block
    
    e.printStackTrace();
    
    return "redirect:/error.html";
    
    }
    
    return "redirect:/suc.html";
    
    }
    
    /**
    
     * 演示post
    
     * @param email_to
    
     * @param email_subject
    
     * @param email_content
    
     * @return
    
     */
    
    @PostMapping("/sendClientpost")
    
    public String postsend(String email_to,String email_subject ,String email_content){
    
    try {
    
    Map<String,Object> map=new HashMap<String,Object>();
    
    map.put("email_to",email_to );
    
    map.put("email_subject", email_subject);
    
    map.put("email_content", email_content);
    
    sendMail.send(map);
    
    } catch (RestClientException e) {
    
    // TODO Auto-generated catch block
    
    e.printStackTrace();
    
    return "redirect:/error.html";
    
    }
    
    return "redirect:/suc.html";
    
    }
    
    /**
    
     * 演示调用sendmail的/user/这个请求
    
     * @return
    
     */
    
    @ResponseBody
    
    @GetMapping("/invokeUser")
    
    public String invokeUser(String id){
    
    Map map=sendMail.getUser(id);
    
    return map.get("name").toString();
    
    }
    
    }
    
    启动类
    
    package cn.et;
    
     
    
    import java.util.Map;
    
     
    
    import org.springframework.cloud.netflix.feign.FeignClient;
    
    import org.springframework.web.bind.annotation.GetMapping;
    
    import org.springframework.web.bind.annotation.PathVariable;
    
    import org.springframework.web.bind.annotation.PostMapping;
    
    import org.springframework.web.bind.annotation.RequestBody;
    
     
    
    @FeignClient("EMAILSERVER")
    
    public interface IsendMail {
    
    @GetMapping("/user/{userId}")
    
    public Map getUser(@PathVariable("userId") String userId);
    
    @PostMapping("/send")
    
    public String send(@RequestBody Map<String,Object> map);
    
    }


     

     

    展开全文
  • 使用zookeeper可以实现服务的注册和发现,而Curator是对zookeeper进行的一层封装,自然也封装了一套实现服务的注册和发现,本文就介绍如何使用Curator实现服务的注册和发现 首先要安装zookeeper,我这里安装的是:...

    使用zookeeper可以实现服务的注册和发现,而Curator是对zookeeper进行的一层封装,自然也封装了一套实现服务的注册和发现,本文就介绍如何使用Curator实现服务的注册和发现

    首先要安装zookeeper,我这里安装的是:zookeeper-3.4.6


    curator 的依赖版本如下:

    <dependency>
    	<groupId>org.apache.curator</groupId>
    	<artifactId>curator-x-discovery-server</artifactId>
    	<version>2.9.1</version>
    </dependency>

    做服务的注册和发现,自然要有服务端和客户端

    服务端代码如下:

    服务端一:

    package com.mall.zk.service;
    
    /**
     * 服务的附加信息
     */
    public class ServiceDetail {
    	//服务注册的根路径
    	public static final String REGISTER_ROOT_PATH = "/mall";
    	
    	private String desc;
    	private int weight;
    	
    	public ServiceDetail() {}
    	public ServiceDetail(String desc, int weight) {
    		this.desc = desc;
    		this.weight = weight;
    	}
    	public String getDesc() {
    		return desc;
    	}
    	public void setDesc(String desc) {
    		this.desc = desc;
    	}
    	public int getWeight() {
    		return weight;
    	}
    	public void setWeight(int weight) {
    		this.weight = weight;
    	}
    	@Override
    	public String toString() {
    		return "ServiceDetail [desc=" + desc + ", weight=" + weight + "]";
    	}
    }

    package com.mall.zk.server;
    
    import java.util.concurrent.TimeUnit;
    
    import org.apache.curator.framework.CuratorFramework;
    import org.apache.curator.framework.CuratorFrameworkFactory;
    import org.apache.curator.retry.ExponentialBackoffRetry;
    import org.apache.curator.x.discovery.ServiceDiscovery;
    import org.apache.curator.x.discovery.ServiceDiscoveryBuilder;
    import org.apache.curator.x.discovery.ServiceInstance;
    import org.apache.curator.x.discovery.ServiceInstanceBuilder;
    import org.apache.curator.x.discovery.details.JsonInstanceSerializer;
    
    import com.mall.zk.service.ServiceDetail;
    
    public class AppServer {
    	public static void main(String[] args) throws Exception {
    		CuratorFramework client = CuratorFrameworkFactory.newClient("192.168.1.101:2181", new ExponentialBackoffRetry(1000, 3));
    		client.start();
    		client.blockUntilConnected();
    		
    		/**
    		 * 指定服务的 地址,端口,名称
    		 */
    		ServiceInstanceBuilder<ServiceDetail> sib = ServiceInstance.builder();
    		sib.address("192.168.1.100");
    		sib.port(8855);
    		sib.name("tomcat");
    		sib.payload(new ServiceDetail("主站web程序", 1));
    		
    		ServiceInstance<ServiceDetail> instance = sib.build();
    		
    		ServiceDiscovery<ServiceDetail> serviceDiscovery = ServiceDiscoveryBuilder.builder(ServiceDetail.class)
    														   .client(client)
    														   .serializer(new JsonInstanceSerializer<ServiceDetail>(ServiceDetail.class))
    														   .basePath(ServiceDetail.REGISTER_ROOT_PATH)
    														   .build();
    		//服务注册
    		serviceDiscovery.registerService(instance);
    		serviceDiscovery.start();
    		
    		TimeUnit.SECONDS.sleep(70);
    		
    		serviceDiscovery.close();
    		client.close();
    	}
    }
    服务端二:

    package com.mall.zk.server;
    
    import java.util.concurrent.TimeUnit;
    
    import org.apache.curator.framework.CuratorFramework;
    import org.apache.curator.framework.CuratorFrameworkFactory;
    import org.apache.curator.retry.ExponentialBackoffRetry;
    import org.apache.curator.x.discovery.ServiceDiscovery;
    import org.apache.curator.x.discovery.ServiceDiscoveryBuilder;
    import org.apache.curator.x.discovery.ServiceInstance;
    import org.apache.curator.x.discovery.ServiceInstanceBuilder;
    import org.apache.curator.x.discovery.details.JsonInstanceSerializer;
    
    import com.mall.zk.service.ServiceDetail;
    
    public class AppServer2 {
    	public static void main(String[] args) throws Exception {
    		CuratorFramework client = CuratorFrameworkFactory.newClient("192.168.1.101:2181", new ExponentialBackoffRetry(1000, 3));
    		client.start();
    		client.blockUntilConnected();
    		
    		/**
    		 * 指定服务的 地址,端口,名称
    		 */
    		ServiceInstanceBuilder<ServiceDetail> sib = ServiceInstance.builder();
    		sib.address("192.168.1.100");
    		sib.port(8866);
    		sib.name("tomcat");
    		sib.payload(new ServiceDetail("主站web程序", 2));
    		
    		ServiceInstance<ServiceDetail> instance = sib.build();
    		
    		ServiceDiscovery<ServiceDetail> serviceDiscovery = ServiceDiscoveryBuilder.builder(ServiceDetail.class)
    														   .client(client)
    														   .serializer(new JsonInstanceSerializer<ServiceDetail>(ServiceDetail.class))
    														   .basePath(ServiceDetail.REGISTER_ROOT_PATH)
    														   .build();
    		//服务注册
    		serviceDiscovery.registerService(instance);
    		serviceDiscovery.start();
    		
    		TimeUnit.SECONDS.sleep(70);
    		
    		serviceDiscovery.close();
    		client.close();
    	}
    }
    上面两个服务端代码,几乎一样,只是服务端口,权重不一样。然后运行上面两个main方法

    然后,去zk里面查看

    [zk: localhost:2181(CONNECTED) 54] ls /mall/tomcat
    [a8657594-ef32-4efc-b2b0-3077d105e486, b5b55bbc-ce04-4b70-9413-1ec3c54023b8]
    可以看到,有2个临时节点,也就意味着有两个服务

    客户端代码:

    package com.mall.zk.client;
    
    import java.util.Collection;
    
    import org.apache.curator.framework.CuratorFramework;
    import org.apache.curator.framework.CuratorFrameworkFactory;
    import org.apache.curator.retry.ExponentialBackoffRetry;
    import org.apache.curator.x.discovery.ServiceDiscovery;
    import org.apache.curator.x.discovery.ServiceDiscoveryBuilder;
    import org.apache.curator.x.discovery.ServiceInstance;
    
    import com.mall.zk.service.ServiceDetail;
    
    public class AppClient {
    	public static void main(String[] args) throws Exception{
    		CuratorFramework client = CuratorFrameworkFactory.newClient("192.168.1.101:2181", new ExponentialBackoffRetry(1000, 3));
    		client.start();
    		client.blockUntilConnected();
    		
    		ServiceDiscovery<ServiceDetail> serviceDiscovery = ServiceDiscoveryBuilder.builder(ServiceDetail.class)
    													.client(client)
    													.basePath(ServiceDetail.REGISTER_ROOT_PATH)
    													.build();
    		serviceDiscovery.start();
    		
    		//根据名称获取服务
    		Collection<ServiceInstance<ServiceDetail>> services = serviceDiscovery.queryForInstances("tomcat");
    		for(ServiceInstance<ServiceDetail> service : services) {
    			System.out.println(service.getPayload());
    			System.out.println(service.getAddress() + "\t" + service.getPort());
    			System.out.println("---------------------");
    		}
    		
    		serviceDiscovery.close();
    		client.close();
    	}
    }

    运行客户端,输出:

    ServiceDetail [desc=主站web程序, weight=2]
    192.168.1.100	8866
    ---------------------
    ServiceDetail [desc=主站web程序, weight=1]
    192.168.1.100	8855
    ---------------------

    展开全文
  • 2020-09-04:springcloud如何实现服务的注册和发现?前言springcloud如何实现服务的注册和发现? 前言 每日一题专栏 springcloud如何实现服务的注册和发现? 服务在发布时 指定对应的服务名(服务名包括了IP地址和...

    2020-09-04:springcloud如何实现服务的注册和发现?

    前言

    每日一题专栏

    springcloud如何实现服务的注册和发现?

    服务在发布时 指定对应的服务名(服务名包括了IP地址和端口) 将服务注册到注册中心(eureka或者zookeeper)

    这一过程时springcloud自动实现 只需要在main方法添加@EnableDisscoveryClient 同一个服务修改端口就可以启动多个实例

    调用方法:传递服务名称通过注册中心获取所有的可用实例,通过负载均衡策略调用(ribbon和feign)对应的服务

    展开全文
  • Eureka 是 Netflix 开源的服务注册发现组件,服务发现可以说是微服务架构核心功能了,微服务部署之后,一定要有服务注册和发现的能力,Eureka 就是担任这个角色。Rest API与RPC是服务调用,eureka和zookeeper是...

    微服务框架中有三类角色,分别是注册中心、服务提供者、服务消费者,注册中心就是Eureka

    Eureka是什么:

    1. Eureka 是 Netflix 开源的服务注册发现组件,服务发现可以说是微服务架构的核心功能了,微服务部署之后,一定要有服务注册和发现的能力,Eureka 就是担任这个角色的。Rest API与RPC是服务调用,eureka和zookeeper是服务注册与发现,rest中的服务注册和发现的功能是用eureka来实现的;dubbo 中服务注册和发现的功能是用 zookeeper 来实现的。
    2. Eureka是一个基于REST的服务,用于定位服务,以实现云端中间层服务发现和故障转移。Eureka 主管服务注册与发现,在微服务中,有了这两者,只需要使用服务的标识符(在每个服务的yml文件中取得服务名称)就可以访问到服务,不需要修改服务调用的配置文件。
    3. 是Spring Cloud提供服务中心来管理服务信息,是Spring Cloud的子项目,Spring Cloud Eureka 是基于Spring Cloud Netflix 做了二次封装,实现了服务治理功能,提供EurekaServer、EurekaClient,服务端即是服务注册中心,客户端完成微服务向Eureka服务的注册和发现。
    4. Eureka遵循AP原则(高可用,分区容错性),因为使用了自我保护机制所以保证了高可用。

    Eureka 采用了C-S的设计架构。包含两个组件:Eureka Server(提供注册服务)、 Eureka Client(JAVA客户端,负责发送心跳)

    1. Eureka Server 提供服务注册服务:Eureka Server 作为服务注册功能的服务器,它是服务注册中心。各个节点启动后,会在Eureka Server中进行注册,这样 Eureka Server中的服务注册表中将会存储所有可用服务节点的信息,服务节点的信息可以在界面中直观的看到。
    2. EurekaClient 是一个Java客户端,用于简化Eureka Server的交互,客户端同时也具备一个内置的、使用轮询(round-robin)法的负载均衡器。在应用启动后,将会向 Eureka Server 发送心跳(默认周期为 30 秒)。如果 Eureka Server在多个心跳周期内没有接收到某个节点的心跳,Eureka Server 将会从服务注册表中把这个服务节点移除(默认 90 秒)。

    运行原理:

    服务提供者和消费者都注册到Eureka服务器上,浏览器访问消费者地址,消费者会通过Eureka服务器上服务提供者的名字,找到提供者的真实路径,进行调用。高可用时可以搭建几个Eureka服务器,互相注册,复制各自信息。

    为什么需要注册中心:

    要进行远程调用就需要知道服务端的ip和端口,而注册中心帮助我们管理这些服务端口和ip

    Eureka三大角色

    1. Eureka Server 提供服务注册和发现
    2. Server Provider 服务提供方将自身服务注册到Eureka,从而使服务消费方能够找到,提供服务给个别调用。
    3. Server Consumer 服务消费方从Eureka获取注册服务列表,从而能够消费服务,调用个别提供的服务。

    注:往往大多数服务本身既是服务提供者,也是服务消费者。

    Eureka的自我保护:

    某时刻某一个微服务不可用了,Eureka不会立即清理,依旧会对微服务的信息进行保护。

    构建集群版Eureka Server服务注册中心可以看我的另一个博客

    https://blog.csdn.net/Afflatus_f/article/details/102708483

     

    展开全文
  • 用Eureka做服务的注册和发现,有一个奇怪的现象:有些服务停止后(如图中的A-BOOTIFUL-CLIENT-2服务),该服务还会在Eureka上显示一段时间,需要过一段时间在更新该服务才会在Eureka上消失。 原因 这是由于...
  • Nacos 提供了一组简单易用特性集,帮助您快速实现动态服务发现服务配置、服务元数据及流量管理。简之就是作为配置中心和注册中心。 Nacos安装 应用构建Nacos作为注册中心实现 构建SpringBoot项目,修改pom....
  • 转载地址:...服务发现 - 客户端应用进程向注册中心发起查询,来获取服务的位置。服务发现的一个重要作用就是提供一个可用的服务列表服务定义的格式类似如下:[pla...
  • springcloud如何实现服务的注册和发现

    千次阅读 2019-03-17 22:09:16
    服务在发布时指定对应的服务名(服务名包括了IP地址端口)将服务注册注册中心(eureka或者zookeeper) 这一过程是springcloud自动实现只需要在main方法添加@EnableDisscoveryClient同一个服务修改端口就可以...
  • 进而可以在SpringCloud的服务平台中对SpringBoot一个个服务进行注册和监控。 一、服务注册与发现 关于服务注册与发现,这里有一篇文章讲特别好,也是我写这边博文原因,我们在做微服务时候,很多时候,不...
  • 首先安装consul环境,参照之前文章:《服务注册发现consul之一:consul介绍及安装》中第一节介绍。 Spring Cloud使用Consul的服务发现 1、导入依赖pring-cloud-starter-consul-discovery。 2、在其入口文件...
  • 用springboot写了几个项目,leader说服务可以试着向consul上边迁移,于是搭建了consul测试集群,至于为什么不用eureka,可以看下边这个表 Feature Consul zookeeper etcd euerka 服务健康检查 ...
  • 1 搭建consul环境参考SPING CLOID 官方 http://cloud.spring.io/spring-cloud-consul/ consul官方文档 ...2 建立Consul Cluster 要想利用Consul提供的服务实现服务的注册发现,我们需要建立Consul
  • 失败重新注册和订阅 本地缓存服务信息列表 大体过程如下: 1.服务提供者暴露服务后向注册中心注册,如果多个注册中心话,需要分别注册到多个注册中心;注册信息包含自己主机名,端口号,服务名,其他额外参数等。...
  • 服务的注册与发现是微服务必不可少的功能,这样系统才能有更高的性能,更高的可用性。go-micro框架的服务发现有自己能用的接口Registry。只要实现这个接口就可以定制自己的服务注册和发现。 go-micro在客户端做的...
  • &amp;amp;amp;amp;amp;nbsp;&amp;amp;...微服务可以在”自己程序”中运行...关键在于该服务可以在自己程序中运行。通过这一点我们就可以将服务公开与微服务架构(在现有系统中分布一个API)区分开来。在服务公开
  • 一、Spring Cloud简介 Spring Cloud是基于SpringBoot,为开发人员提供了快速构建分布式系统一些...在这里,我们需要用的的组件上Spring Cloud NetflixEureka ,eureka是一个服务注册和发现模块。 Eureka: ...
  • 创建我们的服务注册中心 创建一个服务提供者eureka client spring cloud 为开发人员提供了快速构建分布式系统一些工具,包括配置管理、服务发现、断路器、路由、微代理、事件总线、全局锁、决策竞选、分布式...
  • 注意这里spring.cloud.zookeeper.discovery.register必须配置为false,否则,应用启动之后,也去zookeeper里面注册服务 启动main方法, 访问http://127.0.0.1:8844/discovery 系统会返回一个可用的服务,...
  • #强制不注册注册服务器 eureka.client.register-with-eureka=false eureka.client.fetch-registry=false #注册中心地址 eureka.client.serviceUrl.defaultZone=http://localhost:${server.port}/eureka/ Java代码...
  • 前言​ 微服务意义概念在当下十分火热,而spring同样提供了实现微服务SpringCloud框架。更多也不多说,希望通过这个系列记录学习过程的的经验。​ 所有版本以SpringBoot2.xSpringCloud Finchley为主,构建...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,200
精华内容 4,080
关键字:

服务的注册和发现