grpc.Client

type ClientConn struct {
	// contains filtered or unexported fields
}

// NewClient creates a new gRPC "channel" for the target URI provided.  No I/O
// is performed.  Use of the ClientConn for RPCs will automatically cause it to
// connect.  Connect may be used to manually create a connection, but for most
// users this is unnecessary.
//
// The target name syntax is defined in
// https://github.com/grpc/grpc/blob/master/doc/naming.md.  e.g. to use dns
// resolver, a "dns:///" prefix should be applied to the target.
//
// The DialOptions returned by WithBlock, WithTimeout,
// WithReturnConnectionError, and FailOnNonTempDialError are ignored by this
// function.
func NewClient(target string, opts ...DialOption) (conn *ClientConn, err error) {
	cc := &ClientConn{
		target: target,
		conns:  make(map[*addrConn]struct{}),
		dopts:  defaultDialOptions(),
	}

	cc.retryThrottler.Store((*retryThrottler)(nil))
	cc.safeConfigSelector.UpdateConfigSelector(&defaultConfigSelector{nil})
	cc.ctx, cc.cancel = context.WithCancel(context.Background())

	// Apply dial options.
	disableGlobalOpts := false
	for _, opt := range opts {
		if _, ok := opt.(*disableGlobalDialOptions); ok {
			disableGlobalOpts = true
			break
		}
	}

	if !disableGlobalOpts {
		for _, opt := range globalDialOptions {
			opt.apply(&cc.dopts)
		}
	}

	for _, opt := range opts {
		opt.apply(&cc.dopts)
	}

	// Determine the resolver to use.
	if err := cc.initParsedTargetAndResolverBuilder(); err != nil {
		return nil, err
	}

	for _, opt := range globalPerTargetDialOptions {
		opt.DialOptionForTarget(cc.parsedTarget.URL).apply(&cc.dopts)
	}

	chainUnaryClientInterceptors(cc)
	chainStreamClientInterceptors(cc)

	if err := cc.validateTransportCredentials(); err != nil {
		return nil, err
	}

	if cc.dopts.defaultServiceConfigRawJSON != nil {
		scpr := parseServiceConfig(*cc.dopts.defaultServiceConfigRawJSON, cc.dopts.maxCallAttempts)
		if scpr.Err != nil {
			return nil, fmt.Errorf("%s: %v", invalidDefaultServiceConfigErrPrefix, scpr.Err)
		}
		cc.dopts.defaultServiceConfig, _ = scpr.Config.(*ServiceConfig)
	}
	cc.mkp = cc.dopts.copts.KeepaliveParams

	if err = cc.initAuthority(); err != nil {
		return nil, err
	}

	// Register ClientConn with channelz. Note that this is only done after
	// channel creation cannot fail.
	cc.channelzRegistration(target)
	channelz.Infof(logger, cc.channelz, "parsed dial target is: %#v", cc.parsedTarget)
	channelz.Infof(logger, cc.channelz, "Channel authority set to %q", cc.authority)

	cc.csMgr = newConnectivityStateManager(cc.ctx, cc.channelz)
	cc.pickerWrapper = newPickerWrapper(cc.dopts.copts.StatsHandlers)

	cc.metricsRecorderList = stats.NewMetricsRecorderList(cc.dopts.copts.StatsHandlers)

	cc.initIdleStateLocked() // Safe to call without the lock, since nothing else has a reference to cc.
	cc.idlenessMgr = idle.NewManager((*idler)(cc), cc.dopts.idleTimeout)

	return cc, nil
}

// CanonicalTarget returns the canonical target string of the ClientConn.
func (cc *ClientConn) CanonicalTarget() string {
	return cc.parsedTarget.String()
}

func main() {
    // 配置ssl，"*.heliu.site"在实际开发中从浏览器中取获取，证书路径使用绝对路径
	creds, _ := credentials.NewClientTLSFromFile(
		"/root/workspace/learn-grpc/key/test.pem",
		"*.heliu.site",
	)

	var opts []grpc.DialOption
	// 不带TLS这里是grpc.WithTransportCredentials(insecure.NewCredentials())
	opts = append(opts, grpc.WithTransportCredentials(creds))
	opts = append(opts, grpc.WithPerRPCCredentials(&ClientTokenAuth{}))
	// 添加客户端拦截器
	opts = append(opts, grpc.WithUnaryInterceptor(interceptor.UnaryClientInterceptor()))
	// 添加流拦截器
	opts = append(opts, grpc.WithStreamInterceptor(interceptor.StreamClientInterceptor()))

	// 连接server端，使用ssl加密通信
	conn, err := grpc.NewClient("127.0.0.1:9090", opts...)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}

	defer conn.Close()

	// -----------  CanonicalTarget: dns:///127.0.0.1:9090  -----------
	log.Printf("CanonicalTarget: %s\n", conn.CanonicalTarget())
    
    // ...
}

