【源码解析】Nacos配置热更新的实现原理

最新推荐文章于 2025-07-28 20:51:49 发布
原创 最新推荐文章于 2025-07-28 20:51:49 发布 · 1.8k 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #redis #开发语言

文章详细阐述了在SpringBoot中使用@RefreshScope和@ConfigurationProperties如何实现配置的动态刷新。通过Nacos监听配置变化，触发RefreshEvent，进而刷新Bean的缓存，重新加载配置。同时介绍了AbstractSharedListener和RefreshEventListener的角色，以及EnvironmentChangeEvent和RefreshScopeRefreshedEvent事件在刷新过程中的作用。整个流程涉及到了Spring的Bean生命周期和Scope管理。

使用入门

  1. 使用@RefreshScope+@Value，实现动态刷新
@RestController
@RefreshScope
public class TestController {

    @Value("${cls.name}")
    private String clsName;

}
  1. 使用ConfigurationProperties，通过@Autowired注入使用
@Data
@ConfigurationProperties(prefix = "redis")
@Component
public class RedisProperties {

    private String userName;

    private String password;

    private String url;
}

源码解析

CacheData

CacheData#checkListenerMd5，当发现监听到的数据和本地配置不一致，会进行提醒。核心点在于会执行listener.receiveConfigInfo(contentTmp);。

    void checkListenerMd5() {
        for (ManagerListenerWrap wrap : listeners) {
            if (!md5.equals(wrap.lastCallMd5)) {
                safeNotifyListener(dataId, group, content, type, md5, encryptedDataKey, wrap);
            }
        }
    }

    private void safeNotifyListener(final String dataId, final String group, final String content, final String type,
            final String md5, final String encryptedDataKey, final ManagerListenerWrap listenerWrap) {
        final Listener listener = listenerWrap.listener;
        
        Runnable job = new Runnable() {
            @Override
            public void run() {
                ClassLoader myClassLoader = Thread.currentThread().getContextClassLoader();
                ClassLoader appClassLoader = listener.getClass().getClassLoader();
                try {
                    if (listener instanceof AbstractSharedListener) {
                        AbstractSharedListener adapter = (AbstractSharedListener) listener;
                        adapter.fillContext(dataId, group);
                        LOGGER.info("[{}] [notify-context] dataId={}, group={}, md5={}", name, dataId, group, md5);
                    }
                    // 执行回调之前先将线程classloader设置为具体webapp的classloader，以免回调方法中调用spi接口是出现异常或错用（多应用部署才会有该问题）。
                    Thread.currentThread().setContextClassLoader(appClassLoader);
                    
                    ConfigResponse cr = new ConfigResponse();
                    cr.setDataId(dataId);
                    cr.setGroup(group);
                    cr.setContent(content);
                    cr.setEncryptedDataKey(encryptedDataKey);
                    configFilterChainManager.doFilter(null, cr);
                    String contentTmp = cr.getContent();
                    listener.receiveConfigInfo(contentTmp);
                    
                    // compare lastContent and content
                    if (listener instanceof AbstractConfigChangeListener) {
                        Map data = ConfigChangeHandler.getInstance()
                                .parseChangeData(listenerWrap.lastContent, content, type);
                        ConfigChangeEvent event = new ConfigChangeEvent(data);
                        ((AbstractConfigChangeListener) listener).receiveConfigChange(event);
                        listenerWrap.lastContent = content;
                    }
                    
                    listenerWrap.lastCallMd5 = md5;
                    LOGGER.info("[{}] [notify-ok] dataId={}, group={}, md5={}, listener={} ", name, dataId, group, md5,
                            listener);
                } catch (NacosException ex) {
                    LOGGER.error("[{}] [notify-error] dataId={}, group={}, md5={}, listener={} errCode={} errMsg={}",
                            name, dataId, group, md5, listener, ex.getErrCode(), ex.getErrMsg());
                } catch (Throwable t) {
                    LOGGER.error("[{}] [notify-error] dataId={}, group={}, md5={}, listener={} tx={}", name, dataId,
                            group, md5, listener, t.getCause());
                } finally {
                    Thread.currentThread().setContextClassLoader(myClassLoader);
                }
            }
        };
        
        final long startNotify = System.currentTimeMillis();
        try {
            if (null != listener.getExecutor()) {
                listener.getExecutor().execute(job);
            } else {
                job.run();
            }
        } catch (Throwable t) {
            LOGGER.error("[{}] [notify-error] dataId={}, group={}, md5={}, listener={} throwable={}", name, dataId,
                    group, md5, listener, t.getCause());
        }
        final long finishNotify = System.currentTimeMillis();
        LOGGER.info("[{}] [notify-listener] time cost={}ms in ClientWorker, dataId={}, group={}, md5={}, listener={} ",
                name, (finishNotify - startNotify), dataId, group, md5, listener);
    }

