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.
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.
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:
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?
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 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 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.
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.
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.
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())
}
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.
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.
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!
Cara membetulkan get laluan lalai komputer tidak tersedia
Bagaimana untuk mendayakan fungsi bandar yang sama pada Douyin
Semak ruang cakera dalam linux
Bagaimana untuk mengecas semula Ouyiokx
permainan ipad tiada bunyi
titik simbol khas
kekunci pintasan komen python
Penjelasan popular tentang maksud Metaverse XR
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
