Learning the design model is to solve practical problems in enterprise-level development and improve code structure, maintainability and scalability. 1. Use interface abstract behavior, such as defining the Repository interface to achieve database access layer decoupling, making testing easier, switching implementation more convenient, and reducing module dependence; 2. Use Option mode to configure complex objects, and flexibly set through function options construction, such as dynamically adding timeouts, proxy and other configurations when creating HTTP clients; 3. Use decorator mode to enhance functions without modifying the original logic, such as adding logs, monitoring and other functions through middleware decorators, which are suitable for Web frameworks and RPC services.

Learning design models, especially the Go design models for enterprise-level development, is not to show off skills, but to solve practical problems. In large systems, code structure, maintainability and scalability are very important, and the design pattern is a set of effective solutions summarized by predecessors.

The following aspects are the most common and useful design model ideas I encounter when writing enterprise-level projects using Go.

Use interfaces to abstract behavior and decouple core logic

The Go interface is lightweight, but powerful. Especially in enterprise applications, it is often necessary to separate business logic and specific implementation. For example, in the database access layer, we usually define a Repository interface and then implement it according to different data sources (MySQL, PostgreSQL, Mock).

The benefits of doing this are obvious:

• Testing is easier: Mock can be injected
• Switching implementation is more convenient: For example, if you change from MySQL to MongoDB, just change the implementation, and do not change the caller.
• Reduce inter-module dependencies: The caller only relies on the interface and does not care about the specific type

For example, you might write a UserRepository interface that contains GetByID(id string) (*User, error) method, and then use different implementations in different environments.

Configure complex objects using Option mode

When building objects with many configuration items, it is easy to become confusing to directly pass multiple parameters or use the struct initializer. At this time, you can use the "Option mode", that is, through a series of function options to construct the object.

For example, if we want to create an HTTP client, there may be options such as timeout, number of retries, proxy settings, etc. If you use Option mode, you can write this:

 type ClientOption func(*Client)

func WithTimeout(d time.Duration) ClientOption {
    return func(c *Client) {
        c.timeout = d
    }
}

func NewClient(options ...ClientOption) *Client {
    c := &Client{
        timeout: 5 * time.Second,
        // Other default values...
    }
    for _, opt := range options {
        opt(c)
    }
    Return c
}

This makes it very flexible when calling:

 client := NewClient(WithTimeout(10*time.Second), WithProxy("http://proxy.local"))

This method is very common in enterprise-level libraries, for example, many open source projects use this method to handle configuration.

Use the decorator mode to enhance functions without modifying the original logic

Sometimes we need to add some general functions without changing the original functions or methods, such as logging, monitoring, permission checking, etc. At this time, you can consider using the Decorator mode.

Go's function is a first-class citizen, so it is very natural to implement. For example, we can write a middleware decorator and do some things before and after executing a handler:

 func WithLogging(fn http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        log.Printf("Handling request: %s", r.URL.Path)
        fn(w, r)
        log.Printf("Finished handling: %s", r.URL.Path)
    }
}

Then when registering the route, you can wrap it:

 http.HandleFunc("/user", WithLogging(userHandler))

This approach is very practical in web frameworks and RPC services, and can make your function extension cleaner.

Basically that's it. Go's design pattern does not have a complete set of standard writing methods like Java, but it is more about solving problems with language features. After understanding these common patterns, you will find that the code you write is easier to maintain and more suitable for teamwork.

The above is the detailed content of Go Design Patterns for Enterprise Solutions. For more information, please follow other related articles on the PHP Chinese website!