Spring 프레임워크의 수명 주기와 싱글톤에 대한 자세한 설명 설명 [자세한 답변이 포함된 인터뷰 질문]

목차

I. 소개

1.1 Spring 프레임워크와 Bean 개념 소개

두 번째, Bean 인스턴스화 단계

2.1.Bean 인스턴스화 프로세스

2.2 기본 생성자와 팩토리 메서드 사용 소개

3. 빈 초기화 단계

3.1 InitializingBean 인터페이스와 @PostConstruct 애노테이션의 사용

3.2.Bean 초기화 메소드 구성 및 실행 순서

넷째, Bean의 파괴 단계

4.1 DisposableBean 인터페이스와 @PreDestroy 주석 사용

4.2.Bean 소멸 방식 설정 및 실행 순서

5. 면접 질문에 대한 설명

5.1.Bean 생명주기

결론적으로:

5.2 Spring의 JavaBean은 싱글톤입니까 아니면 다중 인스턴스입니까?

논쟁:

5.3 단일 인스턴스 JavaBean과 다중 인스턴스 JavaBean은 언제 생성됩니까?

논쟁:

5.4 싱글톤을 사용할 때 JavaBean을 초기화합니까?

논쟁:

---

I. 소개

1.1 Spring 프레임워크와 Bean 개념 소개

이봐 친구들! Spring Framework와 Bean에 대한 이야기를 분석해 보겠습니다.

Spring 프레임워크는 수호성인과 같으며 Java 애플리케이션의 관리를 담당합니다. 마치 슈퍼 파티 주최자처럼 앱을 쉽게 관리하고 제어할 수 있습니다. 목표는 엔터프라이즈 애플리케이션을 구축하는 효율적이고 유연한 방법을 제공하는 것입니다.

그래서 콩은 무엇입니까? Bean은 실제로 Spring 프레임워크의 실제 객체입니다. Bean은 Spring 프레임워크 파티에서 즐거운 시간을 보내는 작은 친구라고 생각할 수 있습니다! 인간이 출생, 성장, 일, 은퇴의 단계를 거치는 것처럼 각 Bean에는 고유한 수명 주기가 있습니다.

우선, Bean의 인스턴스화는 우리의 탄생과 같습니다. Spring은 Bean 객체를 생성하고 컨테이너에 로드하는 역할을 합니다. 그러면 빈의 속성 부여는 마치 우리가 성장하는 과정에서 새로운 기술을 배우듯 다양한 속성이 주입되어 화려해진다.

다음은 Bean의 초기화 단계입니다. 작업을 시작하기 전에 준비해야 하는 것처럼 Bean은 특정 초기화 메서드를 호출하거나 Bean 후처리기를 통해 일부 후속 작업을 수행하는 등 일부 초기화 작업을 수행할 수도 있습니다.

마지막으로 애플리케이션이 더 이상 Bean을 필요로 하지 않으면 우리가 은퇴한 것처럼 리소스 해제, 데이터베이스 연결 닫기 등과 같은 일부 파괴 작업을 수행할 수 있습니다.

요컨대 Spring 프레임워크와 Bean은 이 작은 친구들이 다양한 단계를 오가며 즐거움과 성취감을 가져다주는 파티와 같습니다. 하지만 걱정하지 마세요. Spring Framework는 책임감 있는 파티 조직자이며 모든 빈이 적절하게 관리되고 보살핌을 받을 수 있도록 할 것입니다!

이 유머러스한 소개를 통해 Spring 프레임워크와 빈을 더 잘 이해할 수 있기를 바랍니다!

두 번째, Bean 인스턴스화 단계

2.1.Bean 인스턴스화 프로세스

Bean 인스턴스화 프로세스는 정의된 Bean을 사용 가능한 객체 인스턴스로 변환하는 프로세스를 말합니다. Spring 프레임워크에서 Bean 인스턴스화는 다음 단계로 나눌 수 있습니다.

1. Bean 정의 로드: 구성 파일(예: XML 구성 파일) 또는 주석을 사용하여 Bean 정의를 컨테이너에 로드하면 Spring 프레임워크가 구문 분석을 담당합니다.

