1 What is Spring Boot, and how is it different from

Spring Framework?

Answer:
Spring Boot is an extension of the Spring Framework that simplifies the development of
Java applications by providing auto-configuration, embedded servers, and a convention-
over-configuration approach.

Key Differences:

Feature Spring Framework Spring Boot

Configuration Requires XML/Java-based config Uses auto-configuration

Needs an external server Comes with an embedded

Server Setup
(Tomcat, Jetty) server

Dependency Uses Spring Boot Starter

Manual dependency handling
Management dependencies

Microservices Built-in support for

Requires setup
Support microservices

Example:

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

This single class is enough to start a Spring Boot application.

2 What is @SpringBootApplication , and what does it do?

Answer:
@SpringBootApplication is a composite annotation that combines:

@Configuration → Defines beans in Spring

@EnableAutoConfiguration → Automatically configures beans based on
dependencies
@ComponentScan → Scans components ( @Controller , @Service , @Repository )

Example:

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

This annotation removes boilerplate configurations and speeds up application

development.

3 What is Dependency Injection (DI) in Spring Boot?

Answer:
Dependency Injection (DI) is a design pattern where Spring automatically injects
dependencies into components, avoiding manual instantiation.

Example:

@Component
class ServiceA {
public void printMessage() {
System.out.println("Hello from ServiceA!");
}
}

@Component
class ServiceB {
private final ServiceA serviceA;

@Autowired // Dependency Injection

public ServiceB(ServiceA serviceA) {
this.serviceA = serviceA;
}

public void execute() {

serviceA.printMessage();
}
}

Why use DI?

Removes tight coupling
Enhances testability
Improves maintainability

4 What is the difference between @Component , @Service ,

and @Repository ?
Answer:
These are stereotype annotations that register classes as Spring Beans.

Annotation Purpose

@Component Generic annotation for Spring Beans. Used when no specific role is
 defined.

@Service Used for business logic/service layer components.

Used for DAO (Data Access Layer) components and enables exception
@Repository
translation.

Example:

@Component
class GeneralComponent {}

@Service
class MyService {}

@Repository
class MyRepository {}

These annotations help Spring automatically manage beans using @ComponentScan .

5 How does Spring Boot handle exception management in

REST APIs?

Answer:
Spring Boot provides global exception handling using @ControllerAdvice and
@ExceptionHandler .

Example:

@RestControllerAdvice
public class GlobalExceptionHandler {

@ExceptionHandler(ResourceNotFoundException.class)
public ResponseEntity<String> handleNotFound(ResourceNotFoundException ex) {
return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND);
}

@ExceptionHandler(Exception.class)
public ResponseEntity<String> handleException(Exception ex) {
return new ResponseEntity<>("Something went wrong",
HttpStatus.INTERNAL_SERVER_ERROR);
}
}

Why use it?

Centralized error handling
Custom error messages
Consistent API responses
6 How do you create a REST API in Spring Boot?

Answer:
Spring Boot makes REST API development simple using @RestController and
@RequestMapping .

Example:

@RestController
@RequestMapping("/users")
public class UserController {

@GetMapping("/{id}")
public ResponseEntity<String> getUser(@PathVariable int id) {
return ResponseEntity.ok("User with ID: " + id);
}

@PostMapping
public ResponseEntity<String> createUser(@RequestBody String user) {
return ResponseEntity.status(HttpStatus.CREATED).body("User Created: " +
user);
}
}

Key Annotations:
@RestController → Marks a class as a REST API controller
@GetMapping , @PostMapping , etc. → Define HTTP methods
@PathVariable → Extracts values from URL
@RequestBody → Reads request body

7 What is Spring Boot Actuator, and how is it used?

Answer:
Spring Boot Actuator provides built-in endpoints to monitor and manage applications.

Key Features:
Health Checks ( /actuator/health )
Metrics ( /actuator/metrics )
Environment Info ( /actuator/env )

How to Enable Actuator?

1 Add the dependency:

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

2 Configure application.properties :
management.endpoints.web.exposure.include=*

3 Access endpoints like:

http://localhost:8080/actuator/health

Actuator helps monitor microservices and improve observability.

8 What is Circuit Breaker in Microservices, and how do

you implement it in Spring Boot?

Answer:
A Circuit Breaker prevents system failures by stopping calls to a failing service and
providing a fallback response.

How to Implement Circuit Breaker using Resilience4j?

1 Add the dependency:

<dependency>
<groupId>io.github.resilience4j</groupId>
<artifactId>resilience4j-spring-boot2</artifactId>
</dependency>

2 Use @CircuitBreaker in your service:

@Service
public class InventoryService {

@CircuitBreaker(name = "inventoryService", fallbackMethod = "fallbackInventory")

public String checkInventory() {
throw new RuntimeException("Service Down!");
}

public String fallbackInventory(Exception ex) {

return "Fallback: Default Inventory Available";
}
}

Why use Circuit Breaker?

Prevents cascading failures
Improves application resilience
Ensures service availability

1 What are Microservices, and how are they different

from Monolithic Architecture?
Answer:
Microservices architecture is a design approach where an application is divided into
small, independent services, each performing a specific function. These services
communicate via APIs and can be deployed, scaled, and updated independently.

