Spring Boot Annotations — Interview Deep Dive

@SpringBootApplication  // = @Configuration + @EnableAutoConfiguration + @ComponentScan
public class ShopifyCloneApplication {
    public static void main(String[] args) {
        SpringApplication.run(ShopifyCloneApplication.class, args);
    }
}

@Component
public class OrderMapper {

    public OrderDto toDto(Order order) {
        return OrderDto.builder()
            .id(order.getId())
            .status(order.getStatus().name())
            .total(order.getTotal())
            .itemCount(order.getLineItems().size())
            .createdAt(order.getCreatedAt())
            .build();
    }

    public Order toEntity(CreateOrderRequest request) {
        Order order = new Order();
        order.setCustomerId(request.getCustomerId());
        order.setShippingAddress(request.getShippingAddress());
        request.getItems().forEach(item -> order.addLineItem(
            new OrderLineItem(item.getProductId(), item.getQuantity(), item.getPrice())
        ));
        return order;
    }
}

// Inside Spring Framework source:
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component  // <-- this is why it works
public @interface Service { }

@Service
public class PaymentService {

    private final PaymentGatewayClient gatewayClient;
    private final OrderRepository orderRepository;
    private final NotificationService notificationService;

    public PaymentService(PaymentGatewayClient gatewayClient,
                          OrderRepository orderRepository,
                          NotificationService notificationService) {
        this.gatewayClient = gatewayClient;
        this.orderRepository = orderRepository;
        this.notificationService = notificationService;
    }

    @Transactional
    public PaymentResult processPayment(UUID orderId, PaymentMethod method) {
        Order order = orderRepository.findById(orderId)
            .orElseThrow(() -> new OrderNotFoundException(orderId));

        ChargeResult charge = gatewayClient.charge(
            order.getCustomerId(), order.getTotal(), method);

        if (charge.isSuccessful()) {
            order.setStatus(OrderStatus.PAID);
            order.setPaymentReference(charge.getTransactionId());
            orderRepository.save(order);
            notificationService.sendPaymentConfirmation(order);
        }

        return PaymentResult.from(charge);
    }
}

@Repository
public class OrderRepositoryImpl implements CustomOrderRepository {

    @PersistenceContext
    private EntityManager entityManager;

    @Override
    public List<Order> findStaleOrders(Duration olderThan) {
        Instant cutoff = Instant.now().minus(olderThan);

        // If this throws a PersistenceException (e.g., connection lost),
        // Spring translates it to DataAccessResourceFailureException
        return entityManager.createQuery(
            "SELECT o FROM Order o WHERE o.status = :status AND o.createdAt < :cutoff",
            Order.class)
            .setParameter("status", OrderStatus.PENDING)
            .setParameter("cutoff", cutoff)
            .getResultList();
    }
}

@Controller
@RequestMapping("/shop")
public class ShopController {

    private final ProductService productService;

    public ShopController(ProductService productService) {
        this.productService = productService;
    }

    @GetMapping("/products")
    public String listProducts(Model model,
                               @RequestParam(defaultValue = "0") int page) {
        Page<Product> products = productService.findAll(PageRequest.of(page, 20));
        model.addAttribute("products", products);
        return "products/list";  // resolves to templates/products/list.html
    }

    @GetMapping("/products/{id}")
    public String productDetail(@PathVariable Long id, Model model) {
        Product product = productService.findById(id)
            .orElseThrow(() -> new ProductNotFoundException(id));
        model.addAttribute("product", product);
        return "products/detail";  // NOT a JSON response — it's a view name
    }
}

@RestController
@RequestMapping("/api/v1/orders")
public class OrderController {

    private final PaymentService paymentService;
    private final OrderRepository orderRepository;
    private final OrderMapper orderMapper;

    public OrderController(PaymentService paymentService,
                           OrderRepository orderRepository,
                           OrderMapper orderMapper) {
        this.paymentService = paymentService;
        this.orderRepository = orderRepository;
        this.orderMapper = orderMapper;
    }