2. 인스턴스화 Bean: Bean의 정의 및 구성 정보에 따라 메모리에 Bean 인스턴스를 생성합니다. 이는 생성자 인스턴스화, 팩토리 메서드 인스턴스화 또는 객체 리플렉션 등을 통해 수행할 수 있습니다.

3. 속성 할당: 기본 데이터 유형, 참조 유형 및 컬렉션 유형을 포함하여 인스턴스화된 Bean 개체에 속성을 할당합니다. 주석 또는 XML 구성 파일을 통해 속성을 종속성에 삽입할 수 있습니다.

4. Aware 인터페이스 콜백: Bean이 Aware 인터페이스를 구현하면 Spring은 자동으로 해당 콜백 메소드를 감지하고 호출합니다. 예를 들어 ApplicationContextAware 인터페이스는 ApplicationContext 객체를 얻을 수 있습니다.

5. 사용자 정의 초기화 방법: bean이 초기화 방법으로 구성된 경우(주석 또는 XML 구성 파일을 통해 가능) Spring은 bean이 속성 할당을 완료한 후 일부 사용자 정의 초기화 작업을 수행하기 위해 이 메서드를 호출합니다.

6. Post-processor 메소드 호출: Bean post-processor(BeanPostProcessor)가 구성되면 Spring은 추가 처리 작업을 위해 관련 메소드를 자동으로 감지하고 호출합니다.

7. Bean is ready: 위 단계 후 Bean 인스턴스화 프로세스가 완료되고 컨테이너에서 관리 및 사용할 수 있습니다.

2.2 기본 생성자와 팩토리 메서드 사용 소개

기본 생성자 : 기본 생성자는 개체 생성 프로세스에 매개 변수를 전달하지 않는 인수 없는 생성자입니다. Spring은 기본 생성자를 자동으로 호출하여 Bean 객체를 인스턴스화합니다. 이 방법은 널리 사용되며 다른 방법으로 매개변수를 전달하지 않고 객체를 생성하는 것이 편리합니다. 예를 들어:

public class MyBean {
    // 默认构造函数
    public MyBean() {
        // 初始化操作
    }
}

팩토리 메소드 : 팩토리 메소드는 특별한 메소드를 통해 Bean 객체를 인스턴스화하는 방법입니다. 일반적으로 이 메서드는 전용 팩터리 클래스에서 정의됩니다. 팩토리 방식을 통해 Bean 객체를 생성하는 데 더 많은 유연성을 가질 수 있고 매개변수 전달과 같은 작업을 사용자 정의할 수 있습니다. 예를 들어:

public class MyBeanFactory {
    // 工厂方法
    public static MyBean createMyBean() {
        // 创建Bean对象的逻辑
        return new MyBean();
    }
}

샘플 코드: 기본 생성자와 팩토리 메서드를 사용하여 Bean 개체를 인스턴스화하는 방법을 보여줍니다.

public class MyBean {
    private String message;

    // 默认构造函数
    public MyBean() {
        this.message = "Hello, world!";
    }

    // getter和setter方法

    public static MyBean createMyBean() {
        MyBean myBean = new MyBean();
        myBean.setMessage("Hello, Spring!");
        return myBean;
    }
}

3. 빈 초기화 단계

3.1 InitializingBean 인터페이스와 @PostConstruct 애노테이션의 사용

InitializingBean 인터페이스는 다음을 사용합니다.

이 인터페이스는 afterPropertiesSet() 메서드를 정의하며 Bean의 모든 속성이 설정되면 Spring 컨테이너는 자동으로 이 메서드를 호출하여 초기화 작업을 완료합니다.

import org.springframework.beans.factory.InitializingBean;

public class MyBean implements InitializingBean {
    private String message;
    
    public void setMessage(String message) {
        this.message = message;
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean: Bean is being initialized with message: " + message);
    }
}

@PostConstruct 주석 사용

이 주석은 Bean의 초기화 작업을 완료하기 위해 Bean의 속성이 설정된 후 메서드가 자동으로 실행됨을 나타내는 Bean의 초기화 메서드에 표시됩니다.

import javax.annotation.PostConstruct;

public class MyBean {
    private String message;
    
    public void setMessage(String message) {
        this.message = message;
    }
    
    @PostConstruct
    public void init() {
        System.out.println("@PostConstruct: Bean is being initialized with message: " + message);
    }
}

