Shulou(Shulou.com)05/31 Report--

In this article, the editor introduces in detail "how to build RESTful API services based on Go language". The content is detailed, the steps are clear, and the details are handled properly. I hope this article "how to build RESTful API services based on Go language" can help you solve your doubts.

What is RESTful API?

RESTful API is a set of specifications that regulate how we operate on resources on the server. Before I know about RESTful API, let me introduce you to HTTP Method, because RESTful API and it are inseparable.

When it comes to HTTP Method, the most common ones are POST and GET. In fact, in the first version of HTTP 0.9, there was only one GET method, which is an idempotent method used to obtain resources on the server, that is, we enter the URL enter request directly in the browser.

In HTTP version 1.0, HEAD and POST methods are added, in which the POST method is commonly used, which is generally used to submit a resource to the server, resulting in changes in the server's resources.

As the network becomes more and more complex, we find that these two methods are not enough, so we continue to add new methods. So in the HTTP1.1 version, the number has increased to nine in one breath, with new methods such as HEAD, OPTIONS, PUT, DELETE, TRACE, PATCH and CONNECT. Now let me introduce their functions to you one by one.

The GET method can request a representation of a specified resource, and requests using GET should only be used to get data.

The HEAD method is used to request the same response as the GET request, but there is no response body.

The POST method is used to commit an entity to a specified resource, usually resulting in state changes or side effects on the server.

The PUT method is used to request a payload to replace all current representations of the target resource.

The DELETE method is used to delete the specified resource.

The CONNECT method is used to establish a tunnel to the server identified by the target resource.

The OPTIONS method is used to describe the communication options of the target resource.

The TRACE method is used to perform a message loopback test along the path to the target resource.

The PATCH method is used to apply partial modifications to resources.

From the introduction of each method above, we can see that the HTTP specification gives a clear definition for each method, so we should follow these definitions as much as possible when we use them, so that we can better cooperate in development.

By understanding these HTTP methods, you can better understand the RESTful API specification, because the RESTful API specification is based on these HTTP methods to regulate our operations on server resources, as well as the style and HTTP Status Code of URL.

In RESTful API, the following five HTTP methods are mainly used:

GET, which means to read resources on the server

POST, which means to create a resource on the server

PUT, which means to update or replace resources on the server

DELETE, which means to delete resources on the server

PATCH, which means to update / modify part of a resource.

The above HTTP method is an operation in the RESTful API specification, which operates on the resources of the server, which are represented by a specific URL.

Now let's give you some examples to better understand RESTful API, as follows:

HTTP GET http://localhost:1000/usersHTTP GET http://localhost:1000/user/123

The above are examples of two GET methods:

The first one means to get information about all users.

The second means to get the information of the user whose ID is 123.

Let's look at another example of the POST method, as shown below:

HTTP POST http://localhost:1000/user

This example represents the creation of a user and provides the server with all the information needed to create the user through the POST method.

Now that you know how to create a user, what do you do if you want to update a particular user? In fact, it is also very simple, and the sample code is as follows:

HTTP PUT http://localhost:1000/user/123

This means that the user whose ID is 123 will be updated / replaced, and all the user information needed to update the user will be provided through the PUT method during the update. The difference between the PUT method and the POST method here is that, from the URL point of view, the PUT method operates on a single resource, such as the user with an ID of 123 here.

Seeing here, I believe you already know how to delete a user. The sample code is as follows:

HTTP DELETE http://localhost:1000/user/123

The use of the DELETE method is the same as the PUT method, which manipulates a single resource, in this case the user whose ID is 123 is deleted.

A simple RESTful API

I'm sure you already know a lot about RESTful API, and from now on, I'll take you through an example of using Golang to implement RESTful API style to deepen your understanding of RESTful API.

