Design in action: blueprint to working code

package com.example.spendlog.model;

public enum Category { FOOD, TRAVEL, BILLS, OTHER }

package com.example.spendlog.model;

import jakarta.persistence.*;
import lombok.*;
import java.math.BigDecimal;
import java.time.LocalDate;

@Entity @Table(name = "expenses")
@Getter @Setter @NoArgsConstructor @AllArgsConstructor
public class Expense {

    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private BigDecimal amount;               // money → BigDecimal, never double

    @Enumerated(EnumType.STRING)             // store the enum as text, not a number
    @Column(nullable = false)
    private Category category;

    @Column(nullable = false)
    private LocalDate date;

    private String note;
}

package com.example.spendlog.repository;

import com.example.spendlog.model.Category;
import com.example.spendlog.model.Expense;
import org.springframework.data.jpa.repository.*;
import org.springframework.data.repository.query.Param;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.List;

public interface ExpenseRepository extends JpaRepository<Expense, Long> {

    List<Expense> findByCategory(Category category);          // derived query

    @Query("select coalesce(sum(e.amount), 0) from Expense e " + "where e.date between :start and :end")
    BigDecimal totalBetween(@Param("start") LocalDate start, @Param("end") LocalDate end);      // custom aggregate
}

package com.example.spendlog.alert;

public interface AlertService {
    void sendOverLimitAlert(String message);
}

package com.example.spendlog.alert;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Slf4j
@Service                                   // this is the bean that satisfies AlertService
public class EmailAlertService implements AlertService {
    @Override
    public void sendOverLimitAlert(String message) {
        // a real one would call an email API; we log to prove it fired
        log.info("[EMAIL] {}", message);
    }
}

package com.example.spendlog.alert;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Slf4j
// @Service   <-- leave OFF for now; see the DI note below
public class SmsAlertService implements AlertService {
    @Override
    public void sendOverLimitAlert(String message) {
        log.info("[SMS] {}", message);
    }
}

package com.example.spendlog.service;

import com.example.spendlog.alert.AlertService;
import com.example.spendlog.model.*;
import com.example.spendlog.repository.ExpenseRepository;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.List;

@Service
public class ExpenseService {

    private final ExpenseRepository repository;
    private final AlertService alertService;             // the INTERFACE, not an impl
    private final BigDecimal limit;

    public ExpenseService(ExpenseRepository repository, AlertService alertService,     // Spring injects EmailAlertService
    @Value("${spendlog.alert-limit:1000}") BigDecimal limit) {
        this.repository = repository;
        this.alertService = alertService;
        this.limit = limit;                              // configurable, from properties
    }

    public Expense add(Expense expense) {
        Expense saved = repository.save(expense);
        if (saved.getAmount().compareTo(limit) > 0) {   // THE rule
            alertService.sendOverLimitAlert("Expense of " + saved.getAmount() + " exceeds limit " + limit);
        }
        return saved;
    }

    public List<Expense> byCategory(Category c) { return repository.findByCategory(c); }

    public BigDecimal monthlyTotal(int year, int month) {
        LocalDate start = LocalDate.of(year, month, 1);
        LocalDate end = start.withDayOfMonth(start.lengthOfMonth());
        return repository.totalBetween(start, end);
    }
}

package com.example.spendlog.controller;

import com.example.spendlog.model.*;
import com.example.spendlog.service.ExpenseService;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.util.List;

@RestController
@RequestMapping("/expenses")
public class ExpenseController {

    private final ExpenseService service;
    public ExpenseController(ExpenseService service) { this.service = service; }

    @PostMapping
    public Expense add(@RequestBody Expense expense) { return service.add(expense); }

    @GetMapping                                          // GET /expenses?category=FOOD
    public List<Expense> byCategory(@RequestParam Category category) {
        return service.byCategory(category);
    }

    @GetMapping("/total")                                // GET /expenses/total?year=2026&month=8
    public BigDecimal monthlyTotal(@RequestParam int year, @RequestParam int month) {
        return service.monthlyTotal(year, month);
    }
}

@ExtendWith(MockitoExtension.class)
class ExpenseServiceTest {

    @Mock ExpenseRepository repository;
    @Mock AlertService alertService;          // mock the interface — no real email

    ExpenseService service;

    @BeforeEach
    void setUp() {
        // limit = 1000 for the test; construct the service by hand with the mocks
        service = new ExpenseService(repository, alertService, new BigDecimal("1000"));
        when(repository.save(any(Expense.class))).thenAnswer(i -> i.getArgument(0));
    }

    @Test
    void add_overLimit_firesAlert() {
        service.add(new Expense(null, new BigDecimal("1500"), Category.TRAVEL, LocalDate.now(), "x"));
        verify(alertService, times(1)).sendOverLimitAlert(anyString());
    }

    @Test
    void add_underLimit_doesNotAlert() {
        service.add(new Expense(null, new BigDecimal("50"), Category.FOOD, LocalDate.now(), "x"));
        verify(alertService, never()).sendOverLimitAlert(anyString());
    }
}