유의할 점은 InitializingBean 인터페이스와 @PostConstruct 주석은 동시에 사용할 수 있지만 이 두 가지 방법은 필수가 아니며 필요에 따라 둘 중 하나를 선택하여 Bean을 초기화할 수 있습니다.

Spring에서는 구성 파일을 통해 Bean 초기화 방법을 지정할 수도 있고, XML 구성 파일에서 <bean> 태그의 init-method 속성을 사용하여 설정할 수도 있습니다. 예는 다음과 같습니다.

<bean id="myBean" class="com.example.MyBean" init-method="init">
    <property name="message" value="Hello World" />
</bean>

3.2.Bean 초기화 메소드 구성 및 실행 순서

InitializingBean 인터페이스, @PostConstruct 주석 또는 XML 구성 파일을 사용하든 관계없이 Bean 초기화 방법을 지정하는 데 사용할 수 있으며 실행 순서는 동일합니다. 먼저 속성의 종속성 주입을 실행한 다음 초기화 방법을 실행합니다.

public class Example {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        MyBean bean = context.getBean(MyBean.class);
        // Bean已经被初始化完成并且可以使用
        
        ((ConfigurableApplicationContext) context).close();
    }
}

위의 예에서 ApplicationContext 개체가 생성되고 XML 구성 파일이 로드됩니다. MyBean의 인스턴스를 얻기 위해 getBean() 메서드를 호출하면 Spring 컨테이너는 자동으로 속성 주입 및 초기화 작업을 수행합니다. 애플리케이션을 닫을 때 ((ConfigurableApplicationContext) context).close() 메서드를 호출하여 컨테이너를 닫을 수 있습니다.

넷째, Bean의 파괴 단계

4.1 DisposableBean 인터페이스와 @PreDestroy 주석 사용

DisposableBean 인터페이스는

이 인터페이스는 Destroy() 메서드를 정의하며, Bean을 파괴해야 할 때 Spring 컨테이너는 자동으로 이 메서드를 호출하여 정리 작업을 완료합니다. 예는 다음과 같습니다.

import org.springframework.beans.factory.DisposableBean;

public class MyBean implements DisposableBean {
    private String message;
    
    public void setMessage(String message) {
        this.message = message;
    }
    
    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean: Bean is being destroyed with message: " + message);
    }
}

@PreDestroy 주석 사용

이 주석은 Bean의 소멸 방법에 표시되어 정리 작업을 완료하기 위해 Bean을 소멸시켜야 할 때 해당 방법이 자동으로 실행됨을 나타냅니다. 예는 다음과 같습니다.

import javax.annotation.PreDestroy;

public class MyBean {
    private String message;
    
    public void setMessage(String message) {
        this.message = message;
    }
    
    @PreDestroy
    public void cleanup() {
        System.out.println("@PreDestroy: Bean is being destroyed with message: " + message);
    }
}

설정 파일에서 <bean> 태그의 destroy-method 속성을 사용하여 Bean의 메소드를 파괴하도록 구성 파일을 통해 Bean 파괴를 지정할 수도 있습니다. 예는 다음과 같습니다.

<bean id="myBean" class="com.example.MyBean" destroy-method="cleanup">
    <property name="message" value="Goodbye World" />
</bean>

4.2.Bean 소멸 방식 설정 및 실행 순서

Bean의 destroy 메소드가 먼저 실행된 다음 컨테이너가 닫히거나 파괴됩니다.

public class Example {
    public static void main(String[] args) {
        // 创建并启动Spring容器
        ConfigurableApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        // 获取Bean实例
        MyBean bean = context.getBean(MyBean.class);
        
        // 使用Bean...
        
        // 手动关闭容器
        context.close();
    }
}

위의 예에서는 ApplicationContext 개체를 만들고 XML 구성 파일을 로드했습니다. MyBean의 인스턴스를 얻기 위해 getBean() 메서드를 호출함으로써 Spring 컨테이너는 자동으로 Bean의 소멸 메서드를 실행할 것입니다. 컨테이너를 수동으로 닫을 때 context.close() 메서드를 호출하여 Bean의 파괴를 트리거할 수 있습니다.

5. 면접 질문에 대한 설명

5.1.Bean 생명주기

