Implementing a REST API server with caching in Go

1. REST API principles

REST (Representational State Transfer) is an architectural style for designing APIs over HTTP protocol, used to build network applications in distributed systems. REST API (RESTful API) is an application programming interface based on this design style. Its main advantage is its great flexibility. As long as data needs to be provided directly from the server to the users of a web application or site, developers can use REST API directly to achieve it.

The design goal of REST API is to create a simple, scalable, maintainable and readable interface to facilitate effective communication between clients and servers. By using the HTTP protocol and a set of unified design principles, REST API has some specific properties in its implementation:

• Resources: In REST, data or services are considered resources. Each resource has a unique identifier that is used to identify and locate the resource on the network.
• Representation: The state of a resource can be presented in different representations, such as JSON, XML, or HTML. The client can interact with the server by requesting a specific representation.
• Stateless: REST is stateless, which means that each request from the client to the server contains enough information that the server does not need to store the client's state. Each request should contain all the information needed to perform the request.
• Uniform Interface: The design of RESTful API should follow consistent interface principles to make communication between different components simple and unified.
• Stateless Communication: Each request from the client to the server should contain enough information so that the server can understand and process the request without relying on previous requests.
• Cacheability: The REST API supports caching to improve performance and reduce the burden on the server. The server can specify a data caching strategy in the response, and the client can use the cache to avoid repeatedly requesting the same data.
• Use standard methods: REST uses standard HTTP methods, such as GET, POST, PUT, and DELETE, to perform different operations. These methods correspond to different operations on resources, making the use of the API more intuitive and in line with HTTP standards.

2. REST API server design

Next, I will use Go language to design a REST API server. The simulation scenario here is to provide article addition, deletion, and query services through the server. There are two ways to query articles: 1. Query all article contents on the server. 2. Query the content of a certain article based on the article ID.

The attributes of an article include three fields: article ID, article title, and article content, which can be represented by a structure:

 type Article struct { ID string `json:"id,omitempty"` Title string `json:"title,omitempty"` Content string `json:"content,omitempty"` }

Since we have designed four functional interfaces, we convert them into the interface code framework as follows:

 // 获取所有文章接口func GetArticles(w http.ResponseWriter, r *http.Request) { ... } // 获取单篇文章接口func GetArticle(w http.ResponseWriter, r *http.Request) { ... } // 创建文章接口func CreateArticle(w http.ResponseWriter, r *http.Request) { ... } // 删除文章接口func DeleteArticle(w http.ResponseWriter, r *http.Request) { ... }

3. Function code implementation

First, implement the interface for obtaining all articles. The specific reference code is as follows:

 // 获取所有文章func GetArticles(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") // 尝试从缓存中获取文章列表if cachedArticles, found := articleCache.Load("all"); found { json.NewEncoder(w).Encode(cachedArticles) return } // 从原始数据源获取文章列表json.NewEncoder(w).Encode(Articles) // 将文章列表存入缓存articleCache.Store("all", Articles) }

To get all articles, we first try to get the article list from the cache. The cache cachedArticles is actually a variable of type sync.Map, which supports concurrency safety. If found, it is directly serialized into JSON format and returned. If not found in the cache, the article list is obtained from the original data source (in actual applications, it should be obtained from the database) and serialized into JSON and returned. The article list is then stored in the cache.

Next, implement the second interface and query by article ID. The reference code is as follows:

 // 获取单篇文章func GetArticle(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") params := mux.Vars(r) // 尝试从缓存中获取单个文章if cachedArticle, found := articleCache.Load(params["id"]); found { json.NewEncoder(w).Encode(cachedArticle) return } // 从原始数据源获取单个文章for _, article := range Articles { if article.ID == params["id"] { json.NewEncoder(w).Encode(article) // 将单个文章存入缓存articleCache.Store(params["id"], article) return } } json.NewEncoder(w).Encode(&Article{}) }

First, the ID parameter passed in is searched in the cache. If found, the JSON data is directly returned. If not found, the search continues in the article list and the single article is stored in the cache.

