go-kratos使用备忘

syntax = "proto3";
package conf;

import "buf/validate/validate.proto";
import "google/protobuf/duration.proto";

option go_package = "github.com/tpl-x/kratos/internal/conf;conf";

message Bootstrap {
  Server server = 1;
  Data data = 2;
  Log log = 3;
}

message Server {
  message HTTP {
    string network = 1;
    string addr = 2;
    google.protobuf.Duration timeout = 3 [
      // the field is required
      (buf.validate.field).required = true,
      // duration must be longer than 1 second but no longer than 10 min.
      (buf.validate.field).duration = {
        // Validates that duration is greater than 1 second
        gt: {seconds: 1}
        // Validates that duration is less than or equal to 10 min.
        lte: {seconds: 600}
      }
    ];
  }
  message GRPC {
    string network = 1;
    string addr = 2;
    google.protobuf.Duration timeout = 3 [
      // the field is required
      (buf.validate.field).required = true,
      // duration must be longer than 1 second but no longer than 10 min.
      (buf.validate.field).duration = {
        // Validates that duration is greater than 1 second
        gt: {seconds: 1}
        // Validates that duration is less than or equal to 10 min.
        lte: {seconds: 600}
      }
    ];
  }
  HTTP http = 1;
  GRPC grpc = 2;
}

message Data {
  message Database {
    string driver = 1;
    string source = 2;
  }
  message Redis {
    string network = 1;
    string addr = 2;
    google.protobuf.Duration read_timeout = 3;
    google.protobuf.Duration write_timeout = 4;
  }
  Database database = 1;
  Redis redis = 2;
}

enum LogLevel {
  Debug = 0;
  Info = 1;
  Warn = 2;
  Error = 3;
  Fatal = 4;
}

message Log {
  string log_path = 1;
  LogLevel log_level = 2 [(buf.validate.field).enum = {
    defined_only: true
    in: [
      0,
      1,
      2,
      3,
      4
    ]
  }];
  int32 max_size = 3;
  int32 max_keep_days = 4;
  int32 max_keep_files = 5;
  bool compress = 6;
}

var bc conf.Bootstrap
if err := c.Scan(&bc); err != nil {
    panic(err)
}

// create  validator to apply validation rules before boot app
validator, err := protovalidate.New()
if err != nil {
    panic(err)
}

// do the validation for config
err = validator.Validate(&bc)
if err != nil {
    panic(err)
}

package tomlencoding
import (
	"github.com/BurntSushi/toml"
	"github.com/go-kratos/kratos/v2/encoding"
)

// Name is the name registered for the xml codec.
const Name = "toml"

func init() {
	encoding.RegisterCodec(codec{})
}

// codec is a Codec implementation with xml.
type codec struct{}

func (codec) Marshal(v interface{}) ([]byte, error) {
	return toml.Marshal(v)
}

func (codec) Unmarshal(data []byte, v interface{}) error {
	return toml.Unmarshal(data, v)
}

func (codec) Name() string {
	return Name
}

// 1. 简单变量
message GetUserRequest {
    string name = 1;  // 值将是 "test123"
}

service UserService {
    rpc GetUser(GetUserRequest) returns (User) {
        option (google.api.http) = {
            get: "/v1/{name}"
        };
    }
}
// 示例 URL: GET /v1/test123


// 2. 带模式的变量
message ListUsersRequest {
    string parent = 1;  // 值将是 "projects/123"
}

service UserService {
    rpc ListUsers(ListUsersRequest) returns (ListUsersResponse) {
        option (google.api.http) = {
            get: "/v1/{parent=projects/*}/users"
        };
    }
}
// 示例 URL: GET /v1/projects/123/users

// 1. 单段匹配
message GetProfileRequest {
    string name = 1;  // 值将是 "profiles/123"
}

rpc GetProfile(GetProfileRequest) returns (Profile) {
    option (google.api.http) = {
        get: "/v1/{name=profiles/*}"
    };
}
// 示例 URL: GET /v1/profiles/123


// 2. 多段匹配
message GetUserSettingRequest {
    string name = 1;  // 值将是 "users/123/settings/email"
}

rpc GetUserSetting(GetUserSettingRequest) returns (Setting) {
    option (google.api.http) = {
        get: "/v1/{name=users/*/settings/*}"
    };
}
// 示例 URL: GET /v1/users/123/settings/email


// 3. 通配符匹配
message GetResourceRequest {
    string path = 1;  // 值将是 "a/b/c/d"
}

rpc GetResource(GetResourceRequest) returns (Resource) {
    option (google.api.http) = {
        get: "/v1/{path=**}"
    };
}
// 示例 URL: GET /v1/a/b/c/d

// 1. GET 请求
message GetUserRequest {
    string name = 1;  // 值将是 "users/123"
}

rpc GetUser(GetUserRequest) returns (User) {
    option (google.api.http) = {
        get: "/v1/{name=users/*}"
    };
}
// 示例 URL: GET /v1/users/123


