Build Scalable Microservices with Spring Boot: A Step-by-Step Guide

Microservices breaks down a monolithic application into a collection of smaller, decoupled spring boot microservices. These microservices in spring boot focus on distinct business capabilities and can be developed and deployed independently.

Spring Boot is a popular Java framework that simplifies building production-grade spring boot microservices. It reduces a lot of boilerplate code through auto-configuration and starter dependencies. This enables faster development of java spring boot microservices.

Now that you have some idea about microservices and spring boot let’s see the reasons why you should choose spring boot microservices.

Advantages of Spring Boot Microservices

Spring boot has many features and tools, making it an ideal choice for developing java microservices framework like spring boot. Below mentioned are the reasons why you should choose spring boot microservices.

Rapid Development

This drastically cuts down on development time, as Spring Boot adheres to convention over configuration. Rapid project iterations are encouraged by its simplified setup and defaults, which free up engineers to concentrate on business logic.

Built-in Conventions

The standardized structure provided by Spring Boot gives projects reasonable defaults and conventions. Collaboration between development teams and between microservices is made easier by this consistency, which encourages code clarity.

Microservice Specific Features

With capabilities like load balancing, service discovery, and centralized configuration management, Spring Boot is designed specifically for microservices architecture. These characteristics improve the general efficiency of microservices by making the development and deployment process simpler.

Embedded Servers

External server setup is no longer necessary thanks to the embedded servers. With Spring Boot, microservices may be easily deployed and scaled independently thanks to its embedded servers, such as Tomcat, Jetty, and Undertow.

Community Support

The community at Spring Boot is lively and engaged. This makes problem-solving and continuous improvement more approachable by guaranteeing that developers have access to a multitude of tools, training, and experience.

Ecosystem Integration

Spring Boot, when compared to Spring alone, is a constituent of the broader Spring ecosystem, it works well with other Spring projects. The adaptation of extra parts and tools to improve the overall development experience is made easier by this integration.

Production Ready Defaults

Production readiness is a priority in the design of Spring Boot. It lessens the friction between the development and deployment processes by providing production-ready configurations and appropriate defaults.

Challenges of Spring Boot Microservices

While spring boot offer multiple pros, it also comes with fair share of challenges. Mitigating these challenges is crucial for developing robust and scalable spring boot microservices architecture. Here are some of the common challenges associated with spring boot microservices:

Service Coordination

Challenge

Managing communication and guaranteeing smooth interactions between services get more difficult as the number of microservices increases.

Mitigation

Optimize request distribution through load balancing and implement efficient service discovery techniques with tools such as Spring Cloud Eureka.

Data Consistency

Challenge

In distributed transactions, it can be particularly difficult to maintain consistency across microservices sharing data.

Mitigation

When implementing compensatory transactions, take eventual consistency into account, choose the consistency model that makes the most sense for your application.

Distributed Tracing & Monitoring

Challenge

In a distributed system, tracking and monitoring requests between microservices for debugging and performance analysis might be difficult.

Mitigation

Utilize monitoring tools to keep an eye on the general health of the system and integrate distributed tracing tools like Zipkin or Sleuth to follow requests as they move among microservices.

Security Concerns

Challenges

It might be difficult to handle authentication, maintain consistency in authorization, and guarantee safe communication between microservices.

Mitigations

Apply strong security precautions by utilizing additional authentication and permission methods, such as OAuth or Spring Security. Use SSL to ensure secure communication.

Testing Challenges

Challenges

Because microservices are distributed in nature, testing them separately and making sure the system functions can be difficult.

Mitigations

Conduct integration testing, use technologies such as Spring Cloud Contract for contract testing, and implement thorough unit testing for each microservice.

Continuous Integration & Deployment

Challenges

Versioning, compatibility, and maintaining a consistent release cycle are problems that arise when coordinating continuous integration and deployment across multiple microservices.

Mitigation

To expedite deployment procedures, establish a strong continuous integration/continuous development (CI/CD) pipeline and leverage orchestration tools like Kubernetes and containerization technologies like Docker.

Resilience and Fault Tolerance

Challenges

For system availability to be maintained, it is imperative to ensure fault tolerance and develop microservices that are resilient to faults.

Mitigations

Use tools such as Spring Cloud Netflix Hystrix to implement resilience patterns such as circuit breakers, retry mechanisms, and fallback techniques.

Microservices Decomposition

Challenges

It can be difficult to opt on suitable boundaries for microservices and to make sure that the monolith is properly broken down.

Mitigations

Observe the principles of domain-driven design, recognize limited contexts, and refine the decomposition of microservices iteratively in response to changing requirements and business demands.

You should now be aware of the benefits and limitations of using microservices with Spring Boot. Let’s now examine the architecture of the system.

Spring Boot Microservices Architecture

Spring Framework, a widely embraced Java application framework and inversion of control container, is pivotal in developing resilient enterprise applications. It thrives on:

• Fostering loose component coupling through dependency injection.
• Employing a declarative programming model and aspect-oriented programming to segregate cross-cutting concerns.
• Providing abstraction and encapsulation over lower-level APIs and frameworks.

