[Spring Boot] Spring Bean (Factory / Container)

Spring 프레임워크에서 Bean은 Spring IoC 컨테이너에 의해 관리되는 객체를 의미합니다. Bean은 애플리케이션의 다양한 구성 요소로서, Spring의 핵심 개념 중 하나입니다. 다음은 Spring Bean에 대한 자세한 설명입니다. → 객체의 생성과 의존성 관리를 개발자가 해주지 않아도 됩니다

Spring Bean의 정의

• Bean: Spring IoC 컨테이너가 생성하고 관리하는 객체로, 애플리케이션의 비즈니스 로직, 데이터 액세스, 웹 계층 등을 구성하는 데 사용됩니다. Spring Bean은 주로 POJO(Plain Old Java Object)로 구현됩니다.

Spring Bean의 특징

1. 생명 주기 관리: Spring IoC 컨테이너는 Bean의 생성, 초기화, 소멸 과정을 관리합니다. 개발자는 Bean의 생명 주기를 신경 쓰지 않고 비즈니스 로직에 집중할 수 있습니다.
2. 의존성 주입: Bean은 다른 Bean과의 의존성을 가질 수 있으며, Spring은 이를 IoC 컨테이너를 통해 자동으로 주입합니다. 이를 통해 코드의 결합도를 낮추고 유지보수를 용이하게 합니다.
3. 스코프: Spring Bean은 여러 가지 스코프를 가질 수 있으며, 이를 통해 Bean의 생명 주기를 정의할 수 있습니다. 일반적인 스코프는 다음과 같습니다:
   • singleton: IoC 컨테이너에서 단 하나의 인스턴스만 생성됩니다. (기본값)
   • prototype: 요청할 때마다 새로운 인스턴스가 생성됩니다.
   • request: HTTP 요청당 하나의 Bean 인스턴스가 생성됩니다. (웹 애플리케이션에서 사용)
   • session: HTTP 세션당 하나의 Bean 인스턴스가 생성됩니다. (웹 애플리케이션에서 사용)
   • globalSession: 글로벌 HTTP 세션당 하나의 Bean 인스턴스가 생성됩니다. (포트렛에서 사용)

Spring Bean의 생성과 설정

1. XML 설정: XML 파일에서 Bean을 정의합니다.

   <bean id="myBean" class="com.example.MyClass">
       <property name="propertyName" value="value" />
   </bean>
   

2. 어노테이션 설정 (묵시적 빈 정의): 어노테이션을 사용하여 Bean을 정의합니다.

   • 클래스에 @Component 어노테이션을 통해서 Spring이 해당 클래스를 스캔하고 Bean으로 등록하게 할 수 있음
   • @Component 어노테이션이 붙여진 Bean은 다른 클래스에서는 @Autowired 어노테이션을 주입받아 사용할 수 있음

   import org.springframework.stereotype.Component;
   
   @Component
   public class MyClass {
       private String propertyName;
   
       // Getter and Setter
   }
   

3. 자바 기반 설정 (명시적 빈 정의): 자바 클래스를 사용하여 Bean을 정의합니다.

   • Spring 설정 파일에 @Configuration 어노테이션을 추가하고, @Bean 어노테이션을 붙여서 명시적으로 Bean을 지정할 수 있음

   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.Configuration;
   
   @Configuration
   public class AppConfig {
       @Bean
       public MyClass myBean() {
           return new MyClass();
       }
   }
   

Spring Bean의 생명 주기

Spring Bean의 생명 주기는 다음과 같은 단계로 이루어집니다:

1. Bean 생성: IoC 컨테이너가 Bean을 생성합니다.
2. 의존성 주입: 필요한 의존성을 주입합니다.
3. 초기화: @PostConstruct 어노테이션이나 InitializingBean 인터페이스를 통해 초기화 작업을 수행합니다.
4. 사용: Bean이 실제로 사용됩니다.
5. 소멸: 애플리케이션 종료 시 @PreDestroy 어노테이션이나 DisposableBean 인터페이스를 통해 정리 작업을 수행합니다.

요약

Spring Bean은 Spring IoC 컨테이너에 의해 관리되는 객체로, 애플리케이션의 다양한 구성 요소를 표현합니다. Bean은 의존성 주입을 통해 다른 Bean과 연결되며, IoC 컨테이너는 Bean의 생명 주기를 관리합니다. Bean의 설정은 XML, 어노테이션, 자바 기반 설정을 통해 이루어질 수 있습니다.

---

Spring에서 팩토리(Factory)와 컨테이너(Container)는 비슷한 역할을 수행하는 것처럼 보일 수 있지만, 그 기능과 목적에 있어 명확한 차이가 있습니다. 이 두 개념의 차이점을 아래와 같이 정리해 드리겠습니다.

1. 팩토리(Factory)

• 정의: 팩토리는 객체를 생성하는 메커니즘입니다. Spring에서는 Bean을 생성하는 데 사용되는 여러 종류의 팩토리 패턴이 있습니다.
• 기능: 팩토리는 주로 객체의 생성과 초기화에 집중합니다. BeanFactory와 같은 Spring의 팩토리는 필요한 시점에 Bean을 생성하고 반환합니다.
• 역할:
  • 객체 인스턴스를 생성
  • 객체의 초기화 작업 수행
  • 특정 조건에 따라 다양한 객체를 생성할 수 있는 능력 제공

