Explain the construction of restful API of spring boot in detail

The previous article explained how to access the database through the integration of spring boot with jdbctemplate, JPA and mybatis. Today, I will mainly share with you how to return data to the front end through spring boot.

In the current development process, in order to maximize the separation of front and rear ends, the back-end interface usually only provides data interface, and the front-end obtains data from the back-end through Ajax request, renders it and presents it to users. The most common method we use is that the back end will return a JSON string to the front end. The front end parses the JSON string to generate JavaScript objects, and then processes them. This article will demonstrate how spring boot implements this pattern. This article will focus on how to design a restful API and implement related APIs through spring boot. However, in order to better understand restful style APIs, we first design a traditional data return interface so that you can compare and understand.

1、 Support for non restful interfaces

Here, we take the article list as an example to implement an interface to return the article list. The code is as follows:

The implementation of this articleservice is very simple, which simply encapsulates the operation of articlemapper. For the content of articlemapper, you can refer to the previous article. The implementation classes of articleservice are as follows:

Run application Java, and then access: http://locahost:8080/article/list.json , you can see the following results:

Articleserviceimpl is a very common class. There is only one spring annotation @ service, which is identified as a bean to facilitate management through the spring IOC container. Let's take another look at the class of articlecontroller. In fact, those who have used spring MVC should be familiar with these annotations. Here's a brief explanation:

@Controller identifies a class as controller.

@The mapping of the requestmapping URL.

@The returned result of ResponseBody is converted into JSON string.

@Requestbody indicates to receive JSON format string parameters.

Through these three annotations, we can easily realize the function of returning JSON format data to the front end through the URL. But you must be a little confused. Aren't these all spring MVC things? What does it have to do with spring boot? In fact, the function of spring boot is to save us the configuration process. Other functions are indeed provided by spring and spring MVC. You should remember that spring boot provides us with automatic configuration services through various starters. This dependency has been introduced into our project before:

This is a jar package that all spring boot web projects need to introduce, that is, all spring boot web projects support the above functions by default. Here we further find that developing web projects through spring boot does save us a lot of configuration work.

2、 Restful API design

Well, let's now look at how to implement the restful API. In fact, restful itself is not a profound technology, but just a programming style, or a design style. In the traditional HTTP interface design, we generally only use the get and post methods, and then use our own defined vocabulary to represent different operations. For example, in the above query article interface, we define article / list JSON to represent the query article list, which can be accessed through get or post methods. The restful API is designed to represent crud related operations through HTTP. Therefore, in addition to the get and post methods, other HTTP methods, such as put, delete, head, etc., are used to represent operations with different meanings through different HTTP methods. The following is a group of restful APIs I designed to add, delete, modify and query articles:

It can be seen that the URL is only the way to identify the resource, and the specific behavior is specified by the HTTP method.

3、 Restful API implementation

Now let's take a look at how to implement the above interface. Let's not talk about others, but directly look at the code:

Let's analyze this code again. The difference between this code and the previous code is:

(1) We use the annotation @ restcontroller instead of @ controller, but this annotation is also not provided by spring boot, but the annotation provided in spring mvc4, indicating a controller that supports restful.

(2) Three URL mappings in this class are the same, i.e. / article / {ID}, which is not allowed in the class identified by @ controller. Here can be distinguished by method. The function of produces is to indicate that the type of returned result is JSON.

(3) The @ pathvariable annotation is also provided by spring MVC to indicate that the value of the variable is obtained from the access path.

So it seems that this code has nothing to do with spring boot. Spring boot only provides automatic configuration, which is a very important reason why spring boot is very comfortable to use, because its intrusion is very, very small, and you can hardly feel its existence.

4、 Testing

After the code is written, how to test it? Except for the get method, we can't access it directly through the browser. Of course, we can send various HTTP requests directly through postman. However, I still support testing various methods through unit test classes. Here we will test various methods through JUnit:

The implementation results will not be posted here. If you are interested, you can experiment by yourself. There are still few points to be explained in the whole class. These things have nothing to do with spring boot. The reason for supporting these operations is the introduction of the corresponding starter mentioned in the previous article:

Because HTTP requests need to be executed, mockmvc is used here. Articlerestcontroller is instantiated by injection and cannot directly new. Otherwise, articlerestcontroller cannot be managed through spring IOC container, so other classes it depends on cannot be injected normally. Through mockmvc, we can easily implement HTTP delete / put / post and other methods.

5、 Summary

This article explains that if restful APIs are implemented through spring boot, spring and spring MVC actually provide most of the things. Spring boot only provides the function of automatic configuration. However, it is this automatic configuration that reduces a lot of development and maintenance work for us, so that we can implement a web project more simply and efficiently, so that we can focus more on the development of the business itself without caring about the framework. In this article, we mentioned that the restful interface can be accessed through postman and JUnit. In the next article, we will introduce another way to access it. Those who are interested can continue to pay attention to it.

The above is the whole content of this article. I hope it will be helpful to your study, and I hope you can support programming tips.