Capstone: Ship a Real Java Project

// Spring Boot 3 · Java 21 · Controller layer
import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;
import java.util.List;

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

    private final ExpenseService service;

    ExpenseController(ExpenseService service) { this.service = service; }

    @GetMapping
    public ResponseEntity<List<ExpenseDTO>> list(@AuthenticationPrincipal AppUser user) {
        return ResponseEntity.ok(service.listFor(user));
    }

    @PostMapping
    public ResponseEntity<ExpenseDTO> create(@RequestBody CreateExpenseRequest req,
                                                    @AuthenticationPrincipal AppUser user) {
        return ResponseEntity.status(201).body(service.create(req, user));
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> delete(@PathVariable Long id,
                                           @AuthenticationPrincipal AppUser user) {
        service.delete(id, user);
        return ResponseEntity.noContent().build();
    }
}

import java.util.*;
import java.time.LocalDate;

record Expense(long id, String description, double amount, LocalDate date) {}

class ExpenseService {
    private final List<Expense> store = new ArrayList<>();
    private long seq = 1;

    public Expense create(String desc, double amount) {
        Expense e = new Expense(seq++, desc, amount, LocalDate.now());
        store.add(e);
        return e;
    }

    public List<Expense> list() { return Collections.unmodifiableList(store); }

    public double totalThisMonth() {
        LocalDate firstOfMonth = LocalDate.now().withDayOfMonth(1);
        return store.stream()
            .filter(e -> !e.date().isBefore(firstOfMonth))
            .mapToDouble(Expense::amount)
            .sum();
    }

    public boolean delete(long id) { return store.removeIf(e -> e.id() == id); }
}

class Main {
    public static void main(String[] args) {
        ExpenseService svc = new ExpenseService();
        svc.create("Office lunch", 120.0);
        svc.create("Rickshaw", 30.0);
        svc.create("Mobile top-up", 50.0);

        System.out.println("--- All Expenses ---");
        svc.list().forEach(e ->
            System.out.printf("#%d %-18s %.2f BDT (%s)%n",
                e.id(), e.description(), e.amount(), e.date()));

        System.out.printf("%nTotal this month: %.2f BDT%n", svc.totalThisMonth());

        svc.delete(2);
        System.out.println("After deleting #2 → count: " + svc.list().size());
    }
}

import java.util.*;
import java.util.stream.*;

enum Category { FOOD, TRANSPORT, UTILITIES, HEALTH, ENTERTAINMENT, OTHER }

record Tx(String label, Category cat, double amount) {}

class DashboardModel {
    private final List<Tx> txns = new ArrayList<>();

    void add(Tx t) { txns.add(t); }

    Map<Category, Double> byCategory() {
        return txns.stream().collect(
            Collectors.groupingBy(Tx::cat, Collectors.summingDouble(Tx::amount)));
    }

    double total() { return txns.stream().mapToDouble(Tx::amount).sum(); }

    Category topCategory() {
        return byCategory().entrySet().stream()
            .max(Map.Entry.comparingByValue())
            .map(Map.Entry::getKey).orElse(Category.OTHER);
    }
}

class Main {
    public static void main(String[] args) {
        DashboardModel m = new DashboardModel();
        m.add(new Tx("Lunch",        Category.FOOD,          150));
        m.add(new Tx("Rickshaw",     Category.TRANSPORT,     40));
        m.add(new Tx("Internet bill", Category.UTILITIES,     500));
        m.add(new Tx("Doctor",        Category.HEALTH,        300));
        m.add(new Tx("Dinner out",    Category.FOOD,          250));
        m.add(new Tx("Cinema",        Category.ENTERTAINMENT, 180));

        System.out.println("--- Category Breakdown ---");
        m.byCategory().forEach((cat, total) ->
            System.out.printf("  %-15s %.2f BDT%n", cat, total));

        System.out.printf("%nTotal Spent : %.2f BDT%n", m.total());
        System.out.println("Top Category: " + m.topCategory());
    }
}

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Objects;

final class Money implements Comparable<Money> {
    private static final String[] BN_DIGITS = {
        "০","১","২","৩","৪","৫","৬","৭","৮","৯"
    };

    private final BigDecimal amount;

    private Money(BigDecimal amount) {
        this.amount = amount.setScale(2, RoundingMode.HALF_UP);
    }

