Chapter 04. 스프링 컨테이너와 스프링 빈

Spring Framework/[인프런] Spring 핵심 원리

Chapter 04. 스프링 컨테이너와 스프링 빈

계란💕 2022. 8. 12. 18:26

4.1 스프링 컨테이너 생성

(1) 스프링 컨테이너 생성

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);

어노테이션 자바 config기반의 스프링을 만들라는 뜻이다.
일반적으로, 인터페이스 ApplicationContext는 '스프링 컨테이너'라고 한다. 사실, 'ApplicationContext'의 최상위에는 'Bean Factory'가 있다.
XML 기반으로 만들 수 있다.
스프링 컨테이너를 생성할 때는 구성 정보를 지정해줘야한다. => 'AppConfig.class'

(2)스프링 빈 등록

빈 이름(key), 반환된 값은 빈의 객체로 등록
빈 이름은 항상 달라야한다! 같은 이름이 등록되면 다른 하나는 무시하거나 덮어버릴 수 있다.
빈 이름 직접 부여 가능

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

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

cf) 그림의 메서드 중에 아래 두 개가 위에 있어야 컴파일러를 위해 좋을 것 같다.

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

cf) 스프링은 먼저 빈을 주입하고 의존 관계를 주입하는 단계가 나눠져있다. 그런데, 자바 코드로 빈을 등록하면 생성자를 호출하면서 의존 관계 주입도 한번에 처리된다.

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

Ex) 모든 빈 조회하기

- AnnotationConfigApplicationInfoTest 클래스를 만든다.

- getBeanDefinitionNames(): 스프링에 등록된 모든 빈 이름을 조회해서 모든 네임을 String 배열로 반환한다.

- ac.getBean("이름"): 빈 이름으로 빈 객체를 조회한다.

<hide/>
package hello.core.beanFind;
import hello.core.AppConfig;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class ApplicationContextInfoTest {

    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);

    @Test
    @DisplayName("모든 빈 출력하기")
    void findAllBean(){
        String[] beanDefinitionNames = ac.getBeanDefinitionNames(); // 빈에 정의된 이름을 등록한다
        
        for(String beanDefinitionName : beanDefinitionNames){

            Object bean = ac.getBean(beanDefinitionName);   // ac에서 빈을 꺼낸다. 타입을 몰라서 Object로 꺼내진다.
            System.out.println("name = " + beanDefinitionName + " object = " + bean);

        }
    }
}

Note) 실행 결과

- 아래 코드의 org.로 시작하는 부분은 스프링이 내부적으로 스프링 자체를 확장하기 위해서 불러오는 부분을 뜻한다.

- AppCofig도 빈으로 등록된다.

- 아래 다섯 줄은 내 코드로 인해 만들어진 다섯 개의 빈을 의미한다. 참고로 AppConfig도 빈으로 등록된다.

Ex) 특정 빈 확인하기

- getBeanDefinition(): 빈 하나하나에 대한 메타 정보를 반환한다.

- getRole(): 세 가지 중에서 ROLE_APPLICATION을 주로 쓴다.

-> ROLE_APPLICATION: 일반적으로 내가 직접 등록한 애플리케이션 빈

-> ROLE_INFRASTRUCTURE: 스프링이 내부에서 사용하는 빈

<hide/>

    @Test
    @DisplayName("애플리케이션 빈 출력하기")
    void findApplicationBean(){
        String[] beanDefinitionNames = ac.getBeanDefinitionNames(); // 빈에 정의된 이름을 등록한다
        for(String beanDefinitionName : beanDefinitionNames){

            BeanDefinition beanDefinition = ac.getBeanDefinition(beanDefinitionName);
            if(beanDefinition.getRole() == BeanDefinition.ROLE_APPLICATION){
                Object bean = ac.getBean(beanDefinitionName);   // ac에서 빈을 꺼낸다. 타입을 몰라서 Object로 꺼내진다.
                System.out.println("name = " + beanDefinitionName + " object = " + bean);
            }
        }
    }

Note) 실행 결과

4.3 스프링 빈 조회 - 기본

Ex) 빈 이름으로 조회 - getBean("빈 이름", "타입")

<hide/>
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());
    }
}

Note) 실행 결과

Ex) 빈 이름 없이 타입으로만 빈 조회 - IsInstanceOf

<hide/>
   @Test
    @DisplayName("이름없이 빈 타입으로 조회")
    void findBeanByType(){

        MemberService memberService = ac.getBean(MemberService.class);
        assertThat(memberService).isInstanceOf(MemberServiceImpl.class);

    }

