Microservices architecture is a design pattern that structures an application as a collection of loosely coupled services. Each service is fine-grained and the protocols are lightweight. This module will guide you through the process of building microservices using Spring Boot.

1. Microservices Architecture:

   • Definition: A method of developing software systems that tries to focus on building single-function modules with well-defined interfaces and operations.
   • Benefits: Scalability, flexibility, and the ability to deploy services independently.
   • Challenges: Complexity in management, inter-service communication, and data consistency.

2. Spring Boot for Microservices:

   • Spring Boot: Provides a robust framework to build microservices with ease.
   • Spring Cloud: A suite of tools to manage microservices, including service discovery, configuration management, and circuit breakers.

1. Create a New Spring Boot Project:

   • Use Spring Initializr (https://start.spring.io/) to generate a new project.
   • Select dependencies: Spring Web, Spring Boot DevTools, and Spring Data JPA.

2. Project Structure:

   • The project structure will be similar to a standard Spring Boot application but will focus on modularity.

1. Define the Entity:

   @Entity
   public class Product {
       @Id
       @GeneratedValue(strategy = GenerationType.IDENTITY)
       private Long id;
       private String name;
       private double price;
   
       // Getters and Setters
   }
   

2. Create the Repository:

   public interface ProductRepository extends JpaRepository<Product, Long> {
   }
   

3. Create the Service Layer:

   @Service
   public class ProductService {
       @Autowired
       private ProductRepository productRepository;
   
       public List<Product> getAllProducts() {
           return productRepository.findAll();
       }
   
       public Product getProductById(Long id) {
           return productRepository.findById(id).orElse(null);
       }
   
       public Product saveProduct(Product product) {
           return productRepository.save(product);
       }
   
       public void deleteProduct(Long id) {
           productRepository.deleteById(id);
       }
   }
   

4. Create the REST Controller:

   @RestController
   @RequestMapping("/products")
   public class ProductController {
       @Autowired
       private ProductService productService;
   
       @GetMapping
       public List<Product> getAllProducts() {
           return productService.getAllProducts();
       }
   
       @GetMapping("/{id}")
       public Product getProductById(@PathVariable Long id) {
           return productService.getProductById(id);
       }
   
       @PostMapping
       public Product createProduct(@RequestBody Product product) {
           return productService.saveProduct(product);
       }
   
       @DeleteMapping("/{id}")
       public void deleteProduct(@PathVariable Long id) {
           productService.deleteProduct(id);
       }
   }
   

1. Add Eureka Server Dependency:

   <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
   </dependency>
   

2. Enable Eureka Server:

   @SpringBootApplication
   @EnableEurekaServer
   public class EurekaServerApplication {
       public static void main(String[] args) {
           SpringApplication.run(EurekaServerApplication.class, args);
       }
   }
   

3. Configure Eureka Server:

   server:
     port: 8761
   
   eureka:
     client:
       register-with-eureka: false
       fetch-registry: false
     server:
       wait-time-in-ms-when-sync-empty: 0
   

4. Add Eureka Client Dependency to Microservice:

   <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
   </dependency>
   

5. Enable Eureka Client:

   @SpringBootApplication
   @EnableEurekaClient
   public class ProductServiceApplication {
       public static void main(String[] args) {
           SpringApplication.run(ProductServiceApplication.class, args);
       }
   }
   

6. Configure Eureka Client:

   eureka:
     client:
       service-url:
         defaultZone: http://localhost:8761/eureka/
   

1. Add Spring Cloud Gateway Dependency:

   <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-gateway</artifactId>
   </dependency>
   

2. Configure Routes:

   spring:
     cloud:
       gateway:
         routes:
           - id: product-service
             uri: lb://PRODUCT-SERVICE
             predicates:
               - Path=/products/**
   

1. Add Spring Cloud Config Server Dependency:

   <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-config-server</artifactId>
   </dependency>
   

2. Enable Config Server:

   @SpringBootApplication
   @EnableConfigServer
   public class ConfigServerApplication {
       public static void main(String[] args) {
           SpringApplication.run(ConfigServerApplication.class, args);
       }
   }
   

3. Configure Config Server:

   server:
     port: 8888
   
   spring:
     cloud:
       config:
         server:
           git:
             uri: https://github.com/your-repo/config-repo
   

4. Add Config Client Dependency to Microservice:

   <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-config</artifactId>
   </dependency>
   

5. Configure Config Client:

   spring:
     cloud:
       config:
         uri: http://localhost:8888
   

1. Create a new Spring Boot project for the Order Service.
2. Define an Order entity with fields like id, productId, quantity, and status.
3. Create a repository, service, and REST controller for the Order entity.
4. Register the Order Service with Eureka.
5. Configure the API Gateway to route requests to the Order Service.
6. Use Spring Cloud Config to manage the configuration of the Order Service.

1. Order Entity:

   @Entity
   public class Order {
       @Id
       @GeneratedValue(strategy = GenerationType.IDENTITY)
       private Long id;
       private Long productId;
       private int quantity;
       private String status;
   
       // Getters and Setters
   }
   

2. Order Repository:

   public interface OrderRepository extends JpaRepository<Order, Long> {
   }
   

3. Order Service:

   @Service
   public class OrderService {
       @Autowired
       private OrderRepository orderRepository;
   
       public List<Order> getAllOrders() {
           return orderRepository.findAll();
       }
   
       public Order getOrderById(Long id) {
           return orderRepository.findById(id).orElse(null);
       }
   
       public Order saveOrder(Order order) {
           return orderRepository.save(order);
       }
   
       public void deleteOrder(Long id) {
           orderRepository.deleteById(id);
       }
   }
   

4. Order Controller:

   @RestController
   @RequestMapping("/orders")
   public class OrderController {
       @Autowired
       private OrderService orderService;
   
       @GetMapping
       public List<Order> getAllOrders() {
           return orderService.getAllOrders();
       }
   
       @GetMapping("/{id}")
       public Order getOrderById(@PathVariable Long id) {
           return orderService.getOrderById(id);
       }
   
       @PostMapping
       public Order createOrder(@RequestBody Order order) {
           return orderService.saveOrder(order);
       }
   
       @DeleteMapping("/{id}")
       public void deleteOrder(@PathVariable Long id) {
           orderService.deleteOrder(id);
       }
   }
   

5. Eureka Client Configuration:

   eureka:
     client:
       service-url:
         defaultZone: http://localhost:8761/eureka/
   

6. API Gateway Configuration:

   spring:
     cloud:
       gateway:
         routes:
           - id: order-service
             uri: lb://ORDER-SERVICE
             predicates:
               - Path=/orders/**
   

7. Config Client Configuration:

   spring:
     cloud:
       config:
         uri: http://localhost:8888
   

In this module, you learned how to build microservices using Spring Boot. You explored the key concepts of microservices architecture, created a simple microservice, and integrated it with Eureka for service discovery. You also learned how to use Spring Cloud Gateway for API routing and Spring Cloud Config for centralized configuration management. By completing the practical exercise, you reinforced your understanding of these concepts and gained hands-on experience in building microservices.

Next, you will delve into deploying Spring Boot applications, where you will learn how to deploy your microservices to various platforms such as Heroku, AWS, and Kubernetes.