    @GetMapping("/{orderId}")
    public ResponseEntity<OrderDto> getOrder(@PathVariable UUID orderId) {
        return orderRepository.findById(orderId)
            .map(orderMapper::toDto)
            .map(ResponseEntity::ok)
            .orElseThrow(() -> new OrderNotFoundException(orderId));
    }
}

@Configuration
public class InfraConfig {

    @Bean
    public RestTemplate restTemplate() {
        RestTemplate template = new RestTemplate();
        template.setRequestFactory(new HttpComponentsClientHttpRequestFactory());
        template.setInterceptors(List.of(new LoggingInterceptor()));
        return template;
    }

    @Bean
    @Primary  // default when multiple ObjectMapper beans exist
    public ObjectMapper objectMapper() {
        return JsonMapper.builder()
            .addModule(new JavaTimeModule())
            .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
            .enable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
            .build();
    }

    @Bean("relaxedMapper")
    public ObjectMapper relaxedObjectMapper() {
        return JsonMapper.builder()
            .addModule(new JavaTimeModule())
            .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
            .build();
    }

    @Bean(destroyMethod = "close")
    public HikariDataSource dataSource(
            @Value("${spring.datasource.url}") String url,
            @Value("${spring.datasource.username}") String username,
            @Value("${spring.datasource.password}") String password) {
        HikariDataSource ds = new HikariDataSource();
        ds.setJdbcUrl(url);
        ds.setUsername(username);
        ds.setPassword(password);
        ds.setMaximumPoolSize(20);
        ds.setMinimumIdle(5);
        return ds;
    }
}

@Configuration
@Import({SecurityConfig.class, CachingConfig.class, MetricsConfig.class})
public class AppConfig {
    // These configs are loaded even if they're not in a scanned package
}

@Configuration
@PropertySource("classpath:payment-gateway.properties")
@PropertySource("classpath:notification-${spring.profiles.active}.properties")
public class ExternalConfig { }

@ConfigurationProperties(prefix = "app.payment")
@Validated
public class PaymentProperties {

    @NotBlank
    private String gatewayUrl;

    @NotBlank
    private String apiKey;

    @Min(1000) @Max(30000)
    private int timeoutMs = 5000;

    @Min(1) @Max(5)
    private int maxRetries = 3;

    private Retry retry = new Retry();

    private List<String> allowedCurrencies = List.of("USD", "EUR", "GBP");

    // Nested object binding
    public static class Retry {
        private int maxAttempts = 3;
        private Duration initialDelay = Duration.ofMillis(500);
        private double multiplier = 2.0;

        // getters and setters
    }

    // getters and setters
}

@RestController
@RequestMapping(
    path = "/api/v1/orders",
    produces = MediaType.APPLICATION_JSON_VALUE
)
public class OrderController {

    private final OrderService orderService;
    private final OrderMapper orderMapper;

    public OrderController(OrderService orderService, OrderMapper orderMapper) {
        this.orderService = orderService;
        this.orderMapper = orderMapper;
    }

    // GET /api/v1/orders?page=0&size=20&status=PENDING
    @GetMapping
    public ResponseEntity<Page<OrderDto>> listOrders(
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "20") int size,
            @RequestParam(required = false) OrderStatus status) {

        Pageable pageable = PageRequest.of(page, size, Sort.by("createdAt").descending());
        Page<OrderDto> orders = orderService.findAll(status, pageable)
            .map(orderMapper::toDto);
        return ResponseEntity.ok(orders);
    }

    // GET /api/v1/orders/550e8400-e29b-41d4-a716-446655440000
    @GetMapping("/{orderId}")
    public ResponseEntity<OrderDto> getOrder(@PathVariable UUID orderId) {
        return orderService.findById(orderId)
            .map(orderMapper::toDto)
            .map(ResponseEntity::ok)
            .orElseThrow(() -> new OrderNotFoundException(orderId));
    }

    // POST /api/v1/orders
    // Body: {"customerId": "...", "items": [...], "shippingAddress": {...}}
    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public OrderDto createOrder(
            @Valid @RequestBody CreateOrderRequest request,
            @AuthenticationPrincipal UserPrincipal principal) {

        Order order = orderService.create(request, principal.getUserId());
        return orderMapper.toDto(order);
    }

    // PUT /api/v1/orders/550e8400.../status
    @PutMapping("/{orderId}/status")
    public OrderDto updateStatus(
            @PathVariable UUID orderId,
            @Valid @RequestBody UpdateStatusRequest request) {

        Order order = orderService.updateStatus(orderId, request.getStatus());
        return orderMapper.toDto(order);
    }

    // DELETE /api/v1/orders/550e8400...
    @DeleteMapping("/{orderId}")
    @ResponseStatus(HttpStatus.NO_CONTENT)  // 204 — no body returned
    public void cancelOrder(@PathVariable UUID orderId) {
        orderService.cancel(orderId);
    }
}

