nacos注册流程

最新推荐文章于 2024-07-06 20:11:18 发布
最新推荐文章于 2024-07-06 20:11:18 发布
阅读量161 收藏
点赞数
分类专栏： # nacos源码 文章标签： spring spring cloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014535922/article/details/131056502
版权

目录

注册时序图

在这里插入图片描述

源码跟踪

@EnableDiscoveryClient 注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(EnableDiscoveryClientImportSelector.class)
public @interface EnableDiscoveryClient {

	/**
	 * If true, the ServiceRegistry will automatically register the local server.
	 */
	boolean autoRegister() default true;
}
  • EnableDiscoveryClient 引用了 EnableDiscoveryClientImportSelector类
/**
 * @author Spencer Gibb
 */
@Order(Ordered.LOWEST_PRECEDENCE - 100)
public class EnableDiscoveryClientImportSelector
		extends SpringFactoryImportSelector<EnableDiscoveryClient> {

	@Override
	public String[] selectImports(AnnotationMetadata metadata) {
		String[] imports = super.selectImports(metadata);

		AnnotationAttributes attributes = AnnotationAttributes.fromMap(
				metadata.getAnnotationAttributes(getAnnotationClass().getName(), true));

		boolean autoRegister = attributes.getBoolean("autoRegister");

		if (autoRegister) {
			List<String> importsList = new ArrayList<>(Arrays.asList(imports));
			importsList.add("org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationConfiguration");
			imports = importsList.toArray(new String[0]);
		} else {
			Environment env = getEnvironment();
			if(ConfigurableEnvironment.class.isInstance(env)) {
				ConfigurableEnvironment configEnv = (ConfigurableEnvironment)env;
				LinkedHashMap<String, Object> map = new LinkedHashMap<>();
				map.put("spring.cloud.service-registry.auto-registration.enabled", false);
				MapPropertySource propertySource = new MapPropertySource(
						"springCloudDiscoveryClient", map);
				configEnv.getPropertySources().addLast(propertySource);
			}

		}

		return imports;
	}

	@Override
	protected boolean isEnabled() {
		return getEnvironment().getProperty(
				"spring.cloud.discovery.enabled", Boolean.class, Boolean.TRUE);
	}

	@Override
	protected boolean hasDefaultFactory() {
		return true;
	}

}
  • 开启自动服务注册后会加载spring-cloud-alibaba-nacos-discovery2.1.0.RELEASE-sources.jar!\META-INF\spring.factories文件中的DiscoveryAutoConfiguration配置类,开启nacos服务自动注册
    在这里插入图片描述

nacos服务注册

  • NacosDiscoveryAutoConfiguration
/**
 * @author xiaojing
 * @author <a href="mailto:mercyblitz@gmail.com">Mercy</a>
 */
@Configuration
@EnableConfigurationProperties
@ConditionalOnNacosDiscoveryEnabled
@ConditionalOnProperty(value = "spring.cloud.service-registry.auto-registration.enabled", matchIfMissing = true)
@AutoConfigureAfter({ AutoServiceRegistrationConfiguration.class,
		AutoServiceRegistrationAutoConfiguration.class })
public class NacosDiscoveryAutoConfiguration {
     //声明向注册中⼼注册服务的bean
	@Bean
	public NacosServiceRegistry nacosServiceRegistry(
			NacosDiscoveryProperties nacosDiscoveryProperties) {
		return new NacosServiceRegistry(nacosDiscoveryProperties);
	}
    //声明存储nacos服务信息的bean
	@Bean
	@ConditionalOnBean(AutoServiceRegistrationProperties.class)
	public NacosRegistration nacosRegistration(
			NacosDiscoveryProperties nacosDiscoveryProperties,
			ApplicationContext context) {
		return new NacosRegistration(nacosDiscoveryProperties, context);
	}
    // 声明⽤于nacos服务⾃动注册的bean
	@Bean
	@ConditionalOnBean(AutoServiceRegistrationProperties.class)
	public NacosAutoServiceRegistration nacosAutoServiceRegistration(
			NacosServiceRegistry registry,
			AutoServiceRegistrationProperties autoServiceRegistrationProperties,
			NacosRegistration registration) {
		return new NacosAutoServiceRegistration(registry,
				autoServiceRegistrationProperties, registration);
	}
}
  • NacosAutoServiceRegistration继承AbstractAutoServiceRegistration,AbstractAutoServiceRegistration实现ApplicationListener监听,所以会执行onApplicationEvent方法