Key Differences:

Feature Monolithic Architecture Microservices Architecture

Difficult, scales as a
Scalability Easy, scale individual services
whole

Deployment Single large deployment Independent deployments

Technology Single tech stack Can use multiple technologies

Fault Failure affects the Failures are isolated to a single

Isolation entire app service

Development Slower due to

Faster, as teams work independently
Speed dependencies

Example:
Monolithic: One large app handling users, payments, and orders.
Microservices: Separate services for users, payments, and orders, communicating
via REST or messaging.

2 What is an API Gateway in Microservices?

Answer:
An API Gateway is a single entry point that manages and routes client requests to the
correct microservice.

Why use an API Gateway?

Authentication & Authorization (e.g., JWT validation)
Rate Limiting & Security (prevents excessive requests)
Load Balancing (distributes requests efficiently)
Logging & Monitoring (tracks request flow)

Example using Spring Cloud Gateway:

spring:
cloud:
gateway:
routes:
- id: user-service
uri: lb://USER-SERVICE
predicates:
- Path=/users/**

This routes requests to USER-SERVICE when /users/** is called.

3 What is Service Discovery, and how does Eureka work in
Microservices?
Answer:
Service Discovery helps microservices find each other dynamically without hardcoding
URLs. Eureka Server (Netflix Eureka) is a registry where services register themselves
and discover other services.

How Eureka Works?

1 Eureka Server acts as a registry.
2 Eureka Clients (services) register themselves.
3 Other services query Eureka to find service locations.

Example:

Eureka Server ( application.yml )

server:
port: 8761

eureka:
client:
register-with-eureka: false
fetch-registry: false

Eureka Client (Microservice)

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

This allows services to register and discover each other dynamically.

4 What is Circuit Breaker, and how do you implement it

in Microservices?

Answer:
A Circuit Breaker prevents cascading failures by stopping calls to a failing service
and returning a fallback response.

How to Implement Circuit Breaker using Resilience4j?

1 Add the dependency:

<dependency>
<groupId>io.github.resilience4j</groupId>
<artifactId>resilience4j-spring-boot2</artifactId>
</dependency>
2 Use @CircuitBreaker in your service:

@Service
public class InventoryService {

@CircuitBreaker(name = "inventoryService", fallbackMethod = "fallbackInventory")

public String checkInventory() {
throw new RuntimeException("Service Down!");
}

public String fallbackInventory(Exception ex) {

return "Fallback: Default Inventory Available";
}
}

Why use Circuit Breaker?

Prevents cascading failures
Improves system resilience
Ensures service availability

5 How does communication happen between Microservices?

Answer:
Microservices communicate using two main approaches:

1. Synchronous Communication (REST APIs)

Services interact using HTTP requests (e.g., GET , POST ).
Problem: If one service is down, the request fails.

Example:

@FeignClient(name = "order-service")
public interface OrderServiceClient {
@GetMapping("/orders/{id}")
Order getOrder(@PathVariable Long id);
}

FeignClient makes API calls easier.

2. Asynchronous Communication (Message Queues)

Uses Kafka, RabbitMQ, or ActiveMQ for event-driven communication.
Advantage: Services are loosely coupled and do not depend on each other.

Example: Kafka Producer

@Autowired
private KafkaTemplate<String, String> kafkaTemplate;

public void sendMessage(String message) {

 kafkaTemplate.send("order-topic", message);
}

Asynchronous communication improves scalability and resilience.

6 How do you handle authentication and authorization in

Microservices?

Answer:
Spring Security and JWT (JSON Web Tokens) are commonly used for authentication.

Steps for JWT Authentication:

1 User logs in → Server issues a JWT token
2 Client includes JWT in every request (as Authorization: Bearer <token> ) 3
Microservices validate JWT using a shared secret key

Example: JWT Filter

public class JwtTokenFilter extends OncePerRequestFilter {

@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse
response, FilterChain chain)
throws ServletException, IOException {
String token = request.getHeader("Authorization");
if (token != null && validateToken(token)) {
chain.doFilter(request, response);
} else {
response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Invalid Token");
}
}
}

OAuth2 is another alternative for authentication in microservices.

7 How do you implement logging and monitoring in

Microservices?
Answer:
Microservices generate distributed logs, making debugging difficult. To solve this,
tools like ELK Stack (Elasticsearch, Logstash, Kibana) and Zipkin (for tracing) are
used.

How to enable centralized logging?

1 Use Spring Boot Actuator for health and metrics:

management.endpoints.web.exposure.include=*

2 Enable Zipkin for distributed tracing:

spring.zipkin.base-url=http://localhost:9411

This helps track requests across multiple services.

8 How do you handle transactions across multiple

microservices?

Answer:
Since each microservice has its own database, transactions must be handled
differently.

1. Distributed Transactions (SAGA Pattern)

A saga is a sequence of transactions, each triggering the next step.
Compensation Transactions undo changes if a failure occurs.

Example of Choreography-based Saga:

Order Service → Sends "Order Created" event
Payment Service → Deducts payment and sends "Payment Successful"
Inventory Service → Reduces stock

If any step fails, a rollback event compensates for previous actions.