Go 마이크로서비스의 요청, 검증, 응답 처리 개선-Golang-php.cn

Improving Request, Validation, and Response Handling in Go Microservices

이 가이드에서는 단순성, 재사용성 및 유지 관리가 용이한 코드베이스를 목표로 Go 마이크로서비스에서 요청, 검증 및 응답 처리를 간소화한 방법을 설명합니다.

소개

저는 꽤 오랫동안 Go에서 마이크로서비스 작업을 해왔고 이 언어가 제공하는 명확성과 단순성에 항상 감사하고 있습니다. 제가 Go에서 가장 좋아하는 점 중 하나는 뒤에서는 아무 일도 일어나지 않는다는 것입니다. 코드는 항상 투명하고 예측 가능합니다.

그러나 개발의 일부 부분은 상당히 지루할 수 있으며, 특히 API 엔드포인트의 응답을 검증하고 표준화하는 경우 더욱 그렇습니다. 나는 이 문제를 해결하기 위해 다양한 접근 방식을 시도했지만 최근 Go 강좌를 작성하는 동안 다소 예상치 못한 아이디어를 생각해 냈습니다. 이 아이디어는 내 핸들러에게 "마법"을 더해 주었고 놀랍게도 마음에 들었습니다. 이 솔루션을 사용하여 요청의 유효성 검사, 디코딩 및 매개 변수 구문 분석을 위한 모든 논리를 중앙 집중화할 수 있을 뿐만 아니라 API에 대한 인코딩 및 응답을 통합할 수 있었습니다. 결국 코드 명확성을 유지하는 것과 반복적인 구현을 줄이는 것 사이의 균형을 찾았습니다.

문제

Go 마이크로서비스를 개발할 때 일반적인 작업 중 하나는 들어오는 HTTP 요청을 효율적으로 처리하는 것입니다. 이 프로세스에는 일반적으로 요청 본문 구문 분석, 매개변수 추출, 데이터 유효성 검사 및 일관된 응답 전송이 포함됩니다. 예를 들어 문제를 설명하겠습니다.

package main

import (
 "encoding/json"
 "github.com/go-chi/chi/v5"
 "github.com/go-chi/chi/v5/middleware"
 "github.com/go-playground/validator/v10"
 "log"
 "net/http"
)

type SampleRequest struct {
 Name string `json:"name" validate:"required,min=3"`
 Age  int    `json:"age" validate:"required,min=1"`
}

var validate = validator.New()

type ValidationErrors struct {
 Errors map[string][]string `json:"errors"`
}

func main() {
 r := chi.NewRouter()
 r.Use(middleware.Logger)
 r.Use(middleware.Recoverer)

 r.Post("/submit/{name}", func(w http.ResponseWriter, r *http.Request) {
  sampleReq := &SampleRequest{}

  // Set the path parameter
  name := chi.URLParam(r, "name")
  if name == "" {
   w.WriteHeader(http.StatusBadRequest)
   json.NewEncoder(w).Encode(map[string]interface{}{
    "code":    http.StatusBadRequest,
    "message": "name is required",
   })
   return
  }
  sampleReq.Name = name

  // Parse and decode the JSON body
  if err := json.NewDecoder(r.Body).Decode(sampleReq); err != nil {
   w.WriteHeader(http.StatusBadRequest)
   json.NewEncoder(w).Encode(map[string]interface{}{
    "code":    http.StatusBadRequest,
    "message": "Invalid JSON format",
   })
   return
  }

  // Validate the request
  if err := validate.Struct(sampleReq); err != nil {
   validationErrors := make(map[string][]string)
   for _, err := range err.(validator.ValidationErrors) {
    fieldName := err.Field()
    validationErrors[fieldName] = append(validationErrors[fieldName], err.Tag())
   }
   w.WriteHeader(http.StatusBadRequest)
   json.NewEncoder(w).Encode(map[string]interface{}{
    "code":    http.StatusBadRequest,
    "message": "Validation error",
    "body":    ValidationErrors{Errors: validationErrors},
   })
   return
  }

  // Send success response
  w.WriteHeader(http.StatusOK)
  json.NewEncoder(w).Encode(map[string]interface{}{
   "code":    http.StatusOK,
   "message": "Request received successfully",
   "body":    sampleReq,
  })
 })

 log.Println("Starting server on :8080")
 http.ListenAndServe(":8080", r)
}

