[Spring] 스프링 컨테이너 생성

안녕하세요? 주니하랑 입니다.

오늘은 Spring의 스프링 컨테이너와 스프링 빈에 대해서 공부 해 보도록 하는 것이에요.

이 내용은 인프런 - 김영한 강사님의 스프링 핵심 원리를 공부하면서 정리 하였습니다.

 

📋 목차

---

01. [Spring] 스프링 핵심 원리
02. [Spring] 좋은 객체 지향 설계의 5가지 원칙 (SOLID)
03. [Spring] 객체 지향 설계와 스프링   
04. [Spring] OCP와 DIP 고려하기
05. [Spring] 객체 지향 원리 적용 - 새로운 할인 정책 개발
06. [Spring] AppConfig 리팩터링    
07. [Spring] Ioc, DI Container  
08. [Spring] 스프링 컨테이너 생성  
09. [Spring] 싱글톤 컨테이너  
10. [Spring] Component Scan And Auto wired Start
11. [Spring] 의존관계 주입 방법    
12. [Spring] Bean Life Cycle Call Back
13. [Spring] Bean Scope

 

 

 

---

 

 

 

📌 Spring Container Create

---

 

먼저 스프링 컨테이너가 생성되는 과정부터 알아봐야 하는 것이에요.

AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);

 

ApplicationContext를 Spring Container라고 하는 것이에요. 또한 이것은 Interface랍니다!

Spring Container는 XML 기반으로 만들수도 있고, Annotaion 기반의 Java 설정 Class로 만들 수도 있는 것이에요.

이 전에 AppConfig.java를 사용했던 방식이 바로 Annotaion 기반의 Java 설정 Class로 Spring Container를 만든 것이에요.

Java 설정 Class를 기반으로 Spring Container(ApplicationContext)를 만들어 볼까요?

1. new AnnotaionConfigApplicationContext(AppConfig.class);
2. 이 Class는 ApplicationContext Interface의 구현체

 

참고 : 정확히는 Spring Container를 부를 때, BeanFactory, ApplicationContext로 구분해서 이야기 한다.

BeanFactory를 직접 사용하는 경우는 거의 없으므로, 일반적으로 ApplicationContext를 Spring Container라고 한다.

 

 

    📍Spring Container 생성 과정

         👉 RateDiscountPolicy 추가

 

 

new AnnotaionConfigApplicationContext(AppConfig.class);

 

위와 같이 Spring Container를 생성할 때 구성 정보(인자값에 들어가는 구성 정보를 담은 Class)를 지정해주어야 하는 것이에요.

여기서는 AppConfig.class로 사용하였죠.

 

         👉 Spring Bean 등록

 

 

스프링 컨테이너는 파라미터로 넘어 온 설정 클래스 정보를 이용하여 스프링 빈에 등록하는 것이에요.

 

여기서 빈 이름은 Method의 이름을 사용하게 되며, 직접 부여할 수도 있는 것이에요. 바로 아래 코드처럼요!

@Bean(name = "BeanName입력")

 

하지만, 조심해야 하는 것이 있는 것이에요. Bean 이름은 항상 다른 이름을 부여해야 하는 것이에요.

같은 이름을 부여하면 Spring Container는 다른 빈을 무시해 버리거나, 기존 빈을 덮어쓰기 해 버리거나, 설정에 따라 오류가 발생하는 것이에요.

 

         👉 Spring Bean 의존관계 설정 - 준비

 

 

         👉 Spring Bean 의존관계 설정 - 완료

 

 

스프링 컨테이너는 설정 정보를 참고해서 의존관계를 주입(DI)하는 것이에요.

단순히 Java의 Method를 호출하는 것 같이 보이지만, 차이가 있는 것이에요.

 

참고로 스프링 빈을 생성하고, 의존관계를 주입하는 단계가 나눠져 있는 것이에요. 그런데, 이렇게 Java 코드로 스프링 빈을 등록하면 생성자를 호출하면서 의존관계 주입도 한번에 처리되어 버리는 것이에요. 이번 공부에서는 이해를 돕기 위해 개념적으로 나눠서 작성 해 볼게요!

 

정리하자면