Note) 실행 결과 - 성공

Ex) 구체적인 타입으로 빈 조회 - 유연성이 떨어진다.

- MemberServiceImpl은 인터페이스 MemberService를 구현한 클래스

<hide/>
  @Test
    @DisplayName("구체 타입으로 조회")
    void findBeanByConcreteType(){

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

    }

Note) 실행 결과 - 성공

Ex) 빈 이름으로 조회되지 않는 경우 (1)

<hide/>
    @Test
    @DisplayName("빈 이름으로 조회 X")
    void findBeanByNameX(){
        MemberService XXX = ac.getBean("XXX", MemberService.class);
//        assertThat(memberService).isInstanceOf(MemberServiceImpl.class);
    }

Note) 실행 결과

- org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named 'XXX' available

- 그러한 빈을 등록한 적 없다는 예외가 나온다.

Ex) 빈 이름으로 조회되지 않는 경우 (2)

<hide/>
    @Test
    @DisplayName("빈 이름으로 조회 X")
    void findBeanByNameX(){
//        MemberService XXX = ac.getBean("XXX", MemberService.class);
        assertThrows(NoSuchBeanDefinitionException.class,
                () ->ac.getBean("XXX", MemberService.class) );  // 예외가 터져야  성공한다는 뜻이다.
    }

Note) 실행 결과 - 성공

- JUnit에 있는 assertThrows()를 쓴다.

- assertThrows("예외", 실행하려는 식): "예외"가 발생해야 테스트 성공하는 메서드이다.

-> 오른쪽의 식을 실행켰을 때 왼쪽의 NoSuchBeanDefinition이 발생하는지 확인한다.

4.4 스프링 빈 조회 - 동일한 타입이 둘 이상인 경우

Ex) 동일한 타입이 둘 이상인 경우 - 중복 오류

<hide/>
package hello.core.beanFind;
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 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) );
    }
    @Configuration
    static class SameBeanConfig{
        @Bean
        public MemberRepository memberRepository1(){
            return new MemoryMemberRepository();
        }

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

- 이 때는 빈 이름을 지정해주면 된다.

- 스프링 입장에서 꺼내는 값이 두 개인데 ac를 생성할 때 매개변수로 SameBeanConfig

cf) 어떤 클래스에 내부 클래스(이너 클래스)를 static으로 선언하면 어떤 클래스 내부에서만 내부 클래스를 사용 가능하다.

Note) 실행 결과 - NoUniqueBeanDefinitionException

org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'hello.core.member.MemberRepository' available: expected single matching bean but found 2: memberRepository1,memberRepository2
빈 두 개를 찾았고 unique하지 않다는 설명이 나온다.

Ex) 동일한 타입이 둘 이상인 경우 - 빈 이름 지정하는 경우

<hide/>
    @Test
    @DisplayName("타입으로 조회 시 같은 이름이 둘 이상 있으면, 빈 이름을 지정하면 된다.")
    void findBeanByName(){

        MemberRepository memberRepository = ac.getBean("memberRepository1" , MemberRepository.class);
        assertThat(memberRepository).isInstanceOf(MemberRepository.class);
    }

Note) 실행 결과 - 성공

Ex) 특정 타입을 모두 꺼내오고 싶은 경우 - getBeansOfType()

<hide/>
    @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);
    }

Note) 실행 결과 - 성공

- 나중에 @Autowired를 자동으로 의존 관계를 주입할 때, 이런 기능이 자동으로 적용된다.

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

상속 관계

부모 타입으로 조회하면 자식 타입도 함께 조회한다.
그래서, "Object"타입으로 조회하면 모든 스프링 빈을 조회한다.

Ex) 부모 타입으로 조회 시 자식이 둘 이상이면 중복 오류가 발생한다.

<hide/>
    @Test
    @DisplayName("부모 타입으로 조회시 자식이 둘 이상 있으면 중복 오류가 발생한다.")
    void findBeanByParentTypeDuplicate(){

        assertThrows(NoUniqueBeanDefinitionException.class,
                () -> ac.getBean(DiscountPolicy.class));
    }

Note) 실행 결과 - 성공

Ex) 부모 타입으로 조회 시, 자식이 둘 이상 있으면 빈 이름을 지정하면 된다.

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

Note) 실행 결과 - 성공

Ex) 특정 하위 타입(RateDiscountPolicy)으로 조회 - 좋은 방법은 아니다.

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

Note) 실행 결과 - 성공

