精华内容
下载资源
问答
  • Nacos做服务注册中心使用案例

    万次阅读 2020-09-21 04:27:51
    关于环境搭建部分请借鉴:nacos做配置中心和服务注册中心 的完整使用案例 <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-...

    关于环境搭建部分请借鉴:nacos做配置中心和服务注册中心 的完整使用案例

    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    
    server.port=8070
    spring.application.name=server-provider
    spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848
    

    主启动类示例代码

    @SpringBootApplication
    @EnableDiscoveryClient
    public class NacosProviderApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(NacosProviderApplication.class, args);
    	}
    
    	@RestController
    	class EchoController {
    		@RequestMapping(value = "/echo/{string}", method = RequestMethod.GET)
    		public String echo(@PathVariable String string) {
    			return "Hello Nacos Discovery " + string;
    		}
    	}
    }
    

    然后启动该主启动类,注意:主启动类至少有一个restful风格的请求资源,不然容易失败,因为是一个空服务

    启动项目后,如下在服务列表中能找到说明成功!
    在这里插入图片描述

    Springboot的示例代码

    在这里插入图片描述

    展开全文
  • import org.springframework.beans.factory.annotation.Value; import org.springframework.cloud.context.config.annotation.RefreshScope; import org.springframework.web.bind.annotation.GetMapping;...
  • 使用服务注册特殊广播接收者

    万次阅读 2017-02-23 00:48:56
    1.屏幕的解锁和锁屏广播,属于安卓系统中操作特别频繁的广播事件 2.它在清单文件中注册无效...4.所以,考虑在服务中去注册广播接收者 MainActivity类: package com.itheima74.screenservice; import android.content.I

    1.屏幕解锁与锁屏,属安卓系统操作特别频繁广播事件
    2.在清单文件中注册无效,需在代码中注册
    3.若在MainActivity中注册,当MainActivity销毁时无法接收广播
    4.考虑在服务中注册广播接收者

    MainActivity:

    package com.itheima74.rigisterservice;
    
    import android.app.Activity;
    import android.content.Intent;
    import android.os.Bundle;
    
    public class MainActivity extends Activity {
    
    	@Override
    	protected void onCreate(Bundle savedInstanceState) {
    		super.onCreate(savedInstanceState);
    		setContentView(R.layout.activity_main);
    		
    		//开启服务
    		Intent intent = new Intent(this,ScreenService.class);
    		startService(intent);
    
    	}
    
    }
    

    ScreenReceiver:

    package com.itheima74.rigisterservice;
    
    import android.content.BroadcastReceiver;
    import android.content.Context;
    import android.content.Intent;
    import android.util.Log;
    
    public class ScreenReceiver extends BroadcastReceiver {
    	// 当屏幕锁屏或解锁执行该方法
    	@Override
    	public void onReceive(Context context, Intent intent) {
    		String action = intent.getAction();
    		if ("android.intent.action.SCREEN_OFF".equals(action)) {
    			Log.i("手机锁屏了");
    		} else if ("android.intent.action.SCREEN_ON".equals(action)) {
    			Log.i("手机解锁了");
    		}
    	}
    
    }
    

    ScreenService:

    package com.itheima74.rigisterservice;
    
    import android.app.Service;
    import android.content.Intent;
    import android.content.IntentFilter;
    import android.os.IBinder;
    
    public class ScreenService extends Service {
    	private ScreenReceiver receiver;
    	@Override
    	public IBinder onBind(Intent intent) {
    		return null;
    	}
    
    	@Override
    	public void onCreate() {
    		super.onCreate();
    		// 为什么不在Mainactivity中注册?
    		// 因特殊广播接收者在Mainactivity退出后无效,需在后台长期运行
    		receiver = new ScreenReceiver();
    		IntentFilter filter = new IntentFilter();
    		filter.addAction("android.intent.action.SCREEN_OFF");
    		filter.addAction("android.intent.action.SCREEN_ON");
    		registerReceiver(receiver, filter);
    	}
    
    	@Override
    	public void onDestroy() {
    		super.onDestroy();
    		unregisterReceiver(receiver);
    	}
    }
    

     

    展开全文
  • nacos源码阅读--服务注册

    万次阅读 2021-02-07 18:16:01
    **很显然,启动注册服务的操作便在NacosServiceRegistry当中。 NacosServiceRegistry可以通过查找所有类直接寻找,也可以从以下springboot自动装配的角度去寻找 通过查看spring.factories文件也可以看到,nacos自动...

    一、springboot启动日志报NacosServiceRegistry

    springboot+nacos启动时,log会有一条nacos注册信息如下:
    在这里插入图片描述
    **很显然,启动注册服务的操作便在NacosServiceRegistry当中。

    NacosServiceRegistry可以通过查找所有类直接寻找,也可以从以下springboot自动装配的角度去寻找

    通过查看spring.factories文件也可以看到,nacos自动装配的类如下,nacos按照了springboot的约定进行了自动装配:**
    在这里插入图片描述
    进入到NacosDiscoveryAutoConfiguration发现,前两个Bean都是作为最后一个Bean的参数,猜想第三个bean是主要的注册方法。
    在这里插入图片描述
    ****点进去发现他继承了AbstractAutoServiceRegistration.class,并且AbstractAutoServiceRegistration.class实现了ApplicationContextAware以及ApplicationListener,果然下方有一个onApplicationEvent的方法
    在这里插入图片描述
    监听器中有一个bind方法,bind方法中又有一个start方法:

    public void start() {
            if (!this.isEnabled()) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Discovery Lifecycle disabled. Not starting");
                }
    
            } else {
                if (!this.running.get()) {
                    this.context.publishEvent(new InstancePreRegisteredEvent(this, this.getRegistration()));
                    this.register();
                    if (this.shouldRegisterManagement()) {
                        this.registerManagement();
                    }
    
                    this.context.publishEvent(new InstanceRegisteredEvent(this, this.getConfiguration()));
                    this.running.compareAndSet(false, true);
                }
    
            }
        }
    

    其中的register便是注册方法。由此便找到了NacosServiceRegistry.class

    二、register剖析

    register方法如下:

    public void register(Registration registration) {
            if (StringUtils.isEmpty(registration.getServiceId())) {
                log.warn("No service to register for nacos client...");
            } else {
                String serviceId = registration.getServiceId();
                Instance instance = this.getNacosInstanceFromRegistration(registration);
    
                try {
                    this.namingService.registerInstance(serviceId, instance);
                    log.info("nacos registry, {} {}:{} register finished", new Object[]{serviceId, instance.getIp(), instance.getPort()});
                } catch (Exception var5) {
                    log.error("nacos registry, {} register failed...{},", new Object[]{serviceId, registration.toString(), var5});
                }
    
            }
        }
    

    2.1 getServiceId查看源码最终发现读取了配置文件的spring项目的name
    在这里插入图片描述
    2.2 getNacosInstanceFromRegistration方法获取了本地客户端的一些信息,然后生成实例

     private Instance getNacosInstanceFromRegistration(Registration registration) {
            Instance instance = new Instance();
            instance.setIp(registration.getHost());
            instance.setPort(registration.getPort());
            instance.setWeight((double)this.nacosDiscoveryProperties.getWeight());
            instance.setClusterName(this.nacosDiscoveryProperties.getClusterName());
            instance.setMetadata(registration.getMetadata());
            return instance;
        }
    

    那么注册的主要方法便是this.namingService.registerInstance(serviceId, instance);

    2.3 registerInstance方法设置了注册需要的一些基础信息,其中groupname默认为DEFAULT_GROUP

    public void registerInstance(String serviceName, String groupName, Instance instance) throws NacosException {
            if (instance.isEphemeral()) {
                BeatInfo beatInfo = new BeatInfo();
                beatInfo.setServiceName(NamingUtils.getGroupedName(serviceName, groupName));
                beatInfo.setIp(instance.getIp());
                beatInfo.setPort(instance.getPort());
                beatInfo.setCluster(instance.getClusterName());
                beatInfo.setWeight(instance.getWeight());
                beatInfo.setMetadata(instance.getMetadata());
                beatInfo.setScheduled(false);
                long instanceInterval = instance.getInstanceHeartBeatInterval();
                beatInfo.setPeriod(instanceInterval == 0L ? DEFAULT_HEART_BEAT_INTERVAL : instanceInterval);
                this.beatReactor.addBeatInfo(NamingUtils.getGroupedName(serviceName, groupName), beatInfo);
            }
    
            this.serverProxy.registerService(NamingUtils.getGroupedName(serviceName, groupName), groupName, instance);
        }
    

    其中最后一行代码执行了注册动作,注册之前会通过schedule的方式添加定时心跳检测任务,默认五秒检测,而且会根据计算机可用资源核心数除以二分配检测资源(最小为1核心数),暂时不看

    2.4 registerService方法进行了post请求,将本地的一些基础信息作为参数放入到请求体当中,进行post

    public void registerService(String serviceName, String groupName, Instance instance) throws NacosException {
            LogUtils.NAMING_LOGGER.info("[REGISTER-SERVICE] {} registering service {} with instance: {}", new Object[]{this.namespaceId, serviceName, instance});
            Map<String, String> params = new HashMap(9);
            params.put("namespaceId", this.namespaceId);
            params.put("serviceName", serviceName);
            params.put("groupName", groupName);
            params.put("clusterName", instance.getClusterName());
            params.put("ip", instance.getIp());
            params.put("port", String.valueOf(instance.getPort()));
            params.put("weight", String.valueOf(instance.getWeight()));
            params.put("enable", String.valueOf(instance.isEnabled()));
            params.put("healthy", String.valueOf(instance.isHealthy()));
            params.put("ephemeral", String.valueOf(instance.isEphemeral()));
            params.put("metadata", JSON.toJSONString(instance.getMetadata()));
            this.reqAPI(UtilAndComs.NACOS_URL_INSTANCE, params, (String)"POST");
        }
    

    最后通过callServer方法中的httpClient进行了http请求,请求地址为http://127.0.0.1:8848/nacos/v1/ns/instance
    在这里插入图片描述
    而通过debug执行这一行代码之后,在nacos就能看到服务已经注册了上去。

    客户端已经知道注册的流程是怎么样的了,接下来看服务端接收到http请求会有什么样的操作。

    三、服务端的处理

    上面的http请求地址为http://127.0.0.1:8848/nacos/v1/ns/instance,对应的controller方法为register方法,位置如下:
    在这里插入图片描述
    3.1 点击去之后发现最终的实现方法为registerInstance

    public void registerInstance(String namespaceId, String serviceName, Instance instance) throws NacosException {
            
            createEmptyService(namespaceId, serviceName, instance.isEphemeral());
            
            Service service = getService(namespaceId, serviceName);
            
            if (service == null) {
                throw new NacosException(NacosException.INVALID_PARAM,
                        "service not found, namespace: " + namespaceId + ", service: " + serviceName);
            }
            
            addInstance(namespaceId, serviceName, instance.isEphemeral(), instance);
        }
    

    首先会去创建一个新的service,namespaceId为键,如果namespaceId不存在,则执行createServiceIfAbsent,服务第一次都会进行这个方法的执行,执行之后会保存在一个叫serviceMap的Map存储结构当中,相当于缓存

    public void createEmptyService(String namespaceId, String serviceName, boolean local) throws NacosException {
        createServiceIfAbsent(namespaceId, serviceName, local, null);
    }
    

    3.2 接着是addInstance方法,这个方法会根据ip地址

    public void addInstance(String namespaceId, String serviceName, boolean ephemeral, Instance... ips)
                throws NacosException {
            
            String key = KeyBuilder.buildInstanceListKey(namespaceId, serviceName, ephemeral);
            
            Service service = getService(namespaceId, serviceName);
            
            synchronized (service) {
                List<Instance> instanceList = addIpAddresses(service, ephemeral, ips);
                
                Instances instances = new Instances();
                instances.setInstanceList(instanceList);
                
                consistencyService.put(key, instances);
            }
        }
    

    最后通过consistencyService.put(key, instances);做持久化,并没有持久到数据库当中。

    ConsistencyService类会通过添加监听器的方式,当值进行变化时执行onchange方法来更改服务当前状态:

    展开全文
  • Eureka服务注册中心---SpringCloud

    万次阅读 2021-01-15 15:43:32
    Eureka服务注册中心 5.1 什么是Eureka Netflix在涉及Eureka时,遵循的就是API原则. Eureka是Netflix的有个子模块,也是核心模块之一。Eureka是基于REST的服务,用于定位服务,以实现云端中间件层服务发现和故障转移...

    Eureka服务注册中心

    5.1 什么是Eureka

    • Netflix在涉及Eureka时,遵循的就是API原则.
    • Eureka是Netflix的有个子模块,也是核心模块之一。Eureka是基于REST的服务,用于定位服务,以实现云端中间件层服务发现和故障转移,服务注册与发现对于微服务来说是非常重要的,有了服务注册与发现,只需要使用服务的标识符,就可以访问到服务,而不需要修改服务调用的配置文件了,功能类似于Dubbo的注册中心,比如Zookeeper.

    原理

    • Eureka基本的架构
      • Springcloud 封装了Netflix公司开发的Eureka模块来实现服务注册与发现 (对比Zookeeper).
      • Eureka采用了C-S的架构设计,EurekaServer作为服务注册功能的服务器,他是服务注册中心.
      • 而系统中的其他微服务,使用Eureka的客户端连接到EurekaServer并维持心跳连接。这样系统的维护人员就可以通过EurekaServer来监控系统中各个微服务是否正常运行,Springcloud 的一些其他模块 (比如Zuul) 就可以通过EurekaServer来发现系统中的其他微服务,并执行相关的逻辑.

    在这里插入图片描述

    • 和Dubbo架构对比.

      在这里插入图片描述

    • Eureka 包含两个组件:Eureka ServerEureka Client.

    • Eureka Server 提供服务注册,各个节点启动后,回在EurekaServer中进行注册,这样Eureka Server中的服务注册表中将会储存所有课用服务节点的信息,服务节点的信息可以在界面中直观的看到.

    • Eureka Client 是一个Java客户端,用于简化EurekaServer的交互,客户端同时也具备一个内置的,使用轮询负载算法的负载均衡器。在应用启动后,将会向EurekaServer发送心跳 (默认周期为30秒) 。如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳,EurekaServer将会从服务注册表中把这个服务节点移除掉 (默认周期为90s).

    • 三大角色

      • Eureka Server:提供服务的注册与发现
      • Service Provider:服务生产方,将自身服务注册到Eureka中,从而使服务消费方能狗找到
      • Service Consumer:服务消费方,从Eureka中获取注册服务列表,从而找到消费服务
    • 目前工程状况

    在这里插入图片描述

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L2Cf7adP-1610696585775)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210114232936013.png)]

    eureka-server

    1. springcloud-eureka-7001 模块建立

    2. pom.xml 配置

      <!--导包~-->
      <dependencies>
          <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server -->
          <!--导入Eureka Server依赖-->
          <dependency>
              <groupId>org.springframework.cloud</groupId>
              <artifactId>spring-cloud-starter-eureka-server</artifactId>
              <version>1.4.6.RELEASE</version>
          </dependency>
          <!--热部署工具-->
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-devtools</artifactId>
          </dependency>
      </dependencies>
      
    3. application.yml

      server:
        port: 7001
      
      # Eureka配置
      eureka:
        instance:
          # Eureka服务端的实例名字
          hostname: 127.0.0.1
        client:
          # 表示是否向 Eureka 注册中心注册自己(这个模块本身是服务器,所以不需要)
          register-with-eureka: false
          # fetch-registry如果为false,则表示自己为注册中心,客户端的化为 ture
          fetch-registry: false
          # Eureka监控页面~
          service-url:
            defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      

    源码中Eureka的默认端口以及访问路径:

    在这里插入图片描述

    1. 主启动类

      /**
       * @Auther: csp1999
       * @Date: 2020/05/18/10:26
       * @Description: 启动之后,访问 http://127.0.0.1:7001/
       */
      @SpringBootApplication
      // @EnableEurekaServer 服务端的启动类,可以接受别人注册进来~
      @EnableEurekaServer
      public class EurekaServer_7001 {
          public static void main(String[] args) {
              SpringApplication.run(EurekaServer_7001.class,args);
          }
      }
      
    2. 启动成功后访问 http://localhost:7001/ 得到以下页面

    在这里插入图片描述

    eureka-client

    调整之前创建的springlouc-provider-dept-8001

    1. 导入Eureca依赖

      <!--Eureka依赖-->
      <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka -->
      <dependency>
          <groupId>org.springframework.cloud</groupId>
          <artifactId>spring-cloud-starter-eureka</artifactId>
          <version>1.4.6.RELEASE</version>
      </dependency>
      
      
    2. application中新增Eureca配置

      # Eureka配置:配置服务注册中心地址
      eureka:
        client:
          service-url:
            defaultZone: http://localhost:7001/eureka/
      
    3. 为主启动类添加@EnableEurekaClient注解

      /**
       * @Auther: csp1999
       * @Date: 2020/05/17/22:09
       * @Description: 启动类
       */
      @SpringBootApplication
      // @EnableEurekaClient 开启Eureka客户端注解,在服务启动后自动向注册中心注册服务
      @EnableEurekaClient
      public class DeptProvider_8001 {
          public static void main(String[] args) {
              SpringApplication.run(DeptProvider_8001.class,args);
          }
      }
      
    4. 先启动7001服务端后启动8001客户端进行测试,然后访问监控页http://localhost:7001/ 产看结果如图,成功

    在这里插入图片描述

    1. 修改Eureka上的默认描述信息

      # Eureka配置:配置服务注册中心地址
      eureka:
        client:
          service-url:
            defaultZone: http://localhost:7001/eureka/
        instance:
          instance-id: springcloud-provider-dept-8001 #修改Eureka上的默认描述信息
      
      

      结果如图:
      在这里插入图片描述

      如果此时停掉springcloud-provider-dept-8001 等30s后 监控会开启保护机制:
      在这里插入图片描述

    2. 配置关于服务加载的监控信息

    热部署配置

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gdmsQkHa-1610696585777)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210115003227472.png)]

    完善监控信息(actuator)

    在这里插入图片描述

    pom.xml中添加依赖

    <!--actuator完善监控信息-->
    <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    
    

    application.yml中添加配置

    # info配置
    info:
    # 项目的名称
     app.name: haust-springcloud
    # 公司的名称
     company.name: 河南科技大学西苑校区软件学院  
    

    此时刷新监控页,点击进入在这里插入图片描述跳转新页面显示如下内容:

    在这里插入图片描述

    自我保护机制:好死不如赖活着

    一句话总结就是:某时刻某一个微服务不可用,eureka不会立即清理,依旧会对该微服务的信息进行保存!

    • 默认情况下,当eureka server在一定时间内没有收到实例的心跳,便会把该实例从注册表中删除(默认是90秒),但是,如果短时间内丢失大量的实例心跳,便会触发eureka server的自我保护机制,比如在开发测试时,需要频繁地重启微服务实例,但是我们很少会把eureka server一起重启(因为在开发过程中不会修改eureka注册中心),当一分钟内收到的心跳数大量减少时,会触发该保护机制。可以在eureka管理界面看到Renews threshold和Renews(last min),当后者(最后一分钟收到的心跳数)小于前者(心跳阈值)的时候,触发保护机制,会出现红色的警告:EMERGENCY!EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY'RE NOT.RENEWALS ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEGING EXPIRED JUST TO BE SAFE.从警告中可以看到,eureka认为虽然收不到实例的心跳,但它认为实例还是健康的,eureka会保护这些实例,不会把它们从注册表中删掉。
    • 该保护机制的目的是避免网络连接故障,在发生网络故障时,微服务和注册中心之间无法正常通信,但服务本身是健康的,不应该注销该服务,如果eureka因网络故障而把微服务误删了,那即使网络恢复了,该微服务也不会重新注册到eureka server了,因为只有在微服务启动的时候才会发起注册请求,后面只会发送心跳和服务列表请求,这样的话,该实例虽然是运行着,但永远不会被其它服务所感知。所以,eureka server在短时间内丢失过多的客户端心跳时,会进入自我保护模式,该模式下,eureka会保护注册表中的信息,不在注销任何微服务,当网络故障恢复后,eureka会自动退出保护模式。自我保护模式可以让集群更加健壮。
    • 但是我们在开发测试阶段,需要频繁地重启发布,如果触发了保护机制,则旧的服务实例没有被删除,这时请求有可能跑到旧的实例中,而该实例已经关闭了,这就导致请求错误,影响开发测试。所以,在开发测试阶段,我们可以把自我保护模式关闭,只需在eureka server配置文件中加上如下配置即可:eureka.server.enable-self-preservation=false【不推荐关闭自我保护机制】

    详细内容可以参考下这篇博客内容:https://blog.csdn.net/wudiyong22/article/details/80827594

    注册进来的微服务,获取一些消息(团队开发会用到)

    DeptController.java新增方法

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gdDAPdyk-1610696585779)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210115004810922.png)]

    /**
     * DiscoveryClient 可以用来获取一些配置的信息,得到具体的微服务!
     */
    @Autowired
    private DiscoveryClient client;
    
    /**
     * 获取一些注册进来的微服务的信息~,
     *
     * @return
     */
    @GetMapping("/dept/discovery")
    public Object discovery() {
        // 获取微服务列表的清单
        List<String> services = client.getServices();
        System.out.println("discovery=>services:" + services);
        // 得到一个具体的微服务信息,通过具体的微服务id,applicaioinName;
        List<ServiceInstance> instances = client.getInstances("SPRINGCLOUD-PROVIDER-DEPT");
        for (ServiceInstance instance : instances) {
            System.out.println(
                    instance.getHost() + "\t" + // 主机名称
                            instance.getPort() + "\t" + // 端口号
                            instance.getUri() + "\t" + // uri
                            instance.getServiceId() // 服务id
            );
        }
        return this.client;
    }
    

    在这里插入图片描述

    主启动类中加入@EnableDiscoveryClient 注解

    @SpringBootApplication
    // @EnableEurekaClient 开启Eureka客户端注解,在服务启动后自动向注册中心注册服务
    @EnableEurekaClient
    // @EnableEurekaClient 开启服务发现客户端的注解,可以用来获取一些配置的信息,得到具体的微服务
    @EnableDiscoveryClient
    public class DeptProvider_8001 {
        ...
    }
    
    

    结果如图:

    在这里插入图片描述

    在这里插入图片描述

    集群环境配置

    在这里插入图片描述

    1.初始化

    新建springcloud-eureka-7002、springcloud-eureka-7003 模块

    1.为pom.xml添加依赖 (与springcloud-eureka-7001相同)

    <!--导包~-->
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server -->
        <!--导入Eureka Server依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>
        <!--热部署工具-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>
    

    2.application.yml配置(与springcloud-eureka-7001相同)

    server:
      port: 7003
    
    # Eureka配置
    eureka:
      instance:
        hostname: localhost # Eureka服务端的实例名字
      client:
        register-with-eureka: false # 表示是否向 Eureka 注册中心注册自己(这个模块本身是服务器,所以不需要)
        fetch-registry: false # fetch-registry如果为false,则表示自己为注册中心
        service-url: # 监控页面~
          # 重写Eureka的默认端口以及访问路径 --->http://localhost:7001/eureka/
          defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
    

    3.主启动类(与springcloud-eureka-7001相同)

    /**
     * @Auther: csp1999
     * @Date: 2020/05/18/10:26
     * @Description: 启动之后,访问 http://127.0.0.1:7003/
     */
    @SpringBootApplication
    // @EnableEurekaServer 服务端的启动类,可以接受别人注册进来~
    public class EurekaServer_7003 {
        public static void main(String[] args) {
            SpringApplication.run(EurekaServer_7003.class,args);
        }
    }
    
    

    2.集群成员相互关联

    配置一些自定义本机名字,找到本机hosts文件并打开

    在这里插入图片描述

    在hosts文件最后加上,要访问的本机名称,默认是localhost

    在这里插入图片描述

    修改application.yml的配置,如图为springcloud-eureka-7001配置,springcloud-eureka-7002/springcloud-eureka-7003同样分别修改为其对应的名称即可

    在这里插入图片描述

    在集群中使springcloud-eureka-7001关联springcloud-eureka-7002、springcloud-eureka-7003

    完整的springcloud-eureka-7001下的application.yml如下

    server:
      port: 7001
    
    #Eureka配置
    eureka:
      instance:
        hostname: eureka7001.com #Eureka服务端的实例名字
      client:
        register-with-eureka: false #表示是否向 Eureka 注册中心注册自己(这个模块本身是服务器,所以不需要)
        fetch-registry: false #fetch-registry如果为false,则表示自己为注册中心
        service-url: #监控页面~
          #重写Eureka的默认端口以及访问路径 --->http://localhost:7001/eureka/
          # 单机: defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
          # 集群(关联):7001关联7002、7003
          defaultZone: http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
    
    

    同时在集群中使springcloud-eureka-7002关联springcloud-eureka-7001、springcloud-eureka-7003

    完整的springcloud-eureka-7002下的application.yml如下

    server:
      port: 7002
    
    #Eureka配置
    eureka:
      instance:
        hostname: eureka7002.com #Eureka服务端的实例名字
      client:
        register-with-eureka: false #表示是否向 Eureka 注册中心注册自己(这个模块本身是服务器,所以不需要)
        fetch-registry: false #fetch-registry如果为false,则表示自己为注册中心
        service-url: #监控页面~
          #重写Eureka的默认端口以及访问路径 --->http://localhost:7001/eureka/
          # 单机: defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
          # 集群(关联):7002关联7001、7003
          defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7003.com:7003/eureka/
    

    springcloud-eureka-7003配置方式同理可得.

    通过springcloud-provider-dept-8001下的yml配置文件,修改Eureka配置:配置服务注册中心地址

    # Eureka配置:配置服务注册中心地址
    eureka:
      client:
        service-url:
          # 注册中心地址7001-7003
          defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
      instance:
        instance-id: springcloud-provider-dept-8001 #修改Eureka上的默认描述信息
    

    这样模拟集群就搭建号了,就可以把一个项目挂载到三个服务器上了

    在这里插入图片描述

    对比和Zookeeper

    1. 回顾CAP原则

    RDBMS (MySQL\Oracle\sqlServer) ===> ACID

    NoSQL (Redis\MongoDB) ===> CAP

    ACID

    • A (Atomicity) 原子性
    • C (Consistency) 一致性
    • I (Isolation) 隔离性
    • D (Durability) 持久性

    CAP

    • C (Consistency) 强一致性
    • A (Availability) 可用性
    • P (Partition tolerance) 分区容错性

    CAP的三进二:CA、AP、CP

    CAP理论的核心

    • 一个分布式系统不可能同时很好的满足一致性,可用性和分区容错性这三个需求
    • 根据CAP原理,将NoSQL数据库分成了满足CA原则,满足CP原则和满足AP原则三大类
      • CA:单点集群,满足一致性,可用性的系统,通常可扩展性较差
      • CP:满足一致性,分区容错的系统,通常性能不是特别高
      • AP:满足可用性,分区容错的系统,通常可能对一致性要求低一些

    Eureka VS Zookeeper

    著名的CAP理论指出,一个分布式系统不可能同时满足C (一致性) 、A (可用性) 、P (容错性),由于分区容错性P再分布式系统中是必须要保证的,因此我们只能再A和C之间进行权衡。

    • Zookeeper 保证的是 CP —> 满足一致性,分区容错的系统,通常性能不是特别高
    • Eureka 保证的是 AP —> 满足可用性,分区容错的系统,通常可能对一致性要求低一些

    Zookeeper保证的是CP

    当向注册中心查询服务列表时,我们可以容忍注册中心返回的是几分钟以前的注册信息,但不能接收服务直接down掉不可用。也就是说,服务注册功能对可用性的要求要高于一致性。但zookeeper会出现这样一种情况,当master节点因为网络故障与其他节点失去联系时,剩余节点会重新进行leader选举。问题在于,选举leader的时间太长,30-120s,且选举期间整个zookeeper集群是不可用的,这就导致在选举期间注册服务瘫痪。在云部署的环境下,因为网络问题使得zookeeper集群失去master节点是较大概率发生的事件,虽然服务最终能够恢复,但是,漫长的选举时间导致注册长期不可用,是不可容忍的。

    Eureka保证的是AP

    Eureka看明白了这一点,因此在设计时就优先保证可用性。Eureka各个节点都是平等的,几个节点挂掉不会影响正常节点的工作,剩余的节点依然可以提供注册和查询服务。而Eureka的客户端在向某个Eureka注册时,如果发现连接失败,则会自动切换至其他节点,只要有一台Eureka还在,就能保住注册服务的可用性,只不过查到的信息可能不是最新的,除此之外,Eureka还有之中自我保护机制,如果在15分钟内超过85%的节点都没有正常的心跳,那么Eureka就认为客户端与注册中心出现了网络故障,此时会出现以下几种情况:

    • Eureka不在从注册列表中移除因为长时间没收到心跳而应该过期的服务
    • Eureka仍然能够接受新服务的注册和查询请求,但是不会被同步到其他节点上 (即保证当前节点依然可用)
    • 当网络稳定时,当前实例新的注册信息会被同步到其他节点中

    因此,Eureka可以很好的应对因网络故障导致部分节点失去联系的情况,而不会像zookeeper那样使整个注册服务瘫痪

    展开全文
  • SpringBoot使用Nacos作为配置中心服务和服务注册中心

    万次阅读 多人点赞 2019-03-07 18:15:41
    想象一下如果你有一百台服务的需要修改,那是不可想象的工作量。 目前已有的配置中心 携程开源的Apollo:数据保存在mysql中,支持命名空间和分发更新配置 springcloud 中的springcloud config:必须使用git保存配置...
  • 1.有了解过dubbo的都知道dubbo分为...查阅相关资料之后可以发现dubbo提供的服务注册方式不仅仅xml配置,还有API配置,注解配置,属性配置,其实,细心的你可以发现,xml配置最终也是转化为java代码实现,只是dubbo帮...
  • 如何理解服务注册和服务发现

    千次阅读 2019-05-06 11:49:28
    服务注册、服务注册表、服务发现 三者的关系是:通过服务注册机制将启动服务的信息上传至服务注册表,服务发现机制通过服务注册表实时获取可用服务的信息。 服务注册的方式包括:自注册和第三方注册。自注册的意思...
  • 服务注册中心

    千次阅读 2018-07-25 21:34:48
    一、服务注册中心介绍 分布式服务框架部署在多台不同的机器上,例如服务提供者在集群A,服务调用者在集群B,那么B在调用A的服务的过程中,集群A的机器需要和集群B的机器进行通信。 抠张图看看  在上图中,有...
  • Nacos服务注册与服务发现

    万次阅读 2019-04-08 15:50:30
    一、服务注册流程分析 (基于Nacos-0.9.0版本分析) Step1:NacosServiceRegistry.register() NacosNamingService.registerInstance() 1. 创建心跳信息 2. 调用注册方法 NamingProxy.registerService(String ...
  • SpringCloud-Alibaba-Nacos服务注册和配置中心--一篇入门

    万次阅读 多人点赞 2020-11-19 23:09:11
    一个更易于构建云原生应用的动态服务发现,配置管理和服务管理中心 Nacos 有自己独立的,注册和配置 服务端。不像Eureka我还得去起服务端才能注册。 Nacos = Eureka+Config+Bus 下载地址:...
  • springcloud服务注册与发现eureka 接下来,我们一块进入springcloud系列的学习中,关于springcloud微服务的理论知识这里不在描述。 同时欢迎加入qq交流群:springcloud&boot2有问必答,群聊号码:779283684 ...
  • Consul服务注册与服务发现机制

    千次阅读 2019-06-25 15:43:02
    1、什么是服务注册中心? 顾名思义,假设你有一个分布式系统,里面包含了多个服务,部署在不同的机器上,然后这些不同机器上的服务之间要互相调用。 举个现实点的例子吧,比如电商系统里的订单服务需要调用库存...
  • 1.创建子工程并导入依赖 <?xml version="1.0" encoding="UTF-8"?> ...启动,服务端注册成功
  • 文章 史上最简单的 SpringCloud 教程 | 第一篇: 服务的注册与发现(Eureka) 介绍了服务注册与发现,其中服务注册中心Eureka Server,是一个实例,当成千上万个服务向它注册的时候,它的负载是非常高的,这...
  • Eureka 服务注册与发现

    千次阅读 2019-02-12 19:46:39
    Eureka 服务注册与发现
  • EurekaServer服务注册中心建立及微服务注册进Eureka服务   目录 一、Eureka简介 二、EurekaServer的建立 三、将微服务注册到Eureka服务中心 一、Eureka简介 Eureka是Netflix开发的服务发现框架,本身是一个...
  • nacos服务中心搭建与服务注册

    千次阅读 2019-06-26 08:24:06
    之前作为服务注册中心的Eureka已经不再开源,阿里的nacos,越来越多的被使用。下面说一下已nacos作为注册中心,实现服务的注册。 下载与安装 下载地址为https://github.com/alibaba/nacos/releases,完成下载后,...
  • 1、安装、配置consul ...3、创建服务注册,服务提供者 yml配置 开启注册中心 提供controller类对外提供方法: https://blog.csdn.net/qq_41770939/article/details/85498655 ...
  • nacos服务注册流程

    千次阅读 2020-04-26 10:13:07
    nacos的客户端已经搭建好了,那么客户端是怎么将服务注册到注册中心去的呢。 1、 如果对springboot自动配置原理有一定了解的话,那么第三方框架一般都会通过spi的方式来初始化自己包中的bean。比如mybatis与spring...
  • 利用etcd实现服务注册和服务发现

    千次阅读 2019-03-31 16:45:37
    文章目录服务注册服务发现协议编写服务端实现客户端实现实验结果参考文章 服务注册 主要逻辑在go func函数里面,先是去etcd获取一下服务,没有获取到的话就注册进去。 package etcdservice import ( "context" ...
  • SpringCloud服务发现与服务注册

    万次阅读 2018-01-17 07:21:05
    服务发现与服务注册更多干货spring cloud 微服务spring cloud 知识点服务发现与服务注册定制Rabbon客户端负载均衡策略Spring Cloud Feign使用1SpringCloud Feign使用二SpringCloud Hystrix 实现SpringCloud超时机制...
  • 使用Spring Cloud搭建服务注册中心

    万次阅读 多人点赞 2017-09-03 12:08:25
    ,但是小伙伴们应该也看到了,阿里的dubbo无法单独完成工作,我们还要借助于Apache上的开源框架zookeeper(不是必须,但是最佳实践莫过于zookeeper),使用zookeeper作为服务注册中心,才能实现一个较好的分布式应用...
  • NodeJs服务注册与服务发现实现

    千次阅读 2019-01-09 12:38:04
    前言 由于作者才刚开始学习NodeJs,水平实在有限,本文更像是一篇学习笔记,适合同刚开始学习...服务注册与服务发现就是这其中一种机制,大概的流程为: 其中: 注册中心:zookeeper 服务提供者:NodeJs应用服...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 111,090
精华内容 44,436
关键字:

服务注册