1. XML, Java annotation(annotation), Java Configuration(configuration class) 등을 통해 Spring Bean을 Load한다.

2.BeanDefinitionReader: Bean의 정의를 구문 분석합니다. Spring 컨테이너의 시작 프로세스 중에 Bean은 Spring 내부의 BeanDefinition 구조로 구문 분석됩니다. spring.xml의 <bean> 태그를 BeanDefinition 구조로 변환하는 것은 XML 구문 분석과 다소 유사합니다.

3.BeanDefinition: 많은 속성과 메서드를 포함합니다. 예: id, class(클래스 이름), 범위, ref(종속 빈) 등 실제로 해당 BeanDefinition의 해당 속성에 해당 Bean(예: <bean>)의 정의 정보를 저장하는 것입니다.예를 들면 다음과 같습니다.

<bean id="" class="" scope=""> -----> BeanDefinition(id/class/scope)

4.BeanFactoryPostProcessor: Spring 컨테이너 기능의 확장 인터페이스이다.

알아채다:

1) BeanFactoryPostProcessor가 스프링 컨테이너에 BeanDefinition을 로드한 후,

Bean이 인스턴스화되기 전에 실행됨

2) 빈 메타데이터(BeanDefinition) 즉, BeanDefinition 처리

속성 채우기, 수정 및 기타 작업

5. BeanFactory: 콩 공장. 우리의 요구 사항에 따라 필요한 다양한 콩을 생산합니다.

예를 들어:

BeanFactory -> 목록 <BeanDefinition>

BeanDefinition(ID/클래스/범위/초기화 방법)

<빈 클래스="com.zking.spring02.biz.BookBizImpl"/>

foreach(BeanDefinition 빈: List<BeanDefinition>){

   //클래스 속성 리플렉션 메커니즘에 따라 객체를 인스턴스화합니다.

   // 반영 할당 설정 속성

}

6. 인식 인터페이스: 실제 개발에서는 Spring 컨테이너 자체의 기능적 리소스를 사용해야 하는 경우가 많습니다.

예: BeanNameAware, ApplicationContextAware 등

BeanDefinition은 BeanNameAware, ApplicationContextAware를 구현합니다.

7.BeanPostProcessor: 포스트 프로세서. Bean 개체가 인스턴스화되고 주입된 후 초기화 메서드 호출 전후에 사용자 지정 논리를 추가합니다. (AOP의 순환 통지와 유사) 전제 조건: Bean 객체가 BeanPostProcessor 포스트 프로세서를 구현하는 것으로 감지되면 Before 및 After 메소드가 실행됩니다.

빈포스트프로세서

1) 전에

2) 초기화 Bean 호출(InitializingBean 및 init-method, Bean의 초기화가 완료된 것으로 간주)

3) 이후

8.destory: 파괴하다

결론적으로:

1.xml/annotation/configuation은 JavaBean을 구성합니다.

2. BeanDefinitionReader는 구성된 Javabean을 구문 분석하여 BeanDefinition을 가져오고 마지막으로 List 컬렉션을 가져옵니다.

3. Trigger BeanFactoryPostProcessor, JavaBean은 초기화 전에 자체 비즈니스를 실행합니다.

4. spring의 beanFactory는 List<BeanDefinition> 콜렉션(반영 인스턴스화)을 통해 모든 JavaBean 오브젝트를 순회하고 초기화합니다.

5. 자체 JavaBean이 스프링 컨텍스트에서 자원을 동원해야 하는 경우 *Aware 인식 인터페이스를 구현해야 합니다.

6. 자신의 JavaBean이 초기화되었고 확장이 필요한 경우 이를 달성하기 위해 BeanPostProcessor를 사용해야 합니다.

7. 파괴하다(파괴하다).

5.2 Spring의 JavaBean은 싱글톤입니까 아니면 다중 인스턴스입니까?

1. 기본은 단일 인스턴스이지만 여러 인스턴스를 구성할 수 있습니다.

2. 단일 인스턴스의 장점은 메모리를 절약할 수 있지만 변수 오염이 있다는 단점(다중 인스턴스의 장점은 변수 오염이 없지만 메모리를 극도로 소모함)

싱글톤과 다중 인스턴스의 차이점과 각각의 장점과 단점을 표현한 짧고 재미있는 이야기.