로그인 후 복사

수동으로 처리하는 핸들러 부분을 중심으로 위의 코드를 설명하겠습니다.

경로 매개변수 처리: 필수 경로 매개변수가 있는지 확인하고 처리합니다.
요청 본문 디코딩: 수신 JSON이 올바르게 구문 분석되는지 확인
검증: 유효성 검사기 패키지를 사용하여 요청 필드가 요구 사항 기준을 충족하는지 확인합니다.
오류 처리: 유효성 검사가 실패하거나 JSON 형식이 잘못된 경우 적절한 오류 메시지로 클라이언트에 응답합니다.
일관된 응답: 수동으로 응답 구조를 구축합니다.

코드는 기능적이지만 각각의 새로운 엔드포인트에 대해 반복되어야 하는 상당한 양의 상용구 논리를 포함하므로 유지 관리가 더 어렵고 불일치가 발생하기 쉽습니다.

그럼 어떻게 개선할 수 있을까요?

코드 분석

이 문제를 해결하고 코드 유지 관리성을 향상시키기 위해 로직을 요청, 응답, 검증이라는 세 가지 계층으로 나누기로 결정했습니다. 이 접근 방식은 각 부분의 논리를 캡슐화하여 재사용이 가능하고 독립적으로 테스트하기가 더 쉽습니다.

요청 레이어

요청 레이어는 들어오는 HTTP 요청에서 데이터를 구문 분석하고 추출하는 역할을 담당합니다. 이 논리를 분리함으로써 데이터 처리 방법을 표준화하고 모든 구문 분석이 균일하게 처리되도록 할 수 있습니다.

검증 레이어

검증 레이어는 사전 정의된 규칙에 따라 구문 분석된 데이터를 검증하는 데만 중점을 둡니다. 이렇게 하면 유효성 검사 논리가 요청 처리와 별도로 유지되므로 다양한 엔드포인트에서 유지 관리 및 재사용이 더욱 용이해집니다.

응답 계층

응답 레이어는 응답의 구성과 형식을 처리합니다. 응답 로직을 중앙 집중화함으로써 모든 API 응답이 일관된 구조를 따르도록 보장하여 디버깅을 단순화하고 클라이언트 상호 작용을 개선할 수 있습니다.

그래서… 코드를 레이어로 분할하면 재사용성, 테스트성, 유지관리성과 같은 이점이 있지만 몇 가지 절충점이 있습니다. 복잡성이 증가하면 새로운 개발자가 프로젝트 구조를 이해하기가 더 어려워질 수 있으며, 단순한 엔드포인트의 경우 별도의 레이어를 사용하는 것이 과도하다고 느껴질 수 있으며 잠재적으로 과도한 엔지니어링으로 이어질 수 있습니다. 이러한 장단점을 이해하면 이 패턴을 효과적으로 적용할 시기를 결정하는 데 도움이 됩니다.

결국에는 항상 당신을 가장 괴롭히는 것이 무엇인지에 관한 것입니다. 오른쪽? 이제 이전 코드에 손을 넣어 위에서 언급한 레이어 구현을 시작해 보겠습니다.

코드를 레이어로 리팩터링

1단계: 요청 계층 생성

먼저 코드를 리팩터링하여 요청 구문 분석을 전용 함수나 모듈로 캡슐화합니다. 이 레이어는 요청 본문을 읽고 구문 분석하는 데에만 중점을 두고 핸들러의 다른 책임과 분리되도록 합니다.

새 파일 만들기 httpsuite/request.go:

package main

import (
 "encoding/json"
 "github.com/go-chi/chi/v5"
 "github.com/go-chi/chi/v5/middleware"
 "github.com/go-playground/validator/v10"
 "log"
 "net/http"
)

type SampleRequest struct {
 Name string `json:"name" validate:"required,min=3"`
 Age  int    `json:"age" validate:"required,min=1"`
}

var validate = validator.New()

type ValidationErrors struct {
 Errors map[string][]string `json:"errors"`
}

