@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 Bean - シングルトンで管理される
@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   │  ← シングルトン、1つだけ  │
│   │  （インスタンス）  │                          │
│   └────────────────┘                          │
│                                               │
│   ┌──────┐  ┌──────┐  ┌──────┐               │
│   │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を1つ割り当て
  → この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 (SpringコンテナにmemberRepository Beanがすでにあれば)
      return 既存のBean;       ← シングルトン保証
  else
      新たに生成 → コンテナに登録 → return;

// ⚠️ @Configurationなしで@Beanだけを使用
@Component  // @Configurationではない
public class AppConfig {

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

    @Bean
    public MemberService memberService() {
        // CGLIBプロキシがないので純粋なJavaメソッド呼び出し
        // -> ここでmemberRepository()を直接呼ぶと新しいオブジェクトが生成される可能性がある
        return new MemberServiceImpl(memberRepository());
    }
}

                        Springコンテナ（Heap）
                    ┌─────────────────────────────┐
    シングルトン Bean  │  Controller ─── Service ─── Repository  │
    （振る舞い中心、   │     （ステートレス、1つだけ存在、全スレッド共有）│
     @Component系）  │                                         │
                    └─────────────────────────────┘
                            ↑ 共有使用 ↑
                    ┌───────┴───────────┴───────┐
                    │                           │
            ┌───────────────┐           ┌───────────────┐
            │   Thread A    │           │   Thread B    │
            │   （リクエスト#1）│           │   （リクエスト#2）│
            │               │           │               │
            │  ローカル変数:  │           │  ローカル変数:  │
            │  - DTO-A      │           │  - DTO-B      │
            │  - Entity-A   │           │  - Entity-B   │
            │  （このスレッドのみ│           │  （このスレッドのみ│
            │   使用、GC対象） │           │   使用、GC対象） │
            └───────────────┘           └───────────────┘
                  データオブジェクト            データオブジェクト
                  （状態中心、               （状態中心、
                   毎回new生成）              毎回new生成）