---

환상의 마법 학교에는 "매직 맨"이라는 특별한 교사가 있습니다. 그는 초능력을 가지고 있으며 학생들에게 모든 종류의 마법 주문을 가르치는 일을 담당합니다.

Magic Man에게 그는 완전한 단일 사례입니다. 그는 학교 전체에서 이처럼 강력한 마법의 힘을 가진 유일한 사람이며 모든 학생과 교직원은 그에게 도움과 지도를 요청할 것입니다. 그는 항상 학교의 중심에 둘러싸여 있으며 모두가 그의 존재를 추구합니다.

그러나 매직맨의 특수한 지위로 인해 그의 마력은 학교 전체에 스며들었다. 교실에 있든 학교의 다른 장소에 있든 그의 독특한 마법 같은 분위기가 가득합니다. 때때로 학생들이 주문을 걸려고 할 때 마술사의 힘에 영향을 받아 예상치 못한 효과가 발생했습니다.

그에 반해 '여러구름'이라는 또 다른 선생님이 있다. 그녀는 다중 사례이며 모든 수업에서 찾을 수 있습니다. 그녀는 부드럽고 유연한 마법의 힘을 가지고 있으며 학생들의 필요와 상황에 적응하는 데 능숙합니다.

Duodiyun의 지도에 따라 학생들이 마법을 걸 때 그녀는 수업 환경과 필요에 따라 학생들이 최대한의 잠재력을 발휘하도록 돕습니다. 그녀의 마력은 다른 클래스의 영향력을 오염시키지 않기 때문에 학생들은 자신의 마법 기술을 더 자유롭게 탐색하고 개발할 수 있습니다.

이 이야기는 싱글톤과 다중 인스턴스가 고유한 장점과 단점이 있음을 알려줍니다. 싱글톤의 장점은 중앙 집중식 관리 및 권한에 있지만 변수 오염 문제가 발생하기 쉽습니다. 여러 인스턴스는 다양한 시나리오에 대한 맞춤형 서비스를 제공하여 변수 오염의 잠재적인 문제를 방지할 수 있습니다.

소프트웨어를 설계할 때 특정 요구 사항에 따라 적절한 모드를 선택해야 합니다. Singleton은 전역적으로 통합된 액세스 및 공유 리소스가 필요한 상황에 사용할 수 있습니다. 유연성이 필요하고 변수 오염이 없는 시나리오의 경우 여러 사례가 더 나은 선택입니다. 싱글톤과 다중 인스턴스의 장점과 단점의 균형을 유지하고 특정 요구 사항에 따라 현명한 선택을 해야 합니다.

논쟁:

ParamAction.java

package com.csdn.xw.aop.beanLife;

import java.util.List;

public class ParamAction {
	private int age;
	private String name;
	private List<String> hobby;
	private int num = 1;
	// private UserBiz userBiz = new UserBizImpl1();

	public ParamAction() {
		super();
	}

	public ParamAction(int age, String name, List<String> hobby) {
		super();
		this.age = age;
		this.name = name;
		this.hobby = hobby;
	}

	public void execute() {
		// userBiz.upload();
		// userBiz = new UserBizImpl2();
		System.out.println("this.num=" + this.num++);
		System.out.println(this.name);
		System.out.println(this.age);
		System.out.println(this.hobby);
	}
}

spring-context.xml

  <bean id="paramAction" class="com.csdn.xw.aop.beanLife.ParamAction">
        <constructor-arg name="name" value="三丰"></constructor-arg>
        <constructor-arg name="age" value="21"></constructor-arg>
        <constructor-arg name="hobby">
            <list>
                <value>抽烟</value>
                <value>烫头</value>
                <value>大保健</value>
            </list>
        </constructor-arg>
    </bean>

테스트 테스트 클래스

package com.csdn.xw.aop.beanLife;

import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

/*
 * spring	bean的生命週期
 * spring	bean的單例多例
 */
public class Demo2 {
	// 体现单例与多例的区别
	@Test
	public void test1() {
		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
//		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
		ParamAction p1 = (ParamAction) applicationContext.getBean("paramAction");
		ParamAction p2 = (ParamAction) applicationContext.getBean("paramAction");
		// System.out.println(p1==p2);
		p1.execute();
		p2.execute();
		
//		单例时，容器销毁instanceFactory对象也销毁；多例时，容器销毁对象不一定销毁；
		applicationContext.close();
	}