func main() {
 r := chi.NewRouter()
 r.Use(middleware.Logger)
 r.Use(middleware.Recoverer)

 r.Post("/submit/{name}", func(w http.ResponseWriter, r *http.Request) {
  sampleReq := &SampleRequest{}

  // Set the path parameter
  name := chi.URLParam(r, "name")
  if name == "" {
   w.WriteHeader(http.StatusBadRequest)
   json.NewEncoder(w).Encode(map[string]interface{}{
    "code":    http.StatusBadRequest,
    "message": "name is required",
   })
   return
  }
  sampleReq.Name = name

  // Parse and decode the JSON body
  if err := json.NewDecoder(r.Body).Decode(sampleReq); err != nil {
   w.WriteHeader(http.StatusBadRequest)
   json.NewEncoder(w).Encode(map[string]interface{}{
    "code":    http.StatusBadRequest,
    "message": "Invalid JSON format",
   })
   return
  }

  // Validate the request
  if err := validate.Struct(sampleReq); err != nil {
   validationErrors := make(map[string][]string)
   for _, err := range err.(validator.ValidationErrors) {
    fieldName := err.Field()
    validationErrors[fieldName] = append(validationErrors[fieldName], err.Tag())
   }
   w.WriteHeader(http.StatusBadRequest)
   json.NewEncoder(w).Encode(map[string]interface{}{
    "code":    http.StatusBadRequest,
    "message": "Validation error",
    "body":    ValidationErrors{Errors: validationErrors},
   })
   return
  }

  // Send success response
  w.WriteHeader(http.StatusOK)
  json.NewEncoder(w).Encode(map[string]interface{}{
   "code":    http.StatusOK,
   "message": "Request received successfully",
   "body":    sampleReq,
  })
 })

 log.Println("Starting server on :8080")
 http.ListenAndServe(":8080", r)
}

로그인 후 복사

참고: 이 시점에서는 리플렉션을 사용해야 했습니다. 아마도 나는 더 나은 방법을 찾기에는 너무 어리석은 것 같습니다. ?

물론 이를 테스트할 수도 있으므로 테스트 파일 httpssuite/request_test.go:
를 만드세요.

package httpsuite

import (
 "encoding/json"
 "errors"
 "github.com/go-chi/chi/v5"
 "net/http"
 "reflect"
)

// RequestParamSetter defines the interface used to set the parameters to the HTTP request object by the request parser.
// Implementing this interface allows custom handling of URL parameters.
type RequestParamSetter interface {
 // SetParam assigns a value to a specified field in the request struct.
 // The fieldName parameter is the name of the field, and value is the value to set.
 SetParam(fieldName, value string) error
}

// ParseRequest parses the incoming HTTP request into a specified struct type, handling JSON decoding and URL parameters.
// It validates the parsed request and returns it along with any potential errors.
// The pathParams variadic argument allows specifying URL parameters to be extracted.
// If an error occurs during parsing, validation, or parameter setting, it responds with an appropriate HTTP status.
func ParseRequest[T RequestParamSetter](w http.ResponseWriter, r *http.Request, pathParams ...string) (T, error) {
 var request T
 var empty T

 defer func() {
  _ = r.Body.Close()
 }()

 if r.Body != http.NoBody {
  if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
   SendResponse[any](w, "Invalid JSON format", http.StatusBadRequest, nil)
   return empty, err
  }
 }

 // If body wasn't parsed request may be nil and cause problems ahead
 if isRequestNil(request) {
  request = reflect.New(reflect.TypeOf(request).Elem()).Interface().(T)
 }

 // Parse URL parameters
 for _, key := range pathParams {
  value := chi.URLParam(r, key)
  if value == "" {
   SendResponse[any](w, "Parameter "+key+" not found in request", http.StatusBadRequest, nil)
   return empty, errors.New("missing parameter: " + key)
  }

  if err := request.SetParam(key, value); err != nil {
   SendResponse[any](w, "Failed to set field "+key, http.StatusInternalServerError, nil)
   return empty, err
  }
 }

 // Validate the combined request struct
 if validationErr := IsRequestValid(request); validationErr != nil {
  SendResponse[ValidationErrors](w, "Validation error", http.StatusBadRequest, validationErr)
  return empty, errors.New("validation error")
 }

 return request, nil
}