Ex) 부모 타입(DiscountPolicy)으로 조회

<hide/>
 @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));
        }
    }

Note) 실행 결과 - 성공

Ex) Object 타입으로 모두 꺼내보기 - getBeansOfType(Object.class)

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

Note) 실행 결과 - 성공

- 스프링에 있는 것까지 모두 튀어나온다.

- 자바의 모든 객체는 object 의 자식이기 때문이다.

4.6 Bean Factory와 ApplicationContext

BeanFactory

BeanFactory는 스프링 컨테이너의 최상위 인터페이스
ApplicationContext 는 BeanFactory에 부가 기능을 더한 거라 볼 수 있다.
BeanFactory에는 getBean()메서드가 있다.

ApplicationContext

ApplicationContext 는 BeanFactory의 기능을 모두 상속받아서 제공한다.
ApplicationContext 와 BeanFactory의 차이는 ?
- 애플리케이션을 개발할 때는 빈을 관리하고 조회하는 기능은 물론, 수많은 기능이 필요하다.
- ApplicationContext 의 여러 가지 부가 기능이 있다. BeanFactory 뿐만 아니라 아래의 인터페이스를 모두 상속
- 인터페이스 MessageSource(메시지 소스를 활용한 국제화 기능): ex) 한국에서 접속하면 한국어 표시
- 인터페이스 EnviornmentCapable(환경 변수): 로컬, 개발, 운영 등을 구분해서 처리한다.
- 인터페이스 ApplicationEventPublisher(애플리케이션 이벤트): 이벤트를 발행하고 구독하는 모델을 편리하게 지원
- 인터페이스 ResourceLoader(편리한 리소스 조회): 파일, 클래스 패스, 외부 등에서 리소스를 편리하게 조회한다. ex) 외부 url을 읽어서 추상화시켜서 편리하게 만든다.

BeanFactory와 ApplicationContext 비교 정리

ApplicationContext는 빈 관리기능 + 편리한 부가 기능을 제공한다.
BeanFactory를 직접 사용할 일은 거의 없다. 부가 기능이 포함된 ApplicationContext를 주로 사용한다.
보통 BeanFactory와 ApplicationContext를 둘다 스프링 컨테이너라고 부른다.

4.7 다양한 설정 형식 지원 - 자바 코드, XML(eXtensible Markup Language)

다양한 형식 지원

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

Ex) XmlAppConfig 사용 자바 코드

- 이 상태로는 테스트 실패한다. (xml 파일을 만들어야 한다.)

- 리소스 위치를 의미하는 괄호 안의 xml 파일을 끌어다가 동작한다.

<hide/>
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);

    }
}

- appConfig.xml 파일을 만든다.

-> memberRepository빈을 등록한다.

-> 이렇게 해주면 AppConfig에서 빈으로 등록한 memberService와 같아진다.

-> constructor - arg는 생성자를 의미한다.

<hide/>
<?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"/>
</beans>

- xml 파일에 할인 정책을 만든다.

-> 빈을 만들면서 constructor-arg는 생성자를 뜻한다. ref에 리포지토리 등록

<hide/>
<?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.order.OrderServiceImpl">
        <constructor-arg name="memberRepository" ref="memberRepository"/>
        <constructor-arg name="discountPolicy" ref="discountPolicy"/>
    </bean>
    <bean id ="discountPolicy" class ="hello.core.discount.RateDiscountPolicy"/>
</beans>

- xml을 위처럼 세팅해주면 AppConfig 클래스 코드와 완전히 같다.

<hide/>
package hello.core;
import hello.core.discount.DiscountPolicy;
import hello.core.discount.RateDiscountPolicy;
import hello.core.member.MemberRepository;
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 MemberRepository memberRepository() {
        return new MemoryMemberRepository();
    }
    @Bean
    public OrderService orderService(){ // 누군가 오더서비스를 조회하면?
        return new OrderServiceImpl( memberRepository(), discountPolicy());
    }

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

Note) xmlAppContext 실행 결과 - 성공

- xmlAppContext을 실행하면 방금 만든 xml 파일을 끌어다 동작시킨다.

- 클래스가 아닌 xml에 설정 정보가 있는 것 말고는 변경 사항이 없다.

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

스프링은 어떻게 다양한 설정 형식을 지원할까?