// Close tears down the ClientConn and all underlying connections.
func (cc *ClientConn) Close() error {
	defer func() {
		cc.cancel()
		<-cc.csMgr.pubSub.Done()
	}()

	// Prevent calls to enter/exit idle immediately, and ensure we are not
	// currently entering/exiting idle mode.
	cc.idlenessMgr.Close()

	cc.mu.Lock()
	if cc.conns == nil {
		cc.mu.Unlock()
		return ErrClientConnClosing
	}

	conns := cc.conns
	cc.conns = nil
	cc.csMgr.updateState(connectivity.Shutdown)

	// We can safely unlock and continue to access all fields now as
	// cc.conns==nil, preventing any further operations on cc.
	cc.mu.Unlock()

	cc.resolverWrapper.close()
	// The order of closing matters here since the balancer wrapper assumes the
	// picker is closed before it is closed.
	cc.pickerWrapper.close()
	cc.balancerWrapper.close()

	<-cc.resolverWrapper.serializer.Done()
	<-cc.balancerWrapper.serializer.Done()

	for ac := range conns {
		ac.tearDown(ErrClientConnClosing)
	}
	cc.addTraceEvent("deleted")
	// TraceEvent needs to be called before RemoveEntry, as TraceEvent may add
	// trace reference to the entity being deleted, and thus prevent it from being
	// deleted right away.
	channelz.RemoveEntry(cc.channelz.ID)

	return nil
}

func main() {
    // 配置ssl，"*.heliu.site"在实际开发中从浏览器中取获取，证书路径使用绝对路径
	creds, _ := credentials.NewClientTLSFromFile(
		"/root/workspace/learn-grpc/key/test.pem",
		"*.heliu.site",
	)

	var opts []grpc.DialOption
	// 不带TLS这里是grpc.WithTransportCredentials(insecure.NewCredentials())
	opts = append(opts, grpc.WithTransportCredentials(creds))
	opts = append(opts, grpc.WithPerRPCCredentials(&ClientTokenAuth{}))
	// 添加客户端拦截器
	opts = append(opts, grpc.WithUnaryInterceptor(interceptor.UnaryClientInterceptor()))
	// 添加流拦截器
	opts = append(opts, grpc.WithStreamInterceptor(interceptor.StreamClientInterceptor()))

	// 连接server端，使用ssl加密通信
	conn, err := grpc.NewClient("127.0.0.1:9090", opts...)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}

	// -----------  Close  -----------
	defer conn.Close()

	log.Printf("CanonicalTarget: %s\n", conn.CanonicalTarget())
    
    // ...
}

// Connect causes all subchannels in the ClientConn to attempt to connect if
// the channel is idle.  Does not wait for the connection attempts to begin
// before returning.
//
// # Experimental
//
// Notice: This API is EXPERIMENTAL and may be changed or removed in a later
// release.
func (cc *ClientConn) Connect() {
	if err := cc.idlenessMgr.ExitIdleMode(); err != nil {
		cc.addTraceEvent(err.Error())
		return
	}
	// If the ClientConn was not in idle mode, we need to call ExitIdle on the
	// LB policy so that connections can be created.
	cc.mu.Lock()
	cc.balancerWrapper.exitIdle()
	cc.mu.Unlock()
}

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"time"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	conn, err := grpc.DialContext(ctx, "localhost:50051", grpc.WithBlock())
	if err != nil {
		fmt.Printf("Failed to dial: %v\n", err)
		return
	}
	defer conn.Close()

	// 等待连接状态从DOWN变为READY
	if conn.WaitForStateChange(ctx, connectivity.StateDown) {
		fmt.Println("Connection state changed to READY")
	} else {
		fmt.Println("Connection state change timeout")
	}

	// 在需要时重新连接
	conn.Connect()
}

// GetMethodConfig gets the method config of the input method.
// If there's an exact match for input method (i.e. /service/method), we return
// the corresponding MethodConfig.
// If there isn't an exact match for the input method, we look for the service's default
// config under the service (i.e /service/) and then for the default for all services (empty string).
//
// If there is a default MethodConfig for the service, we return it.
// Otherwise, we return an empty MethodConfig.
func (cc *ClientConn) GetMethodConfig(method string) MethodConfig {
	// TODO: Avoid the locking here.
	cc.mu.RLock()
	defer cc.mu.RUnlock()
	return getMethodConfig(cc.sc, method)
}