func isRequestNil(i interface{}) bool {
 return i == nil || (reflect.ValueOf(i).Kind() == reflect.Ptr && reflect.ValueOf(i).IsNil())
}

로그인 후 복사

보시다시피 Request 레이어는 Validation 레이어를 사용합니다. 그러나 유지 관리를 더 쉽게 할 뿐만 아니라 유효성 검사 레이어를 격리하여 사용하고 싶을 수도 있기 때문에 코드에서 레이어를 분리된 상태로 유지하고 싶습니다.

필요에 따라 향후에는 모든 레이어를 격리하고 일부 인터페이스를 사용하여 상호 종속성을 허용하기로 결정할 수도 있습니다.

2단계: 검증 계층 구현

요청 구문 분석이 분리되면 유효성 검사 논리를 처리하는 독립형 유효성 검사 함수 또는 모듈을 만듭니다. 이 로직을 분리함으로써 쉽게 테스트하고 여러 엔드포인트에 걸쳐 일관된 유효성 검사 규칙을 적용할 수 있습니다.

이를 위해 httpsuite/validation.go 파일을 생성해 보겠습니다.

package main

import (
 "encoding/json"
 "github.com/go-chi/chi/v5"
 "github.com/go-chi/chi/v5/middleware"
 "github.com/go-playground/validator/v10"
 "log"
 "net/http"
)

type SampleRequest struct {
 Name string `json:"name" validate:"required,min=3"`
 Age  int    `json:"age" validate:"required,min=1"`
}

var validate = validator.New()

type ValidationErrors struct {
 Errors map[string][]string `json:"errors"`
}

func main() {
 r := chi.NewRouter()
 r.Use(middleware.Logger)
 r.Use(middleware.Recoverer)

 r.Post("/submit/{name}", func(w http.ResponseWriter, r *http.Request) {
  sampleReq := &SampleRequest{}

  // Set the path parameter
  name := chi.URLParam(r, "name")
  if name == "" {
   w.WriteHeader(http.StatusBadRequest)
   json.NewEncoder(w).Encode(map[string]interface{}{
    "code":    http.StatusBadRequest,
    "message": "name is required",
   })
   return
  }
  sampleReq.Name = name

  // Parse and decode the JSON body
  if err := json.NewDecoder(r.Body).Decode(sampleReq); err != nil {
   w.WriteHeader(http.StatusBadRequest)
   json.NewEncoder(w).Encode(map[string]interface{}{
    "code":    http.StatusBadRequest,
    "message": "Invalid JSON format",
   })
   return
  }

  // Validate the request
  if err := validate.Struct(sampleReq); err != nil {
   validationErrors := make(map[string][]string)
   for _, err := range err.(validator.ValidationErrors) {
    fieldName := err.Field()
    validationErrors[fieldName] = append(validationErrors[fieldName], err.Tag())
   }
   w.WriteHeader(http.StatusBadRequest)
   json.NewEncoder(w).Encode(map[string]interface{}{
    "code":    http.StatusBadRequest,
    "message": "Validation error",
    "body":    ValidationErrors{Errors: validationErrors},
   })
   return
  }

  // Send success response
  w.WriteHeader(http.StatusOK)
  json.NewEncoder(w).Encode(map[string]interface{}{
   "code":    http.StatusOK,
   "message": "Request received successfully",
   "body":    sampleReq,
  })
 })

 log.Println("Starting server on :8080")
 http.ListenAndServe(":8080", r)
}

로그인 후 복사

이제 테스트 파일을 생성합니다. httpsuite/validation_test.go:

package httpsuite

import (
 "encoding/json"
 "errors"
 "github.com/go-chi/chi/v5"
 "net/http"
 "reflect"
)

// RequestParamSetter defines the interface used to set the parameters to the HTTP request object by the request parser.
// Implementing this interface allows custom handling of URL parameters.
type RequestParamSetter interface {
 // SetParam assigns a value to a specified field in the request struct.
 // The fieldName parameter is the name of the field, and value is the value to set.
 SetParam(fieldName, value string) error
}

