Spring Modulith: Building a Modular Monolith

//ShopApp.java
package com.javabrahman.shop;

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

@SpringBootApplication
public class ShopApp {

  public static void main(String[] args) {
    System.exit(SpringApplication.exit(SpringApplication.run(ShopApp.class, args)));
  }
}

//CatalogService.java
package com.javabrahman.shop.catalog;

import com.javabrahman.shop.catalog.internal.PriceTable;
import org.springframework.stereotype.Service;

@Service
public class CatalogService {

  private final PriceTable prices;

  CatalogService(PriceTable prices) {
    this.prices = prices;
  }

  public int priceInCents(String isbn) {
    return prices.lookup(isbn);
  }
}

//PriceTable.java
package com.javabrahman.shop.catalog.internal;

import java.util.Map;
import org.springframework.stereotype.Component;

@Component
public class PriceTable {

  private final Map<String, Integer> prices = Map.of("978-1", 4500, "978-2", 3850);

  public int lookup(String isbn) {
    return prices.get(isbn);
  }
}

//OrderPlaced.java
package com.javabrahman.shop.order;

public record OrderPlaced(long orderId, String isbn, int quantity) {
}

//OrderService.java
package com.javabrahman.shop.order;

import com.javabrahman.shop.catalog.CatalogService;
import com.javabrahman.shop.order.internal.OrderRepository;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class OrderService {

  private final OrderRepository orders;
  private final CatalogService catalog;
  private final ApplicationEventPublisher events;

  OrderService(OrderRepository orders, CatalogService catalog, ApplicationEventPublisher events) {
    this.orders = orders;
    this.catalog = catalog;
    this.events = events;
  }

  @Transactional
  public void place(long id, String isbn, int quantity) {
    int total = catalog.priceInCents(isbn) * quantity;
    orders.save(id, isbn, quantity, total);
    events.publishEvent(new OrderPlaced(id, isbn, quantity));
    System.out.println("order: order " + id + " saved, total " + total + " cents [" + Thread.currentThread().getName() + "]");
  }
}

//OrderRepository.java
package com.javabrahman.shop.order.internal;

import org.springframework.jdbc.core.simple.JdbcClient;
import org.springframework.stereotype.Repository;

@Repository
public class OrderRepository {

  private final JdbcClient jdbc;

  OrderRepository(JdbcClient jdbc) {
    this.jdbc = jdbc;
  }

  public void save(long id, String isbn, int quantity, int totalCents) {
    jdbc.sql("insert into orders values (?, ?, ?, ?)").params(id, isbn, quantity, totalCents).update();
  }
}

create table orders (id bigint primary key, isbn varchar(20), quantity int, total_cents int);
create table stock (isbn varchar(20) primary key, available int);
insert into stock values ('978-1', 10);

//VerifyModules.java
package com.javabrahman.shop;

import org.springframework.modulith.core.ApplicationModules;

public class VerifyModules {

  public static void main(String[] args) {
    ApplicationModules modules = ApplicationModules.of(ShopApp.class);
    modules.forEach(System.out::println);
    modules.verify();
    System.out.println("verify(): no violations");
  }
}

class ModularityTests {

  @Test
  void verifiesModularStructure() {
    ApplicationModules.of(ShopApp.class).verify();
  }
}

//BadShopApp.java
package com.javabrahman.badshop;

import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.modulith.core.ApplicationModules;
import org.springframework.modulith.core.Violations;

@SpringBootApplication
public class BadShopApp {

  public static void main(String[] args) {
    try {
      ApplicationModules.of(BadShopApp.class).verify();
    } catch (Violations violations) {
      System.out.println(violations.getMessage());
    }
  }
}

//PricingService.java
package com.javabrahman.badshop.pricing;

import com.javabrahman.badshop.billing.BillingService;
import org.springframework.stereotype.Service;

@Service
public class PricingService {

  private final BillingService billing;

  PricingService(BillingService billing) {
    this.billing = billing;
  }

  public int price(String isbn) {
    return billing.hasUnpaidInvoices() ? 5000 : 4500;
  }
}

//DiscountTable.java
package com.javabrahman.badshop.pricing.internal;

import org.springframework.stereotype.Component;

@Component
public class DiscountTable {

  public int discountPercent(String isbn) {
    return 10;
  }
}

//BillingService.java
package com.javabrahman.badshop.billing;

import com.javabrahman.badshop.pricing.PricingService;
import com.javabrahman.badshop.pricing.internal.DiscountTable;
import org.springframework.stereotype.Service;

@Service
public class BillingService {

  private final PricingService pricing;
  private final DiscountTable discounts;