// 2. POST 请求
message CreateUserRequest {
    string parent = 1;     // 值将是 "projects/123"
    User user = 2;        // 请求体
}

rpc CreateUser(CreateUserRequest) returns (User) {
    option (google.api.http) = {
        post: "/v1/{parent=projects/*}/users"
        body: "user"
    };
}
// 示例 URL: POST /v1/projects/123/users
// 请求体: {"name": "users/123", "display_name": "John Doe", "email": "[email protected]"}


// 3. PUT 请求
message UpdateUserRequest {
    User user = 1;        // user.name 将是 "users/123"
    string update_mask = 2;
}

rpc UpdateUser(UpdateUserRequest) returns (User) {
    option (google.api.http) = {
        put: "/v1/{user.name=users/*}"
        body: "user"
    };
}
// 示例 URL: PUT /v1/users/123
// 请求体: {"name": "users/123", "display_name": "John Doe Updated"}


// 4. PATCH 请求
message PatchUserRequest {
    User user = 1;        // user.name 将是 "users/123"
    google.protobuf.FieldMask update_mask = 2;
}

rpc PatchUser(PatchUserRequest) returns (User) {
    option (google.api.http) = {
        patch: "/v1/{user.name=users/*}"
        body: "user"
    };
}
// 示例 URL: PATCH /v1/users/123
// 请求体: {"user": {"name": "users/123", "display_name": "John"}, "update_mask": "display_name"}


// 5. DELETE 请求
message DeleteUserRequest {
    string name = 1;  // 值将是 "users/123"
}

rpc DeleteUser(DeleteUserRequest) returns (google.protobuf.Empty) {
    option (google.api.http) = {
        delete: "/v1/{name=users/*}"
    };
}
// 示例 URL: DELETE /v1/users/123

// 1. 激活用户
message ActivateUserRequest {
    string name = 1;  // 值将是 "users/123"
    string reason = 2;
}

rpc ActivateUser(ActivateUserRequest) returns (User) {
    option (google.api.http) = {
        post: "/v1/{name=users/*}:activate"
        body: "*"
    };
}
// 示例 URL: POST /v1/users/123:activate
// 请求体: {"name": "users/123", "reason": "Account verified"}


// 2. 批量操作
message BatchCreateUsersRequest {
    string parent = 1;                    // 值将是 "projects/123"
    repeated CreateUserRequest requests = 2;
}

rpc BatchCreateUsers(BatchCreateUsersRequest) returns (BatchCreateUsersResponse) {
    option (google.api.http) = {
        post: "/v1/{parent=projects/*}/users:batchCreate"
        body: "*"
    };
}
// 示例 URL: POST /v1/projects/123/users:batchCreate
// 请求体: {
//   "parent": "projects/123",
//   "requests": [
//     {"parent": "projects/123", "user": {"display_name": "User 1"}},
//     {"parent": "projects/123", "user": {"display_name": "User 2"}}
//   ]
// }

// 1. 列出用户的所有设备
message ListDevicesRequest {
    string parent = 1;  // 值将是 "users/123"
    int32 page_size = 2;
    string page_token = 3;
}

rpc ListDevices(ListDevicesRequest) returns (ListDevicesResponse) {
    option (google.api.http) = {
        get: "/v1/{parent=users/*}/devices"
    };
}
// 示例 URL: GET /v1/users/123/devices?page_size=10&page_token=next_token


// 2. 获取特定设备
message GetDeviceRequest {
    string name = 1;  // 值将是 "users/123/devices/456"
}

rpc GetDevice(GetDeviceRequest) returns (Device) {
    option (google.api.http) = {
        get: "/v1/{name=users/*/devices/*}"
    };
}
// 示例 URL: GET /v1/users/123/devices/456

message GetResourceRequest {
    string name = 1;  // 值可能是 "projects/123/resources/456" 或 "locations/us-east1/resources/456"
}

rpc GetResource(GetResourceRequest) returns (Resource) {
    option (google.api.http) = {
        get: "/v1/{name=projects/*/resources/*}"
        additional_bindings {
            get: "/v1/{name=locations/*/resources/*}"
        }
    };
}
// 示例 URL 1: GET /v1/projects/123/resources/456
// 示例 URL 2: GET /v1/locations/us-east1/resources/456

service UserService {
  // 基础路径变量
  rpc GetUser(GetUserRequest) returns (User) {
    option (google.api.http) = {
      get: "/v1/users/{user_id}"
    };
  }

  // 多段路径变量
  rpc GetUserPost(GetUserPostRequest) returns (Post) {
    option (google.api.http) = {
      get: "/v1/users/{user_id}/posts/{post_id}"
    };
  }

  // 通配符路径
  rpc GetResource(GetResourceRequest) returns (Resource) {
    option (google.api.http) = {
      get: "/v1/{name=projects/*/resources/**}"  // **表示任意多层级路径
    };
  }

  // 复杂路径模板
  rpc ListOrganizationUsers(ListOrganizationUsersRequest) returns (ListOrganizationUsersResponse) {
    option (google.api.http) = {
      get: "/v1/{parent=organizations/*/departments/*}/users"
    };
  }
}