// ParseRequest parses the incoming HTTP request into a specified struct type, handling JSON decoding and URL parameters.
// It validates the parsed request and returns it along with any potential errors.
// The pathParams variadic argument allows specifying URL parameters to be extracted.
// If an error occurs during parsing, validation, or parameter setting, it responds with an appropriate HTTP status.
func ParseRequest[T RequestParamSetter](w http.ResponseWriter, r *http.Request, pathParams ...string) (T, error) {
 var request T
 var empty T

 defer func() {
  _ = r.Body.Close()
 }()

 if r.Body != http.NoBody {
  if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
   SendResponse[any](w, "Invalid JSON format", http.StatusBadRequest, nil)
   return empty, err
  }
 }

 // If body wasn't parsed request may be nil and cause problems ahead
 if isRequestNil(request) {
  request = reflect.New(reflect.TypeOf(request).Elem()).Interface().(T)
 }

 // Parse URL parameters
 for _, key := range pathParams {
  value := chi.URLParam(r, key)
  if value == "" {
   SendResponse[any](w, "Parameter "+key+" not found in request", http.StatusBadRequest, nil)
   return empty, errors.New("missing parameter: " + key)
  }

  if err := request.SetParam(key, value); err != nil {
   SendResponse[any](w, "Failed to set field "+key, http.StatusInternalServerError, nil)
   return empty, err
  }
 }

 // Validate the combined request struct
 if validationErr := IsRequestValid(request); validationErr != nil {
  SendResponse[ValidationErrors](w, "Validation error", http.StatusBadRequest, validationErr)
  return empty, errors.New("validation error")
 }

 return request, nil
}

func isRequestNil(i interface{}) bool {
 return i == nil || (reflect.ValueOf(i).Kind() == reflect.Ptr && reflect.ValueOf(i).IsNil())
}

로그인 후 복사

3단계: 응답 계층 구축

마지막으로 응답 구성을 별도의 모듈로 리팩터링합니다. 이렇게 하면 모든 응답이 일관된 형식을 따르므로 애플리케이션 전체에서 응답을 보다 쉽게 관리하고 디버그할 수 있습니다.

파일 만들기 httpsuite/response.go:

package httpsuite

import (
 "bytes"
 "context"
 "encoding/json"
 "errors"
 "fmt"
 "github.com/go-chi/chi/v5"
 "github.com/stretchr/testify/assert"
 "log"
 "net/http"
 "net/http/httptest"
 "strconv"
 "strings"
 "testing"
)

// TestRequest includes custom type annotation for UUID
type TestRequest struct {
 ID   int    `json:"id" validate:"required"`
 Name string `json:"name" validate:"required"`
}

func (r *TestRequest) SetParam(fieldName, value string) error {
 switch strings.ToLower(fieldName) {
 case "id":
  id, err := strconv.Atoi(value)
  if err != nil {
   return errors.New("invalid id")
  }
  r.ID = id
 default:
  log.Printf("Parameter %s cannot be set", fieldName)
 }

 return nil
}