public abstract class AbstractAutoServiceRegistration<R extends Registration>
		implements AutoServiceRegistration, ApplicationContextAware, ApplicationListener<WebServerInitializedEvent> {
	*******************************************

	@Override
	@SuppressWarnings("deprecation")
	public void onApplicationEvent(WebServerInitializedEvent event) {
		bind(event);
	}

	@Deprecated
	public void bind(WebServerInitializedEvent event) {
		ApplicationContext context = event.getApplicationContext();
		if (context instanceof ConfigurableWebServerApplicationContext) {
			if ("management".equals(
					((ConfigurableWebServerApplicationContext) context).getServerNamespace())) {
				return;
			}
		}
		this.port.compareAndSet(0, event.getWebServer().getPort());
		this.start();
	}

	@Override
	public void setApplicationContext(ApplicationContext applicationContext)
			throws BeansException {
		this.context = applicationContext;
		this.environment = this.context.getEnvironment();
	}

	@Deprecated
	protected Environment getEnvironment() {
		return environment;
	}

	@Deprecated
	protected AtomicInteger getPort() {
		return port;
	}

	public boolean isAutoStartup() {
		return this.autoStartup;
	}

	public void start() {
		if (!isEnabled()) {
			if (logger.isDebugEnabled()) {
				logger.debug("Discovery Lifecycle disabled. Not starting");
			}
			return;
		}

		// only initialize if nonSecurePort is greater than 0 and it isn't already running
		// because of containerPortInitializer below
		if (!this.running.get()) {
			this.context.publishEvent(new InstancePreRegisteredEvent(this, getRegistration()));
			register();
			if (shouldRegisterManagement()) {
				registerManagement();
			}
			this.context.publishEvent(
					new InstanceRegisteredEvent<>(this, getConfiguration()));
			this.running.compareAndSet(false, true);
		}

	}
*******************************************
  • NacosNamingService的registerInstance方法
@Override
    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 == 0 ? DEFAULT_HEART_BEAT_INTERVAL : instanceInterval);
             //添加⼼跳上报线程
            beatReactor.addBeatInfo(NamingUtils.getGroupedName(serviceName, groupName), beatInfo);
        }
        //注册服务
        serverProxy.registerService(NamingUtils.getGroupedName(serviceName, groupName), groupName, instance);
    }

addBeatInfo方法

    public void addBeatInfo(String serviceName, BeatInfo beatInfo) {
        NAMING_LOGGER.info("[BEAT] adding beat: {} to beat map.", beatInfo);
        dom2Beat.put(buildKey(serviceName, beatInfo.getIp(), beatInfo.getPort()), beatInfo);
        executorService.schedule(new BeatTask(beatInfo), 0, TimeUnit.MILLISECONDS);
        MetricsMonitor.getDom2BeatSizeMonitor().set(dom2Beat.size());
    }

 class BeatTask implements Runnable {

        BeatInfo beatInfo;

        public BeatTask(BeatInfo beatInfo) {
            this.beatInfo = beatInfo;
        }

        @Override
        public void run() {
            if (beatInfo.isStopped()) {
                return;
            }
            long result = serverProxy.sendBeat(beatInfo);
            long nextTime = result > 0 ? result : beatInfo.getPeriod();
            executorService.schedule(new BeatTask(beatInfo), nextTime, TimeUnit.MILLISECONDS);
        }
    }

registerService方法

public void registerService(String serviceName, String groupName, Instance instance) throws NacosException {

        NAMING_LOGGER.info("[REGISTER-SERVICE] {} registering service {} with instance: {}",
            namespaceId, serviceName, instance);

        final Map<String, String> params = new HashMap<String, String>(9);
        params.put(CommonParams.NAMESPACE_ID, namespaceId);
        params.put(CommonParams.SERVICE_NAME, serviceName);
        params.put(CommonParams.GROUP_NAME, groupName);
        params.put(CommonParams.CLUSTER_NAME, 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()));
        //发送注册服务请求
        reqAPI(UtilAndComs.NACOS_URL_INSTANCE, params, HttpMethod.POST);

    }
  • InstanceController类
