NACOS 配置文件与服务监听

对于启动项目时可以检测的配置文件，修改配置文件时也可进入监听，对于服务监听时，项目启动时注册进nacos可以监听，修改服务时关闭服务时都可以监听，也可以手动推送服务到nacos上。

添加nacos相关的配置文件：

     <dependency>
            <groupId>com.alibaba.nacos</groupId>
            <artifactId>nacos-spring-context</artifactId>
            <version>0.3.6</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            <version>2.1.3.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba.nacos</groupId>
            <artifactId>nacos-client</artifactId>
            <version>1.4.1</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
            <version>2.1.3.RELEASE</version>
        </dependency>

修改配置文件，链接nacos

nacos上的配置文件名称为：服务名称-dev.yaml
bootstrap.yml

spring:
  application:
    name: 服务名称
  profiles:
    active: dev
  cloud:
    nacos:
       //服务相关
      discovery:
        server-addr: IP:8848
        //注册服务时添加元数据
        metadata:
          sort: 9090
      //配置文件相关
      config:
        server-addr: IP:8848
        file-extension: yaml
        group: DEFAULT_GROUP

编写配置类，监听服务与配置文件

package com.zaz.weifuwu.config;

import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.annotation.NacosInjected;
import com.alibaba.nacos.api.annotation.NacosProperties;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.config.listener.AbstractListener;
import com.alibaba.nacos.api.exception.NacosException;
import com.alibaba.nacos.api.naming.NamingFactory;
import com.alibaba.nacos.api.naming.NamingService;
import com.alibaba.nacos.api.naming.pojo.Instance;
import com.alibaba.nacos.spring.context.annotation.discovery.EnableNacosDiscovery;
import io.micrometer.core.instrument.util.JsonUtils;
import jdk.nashorn.internal.ir.annotations.Reference;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.yaml.snakeyaml.Yaml;

import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

@Configuration
@Slf4j
@EnableNacosDiscovery(globalProperties = @NacosProperties(serverAddr = "IP:8848"))
@Reference
public class NacosConfig implements InitializingBean, DisposableBean {


    private String dataId = "application-dev.yaml";
    private String serverAddr = "IP:8848";
    private String group = "DEFAULT_GROUP";
    private String namespace;
    
    @NacosInjected
    private NamingService namingService;  //服务注册功能的Service
    
    private ConfigService configService;
    public NacosConfig() throws NacosException {
    }

    @PostConstruct
    public void init() {
    }

    @Override
    public void destroy() throws Exception {
        configService.shutDown();
    }
    @Override
    public void afterPropertiesSet() throws Exception {


        //启动配置文件时监听
        Properties properties = new Properties();
        properties.put("serverAddr", serverAddr);
//        properties.put("namespace", namespace);
        ConfigService configService = NacosFactory.createConfigService(properties);
        configService = NacosFactory.createConfigService(properties);

        try {
            //修改配置文件时监听
            configService.addListener(dataId, group, new AbstractListener() {
                @Override
                public void receiveConfigInfo(String configInfo) {
                    Yaml yaml = new Yaml();
                    Map load = yaml.load(configInfo);
                    log.info("监听到最新的配置文件信息：{}", JsonUtils.obj2Json(load));
                    //获取配置文件中的某一项值
                    Integer choose = (Integer) load.get("choose");
                }
            });
        } catch (NacosException e) {
            log.error(ExceptionUtils.getStackTrace(e));
        }

        try {
            //监听服务（启动，修改，关闭都会监听到）
            NamingService namingService = NamingFactory.createNamingService("IP:8848");
            namingService.subscribe("要监听的服务名", "DEFAULT_GROUP", event -> {
                List<Instance> allInstances = null;
                try {
                    //获取所有该服务的列表
                    allInstances = namingService.getAllInstances("要监听的服务名");
                    
                    //如果是要修改某服务便可直接用上面的所有列表即可   如果么有可以新建Instance进行推送
                    //手动推送服务
                    Instance instance=new Instance ();
                    instance.setClusterName("TestCluster");  //集群名称
                    instance.setEnabled(true);   //是否启用
                    instance.setEphemeral(true);  //临时节点/持久化节点, CP（Raft）, AP（Distro）
                    instance.setIp("localhost");
                    instance.setPort(8848);
                    instance.setWeight(10);  //1~100
                    Map<String,String > map =new HashMap<>();
                    map.put("post","9090");
                    //添加元数据
                    instance.setMetadata(map);
                    try {
                        //推送到该服务名下
                        namingService.registerInstance("SpringBoot-Nacos",instance);
                    } catch (NacosException e) {
                        e.printStackTrace();
                    }
                    
                    
                } catch (NacosException e) {
                    e.printStackTrace();
                }
            });

        } catch (NacosException e) {
            log.error(e.getMessage(), e);
        }
    }
}

手动注册服务到nacos

    @NacosInjected
    private NamingService namingService;  //服务注册功能的Service
    
    @PostMapping("push")
    public void Push(String name,String ip,Integer post,Integer weight,String ServerName){
        Instance instance=new Instance ();
        instance.setClusterName(name);  //集群名称
        instance.setEnabled(true);   //是否启用
        instance.setEphemeral(true);  //临时节点/持久化节点, CP（Raft）, AP（Distro）
        instance.setIp(ip);
        instance.setPort(post);
        instance.setWeight(weight);  //1~100

        try {
            //推送到该服务名下
            namingService.registerInstance("ServerName",instance);
        } catch (NacosException e) {
            e.printStackTrace();
        }
    }

JsonUtils

package com.util;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;

import java.lang.reflect.Type;
import java.util.Map;

/**
 * @Description json工具类
 */
public class JsonUtils {
	private static Gson gson = new Gson();
	/**
	 * 
	 * @param jsonclass
	 * @param json
	 * @return
	 */
	public static Object json2Obj(Class<Object> jsonclass, String json) {
		Object obj = null;
		obj = gson.fromJson(json, jsonclass);
		return obj;

	}

	public static String obj2Json(Object obj) {

		String jsonStr = gson.toJson(obj);

		return jsonStr;
	}

	public static <T> T json2Obj(String json,Type tp) {

		T obj = gson.fromJson(json, tp);

		return obj;
	}
	
	public static <T> T json2Obj(String json,Class<T> tp) {

		T response = gson.fromJson(json, tp);

		return response;
	}
	
	public static Map<String,String> json2Map(String json) {

		Type tp = new TypeToken<Map<String,String>>() {}.getType();

		return gson.fromJson(json, tp);
	}
	
	public static String ObjectToJson(Object obj){
		 GsonBuilder gb =new GsonBuilder();
		 gb.disableHtmlEscaping();
		 gb.create().toJson(obj);
		 return gb.create().toJson(obj);
	}

}