微服务之服务注册和服务发现篇

关注

原创最新推荐文章于 2026-06-26 13:09:09 发布 180 阅读 AI 写同款· GEO 优化 ›

二维TE波ADI-FDTD程序包使用指南：解压前的三件事时域有限差分（FDTD）是电磁仿真的核心方法，但传统显式格式受Courant稳定条件约束，网格细化后时间步长被迫缩小，计算成本剧增。交替方向隐式时域有限差分（ADI-FDTD）通过将每个时间步分裂为两个半步，以隐式更新换取对稳定条件的突破，在保持精度的同时显著放大时间步长。针对二维TE波（仅含Ex、Ey、Hz分量），ADI-FDTD只需交替求解两个方向的三对角方程，非常适合波导、光子晶体、微带电路等纵向均匀结构的建模。然而，“无条件稳定”不等于无条件准确，程序落地仍需验证场分量类型、时间步放大倍数及PML吸阅读详情

有了服务注册和发现机制，消费者不需要知道具体服务提供者的真实物理地址就可以进行调用，也无须知道具体有多少个服务者可用；而服务提供者只需要注册到注册中心，就可以对外提供服务，在对外服务时不需要知道具体是哪些服务调用了自己。

RPC 配置

Etcd:
  Hosts:
  - 127.0.0.1:2379
  Key: user.rpc

这里分析 go-zero 的 etcd 部分源码, 源码引用 https://github.com/zeromicro/go-zero-demo/tree/master/mall

被调方-服务注册

mall/user/rpc/user.go 源码如下

package main

import (
	"flag"
	"fmt"

	"go-zero-demo-rpc/mall/user/rpc/internal/config"
	"go-zero-demo-rpc/mall/user/rpc/internal/server"
	"go-zero-demo-rpc/mall/user/rpc/internal/svc"
	"go-zero-demo-rpc/mall/user/rpc/types/user"

	"github.com/zeromicro/go-zero/core/conf"
	"github.com/zeromicro/go-zero/core/service"
	"github.com/zeromicro/go-zero/zrpc"
	"google.golang.org/grpc"
	"google.golang.org/grpc/reflection"
)

var configFile = flag.String("f", "etc/user.yaml", "the config file")

func main() {
    flag.Parse()
    
    var c config.Config
    conf.MustLoad(*configFile, &c)
    ctx := svc.NewServiceContext(c)
    svr := server.NewUserServer(ctx)
    
    s := zrpc.MustNewServer(c.RpcServerConf, func(grpcServer *grpc.Server) {
        user.RegisterUserServer(grpcServer, svr)
    
        if c.Mode == service.DevMode || c.Mode == service.TestMode {
            reflection.Register(grpcServer)
        }
    })
    defer s.Stop()
    
    fmt.Printf("Starting rpc server at %s...\n", c.ListenOn)
    s.Start()
}

MustNewServer 内部实现调用了 NewServer 方法, 这里我们关注 NewServer 通过 internal.NewRpcPubServer 方法实例化了 internal.Server

if c.HasEtcd() {
    server, err = internal.NewRpcPubServer(c.Etcd, c.ListenOn, serverOptions...)
    if err != nil {
        return nil, err
    }
}

internal.NewRpcPubServer 中的 registerEtcd 会调用 Publisher.KeepAlive 方法

// KeepAlive keeps key:value alive.
func (p *Publisher) KeepAlive() error {
    // 这里获取 etcd 的连接
    cli, err := internal.GetRegistry().GetConn(p.endpoints)
    if err != nil {
        return err
    }
    
    p.lease, err = p.register(cli)
    if err != nil {
        return err
    }
    
    proc.AddWrapUpListener(func() {
        p.Stop()
    })
    
    return p.keepAliveAsync(cli)
}

p.register 这里把自己注册到服务中

func (p *Publisher) register(client internal.EtcdClient) (clientv3.LeaseID, error) {

    // 这里新建一个租约
    resp, err := client.Grant(client.Ctx(), TimeToLive)
    if err != nil {
        return clientv3.NoLease, err
    }
    
    // 得到租约的 ID
    lease := resp.ID
    
    // 这里拼接出实际存储的 key
    if p.id > 0 {
        p.fullKey = makeEtcdKey(p.key, p.id)
    } else {
        p.fullKey = makeEtcdKey(p.key, int64(lease))
    }

    // p.value 是前面的 figureOutListenOn 方法获取到自己的地址
	_, err = client.Put(client.Ctx(), p.fullKey, p.value, clientv3.WithLease(lease))

    return lease, err
}

注册完之后, keepAliveAsync 开了一个协程保活这个服务
当这个服务意外宕机时, 就不会再向 etcd 保活, etcd 就会删除这个 key
注册好的服务如图

1.png

调用方-服务发现

order/api/order.go 源码如下

package main