@RestController
@RequestMapping(UtilsAndCommons.NACOS_NAMING_CONTEXT + "/instance")
public class InstanceController {

 //******************************************************************************


    @CanDistro
    @PostMapping
    @Secured(parser = NamingResourceParser.class, action = ActionTypes.WRITE)
    public String register(HttpServletRequest request) throws Exception {

        String serviceName = WebUtils.required(request, CommonParams.SERVICE_NAME);
        String namespaceId = WebUtils.optional(request, CommonParams.NAMESPACE_ID, Constants.DEFAULT_NAMESPACE_ID);

        serviceManager.registerInstance(namespaceId, serviceName, parseInstance(request));
        return "ok";
    }




 

    
    @GetMapping("/list")
    @Secured(parser = NamingResourceParser.class, action = ActionTypes.READ)
    public JSONObject list(HttpServletRequest request) throws Exception {

        String namespaceId = WebUtils.optional(request, CommonParams.NAMESPACE_ID,
            Constants.DEFAULT_NAMESPACE_ID);

        String serviceName = WebUtils.required(request, CommonParams.SERVICE_NAME);
        String agent = WebUtils.getUserAgent(request);
        String clusters = WebUtils.optional(request, "clusters", StringUtils.EMPTY);
        String clientIP = WebUtils.optional(request, "clientIP", StringUtils.EMPTY);
        Integer udpPort = Integer.parseInt(WebUtils.optional(request, "udpPort", "0"));
        String env = WebUtils.optional(request, "env", StringUtils.EMPTY);
        boolean isCheck = Boolean.parseBoolean(WebUtils.optional(request, "isCheck", "false"));

        String app = WebUtils.optional(request, "app", StringUtils.EMPTY);

        String tenant = WebUtils.optional(request, "tid", StringUtils.EMPTY);

        boolean healthyOnly = Boolean.parseBoolean(WebUtils.optional(request, "healthyOnly", "false"));

        return doSrvIPXT(namespaceId, serviceName, agent, clusters, clientIP, udpPort, env, isCheck, app, tenant,
            healthyOnly);
    }

    

