【源码解析】SpringBoot使用Nacos配置中心和使用 @NacosValue 进行热更新

最新推荐文章于 2024-05-27 22:40:58 发布
最新推荐文章于 2024-05-27 22:40:58 发布
阅读量1.8k 收藏
点赞数
分类专栏： 源码解析 文章标签： spring boot java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42985872/article/details/130909276
版权

SpringBoot使用Nacos

引入依赖

<dependency>
	<groupId>com.alibaba.boot</groupId>
	<artifactId>nacos-config-spring-boot-starter</artifactId>
	<version>0.2.12</version>
</dependency>

增加本地配置

nacos:
  config:
    server-addr: 127.0.0.1:8848
    bootstrap:
      enable: true
      log:
        enable: true
    data-id: cls-service
    type: yaml
    auto-refresh: true # 开启自动刷新

增加远程配置

cls:
  cname: chars11

使用@NacosValue

@RestController
@RequestMapping("test")
public class NacosValueController {

    @NacosValue(value = "${cls.cname}", autoRefreshed = true)
    private String userName;

    @GetMapping("t1")
    public String getUserName() {
        return userName;
    }

}

NacosValue原理解析

NacosConfigEnvironmentProcessor

EnvironmentPostProcessorApplicationListener实现了SmartApplicationListener，系统启动的时候，会执行EnvironmentPostProcessorApplicationListener#onApplicationEvent。获取容器中所有的EnvironmentPostProcessor，执行对应的postProcessEnvironment。

    public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof ApplicationEnvironmentPreparedEvent) {
            this.onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent)event);
        }

        if (event instanceof ApplicationPreparedEvent) {
            this.onApplicationPreparedEvent();
        }

        if (event instanceof ApplicationFailedEvent) {
            this.onApplicationFailedEvent();
        }

    }

    private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
        ConfigurableEnvironment environment = event.getEnvironment();
        SpringApplication application = event.getSpringApplication();
        Iterator var4 = this.getEnvironmentPostProcessors(application.getResourceLoader(), event.getBootstrapContext()).iterator();

        while(var4.hasNext()) {
            EnvironmentPostProcessor postProcessor = (EnvironmentPostProcessor)var4.next();
            postProcessor.postProcessEnvironment(environment, application);
        }

    }

NacosConfigEnvironmentProcessor#postProcessEnvironment，如果nacos.config.bootstrap.logEnable=true，开启预加载。系统添加了NacosConfigApplicationContextInitializer初始化器。

	public void postProcessEnvironment(ConfigurableEnvironment environment,
			SpringApplication application) {
		application.addInitializers(new NacosConfigApplicationContextInitializer(this));
		nacosConfigProperties = NacosConfigPropertiesUtils
				.buildNacosConfigProperties(environment);
		if (enable()) {
			System.out.println(
					"[Nacos Config Boot] : The preload log configuration is enabled");
			loadConfig(environment);
			NacosConfigLoader nacosConfigLoader = NacosConfigLoaderFactory.getSingleton(nacosConfigProperties, environment, builder);
			LogAutoFreshProcess.build(environment, nacosConfigProperties, nacosConfigLoader, builder).process();
		}
	}

	boolean enable() {
		return nacosConfigProperties != null
				&& nacosConfigProperties.getBootstrap().isLogEnable();
	}

NacosConfigEnvironmentProcessor#loadConfig，调用NacosConfigLoader进行加载。

	private void loadConfig(ConfigurableEnvironment environment) {
		NacosConfigLoader configLoader = new NacosConfigLoader(nacosConfigProperties,
				environment, builder);
		configLoader.loadConfig();
		// set defer NacosPropertySource
		deferPropertySources.addAll(configLoader.getNacosPropertySources());
	}

