Microservices là gì? So sánh Monolithic và Microservices

01-monolith-va-microservices/
  pom.xml                       parent Boot 4.1.1, webmvc, jdbc, restclient, H2
  src/main/java/dev/canhdominich/micro/
    monolith/MonolithApplication.java     nguyên khối: bảng stock và orders cùng một cơ sở dữ liệu
    monolith/ShopService.java             placeOrder trong một giao dịch @Transactional
    monolith/ShopController.java          POST /orders, GET /stock/{sku}, GET /orders/count
    inventory/InventoryApplication.java   dịch vụ tồn kho với cơ sở dữ liệu riêng
    inventory/InventoryController.java    POST /reserve, GET /stock/{sku}
    order/OrderApplication.java           dịch vụ đơn hàng với cơ sở dữ liệu riêng
    order/OrderController.java            POST /orders gọi inventory rồi lưu đơn, GET /orders/count
    ComparisonDemo.java                   khởi chạy từng tiến trình và đo

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>4.1.1</version>
        <relativePath/>
    </parent>

    <groupId>dev.canhdominich.javabackend</groupId>
    <artifactId>micro-monolith-vs-microservices</artifactId>
    <version>1.0.0</version>
    <name>Microservices - Monolith va Microservices</name>

    <properties>
        <java.version>17</java.version>
        <main.class>dev.canhdominich.micro.ComparisonDemo</main.class>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webmvc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-restclient</artifactId>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <configuration>
                    <executable>java</executable>
                    <arguments>
                        <argument>-classpath</argument>
                        <classpath/>
                        <argument>${main.class}</argument>
                    </arguments>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

package dev.canhdominich.micro.monolith;

import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.core.JdbcTemplate;

@SpringBootApplication
public class MonolithApplication {

    @Bean
    ApplicationRunner schema(JdbcTemplate jdbc) {
        return args -> {
            jdbc.execute("create table stock (sku varchar(20) primary key, quantity int not null)");
            jdbc.execute("create table orders (id bigint auto_increment primary key, sku varchar(20) not null, quantity int not null)");
            jdbc.update("insert into stock values ('BOOK', 10000)");
        };
    }

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

package dev.canhdominich.micro.monolith;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class ShopService {

    private final JdbcTemplate jdbc;

    public ShopService(JdbcTemplate jdbc) {
        this.jdbc = jdbc;
    }

    @Transactional
    public void placeOrder(String sku, int quantity, boolean failAfterReserve) {
        int updated = jdbc.update("update stock set quantity = quantity - ? where sku = ? and quantity >= ?", quantity, sku, quantity);
        if (updated == 0) {
            throw new IllegalStateException("out of stock");
        }
        jdbc.update("insert into orders (sku, quantity) values (?, ?)", sku, quantity);
        if (failAfterReserve) {
            throw new IllegalStateException("simulated failure after the stock was reserved");
        }
    }

    public int stock(String sku) {
        return jdbc.queryForObject("select quantity from stock where sku = ?", Integer.class, sku);
    }

    public int orderCount() {
        return jdbc.queryForObject("select count(*) from orders", Integer.class);
    }
}

package dev.canhdominich.micro.monolith;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ShopController {

    private final ShopService shop;

    public ShopController(ShopService shop) {
        this.shop = shop;
    }

    @PostMapping("/orders")
    public String order(@RequestParam String sku, @RequestParam int quantity, @RequestParam(defaultValue = "false") boolean failAfterReserve) {
        shop.placeOrder(sku, quantity, failAfterReserve);
        return "ordered";
    }

    @GetMapping("/stock/{sku}")
    public String stock(@PathVariable String sku) {
        return String.valueOf(shop.stock(sku));
    }

    @GetMapping("/orders/count")
    public String count() {
        return String.valueOf(shop.orderCount());
    }
}

package dev.canhdominich.micro.inventory;

import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.core.JdbcTemplate;

@SpringBootApplication
public class InventoryApplication {

    @Bean
    ApplicationRunner schema(JdbcTemplate jdbc) {
        return args -> {
            jdbc.execute("create table stock (sku varchar(20) primary key, quantity int not null)");
            jdbc.update("insert into stock values ('BOOK', 10000)");
        };
    }

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

package dev.canhdominich.micro.inventory;

import org.springframework.http.HttpStatus;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.server.ResponseStatusException;

@RestController
public class InventoryController {

    private final JdbcTemplate jdbc;

    public InventoryController(JdbcTemplate jdbc) {
        this.jdbc = jdbc;
    }

