스프링 컨테이너와 스프링 빈-스프링 핵심원리 기본

목차

• 스프링 컨테이너 생성
• 컨테이너에 등록된 모든 빈 조회
• 스프링 빈 조회 - 기본
• 스프링 빈 조회 - 동일한 타입이 둘 이상
• 스프링 빈 조회 - 상속 관계
• BeanFactory와 ApplicationContest
• 다양한 설정 형식 지원 - 자바 코드,XML
• 스프링 빈 설정 메타 정보 - BeanDefinition

📌스프링 컨테이너 생성

// 스프링 컨테이너 생성
ApplicationContext ac //인터페이스
 = new AnnotationConfigApplicationContext(AppConfig.class); //구현체(다형성 적용)

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

• ApplicationContext는 인터페이스이다.

• 스프링 컨테이너는 애노테이션 기반 자바 설정 클래스로 만들 수 있고, XML을 기반으로도 자바 설정 클래스를 만들 수 있지만 지금은 잘 안쓰인다고 한다.

• 아래 코드처럼 AppConfig.class를 사용했던 방식이 애노테이션 기반의 자바 설정 클래스로 스프링 컨테이너를 만든것이다.

  @Configuration
  public class AppConfig {
  
    @Bean
    public MemberService memberService(){
        return new MemberServiceImp(memberRepository());
    }
  
  ...

  스프링컨테이너는 BeanFactory,ApplicationContext로 구분해서 말하지만 BeanFactory를 직접사용하는 경우는 거의 없으므로 일반적으로 ApplicatrionContext를 스프링 컨테이너라고 말한다.

1. 스프링 컨테이너 생성

• 스프링컨테이너의 구현체인 AnnotationConfigApplicationContext로 스프링 컨테이너 생성
• 스프링 컨테이너를 생성할 때는 구성 정보를 파라미터로 넣주어야해서 AppConfig.class를 구성정보로 지정

2. 스프링 빈 등록

• 스프링 컨테이너는 파라미터로 넘어온 AppConfig.class의 정보를 사용해서 스프링 빈을 등록 한다.

빈 이름

• 빈 이름은 메서드 이름을 사용한다.
• 빈 이름을 직접 부여할 수 도 있다.
  • @Bean(name="새로 등록할 이름")

3. 스프링 빈 의존관계 설정 - 준비

4. 스프링 빈 의존관계 설정 - 완료

• 스프링 컨테이너는 설정 정보를 참고해서 의존관계를 주입(DI)한다.
• 단순히 자바 코드를 호출하는 것 같지만, 차이가있다. 이 차이는 뒷 부분 싱글톤 컨테이너에서 설명이 있다고 한다.

정리

• 스프링 컨테이너를 생성하면 설정(구성)정보인 AppConfig를 참고해서 스프링 빈을 등록하고, 의존관계도 설정해 준다.
  
  
  

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

스프링 컨테이너에 실제 스프링 빈들이 잘 등록 되었는지 확인해 보기.

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 {

    //AppConfig.class 의 정보가 담겨있는 스프링 컨테이너 생성
    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);

    @Test
    @DisplayName("모든 빈 출력하기")
    void findAllBean() {

        String[] beanDefinitionNames = ac.getBeanDefinitionNames();
        // getBeanDefinitionNames()으로 빈 객체이름들을 모두 beanDefinitionNames에 담음

        for (String beanDefinitionName : beanDefinitionNames) {
            Object bean = ac.getBean(beanDefinitionName);
            //beanDefinitionName의 객체들을 하나하나 Object타입의 변수에 담음
            System.out.println("Name = " + beanDefinitionName + "  ,object = " + bean);
        }
    }
        @Test
        @DisplayName("애플리케이션 빈 출력하기")
        void findApplicationBean(){
            String[] beanDefinitionNames = ac.getBeanDefinitionNames();
            for (String beanDefinitionName : beanDefinitionNames) {
                BeanDefinition beanDefinition = ac.getBeanDefinition(beanDefinitionName);

                //Role ROLE_APPLICATION : 직접 등록한 애플리케이션 빈
                //Role ROLE_INFRASTRUCTURE : 스프링이 내부에서 사용하는 빈
                if(beanDefinition.getRole() == BeanDefinition.ROLE_APPLICATION){
                    Object bean = ac.getBean(beanDefinitionName);
                    System.out.println("name= " + beanDefinitionName + ", object= "+bean);
                }

        }
    }
}

• 모든 빈 출력하기
  • 실행화면 스프링에 등록된 모든 빈 정보를 출력 할 수 있다.
• 애플리케이션 빈 출력하기
  • 스프링이 내부에서 사용하는 빈 제외 내가 등록한 빈만 보기
  • Role ROLE_APPLICATION을 이용해서 직접 등록한 애플리케이션 빈일때만 Object 변수에 담기
    
    
    

