Detailed explanation of the use of interceptors in gRPC

// UnaryInterceptor returns a ServerOption that sets the UnaryServerInterceptor for the
// server. Only one unary interceptor can be installed. The construction of multiple
// interceptors (., chaining) can be implemented at the caller.
func UnaryInterceptor(i UnaryServerInterceptor) ServerOption {
	return newFuncServerOption(func(o *serverOptions) {
		if  != nil {
			panic("The unary server interceptor was already set and may not be reset.")
		}
		 = i
	})
}

// UnaryServerInterceptor provides a hook to intercept the execution of a unary RPC on the server. info
// contains all the information of this RPC the interceptor can operate on. And handler // is the wrapper of the service method implementation. It is the responsibility of the // interceptor to invoke handler to complete the RPC.
type UnaryServerInterceptor func(ctx , req interface{}, info *UnaryServerInfo, handler UnaryHandler) (resp interface{}, err error)

// StreamInterceptor returns a ServerOption that sets the StreamServerInterceptor for the
// server. Only one stream interceptor can be installed.
func StreamInterceptor(i StreamServerInterceptor) ServerOption {
	return newFuncServerOption(func(o *serverOptions) {
		if  != nil {
			panic("The stream server interceptor was already set and may not be reset.")
		}
		 = i
	})
}

// StreamServerInterceptor provides a hook to intercept the execution of a streaming RPC //on the  contains all the information of this RPC the interceptor can operate //on. And handler is the service method implementation. It is the responsibility of the // interceptor to invoke handler to complete the RPC.
type StreamServerInterceptor func(srv interface{}, ss ServerStream, info *StreamServerInfo, handler StreamHandler) error

// One-yuan interceptorfunc Unary()  {
	return func(
		ctx ,
		req interface{},
		info *,
		handler ) (interface{}, error) {
		("---------> the unaryServerInterceptor: ", )
		err := (ctx, )//Implement the logic of intercept verification and implement it yourself. I am in the complete code I intercepted here, and you can also refer to the code on my gitee		if err != nil {
			return nil, err
		}
		return handler(ctx, req)
	}
}
//stream interceptorfunc Stream()  {
	return func(
		srv interface{},
		stream ,
		info *,
		handler ) error {
		("--------->the streamServerInterceptor: ", )
		err := ((), )//Implement the logic of intercept verification and implement it yourself. I am in the complete code I intercepted here, and you can also refer to the code on my gitee		if err != nil {
			return err
		}
		return handler(srv, stream)
	}
}

serverOptions := []{
	(Unary()),
	(Stream()),
}
grpcServer := (serverOptions...)

// WithUnaryInterceptor returns a DialOption that specifies the interceptor for
// unary RPCs.
func WithUnaryInterceptor(f UnaryClientInterceptor) DialOption {
	return newFuncDialOption(func(o *dialOptions) {
		 = f
	})
}

// UnaryClientInterceptor intercepts the execution of a unary RPC on the client.
// Unary interceptors can be specified as a DialOption, using
// WithUnaryInterceptor() or WithChainUnaryInterceptor(), when creating a
// ClientConn. When a unary interceptor(s) is set on a ClientConn, gRPC
// delegates all unary RPC invocations to the interceptor, and it is the
// responsibility of the interceptor to call invoker to complete the processing
// of the RPC.
//
// method is the RPC name. req and reply are the corresponding request and
// response messages. cc is the ClientConn on which the RPC was invoked. invoker
// is the handler to complete the RPC and it is the responsibility of the
// interceptor to call it. opts contain all applicable call options, including
// defaults from the ClientConn as well as per-call options.
//
// The returned error must be compatible with the status package.
type UnaryClientInterceptor func(ctx , method string, req, reply interface{}, cc *ClientConn, invoker UnaryInvoker, opts ...CallOption) error

// WithStreamInterceptor returns a DialOption that specifies the interceptor for
// streaming RPCs.
func WithStreamInterceptor(f StreamClientInterceptor) DialOption {
	return newFuncDialOption(func(o *dialOptions) {
		 = f
	})
}

// StreamClientInterceptor intercepts the creation of a ClientStream. Stream
// interceptors can be specified as a DialOption, using WithStreamInterceptor()
// or WithChainStreamInterceptor(), when creating a ClientConn. When a stream
// interceptor(s) is set on the ClientConn, gRPC delegates all stream creations
// to the interceptor, and it is the responsibility of the interceptor to call
// streamer.
//
// desc contains a description of the stream. cc is the ClientConn on which the
// RPC was invoked. streamer is the handler to create a ClientStream and it is
// the responsibility of the interceptor to call it. opts contain all applicable
// call options, including defaults from the ClientConn as well as per-call
// options.
//
// StreamClientInterceptor may return a custom ClientStream to intercept all I/O
// operations. The returned error must be compatible with the status package.
type StreamClientInterceptor func(ctx , desc *StreamDesc, cc *ClientConn, method string, streamer Streamer, opts ...CallOption) (ClientStream, error)

func Unary()  {
	return func(
		ctx ,
		method string,
		req, reply interface{},
		conn *,
		invoker , //Callback function		opts ...,
	) error {
		("-------> unary interceptor: %s", method)
		if authMethods[method] { //If it is an intercepting method, add the token to the context before calling the actual rpc method. This storage requires intercepting method			return invoker(attachToken(ctx), method, req, reply, conn, opts...) // AttachToken appends token after the client intercepts the request.		}
		return invoker(ctx, method, req, reply, conn, opts...)
	}
}
// Stream returns a client interceptor to authenticate stream RPC
func Stream()  {
	return func(
		ctx ,
		desc *,
		conn *,
		method string,
		streamer ,
		opts ...,
	) (, error) {
		("-------> stream interceptor: %s", method)
		if [method] {
			return streamer(attachToken(ctx), desc, conn, method, opts...)
		}
		return streamer(ctx, desc, conn, method, opts...)
	}
}

conn2, err := (
	Address, //address	transportOption, //SSL/TLS certificate selection	(Unary()),
	(Stream()))
if err != nil {
	("cannot dial server: ", err)
}