[스프링 핵심 원리 - 기본편] #4. 스프링 컨테이너와 스프링 빈

[Pracrobo]

Spring Container 생성

---

스프링 컨테이너가 생성되는 과정을 알아보자

ApplicationContext applicationContext =  new AnnotationConfigApplicationContext(AppConfig.class);

• ApplicationContext를 스프링 컨테이너라 한다.

• ApplicationContext 는 인터페이스다. (다형성이 적용됨)

• 스프링 컨테이너는 XML기반으로 만들 수 있고 Annotation 기반의 자바 설정 클래스로 만들 수 있다.(요즘엔 Annotation기반으로 많이 사용)

• 직전에 AppConfig를 사용했던 방식이 Annotation기반의 자바 설정 클래스로 스프링 컨테이너를 만든 것이다.

• 자바 설정 클래스를 기반으로 스프링 컨테이너(ApplicatoinContext)를 만들어보자

  • new AnnotationConfigApplicationContext(AppConfig.class); ( 파라미터를 AppConfig.class로)
  • 이 클래스는 ApplicationContext 인터페이스의 구현체이다.

**스프링 컨테이너를 부를 때 BeanFactory, ApplicationContext로 구분해서 이야기한다.
뒤에서 설명하고 BeanFactory를 직접 사용하는 경우는 거의 없으므로 일반적으로 ApplicationContext를 스프링 컨테이너라 한다.

스프링 컨테이너의 생성 과정

1. new AnnotationConfigApplicationContext (AppConfig.class) : 스프링 컨테이너 생성(AppConfig.class)
2. 스프링 컨테이너 안에 빈 저장소가 있는데 빈 이름(key), 객체(value)로 되어있다(그림)

• 스프링 컨테이너를 생성할 때는 구성 정보를 지정해주어야 한다.
• 여기서는 AppConfig.class를 구성 정보로 지정했다.

3. 스프링 컨테이너를 생성할때는 구성 정보를 지정해주어야 한다(AppConfig.class, 파라미터로 넘긴것)
   스프링 빈 저장소에 빈 이름과 빈 객체를 저장

4. @bean을 호출

• key (빈 이름): 메서드 이름
  • 빈 이름은 메서드 이름을 사용한다.
  • 빈 이름을 직접 부여할 수도 있다.
  • @bean (name=”memberService2”)

주의: “빈 이름은 항상 다른 이름을 부여” 해야 한다. 같은 이름을 부여하면 다른 빈이 무시되거나 기존 빈을 덮어버리거나 설정에 따라 오류가 발생한다.

• new 반환 객체 : value (빈 객체)

5. 의존관계를 설정하기

6. 의존관계를 넣어주기

• 동적인 의존 관계를 스프링이 설정해준다.

• 실제 스프링빈이 연결이 된다.

• 스프링 컨테이너는 설정 정보를 참고해서 의존관계를 주입(DI)한다.

• 스프링 빈을 생성하고 의존 관계를 주입하는 단계가 나눠져 있다.
  그런데 이렇게 자바 코드로 스프링 빈을 등록하면 생성자를 호출하면서 의존관계 주입도 한꺼번에 처리된다. 여기서는 개념적으로 이해하기 쉽게 나눠서 설명했다.

정리

• 스프링 컨테이너를 생성하고 설정(구성)정보를 참고해서 스프링 빈도 등록하고 의존관계도 설정했다.
• 이제 스프링 컨테이너에서 데이터를 조회해보자.

코드

package hello.core;

import hello.core.discount.DiscountPolicy;
import hello.core.discount.FixDiscountPolicy;
import hello.core.discount.RateDiscountPolicy;
import hello.core.member.MemberService;
import hello.core.member.MemberServiceImpl;
import hello.core.member.MemoryMemberRepository;
import hello.core.order.OrderService;
import hello.core.order.OrderServiceImpl;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {
    @Bean
    public MemberService memberService() {
        return new MemberServiceImpl(memberRepository());
    }
    @Bean
    public static MemoryMemberRepository memberRepository() {
        return new MemoryMemberRepository();
    }
   @Bean
    public OrderService orderService() {
        return new OrderServiceImpl(memberRepository(), discountPolicy());
    }
    @Bean
    public DiscountPolicy discountPolicy(){
       return new FixDiscountPolicy();
       // return new RateDiscountPolicy();
    }
}

정리

스프링 컨테이너를 생성하고, 설정(구성) 정보를 참고해서 스프링 빈도 등록하고 의존관계도 설정했다.이제 스프링 컨테이너에서 데이터를 조회해본다

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

---