One of the great advantages of Go language is that it is easy to develop network background services with fast performance and high efficiency. When developing the back-end HTTP network application service, we need to deal with a lot of HTTP request access, such as the common RESTful API service, we have to process a lot of HTTP requests, and then return the processed information to the consumer. For this type of requirement, Golang provides a built-in net/http package to help us process these HTTP requests, making it easier for us to develop a HTTP service.

Let's take a look at a simple Go language implementation of the HTTP service, with the following code:

Func main () {http.HandleFunc ("/ users", handleUsers) http.ListenAndServe (": 1000", nil)} func handleUsers (w http.ResponseWriter, r * http.Request) {fmt.Fprintln (w, "ID:1,Name: Zhang San") fmt.Fprintln (w, "ID:2,Name: Li Si") fmt.Fprintln (w, "ID:3,Name: Wang Wu")}

After this example runs, you can type http://localhost:1000/users, in your browser and you will see the following information:

ID:1,Name: Zhang San

ID:2,Name: Li Si

ID:3,Name: Wang Wu

That is to get all the user information, but this is not a RESTful API, because users can not only get all the user information through the HTTP GET method, but also get all the user information through POST, DELETE, PUT and other HTTP methods, which obviously does not conform to the RESTful API specification.

Now I modify the above example to make it conform to the RESTful API specification, and the modified sample code is as follows:

Func handleUsers (w http.ResponseWriter, r * http.Request) {switch r.Method {case "GET": w.WriteHeader (http.StatusOK) fmt.Fprintln (w, "ID:1,Name: Zhang San") fmt.Fprintln (w, "ID:2,Name: Li Si") fmt.Fprintln (w, "ID:3,Name: Wang Wu") default: w.WriteHeader (http.StatusNotFound) fmt.Fprintln (w, "not found")}}

Here I only modify the handleUsers function to add that all users' information is obtained only when the GET method is used, and not found is returned in other cases.

If you run this example again, you will find that you can only access it through the HTTP GET method, and using other methods will prompt not found.

RESTful JSON API

The most common thing in a project is to use JSON format to transmit information, that is, we provide RESTful API to return JSON content to the user.

Also using the above example, I transformed it into a way to return JSON content, with the sample code as follows:

