프로토타입과 요청 스코프

package example.scope;

import jakarta.annotation.PreDestroy;
import java.util.UUID;

public final class ExportJob implements AutoCloseable {
    private final UUID id = UUID.randomUUID();
    private int writtenPosts;
    private boolean closed;

    public UUID id() {
        return id;
    }

    public int writtenPosts() {
        return writtenPosts;
    }

    public boolean isClosed() {
        return closed;
    }

    public void write(BatchExporter.PostBatch batch) {
        if (closed) {
            throw new IllegalStateException("export job is closed");
        }
        writtenPosts += batch.titles().size();
    }

    @PreDestroy
    @Override
    public void close() {
        closed = true;
    }
}

package example.scope;

import java.util.List;
import java.util.Objects;
import java.util.UUID;

public final class BatchExporter {
    private final ExportJobFactory jobs;

    public BatchExporter(ExportJobFactory jobs) {
        this.jobs = Objects.requireNonNull(jobs);
    }

    public UUID export(PostBatch batch) {
        try (var job = jobs.open()) {
            job.write(batch);
            return job.id();
        }
    }

    @FunctionalInterface
    public interface ExportJobFactory {
        ExportJob open();
    }

    public record PostBatch(List<String> titles) {
        public PostBatch {
            titles = List.copyOf(Objects.requireNonNull(titles));
        }
    }
}

package example.scope;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

class PrototypeScopeTest {
    @Test
    void directInjectionReusesOnePrototype() {
        try (var context = new AnnotationConfigApplicationContext(
                DirectInjectionConfig.class)) {
            var exporter = context.getBean(FixedExporter.class);

            assertEquals(exporter.start(), exporter.start());
            assertNotSame(
                    context.getBean(ExportJob.class),
                    context.getBean(ExportJob.class));
        }
    }

    @Test
    void providerLookupCreatesAndClosesOneJobPerExport() {
        try (var context = new AnnotationConfigApplicationContext(
                ProviderConfig.class)) {
            var exporter = context.getBean(BatchExporter.class);
            var batch = new BatchExporter.PostBatch(List.of("first"));

            UUID first = exporter.export(batch);
            UUID second = exporter.export(batch);

            assertNotEquals(first, second);
            var created = context.getBean(ProviderConfig.class).createdJobs();
            assertEquals(2, created.size());
            assertTrue(created.stream().allMatch(ExportJob::isClosed));
            assertTrue(created.stream()
                    .allMatch(job -> job.writtenPosts() == 1));
        }
    }

    @Test
    void contextShutdownDoesNotCloseAPrototype() {
        var context = new AnnotationConfigApplicationContext(
                PrototypeOnlyConfig.class);
        var job = context.getBean(ExportJob.class);

        context.close();

        assertFalse(job.isClosed());
        job.close();
        assertTrue(job.isClosed());
    }

    @Configuration(proxyBeanMethods = false)
    static class DirectInjectionConfig {
        @Bean
        @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
        ExportJob exportJob() {
            return new ExportJob();
        }

        @Bean
        FixedExporter fixedExporter(ExportJob job) {
            return new FixedExporter(job);
        }
    }

    @Configuration(proxyBeanMethods = false)
    static class ProviderConfig {
        private final List<ExportJob> created = new ArrayList<>();

        @Bean
        @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
        ExportJob exportJob() {
            var job = new ExportJob();
            created.add(job);
            return job;
        }

        @Bean
        BatchExporter batchExporter(ObjectProvider<ExportJob> jobs) {
            return new BatchExporter(jobs::getObject);
        }

        List<ExportJob> createdJobs() {
            return List.copyOf(created);
        }
    }

    @Configuration(proxyBeanMethods = false)
    static class PrototypeOnlyConfig {
        @Bean
        @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
        ExportJob exportJob() {
            return new ExportJob();
        }
    }

    static final class FixedExporter {
        private final ExportJob job;

        FixedExporter(ExportJob job) {
            this.job = job;
        }

        UUID start() {
            return job.id();
        }
    }
}

package example.scope;

import java.util.UUID;

public class RequestTrace {
    private final String id = UUID.randomUUID().toString();

    public String id() {
        return id;
    }
}

package example.scope;

import java.util.Objects;

public final class RequestAudit {
    private final RequestTrace trace;

    public RequestAudit(RequestTrace trace) {
        this.trace = Objects.requireNonNull(trace);
    }

    public String currentTraceId() {
        return trace.id();
    }
}

package example.scope;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.annotation.RequestScope;

@Configuration(proxyBeanMethods = false)
public class RequestTraceConfig {
    @Bean
    @RequestScope
    RequestTrace requestTrace() {
        return new RequestTrace();
    }

    @Bean
    RequestAudit requestAudit(RequestTrace trace) {
        return new RequestAudit(trace);
    }
}