class ApplicationContextInfoTest { //public을 안써도 된다 >> JUnit5 이상
    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);

    @Test
    @DisplayName("모든 빈 출력하기")
    void findAllBean() {
        String[] beanDefinitionNames = ac.getBeanDefinitionNames();
        for(String beanDefinitionName : beanDefinitionNames) {
            Object bean = ac.getBean(beanDefinitionName);
            System.out.println("name=" + beanDefinitionName + "object");

        }
    }

결과를 좀 다르게 하기 위해서 , 를 넣었다.

    @Test
    @DisplayName("애플리케이션 빈 출력하기")
    void findApplicationBean() {
        String[] beanDefinitionNames = ac.getBeanDefinitionNames();
        for(String beanDefinitionName : beanDefinitionNames) {
            BeanDefinition beanDefinition = ac.getBeanDefinition(beanDefinitionName);

            //Role ROLE_APPLICATION:  직접 등록한 애플리케이션 빈
            if(beanDefinition.getRole() == BeanDefinition.ROLE_APPLICATION) {
                Object bean = ac.getBean(beanDefinitionName);
                System.out.println("name = " + beanDefinitionName + ", object = " + bean);
            }
        }
    }

결과

• 우리가 등록한 5개의 bean이 출력된다.

    @Test
    @DisplayName("애플리케이션 빈 출력하기")
    void findApplicationBean() {
        String[] beanDefinitionNames = ac.getBeanDefinitionNames();
        for(String beanDefinitionName : beanDefinitionNames) {
            BeanDefinition beanDefinition = ac.getBeanDefinition(beanDefinitionName);

        
            //Role ROLE_INFRASTRUCTURE : 스프링이 내부에서 사용하는 빈
            if(beanDefinition.getRole() == BeanDefinition.ROLE_INFRASTRUCTURE) {
                Object bean = ac.getBean(beanDefinitionName);
                System.out.println("name = " + beanDefinitionName + ", object = " + bean);
            }
        }
    }

결과

• 모든 빈 출력하기
  • 실행하면 스프링에 등록된 모든 빈 정보를 출력할 수 있다.
  • ac.getBeanDefinitionNames() : 스프링에 등록된 모든 빈 이름을 조회한다.
  • ac.getBean() : 빈 이름으로 빈 객체(인스턴스)를 조회한다.
• 애플리케이션 빈 출력하기
  • 스프링이 내부에서 사용하는 빈은 제외하고, 내가 등록한 빈만 출력해보자.
  • 스프링이 내부에서 사용하는 빈은 getRole()로 구분할 수 있다.
    • ROLE_APPLICATION : 일반적으로 사용자가 정의한 빈
    • ROLE_INFRASTRUCTURE : 스프링이 내부에서 사용하는 빈

스프링 빈 조회 : 기본

---

스프링 컨테이너에서 스프링 빈을 찾는 가장 기본적인 조회 방법
- ac.getBean(빈이름, 타입)
- ac.getBean(타입)

• 조회 대상 스프링 빈이 없으면 예외 발생
  NoSuchBeanDefinitionException: No bean named 'xxxxx' available

package hello.core.beanfind;

import hello.core.AppConfig;
import hello.core.member.MemberService;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class ApplicationContextBasicFindTest {

    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);

    @Test
    @DisplayName("빈 이름으로 조회")
    void  findBeanByName() {
        MemberService memberService= ac.getBean("memberService", MemberService.class);
        System.out.println("memberService = " + memberService);
        System.out.println("memberService.getClass() = "+ memberService.getClass());
    }
}

    @Test
    @DisplayName("빈 이름으로 조회")
    void  findBeanByName() {
        MemberService memberService= ac.getBean("memberService", MemberService.class);
        Assertions.assertThat(memberService).isInstanceOf(MemberServiceImpl.class);
        //성공 확인 후에 assertions 지워서 static import 만든다.

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

    }
//"name"을 없애고 타입만으로 조회한다.

    @Test
    @DisplayName("구체 타입으로 조회")
    void  findBeanByName2() {
        MemberService memberService= ac.getBean("memberService", MemberServiceImpl.class);
        assertThat(memberService).isInstanceOf(MemberServiceImpl.class);

    }
    
    
    //ServiceImpl이라는 구체타입으로 조회한다.
    // 구체 타입으로 조회하면 변경시 유연성이 떨어진다. (역할에 의존해야 하는데 구현에 의존)
    // test 통과
    

//실패 테스트

    @Test
    @DisplayName("빈 이름으로 조회 X")
    void findBeanByNameX() {
        //ac.getBean("xxxxx", MemberService.class);
        MemberService xxxxx = ac.getBean("xxxxx", MemberService.class);
        
    }

