ServiceLoader.load 没报错，为什么真正使用插件时才失败？

import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Comparator;
import java.util.ConcurrentModificationException;
import java.util.ServiceConfigurationError;
import java.util.ServiceLoader;

/** Single source: the program creates and removes its own META-INF/services files. */
public class ServiceLoaderLifecycleDemo {
    private static int checks;
    public interface Greeting { String hello(); }
    public interface BrokenService { }

    public static final class Good implements Greeting, AutoCloseable {
        static int created;
        static int closed;
        private final int id;
        private boolean isClosed;
        public Good() { id = ++created; }
        public String hello() {
            if (isClosed) throw new IllegalStateException("closed");
            return "hello-" + id;
        }
        public void close() { if (!isClosed) { isClosed = true; closed++; } }
    }

    public static final class Broken implements BrokenService {
        static int attempts;
        public Broken() { attempts++; throw new IllegalStateException("provider constructor failed"); }
    }

    private static void descriptor(Path root, Class<?> service, Class<?> provider) throws IOException {
        Path directory = root.resolve("META-INF").resolve("services");
        Files.createDirectories(directory);
        Files.writeString(directory.resolve(service.getName()), provider.getName() + "\n", StandardCharsets.UTF_8);
    }

    private static void check(boolean condition, String message) {
        if (!condition) throw new AssertionError(message);
        checks++;
    }

    private static void removeOwnedDirectory(Path directory) throws IOException {
        try (var paths = Files.walk(directory)) {
            for (Path path : paths.sorted(Comparator.reverseOrder()).toList()) Files.delete(path);
        }
    }

    public static void main(String[] args) throws Exception {
        Path directory = Files.createTempDirectory("qinghuan-services-");
        Good first = null, second = null;
        try {
            descriptor(directory, Greeting.class, Good.class);
            descriptor(directory, BrokenService.class, Broken.class);
            // Provider classes stay in the parent loader; this loader supplies only local metadata.
            try (URLClassLoader resources = new URLClassLoader(new URL[]{directory.toUri().toURL()},
                    ServiceLoaderLifecycleDemo.class.getClassLoader())) {
                ServiceLoader<Greeting> loader = ServiceLoader.load(Greeting.class, resources);
                check(Good.created == 0, "load must not construct the provider yet");
                var oldIterator = loader.iterator();
                check(Good.created == 0, "creating an iterator does not construct provider");
                first = (Good) oldIterator.next();
                check(Good.created == 1 && first.hello().equals("hello-1"), "first demand creates provider");
                check(loader.iterator().next() == first && Good.created == 1, "second iteration reuses cached instance");
                System.out.println("after_load=0; after_first_next=1; second_iterator_same_instance=true");

                loader.reload();
                check(Good.created == 1, "reload clears cache without immediate construction");
                boolean stale = false;
                try { oldIterator.hasNext(); }
                catch (ConcurrentModificationException expected) { stale = true; }
                check(stale, "discard iterators made before reload");
                second = (Good) loader.iterator().next();
                check(second != first && Good.created == 2, "new iteration constructs new instance");
                check(first.hello().equals("hello-1") && Good.closed == 0, "reload did not close or revoke old instance");
                System.out.println("after_reload_before_next=1; after_new_next=2; old_iterator=ConcurrentModificationException");
                System.out.println("old_instance_still_usable=true; automatically_closed=0");
                first.close(); second.close();
                check(Good.closed == 2, "caller explicitly closes owned providers");

                ServiceLoader<BrokenService> broken = ServiceLoader.load(BrokenService.class, resources);
                check(Broken.attempts == 0, "broken provider not constructed by load");
                boolean causePreserved = false;
                try { broken.iterator().next(); }
                catch (ServiceConfigurationError expected) {
                    causePreserved = expected.getCause() instanceof IllegalStateException
                            && expected.getCause().getMessage().equals("provider constructor failed");
                }
                check(causePreserved && Broken.attempts == 1, "iteration exposes provider construction failure");
                System.out.println("broken: load_returned=true; next=ServiceConfigurationError; cause=IllegalStateException");
            }
        } finally {
            if (first != null) first.close();
            if (second != null) second.close();
            removeOwnedDirectory(directory);
        }
        check(!Files.exists(directory), "temporary descriptors removed");
        System.out.println("PASS checks=" + checks + "; providers_closed=2; temporary_files_cleaned=true");
    }
}