message UpdateUserRequest {
  string user_id = 1;
  User user = 2;
  string etag = 3;
  google.protobuf.FieldMask update_mask = 4;
}

service UserService {
  // 完整请求体映射
  rpc CreateUser(User) returns (User) {
    option (google.api.http) = {
      post: "/v1/users"
      body: "*"  // 映射整个消息
    };
  }

  // 嵌套字段映射
  rpc UpdateUserProfile(UpdateUserRequest) returns (User) {
    option (google.api.http) = {
      patch: "/v1/users/{user_id}/profile"
      body: "user.profile"  // 只映射user消息中的profile字段
    };
  }

  // 多字段映射
  rpc UpdateUserSettings(UpdateUserRequest) returns (User) {
    option (google.api.http) = {
      patch: "/v1/users/{user_id}/settings"
      body: "user.settings,etag"  // 映射多个字段
    };
  }
}

message ListUsersRequest {
  string parent = 1;
  int32 page_size = 2;
  string page_token = 3;
  string filter = 4;
  string order_by = 5;
  enum ViewType {
    VIEW_UNSPECIFIED = 0;
    BASIC = 1;
    FULL = 2;
  }
  ViewType view = 6;
  google.protobuf.FieldMask read_mask = 7;
}

service UserService {
  // 复杂查询参数
  rpc ListUsers(ListUsersRequest) returns (ListUsersResponse) {
    option (google.api.http) = {
      get: "/v1/{parent=organizations/*}/users"
      // 自动映射其他字段为查询参数
    };
  }
  // 生成URL示例: 
  // /v1/organizations/123/users?page_size=10&page_token=next&filter=age>18&order_by=name desc&view=FULL&read_mask=name,email,profile.avatar
}

service UserService {
  // 自定义响应状态码
  rpc CreateUser(CreateUserRequest) returns (User) {
    option (google.api.http) = {
      post: "/v1/users"
      body: "*"
      response_code: 201  // Created
    };
  }

  // 自定义响应头
  rpc GetUser(GetUserRequest) returns (User) {
    option (google.api.http) = {
      get: "/v1/users/{user_id}"
      response_headers: {
        key: "Cache-Control"
        value: "max-age=3600"
      }
      response_headers: {
        key: "ETag"
        value: "{etag}"
      }
    };
  }
}

service StreamService {
  // 服务器发送事件(SSE)
  rpc WatchResources(WatchRequest) returns (stream Resource) {
    option (google.api.http) = {
      get: "/v1/watch"
      response_body: "resource"
      additional_bindings: {
        get: "/v1/events"
        response_format: EVENT_STREAM
      }
    };
  }

  // 双向流式
  rpc Chat(stream ChatMessage) returns (stream ChatMessage) {
    option (google.api.http) = {
      post: "/v1/chat"
      protocol: WEBSOCKET
    };
  }
}

import "google/rpc/error_details.proto";

service UserService {
  rpc CreateUser(CreateUserRequest) returns (User) {
    option (google.api.http) = {
      post: "/v1/users"
      body: "*"
      error_details: {
        rules: {
          selector: "InvalidArgument"
          code: 400
          message: "Invalid request parameters"
          details: {
            type_url: "type.googleapis.com/google.rpc.BadRequest"
            required: true
          }
        }
        rules: {
          selector: "AlreadyExists"
          code: 409
          message: "User already exists"
          details: {
            type_url: "type.googleapis.com/google.rpc.ResourceInfo"
            required: true
          }
        }
      }
    };
  }
}

service SecureService {
  // OAuth2认证
  rpc GetSecretData(GetSecretRequest) returns (SecretData) {
    option (google.api.http) = {
      get: "/v1/secrets/{name}"
      security: {
        oauth2: {
          scopes: [
            "https://api.example.com/auth/secrets.read",
            "https://api.example.com/auth/secrets.write"
          ]
        }
      }
    };
  }

  // API密钥认证
  rpc PublicAPI(ApiRequest) returns (ApiResponse) {
    option (google.api.http) = {
      get: "/v1/public/{name}"
      security: {
        api_key: {
          header: "X-API-Key"
          description: "API key for authentication"
        }
      }
    };
  }
}

service VersionedService {
  // API版本控制
  rpc GetResource(GetResourceRequest) returns (Resource) {
    option (google.api.http) = {
      get: "/v1/resources/{name}"
      additional_bindings: {
        get: "/v2/resources/{name}"  // 支持多个版本
      }
    };
    option deprecated = true;  // 标记为废弃
  }

  // 新版本API
  rpc GetResourceV2(GetResourceRequestV2) returns (ResourceV2) {
    option (google.api.http) = {
      get: "/v2/resources/{name}"
    };
  }
}

