Building Microservices REST API using Spring Boot

Introduction:

Microservices have become the go-to architecture for developing large-scale applications in recent years. They provide scalability, flexibility, and maintainability, making it easier to develop and deploy complex applications. Spring Boot, with its built-in support for microservices, has become one of the most popular frameworks for building microservices-based applications. In this article, we'll take a deep dive into building microservices REST API using Spring Boot.

Step-by-Step Guide:

Step 1: Set up a Spring Boot project To start building a Spring Boot microservices REST API, you first need to set up a new Spring Boot project. You can do this by using the Spring Initializr or by manually creating a new project in your favorite IDE.

Step 2: Add dependencies After setting up the Spring Boot project, you need to add the necessary dependencies. To build a microservices-based REST API, you'll need to add the Spring Web and Spring Data JPA dependencies. You can do this by adding the following lines to your pom.xml file:

<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> </dependencies>

Step 3: Create a REST API controller Now that you have set up your project and added the necessary dependencies, you can start creating your REST API controller. To do this, create a new Java class and annotate it with the @RestController annotation. This annotation tells Spring that this class is a REST controller and that all its methods return REST responses. Here's an example:

@RestController @RequestMapping("/api") public class UserController { @Autowired private UserRepository userRepository; @GetMapping("/users") public List<User> getAllUsers() { return userRepository.findAll(); } @PostMapping("/users") public User createUser(@RequestBody User user) { return userRepository.save(user); } @GetMapping("/users/{id}") public User getUserById(@PathVariable Long id) { return userRepository.findById(id).orElseThrow(() -> new ResourceNotFoundException("User not found")); } @PutMapping("/users/{id}") public User updateUser(@PathVariable Long id, @RequestBody User userDetails) { User user = userRepository.findById(id).orElseThrow(() -> new ResourceNotFoundException("User not found")); user.setName(userDetails.getName()); user.setEmail(userDetails.getEmail()); user.setPhone(userDetails.getPhone()); User updatedUser = userRepository.save(user); return updatedUser; } @DeleteMapping("/users/{id}") public ResponseEntity<?> deleteUser(@PathVariable Long id) { User user = userRepository.findById(id).orElseThrow(() -> new ResourceNotFoundException("User not found")); userRepository.delete(user); return ResponseEntity.ok().build(); } }

In this example, we have created a UserController class that has various REST endpoints such as getAllUsers, createUser, getUserById, updateUser, and deleteUser. We have also used the Spring Data JPA repository to interact with the database.

Step 4: Set up the application properties You now need to set up the application properties. In the application.properties file, add the following lines:

spring.jpa.hibernate.ddl-auto=update spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase spring.datasource.username=root spring.datasource.password=password

These lines configure the database that the application will use. In this example, we're using MySQL as the database.

Step 5: Create a data model Next, create a data model that maps to your database table. For example, if you have a users table in your database, you can create a User class that maps to that table. Here's an example:

@Entity @Table(name = "users") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(name = "name") private String name; @Column(name = "email") private String email; @Column(name = "phone") private String phone; // getters and setters }

In this example, we have annotated the User class with the @Entity annotation to indicate that it is a JPA entity. We have also specified the table name using the @Table annotation, and we have used the @Id and @GeneratedValue annotations to specify the primary key field.

Step 6: Create a repository After creating the data model, you need to create a repository interface that extends the Spring Data JPA CrudRepository interface. Here's an example:

public interface UserRepository extends CrudRepository<User, Long> { }

This repository interface provides basic CRUD operations for the User entity.

Step 7: Run the application You have now completed all the necessary steps to build a microservices REST API using Spring Boot. You can run the application using your IDE or by running the mvn spring-boot:run command in the terminal.

Use Cases:

1. Building a REST API for an e-commerce application to manage products and orders
2. Building a REST API for a social media application to manage user profiles and posts
3. Building a REST API for a finance application to manage transactions and customer accounts

Conclusion: In this article, we have covered the step-by-step process of building a microservices REST API using Spring Boot. We started by setting up a new Spring Boot project, adding the necessary dependencies, creating a REST API controller, setting up the application properties, creating a data model, creating a repository, and finally running the application. We also provided some use cases for building a microservices-based REST API using Spring Boot. By following the steps outlined in this article, you can easily build a robust and scalable microservices-based REST API using Spring Boot.

Official Documentation: You can find more information about building microservices using Spring Boot in the official Spring Boot documentation: https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-restful-services

You can also find more information about building RESTful web services with Spring in the official Spring documentation: https://docs.spring.io/spring-framework/docs/current/reference/html/web.html#spring-we

JBI Training offers a number of courses. Some of our most popular courses are found below. We can customize a course for your teams needs, for any training requirements or requests simply get in touch. 

• Spring Boot Microservices
• Spring 4 for the Enterprise
• Spring 4
• Enterprise Spring with Hibernate &JPA
• Scala Design Patterns Workshop
• Secure coding for Java and Javascript
• Microservices Architecture