NacosConfigLoader#loadConfig，调用了NacosUtils.getContent来获取远程配置的内容。

	public void loadConfig() {
		MutablePropertySources mutablePropertySources = environment.getPropertySources();
		List<NacosPropertySource> sources = reqGlobalNacosConfig(globalProperties,
				nacosConfigProperties.getType());
		for (NacosConfigProperties.Config config : nacosConfigProperties.getExtConfig()) {
			List<NacosPropertySource> elements = reqSubNacosConfig(config,
					globalProperties, config.getType());
			sources.addAll(elements);
		}
		if (nacosConfigProperties.isRemoteFirst()) {
			for (ListIterator<NacosPropertySource> itr = sources.listIterator(sources.size()); itr.hasPrevious();) {
				mutablePropertySources.addAfter(
						StandardEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, itr.previous());
			}
		} else {
			for (NacosPropertySource propertySource : sources) {
				mutablePropertySources.addLast(propertySource);
			}
		}
	}

	private List<NacosPropertySource> reqGlobalNacosConfig(Properties globalProperties,
			ConfigType type) {
		List<String> dataIds = new ArrayList<>();
		// Loads all data-id information into the list in the list
		if (!StringUtils.hasLength(nacosConfigProperties.getDataId())) {
			final String ids = environment
					.resolvePlaceholders(nacosConfigProperties.getDataIds());
			dataIds.addAll(Arrays.asList(ids.split(",")));
		}
		else {
			dataIds.add(nacosConfigProperties.getDataId());
		}
		final String groupName = environment
				.resolvePlaceholders(nacosConfigProperties.getGroup());
		final boolean isAutoRefresh = nacosConfigProperties.isAutoRefresh();
		return new ArrayList<>(Arrays.asList(reqNacosConfig(globalProperties,
				dataIds.toArray(new String[0]), groupName, type, isAutoRefresh)));
	}

	private NacosPropertySource[] reqNacosConfig(Properties configProperties,
			String[] dataIds, String groupId, ConfigType type, boolean isAutoRefresh) {
		final NacosPropertySource[] propertySources = new NacosPropertySource[dataIds.length];
		for (int i = 0; i < dataIds.length; i++) {
			if (!StringUtils.hasLength(dataIds[i])) {
				continue;
			}
			// Remove excess Spaces
			final String dataId = environment.resolvePlaceholders(dataIds[i].trim());
			final String config = NacosUtils.getContent(builder.apply(configProperties),
					dataId, groupId);
			final NacosPropertySource nacosPropertySource = new NacosPropertySource(
					dataId, groupId,
					buildDefaultPropertySourceName(dataId, groupId, configProperties),
					config, type.getType());
			nacosPropertySource.setDataId(dataId);
			nacosPropertySource.setType(type.getType());
			nacosPropertySource.setGroupId(groupId);
			nacosPropertySource.setAutoRefreshed(isAutoRefresh);
			logger.info("load config from nacos, data-id is : {}, group is : {}",
					nacosPropertySource.getDataId(), nacosPropertySource.getGroupId());
			propertySources[i] = nacosPropertySource;
			DeferNacosPropertySource defer = new DeferNacosPropertySource(
					nacosPropertySource, configProperties, environment);
			nacosPropertySources.add(defer);
		}
		return propertySources;
	}

NacosUtils#getContent，获取远程配置，调用核心类ConfigService。

	public static String getContent(ConfigService configService, String dataId,
			String groupId) {
		String content = null;
		try {
			content = configService.getConfig(dataId, groupId, DEFAULT_TIMEOUT);
		}
		catch (NacosException e) {
			if (logger.isErrorEnabled()) {
				logger.error("Can't get content from dataId : " + dataId + " , groupId : "
						+ groupId, e);
			}
		}
		return content;
	}

NacosConfigApplicationContextInitializer

NacosConfigApplicationContextInitializer初始化，会添加自动刷新的监听器。

public class NacosConfigApplicationContextInitializer
		implements ApplicationContextInitializer<ConfigurableApplicationContext> {
	// ...

	@Override
	public void initialize(ConfigurableApplicationContext context) {
		singleton.setApplicationContext(context);
		environment = context.getEnvironment();
		nacosConfigProperties = NacosConfigPropertiesUtils
				.buildNacosConfigProperties(environment);
		final NacosConfigLoader configLoader = NacosConfigLoaderFactory.getSingleton(
				nacosConfigProperties, environment, builder);
		if (!enable()) {
			logger.info("[Nacos Config Boot] : The preload configuration is not enabled");
		}
		else {

			// If it opens the log level loading directly will cache
			// DeferNacosPropertySource release

			if (processor.enable()) {
				processor.publishDeferService(context);
				configLoader
						.addListenerIfAutoRefreshed(processor.getDeferPropertySources());
			}
			else {
				configLoader.loadConfig();
				configLoader.addListenerIfAutoRefreshed();
			}
		}

		final ConfigurableListableBeanFactory factory = context.getBeanFactory();
		if (!factory
				.containsSingleton(NacosBeanUtils.GLOBAL_NACOS_PROPERTIES_BEAN_NAME)) {
			factory.registerSingleton(NacosBeanUtils.GLOBAL_NACOS_PROPERTIES_BEAN_NAME,
					configLoader.getGlobalProperties());
		}
	}

	private boolean enable() {
		return processor.enable() || nacosConfigProperties.getBootstrap().isEnable();
	}

}

