Panduan ini menerangkan cara saya memperkemas pengendalian permintaan, pengesahan dan respons dalam perkhidmatan mikro Go saya, bertujuan untuk kesederhanaan, kebolehgunaan semula dan pangkalan kod yang lebih boleh diselenggara.

pengenalan

Saya telah lama bekerja dengan perkhidmatan mikro dalam Go dan saya sentiasa menghargai kejelasan dan kesederhanaan yang ditawarkan oleh bahasa ini. Salah satu perkara yang paling saya suka tentang Go ialah tiada apa yang berlaku di sebalik tabir; kod itu sentiasa telus dan boleh diramal.

Walau bagaimanapun, sesetengah bahagian pembangunan boleh menjadi agak membosankan, terutamanya apabila ia berkaitan dengan mengesahkan dan menyeragamkan respons dalam titik akhir API. Saya telah mencuba pelbagai pendekatan untuk menangani perkara ini, tetapi baru-baru ini, semasa menulis kursus Go saya, saya mendapat idea yang agak tidak dijangka. Idea ini menambahkan sentuhan "ajaib" kepada pengendali saya, dan, yang mengejutkan saya, saya menyukainya. Dengan penyelesaian ini, saya dapat memusatkan semua logik untuk pengesahan, penyahkodan dan penghuraian parameter permintaan, serta menyatukan pengekodan dan respons untuk API. Akhirnya, saya mendapati keseimbangan antara mengekalkan kejelasan kod dan mengurangkan pelaksanaan berulang.

Masalahnya

Apabila membangunkan perkhidmatan mikro Go, satu tugas biasa ialah mengendalikan permintaan HTTP masuk dengan cekap. Proses ini biasanya melibatkan badan permintaan menghurai, mengekstrak parameter, mengesahkan data dan menghantar semula respons yang konsisten. Biar saya menggambarkan masalah dengan contoh:

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)
}

Biar saya terangkan kod di atas, memfokuskan pada bahagian pengendali yang kami kendalikan secara manual:

• Mengendalikan parameter laluan: Sahkan sama ada parameter laluan yang diperlukan wujud dan mengendalikannya.
• Menyahkod kandungan permintaan: Memastikan JSON yang masuk dihuraikan dengan betul.
• Pengesahan: Menggunakan pakej pengesah untuk menyemak sama ada medan permintaan memenuhi kriteria keperluan.
• Ralat pengendalian: Membalas pelanggan dengan mesej ralat yang sesuai apabila pengesahan gagal atau JSON salah bentuk.
• Respons konsisten: Membina struktur tindak balas secara manual.

Walaupun kod berfungsi, ia melibatkan sejumlah besar logik boilerplate yang mesti diulang untuk setiap titik akhir baharu, menjadikannya lebih sukar untuk dikekalkan dan terdedah kepada ketidakkonsistenan.

Jadi, bagaimana kita boleh memperbaiki perkara ini?

Memecahkan kod

Untuk menangani isu ini dan meningkatkan kebolehselenggaraan kod, saya memutuskan untuk membahagikan logik kepada tiga lapisan berbeza: Permintaan, Respon dan Pengesahan. Pendekatan ini merangkumi logik untuk setiap bahagian, menjadikannya boleh digunakan semula dan lebih mudah untuk diuji secara bebas.

Lapisan Permintaan

Lapisan Permintaan bertanggungjawab untuk menghuraikan dan mengekstrak data daripada permintaan HTTP yang masuk. Dengan mengasingkan logik ini, kami boleh menyeragamkan cara data diproses dan memastikan semua penghuraian dikendalikan secara seragam.

Lapisan Pengesahan

Lapisan Pengesahan memfokuskan semata-mata pada mengesahkan data yang dihuraikan mengikut peraturan yang telah ditetapkan. Ini memastikan logik pengesahan berasingan daripada pengendalian permintaan, menjadikannya lebih boleh diselenggara dan boleh digunakan semula merentas titik akhir yang berbeza.

Lapisan Respons

Pengendali lapisan Respons pembinaan dan pemformatan respons. Dengan memusatkan logik tindak balas, kami boleh memastikan bahawa semua respons API mengikut struktur yang konsisten, memudahkan penyahpepijatan dan meningkatkan interaksi pelanggan.

Jadi... Walaupun pembahagian kod kepada lapisan menawarkan faedah seperti kebolehgunaan semula, kebolehujian dan kebolehselenggaraan, ia datang dengan beberapa pertukaran. Kerumitan yang meningkat boleh menjadikan struktur projek lebih sukar untuk difahami oleh pembangun baharu, dan untuk titik akhir yang mudah, menggunakan lapisan berasingan mungkin terasa berlebihan, yang berpotensi membawa kepada terlalu kejuruteraan. Memahami kebaikan dan keburukan ini membantu dalam menentukan masa untuk menggunakan corak ini dengan berkesan.