스프링 컨테이너를 생성하고, 설정(구성) 정보를 참고해서 스프링 빈도 등록하고, 의존관계도 설정한 것이에요.

이제 한번 Data를 조회 해 봐요 우리!

 

         👉 컨테이너에 등록된 모든 빈 조회

 

package hello.core.beanfind;


import hello.core.AppConfig;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class ApplicationContextInfoTest {

    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);

    @Test @DisplayName("모든 Bean 출력하기")
    void findAllBean() {
        String[] beanDefinitionNames = ac.getBeanDefinitionNames();

        for (String beanDefinitionName : beanDefinitionNames) {
            Object bean = ac.getBean(beanDefinitionName);

            System.out.println("name = " + beanDefinitionName + "\n object = " + bean);
            System.out.println("----------------------------------------------------------------");
        }
    }

    @Test @DisplayName("Application Bean 출력하기")
    void findApplicationBean() {
        String[] beanDefinitionNames = ac.getBeanDefinitionNames();

        for (String beanDefinitionName : beanDefinitionNames) {
            BeanDefinition beanDefinition = ac.getBeanDefinition(beanDefinitionName);  // getBeanDefinition 이것은 Bean에 대한 Meta Data 정보를 가지고 있다.
            // ROLE_INFRASTRUCTOR는 스프링 내부에서 사용하는 Bean에 대해 정보를 가지고 있다.
            if (beanDefinition.getRole() == BeanDefinition.ROLE_APPLICATION) {  // getRole Method에서 ROL_AAPLICATON은 Spring이 사전에 등록한 Bean이 아닌 사용자가 생성한 Bean 혹은 외부 Library 라는 뜻

                Object bean = ac.getBean(beanDefinitionName);

                System.out.println("name = " + beanDefinitionName + "\n object = " + bean);
                System.out.println("----------------------------------------------------------------");

            }
        }
    }
} // Class 끝

 

1. 모든 빈 출력
   • 실행 시 Spring에 등록된 모든 빈 정보 출력
   • AnnotationConfigApplicationContext.getBeanDefinitionNames() : 스프링에 등록된 모든 빈 이름 조회 시 사용
   • AnnotationConfigApplicationContext.getBean() : 빈 이름으로 빈 객체(인스턴스) 조회 시 사용
2. Application Bean Output
   • 스프링 내부에서 사용하는 빈을 제외하고, 우리가 만든 빈만 출력하는 방법
   • 스프링 내부에서 사용하는 빈은 getRole()을 사용하여 구분 가능
     • ROLE_APPLICATION : 일반적으로 개발자가 정의한 빈
     • ROLE_INFRASTRUCTURE : 스프링 내부에서 사용하는 빈

 

 

 

         👉 Spring Bean 조회 - 기본

 

스프링 컨테이너에서 스프링 빈을 찾는 가장 기본적인 방법은 무엇일까요?

1. AnnotationConfigApplicationContext.getBean(BeanName, BeanType)
2. AnnotationConfigApplicationContext.getBean(BeanType)
3. 조회 대상 스프링 빈이 없을 경우 예외 발생
   • NoSuchBeanDefinitionException : No bean named '~~~~' available

 

package hello.core.beanfind;

import hello.core.AppConfig;
import hello.core.member.MemberService;
import hello.core.member.MemberServiceImpl;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class ApplicationContextBasicFindTest {

    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);

    @Test @DisplayName("Bean Name으로 조회")
    void findBeanName() {
        MemberService memberService = ac.getBean("memberService", MemberService.class);

        Assertions.assertThat(memberService).isInstanceOf(MemberServiceImpl.class);
    }  // findBeanName() 끝

    @Test @DisplayName("이름 없이 타입으로만 조회")
    void findBeanByType() {
        MemberService memberService = ac.getBean(MemberService.class);

        Assertions.assertThat(memberService).isInstanceOf(MemberServiceImpl.class);
    } // findBeanByType() 끝

    @Test @DisplayName("구체 타입으로 조회")
    void findBeanName1() {  // 이렇게 구체화를 통해 조회를 하는 것은 좋지 않다. 왜냐하면? 추상화에 의존해야 하는데, 구체화에 의존하기 때문
        MemberService memberService = ac.getBean("memberService", MemberServiceImpl.class);

        Assertions.assertThat(memberService).isInstanceOf(MemberServiceImpl.class);
    } // findBeanByType() 끝

    @Test @DisplayName("빈 이름으로 조회가 되지 않을 때")
    void findBeanByNameX() { // Test를 만들 때는 실패에 대한 것도 만들어야 한다.
        // ac.getBean("xxxx", MemberService.class); MemberService에 "xxxx"라는 이름으로 된 Bean이 없기 때문에 NoSuchBeanDefinitionException Exception이 뜰 것이다.

        org.junit.jupiter.api.Assertions.assertThrows(NoSuchBeanDefinitionException.class,
                () -> ac.getBean("xxxx", MemberService.class)); // 오른쪽에 인자값이 실행되면 왼쪽 인자값 Exception이 터져야 Test 정상이 나온다.
    } // findBeanByNameX() 끝

} // Class 끝

 