service BatchService {
  // 批量获取
  rpc BatchGetUsers(BatchGetUsersRequest) returns (BatchGetUsersResponse) {
    option (google.api.http) = {
      get: "/v1/users:batchGet"
      response_body: "users"
    };
  }

  // 批量创建
  rpc BatchCreateUsers(BatchCreateUsersRequest) returns (BatchCreateUsersResponse) {
    option (google.api.http) = {
      post: "/v1/users:batchCreate"
      body: "requests"
    };
  }

  // 批量更新
  rpc BatchUpdateUsers(BatchUpdateUsersRequest) returns (BatchUpdateUsersResponse) {
    option (google.api.http) = {
      post: "/v1/users:batchUpdate"
      body: "*"
    };
  }
}

service CustomMethodService {
  // 自定义动作
  rpc ActivateUser(ActivateUserRequest) returns (User) {
    option (google.api.http) = {
      post: "/v1/users/{name}:activate"
      body: "*"
    };
  }

  // 导入导出
  rpc ExportUsers(ExportUsersRequest) returns (Operation) {
    option (google.api.http) = {
      post: "/v1/users:export"
      body: "*"
    };
  }

  // 复杂操作
  rpc MigrateData(MigrateDataRequest) returns (Operation) {
    option (google.api.http) = {
      post: "/v1/data:migrate"
      body: "*"
      long_running: {
        operation_info: {
          response_type: "MigrateDataResponse"
          metadata_type: "MigrateDataMetadata"
        }
      }
    };
  }
}

// 标准分页请求
message ListBooksRequest {
  // 父资源名称,例如 "shelves/shelf1"
  string parent = 1;
  
  // 每页大小,服务器可能会调整这个值
  int32 page_size = 2;
  
  // 上一次请求返回的页面标记
  string page_token = 3;
  
  // 可选的排序
  string order_by = 4;
  
  // 可选的过滤条件
  string filter = 5;
}

// 标准分页响应
message ListBooksResponse {
  // 当前页的数据
  repeated Book books = 1;
  
  // 下一页的标记,如果为空表示没有更多数据
  string next_page_token = 2;
  
  // 总记录数(可选)
  int32 total_size = 3;
}

service BookService {
  // 标准列表接口
  rpc ListBooks(ListBooksRequest) returns (ListBooksResponse) {
    option (google.api.http) = {
      get: "/v1/{parent=shelves/*}/books"
    };
  }

  // 使用游标分页
  rpc ListBooksByCursor(ListBooksByCursorRequest) returns (ListBooksByCursorResponse) {
    option (google.api.http) = {
      get: "/v1/{parent=shelves/*}/books:listByCursor"
    };
  }

  // 使用偏移量分页
  rpc ListBooksByOffset(ListBooksByOffsetRequest) returns (ListBooksByOffsetResponse) {
    option (google.api.http) = {
      get: "/v1/{parent=shelves/*}/books:listByOffset"
    };
  }
}

// 游标分页请求
message ListBooksByCursorRequest {
  string parent = 1;
  int32 limit = 2;
  string cursor = 3;  // 基于上一条记录的标识
  string order_by = 4;
}

// 游标分页响应
message ListBooksByCursorResponse {
  repeated Book books = 1;
  string next_cursor = 2;  // 下一页的游标
  bool has_more = 3;       // 是否还有更多数据
}

// 偏移量分页请求
message ListBooksByOffsetRequest {
  string parent = 1;
  int32 limit = 2;
  int32 offset = 3;  // 跳过的记录数
  string order_by = 4;
}

// 偏移量分页响应
message ListBooksByOffsetResponse {
  repeated Book books = 1;
  int32 total = 2;   // 总记录数
  int32 offset = 3;  // 当前偏移量
}

// 使用field_behavior注解标记只读字段
import "google/api/field_behavior.proto";

message Book {
  // 资源名称(只读)
  string name = 1 [(google.api.field_behavior) = OUTPUT_ONLY];
  
  // 可编辑字段
  string title = 2;
  string author = 3;
  
  // 创建时间(只读)
  google.protobuf.Timestamp create_time = 4 [
    (google.api.field_behavior) = OUTPUT_ONLY
  ];
  
  // 更新时间(只读)
  google.protobuf.Timestamp update_time = 5 [
    (google.api.field_behavior) = OUTPUT_ONLY
  ];
  
  // 系统生成的版本号(只读)
  string etag = 6 [(google.api.field_behavior) = OUTPUT_ONLY];

  // 创建时必填,后续只读
  string isbn = 7 [(google.api.field_behavior) = IMMUTABLE];
  
  // 计算得出的字段(只读)
  int32 page_count = 8 [(google.api.field_behavior) = OUTPUT_ONLY];
  double average_rating = 9 [(google.api.field_behavior) = OUTPUT_ONLY];
}

// 只读资源
message BookStats {
  option (google.api.resource) = {
    type: "library.googleapis.com/BookStats"
    pattern: "books/{book}/stats"
    style: DECLARATIVE_FRIENDLY
  };
  
  // 所有字段都是只读的
  string name = 1 [(google.api.field_behavior) = OUTPUT_ONLY];
  int32 view_count = 2 [(google.api.field_behavior) = OUTPUT_ONLY];
  int32 download_count = 3 [(google.api.field_behavior) = OUTPUT_ONLY];
  double popularity_score = 4 [(google.api.field_behavior) = OUTPUT_ONLY];
}