// GetState returns the connectivity.State of ClientConn.
func (cc *ClientConn) GetState() connectivity.State {
	return cc.csMgr.getState()
}

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"time"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	conn, err := grpc.DialContext(ctx, "localhost:50051", grpc.WithBlock())
	if err != nil {
		fmt.Printf("Failed to dial: %v\n", err)
		return
	}
	defer conn.Close()

	// 获取连接状态
	state := conn.GetState()
	fmt.Printf("Connection state: %s\n", state)

	// 假设在连接过程中遇到了短暂故障
	if conn.WaitForStateChange(ctx, connectivity.StateIdle) {
		fmt.Println("Connection state changed to READY")
	} else {
		fmt.Println("Connection state change timeout")
	}
}

// Invoke sends the RPC request on the wire and returns after response is
// received.  This is typically called by generated code.
//
// All errors returned by Invoke are compatible with the status package.
func (cc *ClientConn) Invoke(ctx context.Context, method string, args, reply any, opts ...CallOption) error {
	// allow interceptor to see all applicable call options, which means those
	// configured as defaults from dial option as well as per-call options
	opts = combine(cc.dopts.callOptions, opts)

	if cc.dopts.unaryInt != nil {
		return cc.dopts.unaryInt(ctx, method, args, reply, cc, invoke, opts...)
	}
	return invoke(ctx, method, args, reply, cc, opts...)
}

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"time"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	conn, err := grpc.DialContext(ctx, "localhost:50051", grpc.WithBlock())
	if err != nil {
		fmt.Printf("Failed to dial: %v\n", err)
		return
	}
	defer conn.Close()

	// 调用服务器端的单向RPC方法
	err = conn.Invoke(ctx, "MyService.MyMethod", nil, nil, grpc.FailOnNonTempDialError(true))
	if err != nil {
		fmt.Printf("Failed to invoke RPC: %v\n", err)
		return
	}

	// 处理响应（如果有的话）
	// ...
}

// NewStream creates a new Stream for the client side. This is typically
// called by generated code. ctx is used for the lifetime of the stream.
//
// To ensure resources are not leaked due to the stream returned, one of the following
// actions must be performed:
//
//  1. Call Close on the ClientConn.
//  2. Cancel the context provided.
//  3. Call RecvMsg until a non-nil error is returned. A protobuf-generated
//     client-streaming RPC, for instance, might use the helper function
//     CloseAndRecv (note that CloseSend does not Recv, therefore is not
//     guaranteed to release all resources).
//  4. Receive a non-nil, non-io.EOF error from Header or SendMsg.
//
// If none of the above happen, a goroutine and a context will be leaked, and grpc
// will not call the optionally-configured stats handler with a stats.End message.
func (cc *ClientConn) NewStream(ctx context.Context, desc *StreamDesc, method string, opts ...CallOption) (ClientStream, error) {
	// allow interceptor to see all applicable call options, which means those
	// configured as defaults from dial option as well as per-call options
	opts = combine(cc.dopts.callOptions, opts)

	if cc.dopts.streamInt != nil {
		return cc.dopts.streamInt(ctx, desc, cc, method, newClientStream, opts...)
	}
	return newClientStream(ctx, desc, cc, method, opts...)
}

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"time"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	conn, err := grpc.DialContext(ctx, "localhost:50051", grpc.WithBlock())
	if err != nil {
		fmt.Printf("Failed to dial: %v\n", err)
		return
	}
	defer conn.Close()

	// 创建一个新的流
	stream, err := conn.NewStream(ctx, &StreamDesc{
		// 流描述
	}, "MyService.MyMethod", grpc.FailOnNonTempDialError(true))
	if err != nil {
		fmt.Printf("Failed to create stream: %v\n", err)
		return
	}

	// 发送请求消息
	// ...

	// 接收响应消息
	// ...

	// 关闭流
	stream.CloseSend()
}

