func main() {    	// 通过默认配置获取一个服务发现组件的实例    	// 方法内部有通过默认配置创建一个 nacos 客户端，方便后续与 nacos 交互	r, err := resolver.NewDefaultNacosResolver()	if err != nil {		panic(err)	}	newClient := hello.MustNewClient(		"Hello",        		// 以 WithOption 的方式服务发现实例		client.WithResolver(r),    		client.WithRPCTimeout(time.Second*3),	)	for {		resp, err := newClient.Echo(context.Background(), &api.Request{Message: "Hello"})		if err != nil {			log.Fatal(err)		}		log.Println(resp)		time.Sleep(time.Second)	}}

 go run example/custom-config/server/main.go

 go run example/custom-config/client/main.go

type kClient struct {	svcInfo *serviceinfo.ServiceInfo	mws     []endpoint.Middleware	eps     endpoint.Endpoint	sEps    endpoint.Endpoint	opt     *client.Options	lbf     *lbcache.BalancerFactory
	inited bool	closed bool}

type BalancerFactory struct {	Hookable	opts       Options	cache      sync.Map // key -> LoadBalancer	resolver   discovery.Resolver	balancer   loadbalance.Loadbalancer	rebalancer loadbalance.Rebalancer	sfg        singleflight.Group}

func (kc *kClient) initLBCache() error {	resolver := kc.opt.Resolver	if resolver == nil {		// 生成一个携带 kerrors.ErrNoResolver 错误的 resolver	}
	balancer := kc.opt.Balancer
	// 默认使用基于权重的负载均衡	// 参看 https://www.cloudwego.io/zh/docs/kitex/tutorials/basic-feature/loadbalance/	if balancer == nil {		balancer = loadbalance.NewWeightedBalancer()	}
	cacheOpts := lbcache.Options{DiagnosisService: kc.opt.DebugService}	if kc.opt.BalancerCacheOpt != nil {		cacheOpts = *kc.opt.BalancerCacheOpt	}
	// 1、生成一个 BalancerFactory 对象；	// 2、检查 cacheOpts 刷新时间间隔设置，若没有则默认 5s	// 3、检查 cacheOpts 缓存过期时间设置，若没有则默认 15s	// 4、异步协程定期标记服务已发现的信息过期，具体在在 BalancerFactory.cache 字段	// 5、最后将 resolver + balancer + cacheOpts.RefreshInterval + cacheOpts.ExpireInterval 为 key，	// 缓存到 balancerFactories 的 sync.Map 上	kc.lbf = lbcache.NewBalancerFactory(resolver, balancer, cacheOpts)
	// ...	return nil}

func NewBalancerFactory(resolver discovery.Resolver, balancer loadbalance.Loadbalancer, opts Options) *BalancerFactory {	// 检查刷新时间间隔，若没有则默认 5s	// 检查缓存过期时间，若没有则默认 15s	opts.check()
	// 构建一个当前负载均衡规则的缓存 key	uniqueKey := cacheKey(resolver.Name(), balancer.Name(), opts)
	// 规则缓存是否存在	val, ok := balancerFactories.Load(uniqueKey)	if ok {		return val.(*BalancerFactory)	}
	// 若没有则缓存一次	val, _, _ = balancerFactoriesSfg.Do(uniqueKey, func() (interface{}, error) {		b := &BalancerFactory{			opts:     opts,			resolver: resolver,			balancer: balancer,		}		if rb, ok := balancer.(loadbalance.Rebalancer); ok {			hrb := newHookRebalancer(rb)			b.rebalancer = hrb			b.Hookable = hrb		} else {			b.Hookable = noopHookRebalancer{}		}
		// 根据 opts.ExpireInterval 定期清理已发现服务的缓存		// 主要操作 BalancerFactory.cache		go b.watcher()
		balancerFactories.Store(uniqueKey, b)		return b, nil	})
	return val.(*BalancerFactory)}

// Middleware deal with input Endpoint and output Endpoint.type Middleware func(Endpoint) Endpoint
// 在这里，我们只需要知道 newResolveMWBuilder 返回了 endpoint.Middleware 的函数即可// 具体逻辑我们稍后再分析func (kc *kClient) initMiddlewares(ctx context.Context) {	// ...	if kc.opt.Proxy == nil {		// 自定义服务发现		kc.mws = append(kc.mws, newResolveMWBuilder(kc.lbf)(ctx))		// ...	} else {		if kc.opt.Resolver != nil { // 自定义服务发现			kc.mws = append(kc.mws, newResolveMWBuilder(kc.lbf)(ctx))		}		kc.mws = append(kc.mws, newProxyMW(kc.opt.Proxy))	}	// ...}
// 经过以上初始化过程，是组装了一系列需要用到的 Middleware 到 kClient.mws 这个切片里

func (kc *kClient) buildInvokeChain() error {	// 构建一个发送请求并接收响应的 Endpoint，主要与远端交互	innerHandlerEp, err := kc.invokeHandleEndpoint()	if err != nil {		return err	}
	// 把调用处理逻辑与上一步处理好的所有 Middleware 串联起来，放在 kClient.eps 里	kc.eps = endpoint.Chain(kc.mws...)(innerHandlerEp)
	// ...	return nil}

type RPCInfo interface {	From() EndpointInfo	To() EndpointInfo	Invocation() Invocation	Config() RPCConfig	Stats() RPCStats}
type Balancer struct {	b            *BalancerFactory	target       string       // a description returned from the resolver's Target method	res          atomic.Value // newest and previous discovery result	expire       int32        // 0 = normal, 1 = expire and collect next ticker	sharedTicker *sharedTicker}
	// 获取到 RPC 相关信息	rpcInfo := rpcinfo.GetRPCInfo(ctx)	dest := rpcInfo.To()	if dest == nil {		return kerrors.ErrNoDestService	}
	remote := remoteinfo.AsRemoteInfo(dest)	if remote == nil {		err := fmt.Errorf("unsupported target EndpointInfo type: %T", dest)		return kerrors.ErrInternalException.WithCause(err)	}	if remote.GetInstance() != nil {		return next(ctx, request, response)	}
	// 1、从 BalancerFactory 获取目标服务对应的均衡器 Balancer 等信息	// 2、这里也是有缓存的，刷新机制是根据设置的 cacheOpts.RefreshInterval 时间定时刷新	// 参照 Balancer.refresh 的代码(https://github.com/cloudwego/kitex/blob/develop/pkg/loadbalance/lbcache/cache.go#L184)	// 3、根据不同的 dest 可以得到不同的 Balancer	lb, err := lbf.Get(ctx, dest)	if err != nil {		return kerrors.ErrServiceDiscovery.WithCause(err)	}
	// picker 是 BalancerFactory.balancer 设置的均衡器对应的	// picker 的 主要逻辑是从一组服务实例信息中选取其中一个，如默认的 WeightedRandom 基于权重的随机	picker := lb.GetPicker()	if r, ok := picker.(internal.Reusable); ok {		defer r.Recycle()	}	var lastErr error	for {		select {		case <-ctx.Done():			return kerrors.ErrRPCTimeout		default:		}		// 具体的选取其中一个节点，代码例如可以参考： randomPicker.Next    		// https://github.com/cloudwego/kitex/blob/develop/pkg/loadbalance/weighted_random.go#L56		ins := picker.Next(ctx, request)		if ins == nil {			return kerrors.ErrNoMoreInstance.WithCause(fmt.Errorf("last error: %w", lastErr))		}		remote.SetInstance(ins)
		if err = next(ctx, request, response); err != nil && retryable(err) {			lastErr = err			continue		}		return err	}

// 根据目标服务信息获取对应的解析策略func (b *BalancerFactory) Get(ctx context.Context, target rpcinfo.EndpointInfo) (*Balancer, error) {	desc := b.resolver.Target(ctx, target)	val, ok := b.cache.Load(desc)	if ok {		return val.(*Balancer), nil	}
	val, err, _ := b.sfg.Do(desc, func() (interface{}, error) {		// 从注册中心获取服务实例列表		res, err := b.resolver.Resolve(ctx, desc)		if err != nil {			return nil, err		}		// 重命名发现结果的缓存 key		renameResultCacheKey(&res, b.resolver.Name())		bl := &Balancer{			b:      b,			target: desc,		}		bl.res.Store(res)
		// 定时刷新服务发现的结果，刷新逻辑在 sharedTicker.add 中开了一个协程		bl.sharedTicker = getSharedTicker(bl, b.opts.RefreshInterval)
		b.cache.Store(desc, bl)		return bl, nil	})	if err != nil {		return nil, err	}	return val.(*Balancer), nil}