  BillingService(PricingService pricing, DiscountTable discounts) {
    this.pricing = pricing;
    this.discounts = discounts;
  }

  public int invoiceAmount(String isbn) {
    return pricing.price(isbn) * (100 - discounts.discountPercent(isbn)) / 100;
  }

  public boolean hasUnpaidInvoices() {
    return false;
  }
}

//InventoryListener.java
package com.javabrahman.shop.inventory;

import com.javabrahman.shop.order.OrderPlaced;
import org.springframework.jdbc.core.simple.JdbcClient;
import org.springframework.modulith.events.ApplicationModuleListener;
import org.springframework.stereotype.Component;

@Component
class InventoryListener {

  private final JdbcClient jdbc;

  InventoryListener(JdbcClient jdbc) {
    this.jdbc = jdbc;
  }

  @ApplicationModuleListener
  void on(OrderPlaced event) {
    jdbc.sql("update stock set available = available - ? where isbn = ?").params(event.quantity(), event.isbn()).update();
    System.out.println("inventory: stock reduced for order " + event.orderId() + " [" + Thread.currentThread().getName() + "]");
  }
}

//MailGateway.java
package com.javabrahman.shop.notification;

import org.springframework.stereotype.Component;

@Component
public class MailGateway {

  private volatile boolean available = true;

  public void setAvailable(boolean available) {
    this.available = available;
  }

  void send(String text) {
    if (!available) {
      System.out.println("notification: mail NOT sent - mail server not reachable [" + Thread.currentThread().getName() + "]");
      throw new IllegalStateException("mail server not reachable");
    }
    System.out.println("notification: mail sent - " + text + " [" + Thread.currentThread().getName() + "]");
  }
}

//NotificationListener.java
package com.javabrahman.shop.notification;

import com.javabrahman.shop.order.OrderPlaced;
import org.springframework.modulith.events.ApplicationModuleListener;
import org.springframework.stereotype.Component;

@Component
class NotificationListener {

  private final MailGateway mail;

  NotificationListener(MailGateway mail) {
    this.mail = mail;
  }

  @ApplicationModuleListener
  void on(OrderPlaced event) {
    mail.send("your order " + event.orderId() + " is confirmed");
  }
}

spring.main.banner-mode=off
logging.level.root=WARN
spring.modulith.events.jdbc.schema-initialization.enabled=true
logging.level.org.springframework.aop.interceptor=OFF

//ShopRunner.java
package com.javabrahman.shop;

import com.javabrahman.shop.notification.MailGateway;
import com.javabrahman.shop.order.OrderService;
import org.springframework.boot.CommandLineRunner;
import org.springframework.jdbc.core.simple.JdbcClient;
import org.springframework.modulith.events.IncompleteEventPublications;
import org.springframework.stereotype.Component;

@Component
class ShopRunner implements CommandLineRunner {

  private final OrderService orders;
  private final MailGateway mail;
  private final IncompleteEventPublications incomplete;
  private final JdbcClient jdbc;

  ShopRunner(OrderService orders, MailGateway mail, IncompleteEventPublications incomplete, JdbcClient jdbc) {
    this.orders = orders;
    this.mail = mail;
    this.incomplete = incomplete;
    this.jdbc = jdbc;
  }

  @Override
  public void run(String... args) throws Exception {
    System.out.println("--- order 1");
    orders.place(1, "978-1", 2);
    Thread.sleep(1000);
    publications();

    System.out.println("--- order 2, while the mail server is down");
    mail.setAvailable(false);
    orders.place(2, "978-1", 1);
    Thread.sleep(1000);
    publications();

    System.out.println("--- the mail server is back: resubmit what is incomplete");
    mail.setAvailable(true);
    incomplete.resubmitIncompletePublications(publication -> true);
    Thread.sleep(1000);
    publications();
  }

  private void publications() {
    jdbc.sql("select listener_id, serialized_event, status from event_publication order by publication_date, listener_id")
        .query((row, n) -> {
          String listener = row.getString(1).replaceAll(".*\\.(\\w+\\.\\w+)\\.on\\(.*", "$1");
          return "   " + listener + "  " + row.getString(2) + "  " + row.getString(3);
        }).list().forEach(System.out::println);
  }
}

//DocumentModules.java
package com.javabrahman.shop;

import org.springframework.modulith.core.ApplicationModules;
import org.springframework.modulith.docs.Documenter;

public class DocumentModules {

  public static void main(String[] args) {
    new Documenter(ApplicationModules.of(ShopApp.class))
        .writeModulesAsPlantUml()
        .writeModuleCanvases();
    System.out.println("documentation written");
  }
}