service BookService {
  // 只读接口
  rpc GetBookStats(GetBookStatsRequest) returns (BookStats) {
    option (google.api.http) = {
      get: "/v1/{name=books/*/stats}"
    };
    // 标记整个方法为只读
    option (google.api.method_signature) = "name";
  }

  // 带有条件检查的更新
  rpc UpdateBook(UpdateBookRequest) returns (Book) {
    option (google.api.http) = {
      patch: "/v1/{book.name=books/*}"
      body: "book"
    };
  }
}

message UpdateBookRequest {
  Book book = 1;
  
  // 用于并发控制的条件检查
  string etag = 2;
  
  // 指定要更新的字段
  google.protobuf.FieldMask update_mask = 3;
  
  // 是否验证只读字段
  bool validate_only = 4;
}

// 资源视图控制
message GetBookRequest {
  string name = 1;
  
  enum ViewType {
    // 默认视图
    VIEW_TYPE_UNSPECIFIED = 0;
    // 基础视图(不包含只读计算字段)
    BASIC = 1;
    // 完整视图(包含所有字段)
    FULL = 2;
  }
  
  ViewType view = 2;
}

func getPayloadFromCtx(ctx context.Context, partName string) (string, error) {
	if claims, ok := jwt.FromContext(ctx); ok {
		if m, ok := claims.(jwtV4.MapClaims); ok {
			if v, ok := m[partName].(string); ok {
				return v, nil
			}
		}
	}
	return "", errors.New("invalid Jwt")
}

if tr, ok := transport.FromServerContext(ctx); ok {
    // 可以取header等信息
    if hr, ok := tr.(*http.Transport); ok {
      // 可以取request等信息
   }
}

if httpCtx, ok := ctx.(http.Context); ok {
		httpCtx.Response().Header().Set("x-gopher", "czyt")
}

h := NewHelper(
    NewFilter(logger,
        // 等级过滤
        FilterLevel(log.LevelError),

        // 按key遮蔽
        FilterKey("username"),

        // 按value遮蔽
        FilterValue("hello"),

        // 自定义过滤函数
        FilterFunc(
            func (level Level, keyvals ...interface{}) bool {
                if level == LevelWarn {
                    return true
                }
                for i := 0; i < len(keyvals); i++ {
                    if keyvals[i] == "password" {
                        keyvals[i+1] = fuzzyStr
                    }
                }
                return false
            }
        ),
    ),
)

syntax = "proto3";

package helloworld.v1;

import "google/api/annotations.proto";

option go_package = "github.com/go-kratos/service-layout/api/helloworld/v1;v1";
option java_multiple_files = true;
option java_package = "dev.kratos.api.helloworld.v1";
option java_outer_classname = "HelloWorldProtoV1";

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply)  {
    option (google.api.http) = {
        // 定义一个 GET 接口，并且把 name 映射到 HelloRequest
        get: "/helloworld/{name}",
        // 可以添加附加接口
        additional_bindings {
            // 定义一个 POST 接口，并且把 body 映射到 HelloRequest
            post: "/v1/greeter/say_hello",
            body: "*",
        }
    };
  }
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}

rpc CreateUser(CreateUserRequest) returns (CreateUserResponse) {
    option (google.api.http) = {
      post: "/users",
      body: "user"
    };
  }
  
message CreateUserRequest {
  string password = 1;
  User user = 2;
}
message CreateUserResponse {
  string response = 1;
}

message User {
  string first_name = 1;
  string last_name = 2;
}
  

func (s *GreeterService) CreateUser(ctx context.Context, req *v1.CreateUserRequest) (*v1.CreateUserResponse, error) {
	info := fmt.Sprintf("password:%s,userName:%s %s", req.Password, req.User.FirstName, req.User.LastName)
	return &v1.CreateUserResponse{Response: info}, nil
}

curl --location -g --request POST 'http://127.0.0.1:8000/users?password=e77eEDab-BdAe-78BE-0979-2F798d9bBe4b \
--header 'Content-Type: application/json' \
--data-raw '{
    "first_name":"czyt",
    "last_name":"cn"
}'

{
    "response": "password:e77eEDab-BdAe-78BE-0979-2F798d9bBe4b,userName:czyt cn"
}

package main

import (
	"log"

	"github.com/go-kratos/examples/ws/handler"
	"github.com/go-kratos/kratos/v2"
	"github.com/go-kratos/kratos/v2/transport/http"
	"github.com/gorilla/mux"
)

func main() {
	router := mux.NewRouter()
	router.HandleFunc("/ws", handler.WsHandler)

	httpSrv := http.NewServer(http.Address(":8080"))
	httpSrv.HandlePrefix("/", router)

	app := kratos.New(
		kratos.Name("ws"),
		kratos.Server(
			httpSrv,
		),
	)
	if err := app.Run(); err != nil {
		log.Println(err)
	}
}