NacosContextRefresher

NacosContextRefresher#onApplicationEvent，系统启动的时候，会注册监听器。该监听器重写了innerReceive方法。

	public void onApplicationEvent(ApplicationReadyEvent event) {
		// many Spring context
		if (this.ready.compareAndSet(false, true)) {
			this.registerNacosListenersForApplications();
		}
	}

	private void registerNacosListenersForApplications() {
		if (isRefreshEnabled()) {
			for (NacosPropertySource propertySource : NacosPropertySourceRepository
					.getAll()) {
				if (!propertySource.isRefreshable()) {
					continue;
				}
				String dataId = propertySource.getDataId();
				registerNacosListener(propertySource.getGroup(), dataId);
			}
		}
	}

	private void registerNacosListener(final String groupKey, final String dataKey) {
		String key = NacosPropertySourceRepository.getMapKey(dataKey, groupKey);
		Listener listener = listenerMap.computeIfAbsent(key,
				lst -> new AbstractSharedListener() {
					@Override
					public void innerReceive(String dataId, String group,
							String configInfo) {
						refreshCountIncrement();
						nacosRefreshHistory.addRefreshRecord(dataId, group, configInfo);
						// todo feature: support single refresh for listening
						applicationContext.publishEvent(
								new RefreshEvent(this, null, "Refresh Nacos config"));
						if (log.isDebugEnabled()) {
							log.debug(String.format(
									"Refresh Nacos config group=%s,dataId=%s,configInfo=%s",
									group, dataId, configInfo));
						}
					}
				});
		try {
			configService.addListener(dataKey, groupKey, listener);
		}
		catch (NacosException e) {
			log.warn(String.format(
					"register fail for nacos listener ,dataId=[%s],group=[%s]", dataKey,
					groupKey), e);
		}
	}

AbstractSharedListener执行receiveConfigInfo方法，会调用innerReceive方法。

public abstract class AbstractSharedListener implements Listener {
    private volatile String dataId;
    private volatile String group;

    public AbstractSharedListener() {
    }

    public final void fillContext(String dataId, String group) {
        this.dataId = dataId;
        this.group = group;
    }

    public final void receiveConfigInfo(String configInfo) {
        this.innerReceive(this.dataId, this.group, configInfo);
    }

    public Executor getExecutor() {
        return null;
    }

    public abstract void innerReceive(String var1, String var2, String var3);
}

RefreshEventListener

RefreshEventListener监听到RefreshEvent，会执行this.refresh.refresh();

    public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof ApplicationReadyEvent) {
            this.handle((ApplicationReadyEvent)event);
        } else if (event instanceof RefreshEvent) {
            this.handle((RefreshEvent)event);
        }

    }    

	public void handle(RefreshEvent event) {
        if (this.ready.get()) {
            log.debug("Event received " + event.getEventDesc());
            Set<String> keys = this.refresh.refresh();
            log.info("Refresh keys changed: " + keys);
        }

    }

ContextRefresher