참고로 구체 Type으로 조회하면 된다 안된다? 안 된다! 왜 안된다? 역할과 구현을 나눠야 하고, DIP, OCS 위반이다!

그러므로, 변경 시 유연성이 떨어지게 되기 때문에 주의 해야 하는 것이에요!

 

 

 

         👉 Spring Bean 조회 - 동일한 타입이 둘 이상일 때

 

만약 타입으로 조회할 때, 같은 타입의 스프링 빈이 둘 이상이면 예외가 발생하는 것이에요. 이를 해결하기 위해서는 빈 이름을 지정하는 방법이 있을것이에요.

AnnotationConfigApplicationContext.getBeanOfType()을 사용하게 되면 해당 타입의 모든 빈을 조회할 수 있답니다!

 

 

package hello.core.beanfind;

import hello.core.member.MemberRepository;
import hello.core.member.MemoryMemberRepository;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.NoUniqueBeanDefinitionException;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Map;

public class ApplicationContextBeanFindTest {

    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(SameBeanConfig.class);

    @Configuration
    static class SameBeanConfig { // Bean 이름이 다르고, 객체 타입(인스턴스 타입)이 같게 할 수 있다.

        @Bean
        public MemberRepository memberRepository1() {
            return new MemoryMemberRepository();
        } // memberRepository1() 끝

        @Bean
        public MemberRepository memberRepository2() {
            return new MemoryMemberRepository();
        } // memberRepository2() 끝
    } // SameBeanConfig Class 끝

    @Test @DisplayName("타입으로 조회 시 같은 타입이 둘 이상 있으면, 중복 오류 발생")
    void findBeanByTypeDuplicate() {
        MemberRepository bean = ac.getBean(MemberRepository.class);

        Assertions.assertThrows(NoUniqueBeanDefinitionException.class, () -> ac.getBean(MemberRepository.class));
    } // findBeanByTypeDuplicate() 끝

    @Test @DisplayName("타입으로 조회 시 같은 타입이 둘 이상 있으면, Bean 이름 지정 시 해결")
    void findBeanByName() {
       MemberRepository memberRepository = ac.getBean("memberRepository1", MemberRepository.class);

        org.assertj.core.api.Assertions.assertThat(memberRepository).isInstanceOf(MemberRepository.class);

    } // findBeanByName() 끝

    @Test @DisplayName("특정 타입을 모두 조회하기")
    void findAllBeanByType() {
        Map<String, MemberRepository> beanOfType = ac.getBeansOfType(MemberRepository.class);

        for (String key : beanOfType.keySet()) {
            System.out.println("key = " + key +  "\n Value = " + beanOfType.get(key));
        }

        System.out.println("beanOfType = " + beanOfType);

        org.assertj.core.api.Assertions.assertThat(beanOfType.size()).isEqualTo(2);
    } // findAllBeanByType() 끝
} // Class 끝

 

 

 

         👉 Spring Bean 조회 - 상속 관계

 

부모 타입으로 조회하면 자식 타입도 함께 조회되는 것이에요.

따라서 모든 자바 객체의 최고 부모 아담과 하와 격인 Java의 Object 타입으로 조회하면 모든 스프링 빈도 조회가 되는 것이에요.

 

반응형

 

