Spring Boot Interview Questions: Core Concepts Explained With Depth

// ============================================================
// HOW AUTO-CONFIGURATION WORKS — A MINIMAL REPRODUCIBLE EXAMPLE
// Run with: mvn spring-boot:run -Ddebug
// Look for 'CONDITIONS EVALUATION REPORT' in the console output
// ============================================================

package io.thecodeforge.autoconfigdemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

@SpringBootApplication
// @SpringBootApplication is shorthand for THREE annotations:
//   1. @Configuration       — this class is a source of bean definitions
//   2. @EnableAutoConfiguration — scan spring.factories and apply conditional config
//   3. @ComponentScan       — find @Component, @Service, @Repository in this package
public class AutoConfigurationDemo {

    public static void main(String[] args) {
        ConfigurableApplicationContext context =
            SpringApplication.run(AutoConfigurationDemo.class, args);

        // H2 in-memory database is on the classpath (via pom.xml)
        // Spring Boot auto-configured a DataSource AND a JdbcTemplate
        // — we never wrote a single line of DataSource config
        JdbcTemplate jdbcTemplate = context.getBean(JdbcTemplate.class);

        // Create a simple table and insert a row to prove the DB is live
        jdbcTemplate.execute("CREATE TABLE product (id INT, name VARCHAR(50))");
        jdbcTemplate.update("INSERT INTO product VALUES (1, 'Wireless Keyboard')");

        // Query back the row — auto-configured DataSource handles the connection
        String productName = jdbcTemplate.queryForObject(
            "SELECT name FROM product WHERE id = ?",
            String.class,
            1
        );

        System.out.println("Auto-configured DB returned: " + productName);
        // OUTPUT: Auto-configured DB returned: Wireless Keyboard

        // Now check: if you define your OWN DataSource bean in this class,
        // DataSourceAutoConfiguration backs off and yours is used instead.
        context.close();
    }
}

// ============================================================
// pom.xml dependencies needed for this demo:
// <dependency>
//   <groupId>org.springframework.boot</groupId>
//   <artifactId>spring-boot-starter-jdbc</artifactId>
// </dependency>
// <dependency>
//   <groupId>com.h2database</groupId>
//   <artifactId>h2</artifactId>
//   <scope>runtime</scope>
// </dependency>
// ============================================================

// ============================================================
// DEPENDENCY INJECTION — THE RIGHT WAY VS THE WRONG WAY
// This shows constructor injection (correct) vs field injection (avoid)
// ============================================================

package io.thecodeforge.dipatterns;

import org.springframework.stereotype.Service;
import org.springframework.stereotype.Repository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

// ---- REPOSITORY LAYER ----
@Repository  // Specialisation of @Component — also enables exception translation
public class OrderRepository {
    public String findOrderById(Long orderId) {
        // In real life this hits a database; here we simulate it
        return "Order #" + orderId + " [Wireless Keyboard x2]";
    }
}

// ---- WRONG WAY: Field injection ----
// @Service
// public class BadOrderService {
//     @Autowired  // Hidden dependency — can't unit test without Spring context
//     private OrderRepository orderRepository;
// }

// ---- RIGHT WAY: Constructor injection ----
@Service  // Specialisation of @Component — signals this holds business logic
public class OrderService {

    // 'final' enforces that this dependency can never be swapped out after construction
    // This is IMPOSSIBLE with field injection — a major safety advantage
    private final OrderRepository orderRepository;

    // Spring detects a single constructor and injects automatically (no @Autowired needed in Spring 4.3+)
    public OrderService(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }

    public String getOrderDetails(Long orderId) {
        return orderRepository.findOrderById(orderId);
    }
}

// ---- SCOPE DEMO ----
// Each call to context.getBean(AuditToken.class) returns a FRESH instance
@Component
@Scope("prototype")  // Default is 'singleton' — override here for new-instance-per-request
public class AuditToken {
    private final long createdAt = System.currentTimeMillis();

    public long getCreatedAt() {
        return createdAt;
    }
}

// ---- HOW TO TEST OrderService WITHOUT SPRING ----
// This is WHY constructor injection wins:
//
// class OrderServiceTest {
//     @Test
//     void shouldReturnOrderDetails() {
//         OrderRepository mockRepo = Mockito.mock(OrderRepository.class);
//         Mockito.when(mockRepo.findOrderById(42L)).thenReturn("Order #42 [Monitor]");
//
//         OrderService service = new OrderService(mockRepo); // No Spring needed!
//         assertEquals("Order #42 [Monitor]", service.getOrderDetails(42L));
//     }
// }

// ============================================================
// PRODUCTION-STYLE REST CONTROLLER WITH GLOBAL EXCEPTION HANDLING
// Shows @RestController, ResponseEntity, @ControllerAdvice pattern
// ============================================================

package io.thecodeforge.restdemo;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.context.request.WebRequest;

import java.time.Instant;
import java.util.HashMap;
import java.util.Map;

// ---- CUSTOM EXCEPTION ----
class ProductNotFoundException extends RuntimeException {
    private final Long productId;
    public ProductNotFoundException(Long productId) {
        super("Product not found with id: " + productId);
        this.productId = productId;
    }
    public Long getProductId() { return productId; }
}

// ---- SIMPLE DTO ----
record ProductResponse(Long id, String name, double priceGbp) {}

