go install github.com/cloudwego/kitex/tool/cmd/kitex@latest

go get -u github.com/cloudwego/kitex

syntax="proto3";

package idl;    // proto文件互相引用时需要指定package。不需要相互引用时，这一行可以不写
option go_package="math_service";    //生成go文件后对应的package名

message AddRequest {
    int32 left = 1;
    int32 right = 2;
}

message AddResponse {
    int32 sum = 1;
}

message SubRequest {
    int32 left = 1;
    int32 right = 2;
}

message SubResponse {
    int32 diff = 1;
}

service Math {
    rpc Add(AddRequest) returns (AddResponse);
    rpc Sub(SubRequest) returns (SubResponse);
}

kitex -module myKitex idl/math.proto

cd /my_kitex/server/
kitex -module myKitex -service easyimpr.math -use myKitex/kitex_gen  ../idl/math.proto

// Add implements the MathImpl interface.
func (s *MathImpl) Add(ctx context.Context, req *math_service.AddRequest) (resp *math_service.AddResponse, err error) {
	// TODO: Your code here...
	resp = &math_service.AddResponse{
		Sum: req.Left + req.Right,
	}
	return resp, nil
}

// Sub implements the MathImpl interface.
func (s *MathImpl) Sub(ctx context.Context, req *math_service.SubRequest) (resp *math_service.SubResponse, err error) {
	// TODO: Your code here...
	resp = &math_service.SubResponse{
		Diff: req.Left - req.Right,
	}
	return resp, nil
}

	addr, _ := net.ResolveTCPAddr("tcp", "127.0.0.1:5678")
	svr := math_service.NewServer(new(MathImpl), server.WithServiceAddr(addr))
	err := svr.Run()
	if err != nil {
		log.Println(err.Error())
	}

cd ./my_kitex/client/

import (
	"context"
	"fmt"
	"log"
	"myKitex/kitex_gen/math_service"
	"myKitex/kitex_gen/math_service/math"

	"github.com/cloudwego/kitex/client"
)

func main() {
	//这个函数是之前生成的脚手架代码中的函数，用于创建一个客户端，前面的是服务名称，后面的是地址
	client, err := math.NewClient("easyimpr.math", client.WithHostPorts("127.0.0.1:5678"))
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	//定义请求参数
	request := math_service.SubRequest{Left: 9, Right: 1}
	//调用方法
	response, err := client.Sub(context.Background(), &request)
	if err != nil {
		log.Fatalf("failed to call sub: %v", err)
	}
	//打印结果
	fmt.Println(response.Diff)
}

	"github.com/cloudwego/kitex/pkg/klog"

	klog.SetLevel(klog.LevelInfo) //大于等于info的日志会被打印出来
	klog.Debug("我是debug")
	klog.Info("我是info")
	klog.Warn("我是warn")
	klog.Error("我是error")

	fout, err := os.OpenFile("./log/server.log", os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
	if err != nil {
		panic(err)
	}
	defer fout.Close()
	klog.SetOutput(fout)

etcd "github.com/kitex-contrib/registry-etcd" //起了个别名为etcd

addr, _ := net.ResolveTCPAddr("tcp", "127.0.0.1:5678")
reg, err := etcd.NewEtcdRegistry([]string{"127.0.0.1:2379"}) //线上需要使用密码，用NewEtcdRegistryWithAuth
	if err != nil {
		klog.Fatal("failed to create registry: %v", err)
	}
	svr := math_service.NewServer(new(MathImpl),
		server.WithServiceAddr(addr),
		server.WithRegistry(reg), //注册服务
		server.WithServerBasicInfo(&rpcinfo.EndpointBasicInfo{
			ServiceName: "easyimpr.math",
		}),//在这里就必须写上服务的名称了，因为etcd得知道
	)
	err = svr.Run()

resolver, err := etcd.NewEtcdResolver([]string{"127.0.0.1:2379"})
	if err != nil {
		log.Fatalf("failed to create resolver: %v", err)
	}
	//这里就不需要指定端口号和ip地址了
	client, err := math.NewClient("easyimpr.math", client.WithResolver(resolver))
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}

func TimeMiddleware(next endpoint.Endpoint) endpoint.Endpoint {
	return func(ctx context.Context, req, resp interface{}) (err error) {
		begin := time.Now()
		err = next(ctx, req, resp) //这里指运行剩下的中间件，以及核心业务接口
		elapsed := time.Since(begin)
		//可以获取执行的业务
		method, _ := kitexutil.GetMethod(ctx)
		//可以获取调用方地址
		addr, _ := kitexutil.GetCallerAddr(ctx)
		//可以获取上游server
		server, _ := kitexutil.GetCaller(ctx)
		fmt.Printf("method %s from %s took %s 上游 %s\n", method, addr, elapsed, server)
		return err
	}
}

	svr := math_service.NewServer(new(MathImpl),
		server.WithServiceAddr(addr),
		server.WithRegistry(reg), //注册服务
		server.WithServerBasicInfo(&rpcinfo.EndpointBasicInfo{
			ServiceName: "easyimpr.math",
		}),
		server.WithMiddleware(middleware.TimeMiddleware), //注册中间件
	)