    @CanDistro
    @PutMapping("/beat")
    @Secured(parser = NamingResourceParser.class, action = ActionTypes.WRITE)
    public JSONObject beat(HttpServletRequest request) throws Exception {

        JSONObject result = new JSONObject();

        result.put("clientBeatInterval", switchDomain.getClientBeatInterval());
        String serviceName = WebUtils.required(request, CommonParams.SERVICE_NAME);
        String namespaceId = WebUtils.optional(request, CommonParams.NAMESPACE_ID,
            Constants.DEFAULT_NAMESPACE_ID);
        String clusterName = WebUtils.optional(request, CommonParams.CLUSTER_NAME,
            UtilsAndCommons.DEFAULT_CLUSTER_NAME);
        String ip = WebUtils.optional(request, "ip", StringUtils.EMPTY);
        int port = Integer.parseInt(WebUtils.optional(request, "port", "0"));
        String beat = WebUtils.optional(request, "beat", StringUtils.EMPTY);

        RsInfo clientBeat = null;
        if (StringUtils.isNotBlank(beat)) {
            clientBeat = JSON.parseObject(beat, RsInfo.class);
        }

        if (clientBeat != null) {
            if (StringUtils.isNotBlank(clientBeat.getCluster())) {
                clusterName = clientBeat.getCluster();
            }
            ip = clientBeat.getIp();
            port = clientBeat.getPort();
        }

        if (Loggers.SRV_LOG.isDebugEnabled()) {
            Loggers.SRV_LOG.debug("[CLIENT-BEAT] full arguments: beat: {}, serviceName: {}", clientBeat, serviceName);
        }

        Instance instance = serviceManager.getInstance(namespaceId, serviceName, clusterName, ip, port);

        if (instance == null) {
            if (clientBeat == null) {
                result.put(CommonParams.CODE, NamingResponseCode.RESOURCE_NOT_FOUND);
                return result;
            }
            instance = new Instance();
            instance.setPort(clientBeat.getPort());
            instance.setIp(clientBeat.getIp());
            instance.setWeight(clientBeat.getWeight());
            instance.setMetadata(clientBeat.getMetadata());
            instance.setClusterName(clusterName);
            instance.setServiceName(serviceName);
            instance.setInstanceId(instance.getInstanceId());
            instance.setEphemeral(clientBeat.isEphemeral());

            serviceManager.registerInstance(namespaceId, serviceName, instance);
        }

        Service service = serviceManager.getService(namespaceId, serviceName);

        if (service == null) {
            throw new NacosException(NacosException.SERVER_ERROR,
                "service not found: " + serviceName + "@" + namespaceId);
        }
        if (clientBeat == null) {
            clientBeat = new RsInfo();
            clientBeat.setIp(ip);
            clientBeat.setPort(port);
            clientBeat.setCluster(clusterName);
        }
        service.processClientBeat(clientBeat);

        result.put(CommonParams.CODE, NamingResponseCode.OK);
        result.put("clientBeatInterval", instance.getInstanceHeartBeatInterval());
        result.put(SwitchEntry.LIGHT_BEAT_ENABLED, switchDomain.isLightBeatEnabled());
        return result;
    }
  • ClientBeatCheckTask类客户端心跳检查线程
   @Override
    public void run() {
        try {
            if (!getDistroMapper().responsible(service.getName())) {
                return;
            }

            if (!getSwitchDomain().isHealthCheckEnabled()) {
                return;
            }
            //1. 获取实例
            List<Instance> instances = service.allIPs(true);

            // first set health status of instances:
            //2.检查客户端实例最后使⽤时间是否超时
            for (Instance instance : instances) {
                if (System.currentTimeMillis() - instance.getLastBeat() > instance.getInstanceHeartBeatTimeOut()) {
                    if (!instance.isMarked()) {
                        if (instance.isHealthy()) {
                        //3.如果超时15秒设置健康状态为false
                            instance.setHealthy(false);
                            Loggers.EVT_LOG.info("{POS} {IP-DISABLED} valid: {}:{}@{}@{}, region: {}, msg: client timeout after {}, last beat: {}",
                                instance.getIp(), instance.getPort(), instance.getClusterName(), service.getName(),
                                UtilsAndCommons.LOCALHOST_SITE, instance.getInstanceHeartBeatTimeOut(), instance.getLastBeat());
                            getPushService().serviceChanged(service);
                            SpringContext.getAppContext().publishEvent(new InstanceHeartbeatTimeoutEvent(this, instance));
                        }
                    }
                }
            }

            if (!getGlobalConfig().isExpireInstance()) {
                return;
            }

            // then remove obsolete instances:
            for (Instance instance : instances) {

                if (instance.isMarked()) {
                    continue;
                }
// 4. 检查是否超过30秒
                if (System.currentTimeMillis() - instance.getLastBeat() > instance.getIpDeleteTimeout()) {
                    // delete instance
                    // 5. 如果超过30秒则删除实例
                    Loggers.SRV_LOG.info("[AUTO-DELETE-IP] service: {}, ip: {}", service.getName(), JSON.toJSONString(instance));
                    deleteIP(instance);
                }
            }

        } catch (Exception e) {
            Loggers.SRV_LOG.warn("Exception while processing client beat time out.", e);
        }

    }
  • ClientBeatProcessor客户端心跳处理类
@Override
    public void run() {
        Service service = this.service;
        if (Loggers.EVT_LOG.isDebugEnabled()) {
            Loggers.EVT_LOG.debug("[CLIENT-BEAT] processing beat: {}", rsInfo.toString());
        }

        String ip = rsInfo.getIp();
        String clusterName = rsInfo.getCluster();
        int port = rsInfo.getPort();
        Cluster cluster = service.getClusterMap().get(clusterName);
        //1.获取所有实例
        List<Instance> instances = cluster.allIPs(true);

        for (Instance instance : instances) {
            if (instance.getIp().equals(ip) && instance.getPort() == port) {
                if (Loggers.EVT_LOG.isDebugEnabled()) {
                    Loggers.EVT_LOG.debug("[CLIENT-BEAT] refresh beat: {}", rsInfo.toString());
                }
                //2. 设置实例的最后使⽤时间
                instance.setLastBeat(System.currentTimeMillis());
                if (!instance.isMarked()) {
                    if (!instance.isHealthy()) {
                        instance.setHealthy(true);
                        Loggers.EVT_LOG.info("service: {} {POS} {IP-ENABLED} valid: {}:{}@{}, region: {}, msg: client beat ok",
                            cluster.getService().getName(), ip, port, cluster.getName(), UtilsAndCommons.LOCALHOST_SITE);
                        getPushService().serviceChanged(service);
                    }
                }
            }
        }
    }

总结