@Controller
public class HybridController {

    @GetMapping("/dashboard")
    public String dashboard(Model model) {
        return "dashboard";  // returns a VIEW (Thymeleaf template)
    }

    @GetMapping("/api/stats")
    @ResponseBody  // THIS method returns JSON, not a view
    public DashboardStats getStats() {
        return statsService.calculate();
    }
}

@Configuration
public class DataSourceConfig {

    @Bean("primaryDs")
    public DataSource primaryDataSource() {
        return createDataSource("jdbc:postgresql://primary:5432/shop");
    }

    @Bean("replicaDs")
    public DataSource replicaDataSource() {
        return createDataSource("jdbc:postgresql://replica:5432/shop");
    }
}

@Service
public class ReportService {

    private final DataSource readOnlyDataSource;

    public ReportService(@Qualifier("replicaDs") DataSource readOnlyDataSource) {
        this.readOnlyDataSource = readOnlyDataSource;  // injects the replica
    }
}

@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface ReadOnly { }

@Bean
@ReadOnly
public DataSource replicaDataSource() { ... }

// Usage:
public ReportService(@ReadOnly DataSource dataSource) { ... }

@Configuration
public class ObjectMapperConfig {

    @Bean
    @Primary  // injected by default everywhere
    public ObjectMapper strictMapper() {
        return JsonMapper.builder()
            .enable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
            .build();
    }

    @Bean("lenientMapper")
    public ObjectMapper lenientMapper() {
        return JsonMapper.builder()
            .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
            .build();
    }
}

// Gets the @Primary strictMapper automatically:
@Service
public class OrderService {
    public OrderService(ObjectMapper mapper) { ... }
}

// Explicitly requests the lenient one:
@Service  
public class LegacyIntegrationService {
    public LegacyIntegrationService(@Qualifier("lenientMapper") ObjectMapper mapper) { ... }
}

@Service
public class NotificationService {

    @Value("${app.notification.from-email}")
    private String fromEmail;

    @Value("${app.notification.max-retries:3}")  // default value after colon
    private int maxRetries;

    @Value("${app.notification.enabled:true}")
    private boolean enabled;

    @Value("#{${app.notification.max-retries:3} * 2}")  // SpEL expression
    private int maxTotalAttempts;

    @Value("${STRIPE_API_KEY}")  // from environment variable
    private String stripeApiKey;

    // BROKEN: static field — Spring cannot inject
    // @Value("${app.version}")
    // private static String appVersion;
}

@Service
@Lazy  // entire bean is lazy — only created when first injected AND used
public class RecommendationEngine {

    public RecommendationEngine() {
        // Loads ML model — takes 5 seconds
        loadModel();
    }
}

@Service
public class ProductService {

    private final RecommendationEngine engine;

    // @Lazy on parameter — injects a proxy, engine not created until first use
    public ProductService(@Lazy RecommendationEngine engine) {
        this.engine = engine;
    }

    public List<Product> getRecommendations(UUID userId) {
        return engine.recommend(userId);  // NOW the real bean is created
    }
}

@Service
public class OrderService {

    private final PaymentProperties paymentProperties;
    private PaymentGatewayClient client;

    public OrderService(PaymentProperties paymentProperties) {
        this.paymentProperties = paymentProperties;
    }