// ResetConnectBackoff wakes up all subchannels in transient failure and causes
// them to attempt another connection immediately.  It also resets the backoff
// times used for subsequent attempts regardless of the current state.
//
// In general, this function should not be used.  Typical service or network
// outages result in a reasonable client reconnection strategy by default.
// However, if a previously unavailable network becomes available, this may be
// used to trigger an immediate reconnect.
//
// # Experimental
//
// Notice: This API is EXPERIMENTAL and may be changed or removed in a
// later release.
func (cc *ClientConn) ResetConnectBackoff() {
	cc.mu.Lock()
	conns := cc.conns
	cc.mu.Unlock()
	for ac := range conns {
		ac.resetConnectBackoff()
	}
}

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"time"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	conn, err := grpc.DialContext(ctx, "localhost:50051", grpc.WithBlock())
	if err != nil {
		fmt.Printf("Failed to dial: %v\n", err)
		return
	}
	defer conn.Close()

	// 假设在连接过程中遇到了短暂故障
	if conn.WaitForStateChange(ctx, connectivity.StateIdle) {
		fmt.Println("Connection state changed to READY")
	} else {
		fmt.Println("Connection state change timeout")
	}

	// 网络故障恢复，重置连接退避
	conn.ResetConnectBackoff()

	// 再次尝试连接
	if conn.WaitForStateChange(ctx, connectivity.StateIdle) {
		fmt.Println("Connection state changed to READY")
	} else {
		fmt.Println("Connection state change timeout")
	}
}

// Target returns the target string of the ClientConn.
func (cc *ClientConn) Target() string {
	return cc.target
}

func main() {
	// 配置ssl，"*.heliu.site"在实际开发中从浏览器中取获取，证书路径使用绝对路径
	creds, _ := credentials.NewClientTLSFromFile(
		"/root/workspace/learn-grpc/key/test.pem",
		"*.heliu.site",
	)

	var opts []grpc.DialOption
	// 不带TLS这里是grpc.WithTransportCredentials(insecure.NewCredentials())
	opts = append(opts, grpc.WithTransportCredentials(creds))
	opts = append(opts, grpc.WithPerRPCCredentials(&ClientTokenAuth{}))
	// 添加客户端拦截器
	opts = append(opts, grpc.WithUnaryInterceptor(interceptor.UnaryClientInterceptor()))
	// 添加流拦截器
	opts = append(opts, grpc.WithStreamInterceptor(interceptor.StreamClientInterceptor()))

	// 连接server端，使用ssl加密通信
	conn, err := grpc.NewClient("127.0.0.1:9090", opts...)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}

	defer conn.Close()

	// Target(): 127.0.0.1:9090
	log.Printf("Target(): %s\n", conn.Target())

	// 建立连接
	client := pb.NewSayHelloClient(conn)
    
    // ...
}

// WaitForStateChange waits until the connectivity.State of ClientConn changes from sourceState or
// ctx expires. A true value is returned in former case and false in latter.
func (cc *ClientConn) WaitForStateChange(ctx context.Context, sourceState connectivity.State) bool {
	ch := cc.csMgr.getNotifyChan()
	if cc.csMgr.getState() != sourceState {
		return true
	}
	select {
	case <-ctx.Done():
		return false
	case <-ch:
		return true
	}
}

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"time"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	conn, err := grpc.DialContext(ctx, "localhost:50051", grpc.WithBlock())
	if err != nil {
		fmt.Printf("Failed to dial: %v\n", err)
		return
	}
	defer conn.Close()

	// 等待连接状态从DOWN变为READY
	if conn.WaitForStateChange(ctx, connectivity.StateDown) {
		fmt.Println("Connection state changed to READY")
	} else {
		fmt.Println("Connection state change timeout")
	}
}

type DialOption interface {
    apply(*dialOptions)
}

// WithAuthority returns a DialOption that specifies the value to be used as the
// :authority pseudo-header and as the server name in authentication handshake.
func WithAuthority(a string) DialOption {
    return newFuncDialOption(func(o *dialOptions) {
        o.authority = a
    })
}

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"time"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	// 指定要连接的服务器的权威信息
	opts := []grpc.DialOption{
		grpc.WithAuthority("example.com:50051"),
	}

	conn, err := grpc.DialContext(ctx, "localhost:50051", opts...)
	if err != nil {
		fmt.Printf("Failed to dial: %v\n", err)
		return
	}
	defer conn.Close()

	// 客户端可以继续使用这个连接进行RPC调用
	// ...
}

// WithChainStreamInterceptor returns a DialOption that specifies the chained
// interceptor for streaming RPCs. The first interceptor will be the outer most,
// while the last interceptor will be the inner most wrapper around the real call.
// All interceptors added by this method will be chained, and the interceptor
// defined by WithStreamInterceptor will always be prepended to the chain.
func WithChainStreamInterceptor(interceptors ...StreamClientInterceptor) DialOption {
    return newFuncDialOption(func(o *dialOptions) {
        o.chainStreamInts = append(o.chainStreamInts, interceptors...)
    })
}

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"time"
)