📌스프링 빈 조회 - 기본

package hello.core.beanfind;

import hello.core.AppConfig;
import hello.core.member.MemberService;
import hello.core.member.MemberServiceImp;
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;

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

public class ApplicationContextBasicFindTest {
    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);

    @Test
    @DisplayName("빈 이름으로 조회")
    void 빈이름으로조회(){
       MemberService memberService = ac.getBean("memberService", MemberService.class);
        System.out.println("memberService" + memberService);
        System.out.println("memberService.g1etClass() = " + memberService.getClass());
        assertThat(memberService).isInstanceOf(MemberServiceImp.class);
    }
    @Test
    @DisplayName("이름없이 타입으로 조회")
    void 이름없이타입으로조회(){
        MemberService memberService = ac.getBean(MemberService.class);
        assertThat(memberService).isInstanceOf(MemberServiceImp.class);
    }

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


    @Test //실패 테스트 NoSuchBeanDefinitionException 발생시 테스트 성공
    @DisplayName("빈 이름으로 조회 x")
    void 빈이름으로조회x(){
        org.junit.jupiter.api.Assertions.assertThrows(NoSuchBeanDefinitionException.class,
                () -> ac.getBean("xxxx", MemberService.class));
     }
}

• getBean(빈이름, 타입) or getBean(타입)
• 조회 대생 스프링 빈이 없으면 예외 발생
  • NoSuchBeanDefinitionException: No bean named 'xxxx' available
    
    
    

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

package hello.core.beanfind;

import hello.core.discount.DiscountPolicy;
import hello.core.member.MemberMemoryRepository;
import hello.core.member.MemberRepository;
import org.junit.jupiter.api.Assertions;
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);

    @Test
    @DisplayName("타입으로 조회시 같은 타입이 둘 이상 있으면, 중복 오류가 발생한다.")

    void 같은타입조회() {
        MemberRepository bean = ac.getBean(MemberRepository.class);
        //NoUniqueBeanDefinitionException
    }



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

NoUniqueBeanDefinitionException 에러(예외) 발생

  //특정타입 모두 조회하기
    @Test
    @DisplayName("특정타입 모두 조회")
    void AllFind(){
        Map<String, MemberRepository> beansOfType = ac.getBeansOfType(MemberRepository.class);
        for (String key : beansOfType.keySet()){
            System.out.println("key = " + key+ "value = " + beansOfType.get(key));
        }
        org.assertj.core.api.Assertions.assertThat(beansOfType.size()).isEqualTo(2);
    }

📌스프링 빈 조회 - 상속 관계

package hello.core.beanfind;