/ / data source Similar to the data in MySQL var users = [] User {{ID: 1 GET name: "Zhang San"}, {ID: 2 Magi name: "Li Si"}, {ID: 3 language name: "Wang Wu"},} func handleUsers (w http.ResponseWriter, r * http.Request) {switch r.Method {case "GET": users Err:=json.Marshal (users) if erratum nil {w.WriteHeader (http.StatusInternalServerError) fmt.Fprint (w, "{" message ":" + err.Error () + ""} ")} else {w.WriteHeader (http.StatusOK) w.Write (users)} default: w.WriteHeader (http.StatusNotFound) fmt.Fprint (w "{" message ":" not found "}")}} / / user type User struct {ID int Name string}

As you can see from the above code, the main purpose of this transformation is to create a new User structure, and use the slice users to store all users, and then convert it to a JSON array in the handleUsers function. In this way, RESTful API based on JSON data format is implemented.

Run this example, type http://localhost:1000/users in the browser, and you can see the following information:

[{"ID": 1, "Name": "Zhang San"}, {"ID": 2, "Name": "Li Si"}, {"ID": 3, "Name": "Wang Wu"}]

This is already the user information in JSON format, including all users.

Gin framework

Although the net/http package that comes with the Go language makes it relatively easy to create HTTP services, it also has many shortcomings:

You cannot register specific handlers for request methods (POST, GET, etc.) separately

Path variable parameters are not supported

Path cannot be calibrated automatically

The performance is average

Based on these shortcomings, there are many Golang Web frameworks, such as Mux,Gin, Fiber and so on. Today I would like to introduce to you the most frequently used Gin framework.

Introduction of Gin framework

Gin framework is an open source Web framework on Github, which encapsulates many common functions needed by Web development, and the performance is also very high, which allows us to easily write RESTful API.

The Gin framework is actually a module, that is, Go Mod, so it can be introduced using the method of Go Mod. First, you need to download and install the Gin framework. The installation code is as follows:

Go get-u github.com/gin-gonic/gin

Then you can import and use it in the Go language code, as follows:

Import "github.com/gin-gonic/gin"

With the above installation and import steps, you can use the Gin framework in your Go language project.

Use the Gin framework

Now that the Gin framework has been introduced, I'll rewrite the above example with the Gin framework, with the modified code as follows:

Func main () {r:=gin.Default () r.GET ("/ users", listUser) r.Run (": 1000")} func listUser (c * gin.Context) {c.JSON (200)}

Compared to the net/http package, the code of the Gin framework is very simple. Through its GET method, you can create a service that only handles the HTTP GET method, and it is also very easy to output data in JSON format, using the c.JSON method.

Finally, the HTTP service is started through the Run method, and the listening is on port 1000. Now run the Gin example, type http://localhost:1000/users into the browser, and you will see the same information as achieved through the net/http package.

Add a new user

Now that you can use Gin to get all users and specific users, you should also know how to add a user. Now I use Gin to implement how to add a user to see if it is similar to what you want.

According to the RESTful API specification, the new implementation uses the POST method, and the format of URL is http://localhost:1000/users. If you send data to this URL, you can add a new user and return the created user information.

Now I use the Gin framework to implement a new user, and the sample code is as follows:

Func main () {/ / omit the unchanged code r.POST ("/ users", createUser)} func createUser (c * gin.Context) {name: = c.DefaultPostForm ("name", ") if name! =" {u: = User {ID: len (users) + 1, Name: name} users = append (users, u) c.JSON (http.StatusCreated,u)} else {c.JSON (http.StatusOK) Gin.H {"message": "Please enter user name",})}}

The main logic of the above new users is to obtain the name value uploaded by the client, then generate a User user, and finally store it in the users collection to achieve the purpose of adding new users.

In this example, the POST method is used to add new users, so the new users can only be successfully added through the POST method.

Now run the example, and then send a request for a new user with the following command to view the result:

➜curl-X POST-d "name=Ele" http://localhost:1000/users

{"ID": 4, "Name": "Ele"}

You can see that the new users are successful and the new users are returned, as well as the assigned ID.

Get a specific user

Now that you know how to create a simple RESTful API using the Gin framework and return all user information, how do you get information about specific users?

Below, I use the Path path parameter of the Gin framework to obtain the information of a specific user. The sample code is as follows:

Func main () {/ / omit the unchanged code r.GET ("/ users/:id", getUser)} func getUser (c * gin.Context) {id: = c.Param ("id") var user User found: = false / / similar to database SQL query for _, u: = range users {if strings.EqualFold (id) Strconv.Itoa (u.ID)) {user = u found = true break}} if found {c.JSON (200, user)} else {c.JSON (404, gin.H {"message": "user does not exist",})}}

In the Gin framework, colons are used in the path to indicate Path path parameters, such as: id in the example, and then in the getUser function, you can get the ID value of the user you want to query through c.Param ("id"). The parameters of the PS:Param method should be the same as those in the Path path parameters, such as ID in the example.

Now run this example and visit http://localhost:1000/users/4 through a browser to get a user with an ID of 4. The output information is as follows:

{"ID": 4, "Name": "Ele"}

As you can see, the user whose ID is 4 has been correctly obtained, and his name is Ele.

If we visit an ID that does not exist, what will we get? For example, 99, the example is as follows:

Curl http://localhost:1000/users/99

{"message": "user does not exist"}

As you can see from the sample output above, the message "user does not exist" is returned, just like the logic handled in our code.

After reading this, the article "how to build RESTful API Services based on Go language" has been introduced. If you want to master the knowledge points of this article, you still need to practice and use it yourself. If you want to know more about related articles, welcome to follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.