    @PostConstruct
    public void init() {
        // Validate config early — fail fast
        if (paymentProperties.getGatewayUrl() == null) {
            throw new IllegalStateException("Payment gateway URL not configured!");
        }

        // Initialize expensive resource
        this.client = PaymentGatewayClient.builder()
            .url(paymentProperties.getGatewayUrl())
            .timeout(paymentProperties.getTimeoutMs())
            .build();

        log.info("OrderService initialized with gateway: {}", 
                 paymentProperties.getGatewayUrl());
    }
}

@Service
public class OrderEventPublisher {

    private final ExecutorService executor = Executors.newFixedThreadPool(4);
    private final BlockingQueue<OrderEvent> buffer = new LinkedBlockingQueue<>(1000);

    @PreDestroy
    public void shutdown() {
        log.info("Shutting down OrderEventPublisher — flushing {} buffered events", buffer.size());

        // Flush remaining events
        List<OrderEvent> remaining = new ArrayList<>();
        buffer.drainTo(remaining);
        remaining.forEach(this::publishSync);

        // Graceful executor shutdown
        executor.shutdown();
        try {
            if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

@Component
@Scope("prototype")
public class ShoppingCart {
    private List<CartItem> items = new ArrayList<>();

    public void addItem(CartItem item) { items.add(item); }
}

@Service
public class CheckoutService {

    // BROKEN: prototype injected into singleton = same cart forever!
    // private final ShoppingCart cart;

    // CORRECT: use ObjectProvider to get fresh instance each time
    private final ObjectProvider<ShoppingCart> cartProvider;

    public CheckoutService(ObjectProvider<ShoppingCart> cartProvider) {
        this.cartProvider = cartProvider;
    }

    public ShoppingCart getNewCart() {
        return cartProvider.getObject();  // fresh instance each time
    }
}

@Configuration
public class DataSourceConfig {

    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.H2)
            .addScript("schema.sql")
            .addScript("dev-data.sql")
            .build();
    }

    @Bean
    @Profile("prod")
    public DataSource prodDataSource(
            @Value("${DB_URL}") String url,
            @Value("${DB_USER}") String user,
            @Value("${DB_PASS}") String password) {
        HikariDataSource ds = new HikariDataSource();
        ds.setJdbcUrl(url);
        ds.setUsername(user);
        ds.setPassword(password);
        ds.setMaximumPoolSize(30);
        return ds;
    }

    @Bean
    @Profile("test")
    public DataSource testDataSource() {
        // Testcontainers PostgreSQL for realistic testing
        return DataSourceBuilder.create()
            .url(postgreSQLContainer.getJdbcUrl())
            .username(postgreSQLContainer.getUsername())
            .password(postgreSQLContainer.getPassword())
            .build();
    }
}

@Configuration
public class CacheConfig {

    @Bean
    @ConditionalOnProperty(name = "app.cache.type", havingValue = "redis")
    public CacheManager redisCacheManager(RedisConnectionFactory factory) {
        return RedisCacheManager.builder(factory)
            .cacheDefaults(RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(30)))
            .build();
    }

    @Bean
    @ConditionalOnMissingBean(CacheManager.class)  // fallback
    public CacheManager noOpCacheManager() {
        return new NoOpCacheManager();
    }
}

@Service
public class OrderService {

    @Transactional
    public Order placeOrder(CreateOrderRequest request) {
        // Everything here runs in a single transaction
        // RuntimeException = automatic rollback
        // Checked exception = NO rollback (unless you configure rollbackFor)
    }

    @Transactional(readOnly = true)  // optimization: no dirty checking, manual flush mode
    public Page<Order> findAll(Pageable pageable) { ... }

    @Transactional(
        propagation = Propagation.REQUIRES_NEW,  // new independent transaction
        timeout = 5,                              // seconds
        rollbackFor = PaymentException.class      // rollback on this checked exception
    )
    public void processRefund(UUID orderId) { ... }
}

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@Testcontainers
class OrderIntegrationTest {

    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15");

