Maven 多模块：聚合、继承与版本管理

import java.util.*;
public class Main {
    record Task(long duration, List<String> deps) {}
    static long earliest(Map<String,Task> tasks) {
        Map<String,Integer> left = new HashMap<>();
        Map<String,List<String>> next = new HashMap<>();
        Map<String,Long> start = new HashMap<>();
        for (String name : tasks.keySet()) next.put(name,new ArrayList<>());
        for (var entry : tasks.entrySet()) {
            Task t = entry.getValue();
            if (t.duration() < 0) throw new IllegalArgumentException("duration");
            Set<String> seen = new HashSet<>();
            for (String d : t.deps()) {
                if (!tasks.containsKey(d) || !seen.add(d))
                    throw new IllegalArgumentException("dependency");
                // 反向邻接表用于通知所有等待当前模块的使用者。
                next.get(d).add(entry.getKey());
            }
            left.put(entry.getKey(),seen.size());
            start.put(entry.getKey(),0L);
        }
        Deque<String> ready = new ArrayDeque<>();
        for (String n : tasks.keySet()) if (left.get(n) == 0) ready.add(n);
        int done = 0;
        long answer = 0;
        while (!ready.isEmpty()) {
            String n = ready.remove();
            long finish = Math.addExact(start.get(n),tasks.get(n).duration());
            done++;
            answer = Math.max(answer,finish);
            for (String child : next.get(n)) {
                // 需等待全部依赖，开始时间取完成时间的最大值。
                start.put(child,Math.max(start.get(child),finish));
                int remaining = left.merge(child,-1,Integer::sum);
                if (remaining == 0) ready.add(child);
            }
        }
        // 未处理节点代表环，不返回不完整任务的局部时间。
        if (done != tasks.size()) throw new IllegalArgumentException("cycle");
        return answer;
    }
    static Task t(long duration, String... deps) { return new Task(duration,List.of(deps)); }
    static void eq(long expected, long actual) {
        if (expected != actual) throw new AssertionError(actual);
    }
    static void reject(Runnable r) {
        try { r.run(); throw new AssertionError("accepted"); }
        catch (IllegalArgumentException expected) {}
    }
    public static void main(String[] args) {
        eq(0,earliest(Map.of()));
        eq(6,earliest(Map.of("common",t(2),"service",t(3,"common"),"app",t(1,"service"))));
        eq(7,earliest(Map.of("a",t(3),"b",t(2),"c",t(4,"a","b"))));
        eq(4,earliest(Map.of("a",t(0),"b",t(4,"a"))));
        reject(() -> earliest(Map.of("a",t(1,"b"))));
        reject(() -> earliest(Map.of("a",t(1,"b"),"b",t(1,"a"))));
        try {
            earliest(Map.of("a",t(Long.MAX_VALUE),"b",t(1,"a")));
            throw new AssertionError("overflow accepted");
        } catch (ArithmeticException expected) {}
        System.out.println("PASS 7 reactor scheduling tests");
    }
}