9 Composition patterns

This chapter champions Go’s composition-first philosophy: favor small, explicit pieces that can be combined over inheritance or sprawling frameworks. It shows how higher-order functions and implicit interfaces lead to reusable building blocks, and stresses consistent function signatures and explicit dependency injection for clarity and testability. Across HTTP services, it applies these ideas to cross-cutting concerns such as logging, tracing, encoding/decoding, and safe I/O, demonstrating how simple components compose into robust systems.

It begins with the middleware pattern, wrapping http.Handlers to add behavior like request/response logging without touching handler code. Response metrics are gathered via independent, chainable pieces (for example, Duration and StatusCode) collected in a Response value through a RecordResponse helper. To capture status codes, an Interceptor embeds http.ResponseWriter and intercepts WriteHeader. The chapter then explores the hazards of field embedding with optional interfaces (Flusher, Hijacker, Pusher), showing how type assertions and the standard ResponseController preserve optional behavior, and adds an Unwrap method so wrappers can expose the original ResponseWriter when needed.

For request-scoped telemetry, a traceid middleware injects IDs into Context and a custom slog.Handler automatically adds them as log attributes. The handler chaining pattern introduces a chainable hio.Handler and a Responder helper (Error, Redirect, Text, JSON) to enforce explicit returns and prevent subtle response bugs. JSON helpers simplify marshaling and unmarshaling, with validation discovered via anonymous interfaces. Finally, the chapter strengthens reliability by wrapping Request.Body with MaxBytesReader to bound input size and by unwrapping ResponseWriters so servers can disconnect clients that exceed limits—illustrating how careful wrapping, unwrapping, and interface-based composition yield simple, modular, and maintainable code.

Middleware layers process both incoming HTTP requests and outgoing HTTP responses, enhancing functionality without altering the handler code.

The middleware's handler forwards requests to ServeMux and then logs.

The logger middleware calls RecordResponse, which runs the Duration middleware to wrap the handler and calculate response duration. RecordResponse returns response metrics in a Response, which the logger middleware logs.

Interceptor captures HTTP status codes by intercepting WriteHeader.

Injecting and propagating trace IDs through the Request.Context.

Automatically adding log attributes to log records by wrapping the original log handler with a custom one that extracts trace IDs from Context.

Shorten delegates response processing to other handlers in the chain.

• We can pass functions to functions or return them from functions.
• Middleware adds extra functionality to handlers without modifying their code.
• The canonical middleware signature is func(http.Handler) http.Handler. This signature also allows us to chain multiple middleware (including third-party ones).
• Avoid package-level dependencies for testable and maintainable code.
• Be consistent in your function signatures for better composability.
• Expert packages improve maintainability by keeping related code together.
• Generic packages may introduce unnecessary dependencies, hurting maintenance.
• Use the standard library's slog package for structured logging.
• slog.Attr is a key-value pair to put in a log record. It can contain any value type.
• slog.String returns a slog.Attr value with a string value.
• slog.Any returns a slog.Attr value with any value.
• Use slog.Any to avoid unnecessary String method calls.
• slog.LogAttrs is more efficient than other slog.Logger methods.
• Avoid unnecessary coupling between types to improve composability.
• slices.Backward returns an iterator that iterates over a slice in reverse order.
• Embedding a type without a field name in a struct promotes its fields and methods, allowing automatic forwarding of method calls from the outer type to the inner.
• Embedding an interface makes the embedder satisfy the interface.
• Embedding can surprisingly change the embedder type's behavior.
• Intercept method calls by embedding an interface and add the methods to intercept.
• slog.Int returns a slog.Attr value with an int value.
• Optional interfaces help to detect extra functionality behind an interface.
• Concrete types behind interfaces may have additional methods.
• Type assertions can detect and extract the underlying type of an interface.
• Embedding an interface only adds that interface's methods to the embedder.
• Embedded interfaces can hide the capabilities of their underlying types.
• Implementing the Unwrap method allows ResponseController and handlers to unwrap the underlying ResponseWriter to access its functionalities.
• http.ResponseController is a concrete type that wraps an http.ResponseWriter and allows us to use optional functionalities of the underlying implementation.
• Context can implicitly propagate any value across package boundaries.
• context.WithValue attaches a single value to a new Context.
• Context.Value extracts an any value from a Context using a key.
• Context keys should be unique types to prevent key collisions.
• Context keys are often an unexported type to avoid collisions. Using an empty struct as the key type is common and avoids memory allocations.
• Use Context for storing request-scoped values. The values stored in a Context should inform but not control the program's flow. Storing many values in a Context can lead to memory leaks and make the code harder to maintain and test.
• slog.Logger handles slog.Record values with a slog.Handler.
• slog.Handler is an interface that defines the behavior of handling log records.
• slog.Handler.WithAttrs returns a new Handler that adds the given attributes to the log records. WithGroup returns a new Handler that groups log records.
• HTTP handler chaining patterns reduce the chances of unintentional mistakes, make the code more maintainable, and simplify repetitive tasks.
• Reducing unnecessary direct dependencies may improve modularity and flexibility.
• json.Marshal and json.Unmarshal are functions for encoding and decoding JSON.
• json only considers exported fields while encoding and decoding.
• Reading large payloads could lead to denial-of-service attacks (DoS).
• http.MaxBytesReader helps limit reading excessive request bodies. It can instruct http.Server using a method to disconnect clients that go beyond the limit.
• Type assertion with an anonymous interface that we can declare within a function makes it easier to unearth and use methods from the interface's underlying type.
• Avoid doing the caller's work; provide composable building blocks instead.
• Small, focused functions improve testability, maintainability, and composability.
• Composition reduces code duplication and prevents rigid abstractions.
• Packages that provide composable functionality and building blocks are often more reusable than packages with all-in-one solutions and do everything for users.

FAQ