func Test_ParseRequest(t *testing.T) {
 testSetURLParam := func(r *http.Request, fieldName, value string) *http.Request {
  ctx := chi.NewRouteContext()
  ctx.URLParams.Add(fieldName, value)
  return r.WithContext(context.WithValue(r.Context(), chi.RouteCtxKey, ctx))
 }

 type args struct {
  w          http.ResponseWriter
  r          *http.Request
  pathParams []string
 }
 type testCase[T any] struct {
  name    string
  args    args
  want    *TestRequest
  wantErr assert.ErrorAssertionFunc
 }
 tests := []testCase[TestRequest]{
  {
   name: "Successful Request",
   args: args{
    w: httptest.NewRecorder(),
    r: func() *http.Request {
     body, _ := json.Marshal(TestRequest{Name: "Test"})
     req := httptest.NewRequest("POST", "/test/123", bytes.NewBuffer(body))
     req = testSetURLParam(req, "ID", "123")
     req.Header.Set("Content-Type", "application/json")
     return req
    }(),
    pathParams: []string{"ID"},
   },
   want:    &TestRequest{ID: 123, Name: "Test"},
   wantErr: assert.NoError,
  },
  {
   name: "Missing body",
   args: args{
    w: httptest.NewRecorder(),
    r: func() *http.Request {
     req := httptest.NewRequest("POST", "/test/123", nil)
     req = testSetURLParam(req, "ID", "123")
     req.Header.Set("Content-Type", "application/json")
     return req
    }(),
    pathParams: []string{"ID"},
   },
   want:    nil,
   wantErr: assert.Error,
  },
  {
   name: "Missing Path Parameter",
   args: args{
    w: httptest.NewRecorder(),
    r: func() *http.Request {
     req := httptest.NewRequest("POST", "/test", nil)
     req.Header.Set("Content-Type", "application/json")
     return req
    }(),
    pathParams: []string{"ID"},
   },
   want:    nil,
   wantErr: assert.Error,
  },
  {
   name: "Invalid JSON Body",
   args: args{
    w: httptest.NewRecorder(),
    r: func() *http.Request {
     req := httptest.NewRequest("POST", "/test/123", bytes.NewBufferString("{invalid-json}"))
     req = testSetURLParam(req, "ID", "123")
     req.Header.Set("Content-Type", "application/json")
     return req
    }(),
    pathParams: []string{"ID"},
   },
   want:    nil,
   wantErr: assert.Error,
  },
  {
   name: "Validation Error for body",
   args: args{
    w: httptest.NewRecorder(),
    r: func() *http.Request {
     body, _ := json.Marshal(TestRequest{})
     req := httptest.NewRequest("POST", "/test/123", bytes.NewBuffer(body))
     req = testSetURLParam(req, "ID", "123")
     req.Header.Set("Content-Type", "application/json")
     return req
    }(),
    pathParams: []string{"ID"},
   },
   want:    nil,
   wantErr: assert.Error,
  },
  {
   name: "Validation Error for zero ID",
   args: args{
    w: httptest.NewRecorder(),
    r: func() *http.Request {
     body, _ := json.Marshal(TestRequest{Name: "Test"})
     req := httptest.NewRequest("POST", "/test/0", bytes.NewBuffer(body))
     req = testSetURLParam(req, "ID", "0")
     req.Header.Set("Content-Type", "application/json")
     return req
    }(),
    pathParams: []string{"ID"},
   },
   want:    nil,
   wantErr: assert.Error,
  },
 }

 for _, tt := range tests {
  t.Run(tt.name, func(t *testing.T) {
   got, err := ParseRequest[*TestRequest](tt.args.w, tt.args.r, tt.args.pathParams...)
   if !tt.wantErr(t, err, fmt.Sprintf("parseRequest(%v, %v, %v)", tt.args.w, tt.args.r, tt.args.pathParams)) {
    return
   }
   assert.Equalf(t, tt.want, got, "parseRequest(%v, %v, %v)", tt.args.w, tt.args.r, tt.args.pathParams)
  })
 }
}

로그인 후 복사

테스트 파일 만들기 httpsuite/response_test.go:

package httpsuite

import (
 "errors"
 "github.com/go-playground/validator/v10"
)

// ValidationErrors represents a collection of validation errors for an HTTP request.
type ValidationErrors struct {
 Errors map[string][]string `json:"errors,omitempty"`
}

// NewValidationErrors creates a new ValidationErrors instance from a given error.
// It extracts field-specific validation errors and maps them for structured output.
func NewValidationErrors(err error) *ValidationErrors {
 var validationErrors validator.ValidationErrors
 errors.As(err, &validationErrors)

 fieldErrors := make(map[string][]string)
 for _, vErr := range validationErrors {
  fieldName := vErr.Field()
  fieldError := fieldName + " " + vErr.Tag()

  fieldErrors[fieldName] = append(fieldErrors[fieldName], fieldError)
 }

 return &ValidationErrors{Errors: fieldErrors}
}

// IsRequestValid validates the provided request struct using the go-playground/validator package.
// It returns a ValidationErrors instance if validation fails, or nil if the request is valid.
func IsRequestValid(request any) *ValidationErrors {
 validate := validator.New(validator.WithRequiredStructEnabled())
 err := validate.Struct(request)
 if err != nil {
  return NewValidationErrors(err)
 }
 return nil
}

로그인 후 복사

