Go注册服务发现Nacos

package utils

import (
	"double-preventionv2/global"
	"fmt"
	"github.com/nacos-group/nacos-sdk-go/clients"
	"github.com/nacos-group/nacos-sdk-go/clients/config_client"
	"github.com/nacos-group/nacos-sdk-go/clients/nacos_client"
	"github.com/nacos-group/nacos-sdk-go/clients/naming_client"
	"github.com/nacos-group/nacos-sdk-go/common/constant"
	"github.com/nacos-group/nacos-sdk-go/common/http_agent"
	"github.com/nacos-group/nacos-sdk-go/model"
	utils "github.com/nacos-group/nacos-sdk-go/util"
	"github.com/nacos-group/nacos-sdk-go/vo"
	"log"
	"strconv"
	//"log"
	//"time"
)

//构建客户端
func CreateNamingClient() (namingClient naming_client.INamingClient) {

	namingClient, err := clients.CreateNamingClient(map[string]interface{}{
		"serverConfigs": []constant.ServerConfig{
			{
				//nacos服务的ip地址
				IpAddr: global.GVA_CONFIG.ServerConfig.IpAddr,
				//nacos服务端口
				Port: global.GVA_CONFIG.ServerConfig.Port,
			},
		},
		"clientConfig": constant.ClientConfig{
			TimeoutMs:            global.GVA_CONFIG.ClientConfig.TimeoutMs,            //http请求超时时间，单位毫秒
			ListenInterval:       global.GVA_CONFIG.ClientConfig.ListenInterval,       //监听间隔时间，单位毫秒（仅在ConfigClient中有效）
			BeatInterval:         global.GVA_CONFIG.ClientConfig.BeatInterval,         //心跳间隔时间，单位毫秒（仅在ServiceClient中有效）
			NamespaceId:          global.GVA_CONFIG.ClientConfig.NamespaceId,          //nacos命名空间
			UpdateThreadNum:      global.GVA_CONFIG.ClientConfig.UpdateThreadNum,      //更新服务的线程数
			NotLoadCacheAtStart:  global.GVA_CONFIG.ClientConfig.NotLoadCacheAtStart,  //在启动时不读取本地缓存数据，true--不读取，false--读取
			UpdateCacheWhenEmpty: global.GVA_CONFIG.ClientConfig.UpdateCacheWhenEmpty, //当服务列表为空时是否更新本地缓存，true--更新,false--不更新
		},
	})

	if err != nil {
		panic(err)
	}
	return
}

// 注册服务实例
func RegisterInstance(namingClient naming_client.INamingClient) {
	boo, _ := namingClient.RegisterInstance(vo.RegisterInstanceParam{
		Ip:          utils.LocalIP(),
		Port:        uint64(global.GVA_CONFIG.System.Addr),
		ServiceName: global.GVA_CONFIG.System.Name,
		Weight:      10,
		Enable:      true,
		Healthy:     true,
		Ephemeral:   true,
		Metadata: map[string]string{
			"preserved.register.source": "SPRING_CLOUD",
		},
	})
	fmt.Println(boo)
}

// 注销服务实例
func DeregisterInstance(namingClient naming_client.INamingClient) {
	namingClient.DeregisterInstance(vo.DeregisterInstanceParam{
		Ip:          utils.LocalIP(),
		Port:        uint64(global.GVA_CONFIG.System.Addr),
		ServiceName: global.GVA_CONFIG.System.Name,
		Ephemeral:   true,
	})
}

// 获取服务
func GetService(namingClient naming_client.INamingClient) (service model.Service) {
	service, _ = namingClient.GetService(vo.GetServiceParam{
		ServiceName: global.GVA_CONFIG.System.Name,
	})
	return
}

// 获取所有的实例列表
func SelectAllInstances(namingClient naming_client.INamingClient) (instances []model.Instance) {
	instances, _ = namingClient.SelectAllInstances(vo.SelectAllInstancesParam{
		ServiceName: global.GVA_CONFIG.System.Name,
	})
	return
}

// 获取实例列表
func SelectInstances(namingClient naming_client.INamingClient) (instances []model.Instance) {
	instances, _ = namingClient.SelectInstances(vo.SelectInstancesParam{
		ServiceName: global.GVA_CONFIG.System.Name,
		HealthyOnly: true,
	})
	return
}

// 获取一个健康的实例（加权轮训负载均衡）
func SelectOneHealthyInstance(namingClient naming_client.INamingClient) (instance *model.Instance) {
	instance, _ = namingClient.SelectOneHealthyInstance(vo.SelectOneHealthInstanceParam{
		ServiceName: global.GVA_CONFIG.System.Name,
	})
	return
}

//服务监听
func Subscribe(namingClient naming_client.INamingClient) {
	namingClient.Subscribe(&vo.SubscribeParam{
		ServiceName: global.GVA_CONFIG.System.Name,
		SubscribeCallback: func(services []model.SubscribeService, err error) {
			log.Printf("\n\n callback return services:%s \n\n", utils.ToJsonString(services))
		},
	})
}

//取消服务监听
func Unsubscribe(namingClient naming_client.INamingClient) {
	namingClient.Unsubscribe(&vo.SubscribeParam{
		ServiceName: global.GVA_CONFIG.System.Name,
		SubscribeCallback: func(services []model.SubscribeService, err error) {
			log.Printf("\n\n callback return services:%s \n\n", utils.ToJsonString(services))
		},
	})
}

/**
 * 😊
 * @Author 😊
 * @Description 创建config客户端
 * @Date 9:04 2020/7/17
 * @Param
 * @return
 **/
func ConfigClient() config_client.ConfigClient {
	nc := nacos_client.NacosClient{}
	nc.SetServerConfig([]constant.ServerConfig{
		constant.ServerConfig{
			//nacos服务的ip地址
			IpAddr: global.IPADDR,
			//nacos服务端口
			Port:        global.PORT,
			ContextPath: "/nacos",
		}})
	nc.SetClientConfig(constant.ClientConfig{
		TimeoutMs:           10000,
		BeatInterval:        5000,
		ListenInterval:      5000,
		NotLoadCacheAtStart: true,
		//Username:            "nacos",
		//Password:            "nacos",
	})
	nc.SetHttpAgent(&http_agent.HttpAgent{})
	client, _ := config_client.NewConfigClient(&nc)
	return client
}

/**
 * 😊
 * @Author 😊
 * @Description 获取配置
 * @Date 9:09 2020/7/17
 * @Param
 * @return
 **/
func GetConfig(namingClient config_client.ConfigClient) (content string) {
	content, err := namingClient.GetConfig(vo.ConfigParam{
		DataId: global.NOCOS_CONFIG_DATAID,
		Group:  global.NOCOS_CONFIG_GROUP,
	})
	IsError(err)
	return
}

/**
 * 😊
 * @Author 😊
 * @Description 用于获取调用服务的ip和port，进行地址组装
 * @Date 8:43 2020/7/13
 * @Param  serverName
 * @return httpPath
 **/
// 获取一个健康的实例（加权轮训负载均衡）
func HttpPaths(serverName string) (httpPath string) {
	instance, _ := global.GVA_NACOS.SelectOneHealthyInstance(vo.SelectOneHealthInstanceParam{
		ServiceName: serverName,
	})
	httpPath = "http://" + instance.Ip + ":" + strconv.Itoa(int(instance.Port))
	return
}