    public static Money of(double taka) { return new Money(BigDecimal.valueOf(taka)); }
    public static Money of(long taka)   { return new Money(BigDecimal.valueOf(taka)); }

    public Money plus(Money other)  { return new Money(amount.add(other.amount)); }
    public Money minus(Money other) { return new Money(amount.subtract(other.amount)); }
    public Money times(double factor) {
        return new Money(amount.multiply(BigDecimal.valueOf(factor)));
    }

    public String formatBn() {
        String s = amount.toPlainString();
        StringBuilder sb = new StringBuilder();
        for (char c : s.toCharArray()) {
            sb.append(c >= '0' && c <= '9' ? BN_DIGITS[c - '0'] : c);
        }
        return "৳" + sb;
    }

    @Override public int     compareTo(Money o)  { return amount.compareTo(o.amount); }
    @Override public boolean equals(Object o)    { return o instanceof Money m && amount.equals(m.amount); }
    @Override public int     hashCode()         { return Objects.hash(amount); }
    @Override public String  toString()         { return "BDT " + amount.toPlainString(); }
}

class Main {
    public static void main(String[] args) {
        Money price  = Money.of(1250.50);
        Money tax    = price.times(0.15);
        Money total  = price.plus(tax);
        Money change = Money.of(2000).minus(total);

        System.out.println("Price  : " + price.formatBn());
        System.out.println("Tax 15%: " + tax.formatBn());
        System.out.println("Total  : " + total.formatBn());
        System.out.println("Change : " + change.formatBn());
        System.out.println("price < total? " + (price.compareTo(total) < 0));
    }
}

import java.util.*;
import java.util.stream.*;

class Stats {
    final String column;
    final double min, max, mean, p50, p90;
    final long   count;

    private Stats(String col, double[] sorted) {
        column = col;
        count  = sorted.length;
        min    = sorted[0];
        max    = sorted[sorted.length - 1];
        mean   = Arrays.stream(sorted).average().orElse(0);
        p50    = percentile(sorted, 50);
        p90    = percentile(sorted, 90);
    }

    static Stats of(String col, List<Double> values) {
        double[] sorted = values.stream().mapToDouble(Double::doubleValue).sorted().toArray();
        return new Stats(col, sorted);
    }

    private static double percentile(double[] s, int p) {
        int idx = (int) Math.ceil(p / 100.0 * s.length) - 1;
        return s[Math.max(0, idx)];
    }

    @Override public String toString() {
        return String.format(
            "%-12s count=%-4d min=%-8.2f max=%-8.2f mean=%-8.2f p50=%-8.2f p90=%.2f",
            column, count, min, max, mean, p50, p90);
    }
}

class CsvParser {
    /** Parse a CSV string into column→values map. */
    static Map<String, List<Double>> parse(String csv) {
        String[] lines = csv.strip().split("\n");
        String[] headers = lines[0].split(",");
        Map<String, List<Double>> cols = new LinkedHashMap<>();
        for (String h : headers) cols.put(h.trim(), new ArrayList<>());

        for (int i = 1; i < lines.length; i++) {
            String[] vals = lines[i].split(",");
            for (int j = 0; j < headers.length; j++) {
                try { cols.get(headers[j].trim()).add(Double.parseDouble(vals[j].trim())); }
                catch (NumberFormatException ignored) {}
            }
        }
        return cols;
    }
}

class Main {
    public static void main(String[] args) {
        String csv =
            "salary,hours,rating\n" +
            "45000,40,4.2\n50000,38,3.8\n62000,45,4.7\n" +
            "38000,42,3.5\n71000,35,4.9\n55000,40,4.1\n" +
            "48000,43,3.9\n66000,37,4.6\n42000,41,4.0\n" +
            "58000,39,4.3\n";

        System.out.println("bdstats summary");
        System.out.println("─".repeat(80));
        CsvParser.parse(csv).forEach((col, vals) ->
            System.out.println(Stats.of(col, vals)));
    }
}

# Stage 1: build
FROM eclipse-temurin:21-jdk-alpine AS build
WORKDIR /app
COPY . .
RUN ./mvnw -q package -DskipTests

# Stage 2: run — smaller image
FROM eclipse-temurin:21-jre-alpine
WORKDIR /app
COPY --from=build /app/target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

name: CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          java-version: '21'
          distribution: 'temurin'
          cache: maven
      - name: Run tests
        run: ./mvnw -q test
      - name: Build Docker image
        run: docker build -t expense-tracker:ci .