    @DynamicPropertySource
    static void configureDatabase(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", postgres::getJdbcUrl);
        registry.add("spring.datasource.username", postgres::getUsername);
        registry.add("spring.datasource.password", postgres::getPassword);
    }

    @Autowired
    private TestRestTemplate restTemplate;

    @MockBean
    private PaymentGatewayClient paymentGateway;

    @Test
    void shouldCreateAndRetrieveOrder() {
        when(paymentGateway.charge(any(), any(), any()))
            .thenReturn(ChargeResult.success("txn_123"));

        // Create
        CreateOrderRequest request = new CreateOrderRequest(/*...*/);
        ResponseEntity<OrderDto> createResponse = restTemplate.postForEntity(
            "/api/v1/orders", request, OrderDto.class);

        assertThat(createResponse.getStatusCode()).isEqualTo(HttpStatus.CREATED);
        UUID orderId = createResponse.getBody().getId();

        // Retrieve
        ResponseEntity<OrderDto> getResponse = restTemplate.getForEntity(
            "/api/v1/orders/" + orderId, OrderDto.class);

        assertThat(getResponse.getBody().getStatus()).isEqualTo("PAID");
    }
}

@WebMvcTest(OrderController.class)
class OrderControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private OrderService orderService;

    @MockBean
    private OrderMapper orderMapper;

    @Test
    void shouldReturn404WhenOrderNotFound() throws Exception {
        when(orderService.findById(any())).thenReturn(Optional.empty());

        mockMvc.perform(get("/api/v1/orders/{id}", UUID.randomUUID())
                .contentType(MediaType.APPLICATION_JSON))
            .andExpect(status().isNotFound())
            .andExpect(jsonPath("$.message").value("Order not found"));
    }

    @Test
    void shouldReturn400OnInvalidRequest() throws Exception {
        String invalidBody = """
            {"customerId": null, "items": []}
            """;

        mockMvc.perform(post("/api/v1/orders")
                .contentType(MediaType.APPLICATION_JSON)
                .content(invalidBody))
            .andExpect(status().isBadRequest())
            .andExpect(jsonPath("$.errors").isArray());
    }
}

@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
class OrderRepositoryTest {

    @Autowired
    private TestEntityManager em;

    @Autowired
    private OrderRepository orderRepository;

    @Test
    void shouldFindPendingOrdersOlderThan24Hours() {
        Order staleOrder = createOrder(OrderStatus.PENDING, Instant.now().minus(Duration.ofHours(25)));
        Order freshOrder = createOrder(OrderStatus.PENDING, Instant.now().minus(Duration.ofHours(1)));
        em.persist(staleOrder);
        em.persist(freshOrder);
        em.flush();

        List<Order> stale = orderRepository.findStaleOrders(Duration.ofHours(24));

        assertThat(stale).containsExactly(staleOrder);
    }
}

@SpringBootTest
class PaymentFlowTest {

    @MockBean  // replaces the REAL PaymentGatewayClient with a mock
    private PaymentGatewayClient paymentGateway;

    @Autowired
    private OrderService orderService;  // gets the mock injected

    @Test
    void shouldHandlePaymentFailure() {
        when(paymentGateway.charge(any(), any(), any()))
            .thenThrow(new PaymentDeclinedException("Insufficient funds"));

        assertThrows(PaymentDeclinedException.class, () ->
            orderService.placeOrder(createRequest()));
    }
}

@TestConfiguration
public class TestNotificationConfig {

    @Bean
    public NotificationService notificationService() {
        // In-memory implementation that captures sent notifications
        return new InMemoryNotificationService();
    }
}

@SpringBootTest
@Import(TestNotificationConfig.class)
class OrderFlowTest {

    @Autowired
    private InMemoryNotificationService notifications;

    @Test
    void shouldSendConfirmationAfterOrder() {
        orderService.placeOrder(createRequest());

        assertThat(notifications.getSentEmails())
            .hasSize(1)
            .first()
            .extracting("subject")
            .isEqualTo("Order Confirmed");
    }
}