`run : NoSuchBeanDefinitionException: No bean named 'xxxxx' available`

예외 성공 처리로 바꿔주기

    @Test
    @DisplayName("빈 이름으로 조회 X")
    void findBeanByNameX() { //람다식 사용
        assertThrows(NoSuchBeanDefinitionException.class, () -> ac.getBean("xxxxx", MemberService.class));
    } //여기서의 assertThrows는 jUnit static import
// 예외가 터져야 되는 Exception
    // import static org.junit.jupiter.api.Assertions.assertThrows;

스프링 빈 조회 : 동일한 타입이 둘 이상

• 타입으로 조회시 같은 타입의 스프링 빈이 둘 이상이면 오류가 발생한다. 이때는 빈 이름을 지정하자.
• ac.getBeansOfType() 을 사용하면 해당 타입의 모든 빈을 조회할 수 있다.

package hello.core.beanfind;

import hello.core.AppConfig;
import hello.core.discount.DiscountPolicy;
import hello.core.member.MemberRepository;
import hello.core.member.MemoryMemberRepository;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

public class ApplicationContextSameBeanFindTest {
    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(SameBeanConfig.class);
// SameBeanConfig만 가지고 실행
    
    @Test
    @DisplayName("타입으로 조회시 같은 타입이 둘 이상 있으면, 중복 오류가 발생한다.")
    void findBeanByTypeDuplicate() {
        MemberRepository bean = ac.getBean(MemberRepository.class);

    }

// 이 안에서만 쓰겠다는 scope
    @Configuration
    static class SameBeanConfig {
        @Bean
        public MemberRepository memberRepository1() {
            return new MemoryMemberRepository();
        }

        @Bean
        public MemberRepository memberRepository2() {
            return new MemoryMemberRepository();

// 클래스 타입이 같을 수 있다.
        }
    }
}

run : NoUniqueBeanDefinitionException: No qualifying bean of type 'hello.core.member.MemberRepository' available: expected single matching bean but found 2: memberRepository1,memberRepository2

• 단축키 : Ctrl + Alt + V : Extract / Introduce

package hello.core.beanfind;

import hello.core.AppConfig;
import hello.core.discount.DiscountPolicy;
import hello.core.member.MemberRepository;
import hello.core.member.MemoryMemberRepository;
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;

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;

public class ApplicationContextSameBeanFindTest {
    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(SameBeanConfig.class);

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

    }

    @Test
    @DisplayName("타입으로 조회시 같은 타입이 둘 이상 있으면 , 빈 이름을 지정하면 된다.")
    void findBeanByName() {
        MemberRepository memberRepository = ac.getBean("memberRepository1", MemberRepository.class); // 앞에 bean 이름 넣어주기 "" 
        assertThat(memberRepository).isInstanceOf(MemberRepository.class);
    }

    @Test
    @DisplayName("특정 타입을 모두 조회하기")
    void findAllBeanByType() {
        Map<String, MemberRepository> beansOfType =  ac.getBeansOfType(MemberRepository.class);
        for(String key : beansOfType.keySet()) {
            System.out.println("key = " + key + "value = " + beansOfType.get(key));
        }
        System.out.println("beansOfType = " + beansOfType);
        assertThat(beansOfType.size()).isEqualTo(2);
    } // 한번에 조회하는 방법
    // @autowired 같은 것들을 해도 다 된다.

    @Configuration
    static class SameBeanConfig {
        @Bean
        public MemberRepository memberRepository1() {
            return new MemoryMemberRepository();
        }

        @Bean
        public MemberRepository memberRepository2() {
            return new MemoryMemberRepository();
        }
    }
    
}

스프링 빈 조회 : 상속관계

---

• 부모타입으로 조회하면 , 자식 타입도 함께 조회된다.
• 그래서 모든 자바 객체의 최고 부모인 Object 타입으로 조회하면 모든 스프링 빈을 조회한다.
• 원래 extends 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.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

public class ApplicationContextExtendsFindTest {
    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(TestConfig.class);

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

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

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

run : NoUniqueBeanDefinitionException: No qualifying bean of type 'hello.core.discount.DiscountPolicy' available: expected single matching bean but found 2: rateDiscountPolicy,fixDiscountPolicy

    @Test
    @DisplayName("부모 타입으로 조회시 , 자식이 둘 이상 있으면, 중복 오류가 발생한다.")
    void findBeanByParentTypeDuplicate() {
        assertThrows(NoUniqueBeanDefinitionException.class, () -> ac.getBean(DiscountPolicy.class));
    }