import hello.core.AppConfig;
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);

    @Test
    @DisplayName("같은 부모 타입 조회시 결과 테스트")
    void findSameExtendsTypeBean(){
 /*
   DiscountPolicy bean = ac.getBean(DiscountPolicy.class);
        System.out.println("bean = " + bean);
        예외 발생 : NoUniqueBeanDefinitionException
        */

        Assertions.assertThrows(NoUniqueBeanDefinitionException.class,
                ()->ac.getBean(DiscountPolicy.class));
        //junit5의 assertThrows 예외 테스트 assertThrows 첫번째인자에 예외클래스드를 인자로 넣어주고
        //두번째인자엔 첫번째 인자의 예외 타입과 같은지 혹은 상속관계의 예외인지 검사한다.


    }

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

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

    @Test
    @DisplayName("부모타입으로 모든 빈 조회")
    void 부모타입모든빈조회(){
        Map<String , DiscountPolicy> beansOfType= ac.getBeansOfType(DiscountPolicy.class);
        for(String key : beansOfType.keySet()){ //keySet() = 해당클래스의 키를 리턴
            System.out.println("key = " + key + "value = " +beansOfType.get(key) );
        }
    }

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



    //상속 관계 빈 조회 테스트를 위한 테스트 빈 컨테이너
    @Configuration
    static class TestConfig{

        @Bean
        public DiscountPolicy rateDiscountPolicy() {
            return new RateDiscountPolicy();
        }

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

학습한 내용

NoUniqueBeanDefinitionException

• 같은 부모타입의 빈을 조회시 NoUniqueBeanDefinitionException 발생

  junit5의 assertThrows 예외 테스트

• assertThrows 첫번째인자에 예외클래스드를 인자로 넣어주고 두번째인자엔 첫번째 인자의 예외 타입과 같은지 혹은 상속관계의 예외인지 검사한다.

  Map Class 메서드

• keySet() : 클래스키를 리턴받음

AbstractApplicationContext 클래스 메서드

• getBean() : 인자로 받은 클래스의 빈을 리턴받는다.
• getBeanOfType() : 인자로받은 클래스의 키와 값을 리턴받는다
  
  
  

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

이전에 자바코드로 스프링컨테이너를 생성할때

ApplicatoinContext의 구현객체인 AnnotationConfigApplicationContext 를 객체로 new 해서 사용했다.
그리고 스프링에서는 자바코드말고도 xml을 이용해서 빈을 등록할 수 있소 직접 구현객체를 만들어서 사용 할 수 도 있다.

아래코드는 GenericXmlApplicationContext를 구현객체로 생성해서 xml으로 스프링 빈을 등록해 보았다.

public class XmlAppContext {

    @Test
    void xmlAppContext(){
        ApplicationContext ac = new GenericXmlApplicationContext("appConfig.xml");
        //GenericXmlApplicationContext 을 구현체로 생성해서 "appConfig.xml"을 인자로 넣어줌
        MemberService memberService = ac.getBean("memberService", MemberService.class);
        System.out.println("memberService = " + memberService);
        Assertions.assertThat(memberService).isInstanceOf(MemberService.class);
    }
}

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.MemberServiceImp">
        <constructor-arg name="memberRepository" ref="memberRepository" />
    </bean>

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

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

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

</beans>

xml 설정파일도 자바설정클래스와 비슷하게 빈을 등록하는 것을 알 수 있다.
이처럼 스프링은 설정파일을 유연하게 변경 할 수 있다는 장점이 있는거같다.

📌스프링 빈 설정 메타 정보 - BeanDefinition

• 스프링이 다양한 설정형식을 지원할 수 있는 이유는 BeanDefinition 라는 인터페이스로 역할과 구부현을 개념적으로 나누었기 떄문이다.
• 따라서 xml이든 자바코드의 빈 설정 정보든 구현체를 만들어서 BeanDefinition을 만들면 된다.
• BeanDefinition은 빈 설정 메타정보라고 한다.
  • @Bean, < bean > 당 각각 하나씩 메타정보가 생성 된다.
• 스프링 컨테이너는 이 메타정보를 기반으로 스프링 빈을 생성한다.

  메타데이터란 데이터에 대한 데이터이며 정확히는 어떤 목적을 가지고 만들어진 데이터라고도 정의한다.
  즉, 메타데이터는 어떠한 데이터의 정보(데이터)들을 담고있는 것을 말하는것 같다.
  
  ex) 이미지파일이 있을때 이미지의 확장자, 크기 ,이름, 생성일, 등을 메타데이터라고 할 수 있다.

• AnnotationConfigApplicationContext가 AnnotatedBeanDefinitionReader를 사용해서 AppConfig.class의 설정 정보를 읽고 BeanDefinition을 생성한다.
  
  

package 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.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class BeanDefinitionTest {

  AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);

  @Test
  @DisplayName("빈 설정 메타정보 확인")
  void 빈설정메타정보확인() {
    //컨테이너 생성
    String[] beanDefinitionNames = ac.getBeanDefinitionNames();

    // 배열 담긴 bean 이름을  beanDefinitionName 담음
    for(String beanDefinitionName : beanDefinitionNames){

     BeanDefinition beanDefinition = ac.getBeanDefinition(beanDefinitionName);
      //파라미터로 받은 배열이름의 정보를 꺼네와서 beanDefinition 에담음

      if (beanDefinition.getRole() == BeanDefinition.ROLE_APPLICATION) {
        //beanDefinition의 정보 == BeanDefinition에서 사용자가 정의한 빈
        System.out.println("beanDefinitionName = " + beanDefinitionName+ " beanDefinition = " + beanDefinition);

      }
    }
  }

}

BeanDefinition 살펴보기

BeanDefinition 정보

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

beanDefinitionName = appConfig 
beanDefinition = Generic bean: class [hello.core.AppConfig$$EnhancerBySpringCGLIB$$3013409a]; scope=singleton;
abstract=false; 
lazyInit=null; 
autowireMode=0; 
dependencyCheck=0; 
autowireCandidate=true; 
primary=false; 
factoryBeanName=null; 
factoryMethodName=null;
initMethodName=null;
 destroyMethodName=null



beanDefinitionName = memberService 
beanDefinition = Root bean: class [null];
 scope=;
abstract=false; 
lazyInit=null; 
autowireMode=3; 
dependencyCheck=0; 
autowireCandidate=true; 
primary=false; 
factoryBeanName=appConfig; 
factoryMethodName=memberService; 
initMethodName=null; 
destroyMethodName=(inferred); 
defined in hello.core.AppConfig

Ref 김영한님 스프링 핵심 원리 기본편