Core Container

At its heart, the Spring container adeptly manages Java objects throughout their lifecycle, handling tasks such as dependency injection, executing lifecycle callbacks, and applying AOP advices. Noteworthy advantages include simplified configuration achieved through either pure Java code or XML.

Data Access & Integration

The Spring Framework abstracts complexities in data access technologies, simplifying database and transaction management. It seamlessly integrates with prominent object-relational mapping APIs like JPA and JDO for persistence. For NoSQL stores, Spring extends support through integration modules.

Web Framework

Spring’s Web module offers a robust Model-View-Controller framework, catering to web application development. It encompasses RESTful endpoints, WebSocket integration, testability, and adaptability into other frameworks. Furthermore, it seamlessly integrates with UI technologies such as Struts and JSF.

AOP & Aspects

Navigating system-level concerns in distributed programming and modularization, Spring Framework utilizes straightforward abstractions over Aspect-Oriented Programming. This proves invaluable in implementing cross-cutting functionality like logging, auditing, and transactions without muddling domain or business logic.

In short, Spring Framework’s mission is to streamline enterprise Java development. It achieves this through managed components, a user-friendly programming model centred on Plain Old Java Objects (POJOs), and seamless integration with prevalent frameworks and APIs.

Now that you’ve understand microservices using spring boot, let’s move forward to spring boot microservice example.

Practical Example of Developing Spring Boot Microservices

In this Spring boot microservices tutorial, we will start from scratch, and only use bare minimum, after that slowly build on the top of it.

Prerequisite

• Java
• Spring Boot

When you’re building microservices each spring boot microservice, is an different spring boot application & for this spring boot microservice example, we are going to make three microservices with spring boot.

And for the example, I’ve picked for this is Goodreads. Hopefully you’re aware of this, and if you’re not, Goodreads is a website that let’s you catalogue the books that you’ve read or you want to read. It let’s you add the books you want to read in your reading list. Apart from this, you can also leave the review and rate the book that you’ve read. You can also follow the authors there and be updated about book release, special offers and more.

We are going to create something like that but on the small scale. So, basically the idea here is to develop an app where anyone can add the books that they have read & add rating for the same.

To start from bare minimum, we are going to develop 2 microservices which have information about books and ratings as well. Here the 3^rd microservice is going to get the data & combine it and send back the response.

In nutshell, here we are going to:

• Create 3 spring boot projects
• Build a book_catalog_service API
• Build a book_info_service API
• Build a rating_review_service API
• Have book catalogue service call the other two services

Note: Until the 5^th step these are not really microservices these are separate spring boot applications,  They turn into the microservices when they communicate

Let’s begin by creating microservices.

So here the question arises is how can you create the microservices?

There are three ways in which you can create the 3 spring boot applications

1. Using Maven & adding dependencies
2. Utilizing Spring CLI
3. Using start.spring.io

For this example, we are going with the web version that is start.spring.io.

The first microservice that we are going to create us to develop is books_catalog_services, this spring boot microservices is responsible for returning the output of the book based on the input.

Let’s create the service, using start.spring.io.

• Select the project type you want to create
• Select the project language
• Select the desired spring boot version
• Add Project Metadata, such as group, Artifact, name & description as well as package Name
• Select between Jar or War
• Select the Java version you want to work with
• Add Spring web dependencies
• Click on Generate button

Once you complete all this step, you are going to have a zip file. Once you extract it, you need to import it in the IDE that you’re using (Here I am using IntelliJ IDE).

The second microservice we are developing is books_info_service. This microservices with spring boot is responsible for providing the books details.

The third microservice that we are going to develop is Rating Data Service. This microservices is responsible for storing the particular ratings of the books given by the user.

So, once you have imported these spring boot application open in the IDE, you can see that you are dealing with the blank Spring boot Project. But how do you know it? Switch to the packages view, you can see that there are two classes in this application.

One is the BookCatalogeServiceApplicaiton Class & other is  BookCatalogeServiceApplicaitontest. Here we are not going to do any testing today. So there is just a single class in this application.

It also has the annotation called @SprinBootApplicaiton. This is what tells spring that this is a spring boot application.

You can run this application as almost all of the spring boot application has main method. So once you choose Run books_catalog_service. You will see that it works, Tomcat server runs, but it doesn’t have anything to execute.

It is a bare minimum app so it doesn’t how to handle the requests. But why is tomcat server working? No idea? Don’t worry let’s understand it.  Tomcat works because we choose web. Web requires tomcat to works. So the starter dependencies brings in the tomcat.

Next, run your project on localhost:8080, you will notice that it shows error page. Something like this:

This happens as the application has nothing to execute and there is no error in the program therefore its showing an error page for not having an error.

To mitigate that let’s add an API it this project. So what we want here basically what we want is something that accepts the userId in the URL and then returns back a payload with the list of books inside it.

For that follow the instructions below:

Go back to your IDE, in the book_catalog_service page, right click on the app name and select new and select java class.

Select the main method from two options as we want it in the main function. And create the new class and name it as bookcatalogresource.