    @Test
    @DisplayName("부모 타입으로 조회시 , 자식이 둘 이상 있으면, 빈 이름을 지정하면 된다.")
    void findBeanByParentTypeBeanName() {
        DiscountPolicy rateDiscountPolicy = ac.getBean("rateDiscountPolicy", DiscountPolicy.class);
        assertThat(rateDiscountPolicy).isInstanceOf(RateDiscountPolicy.class);
    }

    @Test
    @DisplayName("특정 하위 타입으로 조회")
    void findBeanBySubType() {
        RateDiscountPolicy bean = ac.getBean(RateDiscountPolicy.class);
        assertThat(bean).isInstanceOf(RateDiscountPolicy.class);
    }

     @Test
     @DisplayName("부모 타입으로 모두 조회하기")
     void findAllBeanByParentType() {
        Map<String, DiscountPolicy> beansOfType = ac.getBeansOfType(DiscountPolicy.class);
        assertThat(beansOfType.size()).isEqualTo(2);
        for(String key : beansOfType.keySet()) {
            System.out.println("key = " + key + "value  = " + beansOfType.get(key));
        }
     }

     @Test
     @DisplayName("부모 타입으로 모두 조회하기 - Object")
     void findAllBeansByObjectType() {
        Map<String, Object> beansOfType = ac.getBeansOfType(Object.class);
        for(String key : beansOfType.keySet()) {
            System.out.println("key = " + key + "value  = " + beansOfType.get(key));
        }

BeanFactory와 ApplicationContext

---

BeanFactory

• 스프링 컨테이너의 최상위 인터페이스다.
• 스프링 빈을 관리하고 조회하는 역할을 담당한다.
• getBean() 을 제공한다.
• 지금까지 우리가 사용했던 대부분의 기능은 BeanFactory가 제공하는 기능이다.

ApplicationContext

• BeanFactory 기능을 모두 상속받아서 제공한다.
• 빈을 관리하고 검색하는 기능을 BeanFactory가 제공해주는데, 그러면 둘의 차이가 뭘까?
• 애플리케이션을 개발할 때는 빈을 관리하고 조회하는 기능은 물론이고, 수 많은 부가기능이 필요하다.

공통기능 : ApplicationContext

• 메세지 소스를 활용한 국제화 기능
  • 예를 들어서 한국에서 한국에서 들어오면 한국어로 영어권에서 들어오면 영어로 출력
• 환경변수
  • 로컬, 개발, 운영 등을 구분해서 처리
  • PC(local 환경), Test Server(개발환경) , Production (운영) , Stage 환경(운영과 비슷한 환경)
• 애플리케이션 이벤트
  • 이벤트를 발행하고 구독하는 모델을 편리하게 지원
• 편리한 리소스 조회
  • 파일, 클래스패스, 외부 등에서 리소스를 편리하게 조회

정리

• ApplicationContext는 BeanFactory의 기능을 상속받는다.
• ApplicationContext는 빈 관리기능 + 편리한 부가 기능을 제공한다.
• BeanFactory를 직접 사용할 일은 거의 없다. 부가기능이 포함된 ApplicationContext를 사용한다.
• BeanFactory나 ApplicationContext를 스프링 컨테이너라 한다.

다양한 설정 형식 지원 - 자바 코드, XML

---

• 스프링 컨테이너는 다양한 형식의 설정 정보를 받아드릴 수 있게 유연하게 설계되어 있다.
  • 자바 코드, XML, Groovy 등등

애노테이션 기반 자바 코드 설정 사용

• 지금까지 했던 것이다.
• new AnnotationConfigApplicationContext(AppConfig.class)
• AnnotationConfigApplicationContext 클래스를 사용하면서 자바 코드로된 설정 정보를 넘기면 된다.

XML 설정 사용

• 최근에는 스프링 부트를 많이 사용하면서 XML기반의 설정은 잘 사용하지 않는다.
• 아직 많은 레거시 프로젝트 들이 XML로 되어 있고, 또 XML을 사용하면 컴파일 없이 빈 설정 정보를 변경할 수 있는 장점도 있으므로 한번쯤 배워두는 것도 괜찮다
• GenericXmlApplicationContext 를 사용하면서 xml 설정 파일을 넘기면 된다.

test

package hello.core.xml;

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

import static org.assertj.core.api.Assertions.assertThat;

public class XmlAppContext {
    @Test
    void xmlAppContext() {

        ApplicationContext ac  =  new GenericXmlApplicationContext("appConfig.xml");
        MemberService memberService = ac.getBean("memberService", MemberService.class);
        assertThat(memberService).isInstanceOf(MemberService.class);
    }
}

resources > appConfig.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등록하는 부분이랑 똑같다

@Configuration
public class AppConfig {
    @Bean
    public MemberService memberService() {
        return new MemberServiceImpl(memberRepository());
    }
    @Bean
    public static MemoryMemberRepository memberRepository() {
        return new MemoryMemberRepository();
    }
   

할인 정책까지 마저 쓰면,

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

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

• xml 기반의 appConfig.xml 스프링 설정 정보와 자바 코드로 된 AppConfig.java 설정 정보를
  비교해보면 거의 비슷하다는 것을 알 수 있다.-
• xml 기반으로 설정하는 것은 최근에 잘 사용하지 않으므로 이정도로 마무리 하고, 필요하면 스프링 공식 레퍼런스 문서를 확인하자.
  https://spring.io/projects/spring-framework

스프링 빈 설정 메타 정보 : BeanDefinition

---

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

• 쉽게 얘기해 "역할과 구현을 개념적으로 나눈 것"이다.

  • XML을 읽어서 BeanDefinition을 만들면 된다.
  • 자바 코드를 읽어서 BeanDefinition을 만들면 된다.
  • 스프링 컨테이너는 자바 코드인지, XML인지 몰라도 되고 오직 BeansDefinitioin만 알면 된다.

• BeanDefiniton을 빈 설정 메타정보라 한다.

  • BeanDefinition 자체가 구현체가 된다.
  • @Bean, <bean> 당 각 하나씩 메타정보가 생성된다.

• 스프링 컨테이너는 이 메타정보를 기반으로 스프링 빈을 생성한다.
  

• 코드 레벨로 넘어가면,

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("빈 설정 메타 정보 확인")
     void findApplicatioinBean() {
        String [] beanDefinitioinNames = ac.getBeanDefinitionNames();
        for(String beanDefinitionName : beanDefinitioinNames) {
            BeanDefinition beanDefinition = ac.getBeanDefinition(beanDefinitionName);
            if(beanDefinition.getRole() == BeanDefinition.ROLE_APPLICATION) {
                System.out.println("beanDefinitionName = " + beanDefinitionName + "beanDefinition" + beanDefinition);
            }
        }
    }
}

BeanDefinition 정보

• BeanClassName: 생성할 빈의 클래스 명(자바 설정 처럼 팩토리 역할의 빈을 사용하면 없음)
• factoryBeanName: 팩토리 역할의 빈을 사용할 경우 이름, 예) appConfig
• factoryMethodName: 빈을 생성할 팩토리 메서드 지정, 예) memberService
• Scope: 싱글톤(기본값)
• lazyInit: 스프링 컨테이너를 생성할 때 빈을 생성하는 것이 아니라, 실제 빈을 사용할 때 까지 최대한 생성을 지연처리 하는지 여부
• InitMethodName: 빈을 생성하고, 의존관계를 적용한 뒤에 호출되는 초기화 메서드 명
• DestroyMethodName: 빈의 생명주기가 끝나서 제거하기 직전에 호출되는 메서드 명
• Constructor arguments, Properties: 의존관계 주입에서 사용한다. (자바 설정 처럼 팩토리 역할의 빈을 사용하면 없음

정리

• BeanDefinition을 직접 생성해서 스프링 컨테이너에 등록할 수 도 있다. (직접)
• 하지만 실무에서 BeanDefinition을 직접 정의하거나 사용할 일은 거의 없다. → 어려우면 그냥 넘어가면 된다^^
• BeanDefinition에 대해서는 너무 깊이있게 이해하기 보다는, 스프링이 다양한 형태의 설정 정보를 BeanDefinition으로 추상화해서 사용하는 것 정도만 이해하면 된다.
• 가끔 스프링 코드나 스프링 관련 오픈 소스의 코드를 볼 때, BeanDefinition 이라는 것이 보일 때가 있다. 이때 이러한 메커니즘을 떠올리면 된다

    GenericXmlApplicationContext ac = new GenericXmlApplicationContext("appConfig.xml");

이거는 getBeanDefinition이 없다.

• Class 가 Null로 나오기도 한다.

최종 정리

• 스프링은 BeanDefinition으로 스프링 메타 정보를 추상화한다.
• 스프링 빈을 만드는 방법은 두가지 방법이 있는데,
  • 1. 직접적으로 스프링 빈을 등록하는 방법
  • 2. factoryBean으로 등록하는 방법 (일반적), factoryMethod 개념

단축키

• Ctrl + Shift + Enter : code completion

[seyxxn]

지은님 사진이 깨져서 안보이는거같은데 저만,, 안보이나요,, ?!?

[Pracrobo]

확인 후 수정중입니다 ! 감사합니다!