ContextRefresher#refresh，会发布EnvironmentChangeEvent事件。ContextRefresher#addConfigFilesToEnvironment启动了一个spring applicaiton程序去加载了一次配置，将变化后的配置重新加载进来了，然后进行this.scope.refreshAll();

	public synchronized Set<String> refresh() {
		Set<String> keys = refreshEnvironment();
		this.scope.refreshAll();
		return keys;
	}

	public synchronized Set<String> refreshEnvironment() {
		Map<String, Object> before = extract(
				this.context.getEnvironment().getPropertySources());
		addConfigFilesToEnvironment();
		Set<String> keys = changes(before,
				extract(this.context.getEnvironment().getPropertySources())).keySet();
		this.context.publishEvent(new EnvironmentChangeEvent(this.context, keys));
		return keys;
	}

	ConfigurableApplicationContext addConfigFilesToEnvironment() {
		ConfigurableApplicationContext capture = null;
		try {
			StandardEnvironment environment = copyEnvironment(
					this.context.getEnvironment());
			SpringApplicationBuilder builder = new SpringApplicationBuilder(Empty.class)
					.bannerMode(Mode.OFF).web(WebApplicationType.NONE)
					.environment(environment);
			// Just the listeners that affect the environment (e.g. excluding logging
			// listener because it has side effects)
			builder.application()
					.setListeners(Arrays.asList(new BootstrapApplicationListener(),
							new ConfigFileApplicationListener()));
			capture = builder.run();
			if (environment.getPropertySources().contains(REFRESH_ARGS_PROPERTY_SOURCE)) {
				environment.getPropertySources().remove(REFRESH_ARGS_PROPERTY_SOURCE);
			}
			MutablePropertySources target = this.context.getEnvironment()
					.getPropertySources();
			String targetName = null;
			for (PropertySource<?> source : environment.getPropertySources()) {
				String name = source.getName();
				if (target.contains(name)) {
					targetName = name;
				}
				if (!this.standardSources.contains(name)) {
					if (target.contains(name)) {
						target.replace(name, source);
					}
					else {
						if (targetName != null) {
							target.addAfter(targetName, source);
							// update targetName to preserve ordering
							targetName = name;
						}
						else {
							// targetName was null so we are at the start of the list
							target.addFirst(source);
							targetName = name;
						}
					}
				}
			}
		}
		finally {
			ConfigurableApplicationContext closeable = capture;
			while (closeable != null) {
				try {
					closeable.close();
				}
				catch (Exception e) {
					// Ignore;
				}
				if (closeable.getParent() instanceof ConfigurableApplicationContext) {
					closeable = (ConfigurableApplicationContext) closeable.getParent();
				}
				else {
					break;
				}
			}
		}
		return capture;
	}

RefreshScope#refreshAll，会发布RefreshScopeRefreshedEvent事件。

	@ManagedOperation(description = "Dispose of the current instance of all beans "
			+ "in this scope and force a refresh on next method execution.")
	public void refreshAll() {
		super.destroy();
		this.context.publishEvent(new RefreshScopeRefreshedEvent());
	}

GenericScope#destroy()，清理GenericScope缓存。

    protected boolean destroy(String name) {
        GenericScope.BeanLifecycleWrapper wrapper = this.cache.remove(name);
        if (wrapper != null) {
            Lock lock = ((ReadWriteLock)this.locks.get(wrapper.getName())).writeLock();
            lock.lock();

            try {
                wrapper.destroy();
            } finally {
                lock.unlock();
            }

            this.errors.remove(name);
            return true;
        } else {
            return false;
        }
    }

获取Bean对象

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Scope("refresh")
@Documented
public @interface RefreshScope {

	/**
	 * @see Scope#proxyMode()
	 * @return proxy mode
	 */
	ScopedProxyMode proxyMode() default ScopedProxyMode.TARGET_CLASS;

}