"BeanDefinition - 빈 설정 메타 정보"이라는 추상화가 있기 때문에 스프링은 다양한 설정 형식을 지원한다.
BeanDefinition 자체가 인터페이스이다.
역할과 구현을 개념적으로 나눈다.
자바 코드를 읽어서 BeanDefinition을 만들면 된다.
하나의 @Bean, <bean> 마다 하나씩 메타 정보가 생성된다.
스프링 컨테이너는 메타 정보를 기반으로 스프링 빈을 생성한다.
스프링은 BeanDefinition으로 스프링 빈에 메타 정보를 추상화한다.

reader가 AppConfig를 읽어서 BeanDefinition를 먼저 생성한다.

BeanDefinition 정보

스프링의 다양한 설정 정보를 beandefinition으로 추상화해서 제공한다.
BeanClassName: 생성할 빈의 클래스명
factoryBeanName: 팩토리 역할의 빈을 사용할 경우 ex) appConfig
factoryMethodName: 빈을 생성할 팩토리 메서드 지정 ex) memberService
Scope: 싱글톤(기본값)
lazyInit: 스프링 컨테이너를 생성할 때, 빈을 생성하는 것이 아니라 실제 빈을 사용할 때까지 최대한 생성을 지연 처리하는지의 여부
InitMethodName: 빈을 생성하고 의존관계를 적용할 뒤에 호출되는 초기화 메서드 명
DestroyMethodName: 빈의 생명주기가 끝나서 제거하기 직전에 호출되는 메서드 명
Constructor arguments, Properties: 의존 관계 주입에서 사용한다. (자바 설정처럼 팩토리 역할의 빈을 사용하면 없다.)
실무에서는 직접 생성해서 스프링 컨테이너에 등록할 수도 있으나 그런 일은 거의 없다.

Ex 1) 빈 설정 메타 정보 확인 - 직접

- 테스트 클래스 만든다.

- ApplicationContext로 만들 경우에는 getDefinition()을 사용할 수 없기 때문에 AnnotationConfigApplicationContext를 사용한다.

<hide/>
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 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
                                + ", beanDefinition = " + beanDefinition
                );
            }
        }
    }
}

Note) 실행 결과

- scope=; => 값이 할당되지 않은 경우 이렇게 표시되는데 이를 싱글톤이라고 한다.

Ex 2) GenericXml

- 위의 예제와 다른 점은?

-> GenericBean은 빈에 대한 정보가 명확하게 등록되어 있다.

-> 1) 은 팩토리 빈을 통해 등록 되는 방식이다.

cf) 스프링에 빈을 등록하는 방법?

1) 직접 스프링 컨테이너에 등록한다.

2) 팩토리 메서드를 이용한다. (우회) ex) AppConfig - 팩토리, memberSerice()는 팩토리 메서드

<hide/>
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;
import org.springframework.context.support.GenericXmlApplicationContext;
public class BeanDefinitionTest {

    GenericXmlApplicationContext ac
            = new GenericXmlApplicationContext("appConfig.xml");
    @Test
    @DisplayName("빈 설정 메타정보 확인")
    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
                                + ", beanDefinition = " + beanDefinition
                );
            }
        }
    }
}

Note) 실행 결과

출처 https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/

스프링 핵심 원리 - 기본편 - 인프런 | 강의

스프링 입문자가 예제를 만들어가면서 스프링의 핵심 원리를 이해하고, 스프링 기본기를 확실히 다질 수 있습니다., - 강의 소개 | 인프런...

www.inflearn.com

저작자표시

'Spring Framework > [인프런] Spring 핵심 원리' 카테고리의 다른 글

Chapter 06. 컴포넌트 스캔(@ComponentScan) (0)	2022.08.14
Chapter 05. 싱글톤 컨테이너 (0)	2022.08.14
Chapter 03. 스프링 핵심 원리 이해2 - 객체 지향 원리 적용 (0)	2022.08.12
Chapter 02. 스프링 핵심 원리 이해1 - 예제 만들기 (0)	2022.08.11
Chapter 01. 객체 지향 설계와 스프링 (0)	2022.08.11

현재글Chapter 04. 스프링 컨테이너와 스프링 빈

Backend Developer lan4250@naver.com https://github.com/goraneee

스프링, JPA, GIT, Queue, 제로베이스 스쿨, 제로베이스 백엔드, dfs, 백준, SQL, 자바, 알고리즘, dp, Java, 코드업, BFS, Stack, 데이터베이스, mysql, 프로그래머스, DB,

Today :
Yesterday :

일	월	화	수	목	금	토
			1	2	3	4
5	6	7	8	9	10	11
12	13	14	15	16	17	18
19	20	21	22	23	24	25
26	27	28	29	30	31

계란 블로그