Spring Boot Interview Questions

Building microservices using Spring Boot involves designing and implementing small, loosely coupled services that can be developed, deployed, and scaled independently. Here's a comprehensive guide on how to build microservices using Spring Boot:

1. Define Microservices Architecture

1. Identify Services: Break down your application into discrete services. Each service should focus on a specific business capability.
2. Decouple Services: Ensure that services are loosely coupled, communicating over well-defined APIs.

2. Set Up a Spring Boot Project

1. Create a New Spring Boot Application: Use Spring Initializr to create a new Spring Boot project for each microservice.

   • Select dependencies like Spring Web, Spring Data JPA, and others as needed.

2. Directory Structure:

   microservices/
   ├── service-a/
   │   └── src/main/java/com/example/servicea
   ├── service-b/
   │   └── src/main/java/com/example/serviceb
   └── ...

3. Develop Each Microservice

1. Define the Domain Model: Create entities and repositories for your microservice.

   @Entity
   public class Product {
       @Id @GeneratedValue
       private Long id;
       private String name;
       private Double price;
       // getters and setters
   }

2. Create Service Layer: Implement business logic in service classes.

   @Service
   public class ProductService {
       @Autowired
       private ProductRepository repository;
       public List<Product> getAllProducts() {
           return repository.findAll();
       }
       // Other business methods
   }

3. Develop REST Controllers: Expose RESTful endpoints.

   @RestController
   @RequestMapping("/products")
   public class ProductController {
       @Autowired
       private ProductService service;
       @GetMapping
       public List<Product> getAllProducts() {
           return service.getAllProducts();
       }
       // Other endpoints
   }

4. Communication Between Microservices

1. REST Template / WebClient: Use RestTemplate (for synchronous calls) or WebClient (for reactive calls) for inter-service communication.

   @Service
   public class InventoryService {
       private final WebClient webClient;
       public InventoryService(WebClient.Builder webClientBuilder) {
           this.webClient = webClientBuilder.baseUrl("http://inventory-service").build();
       }
       public Inventory getInventory(Long productId) {
           return this.webClient.get().uri("/inventory/" + productId)
                 .retrieve().bodyToMono(Inventory.class).block();
       }
   }

2. Feign Client: Use Feign Client for declarative REST client.

   @FeignClient(name = "inventory-service")
   public interface InventoryClient {
       @GetMapping("/inventory/{productId}")
       Inventory getInventory(@PathVariable Long productId);
   }

5. Service Discovery

1. Eureka Server: Set up a Eureka Server for service registry and discovery.

   # application.yml for Eureka Server
   spring:
     application:
       name: eureka-server
   eureka:
     client:
       register-with-eureka: false
       fetch-registry: false

2. Eureka Clients: Configure each microservice as a Eureka client.

   # application.yml for a microservice
   spring:
     application:
       name: product-service
   eureka:
     client:
       service-url:
         defaultZone: http://localhost:8761/eureka/

6. API Gateway

1. Set Up API Gateway: Use Spring Cloud Gateway or Netflix Zuul as an API Gateway.

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

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

7. Configuration Management

1. Spring Cloud Config: Use Spring Cloud Config for centralized configuration.

   # bootstrap.yml for a microservice
   spring:
     cloud:
       config:
         uri: http://localhost:8888

2. Config Server: Set up a Config Server to manage configurations.

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

8. Resilience and Fault Tolerance

1. Hystrix / Resilience4j: Implement circuit breakers and fallback mechanisms.

   @Service
   public class ProductService {
       @HystrixCommand(fallbackMethod = "defaultProducts")
       public List<Product> getAllProducts() {
           // Call to another service
       }
       public List<Product> defaultProducts() {
           return new ArrayList<>();
       }
   }

9. Security

1. OAuth2 / JWT: Implement security using OAuth2 and JWT.

   @Configuration
   @EnableResourceServer
   public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
       @Override
       public void configure(HttpSecurity http) throws Exception {
           http.authorizeRequests()
               .antMatchers("/products/**").authenticated();
       }
   }

10. Monitoring and Logging

1. Spring Boot Actuator: Enable Actuator endpoints for monitoring.

   management:
     endpoints:
       web:
         exposure:
           include: "*"

2. Distributed Tracing: Use Spring Cloud Sleuth with Zipkin for tracing.

   spring:
     zipkin:
       base-url: http://localhost:9411
     sleuth:
       sampler:
         probability: 1.0

11. Building and Deployment

1. Docker: Containerize microservices using Docker.

   FROM openjdk:11-jre-slim
   COPY target/product-service.jar product-service.jar
   ENTRYPOINT ["java", "-jar", "/product-service.jar"]

2. Kubernetes: Deploy microservices to a Kubernetes cluster for orchestration.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: product-service
   spec:
     replicas: 3
     template:
       spec:
         containers:
         - name: product-service
           image: product-service:latest
           ports:
           - containerPort: 8080

Summary

Building microservices with Spring Boot involves creating independent services with well-defined boundaries, ensuring they communicate effectively, and managing them using modern tools and practices. Key components include service discovery, API gateway, centralized configuration, fault tolerance, security, monitoring, and containerization. By leveraging Spring Boot and Spring Cloud, you can create robust, scalable microservices architectures.