The bean that was null for one endpoint

import java.lang.reflect.*;
import java.util.*;

/**
 * Solution: the bean that was null for one endpoint.
 *
 * Two defects, one root cause each, and neither is fixed by configuration.
 *
 *   Defect 1 — the constructor used an injected field. Field injection assigns
 *   fields AFTER the object exists, so every @Autowired field is null while the
 *   constructor body runs. Taking the dependency as a parameter makes the bug
 *   unwritable: a parameter cannot be null before the body it was passed to.
 *
 *   Defect 2 — ReportService and ArchiveService needed each other. Field
 *   injection satisfied that in its second pass, which is the only reason it
 *   ever worked, and the price was that neither class could be built, read or
 *   tested on its own.
 *
 * Both services were calling the other for the same underlying job: turn an id
 * into a rendered report. That job is the missing type. Extract ReportRenderer,
 * let both depend on it, and the cycle is not fixed — it is no longer
 * expressible.
 *
 * Why @Lazy was not the fix: it injects a proxy that resolves the real bean on
 * first use, so startup succeeds and the cycle survives. It converts a
 * startup-time failure into a runtime one and leaves two classes that still
 * cannot be understood separately. Same objection to
 * spring.main.allow-circular-references=true, which only silences the message.
 */
public class Solution {

    static class TemplateEngine {
        boolean warmed = false;

        int warmUp() {
            warmed = true;
            System.out.println("      templates warmed");
            return 1;
        }

        String render(String id) {
            return "<report id=" + id + ">";
        }
    }

    /** The job both services were reaching for, and nothing else. */
    static class ReportRenderer {
        private final TemplateEngine templates;
        private final int warmedCount;

        ReportRenderer(TemplateEngine templates) {
            this.templates = templates;
            // FIX 1: a parameter, so it cannot be null here.
            this.warmedCount = templates.warmUp();
        }

        String render(String id) {
            return templates.render(id);
        }

        int warmedCount() {
            return warmedCount;
        }
    }

    /** FIX 2: depends on the renderer, not on ReportService. */
    static class ArchiveService {
        private final ReportRenderer renderer;
        private final Map<String, String> stored = new LinkedHashMap<>();

        ArchiveService(ReportRenderer renderer) {
            this.renderer = renderer;
        }

        void store(String id, String body) {
            stored.put(id, body);
        }

        String restore(String id) {
            String body = stored.get(id);
            return body != null ? body : renderer.render(id);
        }
    }

    static class ReportService {
        private final ReportRenderer renderer;
        private final ArchiveService archive;

        ReportService(ReportRenderer renderer, ArchiveService archive) {
            this.renderer = renderer;
            this.archive = archive;
        }

        String publish(String id) {
            String body = renderer.render(id);
            archive.store(id, body);
            return body;
        }
    }

    /** Constructor injection: build the parameters first, or report the cycle. */
    static Object byConstructor(Class<?> type, LinkedHashSet<Class<?>> path,
                               Map<Class<?>, Object> singletons) throws Exception {
        if (singletons.containsKey(type)) return singletons.get(type);
        if (!path.add(type)) {
            StringBuilder chain = new StringBuilder();
            for (Class<?> c : path) chain.append(c.getSimpleName()).append(" → ");
            throw new IllegalStateException("circular dependency: " + chain + type.getSimpleName());
        }
        Constructor<?> ctor = type.getDeclaredConstructors()[0];
        Object[] args = new Object[ctor.getParameterCount()];
        for (int i = 0; i < args.length; i++) {
            args[i] = byConstructor(ctor.getParameterTypes()[i], path, singletons);
        }
        path.remove(type);
        ctor.setAccessible(true);
        Object bean = ctor.newInstance(args);
        singletons.put(type, bean);
        return bean;
    }

    static final Class<?>[] SERVICES = { ReportService.class, ArchiveService.class, ReportRenderer.class };

    public static void main(String[] args) {
        boolean ok = true;

        System.out.println("── startup ──");
        TemplateEngine engine = null;
        Object built = null;
        try {
            Map<Class<?>, Object> singletons = new LinkedHashMap<>();
            built = byConstructor(ReportService.class, new LinkedHashSet<>(), singletons);
            engine = (TemplateEngine) singletons.get(TemplateEngine.class);
            System.out.println("  context started");
        } catch (Throwable t) {
            System.out.println("  startup failed: " + rootCause(t));
        }
        ok &= check("the application starts and the templates are warmed",
            built != null && engine != null && engine.warmed);

        System.out.println();
        System.out.println("── restoring a report with no ReportService in existence ──");
        boolean restored = false;
        try {
            ArchiveService archive = new ArchiveService(new ReportRenderer(new TemplateEngine()));
            System.out.println("  " + archive.restore("R-1"));
            restored = true;
        } catch (Throwable t) {
            System.out.println("  " + rootCause(t));
        }
        ok &= check("ArchiveService is usable on its own", restored);

        ok &= check("every field on every service is final", allFieldsFinal(SERVICES));

        boolean declaresAndAcyclic;
        try {
            declaresAndAcyclic = declaresDependencies(SERVICES) && acyclic(SERVICES);
        } catch (IllegalStateException e) {
            System.out.println("  " + e.getMessage());
            declaresAndAcyclic = false;
        }
        ok &= check("dependencies are declared in constructors, and the graph is acyclic",
            declaresAndAcyclic);

        System.out.println();
        System.out.println(ok ? "PASS" : "FAIL");
    }

    /* ─────────────── structural assertions ─────────────── */

    static boolean allFieldsFinal(Class<?>[] types) {
        for (Class<?> t : types) {
            for (Field f : t.getDeclaredFields()) {
                if (!Modifier.isStatic(f.getModifiers()) && !Modifier.isFinal(f.getModifiers())) {
                    return false;
                }
            }
        }
        return true;
    }

    static boolean declaresDependencies(Class<?>[] types) {
        for (Class<?> t : types) {
            if (t.getDeclaredConstructors()[0].getParameterCount() == 0) return false;
        }
        return true;
    }

    static boolean acyclic(Class<?>[] types) {
        for (Class<?> t : types) walk(t, new LinkedHashSet<>());
        return true;
    }

    static void walk(Class<?> type, LinkedHashSet<Class<?>> path) {
        if (!path.add(type)) {
            StringBuilder chain = new StringBuilder();
            for (Class<?> c : path) chain.append(c.getSimpleName()).append(" → ");
            throw new IllegalStateException("circular dependency: " + chain + type.getSimpleName());
        }
        for (Class<?> p : type.getDeclaredConstructors()[0].getParameterTypes()) walk(p, path);
        path.remove(type);
    }

    static String rootCause(Throwable t) {
        while (t.getCause() != null) t = t.getCause();
        return t.getClass().getSimpleName() + ": " + t.getMessage();
    }

    static boolean check(String what, boolean passed) {
        System.out.println((passed ? "  ok    " : "  FAIL  ") + what);
        return passed;
    }
}