Click the above“blue text” to follow us
“Yesterday, a young brother messaged me: ‘Brother Feng, our team leader said we need to use Go for microservices communication, what are Protocol Buffers and middleware chains? My head is buzzing!’ Haha, don’t worry, I’m familiar with this. Microservices are like a big kitchen, where each small chef is responsible for different dishes, and the HTTP middleware chain and Protocol Buffers are like the chefs’ ‘walkie-talkies’ and ‘recipe standards’. Today, I will introduce you to these two seemingly profound but actually quite practical technologies.”
Middleware Chain: A Complete Process of Security Check, Ticket Verification, and Entry
In Go, HTTP middleware is simply a series of security checks. Imagine you are going to a concert; you first go through security, then ticket verification, and finally entry. These three checkpoints are like a middleware chain, with each checkpoint performing a specific task. In web services, middleware serves as the layers of checkpoints in the request processing pipeline, commonly including logging, authentication, request parameter validation, etc.
Implementing a simple middleware in Go is actually quite easy:
func loggingMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Processing before the request arrives
start := time.Now()
fmt.Printf("Received request: %s %s\n", r.Method, r.URL.Path)
// Call the next middleware or final handler function
next.ServeHTTP(w, r)
// Final processing after the request is handled
fmt.Printf("Request processing completed, duration: %v\n", time.Since(start))
})
}See, it’s that simple! Remember, the essence of middleware lies in chain calls. Just like workers on an assembly line, each person only performs one task, but together they can handle complex tasks. Middleware is the same; simple yet powerful, a perfect embodiment of the single responsibility principle.
Protocol Buffers: The Slimmer Brother of JSON
When it comes to microservices communication, many people’s first reaction is JSON. However, when your service needs to handle thousands of requests per second, JSON’s bulky size can become a bit ‘burdensome’. At this point, Protocol Buffers (protobuf) is like a well-trained athlete, small in size, fast in speed, and efficient enough to make you shout with joy.
This serialization tool, open-sourced by Google, is 30% smaller than JSON and has a parsing speed that is 20-100 times faster. How to use it? Define a .proto file:
message User {
required string name = 1;
required int32 age = 2;
optional string email = 3;
}Then use the protoc compiler to generate Go code, and you can directly use this structure in your program. The charm of protobuf lies in its efficiency. Just like a hot pot restaurant’s menu, it doesn’t need fancy pictures and descriptions, just numbers and names, making it fast and accurate for transmission.
Middleware + Protobuf: The Golden Pair for Microservices
Back to our microservices kitchen. When an HTTP request arrives, it first goes through the layers of checks and processing in the middleware chain—logging, identity verification, traffic limiting… and finally reaches the business processing function. Here, we can use protobuf to efficiently parse the request body instead of traditional JSON.
In actual projects, I often use them in combination: middleware handles the pre-processing and post-processing of requests, while protobuf is responsible for efficient data serialization and deserialization. This combination ensures the standardization of request processing while improving data transmission efficiency. Just like a good chef, one must not only know how to cook but also choose the best ingredients and tools.
To make good use of this combination, the key is to understand their respective advantages. Middleware makes the code more modular, while protobuf makes communication more efficient. When your service needs to handle high-concurrency requests, this combination will unleash tremendous power.
“Alright, today’s technical tidbit ends here. Remember, technology is not as complicated as it seems; the key is to find the right methods and tools. Next time you see your team leader, you can talk confidently. However, just talking without practice is useless; hurry up and try it out!”
