Spring Framework

Spring Bean이란?

• Spring IoC 컨테이너에 의해 관리되는 객체

• 컨테이너가 Bean의 생명주기(생성, 초기화, 소멸)를 담당

• 애플리케이션의 핵심 구성 요소들을 Spring이 관리하는 형태

• 내부 클래스 파일은 @Component, @Service, @Repository, @Controller 등으로 등록하고

  외부 라이브러리의 경우 @Configuration의 @Bean 메서드로 등록

객체를 Bean으로 관리하는 이유

1. 객체 생명주기 자동 관리

   @Component
   public class DatabaseConnection {
   
       @PostConstruct
       public void init() {
           // 초기화 로직 (컨테이너가 자동 호출)
       }
   
       
       @PreDestroy
       public void cleanup() {
           // 정리 로직 (컨테이너가 자동 호출)
       }
   }
   

   • 개발자가 직접 객체를 생성하고 소멸시킬 필요가 없다
   • 애플리케이션 시작/종료 시 자동으로 초기화/정리 작업 수행
   
   
   

2. 의존성 주입 (Dependency Injection, DI)

   @Service
   public class UserService {
       private final UserRepository userRepository;
       
       public UserService(UserRepository userRepository) {
           this.userRepository = userRepository;
       }
   }
   

   • 객체 간의 의존 관계를 Spring이 자동으로 설정
     • Spring이 자동 주입
   • 결합도 감소, 테스트 용이성 향상
   
   
   

3. 싱글톤 패턴 자동 적용

   @Component
   public class ConfigurationManager {
       // Spring이 기본적으로 싱글톤으로 관리
       // 애플리케이션 전체에서 하나의 인스턴스만 존재
   }
   

   • 기본적으로 싱글톤 스코프로 관리되어 메모리 효율성 제공
   • 여러 곳에서 동일한 인스턴스 사용 보장
   
   
   

4. AOP (Aspect-Oriented Programming) 적용

   @Service
   @Transactional
   public class OrderService {
       public void processOrder(Order order) {
           // 비즈니스 로직만 작성
           // 트랜잭션 시작/커밋/롤백은 Spring이 자동 처리
       }
   }
   

   • Bean으로 관리되는 객체에만 AOP 적용 가능
   • @Transactional ⇒ Spring이 트랜잭션 프록시 생성
     • 트랜잭션 시작/커밋/롤백은 Spring이 자동 처리
     • 트랜잭션, 보안, 로깅 등을 투명하게 적용
   
   
   

5. 프록시를 통한 기능 확장

   @Component
   public class CacheableService {
       @Cacheable("users")
       public User findUser(Long id) {
           // 실제 조회 로직
           return userRepository.findById(id);
       }
   }
   

   • @Cacheable("users") ⇒ Spring이 캐싱 프록시 생성

Bean Scope와 Lifecycle

• 다양한 Bean Scope 지원

  @Component
  @Scope("singleton")  *// 기본값, 애플리케이션당 하나*
  public class SingletonBean { }
  
  @Component
  @Scope("prototype")  *// 요청할 때마다 새 인스턴스*
  public class PrototypeBean { }
  
  @Component
  @Scope("request")    *// HTTP 요청당 하나 (웹 환경)*
  public class RequestScopedBean { }
  

  • @Scope("singleton")
    • default 값으로 생략 시 기본이 싱글톤 스코프이다.
  • 이러한 스코프에 따라 생명주기가 달라진다.

