애플리케이션 시작
  → @ComponentScan이 지정 패키지 하위를 전부 탐색
  → 각 클래스를 리플렉션으로 읽음
  → @Service/@Repository 발견 → "Bean으로 등록"
  → @Autowired 발견 → "등록된 Bean 중 타입 맞는 것을 주입"
  → @Transactional 발견 → "CGLIB 프록시로 감싸기"

// Spring 내부에서 실제로 일어나는 일 (단순화)
for (Class<?> clazz : scannedClasses) {
    if (clazz.isAnnotationPresent(Component.class)) {
        Object instance = clazz.getDeclaredConstructor().newInstance();
        beanContainer.register(clazz, instance);
    }
}

public class OrderService {
    // 직접 생성 — 강한 결합
    private PaymentService paymentService = new PaymentService();
}

전통적: 개발자 → 객체 생성 → 의존성 연결
IoC:    Spring Container → 객체 생성 → 의존성 연결 → 개발자에게 제공

@Service
public class OrderService {
    private final PaymentService paymentService;

    @Autowired  // 생성자가 1개면 생략 가능
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

@Service
public class OrderService {
    @Autowired
    private PaymentService paymentService; // 테스트 어려움
}

@Component   // 일반 컴포넌트
@Service     // 서비스 레이어
@Repository  // 데이터 접근 레이어 (예외 변환 기능 추가)
@Controller  // Spring MVC 컨트롤러

@Configuration
public class AppConfig {
    @Bean
    public PaymentService paymentService() {
        return new KakaopayService(); // 구현체를 여기서 결정
    }
}

// @Primary — 기본 Bean 지정
@Component
@Primary
public class KakaopayService implements PaymentService { ... }

// @Qualifier — 이름으로 명시적 선택
@Autowired
@Qualifier("naverpay")
private PaymentService paymentService;

Container 시작
  → Bean 인스턴스 생성
  → 의존성 주입
  → @PostConstruct 실행  (초기화 콜백)
  → Bean 사용
  → @PreDestroy 실행     (소멸 콜백)
  → Container 종료

@Component
public class DatabaseConnector {

    @PostConstruct
    public void init() {
        // DB 커넥션 풀 초기화
    }

    @PreDestroy
    public void close() {
        // 커넥션 정리
    }
}

HTTP 요청 도착
  → Tomcat 스레드 풀에서 스레드 1개 꺼냄
  → 해당 스레드가 요청 처리 전체를 담당
     (Filter → DispatcherServlet → Controller → Service → Repository → DB)
  → 응답 완료 후 스레드를 풀에 반납

# application.yml — Tomcat 스레드 풀 설정
server:
  tomcat:
    threads:
      max: 200        # 최대 스레드 수 (기본값)
      min-spare: 10   # 최소 유지 스레드 수 (기본값)

[요청 A] → 스레드-1 → UserController.getUser(1L)
[요청 B] → 스레드-2 → UserController.getUser(2L)
[요청 C] → 스레드-3 → OrderController.create()

@Service  // Singleton — 인스턴스 1개, 스레드 수백 개가 공유
public class UserService {

    private final UserRepository userRepository; // 의존성 주입 — 불변, 안전

    // ⚠️ 위험: 인스턴스 변수에 상태 저장
    private User lastAccessedUser; // 스레드-A가 저장 → 스레드-B가 덮어씀

    public User getUser(Long id) {
        // ✅ 안전: 지역 변수는 스택에 생성 (스레드별 독립)
        User user = userRepository.findById(id).orElseThrow();
        return user;
    }
}

스레드-1 스택: getUser(1L) → user = User{id=1}
스레드-2 스택: getUser(2L) → user = User{id=2}  ← 완전히 별개의 메모리

힙 메모리: UserService 인스턴스 { lastAccessedUser = ??? }
  스레드-1: lastAccessedUser = User{id=1} 저장
  스레드-2: lastAccessedUser = User{id=2} 덮어씀 ← 스레드-1은 User{id=2}를 읽게 됨

@Service
public class OrderService {
    private final OrderRepository orderRepository; // 의존성만 보유 (불변)

    // 모든 상태는 파라미터로 받고, 처리 결과는 반환값으로만
    public Order createOrder(CreateOrderRequest request, Long userId) {
        Order order = Order.of(request, userId);
        return orderRepository.save(order);
    }
}

@Service
public class RequestCounterService {
    // ⚠️ 위험: count++는 원자적이지 않음
    private int count = 0;

    // ✅ 안전: AtomicInteger는 내부적으로 CAS(Compare-And-Swap) 연산 사용
    private final AtomicInteger safeCount = new AtomicInteger(0);

    public void record() {
        safeCount.incrementAndGet(); // 원자적 연산
    }
}

@Component
public class ApiConfig {
    private final String apiKey;
    private final int timeout;

    public ApiConfig(@Value("${api.key}") String apiKey,
                     @Value("${api.timeout}") int timeout) {
        this.apiKey = apiKey;
        this.timeout = timeout;
    }
}

ThreadLocal<User> currentUser = new ThreadLocal<>();

// 스레드-1에서 저장
currentUser.set(User{id=1});

// 스레드-2에서 조회
currentUser.get(); // → null (스레드-2는 스레드-1의 데이터를 볼 수 없음)

@Component
@Scope("prototype")
public class ShoppingCart {
    private final List<Item> items = new ArrayList<>();

    public void addItem(Item item) { items.add(item); }
}

@Service  // Singleton
public class OrderService {
    @Autowired
    private ShoppingCart cart; // ⚠️ 항상 같은 cart 인스턴스 — 모든 요청이 공유
}

@Service
public class OrderService {
    @Autowired
    private ObjectProvider<ShoppingCart> cartProvider;

    public void checkout() {
        ShoppingCart cart = cartProvider.getObject(); // 호출마다 새 인스턴스 생성
        // cart는 이 메서드 범위 내에서만 사용
    }
}

// AOP 없이 — 모든 메서드마다 반복
public Order createOrder(...) {
    log.info("createOrder 시작");   // 로깅
    checkAuth();                     // 인증
    startTransaction();              // 트랜잭션

    Order order = doCreateOrder();   // 실제 비즈니스 로직

    commitTransaction();
    log.info("createOrder 완료");
    return order;
}

호출자 → [프록시] → 실제 Bean
             ↑
        Advice(부가 로직) 실행

@Aspect
@Component
public class LoggingAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();

        Object result = pjp.proceed(); // 실제 메서드 실행

        log.info("{} — {}ms",
            pjp.getSignature().getName(),
            System.currentTimeMillis() - start);
        return result;
    }
}

@Service
public class OrderService {
    @Transactional
    public Order createOrder(...) {
        // 트랜잭션 begin → 프록시가 처리
        Order order = orderRepository.save(...);
        return order;
        // 트랜잭션 commit → 프록시가 처리
    }
}

@Service
public class OrderService {

    public void process() {
        createOrder(); // this.createOrder() — 프록시를 거치지 않음 → 트랜잭션 미적용!
    }

    @Transactional
    public void createOrder() { ... }
}