HTTP

    Network(network string) ServerOption

    配置服务端的 network 协议，如 tcp

    Address(addr string) ServerOption

    配置服务端监听的地址

    Timeout(timeout time.Duration) ServerOption

    配置服务端的超时设置

    Logger(logger log.Logger) ServerOption

    配置服务端使用日志

    Middleware(m ...middleware.Middleware) ServerOption

    配置服务端的 kratos Service中间件

    Filter(filters ...FilterFunc) ServerOption

    配置服务端的 kratos 全局HTTP原生Fitler，此Filter执行顺序在Service中间件之前

    RequestDecoder(dec DecodeRequestFunc) ServerOption

    配置kratos服务端的 HTTP Request Decode方法，用来将Request Body解析至用户定义的pb结构体中 我们看下kratos中默认的RequestDecoder是怎么实现的：

    那么如果我们想要扩展或者替换Content-Type对应的解析实现，就可以通过http.RequestDecoder()来替换kratos默认的RequestDecoder， 或者也可以通过在encoding中注册或覆盖一个Content-Type对应的codec来进行扩展

    ResponseEncoder(en EncodeResponseFunc) ServerOption

    配置kratos服务端的 HTTP Response Encode方法，用来将用户pb定义里的reply结构体序列化后写入Response Body中 我们看下kratos中默认的ResponseEncoder是怎么实现的：

    1. func DefaultResponseEncoder(w http.ResponseWriter, r *http.Request, v interface{}) error {
    2.     // 通过Request Header的Accept中提取出对应的编码器
    3.     // 如果找不到则忽略报错，并使用默认json编码器
    4.     codec, _ := CodecForRequest(r, "Accept")
    5.     data, err := codec.Marshal(v)
    6.     if err != nil {
    7.         return err
    8.     }
    9.     w.Header().Set("Content-Type", httputil.ContentType(codec.Name()))
    10.     w.Write(data)
    11.     return nil
    12. }

    那么如果我们想要扩展或者替换Accept对应的序列化实现，就可以通过http.ResponseEncoder()来替换kratos默认的ResponseEncoder， 或者也可以通过在encoding中注册或覆盖一个Accept对应的codec来进行扩展

    ErrorEncoder(en EncodeErrorFunc) ServerOption

    1. func DefaultErrorEncoder(w http.ResponseWriter, r *http.Request, err error) {
    2.     // 拿到error并转换成kratos Error实体
    3.     se := errors.FromError(err)
    5.     codec, _ := CodecForRequest(r, "Accept")
    6.     body, err := codec.Marshal(se)
    7.     if err != nil {
    8.         w.WriteHeader(http.StatusInternalServerError)
    9.         return
    10.     }
    11.     w.Header().Set("Content-Type", httputil.ContentType(codec.Name()))
    12.     // 设置HTTP Status Code
    13.     w.WriteHeader(int(se.Code))
    14.     w.Write(body)
    15. }

    TLSConfig(c *tls.Config) ServerOption

    为 kratos 服务端添加 tls 配置用于加密 http 通信 我们看下 kratos 中是如何配置的:

    1. // TLSConfig with TLS config.
    2. func TLSConfig(c *tls.Config) ServerOption {
    3.     return func(o *Server) {
    4.         o.tlsConf = c
    5.     }
    6. }

    StrictSlash(strictSlash bool) ServerOption

    为 kratos 服务端添加 StrictSlash 配置，用于重定向路由 我们看下 kratos 中是如何配置的

    1. // StrictSlash is with mux's StrictSlash
    2. // If true, when the path pattern is "/path/", accessing "/path" will
    3. // redirect to the former and vice versa.
    4. func StrictSlash(strictSlash bool) ServerOption {
    5.     return func(o *Server) {
    6.         o.strictSlash = strictSlash
    7.     }
    8. }

    Listener(lis net.Listener) ServerOption

    为 kratos 服务端添加 Listener 接口用于面向流协议的传输 我们看下 kratos 中是如何配置的

    NewServer(opts ...ServerOption) *Server

    传入opts配置并启动HTTP Server

    1. hs := http.NewServer()
    2. app := kratos.New(
    3.   kratos.Name("kratos"),
    4.   kratos.Version("v1.0.0"),
    5.   kratos.Server(hs),
    6. )

    HTTP server 中使用 kratos middleware

    1. hs := http.NewServer(
    2.     http.Address(":8000"),
    3.     http.Middleware(
    4.         logging.Server(),
    5.     ),
    6. )

    middleware 中处理 http 请求

    1. if tr, ok := transport.FromServerContext(ctx); ok {
    2.     kind = tr.Kind().String()
    3.     operation = tr.Operation()
    4.     // 断言成HTTP的Transport可以拿到特殊信息
    5.         fmt.Println(ht.Request())
    6.     }
    7. }

    func (s *Server) Route(prefix string, filters ...FilterFunc) *Router

    创建一个新的HTTP Server Router，同时可以传递kratos的HTTP Filter拦截器 我们看下用法：

    1. r := s.Route("/v1")
    2. r.GET("/helloworld/{name}", _Greeter_SayHello0_HTTP_Handler(srv))

    func (s *Server) Handle(path string, h http.Handler)

    将path添加到路由中，并使用标准的HTTP Handler来处理

    func (s *Server) HandlePrefix(prefix string, h http.Handler)

    前缀匹配的方式将prefix添加到路由中，并使用标准的HTTP Handler来处理

    func (s *Server) ServeHTTP(res http.ResponseWriter, req *http.Request)

    实现了标准库的HTTP Handler接口

    Client

    WithTimeout(d time.Duration) ClientOption

    配置客户端的请求默认超时时间，如果有链路超时优先使用链路超时时间

    WithUserAgent(ua string) ClientOption

    配置客户端的默认User-Agent

    WithMiddleware(m ...middleware.Middleware) ClientOption

    配置客户端使用的 kratos client中间件

    WithEndpoint(endpoint string) ClientOption

    配置客户端使用的对端连接地址，如果不使用服务发现则为ip:port,如果使用服务发现则格式为discovery://\<authority>/\<serviceName>,这里\<authority>可以默认填空

    WithDiscovery(d registry.Discovery) ClientOption

    配置客户端使用的服务发现

    WithRequestEncoder(encoder EncodeRequestFunc) ClientOption

    配置客户端的 HTTP Request Encode方法，用来将户定义的pb结构体中序列化至Request Body 我们看下默认的encoder:

    WithResponseDecoder(decoder DecodeResponseFunc) ClientOption

    配置客户端的 HTTP Response Decode方法，用来将Response Body解析至用户定义的pb结构体中 我们看下kratos中默认的decoder是怎么实现的：

    1. func DefaultResponseDecoder(ctx context.Context, res *http.Response, v interface{}) error {
    2.     defer res.Body.Close()
    3.     data, err := ioutil.ReadAll(res.Body)
    4.     if err != nil {
    5.         return err
    6.     }
    7.     // 这里根据Response Header中的Content-Type拿到对应的decoder
    8.     // 然后进行Unmarshal
    9.     return CodecForResponse(res).Unmarshal(data, v)
    10. }

    WithErrorDecoder(errorDecoder DecodeErrorFunc) ClientOption

    配置客户端的Error解析方法 我们看下kratos中默认的error decoder是怎么实现的：

    1. func DefaultErrorDecoder(ctx context.Context, res *http.Response) error {
    2.     // HTTP Status Code 为最高优先级
    3.     if res.StatusCode >= 200 && res.StatusCode <= 299 {
    4.         return nil
    5.     }
    6.     defer res.Body.Close()
    7.     data, err := ioutil.ReadAll(res.Body)
    8.     if err == nil {
    9.         e := new(errors.Error)
    10.         // 这里根据Response Header中的Content-Type拿到对应的response decoder
    11.         // 然后解析出error主体内容
    12.         if err = CodecForResponse(res).Unmarshal(data, e); err == nil {
    13.             // HTTP Status Code 为最高优先级
    14.             e.Code = int32(res.StatusCode)
    15.             return e
    16.         }
    17.     }
    18.     // 如果没有返回合法的Response Body则直接以HTTP Status Code为准
    19.     return errors.Errorf(res.StatusCode, errors.UnknownReason, err.Error())
    20. }

    WithBalancer(b balancer.Balancer) ClientOption

    配置客户端的负载均衡策略

    WithBlock() ClientOption

    配置客户端的Dial策略为阻塞（直到服务发现发现节点才返回），默认为异步非阻塞

    WithTLSConfig(c *tls.Config) ClientOption

    1. // WithTLSConfig with tls config.
    2. func WithTLSConfig(c *tls.Config) ClientOption {
    3.     return func(o *clientOptions) {
    4.         o.tlsConf = c
    5.     }
    6. }

    创建客户端连接

    1. conn, err := http.NewClient(
    2.     context.Background(),
    3.     http.WithEndpoint("127.0.0.1:8000"),
    4. )

    使用中间件

    使用服务发现

    1. conn, err := http.NewClient(
    2.     context.Background(),
    3.     http.WithEndpoint("discovery:///helloworld"),
    4.     http.WithDiscovery(r),