• Bean 생명주기 콜백

  @Component
  public class LifecycleBean {
      *// 1. 생성자 호출*
      public LifecycleBean() {
          System.out.println("1. 생성자 호출");
      }
      
      *// 2. 의존성 주입 완료 후*
      @PostConstruct
      public void init() {
          System.out.println("2. 초기화 메서드 호출");
      }
      
      *// 3. 컨테이너 종료 시 (애플리케이션 종료 시)*
      @PreDestroy
      public void destroy() {
          System.out.println("3. 소멸 메서드 호출");
      }
  }
  

  • @Component이므로 기본이 싱글톤 스코프이다.
    • 이 경우 생성자, init(), destroy() 딱 1번만 실행한다.
    1. 애플리케이션 시작 시, 생성자가 호출되고
    2. 이후 의존성 주입 완료 후, 초기화 메서드가 호출된다.
    3. 애플리케이션 실행
    4. 애플리케이션 종료 직전 destroy()가 실행된다.
    5. 애플리케이션 종료
  • 콜백이란, Spring이 특정 시점에 자동으로 호출해주는 메서드

Bean 관리의 실무적 이점

• 설정의 중앙화

  @Configuration
  public class AppConfig {
      @Bean
      @Profile("dev")
      public DataSource devDataSource() {
          return new H2DataSource();
      }
      
      @Bean
      @Profile("prod")
      public DataSource prodDataSource() {
          return new PostgreSQLDataSource();
      }
  }
  

  • 환경별 설정을 중앙에서 관리
  • 프로파일에 따른 다른 Bean 주입 가능

• 테스트 지원 (중요!)

  @Service
  public class UserService {
      private final UserRepository userRepository;
      
      public UserService(UserRepository userRepository) {
          this.userRepository = userRepository;
      }
      
      public User createUser(String name) {
          return userRepository.save(new User(name));
      }
  }
  
  
  
  @SpringBootTest
  class UserServiceTest {
  
      @MockBean
      private UserRepository userRepository;  // Mock Bean
      
      @Autowired
      private UserService userService;  
      
      @Test
      void testCreateUser() {
          when(userRepository.save(any())).thenReturn(savedUser);
          // 테스트 수행
      }
  }
  

  • 예를 들어, Bean으로 관리되는 Service를 테스트하는 경우, 테스트 시 쉽게 Mock Bean으로 쉽게 교체할 수 있다.
  • 즉, @MockBean을 설정만 하면 @Autowired 시 Mock Repository가 주입된 UserService 객체가 들어온다.

• 모니터링과 관리

  @Component
  public class HealthChecker {
      @EventListener
      public void handleContextRefresh(ContextRefreshedEvent event) {
          System.out.println("애플리케이션 컨텍스트 초기화 완료");
      }
  }
  

  • Spring Boot Actuator를 통한 Bean 정보 조회
  • 애플리케이션 상태 모니터링

Bean으로 관리하지 않는 객체들