import (
	"flag"
	"fmt"

	"go-zero-demo-rpc/order/api/internal/config"
	"go-zero-demo-rpc/order/api/internal/handler"
	"go-zero-demo-rpc/order/api/internal/svc"

	"github.com/zeromicro/go-zero/core/conf"
	"github.com/zeromicro/go-zero/rest"
)

var configFile = flag.String("f", "etc/order.yaml", "the config file")

func main() {
	flag.Parse()

	var c config.Config
	conf.MustLoad(*configFile, &c)

	server := rest.MustNewServer(c.RestConf)
	defer server.Stop()

	ctx := svc.NewServiceContext(c)
	handler.RegisterHandlers(server, ctx)

	fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
	server.Start()
}

在 svc.NewServiceContext 方法内部又调用了 zrpc.MustNewClient , zrpc.MustNewClient 主要实现在 zrpc.NewClient

func NewServiceContext(c config.Config) *ServiceContext {
	return &ServiceContext{
		Config:  c,
		UserRpc: user.NewUser(zrpc.MustNewClient(c.UserRpc)),
	}
}

最后实际调用了 internal.NewClient 去实例化 rpc client

func NewClient(c RpcClientConf, options ...ClientOption) (Client, error) {
	var opts []ClientOption
	if c.HasCredential() {
		opts = append(opts, WithDialOption(grpc.WithPerRPCCredentials(&auth.Credential{
			App:   c.App,
			Token: c.Token,
		})))
	}
	if c.NonBlock {
		opts = append(opts, WithNonBlock())
	}
	if c.Timeout > 0 {
		opts = append(opts, WithTimeout(time.Duration(c.Timeout)*time.Millisecond))
	}

	opts = append(opts, options...)

	target, err := c.BuildTarget()
	if err != nil {
		return nil, err
	}

	client, err := internal.NewClient(target, opts...)
	if err != nil {
		return nil, err
	}

	return &RpcClient{
		client: client,
	}, nil
}

在 zrpc/internal/client.go 文件里, 包含一个 init 方法, 这里就是实际发现服务的地方, 在这里注册服务发现者

func init() {
	resolver.Register()
}

resolver.Register 方法实现

package resolver

import (
	"github.com/zeromicro/go-zero/zrpc/resolver/internal"
)

// Register registers schemes defined zrpc.
// Keep it in a separated package to let third party register manually.
func Register() {
	internal.RegisterResolver()
}

最后又回到 interval 包的 internal.RegisterResolver 方法, 这里我们关注 etcdResolverBuilder

func RegisterResolver() {
	resolver.Register(&directResolverBuilder)
	resolver.Register(&discovResolverBuilder)
	resolver.Register(&etcdResolverBuilder)
	resolver.Register(&k8sResolverBuilder)
}

etcdBuilder 的内嵌了 discovBuilder 结构体,Build 方法调用过程:实例化服务端: internal.NewClient -> client.dial -> grpc.DialContext由于 etcd 是 resolver.BuildDiscovTarget 生成的 taget 所以是类似这样子的: discov://127.0.0.1:2379/user.rpc解析服务发现: ClientConn.parseTargetAndFindResolver -> grpc.parseTarget -> ClientConn.getResolver然后在 grpc.newCCResolverWrapper 调用 resolver.Builder.Build 方法是去发现服务
我们着重关注 discovBuilder.Build 方法

type etcdBuilder struct {
	discovBuilder
}


type discovBuilder struct{}

func (b *discovBuilder) Build(target resolver.Target, cc resolver.ClientConn, _ resolver.BuildOptions) (
	resolver.Resolver, error) {
	hosts := strings.FieldsFunc(targets.GetAuthority(target), func(r rune) bool {
		return r == EndpointSepChar
	})
	sub, err := discov.NewSubscriber(hosts, targets.GetEndpoints(target))
	if err != nil {
		return nil, err
	}

	update := func() {
		var addrs []resolver.Address
		for _, val := range subset(sub.Values(), subsetSize) {
			addrs = append(addrs, resolver.Address{
				Addr: val,
			})
		}
		if err := cc.UpdateState(resolver.State{
			Addresses: addrs,
		}); err != nil {
			logx.Error(err)
		}
	}
	sub.AddListener(update)
	update()

	return &nopResolver{cc: cc}, nil
}

func (b *discovBuilder) Scheme() string {
	return DiscovScheme
}

discov.NewSubscriber 方法调用 internal.GetRegistry().Monitor 最后调用 Registry.monitor 方法进行监视cluster.getClient 拿到 etcd 连接cluster.load 作为第一次载入数据cluster.watch 去 watch 监听 etcd 前缀 key 的改动

func (c *cluster) monitor(key string, l UpdateListener) error {
	c.lock.Lock()
	c.listeners[key] = append(c.listeners[key], l)
	c.lock.Unlock()

	cli, err := c.getClient()
	if err != nil {
		return err
	}

	c.load(cli, key)
	c.watchGroup.Run(func() {
		c.watch(cli, key)
	})

	return nil
}