package handler

import (
	"log"
	"net/http"

	"github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{}

func WsHandler(w http.ResponseWriter, r *http.Request) {
	c, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		log.Print("upgrade:", err)
		return
	}
	defer c.Close()
	for {
		mt, message, err := c.ReadMessage()
		if err != nil {
			log.Println("read:", err)
			break
		}
		log.Printf("recv: %s", message)
		err = c.WriteMessage(mt, message)
		if err != nil {
			log.Println("write:", err)
			break
		}
	}
}

if httpCtx, ok := ctx.(http.Context); ok {
		if req.Id == "" {
			// 处理验证逻辑
		}
		if err := a.wsUc.HandleWebsocket(req.Id, httpCtx); err != nil {
			return nil, err
		}
  }

upGrader = websocket.Upgrader{
		CheckOrigin: func(r *http.Request) bool {
			return true
		},
}

func HandleWebsocket(id string,httpCtx http.Context) error {
    conn, err := upGrader.Upgrade(ctx.Response(), ctx.Request(), nil)
	if err != nil {
		c.log.Error(err)
		return err
	}
	go handleWsMessage(id, conn)
	return nil
}

map $http_upgrade $connection_upgrade {
      default upgrade;
      '' close;
}

upstream tiny_wssserver {
   server 0.0.0.0:8079;
   ip_hash;
}

server {
    listen      80;
    server_name test.czyt.tech;
    location / {
         root /opt/web/home/;
         index  index.html index.htm;

    }

   location /ws {
     proxy_pass https://tiny_wssserver/ws;
     proxy_http_version 1.1;
     proxy_set_header Upgrade $http_upgrade;
     proxy_set_header Connection $connection_upgrade;
     proxy_set_header   Host $host;
     proxy_read_timeout 36000s;
   }
}


server {
    listen       443  ssl;
    server_name  test.czyt.tech;
    client_max_body_size 50m;

    ssl_certificate /opt/certs/certificates/test.czyt.tech.crt;
    ssl_certificate_key /opt/certs/certificates/test.czyt.tech.key;

    location / {
         root /opt/web/home/;
         index  index.html index.htm;

    }

   location /ws {
     proxy_pass https://tiny_wssserver/ws;
     proxy_http_version 1.1;
     proxy_set_header Upgrade $http_upgrade;
     proxy_set_header Connection $connection_upgrade;
     proxy_set_header   Host $host;
     proxy_read_timeout 36000s;
   }
}

package main

import (
	"io"
	"log"
	"os"

	"github.com/go-kratos/kratos/v2"
	"github.com/go-kratos/kratos/v2/transport/http"
)

func uploadFile(ctx http.Context) error {
	req := ctx.Request()

	fileName := req.FormValue("name")
	file, handler, err := req.FormFile("file")
	if err != nil {
		return err
	}
	defer file.Close()

	f, err := os.OpenFile(handler.Filename, os.O_WRONLY|os.O_CREATE, 0o666)
	if err != nil {
		return err
	}
	defer f.Close()
	_, _ = io.Copy(f, file)

	return ctx.String(200, "File "+fileName+" Uploaded successfully")
}

func main() {
	httpSrv := http.NewServer(
		http.Address(":8000"),
	)
	route := httpSrv.Route("/")
	route.POST("/upload", uploadFile)

	app := kratos.New(
		kratos.Name("upload"),
		kratos.Server(
			httpSrv,
		),
	)
	if err := app.Run(); err != nil {
		log.Fatal(err)
	}
}

import "github.com/gorilla/schema"

func UploadHandlerWithMiddleware[T comparable](ctx http.Context, fileFormKey string) (
	chain middleware.Middleware,
	request T,
	reader io.Reader,
	filename string,
	err error,
) {
		defer func() {
		if err := recover(); err != nil {
			log.Println("panic handled:", err)
		}
	}()
	if fileFormKey == "" {
		fileFormKey = "file"
	}
	// 读取文件
	file, fileHeader, err := ctx.Request().FormFile(fileFormKey)
	defer file.Close()
	if err != nil {
		return nil, request, nil, "", err
	}
	buf := bufPool.Get()
	defer bufPool.Put(buf)
	if _, err := io.Copy(buf, file); err != nil {
		return nil, request, nil, fileHeader.Filename, err
	}
   // 开始解析Form参数
	if err := ctx.Request().ParseForm(); err != nil {
		return nil, request, nil, "", err
	}
	if err := ctx.Request().ParseMultipartForm(32 << 20); err != nil {
		return nil, request, nil, "", err
	}
    // 如果获取的Form参数不为nil，那么就进行参数到对应类型的解析
	if form := ctx.Request().Form; form != nil {
		var decoder = schema.NewDecoder()
		t := new(T)
		if err := decoder.Decode(t, form); err == nil {
			request = *t
		}
	}
    // 获取这个ctx的middleware执行权，当然也可以在上一步获取
	h := ctx.Middleware
	return h, request, bytes.NewReader(buf.Bytes()), fileHeader.Filename, nil
}