func TimeMiddleware(next endpoint.Endpoint) endpoint.Endpoint {
	return func(ctx context.Context, req, resp interface{}) (err error) {
		begin := time.Now()
		err = next(ctx, req, resp) //这里指运行剩下的中间件，以及核心业务接口
		elapsed := time.Since(begin)
		//可以获取执行的业务
		method, _ := kitexutil.GetMethod(ctx)
		//可以获取下游的service name
		serviceName, _ := kitexutil.GetIDLServiceName(ctx)

		//也可以这么写
		// var serviceName, method string
		// ri := rpcinfo.GetRPCInfo(ctx)
		// if ivk := ri.Invocation(); ivk != nil {
		// 	serviceName = ivk.ServiceName()
		// 	method = ivk.MethodName()
		// }

		fmt.Printf("method %s 下游 %s 耗时 %s\n", method, serviceName, elapsed)
		return err
	}
}

	client, err := math.NewClient("easyimpr.math",
		client.WithResolver(resolver),
		client.WithMiddleware(middleware.TimeMiddleware), //注册中间件
	)

func RecordRequestAndResponse(next endpoint.Endpoint) endpoint.Endpoint {
	return func(ctx context.Context, req, resp interface{}) (err error) {
		//打印请求参数
		if arg, ok := req.(utils.KitexArgs); ok { //类型断言
			//调用断言后的函数方法后，发现返回了一个空接口，又要类型断言
			switch request := arg.GetFirstArgument().(type) {
			case *math_service.AddRequest:
				fmt.Printf("request: left %d, right %d\n", request.Left, request.Right)
			case *math_service.SubRequest:
				fmt.Printf("request: left %d, right %d\n", request.Left, request.Right)
			default:
				fmt.Printf("unknown request type %v\n", request)
			}
		}

		//执行接下来的中间件与函数
		err = next(ctx, req, resp)

		//打印响应参数
		if ri := rpcinfo.GetRPCInfo(ctx); ri != nil { //获取rpcinfo
			if stats := ri.Stats(); stats != nil { //rpc正常执行
				if result, ok := resp.(utils.KitexResult); ok { //类型断言
					switch response := result.GetResult().(type) { //调用断言后的函数方法后，发现返回了一个空接口，又要类型断言
					case *math_service.AddResponse:
						if response.Sum != 0 {
							fmt.Printf("response: sum %d\n", response.Sum)
						}
					case *math_service.SubResponse:
						if response.Diff != 0 {
							fmt.Printf("response: diff %d\n", response.Diff)
						}
					default:
						fmt.Printf("unknown response type %v\n", result.GetResult())
					}
				}
			}
		}
		return err
	}
}

func (s *MathImpl) Sub(ctx context.Context, req *math_service.SubRequest) (resp *math_service.SubResponse, err error) {
	// TODO: Your code here...
	a := 0
	b := 10 / a
	resp = &math_service.SubResponse{
		Diff: int32(b),
	}
	return resp, nil
}

//打印响应参数
		if ri := rpcinfo.GetRPCInfo(ctx); ri != nil { //获取rpcinfo
			if stats := ri.Stats(); stats != nil { //rpc正常执行
				//打印panic信息
				if panicHappened, panicInfo := stats.Panicked(); panicHappened { //panicInfo就是recover()的返回值
					klog.Errorf("panic info %s", panicInfo)//打印错误信息到日志
					return fmt.Errorf("服务内部发生panic") //原始panic信息对client隐藏
				} else {
					................
                    ................
				}
			}
		}

	client, err := math.NewClient("easyimpr.math",
		client.WithResolver(resolver),
		client.WithMiddleware(middleware.TimeMiddleware), //注册中间件
		client.WithConnectTimeout(100*time.Millisecond),  //连接超时
		client.WithRPCTimeout(2*time.Second),             //rpc超时
	)

	response, err := client.Sub(
		context.Background(),
		&request,
		callopt.WithConnectTimeout(100*time.Millisecond), //连接超时
		callopt.WithRPCTimeout(200*time.Millisecond),
	)

	client, err := math.NewClient("easyimpr.math",
		client.WithResolver(resolver),
		client.WithMiddleware(middleware.TimeMiddleware), //注册中间件
		client.WithConnectTimeout(100*time.Millisecond),  //连接超时
		client.WithRPCTimeout(2*time.Second),             //rpc超时
		client.WithWarmingUp(&warmup.ClientOption{ //预先初始化服务发现和连接池的相关组件，避免在首次请求时产生较大的延迟
			ResolverOption: &warmup.ResolverOption{
				Dests: []*rpcinfo.EndpointBasicInfo{
					{
						ServiceName: "easyimpr.math", //服务名称
					},
				},
			},
		}),
	)

	//重试机制
	failurePolicy := retry.NewFailurePolicy()
	failurePolicy.WithMaxRetryTimes(2) //最多重试2次（不包含首次）,不是立即重试，中间要休息一段时间

	client, err := math.NewClient("easyimpr.math",
		client.WithResolver(resolver),
		............
        ............
		client.WithFailureRetry(failurePolicy),//注册一下重试机制
	)

        "github.com/cloudwego/kitex/pkg/registry"

		server.WithRegistryInfo(&registry.Info{
			Weight: 100, // 必须是正数
		}),