• 일반적인 데이터 객체 (ex. DTO, Entity)

  @Entity
  public class User {
      private String email;
  

  • Bean으로 관리하지 않음

• Utility 클래스의 static 메서드

  public class StringUtils {
      public static boolean isEmpty(String str) {
          return str == null || str.isEmpty();
      }
  }
  

  • Bean으로 관리할 필요가 없다.

의존성 주입(Dependency Injection)이란?

• 객체가 필요로 하는 의존성(다른 객체)을 외부에서 주입 받는 디자인 패턴
• 객체가 직접 의존성을 생성하는 대신, 외부(컨테이너)에서 생성된 객체를 주입 받는 것
• 제어의 역전(IoC, Inversion of Control)의 구체적인 구현 방법 중 하나
• 객체 간의 결합도를 낮추고, 코드의 유연성과 테스트 용이성을 향상

의존성 주입(DI) 전후 차이

• 이전

  public class OrderService {
  
      private EmailSender emailSender = new EmailSender();  // 직접 생성
      private SmsNotifier smsNotifier = new SmsNotifier();  // 직접 생성
      
      
      public void processOrder(Order order) {
          // 주문 처리 로직
          emailSender.sendOrderConfirmation(order);
          smsNotifier.sendNotification(order);
      }
  }
  

  • 문제점

    • OrderService가 구체적인 구현체에 강한 결합

      ⇒ 테스트 시 실제 이메일이 발송되거나 SMS가 전송될 수 있음

    • 다른 알림 방식으로 변경하려면 코드 수정 필요 (OCP 위반)

    • 단위 테스트가 어려움

• 이후

  @Service
  public class OrderService {
  
      private final NotificationService notificationService;
      
      // 생성자 주입
      public OrderService(NotificationService notificationService) {
          this.notificationService = notificationService;
      }
      
      public void processOrder(Order order) {
          // 주문 처리 로직
          notificationService.sendOrderConfirmation(order);
      }
  }
  
  
  @Component
  public class EmailNotificationService implements NotificationService {
      @Override
      public void sendOrderConfirmation(Order order) {
          // 이메일 발송 로직
      }
  }
  

  • 생성자를 통해 의존성을 주입 받는다.
    • 약한 결합
    • Spring의 경우, IoC 컨테이너로 객체 생성 및 의존성 주입도 자동화할 수 있다.
  • 테스트 시 Mock 객체를 활용할 수 있어 테스트가 용이하다.
  • 인터페이스까지 활용한다면 다른 기능으로 변경 시 쉽게 변경할 수 있다. (OCP 준수)

@Autowired 동작 원리

@Service
public class OrderService {

    private final PaymentService paymentService;
    
    **public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

• 타입 기반으로 Bean을 찾아서 주입
• 같은 타입의 Bean이 여러 개인 경우 @Qualifier 사용
• @Autowired 생략 가능 (생성자가 하나인 경우)

권장되는 의존성 주입 방식

• 생성자 + Lombok

  @RequiredArgsConstructor
  @Service
  public class OrderService {
      private final PaymentService paymentService;
  }
  

  • Spring Boot에서는 생성자가 하나인 경우 @Autowired를 생략할 수 있으며, Lombok의 @RequiredArgsConstructor를 사용하면 final 필드에 대한 생성자를 자동 생성하여 더욱 간편하게 의존성 주입을 구현할 수 있다.
  
  
  • 장점
    • 불변성 보장
    • 테스트 시 의존성 주입이 쉽다.
    • 순환 참조 즉시 감지

의존성 주입의 장점

• 낮은 결합도 (Low Coupling)
  • 인터페이스에 의존하여 구현체 변경이 용이
  • 객체 간의 직접적인 의존성 제거

• 재사용성과 유지보수성 향상
  • 동일한 컴포넌트를 다양한 환경에서 재사용
  • 코드 변경 없이 다른 구현체로 교체 가능

• 높은 테스트 용이성

  @SpringBootTest
  void orderServiceTest() {
  
  **    @MockBean
      private PaymentService paymentService;
  
      @Autowired
      private OrderService orderService;
      
      @Test
      void orderServiceTest() {
          // 테스트 로직
      }
  **}
  

의존성 주입 주의사항

• 순환 참조 (Circular Dependency)

  @Service
  public class ServiceA {
      public ServiceA(ServiceB serviceB) { ... }  *// A → B*
  }
  
  @Service
  public class ServiceB {
      public ServiceB(ServiceA serviceA) { ... }  *// B → A (순환 참조)*
  }
  

  • 생성자 주입 시 애플리케이션 시작 시점에 오류 발생

• @Qualifier를 통한 Bean 선택

  public interface NotificationService { ... }
  
  @Component("emailNotification")
  public class EmailNotificationService implements NotificationService { ... }
  
  @Component("smsNotification") 
  public class SmsNotificationService implements NotificationService { ... }
  
  @Service
  @RequiredArgsConstructor
  public class OrderService {
  
      @Qualifier("emailNotification")
      private final NotificationService notificationService;
  
  }
  

  • NotificationService 구현체가 하나가 아니라면, @Qualifier로 구현체를 특정할 수 있다.

실무에서의 패턴

• 프로파일별 Bean 설정

  @Service
  @Profile("dev")
  public class MockEmailService implements EmailService { ... }
  
  @Service
  @Profile("prod")
  public class RealEmailService implements EmailService { ... }
  

AutoConfiguration이란?

• Spring Boot가 제공하는 자동 설정 기능으로, Classpath에 존재하는 외부 라이브러리와 설정 정보를 기반으로 필요한 Bean을 자동으로 등록

• 개발자가 명시적으로 설정하지 않은 부분을 Spring Boot가 관례에 따라 자동으로 구성

• "Convention over Configuration" 철학을 구현한 핵심 기능

  ⇒ 명시적으로 다 설정하지 않아도, 일반적인 관례를 기본값으로 제공하겠다.

• @SpringBootApplication 애노테이션에 포함된 @EnableAutoConfiguration을 통해 활성화할 수 있다.

AutoConfiguration 동작 과정

• 1단계 : AutoConfigurationImportSelector 실행

  • @EnableAutoConfiguration이 @Import(AutoConfigurationImportSelector.class)를 통해 실행

  • AutoConfigurationImportSelector 클래스

    package: org.springframework.boot.autoconfigure
    ...
    
    public class AutoConfigurationImportSelector 
        implements DeferredImportSelector, BeanClassLoaderAware, 
                ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
    
        @Override
        public String[] selectImports(AnnotationMetadata annotationMetadata) {
            if (!isEnabled(annotationMetadata)) {
                return NO_IMPORTS;
            }
            // 1. 메타데이터 로드
            AutoConfigurationMetadata metadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
            
            // 2. 자동 설정 엔트리 가져오기
            AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(metadata, annotationMetadata);
            
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
    
        protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
            // 3. 후보 설정 클래스들 가져오기 (여기서 파일 읽기!)
            List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
            // 4. 중복 제거, exclude 처리, 필터링
            configurations = removeDuplicates(configurations);
            // 5. 최종 결과 반환
            return new AutoConfigurationEntry(configurations, exclusions);
        }
    }
    

    • selectImports() 메서드가 핵심 진입점 역할 ⇒ getAutoConfigurationEntry()

  • getCandidateConfigurations() 메서드로 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 파일 읽기

    (Spring Boot 2.7 이상)

  • spring-boot-autoconfigure 라이브러리(JAR)의 AutoConfiguration.imports 파일에서 미리 정의된 100여 개의 자동 설정 클래스들 목록 획득

  • 중복 제거, exclude 목록 처리, 필터링 수행

  • Ex. org.springframework.boot.autoconfigure.AutoConfiguration.imports 파일

    org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration
    org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
    org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration
    

• 2단계 : 각 자동 설정 클래스 처리

  • 1단계에서 가져온 자동 설정 클래스들을 하나씩 처리

  • 각 자동 설정 클래스에 대해 조건부 애노테이션 평가 (@ConditionalOnClass, @ConditionalOnMissingBean 등)

    ⇒ Classpath에 특정 라이브러리가 존재하는지, 특정 Bean이 이미 등록되어 있는지 등을 검사

  • @EnableConfigurationProperties가 있는 클래스들은 application.yml 값을 Properties 객체로 바인딩

  • 조건을 만족하는 경우에만 Bean 등록

  • Ex. 예시

    @Configuration(proxyBeanMethods = false)
    @ConditionalOnClass({EntityManager.class})
    @ConditionalOnMissingBean(DataSource.class)
    @EnableConfigurationProperties(JpaProperties.class)  // yml 바인딩
    public class HibernateJpaAutoConfiguration {
        // 조건 만족 시 EntityManager 등 Bean 등록
    }
    

    • JPA 의존성을 넣지 않는 경우

      ⇒ EntityManager 클래스가 classpath에 없으면 조건부 애노테이션에 따라, JPA 설정을 건들이지 않는다.

• 3단계 : Bean 등록 및 우선순위 처리
  • 조건을 만족하는 자동 설정 클래스들이 실행되어 필요한 Bean들을 Spring 컨테이너에 등록
  • 사용자가 정의한 Bean이 우선순위를 가지며, 자동 설정 Bean을 오버라이드할 수 있다.

주요 조건부 어노테이션

• 조건부 애노테이션이란?
  • Bean 등록 또는 설정 적용 여부를 “조건부로 제어”하는 기능
  • 자동 설정이 무조건 적용되지 않고, 상황에 따라 동적으로 적용 여부를 판단하기 위함

• @Conditiona

  @Conditional(MyCondition.class)
  

  • Spring의 기본형 조건부 애노테이션
  • Condition 인터페이스 구현
  • Spring Boot는 이것을 추상화한 특수 조건 애노테이션들을 제공한다.
    • 모두 @Conditional을 내부적으로 사용한다.

• @ConditionalOnClass

  @ConditionalOnClass({DataSource.class, JdbcTemplate.class})
  public class DataSourceAutoConfiguration { ... }
  

  • 특정 클래스가 Classpath에 존재할 때만 실행
  • 즉, Classpath의 .class, -jar 파일을 보고 조건에 해당하는 클래스가 있는지 판단한다.

• @ConditionalOnMissingBean

  @ConditionalOnMissingBean(DataSource.class)
  @Bean
  public DataSource dataSource() { ... }
  

  • 특정 타입의 Bean이 없을 때만 실행

• @ConditionalOnProperty

  @ConditionalOnProperty(name = "spring.datasource.url")
  

  • 특정 프로퍼티 값에 따라 실행
  • application.yml에 해당 프로퍼티가 존재하고 값이 설정되어 있을 때만 자동 설정 적용

@ConfigurationProperties

@Configuration
@ConditionalOnClass({DataSource.class, JdbcTemplate.class})
@EnableConfigurationProperties(DataSourceProperties.class)
public class DataSourceAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public DataSource dataSource(DataSourceProperties properties) {
        return DataSourceBuilder.create()
            .url(properties.getUrl())
            .username(properties.getUsername())
            .password(properties.getPassword())
            .build();
    }
}