package hello.core.beanfind;

import hello.core.discount.DiscountPolicy;
import hello.core.discount.FixDiscountPolicy;
import hello.core.discount.RateDiscountPolicy;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.NoUniqueBeanDefinitionException;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Map;

public class ApplicationContextExtendsFindTest {

    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(TestConfig.class);

    @Configuration
    static class TestConfig {
        @Bean
        public DiscountPolicy rateDiscountPolicy() {
            return new RateDiscountPolicy();
        } // rateDiscountPolicy() 끝

        @Bean
        public DiscountPolicy fixDiscountPolicy() {
            return new FixDiscountPolicy();
        } // fixDiscountPolicy() 끝

    } // TestConfig Class 끝

    @Test
    @DisplayName("부모 타입으로 조회 시 자식이 둘 이상 있으면, 중복 오류 발생")
    void findBeanByParentTypeDuplicate() {
//        DiscountPolicy bean = ac.getBean(DiscountPolicy.class);

        Assertions.assertThrows(NoUniqueBeanDefinitionException.class, () -> ac.getBean(DiscountPolicy.class));
    } // findBeanByParentTypeDuplicate() 끝

    @Test
    @DisplayName("부모 타입 조회 시 자식이 둘 이상 있으면, Bean 이름으로 조회하면 된다.")
    void findBeanByParentTypeBeanName() {
        DiscountPolicy bean = ac.getBean("rateDiscountPolicy", DiscountPolicy.class);

        org.assertj.core.api.Assertions.assertThat(bean).isInstanceOf(RateDiscountPolicy.class);
    } // findBeanByParentTypeBeanName() 끝

    @Test
    @DisplayName("부모 타입 조회 시 자식이 둘 이상 있으면, 특정 하위 타입으로 조회 가능(구현체를 의존하기 때문에 좋지 않은 방법)")
    void findBeanBySubType() {
        RateDiscountPolicy bean = ac.getBean(RateDiscountPolicy.class);

        org.assertj.core.api.Assertions.assertThat(bean).isInstanceOf(RateDiscountPolicy.class);
    } // findBeanBySubType() 끝

    @Test
    @DisplayName("부모 타입으로 전부 조회")
    void findAllBeanByPrentType() {
        Map<String, DiscountPolicy> beansOfType = ac.getBeansOfType(DiscountPolicy.class);

        org.assertj.core.api.Assertions.assertThat(beansOfType.size()).isEqualTo(2);

        for (String key : beansOfType.keySet()) {
            System.out.println("key = " + key + "\n Value = " + beansOfType.get(key));
        } // for문 끝
    } // findAllBeanByPrentType() 끝

    @Test
    @DisplayName("자바의 아담 Object 타입으로 전부 조회")
    void findAllBeanByObjectType() {
        Map<String, Object> beansOfType = ac.getBeansOfType(Object.class);

        org.assertj.core.api.Assertions.assertThat(beansOfType.size()).isEqualTo(16);

        for (String key : beansOfType.keySet()) {
            System.out.println("key = " + key + "\n value = " + beansOfType.get(key));
        } // for문 끝
    } // findAllBeanByObjectType() 끝
} // Class 끝

 

 

         👉 BeanFactory와 ApplicationContext

 

 

BeanFactory

1. 스프링 컨테이너의 최상위 인터페이스
2. 스프링 빈을 관리하고, 조회하는 역할
3. getBean() 제공
4. 앞 써 확인했던 모든 기능은 BeanFactory가 제공하는 기능

 

 

 

ApplicationContext

1. BeanFactory 기능을 모두 상속 받아 제공
2. 빈을 관리하고 검색하는 기능을 BeanFactory가 제공
3. Application 개발 시 빈을 관리하고, 조회하는 기능은 물론 수 많은 부가 기능 필요한데, 이를 제공

 

• MessageSource
  • 메시지소스를 활용한 국제화 기능 : 예를 들어 한국에서 접속하면 한국어로 보이게 하고, 다른 언어권에서 접속하면 그 나라의 언어로 출력
• EnvironmentCapable
  • 환경 변수 : 개인 PC에서 혹은 개발 서버에서 운영 서버에서 하는 일이 모두 다르 듯 이를 구분해서 처리