  1. NacosDiscoveryAutoConfiguration 为注册流程入口类定义了3个bean
  • NacosServiceRegistry声明向注册中心注册服务的bean
  • NacosRegistration声明存储nacos服务信息的bean
  • NacosAutoServiceRegistration声明用于nacos服务自动注册的bean
  1. NacosAutoServiceRegistration继承AbstractAutoServiceRegistration,AbstractAutoServiceRegistration实现了ApplicationListener监听,所以会执onApplicationEvent方法
  • onApplicationEvent 调用bind方法–》调用this.start();
  1. onApplicationEvent 方法最终调用–>NacosServiceRegistry.register–>NacosNamingService.registerInstance进行服务注册
  • beatReactor.addBeatInfo(）开启延时线程上报心跳。reqApi（“nacos/v1/ns/instance/beat”）
  • serverProxy.registerService(）方法进行服务注册，reqApi（“nacos/v1/ns/instance”）
  1. beatReactor.addBeatInfo(）、serverProxy.registerService(）最终调用的是nacos 中InstanceController 的beat和register方法，分别进行心跳上报和服务注册。

  • beat方法

    • 进行客户端心跳检测和修改最后使用时间并设置健康状态true

  • register方法

    • 创建空服务
    • 创建并初始化空服务
    • 调用init方法进行心跳检测 15秒<0<30秒 修改实例健康状态为false ， > 30秒删除服务
刚仔灬
关注
专栏目录
服务启动何时触发 Nacos 的注册流程？
weixin_42118323的博客
07-11 1137
AbstractAutoServiceRegistration#start方法进行简单的判断后继续调用了 AbstractAutoServiceRegistration#start ，调用了 NacosAutoServiceRegistration#register 方法发起服务注册，至此终于出现了 Nacos。总结：服务注册到 Nacos 流程的核心是使用了 Spring 的事件监听机制，虽然 Spring 的监听机制在我们平时写代码中几乎用不到，但是在框架源码中还是大量使用了的。
nacos服务注册流程
cqlaopan的博客
04-26 8686
nacos客户端注册流程 nacos的客户端已经搭建好了，那么客户端是怎么将服务注册到注册中心去的呢。 1、 如果对springboot自动配置原理有一定了解的话，那么第三方框架一般都会通过spi的方式来初始化自己包中的bean。比如mybatis与spring结合都会在/META-INFO/spring.factories下进行自动装配 2、 那么nacos是不是一样的也是基于这种方式来处理的...
Nacos服务注册流程（一）
weixin_39575794的博客
03-14 4175
Nacos客户端注册与服务端发现流程 目录 一、准备事项 1.1 Nacos源码下载 1.2 启动Nacos服务端项目 1.3 启动Nacos客户端项目 二、Nacos客户端注册流程 2.1 注册方法的调用 2.2时序图 2.3注册代码 2.4数据结构 三、Nacos服务端服务注册流程 3.1 注册流程 1. 时序图 2. 具体代码 3.2数据结构 四、总结 一、准备事项 1.1 Nacos源码下载 Nacos官网 Nacos项目地址 将项目clone...
Nacos服务注册简要流程
小桶的博客
08-25 2105
以下内容基于Nacos 2.1.0-SNAPSHOT 1. 服务实例注册示例 当nacos服务已经启动后，可以使用以下示例代码向nacos注册服务实例 @Test public void testRegisterInstance() throw Exception { // nacos地址，用户和密码 Properties properties = new Properties(); properties.put(PropertyKeyConst.SERVER_ADDR, "...
Nacos服务注册总流程(源码分析)
最新发布
qq_44027353的博客
07-06 1175
添加实例的方法中了，这个方法中主要做的事就是将当前service的所有实例通过一个key存入一个Map中，然后保存在一个dataStore这个Map中，同时再把这个key和相关的操作类型存入一个阻塞队列中，至此NacosClient发送的请求就处理完成了。其实我们就可以双击shift键，直接搜索controller，一个一个文件夹找，或者是直接加上关键字，就比如我这里加上了instance这个关键字就找到了真正处理这个请求的controller，类名为。我们启动一个微服务，引入nacos客户端的依赖。
Nacos注册为为windows服务压缩包
12-28
这个“Nacos注册为为windows服务压缩包”就是用于帮助我们完成这一操作的工具。 压缩包中的"WinSW-x64.exe"是一个Windows Service Wrapper的可执行文件，它是用于将任意的命令行程序包装成Windows服务的工具。WinSW...
Nacos源码流程——服务注册与发现.png
04-02
Nacos服务注册与发现源码流程图， 通过流程图展示了服务注册到Nacos服务注册中心的整个源码过程，同时对Nacos代码中一些优秀的思想进行总结
nacos注册发现流程.pdf
03-08
服务注册流程则是服务发现的逆过程，包括以下关键步骤： 1. **实例注册**：当服务启动时，`NacosNamingService`会将服务实例的信息注册到Nacos Server中。这一步通常由Spring Cloud的自动配置完成。 2. **实例更新...
Nacos 注册流程分析（一）
pangxiaoliang14的博客
11-12 515
nacos注册流程分析
二、Nacos源码系列：Nacos服务注册流程(一)
weixiaohuai的博客
01-17 2374
本篇文章中，我们从Nacos客户端自动注册在何时触发开始，然后分析了客户端向Nacos服务端提交服务注册请求，最后到Nacos服务端处理这个注册请求，整个流程大概梳理了一下，下一篇文章，我们将会详细分析NotifyCenter这个事件-发布机制的原理，然后继续分析服务端处理注册请求过程中涉及到的后续流程处理。
Nacos 注册流程分析（二）
pangxiaoliang14的博客
11-19 799
nacos服务端注册流程分析
Nacos服务注册流程
weixin_44610169的博客
10-12 514
二、在要注册的服务的配置文件中，添加注册Nacos服务的配置信息。-- 服务注册 -->一、pom文件中引入对应依赖。三、在启动类中添加注解。
【微服务】Nacos客户端微服务注册原理流程
qq_57756904的博客
11-04 2432
Nacos 是构建以“服务”为中心的现代应用架构 (例如微服务范式、云原生范式) 的服务基础设施。其特性有：服务发现和服务健康监测、动态配置服务、动态 DNS 服务、服务及其元数据管理。
聊一聊nacos是如何进行服务注册的
weixin_45630885的博客
01-26 5841
nacos服务注册源码分析
Spring Cloud---nacos的注册过程
m0_71117042的博客
01-19 389
spring. cloud . nacos .discovery . server- addr=127.0.0. 1: 8848（此时的IP地址配置的是本地）1、添加Nacos服务需要的依赖（将依赖添加到需要注册的模块中的pom.xml文件中）总结错误：1、需要注意nacos与spring-boot的版本要一致；2、在application.yml文件中需要配置name；3、Nacos2.0版本以上新增了两个通信端口；2、配置需要注册的模块的配置文件。# nacos服务地址。3、在启动类中添加注解。
3、Nacos服务注册-客户端流程
jb84006的博客
06-01 2249
  如果您对Nacos工作流程和原理还不是很清楚的话，建议从前面的文章开始看：   1、nacos功能简介   2、Nacos服务注册-客户端自动注册流程    一、主流程   上篇讲到了com.alibaba.cloud.nacos.registry.NacosServiceRegistry#register方法，现在就以这个方法开始，看下这个方法代码： @Override public void register(Registration registration) { if (StringUt
nacos服务注册
qq_41860765的博客
02-20 1665
流程如下：1、微服务启动，将自己注册到Nacos，Nacos记录了各微服务实例的地址。2、网关从Nacos读取服务列表，包括服务名称、服务地址等。3、请求到达网关，网关将请求路由到具体的微服务。要使用网关首先搭建Nacos，Nacos有两个作用：1、服务发现中心。微服务将自身注册至Nacos，网关从Nacos获取微服务列表。2、配置中心。微服务众多，它们的配置信息也非常复杂，为了提供系统的可维护性，微服务的配置信息统一在Nacos配置。
nacos注册中心工作流程
09-03
下面是Nacos注册中心的工作流程： 1. 服务提供者向Nacos注册中心注册：服务提供者在启动时，会将自己的服务信息（包括IP地址、端口号、服务名称等）通过API调用或配置文件的方式注册到Nacos注册中心。 2. 服务消费...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

刚仔灬

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值