Verbesserung der Anforderungs-, Validierungs- und Antwortverarbeitung in Go Microservices

In diesem Leitfaden wird erläutert, wie ich die Bearbeitung von Anfragen, Validierungen und Antworten in meinen Go-Microservices optimiert habe, um Einfachheit, Wiederverwendbarkeit und eine besser wartbare Codebasis zu erreichen.

Einführung

Ich arbeite schon seit geraumer Zeit mit Microservices in Go und schätze immer die Klarheit und Einfachheit, die diese Sprache bietet. Eines der Dinge, die ich an Go am meisten liebe, ist, dass nichts hinter den Kulissen passiert; Der Code ist immer transparent und vorhersehbar.

Einige Teile der Entwicklung können jedoch recht mühsam sein, insbesondere wenn es um die Validierung und Standardisierung von Antworten in API-Endpunkten geht. Ich habe viele verschiedene Ansätze ausprobiert, um dieses Problem anzugehen, aber kürzlich, als ich meinen Go-Kurs schrieb, kam mir eine eher unerwartete Idee. Diese Idee verlieh meinen Vorgesetzten einen Hauch von „Magie“, und zu meiner Überraschung gefiel sie mir. Mit dieser Lösung konnte ich die gesamte Logik für die Validierung, Dekodierung und Parameteranalyse von Anfragen zentralisieren sowie die Kodierung und Antworten für die APIs vereinheitlichen. Am Ende habe ich ein Gleichgewicht zwischen der Aufrechterhaltung der Codeklarheit und der Reduzierung sich wiederholender Implementierungen gefunden.

Das Problem

Bei der Entwicklung von Go-Microservices besteht eine häufige Aufgabe darin, eingehende HTTP-Anfragen effizient zu verarbeiten. Dieser Prozess umfasst typischerweise das Parsen von Anforderungstexten, das Extrahieren von Parametern, das Validieren der Daten und das Zurücksenden konsistenter Antworten. Lassen Sie mich das Problem anhand eines Beispiels veranschaulichen:

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

Lassen Sie mich den obigen Code erklären und mich dabei auf den Handler-Teil konzentrieren, in dem wir manuell handeln:

• Verwaltet Pfadparameter: Überprüfen Sie, ob die erforderlichen Pfadparameter vorhanden sind, und verarbeiten Sie sie.
• Dekodierung des Anfragetextes: Sicherstellen, dass der eingehende JSON korrekt analysiert wird.
• Validierung: Verwenden des Validierungspakets, um zu überprüfen, ob die Anforderungsfelder die Anforderungskriterien erfüllen.
• Fehlerbehandlung: Antwort an den Client mit entsprechenden Fehlermeldungen, wenn die Validierung fehlschlägt oder JSON fehlerhaft ist.
• Konsistente Antworten: Manuelles Erstellen einer Antwortstruktur.

Obwohl der Code funktionsfähig ist, umfasst er eine erhebliche Menge an Standardlogik, die für jeden neuen Endpunkt wiederholt werden muss, was die Wartung erschwert und anfällig für Inkonsistenzen ist.

Wie können wir das also verbessern?

Den Code aufschlüsseln

Um dieses Problem zu beheben und die Wartbarkeit des Codes zu verbessern, habe ich beschlossen, die Logik in drei verschiedene Ebenen aufzuteilen: Anfrage, Antwort und Validierung. Dieser Ansatz kapselt die Logik für jedes Teil, wodurch es wiederverwendbar und einfacher unabhängig zu testen ist.

Anforderungsschicht

Die Request-Ebene ist für das Parsen und Extrahieren von Daten aus den eingehenden HTTP-Anfragen verantwortlich. Durch die Isolierung dieser Logik können wir die Datenverarbeitung standardisieren und sicherstellen, dass die gesamte Analyse einheitlich durchgeführt wird.

Validierungsschicht

Die Ebene Validierung konzentriert sich ausschließlich auf die Validierung der analysierten Daten gemäß vordefinierten Regeln. Dadurch bleibt die Validierungslogik von der Anforderungsbearbeitung getrennt, sodass sie über verschiedene Endpunkte hinweg besser wartbar und wiederverwendbar ist.

Antwortschicht

Die Antwort-Ebene verwaltet die Erstellung und Formatierung von Antworten. Durch die Zentralisierung der Antwortlogik können wir sicherstellen, dass alle API-Antworten einer konsistenten Struktur folgen, was das Debuggen vereinfacht und die Client-Interaktionen verbessert.

Also... Obwohl die Aufteilung des Codes in Schichten Vorteile wie Wiederverwendbarkeit, Testbarkeit und Wartbarkeit bietet, geht sie mit einigen Kompromissen einher. Eine erhöhte Komplexität kann dazu führen, dass die Projektstruktur für neue Entwickler schwerer zu verstehen ist, und bei einfachen Endpunkten könnte sich die Verwendung separater Ebenen übertrieben anfühlen und möglicherweise zu Over-Engineering führen. Das Verständnis dieser Vor- und Nachteile hilft bei der Entscheidung, wann dieses Muster effektiv angewendet werden sollte.