// 定义一个简单的StreamClientInterceptor
func loggingInterceptor(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, opts ...grpc.CallOption) (grpc.ClientStream, error) {
	stream, err := cc.NewStream(ctx, desc, method, opts...)
	if err != nil {
		return nil, err
	}

	return &loggingStream{stream}, nil
}

type loggingStream struct {
	grpc.ClientStream
}

func (s *loggingStream) SendMsg(m interface{}) error {
	fmt.Printf("Sending message: %v\n", m)
	return s.ClientStream.SendMsg(m)
}

func (s *loggingStream) RecvMsg(m interface{}) error {
	fmt.Printf("Received message: %v\n", m)
	return s.ClientStream.RecvMsg(m)
}

func (s *loggingStream) CloseSend() error {
	fmt.Println("Closing send side of the stream")
	return s.ClientStream.CloseSend()
}

func (s *loggingStream) Context() context.Context {
	return s.ClientStream.Context()
}

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	// 创建一个包含拦截器的DialOption
	opts := []grpc.DialOption{
		grpc.WithChainStreamInterceptor(loggingInterceptor),
	}

	conn, err := grpc.DialContext(ctx, "localhost:50051", opts...)
	if err != nil {
		fmt.Printf("Failed to dial: %v\n", err)
		return
	}
	defer conn.Close()

	// 客户端可以继续使用这个连接进行RPC调用
	// ...
}

// WithChainUnaryInterceptor returns a DialOption that specifies the chained
// interceptor for unary RPCs. The first interceptor will be the outer most,
// while the last interceptor will be the inner most wrapper around the real call.
// All interceptors added by this method will be chained, and the interceptor
// defined by WithUnaryInterceptor will always be prepended to the chain.
func WithChainUnaryInterceptor(interceptors ...UnaryClientInterceptor) DialOption {
    return newFuncDialOption(func(o *dialOptions) {
        o.chainUnaryInts = append(o.chainUnaryInts, interceptors...)
    })
}

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"time"
)

// 定义一个简单的UnaryClientInterceptor
func loggingInterceptor(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
	fmt.Printf("Sending request: %v\n", req)
	err := invoker(ctx, method, req, reply, cc, opts...)
	if err != nil {
		return err
	}
	fmt.Printf("Received response: %v\n", reply)
	return nil
}

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	// 创建一个包含拦截器的DialOption
	opts := []grpc.DialOption{
		grpc.WithChainUnaryInterceptor(loggingInterceptor),
	}

	conn, err := grpc.DialContext(ctx, "localhost:50051", opts...)
	if err != nil {
		fmt.Printf("Failed to dial: %v\n", err)
		return
	}
	defer conn.Close()

	// 客户端可以继续使用这个连接进行RPC调用
	// ...
}

// WithChannelzParentID returns a DialOption that specifies the channelz ID of
// current ClientConn's parent. This function is used in nested channel creation
// (e.g. grpclb dial).
//
// # Experimental
//
// Notice: This API is EXPERIMENTAL and may be changed or removed in a
// later release.
func WithChannelzParentID(c channelz.Identifier) DialOption {
    return newFuncDialOption(func(o *dialOptions) {
        o.channelzParent = c
    })
}

package main

import (
	"context"
	"log"

	"google.golang.org/grpc"
	"google.golang.org/grpc/channelz"
)