NacosConfigLoader#addListenerIfAutoRefreshed(List<NacosConfigLoader.DeferNacosPropertySource>)，调用NacosPropertySourcePostProcessor添加监听器。

	public void addListenerIfAutoRefreshed(
			final List<DeferNacosPropertySource> deferNacosPropertySources) {
		for (DeferNacosPropertySource deferNacosPropertySource : deferNacosPropertySources) {
			NacosPropertySourcePostProcessor.addListenerIfAutoRefreshed(
					deferNacosPropertySource.getNacosPropertySource(),
					deferNacosPropertySource.getProperties(),
					deferNacosPropertySource.getEnvironment());
		}
	}

NacosPropertySourcePostProcessor#addListenerIfAutoRefreshed，当监听到配置变化，直接替换env的配置数据。

	public static void addListenerIfAutoRefreshed(
			final NacosPropertySource nacosPropertySource, final Properties properties,
			final ConfigurableEnvironment environment) {

		if (!nacosPropertySource.isAutoRefreshed()) { // Disable Auto-Refreshed
			return;
		}

		final String dataId = nacosPropertySource.getDataId();
		final String groupId = nacosPropertySource.getGroupId();
		final String type = nacosPropertySource.getType();
		final NacosServiceFactory nacosServiceFactory = getNacosServiceFactoryBean(
				beanFactory);

		try {

			ConfigService configService = nacosServiceFactory
					.createConfigService(properties);

			Listener listener = new AbstractListener() {

				@Override
				public void receiveConfigInfo(String config) {
					String name = nacosPropertySource.getName();
					NacosPropertySource newNacosPropertySource = new NacosPropertySource(
							dataId, groupId, name, config, type);
					newNacosPropertySource.copy(nacosPropertySource);
					MutablePropertySources propertySources = environment
							.getPropertySources();
					// replace NacosPropertySource
					propertySources.replace(name, newNacosPropertySource);
				}
			};

			if (configService instanceof EventPublishingConfigService) {
				((EventPublishingConfigService) configService).addListener(dataId,
						groupId, type, listener);
			}
			else {
				configService.addListener(dataId, groupId, listener);
			}

		}
		catch (NacosException e) {
			throw new RuntimeException(
					"ConfigService can't add Listener with properties : " + properties,
					e);
		}
	}

使用DelegatingEventPublishingListener对监听器进行包装。

	public void addListener(String dataId, String group, String type, Listener listener)
			throws NacosException {
		Listener listenerAdapter = new DelegatingEventPublishingListener(configService,
				dataId, group, type, applicationEventPublisher, executor, listener);
		addListener(dataId, group, listenerAdapter);
	}

DelegatingEventPublishingListener#receiveConfigInfo，当接收到事件后，会调用内置的监听器处理，以及发布NacosConfigReceivedEvent事件。

	@Override
	public void receiveConfigInfo(String content) {
		onReceived(content);
		publishEvent(content);
	}

	private void publishEvent(String content) {
		NacosConfigReceivedEvent event = new NacosConfigReceivedEvent(configService,
				dataId, groupId, content, configType);
		applicationEventPublisher.publishEvent(event);
	}

	private void onReceived(String content) {
		delegate.receiveConfigInfo(content);
	}

NacosValueAnnotationBeanPostProcessor