AbstractBeanFactory#doGetBean，获取Bean。如果该类有@Refresh注解，获取对应的scope，执行scope.get来获取Bean对象。

	protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {

		String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
				//...
		}

		else {
			// ...

			try {
				// ...

				// Create bean instance.
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							// Explicitly remove instance from singleton cache: It might have been put there
							// eagerly by the creation process, to allow for circular reference resolution.
							// Also remove any beans that received a temporary reference to the bean.
							destroySingleton(beanName);
							throw ex;
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

				else if (mbd.isPrototype()) {
					// It's a prototype -> create a new instance.
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				else {
					String scopeName = mbd.getScope();
					if (!StringUtils.hasLength(scopeName)) {
						throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
					}
					Scope scope = this.scopes.get(scopeName);
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
					}
					try {
						Object scopedInstance = scope.get(beanName, () -> {
							beforePrototypeCreation(beanName);
							try {
								return createBean(beanName, mbd, args);
							}
							finally {
								afterPrototypeCreation(beanName);
							}
						});
						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
					}
					catch (IllegalStateException ex) {
						throw new BeanCreationException(beanName,
								"Scope '" + scopeName + "' is not active for the current thread; consider " +
								"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
								ex);
					}
				}
			}
			catch (BeansException ex) {
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
		}

		// Check if required type matches the type of the actual bean instance.
		if (requiredType != null && !requiredType.isInstance(bean)) {
			try {
				T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
				if (convertedBean == null) {
					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
				}
				return convertedBean;
			}
			catch (TypeMismatchException ex) {
				if (logger.isTraceEnabled()) {
					logger.trace("Failed to convert bean '" + name + "' to required type '" +
							ClassUtils.getQualifiedName(requiredType) + "'", ex);
				}
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
		}
		return (T) bean;
	}

GenericScope#get，获取缓存中的对象

    public Object get(String name, ObjectFactory<?> objectFactory) {
        GenericScope.BeanLifecycleWrapper value = this.cache.put(name, new GenericScope.BeanLifecycleWrapper(name, objectFactory));
        this.locks.putIfAbsent(name, new ReentrantReadWriteLock());

        try {
            return value.getBean();
        } catch (RuntimeException var5) {
            this.errors.put(name, var5);
            throw var5;
        }
    }

StandardScopeCache#put，如果旧值不存在，存放成功，返回当前value值；如果旧值存在，返回旧值。

    public Object put(String name, Object value) {
        Object result = this.cache.putIfAbsent(name, value);
        return result != null ? result : value;
    }

GenericScope.BeanLifecycleWrapper#getBean，调用objectFactory.getObject()。也就是创建Bean。

        public Object getBean() {
            if (this.bean == null) {
                synchronized(this.name) {
                    if (this.bean == null) {
                        this.bean = this.objectFactory.getObject();
                    }
                }
            }

            return this.bean;
        }

ConfigurationPropertiesRebinderAutoConfiguration

ConfigurationPropertiesRebinderAutoConfiguration注入了ConfigurationPropertiesBeans和ConfigurationPropertiesRebinder。

@Configuration(proxyBeanMethods = false)
@ConditionalOnBean(ConfigurationPropertiesBindingPostProcessor.class)
public class ConfigurationPropertiesRebinderAutoConfiguration
		implements ApplicationContextAware, SmartInitializingSingleton {

	private ApplicationContext context;

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

	@Bean
	@ConditionalOnMissingBean(search = SearchStrategy.CURRENT)
	public static ConfigurationPropertiesBeans configurationPropertiesBeans() {
		return new ConfigurationPropertiesBeans();
	}

	@Bean
	@ConditionalOnMissingBean(search = SearchStrategy.CURRENT)
	public ConfigurationPropertiesRebinder configurationPropertiesRebinder(
			ConfigurationPropertiesBeans beans) {
		ConfigurationPropertiesRebinder rebinder = new ConfigurationPropertiesRebinder(
				beans);
		return rebinder;
	}
}

ConfigurationPropertiesBeans实现了BeanPostProcessor，启动的时候会执行postProcessBeforeInitialization。寻找带有ConfigurationProperties注解的Bean对象，封装成ConfigurationPropertiesBean，存放到ConfigurationPropertiesBeans的beans属性中。

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName)
			throws BeansException {
		if (isRefreshScoped(beanName)) {
			return bean;
		}
		ConfigurationPropertiesBean propertiesBean = ConfigurationPropertiesBean
				.get(this.applicationContext, bean, beanName);
		if (propertiesBean != null) {
			this.beans.put(beanName, propertiesBean);
		}
		return bean;
	}

	public static ConfigurationPropertiesBean get(ApplicationContext applicationContext, Object bean, String beanName) {
		Method factoryMethod = findFactoryMethod(applicationContext, beanName);
		return create(beanName, bean, bean.getClass(), factoryMethod);
	}

	private static ConfigurationPropertiesBean create(String name, Object instance, Class<?> type, Method factory) {
		ConfigurationProperties annotation = findAnnotation(instance, type, factory, ConfigurationProperties.class);
		if (annotation == null) {
			return null;
		}
		Validated validated = findAnnotation(instance, type, factory, Validated.class);
		Annotation[] annotations = (validated != null) ? new Annotation[] { annotation, validated }
				: new Annotation[] { annotation };
		ResolvableType bindType = (factory != null) ? ResolvableType.forMethodReturnType(factory)
				: ResolvableType.forClass(type);
		Bindable<Object> bindTarget = Bindable.of(bindType).withAnnotations(annotations);
		if (instance != null) {
			bindTarget = bindTarget.withExistingValue(instance);
		}
		return new ConfigurationPropertiesBean(name, instance, annotation, bindTarget);
	}