Put it inside the resource folder. You can do it by naming the folder as shown in the screenshot.

It will create a seprate class like in the given picture.

This is the main guy who will combine the output from both the microservices and give the final output to the user.

Now how do I make this rest? The answer is simple add annotation of REST controller.

Now let’s give it something to show. Create a method for that as shown in the picture.

Create the class name catalogItem in model as shown below. We are hardcoding this model right now.

This class is goanna have the couple of fields. Which includes the title of the book, description for the same and the ratings as well.

Now let’s create a getter and setter for the same.

Once its generated its gonna look like this.

Now, let’s create the constructor for the same, so that it can parse that when hardcoding it. This takes all three fields and can create the instances out of that.

Now move back to bookcatalogservices class. Add the following code in it to create a dummy API.

This will create an API which accepts userId and returns the Four Wings. Now you have to tell the spring to treat it  like an API. That is accessible at catalogue\userid. For that it will be done with 2 steps adding request mapping annotation at two places that will allow spring boot to work its magic!

Once it is done, and you run the project, you will notice that localhost:8080 is still giving error however, if you add /catalog/foo in the end you’ll get the result as below.

But, is this microservice? No, this is an independent spring boot application. Let’s do one more. Move to the book_info_service.

For the second API too follow the same steps as above for bookinfoservice. You need to create the file named bookinfoservice in resources

Create the class in the model folder named Bookinfo, same as the above spring boot application.

Repeat the same things that we have done before for the resource file and at the end it will look something like this

However, if you’ll run this application, it wont work because port 8080 is already taken by bookcatalogservices. So what do you do?

Let’s solve this.

To solve this you need to navigate to the application.properties file. This file allows you to specify the configuration. You can specify key value pair which effect spring and affect your code.

It’s a way to make your application do different things without having to change the code with configuration files. So, the way to have spring boot change port is to say don’t use default port. Here you haven’t picked 8080, it took itself.

Why? Because it’s a default port. For that you have to say that don’t use the defaultport but use this port instead. To do that is by specifying the property called server.port and specify the value.

Now if you’ll run it using the same method, you can see that the tomcat is working, and you’ll get response like this

Repeat the same process for rating data services. Once, you have done that remember it is still different spring boot applications not the microservices.

Now, the question here arises is how to convert these spring boot applications in microservices? You must use REST, and spring boot already comes with the client built into it which is called Rest Template.

Let’s begin!

There are various steps involved in this process therefore I’ve added them in comment for your better understanding.

Now let’s get to work.

For now I am going to hardcode the rating parts. For that Copy the Ratings file from model of the rating data service, and paste it in the Book_catalog_service project. As you can see in the screenshot above we are using singletonList.

So instead of using singletonList, do the following code.

This is the hardcoded, but now we are going to change this, we are going to call to the API for each of these books. So, we are going to make a call on book info and that’s what the user needs to see.

To do that you first need to create instance of Rest Template. This is going to be the utility object which will let me make the call.  Now as any object, rest template also has several methods. Here we are going to use getForObject method.

Now as you can see in the screenshot above that getForObject takes two arguments. First one, is the URL that you’re goanna call, it could be any URL, its goanna make an REST call to it. And second is book information.

So, what does it get back from the call?

It gets a string. It also helps you unmarshall it into an object. So, if you know the payload of the response, which in this case we do, is book_info. You can provide the class with the same property of JSON.

You might question that were in all this does REST Template fit in?

The Rest template is  going to create the instance of the class populate that properties to it and provide you with the fully farmed object.

As you can see this is the payload that we want and it has two properties book_id and name, which basically creates the book information, your second argument.

So, you have the class sitting in your project with those parameters, here we are going to use the model file of book_info spring application.

The highlighted line will get you the information you need but you also need to unmarshall it. So to do that, you need to get the object.

The highlighted line gives you the object in return, as simple as that.

Now let’s make the API call for each rated books. Change the code as shown in the picture.

This code, will get do is generate the iteration for each rated books and gets back the book itself. So, what happens when you run this code?

You will get an error. Here the question arises is why did you got an error? It’s because in when you have Java unmarshall something that is not an object to the object you need to provide an empty constructor.

Once you do it and re run your project you can see that you have 2 hardcoded data which technically is not the write way but it indicates that you have made an API call.

Once, you get the output like this, Congratulations, you have just created the API call using the RestTemplate.

Let’s move forward and look where can you use Spring Boot Microservices.

Use Cases of Spring Boot Microservices

Spring Boot microservices are best at developing complex applications for a wide range of industries. Some of the industries these Spring Boot microservices shine in are as follows:

• E-commerce Platforms
• Financial Services
• Healthcare Information Systems
• Travel and Booking Services
• Media Streaming Platforms

Wrapping Up!

In nutshell, Spring Boot Microservices has emerged as the powerful solution for modern, scalable application development. With its ability to address the challenges in various industry, Spring boot is proof of software development evolution. The simplicity of Spring Boot with the robustness of microservices, gives developers the toolkit that is capable to developing scalable and easily maintainable application which will help Spring boot developers in navigating the details of distributed system.