cli, err := echo.NewClient("echo", client.WithLoadBalancer(loadbalance.NewWeightedRoundRobinBalancer()))

cli, err := echo.NewClient("echo", client.WithLoadBalancer(loadbalance.NewInterleavedWeightedRoundRobinBalancer()))

cli, err := echo.NewClient("echo", client.WithLoadBalancer(loadbalance.NewWeightedRandomBalancer()))

cli, err := echo.NewClient("echo", client.WithLoadBalancer(loadbalance.NewWeightedRandomWithAliasMethodBalancer()))

import "github.com/cloudwego/kitex/pkg/circuitbreak"

// 服务粒度：根据服务名称进行熔断
serviceCBSuit := circuitbreak.NewCBSuite(func(ri rpcinfo.RPCInfo) string { 
    return ri.To().ServiceName() 
})

// 方法粒度：根据服务名称+方法名进行熔断
methodCBSuit := circuitbreak.NewCBSuite(func(ri rpcinfo.RPCInfo) string { 
    return ri.To().ServiceName() + "/" + ri.To().Method() 
})

client, err := math.NewClient("easyimpr.math",
    client.WithResolver(resolver),
    client.WithCircuitBreaker(serviceCBSuit),  // 服务粒度熔断
    client.WithCircuitBreaker(methodCBSuit),   // 方法粒度熔断
)

// 方法粒度配置：Math/Add 方法
methodCBSuit.UpdateServiceCBConfig("Math/Add", circuitbreak.CBConfig{
    Enable:    true,   // 是否启用熔断
    ErrRate:   0.3,    // 错误率阈值（30%）
    MinSample: 200,    // 最小采样数（至少200个请求后才开始统计）
})

// 方法粒度配置：Math/Sub 方法
methodCBSuit.UpdateServiceCBConfig("Math/Sub", circuitbreak.CBConfig{
    Enable:    true,
    ErrRate:   0.4,    // 错误率阈值（40%）
    MinSample: 200,
})

// 服务粒度配置：整个 Math 服务
serviceCBSuit.UpdateServiceCBConfig("Math", circuitbreak.CBConfig{
    Enable:    true,
    ErrRate:   0.3,
    MinSample: 500,    // 服务级别需要更多样本
})

// 运行时动态调整
methodCBSuit.UpdateServiceCBConfig("Math/Add", circuitbreak.CBConfig{
    Enable:    true,
    ErrRate:   0.5,    // 调整阈值为 50%
    MinSample: 100,    // 降低采样数
})

import (
    "github.com/cloudwego/kitex/client/callopt"
    "github.com/cloudwego/kitex/pkg/fallback"
)

response, err := client.Add(
    context.Background(),
    &request,
    callopt.WithFallback( // 接口级别的降级策略
        fallback.NewFallbackPolicy(
            fallback.UnwrapHelper(
                func(ctx context.Context, req, resp interface{}, err error) (fbResp interface{}, fbErr error) {
                    if err != nil { // 发生了 error（业务错误、超时、熔断等）
                        fbResp = &math_service.AddResponse{Sum: 0} // 返回默认值
                        fbErr = nil  // 清除错误，对上游隐藏失败
                    } else { // 没有发生 error，直接使用原始结果
                        fbResp = resp
                    }
                    return
                },
            ),
        ),
    ),
)

callopt.WithFallback(
    fallback.NewFallbackPolicy(
        // 1. 业务错误降级
        fallback.ErrorFallback(func(ctx context.Context, req, resp interface{}, err error) (fbResp interface{}, fbErr error) {
            // 处理业务逻辑错误
            klog.Errorf("business error: %v", err)
            fbResp = &math_service.AddResponse{Sum: -1} // 返回特殊值表示业务错误
            fbErr = nil
            return
        }),
        
        // 2. 超时和熔断降级
        fallback.TimeoutAndCBFallback(func(ctx context.Context, req, resp interface{}, err error) (fbResp interface{}, fbErr error) {
            // 处理超时和熔断情况
            klog.Errorf("timeout or circuit breaker: %v", err)
            fbResp = &math_service.AddResponse{Sum: -2} // 返回特殊值表示超时/熔断
            fbErr = nil
            return
        }),
    ),
)

func(ctx context.Context, req, resp interface{}, err error) (fbResp interface{}, fbErr error)

client, err := math.NewClient("easyimpr.math",
    client.WithResolver(resolver),
    client.WithFallback(
        fallback.NewFallbackPolicy(
            fallback.UnwrapHelper(
                func(ctx context.Context, req, resp interface{}, err error) (fbResp interface{}, fbErr error) {
                    if err != nil {
                        klog.Errorf("fallback triggered: %v", err)
                        // 全局默认降级策略
                        fbResp = getDefaultResponse(req)
                        fbErr = nil
                    } else {
                        fbResp = resp
                    }
                    return
                },
            ),
        ),
    ),
)