ConfigurationPropertiesRebinder实现了ApplicationListener<EnvironmentChangeEvent>，当监听到EnvironmentChangeEvent，会销毁Bean对象，再重新生成Bean对象。

    public void onApplicationEvent(EnvironmentChangeEvent event) {
        if (this.applicationContext.equals(event.getSource()) || event.getKeys().equals(event.getSource())) {
            this.rebind();
        }

    }

	@ManagedOperation
	public void rebind() {
		this.errors.clear();
		for (String name : this.beans.getBeanNames()) {
			rebind(name);
		}
	}

	@ManagedOperation
	public boolean rebind(String name) {
		if (!this.beans.getBeanNames().contains(name)) {
			return false;
		}
		if (this.applicationContext != null) {
			try {
				Object bean = this.applicationContext.getBean(name);
				if (AopUtils.isAopProxy(bean)) {
					bean = ProxyUtils.getTargetObject(bean);
				}
				if (bean != null) {
					// TODO: determine a more general approach to fix this.
					// see https://github.com/spring-cloud/spring-cloud-commons/issues/571
					if (getNeverRefreshable().contains(bean.getClass().getName())) {
						return false; // ignore
					}
					this.applicationContext.getAutowireCapableBeanFactory()
							.destroyBean(bean);
					this.applicationContext.getAutowireCapableBeanFactory()
							.initializeBean(bean, name);
					return true;
				}
			}
			catch (RuntimeException e) {
				this.errors.put(name, e);
				throw e;
			}
			catch (Exception e) {
				this.errors.put(name, e);
				throw new IllegalStateException("Cannot rebind to " + name, e);
			}
		}
		return false;
	}

总结一下

  • 所有的RefreshScope注解修饰的bean都保存在GenericScope的缓存里，RefreshScope#refreshAll会将缓存全部清空，当spring获取这些Bean的时候，会重新生成保存到缓存中。
  • 有ConfigurationProperties注解的Bean在监听到EnvironmentChangeEvent，会进行销毁和重新初始化的操作。
  • 如果想要所有的@Value都可以热更新，可以看一下dynamic-config-starter这个项目的实现。