	// 体现单例与多例的初始化的时间点 instanceFactory
	@Test
	public void test2() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
	}

	// BeanFactory会初始化bean对象，但会根据不同的实现子类采取不同的初始化方式
	// 默认情况下bean的初始化，单例模式立马会执行，但是此时XmlBeanFactory作为子类，单例模式下容器创建，bean依赖没有初始化，只有要获取使用bean对象才进行初始化
	@Test
	public void test3() {
		// ClassPathXmlApplicationContext applicationContext = new
		// ClassPathXmlApplicationContext("/spring-context.xml");

		Resource resource = new ClassPathResource("/spring-context.xml");
		BeanFactory beanFactory = new XmlBeanFactory(resource);
//		InstanceFactory i1 = (InstanceFactory) beanFactory.getBean("instanceFactory");
		
	}

}

작업 결과:

이번에는 scope="prototype"의 여러 인스턴스를 수동으로 설정하고 살펴보겠습니다.

5.3 단일 인스턴스 JavaBean과 다중 인스턴스 JavaBean은 언제 생성됩니까?

 단일 사례: JavaBean이 Spring 컨텍스트로 초기화되고 컨테이너의 개체가 생성되고 컨테이너의 개체가 종료됩니다.

 여러 예: JavaBean은 사용 시 생성되며 JVM 이후 소멸됩니다.

논쟁:

InstanceFactory.java

package com.csdn.xw.aop.beanLife;

public class InstanceFactory {
	public void init() {
		System.out.println("初始化方法");
	}

	public void destroy() {
		System.out.println("销毁方法");
	}

	public void service() {
		System.out.println("业务方法");
	}
}

spring-context.xml

  <bean id="instanceFactory" class="com.csdn.xw.aop.beanLife.InstanceFactory"
          scope="prototype" init-method="init" destroy-method="destroy"></bean>

위의 xml 구성에 여러 인스턴스가 있는 것을 볼 수 있습니다. test2를 호출하여 "Bean 초기화"가 완료되었는지 확인하겠습니다.

Spring의 context 객체만 가져오고 Bean 객체는 가져오지 않았기 때문에 없는 것을 알 수 있습니다.

 이때 Bean 객체 획득 여부와 상관없이 JavaBean이 생성된 것을 확인하였다.

요약: 컨테이너가 생성된 후 싱글톤이 초기화되는 이유는 무엇입니까? 싱글톤의 아이디어는 언제 사용하든 상관없이 생성하는 것이기 때문에 브라우저가 생성 요청을 보낼 때까지 기다리면 사용자 경험이 크게 줄어듭니다. 어쨌든 생성될 뿐입니다. 프로젝트를 시작할 때 만들어 보면 어떨까요?자, 시작 프로젝트에서 시간이 많이 걸립니다. 인스턴스가 여러 개인 경우 100개 있으면 100개를 생성합니까? 천 개를 만들면 천 개가 있는데 하나만 사용하면 어떻게 됩니까? 나머지 999개는 낭비이므로 여러 인스턴스는 사용할 때만 생성됩니다.

5.4 싱글톤을 사용할 때 JavaBean을 초기화합니까?

BeanFactory는 bean객체를 초기화하지만 다른 구현 서브클래스에 따라 다른 초기화 방법을 채택한다.기본적으로 bean 초기화는 싱글톤 모드에서 즉시 실행되지만 이때는 XmlBeanFactory가 서브클래스로 사용된다.컨테이너 싱글톤 모드에서 생성, 빈 종속성은 초기화되지 않고 초기화될 bean 객체를 얻기 위해서만 초기화됩니다.

논쟁:

test3를 호출하여 결과 확인

XmlBeanFactory의 서브클래스로 컨테이너는 싱글톤 모드로 생성되고 빈 의존성은 초기화되지 않으니 가져와서 사용해보자

 이 시점에서 Bean이 생성됩니다.

내 공유는 여기까지입니다. 토론하고 소통할 수 있는 댓글 영역에 오신 것을 환영합니다! !

유익하셨다면 손가락 꾸욱 부탁드립니다♥ ♥