Pada penghujung hari, sentiasa tentang perkara yang paling mengganggu anda. Betul ke? Jadi, sekarang mari masukkan sedikit kod lama kita dan mula melaksanakan lapisan yang disebutkan di atas.

Memfaktorkan semula kod ke dalam lapisan

Langkah 1: Mencipta Lapisan Permintaan

Mula-mula, kami memfaktorkan semula kod untuk merangkum penghuraian permintaan ke dalam fungsi atau modul khusus. Lapisan ini memberi tumpuan semata-mata pada membaca dan menghuraikan kandungan permintaan, memastikan ia dipisahkan daripada tanggungjawab lain dalam pengendali.

Buat fail baharu 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)
}

Nota: Pada ketika ini, saya terpaksa menggunakan refleksi. Mungkin saya bodoh untuk mencari penantian yang lebih baik, lakukannya. ?

Sudah tentu, kita juga boleh menguji ini, buat fail ujian httpsuite/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())
}

Seperti yang anda lihat, lapisan Permintaan menggunakan lapisan Pengesahan. Walau bagaimanapun, saya masih mahu memisahkan lapisan dalam kod, bukan sahaja untuk memudahkan penyelenggaraan, tetapi kerana saya juga mungkin mahu menggunakan lapisan pengesahan yang diasingkan.

Bergantung pada keperluan, pada masa hadapan, saya mungkin memutuskan untuk memastikan semua lapisan diasingkan dan membenarkan kebergantungan bersamanya dengan menggunakan beberapa antara muka.

Langkah 2: Melaksanakan Lapisan Pengesahan

Setelah penghuraian permintaan dipisahkan, kami mencipta fungsi atau modul pengesahan kendiri yang mengendalikan logik pengesahan. Dengan mengasingkan logik ini, kami boleh mengujinya dengan mudah dan menggunakan peraturan pengesahan yang konsisten merentas berbilang titik akhir.

Untuk itu, mari buat fail 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)
}

Sekarang, buat fail ujian 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())
}

Langkah 3: Membina Lapisan Respons

Akhir sekali, kami memfaktorkan semula pembinaan tindak balas ke dalam modul yang berasingan. Ini memastikan bahawa semua respons mengikut format yang konsisten, menjadikannya lebih mudah untuk mengurus dan menyahpepijat respons sepanjang aplikasi.

Buat fail 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)
  })
 }
}

Buat fail ujian 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
}

Setiap langkah pemfaktoran semula ini membolehkan kami memudahkan logik pengendali dengan menyerahkan tanggungjawab khusus kepada lapisan yang ditakrifkan dengan baik. Walaupun saya tidak akan menunjukkan kod lengkap pada setiap langkah, perubahan ini melibatkan penghuraian, pengesahan dan logik tindak balas ke dalam fungsi atau fail masing-masing.

Memfaktorkan semula kod contoh

Sekarang, apa yang kita perlukan ialah menukar kod lama untuk menggunakan lapisan dan mari lihat bagaimana ia akan kelihatan.

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)
   }
  })
 }
}

Dengan memfaktorkan semula kod pengendali ke dalam lapisan untuk penghuraian permintaan, pengesahan dan pemformatan respons, kami telah berjaya mengalih keluar logik berulang yang sebelum ini dibenamkan dalam pengendali itu sendiri. Pendekatan modular ini bukan sahaja meningkatkan kebolehbacaan tetapi juga meningkatkan kebolehselenggaraan dan kebolehujian dengan memastikan setiap tanggungjawab fokus dan boleh digunakan semula. Dengan pengendali kini dipermudahkan, pembangun boleh memahami dan mengubah suai lapisan tertentu dengan mudah tanpa menjejaskan keseluruhan aliran, mewujudkan pangkalan kod yang lebih bersih dan berskala.

Kesimpulan

Saya harap panduan langkah demi langkah ini untuk menstrukturkan perkhidmatan mikro Go anda dengan permintaan khusus, pengesahan dan lapisan tindak balas telah memberikan cerapan untuk mencipta kod yang lebih bersih dan boleh diselenggara. Saya ingin mendengar pendapat anda tentang pendekatan ini. Adakah saya kehilangan sesuatu yang penting? Bagaimanakah anda memanjangkan atau menambah baik idea ini dalam projek anda sendiri?

Saya menggalakkan anda menerokai kod sumber dan menggunakan httpsuite terus dalam projek anda. Anda boleh mencari perpustakaan dalam repositori rluders/httpsuite. Maklum balas dan sumbangan anda amat berharga untuk menjadikan perpustakaan ini lebih mantap dan berguna untuk komuniti Go.

Jumpa anda semua pada yang seterusnya.

Atas ialah kandungan terperinci Meningkatkan Permintaan, Pengesahan dan Pengendalian Respons dalam Go Microservices. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!