// ---- CONTROLLER ----
@RestController  // = @Controller + @ResponseBody — return values go to response body, not a view
@RequestMapping("/api/v1/products")  // Base path for all methods in this controller
public class ProductController {

    // GET /api/v1/products/42
    @GetMapping("/{productId}")
    public ResponseEntity<ProductResponse> getProduct(@PathVariable Long productId) {

        // Simulate a database lookup — throw domain exception if not found
        if (productId != 1L) {
            throw new ProductNotFoundException(productId); // Caught by @ControllerAdvice below
        }

        ProductResponse product = new ProductResponse(1L, "Wireless Keyboard", 49.99);

        // ResponseEntity lets us control status code AND headers, not just the body
        return ResponseEntity.ok(product);  // 200 OK + JSON body
    }

    // POST /api/v1/products — returns 201 Created with Location header
    @PostMapping
    public ResponseEntity<ProductResponse> createProduct(@RequestBody ProductResponse newProduct) {
        // In real life: save to DB, get generated ID back
        ProductResponse saved = new ProductResponse(99L, newProduct.name(), newProduct.priceGbp());

        return ResponseEntity
            .status(HttpStatus.CREATED)         // 201, not 200
            .header("Location", "/api/v1/products/" + saved.id()) // Tell client where the new resource lives
            .body(saved);
    }
}

// ---- GLOBAL EXCEPTION HANDLER ----
@RestControllerAdvice  // = @ControllerAdvice + @ResponseBody — intercepts ALL controllers
class GlobalExceptionHandler {

    // Maps ProductNotFoundException to a 404 response with a structured error body
    @ExceptionHandler(ProductNotFoundException.class)
    public ResponseEntity<Map<String, Object>> handleProductNotFound(
            ProductNotFoundException ex,
            WebRequest request) {

        // Consistent error envelope — every client gets the same predictable shape
        Map<String, Object> errorBody = new HashMap<>();
        errorBody.put("timestamp", Instant.now().toString());
        errorBody.put("status", 404);
        errorBody.put("error", "Not Found");
        errorBody.put("message", ex.getMessage());
        errorBody.put("path", request.getDescription(false).replace("uri=", ""));

        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(errorBody);
    }

    // Catch-all for anything we didn't anticipate — never expose stack traces to clients
    @ExceptionHandler(Exception.class)
    public ResponseEntity<Map<String, Object>> handleGenericException(Exception ex) {
        Map<String, Object> errorBody = new HashMap<>();
        errorBody.put("timestamp", Instant.now().toString());
        errorBody.put("status", 500);
        errorBody.put("error", "Internal Server Error");
        errorBody.put("message", "An unexpected error occurred"); // Never expose ex.getMessage() here
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorBody);
    }
}

// ============================================================
// @ConfigurationProperties — THE PRODUCTION-GRADE CONFIG PATTERN
// Binds a whole block of properties to a strongly-typed class
// ============================================================

package io.thecodeforge.configdemo;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.bind.DefaultValue;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Positive;

// Maps all properties with prefix 'payment.gateway' to this class
// application-dev.properties  →  payment.gateway.url=https://sandbox.pay.example.com
// application-prod.properties →  payment.gateway.url=https://api.pay.example.com
@ConfigurationProperties(prefix = "payment.gateway")
public class PaymentGatewayConfig {

    @NotBlank(message = "Payment gateway URL must not be blank")  // Validated at startup
    private String url;

    @Positive
    private int timeoutSeconds;

    private String apiKey;  // In real life: injected from env var, never from a property file

    // Standard getters and setters (or use Lombok @Data)
    public String getUrl() { return url; }
    public void setUrl(String url) { this.url = url; }
    public int getTimeoutSeconds() { return timeoutSeconds; }
    public void setTimeoutSeconds(int timeoutSeconds) { this.timeoutSeconds = timeoutSeconds; }
    public String getApiKey() { return apiKey; }
    public void setApiKey(String apiKey) { this.apiKey = apiKey; }
}

// ---- Enable it in your main config class ----
// @SpringBootApplication
// @EnableConfigurationProperties(PaymentGatewayConfig.class)  // Registers the binding
// public class App { ... }

// ---- HOW TO USE IT IN A SERVICE ----
// @Service
// public class PaymentService {
//     private final PaymentGatewayConfig gatewayConfig;
//
//     public PaymentService(PaymentGatewayConfig gatewayConfig) {
//         this.gatewayConfig = gatewayConfig;
//     }
//
//     public void processPayment(double amount) {
//         System.out.println("Connecting to: " + gatewayConfig.getUrl());
//         System.out.println("Timeout: " + gatewayConfig.getTimeoutSeconds() + "s");
//         // ... call payment API
//     }
// }

// ---- application-dev.properties ----
// payment.gateway.url=https://sandbox.pay.example.com
// payment.gateway.timeout-seconds=10
// payment.gateway.api-key=${PAYMENT_API_KEY}   <-- reads from env var at runtime

// ---- application-prod.properties ----
// payment.gateway.url=https://api.pay.example.com
// payment.gateway.timeout-seconds=5
// payment.gateway.api-key=${PAYMENT_API_KEY}   <-- SAME pattern, different env var value

// Activate dev profile:  java -jar app.jar --spring.profiles.active=dev
// Activate prod profile: SPRING_PROFILES_ACTIVE=prod java -jar app.jar