@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceProperties {
    private String url;
    private String username;
    private String password;
        
        // getter, setter...
}

• @ConfigurationProperties와 AutoConfiguration의 관계
  • AutoConfiguration에서 application.yml 프로퍼티를 Java 객체로 바인딩하는 핵심 메커니즘
  • @EnableConfigurationProperties를 통해 프로퍼티 클래스를 Bean으로 등록
  • 예시
    • application.yml에 spring.datasource.url=jdbc:mysql://localhost/test 설정
    • DataSourceProperties 객체의 url 필드에 자동으로 바인딩
    • AutoConfiguration에서 이 객체를 주입 받아 DataSource Bean 설정에 사용

대표적인 AutoConfiguration 예시

• DataSourceAutoConfiguration
  • H2, MySQL 등의 데이터베이스 드라이버가 Classpath에 있으면 자동으로 DataSource Bean 생성
  • application.yml(properties)의 spring.datasource.* 프로퍼티를 읽어 설정

• JpaRepositoriesAutoConfiguration
  • Spring Data JPA가 Classpath에 있으면 JPA Repository 스캔 및 등록
  • EntityManager, TransactionManager 등을 자동 구성

• WebMvcAutoConfiguration
  • Spring Web MVC 의존성이 있으면 DispatcherServlet, ViewResolver 등을 자동 설정

사용자 정의 설정

• 특정 자동 설정 제외

  @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
  public class MyApplication { ... }
  

  • exclude = {DataSourceAutoConfiguration.class}

• 사용자 정의 Bean으로 오버라이드

  @Configuration
  public class CustomDataSourceConfig {
  
      @Bean
      @Primary
      public DataSource customDataSource() {
          // 사용자 정의 DataSource
      }
  }
  

AutoConfiguration의 장점

• 빠른 개발 시작
  • 최소한의 설정으로 애플리케이션 실행 가능
• 검증 완료
  • 설정되는 것은 Spring 팀이 검증한 설정들이다.
• 유연성
  • 필요에 따라 자동 설정을 부분적으로 오버라이드하거나 완전히 제외 가능
• 유지보수성
  • 라이브러리 업그레이드 시 설정 변경이 자동으로 반영