NacosValueAnnotationBeanPostProcessor实现了BeanPostProcessor，启动的时候执行NacosValueAnnotationBeanPostProcessor#postProcessBeforeInitialization。将带有@NacosValue注解的属性和方法加入到一个Map中。

	@Override
	public Object postProcessBeforeInitialization(Object bean, final String beanName)
			throws BeansException {

		doWithFields(bean, beanName);

		doWithMethods(bean, beanName);

		return super.postProcessBeforeInitialization(bean, beanName);
	}

	private void doWithFields(final Object bean, final String beanName) {
		ReflectionUtils.doWithFields(bean.getClass(),
				new ReflectionUtils.FieldCallback() {
					@Override
					public void doWith(Field field) throws IllegalArgumentException {
						NacosValue annotation = getAnnotation(field, NacosValue.class);
						doWithAnnotation(beanName, bean, annotation, field.getModifiers(),
								null, field);
					}
				});
	}

	private void doWithMethods(final Object bean, final String beanName) {
		ReflectionUtils.doWithMethods(bean.getClass(),
				new ReflectionUtils.MethodCallback() {
					@Override
					public void doWith(Method method) throws IllegalArgumentException {
						NacosValue annotation = getAnnotation(method, NacosValue.class);
						doWithAnnotation(beanName, bean, annotation,
								method.getModifiers(), method, null);
					}
				});
	}

	private void doWithAnnotation(String beanName, Object bean, NacosValue annotation,
			int modifiers, Method method, Field field) {
		if (annotation != null) {
			if (Modifier.isStatic(modifiers)) {
				return;
			}

			if (annotation.autoRefreshed()) {
				String placeholder = resolvePlaceholder(annotation.value());

				if (placeholder == null) {
					return;
				}

				NacosValueTarget nacosValueTarget = new NacosValueTarget(bean, beanName,
						method, field, annotation.value());
				put2ListMap(placeholderNacosValueTargetMap, placeholder,
						nacosValueTarget);
			}
		}
	}

	private <K, V> void put2ListMap(Map<K, List<V>> map, K key, V value) {
		List<V> valueList = map.get(key);
		if (valueList == null) {
			valueList = new ArrayList<V>();
		}
		valueList.add(value);
		map.put(key, valueList);
	}

该类同样还实现了ApplicationListener<NacosConfigReceivedEvent>，当监听到NacosConfigReceivedEvent，通过反射用新的值替换Bean中的属性值。

	@Override
	public void onApplicationEvent(NacosConfigReceivedEvent event) {
		// In to this event receiver, the environment has been updated the
		// latest configuration information, pull directly from the environment
		// fix issue #142
		for (Map.Entry<String, List<NacosValueTarget>> entry : placeholderNacosValueTargetMap
				.entrySet()) {
			String key = environment.resolvePlaceholders(entry.getKey());
			String newValue = environment.getProperty(key);

			if (newValue == null) {
				continue;
			}
			List<NacosValueTarget> beanPropertyList = entry.getValue();
			for (NacosValueTarget target : beanPropertyList) {
				String md5String = MD5Utils.md5Hex(newValue, "UTF-8");
				boolean isUpdate = !target.lastMD5.equals(md5String);
				if (isUpdate) {
					target.updateLastMD5(md5String);
					Object evaluatedValue = resolveNotifyValue(target.nacosValueExpr, key, newValue);
					if (target.method == null) {
						setField(target, evaluatedValue);
					}
					else {
						setMethod(target, evaluatedValue);
					}
				}
			}
		}
	}


	private void setMethod(NacosValueTarget nacosValueTarget, Object propertyValue) {
		Method method = nacosValueTarget.method;
		ReflectionUtils.makeAccessible(method);
		try {
			method.invoke(nacosValueTarget.bean,
					convertIfNecessary(method, propertyValue));

			if (logger.isDebugEnabled()) {
				logger.debug("Update value with {} (method) in {} (bean) with {}",
						method.getName(), nacosValueTarget.beanName, propertyValue);
			}
		}
		catch (Throwable e) {
			if (logger.isErrorEnabled()) {
				logger.error("Can't update value with " + method.getName()
						+ " (method) in " + nacosValueTarget.beanName + " (bean)", e);
			}
		}
	}

	private void setField(final NacosValueTarget nacosValueTarget,
			final Object propertyValue) {
		final Object bean = nacosValueTarget.bean;

		Field field = nacosValueTarget.field;

		String fieldName = field.getName();

		try {
			ReflectionUtils.makeAccessible(field);
			field.set(bean, convertIfNecessary(field, propertyValue));

			if (logger.isDebugEnabled()) {
				logger.debug("Update value of the {}" + " (field) in {} (bean) with {}",
						fieldName, nacosValueTarget.beanName, propertyValue);
			}
		}
		catch (Throwable e) {
			if (logger.isErrorEnabled()) {
				logger.error("Can't update value of the " + fieldName + " (field) in "
						+ nacosValueTarget.beanName + " (bean)", e);
			}
		}
	}