func (u UploadService) RegisterUploadServiceHttpServer(svr *http.Server) {
	route := svr.Route("/")
	route.POST("/v1/upload/demo", u.uploadDemo)

}

// 上传更新处理逻辑
func (u UploadService) uploadDemo(ctx http.Context) error {
    // 指定Operation 这样可以进行路由白名单设置等操作
	http.SetOperation(ctx, "/upload.v1.UploadService/demo")
	lazyCreator, uploadDemoOpt, reader, filename, err := udhandler.UploadHandlerWithMiddleware[biz.UploadDemoOption](
		ctx,
		"file")
	if err != nil {
		return v1.ErrorInvalidUploadDemoRequest("invalid request:%v", err)
	}
	handler := u.uploadUc.UploadDemo(filename, reader, uploadDemoOpt)
	h := lazyCreator(handler)
	resp, err := h(ctx, uploadDemoOpt)
	if err != nil {
		return v1.ErrorInvalidUploadDemoRequest("invalid request:%v", err)
	}
	return ctx.JSON(200, resp)
}

type UploadDemoOption struct {
	// 文件最大尺寸
	FileMaxSize int64 `schema:"file_max_size"`
	// 无损上传
	UploadWithNoLoss bool ` schema:"upload_with_no_loss"`
}

type UploadDemoResult struct {
	// 文件是否上传成功
	Success bool `json:"success"`
	// 文件下载链接
	FileDownloadUrl string `json:"file_download_url"`
}

func (a UploadUseCase) UploadImage(fileName string, reader io.Reader, uploadDemoOption UploadDemoOption) middleware.Handler {
	return func(ctx context.Context, req interface{}) (interface{}, error) {
        imageUploadResult:=UploadDemoResult{}
        ........
		return imageUploadResult, nil
	}
}

import "google/api/field_behavior.proto";
option go_package = "attachment;attachment";

message Attachment {
  string file_name = 1 [json_name = "file_name"];
  int64  content_length = 2 [json_name = "content_length"];
  bytes payload = 3 [(google.api.field_behavior)=REQUIRED];
}

func CustomResponseEncoder() http.ServerOption {
	return http.ResponseEncoder(func(w http.ResponseWriter, r *http.Request, i any) error {
		if asset, ok := i.(*attachment.Attachment); ok {
			err := handleAttachment(w, asset)
			if err != nil {
				return err
			}
			return nil
		}
		if m, ok := i.(proto.Message); ok {
			 // do other logics here
		}
           .......
	})
}

func handleAttachment(w http.ResponseWriter, attach *attachment.Attachment) error {
	w.Header().Set("Content-Disposition", attach.FileName)
	w.Header().Set("Content-Length", strconv.FormatInt(attach.ContentLength, 10))
	w.Header().Set("Content-Type", "application/octet-stream")
	_, err := w.Write(attach.Payload)
	if err != nil {
		return err
	}
	return nil
}

message DeviceMsg{
    int32 msg_type = 1;
    bytes msg_payload = 2;
}

package main

import (
	"embed"
	"log"
	"net/http"

	"github.com/go-kratos/kratos/v2"
	transhttp "github.com/go-kratos/kratos/v2/transport/http"
	"github.com/gorilla/mux"
)

//go:embed assets/*
var f embed.FS

func main() {
	router := mux.NewRouter()
	// example: /assets/index.html
	router.PathPrefix("/assets").Handler(http.FileServer(http.FS(f)))

	httpSrv := transhttp.NewServer(transhttp.Address(":8000"))
	httpSrv.HandlePrefix("/", router)

	app := kratos.New(
		kratos.Name("static"),
		kratos.Server(
			httpSrv,
		),
	)
	if err := app.Run(); err != nil {
		log.Fatal(err)
	}
}

func NewHTTPServer(c *conf.Server, greeter *service.GreeterService, logger log.Logger) *http.Server {
	var opts = []http.ServerOption{
		http.Middleware(
			recovery.Recovery(),
			nop.UserAgent(),
		),
	}
	if c.Http.Network != "" {
		opts = append(opts, http.Network(c.Http.Network))
	}
	if c.Http.Addr != "" {
		opts = append(opts, http.Address(c.Http.Addr))
	}
	if c.Http.Timeout != nil {
		opts = append(opts, http.Timeout(c.Http.Timeout.AsDuration()))
	}
	srv := http.NewServer(opts...)
    // 自定义路由，添加一个echo的功能
	route := srv.Route("/")
	route.GET("/v1/echo/{requester}", EchoHandler)
	v1.RegisterGreeterHTTPServer(srv, greeter)
	return srv
}

// 请求体定义
type echoRequest struct {
	Requester string `json:"requester"`
}
// 响应
type echoResponse struct {
	Resp string `json:"resp"`
}

