@Service
public class OrderService {

    // ❌ 절대 이렇게 하면 안 됨 - 인스턴스 변수 = 공유 상태
    private int orderCount = 0;

    public void createOrder() {
        orderCount++; // 스레드 A와 B가 동시에 접근하면? -> 레이스 컨디션
    }
}

@Service
public class UserContextHolder {

    // ✅ 각 스레드마다 독립된 저장공간
    private static final ThreadLocal<Long> currentUserId = new ThreadLocal<>();

    public void set(Long userId) {
        currentUserId.set(userId);  // 스레드 A가 set해도 스레드 B에는 영향 없음
    }

    public Long get() {
        return currentUserId.get();
    }

    public void clear() {
        currentUserId.remove();
    }
}

// 도메인 객체 - Spring이 관리하지 않음 (싱글톤 아님)
Order order = new Order(1L, "치킨", 20000);

// Spring 빈 - 싱글톤으로 관리됨
@Service
public class OrderService { ... }

@Service
public class ReportService {

    public String generateReport(List<Item> items) {
        // ✅ 이 sb는 이 스레드의 실행 흐름에서만 사용됨
        // 다른 스레드가 접근할 방법이 없음
        StringBuilder sb = new StringBuilder();
        for (Item item : items) {
            sb.append(item.getName()).append("\n");
        }
        return sb.toString();
    }
}

┌──────────────────────────────────────────────┐
│                     Heap                      │
│                                               │
│   ┌────────────────┐                          │
│   │  OrderService   │  ← 싱글톤, 딱 하나       │
│   │  (인스턴스)      │                          │
│   └────────────────┘                          │
│                                               │
│   ┌──────┐  ┌──────┐  ┌──────┐               │
│   │DTO-1 │  │DTO-2 │  │DTO-3 │ ← 요청마다 생성 │
│   └──────┘  └──────┘  └──────┘               │
└──────────────────────────────────────────────┘

┌───────────────┐    ┌───────────────┐
│   Thread A    │    │   Thread B    │
│   Stack       │    │   Stack       │
│ ┌───────────┐ │    │ ┌───────────┐ │
│ │createOrder│ │    │ │createOrder│ │
│ │price=1000 │ │    │ │price=2000 │ │
│ │dto (ref)  │ │    │ │dto (ref)  │ │
│ └───────────┘ │    │ └───────────┘ │
└───────────────┘    └───────────────┘

@Service
public class OrderService {

    public OrderResponse createOrder(OrderRequest request) {
        // price는 스레드 A의 스택 프레임에서만 사용 -> 안전
        int price = request.getPrice();

        // dto 객체는 힙에 생성되지만, 현재 스레드의 참조로만 다루면 안전
        OrderDto dto = new OrderDto(price);

        return new OrderResponse(dto);
    }
}

HTTP 요청 도착
  → Tomcat 스레드 풀에서 java.lang.Thread 하나 할당
  → 이 Thread가 Filter → DispatcherServlet → Controller → Service → Repository 호출
  → 모두 이 Thread의 콜 스택 위에서 실행
  → 응답 반환 후 Thread는 풀에 반납

@Entity
public class Order {
    @Id @GeneratedValue
    private Long id;
    private String status;  // 인스턴스 변수지만, 싱글톤이 아니므로 OK

    public void cancel() {
        this.status = "CANCELLED";  // 이 인스턴스의 상태 변경
    }
}

@Controller   // 싱글톤 - 요청을 라우팅하는 "행위"
@Service      // 싱글톤 - 비즈니스 로직을 수행하는 "행위"
@Repository   // 싱글톤 - 데이터 접근을 수행하는 "행위"
@Component    // 싱글톤 - 기타 인프라 로직

// DTO - 요청마다 다른 데이터를 담아야 함
OrderRequest request1 = new OrderRequest("치킨", 20000);  // 스레드 A의 요청
OrderRequest request2 = new OrderRequest("피자", 30000);  // 스레드 B의 요청

// Entity - 각각 다른 행(row)을 표현
Order order1 = new Order(1L, "치킨", 20000);
Order order2 = new Order(2L, "피자", 30000);

// ❌ 절대로 이러면 안 됨
@Component  // 싱글톤으로 등록되면...
public class OrderRequest {
    private String itemName;
    private int price;

    // 스레드 A: setItemName("치킨")
    // 스레드 B: setItemName("피자")
    // 스레드 A: getItemName() -> "피자" ???  -> 치킨 주문했는데 피자가 나옴
}

public OrderResponse createOrder(OrderRequest request) {
    Order order = Order.create(request);        // 생성
    orderRepository.save(order);                // 저장
    return OrderResponse.from(order);           // 응답 DTO 생성
}   // 메서드 종료 후 더 이상 참조되지 않으면 GC 대상

// ✅ 불변 DTO - record 사용 (Java 16+)
public record OrderRequest(String itemName, int price) {}

// ✅ 불변 DTO - 클래스 사용
public class OrderResponse {
    private final Long orderId;
    private final String status;

    public OrderResponse(Long orderId, String status) {
        this.orderId = orderId;
        this.status = status;
    }

    // getter만 제공, setter 없음
}

@Configuration
public class AppConfig {

    @Bean
    public MemberRepository memberRepository() {
        return new MemoryMemberRepository();
    }

    @Bean
    public MemberService memberService() {
        return new MemberServiceImpl(memberRepository()); // memberRepository() 호출
    }

    @Bean
    public OrderService orderService() {
        return new OrderServiceImpl(memberRepository());  // memberRepository() 또 호출
    }
}

memberRepository() 호출 시:
  if (스프링 컨테이너에 memberRepository 빈이 이미 있으면)
      return 기존 빈;       ← 싱글톤 보장
  else
      새로 생성 → 컨테이너에 등록 → return;

// ⚠️ @Configuration 없이 @Bean만 사용
@Component  // @Configuration이 아님
public class AppConfig {

    @Bean
    public MemberRepository memberRepository() {
        return new MemoryMemberRepository();
    }

    @Bean
    public MemberService memberService() {
        // CGLIB 프록시가 없으므로 순수 자바 메서드 호출
        // -> 여기서 memberRepository()를 직접 호출하면 새 객체가 생성될 수 있음
        return new MemberServiceImpl(memberRepository());
    }
}

                        Spring 컨테이너 (Heap)
                    ┌─────────────────────────────┐
    싱글톤 빈        │  Controller ─── Service ─── Repository  │
    (행위 중심,      │     (무상태, 하나만 존재, 모든 스레드 공유) │
     @Component 계열) │                                         │
                    └─────────────────────────────┘
                            ↑ 공유 사용 ↑
                    ┌───────┴───────────┴───────┐
                    │                           │
            ┌───────────────┐           ┌───────────────┐
            │   Thread A    │           │   Thread B    │
            │   (요청 #1)    │           │   (요청 #2)    │
            │               │           │               │
            │  지역변수:     │           │  지역변수:     │
            │  - DTO-A      │           │  - DTO-B      │
            │  - Entity-A   │           │  - Entity-B   │
            │  (이 스레드만   │           │  (이 스레드만   │
            │   사용, GC 대상)│           │   사용, GC 대상)│
            └───────────────┘           └───────────────┘
                  데이터 객체                데이터 객체
                  (상태 중심,               (상태 중심,
                   매번 new 생성)            매번 new 생성)