package example.scope;

import java.time.LocalDate;
import java.util.Objects;

public record ExportPostsCommand(
        long memberId,
        String requestTraceId,
        LocalDate from,
        LocalDate to) {
    public ExportPostsCommand {
        if (memberId <= 0) {
            throw new IllegalArgumentException("memberId must be positive");
        }
        requestTraceId = Objects.requireNonNull(requestTraceId);
        from = Objects.requireNonNull(from);
        to = Objects.requireNonNull(to);
        if (to.isBefore(from)) {
            throw new IllegalArgumentException("to must not precede from");
        }
    }
}

package example.scope;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.time.LocalDate;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Supplier;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.support.ScopeNotActiveException;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;

class RequestScopeTest {
    @AfterEach
    void clearRequestAttributes() {
        RequestContextHolder.resetRequestAttributes();
    }

    @Test
    void oneTargetPerRequestAndANewTargetForTheNextRequest() {
        try (var context = webContext()) {
            var audit = context.getBean(RequestAudit.class);

            String first = inRequest(() -> {
                String id = audit.currentTraceId();
                assertEquals(id, audit.currentTraceId());
                return id;
            });
            String second = inRequest(audit::currentTraceId);

            assertNotEquals(first, second);
        }
    }

    @Test
    void executorWithoutRequestAttributesFailsOnItsOwnThread()
            throws Exception {
        try (var context = webContext()) {
            var audit = context.getBean(RequestAudit.class);
            Thread requestThread = Thread.currentThread();
            var workerThread = new AtomicReference<Thread>();
            ExecutorService executor = Executors.newSingleThreadExecutor();
            var attributes = requestAttributes();
            RequestContextHolder.setRequestAttributes(attributes);
            try {
                String requestId = audit.currentTraceId();
                assertEquals(requestId, audit.currentTraceId());

                var future = executor.submit(() -> {
                    workerThread.set(Thread.currentThread());
                    return audit.currentTraceId();
                });
                var failure = assertThrows(
                        java.util.concurrent.ExecutionException.class,
                        future::get);

                assertTrue(workerThread.get() != null);
                assertNotSame(requestThread, workerThread.get());
                assertInstanceOf(
                        ScopeNotActiveException.class,
                        failure.getCause());
                assertInstanceOf(
                        IllegalStateException.class,
                        failure.getCause().getCause());
            } finally {
                try {
                    completeRequest(attributes);
                } finally {
                    stop(executor);
                }
            }
        }
    }

    @Test
    void immutableTraceValueCrossesTheBackgroundBoundary()
            throws Exception {
        try (var context = webContext()) {
            var audit = context.getBean(RequestAudit.class);
            String traceId = inRequest(audit::currentTraceId);
            var command = new ExportPostsCommand(
                    7L,
                    traceId,
                    LocalDate.of(2026, 8, 1),
                    LocalDate.of(2026, 8, 31));
            Thread requestThread = Thread.currentThread();
            var workerThread = new AtomicReference<Thread>();
            var workerRequestAttributesPresent =
                    new AtomicReference<Boolean>();
            ExecutorService executor = Executors.newSingleThreadExecutor();
            try {
                var future = executor.submit(() -> {
                    workerThread.set(Thread.currentThread());
                    workerRequestAttributesPresent.set(
                            RequestContextHolder.getRequestAttributes() != null);
                    return consume(command);
                });

                assertEquals(command.requestTraceId(), future.get());
                assertTrue(workerThread.get() != null);
                assertNotSame(requestThread, workerThread.get());
                assertEquals(
                        Boolean.FALSE,
                        workerRequestAttributesPresent.get());
            } finally {
                stop(executor);
            }
        }
    }

    private static AnnotationConfigWebApplicationContext webContext() {
        var context = new AnnotationConfigWebApplicationContext();
        context.register(RequestTraceConfig.class);
        context.refresh();
        return context;
    }

    private static <T> T inRequest(Supplier<T> work) {
        var attributes = requestAttributes();
        RequestContextHolder.setRequestAttributes(attributes);
        try {
            return work.get();
        } finally {
            completeRequest(attributes);
        }
    }

    private static ServletRequestAttributes requestAttributes() {
        return new ServletRequestAttributes(new MockHttpServletRequest());
    }

    private static void completeRequest(
            ServletRequestAttributes attributes) {
        try {
            attributes.requestCompleted();
        } finally {
            RequestContextHolder.resetRequestAttributes();
        }
    }

    private static void stop(ExecutorService executor)
            throws InterruptedException {
        executor.shutdownNow();
        assertTrue(executor.awaitTermination(5, TimeUnit.SECONDS));
    }

    private static String consume(ExportPostsCommand command) {
        return command.requestTraceId();
    }
}