在这里插入图片描述

秋装什么
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot整合nacos完整代码
04-15
SpringBoot整合Nacos是现代Java微服务架构中常见的配置中心和发现服务的组合。Nacos作为阿里开源的一款轻量级的服务发现和配置管理工具，它提供了动态配置、服务发现、健康检查、命名空间隔离等功能，使得微服务环境...
【Nacos】@NacosValue的使用与原理
morris
02-28 2万+
在SpringCloud工程中，可以使用@RefreshScope+@Value实现配置文件内容变更后的动态刷新。在SpringBoot工程中，可以使用@NacosValue来实现配置文件内容变更后的动态刷新。
@NacosValue注解的用法
zouyang920的博客
03-31 3168
在SpringCloud工程中，可以使用@RefreshScope+@Value实现配置文件内容变更后的动态刷新。在SpringBoot工程中，可以使用@NacosValue来实现配置文件内容变更后的动态刷新。
2024.5.22 关于 SpringCloud —— Nacos 配置管理
最新发布
weixin_63888301的博客
05-27 969
Nacos 配置统一管理 Nacos 配置热部署 Nacos 多环境配置共享 配置优先级
【nacos】springboot @Value @NacosValue 使用时可能无效
热门推荐
qfzhangwei的专栏
01-13 2万+
1 @NacosValue 自动刷新 环境依赖版本 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.4.RELEASE</version> <relativeP
【Nacos】nacos @NacosValue 动态配置刷新 源码解析
qfzhangwei的专栏
01-28 5880
1 原理思想 Nacos 采用的是 Pull 模式，但并不是简单的 Pull，而是一种长轮训机制，它结合 Push 和 Pull 两者的优势。客户端采用长轮训的方式定时发起 Pull 请求，去检查服务端配置信息是否发生了变更，如果发生了变更，则客户端会根据变更的数据获得最新的配置。所谓的长轮训，是客户端发起轮训请求之后，服务端如果有配置发生变更，就直接返回，如图所示。 如果客户端发起 Pull 请求后，发现服务端的配置和客户端的配置是保持一致的，那么服务端会先 “Hold” 住这个请求，也就是服务端拿到
实现Nacos属性值自动刷新的三种方式
算命de博客
06-30 5648
在Spring Boot项目中，我们经常使用Nacos作为配置中心，用于管理应用程序的属性配置。当我们在Nacos上修改属性值时，希望应用程序能够自动刷新并应用最新的属性值，以避免重启应用。本篇博客将介绍三种实现Nacos属性值自动刷新的方式，并提供相应的示例代码。
Springboot使用nacos详解含完整示例（值得珍藏）
02-20
配置信息可以统一存储在Nacos中，并通过配置中心进行管理和分发。当配置信息发生变化时，Config能够实时地将最新的配置推送给服务消费者，实现配置的动态更新。 - **重要性**：配置管理在微服务架构中非常重要，它...
Springboot扩展Nacos(Config)配置动态更新
03-29
基于Nacos Client2.1.0版本配置更新监听器AbstractConfigChangeListener实现@Value、@NacosValue的动态注入功能，本地安装jar即可实现配置更新之后的动态注入功能
SpringBoot使用nacos作为配置中心DEMO
05-31
**SpringBoot与Nacos配置中心整合详解** 在现代Java微服务架构中，Spring Boot以其简洁、高效的特性受到了广泛欢迎。而随着服务数量的增加，管理各个服务的配置文件变得复杂且困难，这时就需要一个集中化的配置中心...
Nacos配置中心使用说明（图解）.docx
01-12
Nacos配置中心使用说明（图解）
注解@Value注解获取不到nacos的配置文件，获取为null
weixin_43930851的博客
04-14 6039
Java实践
Nacos 热加载实现方法
小瓜皮
07-14 2130
在Spirng项目中一般使用Spring的@Value注解 或@ConfigurationProperties 的Properties进行参数注入，这样就可以获得配置文件中的的值； @ConfigurationProperties。但是在使用Nacos管理配置时，修改配置文件的值不能同步热更新，在这注解上修改即可实现：过程是在要调用这些变化的配置的类中，通过注解 ...
@NacosPropertySource、@NacosPropertySources、@NacosValue、@NacosConfigurationProperties
Hanyinh的博客
11-30 9236
@NacosPropertySource 用来配置单个DataId 如： @NacosPropertySource(dataId = "user.info", groupId = "springbootvue", autoRefreshed = true) @NacosPropertySources 用来配置多个DataId 如： @NacosPropertySources({ @NacosPropertySource(dataId = "user.info", groupId = "s
nacos整合springmvc:解决使用@Value或@NacosValue无法从nacos配置中心动态获取最新配置数据问题
weixin_42917368的博客
11-05 7213
nacos整合mybatis:解决使用@Value或@NacosValue无法从nacos配置中心动态获取最新配置数据问题 1、出现无法动态获取最新配置数据的项目配置： （1）使用的nacos-spring-context版本是0.2.X，比较老的版本； （2）关于nacos的连接配置以XML方式配置的； （3）用@Value的方式注入相关配置； 2、问题分析： 用的nacos版本比较老，多次测试发现应用没有监听nacos配置中心数据的改变，只能在应用启动或重启时会从nacos配置中心获取一次最新数据；启动
使用Spring的@Value从Nacos配置中心获取值并自动刷新
chuixue24的博客
07-16 2万+
在使用Nacos作为配置中心时，除了@NacosValue可以做到自动刷新外，nacos-spring-context:0.3.4版本是支持@Value获取Nacos配置中心的值，并动态刷新的，该功能是Spri依靠ngValueAnnotationBeanPostProcessor类来实现： @Override protected Tuple<String, NacosValueTarget> doWithAnnotation(String beanName, Object bea.
nacos 系列 - spring boot 集成
_WanG
01-30 3827
nacos 系列 - spring boot 集成 文章目录nacos 系列 - spring boot 集成1. 修改pom.xml2. 启动类注解3. 配置文件修改4. 配置参数使用@NacosValue注入5. 验证1. 代码示例2. 修改配置前3. 修改配置后4. nacos服务端异常退出 需要依赖nacos服务端, 如果还没有搭建nacos服务端的, 请先将服务端跑起来 1. 修改p...
Spring Cloud +Nacos 热更新
fox_233的博客
06-11 4401
1. 环境：JDK8 SpringCloud 2.2.0 RELEASE Nacos1.1.4 2. 问题：nacos上的配置文件可以读取到，但是发现不能热更新 3. 尝试办法1：在用到配置项的类上都加上注解@RefreshScope 结果 ：没有成功 尝试办法2：将@value 注解替换成@NacosValue 结果 ：没有成功 尝试办法3：将@value 注解替换成@NacosValue ...
springboot使用nacos配置
10-09
使用Nacos配置Spring Boot应用程序需要遵循以下步骤： 1. 添加依赖 在pom.xml文件中，添加以下依赖： ```xml <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId> </dependency> ``` 2. 配置Nacos服务器地址 在application.properties或application.yml文件中，配置Nacos服务器地址： ```yaml spring.cloud.nacos.config.server-addr=127.0.0.1:8848 ``` 3. 创建配置文件 在Nacos控制台中创建配置文件。例如，如果你想创建一个名称为"example"的配置文件，可以使用以下命令： ```bash curl -X POST "http://127.0.0.1:8848/nacos/v1/cs/configs?dataId=example&group=DEFAULT_GROUP&content=helloWorld" ``` 4. 从Nacos获取配置 在Spring Boot应用程序中，可以使用`@Value`注解或`Environment`对象来获取Nacos配置。例如： ```java @Value("${example:}") private String example; ``` 或者 ```java @Autowired private Environment environment; String example = environment.getProperty("example"); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值