The reference code for creating an article interface is as follows:

 // 创建文章func CreateArticle(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") var article Article _ = json.NewDecoder(r.Body).Decode(&article) Articles = append(Articles, article) // 清除所有文章缓存articleCache.Delete("all") json.NewEncoder(w).Encode(Articles) }

When creating an article list, it should be noted that in order to maintain cache consistency and avoid dirty data, the cache is cleared so that the latest cache can be updated the next time GetArticles() is called.

Similarly, it is not difficult to implement the interface for deleting articles:

 // 删除文章func DeleteArticle(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") params := mux.Vars(r) // 清除单个文章缓存articleCache.Delete(params["id"]) for index, article := range Articles { if article.ID == params["id"] { Articles = append(Articles[:index], Articles[index+1:]...) break } } // 清除所有文章缓存articleCache.Delete("all") json.NewEncoder(w).Encode(Articles) }

Finally, in the main function, we need to add some data to the list to simulate the number of articles saved by the server, and define the routes of the four interfaces. The overall code is as follows:

 package main import ( "encoding/json" "log" "net/http" "sync" "github.com/gorilla/mux" ) // Article 结构体表示API 中的数据模型type Article struct { ID string `json:"id,omitempty"` Title string `json:"title,omitempty"` Content string `json:"content,omitempty"` } // Articles 数组用于存储文章数据var Articles []Article var articleCache sync.Map // 获取所有文章func GetArticles(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") // 尝试从缓存中获取文章列表if cachedArticles, found := articleCache.Load("all"); found { json.NewEncoder(w).Encode(cachedArticles) return } // 从原始数据源获取文章列表json.NewEncoder(w).Encode(Articles) // 将文章列表存入缓存articleCache.Store("all", Articles) } // 获取单个文章func GetArticle(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") params := mux.Vars(r) // 尝试从缓存中获取单个文章if cachedArticle, found := articleCache.Load(params["id"]); found { json.NewEncoder(w).Encode(cachedArticle) return } // 从原始数据源获取单个文章for _, article := range Articles { if article.ID == params["id"] { json.NewEncoder(w).Encode(article) // 将单个文章存入缓存articleCache.Store(params["id"], article) return } } json.NewEncoder(w).Encode(&Article{}) } // 创建文章func CreateArticle(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") var article Article _ = json.NewDecoder(r.Body).Decode(&article) Articles = append(Articles, article) // 清除所有文章缓存articleCache.Delete("all") json.NewEncoder(w).Encode(Articles) } // 删除文章func DeleteArticle(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") params := mux.Vars(r) // 清除单个文章缓存articleCache.Delete(params["id"]) for index, article := range Articles { if article.ID == params["id"] { Articles = append(Articles[:index], Articles[index+1:]...) break } } // 清除所有文章缓存articleCache.Delete("all") json.NewEncoder(w).Encode(Articles) } func main() { // 初始化数据Articles = append(Articles, Article{ID: "1", Title: "Article 1", Content: "Content 1"}) Articles = append(Articles, Article{ID: "2", Title: "Article 2", Content: "Content 2"}) // 创建路由器router := mux.NewRouter() // 定义路由处理程序router.HandleFunc("/articles", GetArticles).Methods(http.MethodGet) router.HandleFunc("/articles/{id}", GetArticle).Methods(http.MethodGet) router.HandleFunc("/articles", CreateArticle).Methods(http.MethodPost) router.HandleFunc("/articles/{id}", DeleteArticle).Methods(http.MethodDelete) // 启动服务器log.Fatal(http.ListenAndServe(":8080", router)) }

4. Actual operation effect

Run the server locally, the server will listen to port 8080 locally, enter the browser: http://127.0.0.1:8080/articles, this interface will get all articles, as shown in the figure:

Use the API interface to query an article by article ID. The interface request is as follows:

Adding a new article is a POST request. Here, the POST request is mainly sent through Apifox, as shown in the figure:

From the returned results, a new record has been successfully added. Let's use the Get All Articles API again, as shown in the figure:

The new record is indeed added successfully.

Finally, still through Apifox, we send a request to delete the article with ID 2, as shown in the figure:

From the result returned by Apifox, it can be seen that the deletion was successful. Now let's get all the articles, as shown in the figure:

All interfaces have been successfully verified.