팩토리는 객체를 생성하는 책임을 가진 클래스 또는 메커니즘입니다. Spring에서는 일반적으로 객체를 생성하는 데 사용되는 여러 가지 패턴이 있으며, 그 중에서 팩토리 메소드 패턴(Factory Method Pattern)과 추상 팩토리 패턴(Abstract Factory Pattern)이 널리 사용됩니다.

• Factory Method: 서브클래스가 인스턴스를 생성하도록 정의하는 메서드입니다. Spring에서 Bean의 생성 방식을 다양하게 구현하기 위해 사용됩니다.
• Abstract Factory: 관련 객체를 생성하는 인터페이스를 제공하며, 이를 통해 클라이언트 코드에서 구체적인 클래스에 의존하지 않도록 합니다.

Spring에서의 팩토리 역할

Spring에서는 BeanFactory와 ApplicationContext 같은 컨테이너가 내부적으로 팩토리 역할을 수행하여 Bean을 생성합니다. 이 팩토리는 Bean의 생성, 초기화, 의존성 주입을 관리합니다.

public class MyBean {
    public MyBean() {
        System.out.println("MyBean instance created!");
    }
}

<beans>
    <bean id="myBean" class="com.example.MyBean"/>
</beans>

이 XML 설정을 사용하여 ApplicationContext는 MyBean의 인스턴스를 생성할 때 팩토리 역할을 합니다.

2. 컨테이너(Container)

• 정의: 컨테이너는 객체의 생성뿐만 아니라, 생명주기 관리, 의존성 주입 및 다양한 애플리케이션 기능을 지원하는 복합적인 구조입니다. Spring에서는 주로 ApplicationContext와 BeanFactory가 컨테이너로 사용됩니다.
• 기능: 컨테이너는 Bean의 생성뿐만 아니라, Bean 간의 의존성을 관리하고, 각 Bean의 생명주기를 처리합니다.
• 역할:
  • Bean의 생성 및 초기화
  • 의존성 주입 관리
  • 이벤트 처리 및 AOP(Aspect Oriented Programming)와 같은 추가 기능 제공
  • 다양한 스코프 관리 (예: 싱글턴, 프로토타입)

컨테이너는 Spring의 핵심 개념으로, Bean의 생성과 생명주기를 관리하는 객체입니다. Spring은 두 가지 주요 컨테이너를 제공합니다: BeanFactory와 ApplicationContext.

• BeanFactory: 가장 기본적인 컨테이너로, 간단한 의존성 주입과 객체 생성을 지원합니다. 필요할 때만 Bean을 생성하여 메모리 효율성을 높입니다. 하지만 기능이 제한적이고 이벤트 리스너나 국제화 기능을 지원하지 않습니다.
• ApplicationContext: BeanFactory의 확장으로, 더 많은 기능을 제공합니다. 스프링의 모든 기능을 사용할 수 있으며, 이벤트 처리, 국제화, AOP(Aspect Oriented Programming) 지원 등 다양한 기능을 포함합니다. 일반적으로 Spring 애플리케이션에서 사용하는 주요 컨테이너입니다.

Spring 컨테이너의 역할

1. Bean의 생성 및 초기화: 설정 파일(XML, Java Config)이나 애너테이션을 통해 정의된 Bean을 생성하고 초기화합니다.
2. 의존성 주입: 컨테이너는 각 Bean이 필요로 하는 의존성을 자동으로 주입합니다. 이는 @Autowired, @Inject와 같은 애너테이션 또는 XML 설정을 통해 이루어집니다.
3. 생명주기 관리: Bean의 생성부터 소멸까지 생명주기를 관리합니다. 초기화 메서드와 소멸 메서드를 지정할 수 있습니다.
4. 스코프 관리: Bean의 스코프(예: 싱글턴, 프로토타입)를 관리하여 여러 인스턴스의 생성 및 재사용을 처리합니다.

차이점 요약

Feature	Factory	Container
주요 기능	객체 생성	객체 생성, 의존성 주입, 생명주기 관리
주요 역할	객체 초기화와 생성	전체 애플리케이션의 구조 및 관리
예시	BeanFactory, Factory Method	ApplicationContext, BeanFactory
복잡성	상대적으로 단순	상대적으로 복잡하고 기능이 풍부

결론

• 팩토리는 객체 생성에 집중하고, 컨테이너는 객체 생성뿐만 아니라 의존성 관리와 생명주기 관리까지 포함한 더 넓은 개념입니다.
• Spring에서는 팩토리와 컨테이너가 함께 작동하여 효과적으로 Bean을 관리하며, 이 두 개념을 통합적으로 이해하는 것이 중요합니다.

따라서 이 둘은 비슷한 점도 있지만, 각각의 역할과 기능에 따라 다르게 이해해야 합니다. 팩토리는 객체 생성에 더 중점을 두고, 컨테이너는 애플리케이션 전반의 관리와 관련된 더 포괄적인 개념입니다.