Production-Ready Service

<!-- Auto-configures /actuator/health, /actuator/info, and more, based purely
     on this dependency being present on the classpath — no Java code required. -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

spring.application.name=inventory-service

# Actuator exposes ONLY /actuator/health over HTTP by default. This line opens
# up /actuator/info as well; a real production setup would review this list
# carefully rather than exposing every actuator endpoint publicly.
management.endpoints.web.exposure.include=health,info

# Populates the JSON body returned by GET /actuator/info.
info.app.name=Inventory Service
info.app.description=Production-ready Spring Boot REST API

# Active when spring.profiles.active=dev. No install required, resets on restart.
spring.datasource.url=jdbc:h2:mem:inventorydb
spring.datasource.driver-class-name=org.h2.Driver
spring.jpa.hibernate.ddl-auto=update

# DEBUG locally so every SQL statement and framework decision is visible while developing.
logging.level.com.programinds.inventory=DEBUG

# Active when spring.profiles.active=prod. Values come from environment
# variables (Step 5) — never a literal connection string or password here.
spring.datasource.url=${DATABASE_URL}
spring.datasource.username=${DATABASE_USERNAME}
spring.datasource.password=${DATABASE_PASSWORD}
spring.jpa.hibernate.ddl-auto=validate

# INFO in production: DEBUG-level detail would flood production logs and can
# leak more information than a production environment should expose.
logging.level.com.programinds.inventory=INFO

package com.programinds.inventory.service;

// A plain interface — InventoryService (Step 4) depends on this, never on a
// concrete implementation, which is what lets the two @Profile-gated classes
// below be swapped by configuration alone, with zero changes to InventoryService.
public interface NotificationService {
    void notifyLowStock(String productName, int remaining);
}

package com.programinds.inventory.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Service;

// @Profile("dev") means Spring only registers this bean when
// spring.profiles.active=dev. It never touches a real notification provider —
// exactly what a local development run should do.
@Service
@Profile("dev")
public class DevNotificationService implements NotificationService {

    private static final Logger log = LoggerFactory.getLogger(DevNotificationService.class);

    @Override
    public void notifyLowStock(String productName, int remaining) {
        log.info("[DEV] Low stock alert: {} has {} left", productName, remaining);
    }
}

package com.programinds.inventory.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Service;

@Service
@Profile("prod")   // Only registered when spring.profiles.active=prod
public class ProdNotificationService implements NotificationService {

    private static final Logger log = LoggerFactory.getLogger(ProdNotificationService.class);

    @Override
    public void notifyLowStock(String productName, int remaining) {
        // A real implementation would call an email/SMS/Slack provider here,
        // authenticated with credentials read from environment variables
        // (Step 5) — never hardcoded in this class.
        log.warn("Low stock alert: {} has {} left — notifying operations team", productName, remaining);
    }
}

package com.programinds.inventory.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

@Service
public class InventoryService {

    // One Logger per class is the SLF4J convention — every log line this class
    // produces is automatically tagged with "InventoryService" so its origin is unambiguous.
    private static final Logger log = LoggerFactory.getLogger(InventoryService.class);

    private static final int LOW_STOCK_THRESHOLD = 5;

    private final NotificationService notificationService;

    // Spring injects whichever @Profile-gated implementation from Step 3 is
    // currently active. InventoryService never checks which one it got.
    public InventoryService(NotificationService notificationService) {
        this.notificationService = notificationService;
    }

    public void recordSale(String productName, int stockRemaining) {
        // {} placeholders: SLF4J only formats this string if INFO is enabled for
        // this logger, unlike "productName + " is at " + stockRemaining", which
        // always builds the string whether or not it ends up logged anywhere.
        log.info("Sale recorded for {}, {} units remaining", productName, stockRemaining);

        if (stockRemaining <= LOW_STOCK_THRESHOLD) {
            log.warn("{} is below the low-stock threshold of {}", productName, LOW_STOCK_THRESHOLD);
            notificationService.notifyLowStock(productName, stockRemaining);
        }
    }
}

# Local development: reads application-dev.properties, no secrets required
./mvnw spring-boot:run -Dspring-boot.run.profiles=dev

# Production: reads application-prod.properties, and its ${...} placeholders
# are resolved from these environment variables, set by the deployment platform
# (a process manager, container orchestrator, or PaaS config panel) — never
# typed into a properties file that could end up committed to source control.
export SPRING_PROFILES_ACTIVE=prod
export DATABASE_URL=jdbc:postgresql://prod-db.internal:5432/inventory
export DATABASE_USERNAME=inventory_service
export DATABASE_PASSWORD=********
java -jar inventory-service.jar

spring.application.name=inventory-service
management.endpoints.web.exposure.include=health,info
info.app.name=Inventory Service
info.app.description=Production-ready Spring Boot REST API

# Defaults to dev so a plain "./mvnw spring-boot:run" still starts successfully
# with exactly one NotificationService bean available. A real deployment always
# overrides this via the SPRING_PROFILES_ACTIVE environment variable instead.
spring.profiles.active=dev

package com.programinds.inventory.controller;

import com.programinds.inventory.service.InventoryService;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/inventory")
public class InventoryController {

    private final InventoryService inventoryService;

    public InventoryController(InventoryService inventoryService) {
        this.inventoryService = inventoryService;
    }

    @PostMapping("/sale")
    public String recordSale(@RequestParam String productName, @RequestParam int stockRemaining) {
        inventoryService.recordSale(productName, stockRemaining);   // Logs (Step 4) and may trigger a low-stock notification (Step 3)
        return "Sale recorded for " + productName;
    }
}

package com.programinds.inventory;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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