• ApplicationEventPublisher
  • 애플리케이션 이벤트 : 이벤트를 발행하고, 구독하는 모델을 편리하게 지원
• ResourceLoader
  • 편리한 자원 조회 : File, Class Path, Remote(외부) 등에서 자원을 편리하게 조회할 수 있도록 지원

 

정리하자면

1. ApplicationContext는 BeanFactory의 기능 상속
2. ApplicationContext는 빈 관리 기능과 더불어 편리한 부가 기능 제공
3. BeanFactory를 직접 사용할 일은 거의 없고, 부가 기능이 포함된 ApplicationContext 사용
4. BeanFactory나 ApplicationContext가 바로 스프링 컨테이너

 

 

 

 

    📍다양한 설정 형식 지원 - Java Code, XML

 

스프링 컨테이너는 다양한 형식의 설정 정보를 받아드릴 수 있게 유연하게 만들어 놓은 것이에요.

우리는 이것을 통해 자바 코드, XML, Groovy 등을 사용할 수 있답니다!

 

 

 

 

         👉 Annotation 기반 Java Code Configuration 사용

 

new AnnotaionConfigApplicationContext(AppConfig.class);

AnnotationConfigApplicationContext 클래스를 사용하면서 자바 코드로 이루어진 설정 정보를 넘기면 되는 것이에요.

 

 

        👉 XML Configuration 사용

 

최근에는 스프링 부트를 많이 사용하면서 XML 기반 설정은 잘 사용하지 않는다고 합니다!

하지만, 아직 많은 레거시 프로젝트들이 XML로 이뤄져 있고, 또 XML을 사용하면 Compile 없이 빈 설정 정보를 변경할 수 있는 장점도 있는 것이에요.

GenericXmlApplicationContext를 사용하며, xml 설정 파일을 넘기면 되는 것이에요.

 

 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id = "memberService" class = "hello.core.member.MemberServiceImpl">
        <constructor-arg name = "memberRepository" ref = "memberRepository" />
    </bean>

    <bean id = "memberRepository" class = "hello.core.member.MemoryMemberRepository"/>

    <bean id = "orderService" class = "hello.core.orderImsi.OrderServiceImpl">
        <constructor-arg name = "memberRepository" ref = "memberRepository"/>
        <constructor-arg name = "discountPolicy" ref = "discountPolicy"/>
    </bean>

    <bean id = "discountPolicy" class = "hello.core.discount.RateDiscountPolicy"/>
</beans>

 

 

package hello.core.xml;

import hello.core.member.MemberService;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;

public class XmlAppContextTest {

    @Test void xmlAppContext() {
        ApplicationContext ac = new GenericXmlApplicationContext("appConfig.xml");

        MemberService memberService = ac.getBean("memberService", MemberService.class);

        Assertions.assertThat(memberService).isInstanceOf(MemberService.class);
    }
}

 

XML 기반의 appConfig.xml 스프링 설정 정보와 자바 코드로 된 AppConfig.java 설정 정보를 비교해 보면 거의 똑같은 것이에요.

 

Spring 공식 참고 문서

Spring Framework

 

 

 

    📍스프링 빈 설정 메타 정보 - BeanDefintion

 

스프링은 어떻게 이런 다양한 설정 형식을 지원하는 것일까요? 그 중심에는 BeanDefinition이라는 추상화로 이뤄진 친구가 있는 것이에요.

한마디로 이것 역시 '역할과 구현을 개념적으로 나눈 것' 이지요.

이것은 XML을 읽어서 BeanDefinition을 만들면 되는 것이에요. 혹은 자바 코드를 읽어 BeanDefinition을 만들면 되는 것이지요.

스프링 컨테이너는 자바 코드인지 XML인지 상관 없어요! 'I don't care'인 것이이죠. 오직 BeanDefinition만 알면 되는 것이에요.

BeanDefinition을 빈 설정 Meta Information (메타 정보)라고 하는 것이에요.

자바 코드에서는 @Bean XML에서는 <bean>으로 각각 하나씩 Meta Information이 생성된답니다!

스프링 컨테이너는 이 메타정보를 기반으로 스프링 빈을 생성하는 것이에요.

 

 