Am Ende des Tages geht es immer darum, was dich am meisten stört. Rechts? Lassen Sie uns nun etwas an unserem alten Code arbeiten und mit der Implementierung der oben genannten Ebenen beginnen.

Refactoring des Codes in Ebenen

Schritt 1: Erstellen der Anforderungsschicht

Zuerst überarbeiten wir den Code, um die Anforderungsanalyse in eine dedizierte Funktion oder ein dediziertes Modul zu kapseln. Diese Ebene konzentriert sich ausschließlich auf das Lesen und Parsen des Anforderungstexts und stellt sicher, dass er von anderen Verantwortlichkeiten im Handler entkoppelt ist.

Erstellen Sie eine neue Datei 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)
}

Hinweis: An diesem Punkt musste ich Reflexion einsetzen. Wahrscheinlich bin ich viel zu dumm, um einen besseren Weg zu finden, es zu tun. ?

Damit wir das natürlich auch testen können, erstellen Sie die Testdatei 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())
}

Wie Sie sehen können, verwendet die Ebene Anfrage die Ebene Validierung. Allerdings möchte ich die Schichten im Code immer noch getrennt halten, nicht nur, um die Wartung zu vereinfachen, sondern weil ich möglicherweise auch die Validierungsschicht isoliert verwenden möchte.

Abhängig von den Anforderungen kann ich in Zukunft entscheiden, alle Ebenen isoliert zu halten und ihre gegenseitige Abhängigkeit durch die Verwendung einiger Schnittstellen zu ermöglichen.

Schritt 2: Implementierung der Validierungsschicht

Sobald die Anforderungsanalyse getrennt ist, erstellen wir eine eigenständige Validierungsfunktion oder ein eigenständiges Validierungsmodul, das die Validierungslogik verwaltet. Durch die Isolierung dieser Logik können wir sie einfach testen und konsistente Validierungsregeln auf mehrere Endpunkte anwenden.

Dazu erstellen wir die Datei 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)
}

Erstellen Sie nun die Testdatei 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())
}

Schritt 3: Aufbau der Antwortschicht

Schließlich überarbeiten wir die Antwortkonstruktion in einem separaten Modul. Dadurch wird sichergestellt, dass alle Antworten einem einheitlichen Format folgen, wodurch es einfacher wird, Antworten in der gesamten Anwendung zu verwalten und zu debuggen.

Erstellen Sie die Datei 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)
  })
 }
}

Erstellen Sie die Testdatei 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
}

Jeder Schritt dieser Umgestaltung ermöglicht es uns, die Handlerlogik zu vereinfachen, indem wir bestimmte Verantwortlichkeiten an klar definierte Ebenen delegieren. Auch wenn ich nicht bei jedem Schritt den vollständigen Code zeige, beinhalten diese Änderungen das Verschieben von Parsing, Validierung und Antwortlogik in ihre jeweiligen Funktionen oder Dateien.

Refactoring des Beispielcodes

Jetzt müssen wir den alten Code ändern, um die Ebenen zu verwenden, und mal sehen, wie es aussehen wird.

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

Durch die Umgestaltung des Handler-Codes in Ebenen für die Anforderungsanalyse, Validierung und Antwortformatierung haben wir die sich wiederholende Logik, die zuvor im Handler selbst eingebettet war, erfolgreich entfernt. Dieser modulare Ansatz verbessert nicht nur die Lesbarkeit, sondern verbessert auch die Wartbarkeit und Testbarkeit, indem jede Verantwortung fokussiert und wiederverwendbar bleibt. Da der Handler jetzt vereinfacht ist, können Entwickler bestimmte Ebenen leicht verstehen und ändern, ohne den gesamten Ablauf zu beeinträchtigen, wodurch eine sauberere, skalierbarere Codebasis entsteht.

Abschluss

Ich hoffe, dass diese Schritt-für-Schritt-Anleitung zur Strukturierung Ihrer Go-Microservices mit dedizierten Anforderungs-, Validierungs- und Antwortebenen Einblicke in die Erstellung sauberer und wartbarerer Codes gegeben hat. Ich würde gerne Ihre Meinung zu diesem Ansatz hören. Vermisse ich etwas Wichtiges? Wie würden Sie diese Idee in Ihren eigenen Projekten erweitern oder verbessern?

Ich empfehle Ihnen, den Quellcode zu erkunden und httpsuite direkt in Ihren Projekten zu verwenden. Sie finden die Bibliothek im Repository rluders/httpsuite. Ihr Feedback und Ihre Beiträge wären von unschätzbarem Wert, um diese Bibliothek noch robuster und nützlicher für die Go-Community zu machen.

Wir sehen uns alle im nächsten.

Das obige ist der detaillierte Inhalt vonVerbesserung der Anforderungs-, Validierungs- und Antwortverarbeitung in Go Microservices. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!