// 消息处理实现逻辑
func echo(ctx context.Context, req *echoRequest) (*echoResponse, error) {
	return &echoResponse{Resp: fmt.Sprintf("hello,%s", req.Requester)}, nil
}

// middware处理
func EchoHandler(ctx http.Context) error {
	var in echoRequest
	if err := ctx.BindQuery(&in); err != nil {
		return err
	}
	if err := ctx.BindVars(&in); err != nil {
		return err
	}
	h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
		return echo(ctx, req.(*echoRequest))
	})
	resp, err := h(ctx, &in)
	if err != nil {
		return err
	}
	reply := resp.(*echoResponse)
	return ctx.Result(200, reply)
}

func UserAgent() middleware.Middleware {
	return func(handler middleware.Handler) middleware.Handler {
		return func(ctx context.Context, req interface{}) (reply interface{}, err error) {
			if tr, ok := transport.FromServerContext(ctx); ok {
				userAgent:=tr.RequestHeader().Get(userAgent)
				if strings.EqualFold(userAgent,"kratos-nb") {
					return nil, errors.New(403, "INVALID-UA", "user agent is invalid")
				}
			}
			return handler(ctx, req)
		}
	}
}

package middleware

import (
	"context"

	"github.com/go-cinch/layout/api/auth"
	"github.com/go-cinch/layout/internal/biz"
	"github.com/go-kratos/kratos/v2/middleware"
	"github.com/go-kratos/kratos/v2/transport"
	kratosHttp "github.com/go-kratos/kratos/v2/transport/http"
)

const (
	WhitelistIdempotentCategory uint32 = 2
)

func Idempotent(authClient auth.AuthClient) middleware.Middleware {
	return func(handler middleware.Handler) middleware.Handler {
		return func(ctx context.Context, req interface{}) (rp interface{}, err error) {
			tr, ok := transport.FromServerContext(ctx)
			if !ok {
				err = biz.ErrIdempotentMissingToken(ctx)
				return
			}
			var method, path string
			switch tr.Kind() {
			case transport.KindHTTP:
				if ht, ok3 := tr.(kratosHttp.Transporter); ok3 {
					method = ht.Request().Method
					path = ht.Request().URL.Path
				}
			}
			// check idempotent blacklist
			whitelist, err := authClient.HasWhitelist(ctx, &auth.HasWhitelistRequest{
				Category: WhitelistIdempotentCategory,
				Permission: &auth.HasWhitelistRequest_CheckPermission{
					Resource: tr.Operation(),
					Method:   method,
					Uri:      path,
				},
			})
			if err != nil {
				return
			}
			if !whitelist.Ok {
				return handler(ctx, req)
			}
			// check idempotent token
			token := tr.RequestHeader().Get("x-idempotent")
			if token == "" {
				err = biz.ErrIdempotentMissingToken(ctx)
				return
			}
			_, err = authClient.CheckIdempotent(ctx, &auth.CheckIdempotentRequest{Token: token})
			if err != nil {
				return
			}
			return handler(ctx, req)
		}
	}
}

package main

import (
	"context"
	"fmt"
	"log"
	"net/http"

	"github.com/go-kratos/examples/helloworld/helloworld"
	"github.com/go-kratos/kratos/v2"
	"github.com/go-kratos/kratos/v2/errors"
	khttp "github.com/go-kratos/kratos/v2/transport/http"
)

type server struct {
	helloworld.UnimplementedGreeterServer
}

// SayHello implements helloworld.GreeterServer
func (s *server) SayHello(ctx context.Context, in *helloworld.HelloRequest) (*helloworld.HelloReply, error) {
	if in.Name == "error" {
		return nil, errors.BadRequest("custom_error", fmt.Sprintf("invalid argument %s", in.Name))
	}
	if in.Name == "panic" {
		panic("server panic")
	}
	return &helloworld.HelloReply{Message: fmt.Sprintf("Hello %+v", in.Name)}, nil
}

func redirectFilter(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path == "/helloworld/kratos" {
			http.Redirect(w, r, "https://go-kratos.dev/", http.StatusMovedPermanently)
			return
		}
		next.ServeHTTP(w, r)
	})
}

func main() {
	httpSrv := khttp.NewServer(
		khttp.Address(":8000"),
		khttp.Filter(redirectFilter),
	)
	s := &server{}
	helloworld.RegisterGreeterHTTPServer(httpSrv, s)

	app := kratos.New(
		kratos.Name("cors"),
		kratos.Server(
			httpSrv,
		),
	)
	if err := app.Run(); err != nil {
		log.Fatal(err)
	}
}

imports(
    	"github.com/go-kratos/kratos/v2/transport/http"
	stdHttp "net/http"
)
func (s xxService) Handlexxx(ctx context.Context, req *v1.HandlexxxRequest) (resp *v1.HandlexxxResponse, err error) {
if httpCtx, ok := ctx.(http.Context); ok {
		stdHttp.Redirect(
            httpCtx.Response(),
            httpCtx.Request(),
            targetUrl,
            stdHttp.StatusMovedPermanently,
        )
	}
}