Let’s Build a Movie API With Separated Layered Architecture Using Go | by Dilara Görüm | Apr, 2022

The aim of software program structure is to attenuate the human sources required to construct and preserve the required system. [1]

Picture by Felix Mooneeram on Unsplash

In my first article, we talked about testing with Go. Now, we are going to transfer ahead to see how we are able to check our movie API extra simply due to the three-layer structure.

The concept of a layered structure is constructed on the thought of programming to interfaces. When one module interacts with one other although an interface, you may substitute one service supplier for an additional [2].

Don’t fear! I’ll do my greatest to elucidate merely.

Let’s have a look at this diagram beneath. Look easy, proper?

The logic behind this structure each single layer has its personal accountability and they are going to be impartial of one another. In that approach, we are able to check them in a extra isolable approach. Yeap, once more testing!

What are the roles of those layers (handler, service, and repository)❓

Handler: It’s a layer which will get http request and returns http response to the shopper.

Service: It’s a layer the place our enterprise logic is in.

Repository: It’s a layer which supplies all essential knowledge from exterior (DBs) or inner (in-memory) knowledge supply. For simplicity, we use in-memory.

We have to discuss Dependency injection earlier than studying the position of interfaces in a diagram. Dependency injection relies on solely abstractions (interfaces) not concrete sorts (structs). In that method, we inject all our dependencies through the use of interfaces.

For instance, we could have two providers within the venture: MockService and DefaultService.With the assistance of the service interface, we are able to use the strategies of those two totally different structs within the Handler layer. In testing stage, Handler work together with MockService , alternatively, it work together with DefaultService in manufacturing.

Dependency Inversion Instance

Don’t fear, you’ll perceive higher after we’ll see the motion:

Truly, after we name the service technique in Handler and the repository technique in Service, its affordable to think about this relations as “name stack”.

That is the straightforward diagram that we did with the decision stack. Our laptop allocates reminiscence for our perform name.

Let’s think about this reminiscence as a field.

Our first name(in Handler) must be saved in reminiscence.

Then, our second name(in Service) is saved in reminiscence upon the Handler field.

Then, our third name(in Repository) is saved in reminiscence upon Service field. The tough is right here is that our service wants to attend for the repository perform to be performed. When it’s performed, our handler wants to attend for the service perform to be performed. When it’s performed, the Handler perform can do its work.

After it’s performed too, our stack shall be empty. That is how the decision stack works. You’ll be able to learn the ‘Grokking Algorithms Book’s Name Stack part to study extra.

That is the broad perspective of how our design is created. We will go deep into our venture. We are going to deal with simply an instance of PATCH request together with this text.

When the shopper ship request with PATCH technique, movieHandler’s UpdateMovie technique known as utilizing httprouter.

That is the primary layer the place our API will get HTTP request.

Handler is the layer which remodel response coming from service to http response. As you realize, HTTP response is constituted of a standing code, header and physique.

2b. Handler Testing

Earlier than persevering with testing of the handler, I need to introduce mockgen package. This bundle helps our code to check simply.

Give it the interface supply path which you need to mock, present it the place the auto-generated mock file shall be created and let it generate mock struct implementation on behalf of you. If we need to check the handler layer, we have to mock the service layer. We will try this set up it like this:

mockgen -source service/movie_service_interface.go -destination service/mock_movie_service.go -package service

Within the check file, we should always check potential errors and success circumstances to extend the check protection of the handler.

This layer contains our app enterprise logic. By separating enterprise logic into a particular layer, we are able to write unit assessments simply.

Like within the handler testing part, we have to mock our repository to check our service layer:

mockgen -source repository/movie_repository_interface.go -destination repository/mock_movie_repository.go -package repository

I provides you with a trick. Each time we alter interfaces that we give to mockgen, now we have to run mockgen command once more.

Till now, now we have two mock information and we have to write these lengthy codes time and again after we add a brand new technique to our interface. Such a tedious approach! The answer is Makefile. With the Makefile, we use simply generate-mockscommand to recreate our mock information.(make generate-mocks )

We’re testing potential errors by mocking the repository.

That is the place our knowledge integration is carried out:

We’re making an attempt to develop RESTful API, and within the creating course of, we need to positive it really works as anticipated. To make certain, we have to ship HTTP requests to our API.

You are able to do that each approach utilizing curl, Postman, Insomnia, and Jetbrains HTTP Client plugin, and so forth. I actually like to make use of Jetbrains HTTP Shopper plugin.

With the HTTP Shopper plugin, you may create, edit, and execute HTTP requests immediately within the IntelliJ IDEA code editor.

[1,2] Clear Structure A Craftsman’s Information to Software program Construction and Design (Robert C. Martin)

[3] 97 issues each programmer ought to know collective knowledge from the specialists by Kevlin Henney

More Posts