Корень композиции

import java.util.*;

//entity
class Order {
    final int id;
    final int total;

    Order(int id, int total) {
        this.id = id;
        this.total = total;
    }

    int payable() {
        return total >= 200 ? total - total / 10 : total;
    }
}

//gateway
interface Catalog {
    Integer price(String sku);
}

//repository
interface Orders {
    void save(Order order);

    int count();
}

//output port
interface Report {
    void say(String text);
}

//use case: asks for its parts, never builds them
class PlaceOrder {
    private final Catalog catalog;
    private final Orders orders;
    private final Report report;
    private int nextId = 1001;

    PlaceOrder(Catalog catalog, Orders orders,
               Report report) {
        this.catalog = catalog;
        this.orders = orders;
        this.report = report;
    }

    void place(Map<String, Integer> items) {
        int total = 0;
        for (var item : items.entrySet()) {
            Integer price = catalog.price(item.getKey());
            if (price == null) {
                report.say("no " + item.getKey());
                return;
            }
            total += price * item.getValue();
        }
        Order order = new Order(nextId++, total);
        orders.save(order);
        report.say("order " + order.id
                   + " for " + order.payable());
    }
}

//adapters
class MemoryCatalog implements Catalog {
    public Integer price(String sku) {
        return Map.of("pen", 30, "lamp", 190).get(sku);
    }
}

class MemoryOrders implements Orders {
    private final List<Order> rows = new ArrayList<>();

    public void save(Order order) {
        rows.add(order);
    }

    public int count() {
        return rows.size();
    }
}

class ConsoleReport implements Report {
    public void say(String text) {
        System.out.println(text);
    }
}

class SilentReport implements Report {
    public void say(String text) {
    }
}

//composition root: the only place that sees every layer
//at once, and the only place where an adapter is built
class ShopApp {
    final PlaceOrder useCase;
    final Orders orders;

    ShopApp(Catalog catalog, Orders orders, Report report) {
        this.orders = orders;
        this.useCase =
            new PlaceOrder(catalog, orders, report);
    }

    static ShopApp loud() {
        return new ShopApp(new MemoryCatalog(),
                           new MemoryOrders(),
                           new ConsoleReport());
    }

    static ShopApp quiet() {
        return new ShopApp(new MemoryCatalog(),
                           new MemoryOrders(),
                           new SilentReport());
    }
}

//client code
var app = ShopApp.loud();
app.useCase.place(Map.of("pen", 2, "lamp", 1));
app.useCase.place(Map.of("chair", 1));

//a second root builds the same use case differently
var night = ShopApp.quiet();
night.useCase.place(Map.of("lamp", 1));
System.out.println("saved " + night.orders.count());
//printed: order 1001 for 225
//         no chair
//         saved 1