이 리팩토링의 각 단계를 통해 잘 정의된 레이어에 특정 책임을 위임하여 핸들러 로직을 단순화할 수 있습니다. 모든 단계에서 전체 코드를 표시하지는 않지만 이러한 변경에는 구문 분석, 유효성 검사 및 응답 논리를 해당 기능이나 파일로 이동하는 작업이 포함됩니다.

예제 코드 리팩토링

이제 필요한 것은 레이어를 사용하도록 이전 코드를 변경하고 어떻게 보이는지 살펴보는 것입니다.

package httpsuite

import (
 "github.com/go-playground/validator/v10"
 "testing"

 "github.com/stretchr/testify/assert"
)

type TestValidationRequest struct {
 Name string `validate:"required"`
 Age  int    `validate:"required,min=18"`
}

func TestNewValidationErrors(t *testing.T) {
 validate := validator.New()
 request := TestValidationRequest{} // Missing required fields to trigger validation errors

 err := validate.Struct(request)
 if err == nil {
  t.Fatal("Expected validation errors, but got none")
 }

 validationErrors := NewValidationErrors(err)

 expectedErrors := map[string][]string{
  "Name": {"Name required"},
  "Age":  {"Age required"},
 }

 assert.Equal(t, expectedErrors, validationErrors.Errors)
}

func TestIsRequestValid(t *testing.T) {
 tests := []struct {
  name           string
  request        TestValidationRequest
  expectedErrors *ValidationErrors
 }{
  {
   name:           "Valid request",
   request:        TestValidationRequest{Name: "Alice", Age: 25},
   expectedErrors: nil, // No errors expected for valid input
  },
  {
   name:    "Missing Name and Age below minimum",
   request: TestValidationRequest{Age: 17},
   expectedErrors: &ValidationErrors{
    Errors: map[string][]string{
     "Name": {"Name required"},
     "Age":  {"Age min"},
    },
   },
  },
  {
   name:    "Missing Age",
   request: TestValidationRequest{Name: "Alice"},
   expectedErrors: &ValidationErrors{
    Errors: map[string][]string{
     "Age": {"Age required"},
    },
   },
  },
 }

 for _, tt := range tests {
  t.Run(tt.name, func(t *testing.T) {
   errs := IsRequestValid(tt.request)
   if tt.expectedErrors == nil {
    assert.Nil(t, errs)
   } else {
    assert.NotNil(t, errs)
    assert.Equal(t, tt.expectedErrors.Errors, errs.Errors)
   }
  })
 }
}

로그인 후 복사

요청 구문 분석, 유효성 검사 및 응답 형식 지정을 위해 핸들러 코드를 레이어로 리팩터링함으로써 이전에 핸들러 자체에 포함되었던 반복적인 논리를 성공적으로 제거했습니다. 이 모듈식 접근 방식은 가독성을 향상시킬 뿐만 아니라 각 책임에 집중하고 재사용 가능하게 하여 유지 관리 가능성과 테스트 가능성도 향상시킵니다. 이제 핸들러가 단순화됨에 따라 개발자는 전체 흐름에 영향을 주지 않고 특정 레이어를 쉽게 이해하고 수정할 수 있어 더 깔끔하고 확장성이 뛰어난 코드베이스를 만들 수 있습니다.

결론

전용 요청, 검증 및 응답 레이어를 사용하여 Go 마이크로서비스를 구성하는 방법에 대한 이 단계별 가이드가 더 깔끔하고 유지 관리하기 쉬운 코드를 만드는 데 도움이 되기를 바랍니다. 이 접근 방식에 대한 귀하의 생각을 듣고 싶습니다. 제가 뭔가 중요한 것을 놓치고 있는 걸까요? 자신의 프로젝트에서 이 아이디어를 어떻게 확장하거나 개선하시겠습니까?

소스 코드를 살펴보고 프로젝트에서 직접 httpssuite를 사용하는 것이 좋습니다. rluders/httpsuite 저장소에서 라이브러리를 찾을 수 있습니다. 여러분의 피드백과 기여는 이 라이브러리를 Go 커뮤니티에서 더욱 강력하고 유용하게 만드는 데 매우 귀중한 것입니다.

다음편에서 뵙겠습니다.

위 내용은 Go 마이크로서비스의 요청, 검증, 응답 처리 개선의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!