func main() {
	serverAddr := "localhost:50051"

	// 创建一个channelz标识符
	parentID := channelz.Identifier{
		ChannelType: channelz.CHANNEL_TYPE_GRPC_CLIENT,
		Address:     "localhost:50051",
	}

	// 创建gRPC连接时应用WithChannelzParentID选项
	conn, err := grpc.Dial(serverAddr,
		grpc.WithInsecure(),
		grpc.WithChannelzParentID(parentID),
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()

	// ... 使用连接进行后续操作 ...
}

// WithConnectParams configures the ClientConn to use the provided ConnectParams
// for creating and maintaining connections to servers.
//
// The backoff configuration specified as part of the ConnectParams overrides
// all defaults specified in
// https://github.com/grpc/grpc/blob/master/doc/connection-backoff.md. Consider
// using the backoff.DefaultConfig as a base, in cases where you want to
// override only a subset of the backoff configuration.
func WithConnectParams(p ConnectParams) DialOption {
    return newFuncDialOption(func(o *dialOptions) {
        o.bs = internalbackoff.Exponential{Config: p.Backoff}
        o.minConnectTimeout = func() time.Duration {
            return p.MinConnectTimeout
        }
    })
}

package main

import (
	"context"
	"log"
	"time"

	"google.golang.org/grpc"
)

type ConnectParams struct {
	Backoff BackoffConfig
	MinConnectTimeout time.Duration
}

func main() {
	serverAddr := "localhost:50051"

	// 设置连接参数
	connectParams := ConnectParams{
		Backoff: BackoffConfig{
			InitialBackoff: 100 * time.Millisecond,
			MaxBackoff:     1 * time.Second,
			Multiplier:     1.5,
		},
		MinConnectTimeout: 10 * time.Second,
	}

	// 创建gRPC连接时应用WithConnectParams选项
	conn, err := grpc.Dial(serverAddr,
		grpc.WithInsecure(),
		grpc.WithConnectParams(connectParams),
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()

	// ... 使用连接进行后续操作 ...
}

// WithContextDialer returns a DialOption that sets a dialer to create
// connections. If FailOnNonTempDialError() is set to true, and an error is
// returned by f, gRPC checks the error's Temporary() method to decide if it
// should try to reconnect to the network address.
//
// Note: All supported releases of Go (as of December 2023) override the OS
// defaults for TCP keepalive time and interval to 15s. To enable TCP keepalive
// with OS defaults for keepalive time and interval, use a net.Dialer that sets
// the KeepAlive field to a negative value, and sets the SO_KEEPALIVE socket
// option to true from the Control field. For a concrete example of how to do
// this, see internal.NetDialerWithTCPKeepalive().
//
// For more information, please see [issue 23459] in the Go github repo.
//
// [issue 23459]: https://github.com/golang/go/issues/23459
func WithContextDialer(f func(context.Context, string) (net.Conn, error)) DialOption {
	return newFuncDialOption(func(o *dialOptions) {
		o.copts.Dialer = f
	})
}

package main

import (
	"context"
	"log"
	"net"
	"time"

	"google.golang.org/grpc"
)

func main() {
	serverAddr := "localhost:50051"

	// 创建一个自定义的拨号器函数
	dialer := func(ctx context.Context, addr string) (net.Conn, error) {
		d := net.Dialer{
			Timeout:   10 * time.Second,
			KeepAlive: 15 * time.Second,
		}
		return d.DialContext(ctx, "tcp", addr)
	}

	// 创建gRPC连接时应用WithContextDialer选项
	conn, err := grpc.Dial(serverAddr,
		grpc.WithInsecure(),
		grpc.WithContextDialer(dialer),
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()

	// ... 使用连接进行后续操作 ...
}

// WithCredentialsBundle returns a DialOption to set a credentials bundle for
// the ClientConn.WithCreds. This should not be used together with
// WithTransportCredentials.
//
// # Experimental
//
// Notice: This API is EXPERIMENTAL and may be changed or removed in a
// later release.
func WithCredentialsBundle(b credentials.Bundle) DialOption {
    return newFuncDialOption(func(o *dialOptions) {
        o.copts.CredsBundle = b
    })
}

package main

import (
	"context"
	"log"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
)

func main() {
	serverAddr := "localhost:50051"

	// 创建一个凭证捆绑包，包含TLS证书和客户端证书
	bundle := credentials.NewBundle()
	bundle.Add("path/to/client_cert.pem", "path/to/client_key.pem", "path/to/ca_cert.pem")

	// 创建gRPC连接时应用WithCredentialsBundle选项
	conn, err := grpc.Dial(serverAddr,
		grpc.WithInsecure(), // 或者使用其他传输凭证选项
		grpc.WithCredentialsBundle(bundle),
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()

	// ... 使用连接进行后续操作 ...
}

// WithDefaultCallOptions returns a DialOption which sets the default
// CallOptions for calls over the connection.
func WithDefaultCallOptions(cos ...CallOption) DialOption {
    return newFuncDialOption(func(o *dialOptions) {
        o.callOptions = append(o.callOptions, cos...)
    })
}

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"time"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	// 设置RPC调用的默认超时时间为5秒
	opts := []grpc.DialOption{
		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(1024 * 1024)), // 设置最大接收消息大小为1MB
	}

	conn, err := grpc.DialContext(ctx, "localhost:50051", opts...)
	if err != nil {
		fmt.Printf("Failed to dial: %v\n", err)
		return
	}
	defer conn.Close()

	// 客户端可以继续使用这个连接进行RPC调用
	// ...
}

// WithDefaultServiceConfig returns a DialOption that configures the default
// service config, which will be used in cases where:
//
// 1. WithDisableServiceConfig is also used, or
//
// 2. The name resolver does not provide a service config or provides an
// invalid service config.
//
// The parameter s is the JSON representation of the default service config.
// For more information about service configs, see:
// https://github.com/grpc/grpc/blob/master/doc/service_config.md
// For a simple example of usage, see:
// examples/features/load_balancing/client/main.go
func WithDefaultServiceConfig(s string) DialOption {
	return newFuncDialOption(func(o *dialOptions) {
		o.defaultServiceConfigRawJSON = &s
	})
}

package main

import (
	"context"
	"log"

	"google.golang.org/grpc"
)

func main() {
	serverAddr := "localhost:50051"

	// 设置默认服务配置的JSON表示形式
	defaultServiceConfigJSON := `{
		"loadBalancingConfig": {
			"grpclb": {
				"childPolicy": [
					{
						"round_robin": {}
					}
				]
			}
		}
	}`

	// 创建gRPC连接时应用WithDefaultServiceConfig选项
	conn, err := grpc.Dial(serverAddr,
		grpc.WithInsecure(),
		grpc.WithDefaultServiceConfig(defaultServiceConfigJSON),
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()

	// ... 使用连接进行后续操作 ...
}

// WithDisableHealthCheck disables the LB channel health checking for all
// SubConns of this ClientConn.
//
// # Experimental
//
// Notice: This API is EXPERIMENTAL and may be changed or removed in a
// later release.
func WithDisableHealthCheck() DialOption {
	return newFuncDialOption(func(o *dialOptions) {
		o.disableHealthCheck = true
	})
}

package main

import (
	"context"
	"log"

	"google.golang.org/grpc"
)

func main() {
	serverAddr := "localhost:50051"

	// 创建gRPC连接时应用WithDisableHealthCheck选项
	conn, err := grpc.Dial(serverAddr,
		grpc.WithInsecure(),
		grpc.WithDisableHealthCheck(),
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()

	// ... 使用连接进行后续操作 ...
}

// WithDisableRetry returns a DialOption that disables retries, even if the
// service config enables them.  This does not impact transparent retries, which
// will happen automatically if no data is written to the wire or if the RPC is
// unprocessed by the remote server.
func WithDisableRetry() DialOption {
	return newFuncDialOption(func(o *dialOptions) {
		o.disableRetry = true
	})
}

package main

import (
	"context"
	"log"

	"google.golang.org/grpc"
)

func main() {
	serverAddr := "localhost:50051"

	// 创建gRPC连接时应用WithDisableRetry选项
	conn, err := grpc.Dial(serverAddr,
		grpc.WithInsecure(),
		grpc.WithDisableRetry(),
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()

	// ... 使用连接进行后续操作 ...
}

// WithDisableServiceConfig returns a DialOption that causes gRPC to ignore any
// service config provided by the resolver and provides a hint to the resolver
// to not fetch service configs.
//
// Note that this dial option only disables service config from resolver. If
// default service config is provided, gRPC will use the default service config.
func WithDisableServiceConfig() DialOption {
	return newFuncDialOption(func(o *dialOptions) {
		o.disableServiceConfig = true
	})
}

package main

import (
	"context"
	"log"

	"google.golang.org/grpc"
)

func main() {
	serverAddr := "localhost:50051"

	// 创建gRPC连接时应用WithDisableServiceConfig选项
	conn, err := grpc.Dial(serverAddr,
		grpc.WithInsecure(),
		grpc.WithDisableServiceConfig(),
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()

	// ... 使用连接进行后续操作 ...
}

// WithIdleTimeout returns a DialOption that configures an idle timeout for the
// channel. If the channel is idle for the configured timeout, i.e there are no
// ongoing RPCs and no new RPCs are initiated, the channel will enter idle mode
// and as a result the name resolver and load balancer will be shut down. The
// channel will exit idle mode when the Connect() method is called or when an
// RPC is initiated.
//
// A default timeout of 30 minutes will be used if this dial option is not set
// at dial time and idleness can be disabled by passing a timeout of zero.
//
// # Experimental
//
// Notice: This API is EXPERIMENTAL and may be changed or removed in a
// later release.
func WithIdleTimeout(d time.Duration) DialOption {
	return newFuncDialOption(func(o *dialOptions) {
		o.idleTimeout = d
	})
}

package main

import (
	"context"
	"log"
	"time"

	"google.golang.org/grpc"
)

func main() {
	serverAddr := "localhost:50051"

	// 设置空闲超时时间为10分钟
	idleTimeout := 10 * time.Minute

	conn, err := grpc.Dial(serverAddr,
		grpc.WithInsecure(),
		grpc.WithIdleTimeout(idleTimeout),
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()

	// ... 使用连接进行后续操作 ...
}

// WithInitialConnWindowSize returns a DialOption which sets the value for
// initial window size on a connection. The lower bound for window size is 64K
// and any value smaller than that will be ignored.
func WithInitialConnWindowSize(s int32) DialOption {
	return newFuncDialOption(func(o *dialOptions) {
		o.copts.InitialConnWindowSize = s
	})
}

package main

import (
	"context"
	"log"

	"google.golang.org/grpc"
)

func main() {
	serverAddr := "localhost:50051"

	// 设置初始连接窗口大小为2MB
	initialConnWindowSize := int32(2 << 20) // 2MB in bytes

	conn, err := grpc.Dial(serverAddr,
		grpc.WithInsecure(),
		grpc.WithInitialConnWindowSize(initialConnWindowSize),
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()

	// ... 使用连接进行后续操作 ...
}

// WithInitialWindowSize returns a DialOption which sets the value for initial
// window size on a stream. The lower bound for window size is 64K and any value
// smaller than that will be ignored.
func WithInitialWindowSize(s int32) DialOption {
	return newFuncDialOption(func(o *dialOptions) {
		o.copts.InitialWindowSize = s
	})
}

package main

import (
	"context"
	"log"

	"google.golang.org/grpc"
)

func main() {
	serverAddr := "localhost:50051"

	// 设置初始窗口大小为1MB
	initialWindowSize := int32(1 << 20) // 1MB in bytes

	conn, err := grpc.Dial(serverAddr,
		grpc.WithInsecure(),
		grpc.WithInitialWindowSize(initialWindowSize),
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()

	// ... 使用连接进行后续操作 ...
}

// WithKeepaliveParams returns a DialOption that specifies keepalive parameters
// for the client transport.
func WithKeepaliveParams(kp keepalive.ClientParameters) DialOption {
	if kp.Time < internal.KeepaliveMinPingTime {
		logger.Warningf("Adjusting keepalive ping interval to minimum period of %v", internal.KeepaliveMinPingTime)
		kp.Time = internal.KeepaliveMinPingTime
	}
	return newFuncDialOption(func(o *dialOptions) {
		o.copts.KeepaliveParams = kp
	})
}

package main

import (
	"context"
	"log"
	"time"

	"google.golang.org/grpc"
	"google.golang.org/grpc/keepalive"
)

func main() {
	serverAddr := "localhost:50051"

	// 设置保活参数
	keepaliveParams := keepalive.ClientParameters{
		Time:                10 * time.Second, // 发送保活ping的时间间隔
		Timeout:             5 * time.Second,  // 等待服务器响应保活ping的超时时间
		PermitWithoutStream: true,             // 即使没有活动流也允许发送保活ping
	}

	conn, err := grpc.Dial(serverAddr,
		grpc.WithInsecure(),
		grpc.WithKeepaliveParams(keepaliveParams),
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()

	// ... 使用连接进行后续操作 ...
}

// WithMaxCallAttempts returns a DialOption that configures the maximum number
// of attempts per call (including retries and hedging) using the channel.
// Service owners may specify a higher value for these parameters, but higher
// values will be treated as equal to the maximum value by the client
// implementation. This mitigates security concerns related to the service
// config being transferred to the client via DNS.
//
// A value of 5 will be used if this dial option is not set or n < 2.
func WithMaxCallAttempts(n int) DialOption {
	return newFuncDialOption(func(o *dialOptions) {
		if n < 2 {
			n = defaultMaxCallAttempts
		}
		o.maxCallAttempts = n
	})
}

package main

import (
	"context"
	"log"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

func main() {
	serverAddr := "localhost:50051"
	maxCallAttempts := 3 // 设置最大尝试次数为3

	conn, err := grpc.Dial(serverAddr,
		grpc.WithTransportCredentials(insecure.NewCredentials()),
		grpc.WithMaxCallAttempts(maxCallAttempts),
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()

	// ... 使用连接进行后续操作 ...
}

// WithMaxHeaderListSize returns a DialOption that specifies the maximum
// (uncompressed) size of header list that the client is prepared to accept.
func WithMaxHeaderListSize(s uint32) DialOption {
	return MaxHeaderListSizeDialOption{
		MaxHeaderListSize: s,
	}
}