    @PostMapping("/reserve")
    public String reserve(@RequestParam String sku, @RequestParam int quantity) {
        int updated = jdbc.update("update stock set quantity = quantity - ? where sku = ? and quantity >= ?", quantity, sku, quantity);
        if (updated == 0) {
            throw new ResponseStatusException(HttpStatus.CONFLICT, "out of stock");
        }
        return "reserved";
    }

    @GetMapping("/stock/{sku}")
    public String stock(@PathVariable String sku) {
        return String.valueOf(jdbc.queryForObject("select quantity from stock where sku = ?", Integer.class, sku));
    }
}

package dev.canhdominich.micro.order;

import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.core.JdbcTemplate;

@SpringBootApplication
public class OrderApplication {

    @Bean
    ApplicationRunner schema(JdbcTemplate jdbc) {
        return args -> jdbc.execute("create table orders (id bigint auto_increment primary key, sku varchar(20) not null, quantity int not null)");
    }

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

package dev.canhdominich.micro.order;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestClient;

@RestController
public class OrderController {

    private final JdbcTemplate jdbc;
    private final RestClient inventory;

    public OrderController(JdbcTemplate jdbc, RestClient.Builder builder, @Value("${inventory.url}") String inventoryUrl) {
        this.jdbc = jdbc;
        this.inventory = builder.baseUrl(inventoryUrl).build();
    }

    @PostMapping("/orders")
    public String order(@RequestParam String sku, @RequestParam int quantity, @RequestParam(defaultValue = "false") boolean failAfterReserve) {
        inventory.post().uri("/reserve?sku={sku}&quantity={quantity}", sku, quantity).retrieve().toBodilessEntity();
        if (failAfterReserve) {
            throw new IllegalStateException("simulated failure after the stock was reserved");
        }
        jdbc.update("insert into orders (sku, quantity) values (?, ?)", sku, quantity);
        return "ordered";
    }