在这里插入图片描述

【Nacos无压力源码领读】(三) Nacos 配置中心与热更新原理详解超详细解读
wdx7770的博客
08-07 1571
本文将从 Nacos 配置中心的基本使用入手, 详细介绍 Nacos 客户端发布配置, 拉取配置, 订阅配置的过程以及服务器对应的处理过程;配置订阅以及热更新原理相关的部分, 我看了主流的博客网站, 绝对没有比这更详细的讲解;
十一、Nacos源码系列：Nacos配置中心原理（三）- 配置热更新
weixiaohuai的博客
02-20 1204
从源码可以看到，NacosConfigManager 中会进行一个 ConfigService 单例对象的创建，创建流程最终会委托给 ConfigFactory，使用反射方式创建一个 NacosConfigService 的实例对象，NacosConfigService 是一个很核心的类，配置的获取，监听器的注册都需要经此。上面章节我们讲了服务启动的时候从远程 Nacos 服务端拉到配置，以及服务启动后对需要支持热更新的配置都注册了一个监听器，这个章节我们来说下配置变动后具体是怎么处理的。
Nacos热更新原理
最新发布
LUCIAZZZ的博客
07-28 1002
Nacos配置中心采用CRUD机制管理配置信息，支持Derby和MySQL存储 核心功能包括： 1）配置注册与获取 2）长轮询监听机制实现动态刷新（30秒超时+变更触发） 3）版本号/MD5校验。服务注册中心需具备服务发现、注册/注销、持久化、热更新和监控能力
nacos 统一配置以及热更新
m0_61943036的博客
07-18 1334
Nacos除了可以做注册中心，同样可以做配置管理来使用。
SpringCloud 中nacos的配置热更新的原理
牛肉胡辣汤
08-23 2629
Spring Cloud 中的 Nacos 是一个动态服务发现、配置管理和服务管理平台。它支持配置的动态更新，即当配置发生变化时，可以自动通知应用程序并更新配置。以上示例代码演示了如何使用 Nacos 实现配置热更新。当 Nacos 中的配置发生变化时，​。​ 类会自动更新，并且可以在需要的地方获取最新的配置。在需要处理配置更新的地方调用 ​。然后，在需要使用配置的地方注入 ​。​ 类，并在需要处理配置更新的地方调用 ​。​ 方法，即可触发配置的更新逻辑。在应用程序的启动类上添加 ​。
nocas配置中心热更新原理_spring cloud下用nacos做配置中心的初步探究，替换spring config server...
weixin_39801714的博客
12-24 311
一， 背景：1， 引入nacos来做配置中心项目现在用的是spring cloudnetflix，没有用到spring-cloud-alibaba的全家桶，但又想用到nacos来做配置中心，故按官网提供的方式是不行的2， 探究下nacos配置中心的使用与实现目前用的spring config server其实弊端很多，比如： 强依赖gitLab， 加入BUS复杂度高不好确保所有节点的更新等缺点故...
【Nacos无压力源码领读】(三) Nacos 配置中心与热更新原理详解 敢说全网最细
cnzzs的博客
08-07 681
本文将从 Nacos 配置中心的基本使用入手, 详细介绍 Nacos 客户端发布配置, 拉取配置, 订阅配置的过程以及服务器对应的处理过程;配置订阅以及热更新原理相关的部分, 我看了主流的博客网站, 绝对没有比这更详细的讲解;如果在阅读过程中对文中提到的 SpringBoot 启动过程以及扩展机制不太了解, 或者出现了没见...
【Spring Cloud】【Nacos】从源码层面理解Nacos 实现属性动态更新的原理
zhangshenglu1的博客
12-03 1910
在locate方法里面定义如何获取外部配置，并返回PropertySource/***/@Override。
九、Nacos源码系列：Nacos配置中心原理（一）- SpringCloud应用启动时拉取配置
weixiaohuai的博客
02-19 2256
至此，在项目启动的时候（上下文准备阶段）通过NacosPropertySourceLocator就拉取到了远程 Nacos 中的配置信息，并且封装成 NacosPropertySource对象，然后PropertySourceBootstrapConfiguration依靠ApplicationContextInitializer机制（容器刷新之前支持一些自定义初始化工作），将前面封装好的NacosPropertySource对象放到了 Spring 的环境变量Environment 中。
Nacos配置服务的源码解析（全）
m0_67402914的博客
08-02 738
注册到。
Nacos配置中心集群原理及源码分析
JavaMonsterr的博客
05-29 471
Nacos作为配置中心，必然需要保证服务节点的高可用性，那么Nacos是如何实现集群的呢？ 下面这个图，表示Nacos集群的部署图。 Nacos集群工作原理 Nacos作为配置中心的集群结构中，是一种无中心化节点的设计，由于没有主从节点，也没有选举机制，所以为了能够实现热备，就需要增加虚拟IP（VIP）。 Nacos的数据存储分为两部分 /data/program/nacos-1/data/config-data/${GROUP} 在Nacos的设计中，Mysql是一个中心数据仓库，
Nacos配置管理和配置热更新
viperd的博客
03-01 2080
Nacos的配置管理以及热更新
Nacos配置热更新
PaoShan的博客
02-06 363
基于标题
Spring - Nacos 配置实时更新原理分析
迦南的专栏
02-03 1216
上篇文章，我和大家分析了 Nacos 的配置中心原理，主要分析了 Nacos 客户端是如何感知到服务端的配置变更的，但是只是从客户端的角度进行了分析，并没有从服务端的角度进行分析，本篇文章我将结合服务端从两个角度来分析配置变更是如何通知到客户端的。 PS：文章有点长，因为涉及到多个细节需要阐述，如果看不下去的话，可以直接转到文末看结论即可。 一、客户端 从上篇文章中我们已经知道了 Nacos 的客户端维护了一个长轮询的任务，去检查服务端的配置信息是否发生变更，如果发生了变更，那么客户端会拿到变更的 g
谈谈你对Nacos配置动态更新原理的理解，这道题一定要会
Tom弹架构
08-23 3192
100道最新大厂经典面试题。
Nacos配置管理-配置热更新
m0_60769905的博客
12-12 1065
通过@Value注解注入，结合@RefreshScope来刷新通过@ConfigurationProperties注入，自动刷新不是所有的配置都适合放到配置中心，维护起来比较麻烦；建议将一些关键参数，需要运行时调整的参数放到nacos配置中心，一般都是自定义配置；
Nacos配置管理——配置热更新
weixin_47276069的博客
07-25 546
Nacos配置管理——统一配置管理：https://mp.csdn.net/mp_blog/creation/editor/140469753。Nacos配置管理——配置热更新：https://mp.csdn.net/mp_blog/creation/editor/140469827。Nacos的依赖：https://mp.csdn.net/mp_blog/creation/editor/140469206。2.clean一下项目重新启动。
SpringCloud(二) Nacos作为配置中心——配置更新原理
古柏树下的博客
12-12 3224
Nacos 服务端创建了相关的配置项后，客户端就可以进行监听了。客户端是通过一个定时任务来检查自己监听的配置项的数据的，一旦服务端的数据发生变化时，客户端将会获取到最新的数据，并将最新的数据保存在一个 CacheData 对象中，然后会重新计算 CacheData 的 md5 属性的值，此时就会对该 CacheData 所绑定的 Listener 触发 receiveConfigInfo 回调。 ...
Nacos源码解析：注册中心与配置中心的核心原理
服务可以通过Nacos获取和监听配置变化，当配置发生变化时，Nacos能够快速通知到相关的服务实例，实现配置的实时更新。 为了深入了解Nacos，推荐参考阿里云官方发布的《Nacos架构与原理》和《微服务治理技术白皮书》...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值