Implementing Structural Design Patterns

interface PaymentGateway { Receipt charge(Money m); }
class StripeAdapter implements PaymentGateway {
    private final StripeClient stripe;
    public Receipt charge(Money m) {
        var resp = stripe.createCharge(m.cents(), m.currency().code());
        return new Receipt(resp.id(), resp.status());
    }
}

interface Channel { void send(String to, String body); }
abstract class Notification {
    protected final Channel channel;
    Notification(Channel c) { this.channel = c; }
    abstract void notify(User u);
}
class WelcomeNotification extends Notification { ... }  // ↔ EmailChannel, SmsChannel

interface FsNode { long size(); }
record File(String name, long size) implements FsNode {}
record Folder(String name, List<FsNode> children) implements FsNode {
    public long size() { return children.stream().mapToLong(FsNode::size).sum(); }
}

interface DataSource { String read(); void write(String s); }
class EncryptedDataSource implements DataSource {
    private final DataSource inner;
    EncryptedDataSource(DataSource d) { this.inner = d; }
    public String read() { return decrypt(inner.read()); }
    public void write(String s) { inner.write(encrypt(s)); }
}
DataSource ds = new EncryptedDataSource(new CompressedDataSource(new FileDataSource("a.dat")));

class CheckoutFacade {
    public Receipt checkout(Cart c) {
        inventory.reserve(c);
        var charge = payment.charge(c.total());
        var order = orders.place(c, charge);
        notifier.confirm(order);
        return order.receipt();
    }
}

public interface OrderRepository {
    Optional<Order> findById(OrderId id);
    void save(Order order);
    List<Order> findByCustomer(CustomerId c, Pageable p);
}

class LoggingList<T> implements List<T> {
    private final List<T> delegate;
    public boolean add(T t) { log.info("add {}", t); return delegate.add(t); }
    // ... forward all other methods
}

class LazyImageProxy implements Image {
    private final String path;
    private RealImage real;
    public void render() {
        if (real == null) real = new RealImage(path);
        real.render();
    }
}

MyService proxy = (MyService) Proxy.newProxyInstance(
    MyService.class.getClassLoader(),
    new Class<?>[]{MyService.class},
    (p, method, args) -> {
        log.info("call {}", method.getName());
        return method.invoke(target, args);
    });