    @GetMapping("/orders/count")
    public String count() {
        return String.valueOf(jdbc.queryForObject("select count(*) from orders", Integer.class));
    }
}

package dev.canhdominich.micro;

import dev.canhdominich.micro.inventory.InventoryApplication;
import dev.canhdominich.micro.monolith.MonolithApplication;
import dev.canhdominich.micro.order.OrderApplication;
import java.io.File;
import java.net.ServerSocket;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ComparisonDemo {

    private static final HttpClient HTTP = HttpClient.newHttpClient();

    public static void main(String[] args) throws Exception {
        run().forEach(System.out::println);
        System.exit(0);
    }

    public static List<String> run() throws Exception {
        List<String> lines = new ArrayList<>();
        List<Node> nodes = new ArrayList<>();
        try {
            long t0 = System.nanoTime();
            Node monolith = launch(nodes, MonolithApplication.class, "/stock/BOOK");
            double monolithStart = (System.nanoTime() - t0) / 1e9;
            long t1 = System.nanoTime();
            Node inventory = launch(nodes, InventoryApplication.class, "/stock/BOOK");
            Node order = launch(nodes, OrderApplication.class, "/orders/count", "--inventory.url=http://localhost:" + inventory.port);
            double microStart = (System.nanoTime() - t1) / 1e9;
            for (int i = 0; i < 30; i++) {
                post(monolith.port, "/orders?sku=BOOK&quantity=1");
                post(order.port, "/orders?sku=BOOK&quantity=1");
            }
            lines.add("-- cost of running it");
            lines.add("processes: monolith 1, microservices 2");
            lines.add("memory after warm-up: monolith " + round10(rssMb(monolith)) + " MB, microservices " + round10(rssMb(inventory) + rssMb(order)) + " MB");
            lines.add("time until ready: monolith " + roundHalf(monolithStart) + " s, microservices (started one after the other) " + roundHalf(microStart) + " s");
            lines.add("-- cost of every call");
            long[] mono = timings(monolith.port, 300);
            long[] micro = timings(order.port, 300);
            lines.add("median of 300 orders: monolith " + mono[0] + " ms, microservices " + micro[0] + " ms");
            lines.add("one extra network hop makes the median slower: " + (micro[0] > mono[0]));
            lines.add("-- an order that fails after the stock was reserved");
            int monoStockBefore = Integer.parseInt(get(monolith.port, "/stock/BOOK"));
            int monoOrdersBefore = Integer.parseInt(get(monolith.port, "/orders/count"));
            int monoStatus = post(monolith.port, "/orders?sku=BOOK&quantity=5&failAfterReserve=true");
            lines.add("monolith: status " + monoStatus + ", stock change " + (Integer.parseInt(get(monolith.port, "/stock/BOOK")) - monoStockBefore)
                    + ", orders change " + (Integer.parseInt(get(monolith.port, "/orders/count")) - monoOrdersBefore));
            int microStockBefore = Integer.parseInt(get(inventory.port, "/stock/BOOK"));
            int microOrdersBefore = Integer.parseInt(get(order.port, "/orders/count"));
            int microStatus = post(order.port, "/orders?sku=BOOK&quantity=5&failAfterReserve=true");
            lines.add("microservices: status " + microStatus + ", stock change " + (Integer.parseInt(get(inventory.port, "/stock/BOOK")) - microStockBefore)
                    + ", orders change " + (Integer.parseInt(get(order.port, "/orders/count")) - microOrdersBefore));
            lines.add("-- inventory service stops");
            inventory.process.destroyForcibly();
            inventory.process.waitFor();
            lines.add("order service, placing an order: status " + post(order.port, "/orders?sku=BOOK&quantity=1"));
            lines.add("order service, reading its own data: status " + status(order.port, "/orders/count"));
        } finally {
            for (Node node : nodes) {
                node.process.destroyForcibly();
            }
        }
        return lines;
    }

    private static long[] timings(int port, int count) throws Exception {
        long[] values = new long[count];
        for (int i = 0; i < count; i++) {
            long start = System.nanoTime();
            post(port, "/orders?sku=BOOK&quantity=1");
            values[i] = (System.nanoTime() - start) / 1000;
        }
        Arrays.sort(values);
        return new long[] {Math.round(values[count / 2] / 1000.0), Math.round(values[(int) (count * 0.95)] / 1000.0)};
    }

    private static long rssMb(Node node) throws Exception {
        for (String line : Files.readAllLines(Path.of("/proc/" + node.process.pid() + "/status"))) {
            if (line.startsWith("VmRSS:")) {
                return Long.parseLong(line.replaceAll("\\D+", "")) / 1024;
            }
        }
        return -1;
    }

    private static long round10(long value) {
        return Math.round(value / 10.0) * 10;
    }

    private static String roundHalf(double seconds) {
        return String.valueOf(Math.round(seconds * 2) / 2.0);
    }

    private static Node launch(List<Node> nodes, Class<?> main, String readyPath, String... extra) throws Exception {
        int port;
        try (ServerSocket socket = new ServerSocket(0)) {
            port = socket.getLocalPort();
        }
        List<String> command = new ArrayList<>(List.of(
                System.getProperty("java.home") + "/bin/java", "-Xmx128m", "-XX:+UseSerialGC",
                "-classpath", System.getProperty("java.class.path"), main.getName(),
                "--server.port=" + port, "--spring.main.banner-mode=off", "--logging.level.root=WARN"));
        command.addAll(List.of(extra));
        File logs = new File("target/logs");
        logs.mkdirs();
        Process process = new ProcessBuilder(command).redirectErrorStream(true).redirectOutput(new File(logs, main.getSimpleName() + ".log")).start();
        Node node = new Node(process, port);
        nodes.add(node);
        long deadline = System.currentTimeMillis() + 90_000;
        while (System.currentTimeMillis() < deadline) {
            try {
                if (status(port, readyPath) == 200) {
                    return node;
                }
            } catch (Exception ignored) {
                Thread.sleep(100);
            }
            Thread.sleep(100);
        }
        throw new IllegalStateException(main.getSimpleName() + " did not start, see target/logs");
    }

    private static String get(int port, String path) throws Exception {
        return HTTP.send(HttpRequest.newBuilder(URI.create("http://localhost:" + port + path)).GET().build(), HttpResponse.BodyHandlers.ofString()).body();
    }

    private static int status(int port, String path) throws Exception {
        return HTTP.send(HttpRequest.newBuilder(URI.create("http://localhost:" + port + path)).GET().build(), HttpResponse.BodyHandlers.discarding()).statusCode();
    }

    private static int post(int port, String path) throws Exception {
        return HTTP.send(HttpRequest.newBuilder(URI.create("http://localhost:" + port + path)).POST(HttpRequest.BodyPublishers.noBody()).build(), HttpResponse.BodyHandlers.discarding()).statusCode();
    }

    record Node(Process process, int port) {
    }
}

@@OUTPUT@@