AnnotaionConfigApplicationContext는 AnnotatedBeanDefinitionReader를 사용하여 AppConfig.class를 읽어 온 뒤 BeanDefinition을 만드는 것이에요.

또한, GenericXmlApplicationContext는 XmlBeanDefinitionReader를 사용하여 appConfig.xml을 읽어 온 뒤 BeanDefinition을 만드는 것이에요.

만약 개발자가 스스로 새로운 형식의 설정 정보가 추가하려면, XxxBeanDefinitionReader를 만들어 BEanDefinition을 만들면 되는 것이에요.

 

 

        👉 BeanDefinition Information

1. BeanClassName : 생성할 빈의 클래스 이름(자바 설정처럼 Factory 역할의 빈을 사용하면 없음)
2. factoryBeanName : Factory 역할의 빈을 사용할 경우 이름 예:) appConfig
3. factoryMethodName : 빈을 생성할 Factory Method 지정 예:) memberService
4. Scope : 싱글톤(Defulat Value)
5. lazyinit : 스프링 컨테이너를 생성할 때, 빈을 생성하는 것이 아니라, 실제 빈을 사용할 때까지 최대한 생성을 지연처리 하는지 여부
   JPA에서 N + 1문제에 해결 방안에서 또 나오는 개념
6. InitMethodName : 빈을 생성하고, 의존관계를 적용한 뒤 호출되는 초기화 Method 이름
7. DestoryMethodName : 빈의 생명주기가 끝나서 제거하기 직전 호출되는 Method 이름
8. Constructor arguments, Properties : 의존관계 주입에서 사용 (자바 설정처럼 Factory 역할의 빈 사용 시 없음)

 

package hello.core.beandefinition;

import hello.core.AppConfig;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class BeanDefinitionTest {

    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);

    @Test @DisplayName("Bean Configuration Meta Information Check")
    void findApplicationBean() {

        String[] beanDefinitionNames = ac.getBeanDefinitionNames();

        for (String beanDefinitionName : beanDefinitionNames) {
           BeanDefinition beanDefinition = ac.getBeanDefinition(beanDefinitionName);

           if (beanDefinition.getRole() == BeanDefinition.ROLE_APPLICATION) {
               System.out.println("beanDefinitionName = " + beanDefinitionName + "\n beanDefinition 자체 출력 = " + beanDefinition);
           } // if 문 끝
        } // for 문 끝

    } // findApplicationBean() 끝

} // Class 끝

 

 

package hello.core.beandefinition;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.support.GenericXmlApplicationContext;

public class BeanDefinitionTestForXml {

    // 변수 자료형 타입을 ApplicationContext로 하지 않는 이유는 그렇게 하면 getBeanDefinition을 사용할 수 없기 때문
    GenericXmlApplicationContext ac = new GenericXmlApplicationContext("appConfig.xml");

    @Test @DisplayName("Bean Configuration Meta Information Check For XML")
    void findApplicationBean() {

        String[] beanDefinitionNames = ac.getBeanDefinitionNames();

        for (String beanDefinitionName : beanDefinitionNames) {
            BeanDefinition beanDefinition = ac.getBeanDefinition(beanDefinitionName);

            if (beanDefinition.getRole() == BeanDefinition.ROLE_APPLICATION) {
                System.out.println("beanDefinitionName = " + beanDefinitionName + "\n beanDefinition 자체 출력 = " + beanDefinition);
            } // if 문 끝
        } // for 문 끝

    } // findApplicationBean() 끝
} // Class 끝

 

정리하자면

BeanDefinition을 직접 생성하여 스프링 컨테이너에 등록할 수도 있답니다! 하지만, 이렇게 하는 경우는 거의 없다고 하네요!

가끔 스프링 코드나 스프링 관련 오픈 소프 코드를 보면 BeanDefiniton이라는 것이 보일 때가 있는데, 이 때 오늘 공부한 내용을 떠올리면 되는 것이에요!

 

 

 

---

 

주니하랑의 글이 마음에 드셨나요? 구독과 공감! 그리고, 댓글 그리고 방명록은 주니하랑에게 많은 힘이 됩니다