Spring의 ApplicationContext.getBean이 왜 나쁜 것으로 간주됩니까?


270

나는 일반적인 Spring 질문 : Spring Beans 자동 캐스트 를 요청했으며 여러 사람들이 Spring을 호출하는 것을 ApplicationContext.getBean()최대한 피해야한다고 응답했다 . 왜 그런 겁니까?

Spring이 생성하도록 구성한 Bean에 액세스하려면 어떻게해야합니까?

웹 이외의 응용 프로그램에서 Spring을 사용하고 있으며 LiorH에서 설명한대로 공유 ApplicationContext객체 에 액세스하려고 계획했습니다 .

개정

아래 답변을 수락하지만 Martin Fowler 가 의존성 주입의 장점과 서비스 로케이터 사용 (기본적으로 랩핑 된 호출과 동일) 을 논의 하는 대안이 있습니다 ApplicationContext.getBean().

Fowler는 " 서비스 로케이터를 사용하면 응용 프로그램 클래스가 로케이터에 메시지로 명시 적으로 서비스를 요청합니다. 주입을 통해 명시적인 요청이 없으면 서비스가 응용 프로그램 클래스에 표시되므로 제어가 반전됩니다. 제어 역전은 프레임 워크의 일반적인 기능이지만 가격이 비싸기 때문에 이해하기 어렵고 디버그하려고 할 때 문제가 발생할 수 있으므로 전체적으로는이를 피하는 것이 좋습니다. ] 나는 그것을 필요로하지 않는 한.이 그것을 나는 그것이 더 간단 대안을 통해 자신을 정당화하기 위해 필요하다고 생각 그냥 나쁜 일이 말할 수 없습니다. "

답변:


202

나는 다른 질문에 대한 의견에서 이것을 언급했지만, Inversion of Control의 전체 아이디어는 클래스가 그들이 의존하는 객체를 얻는 방법을 알거나 신경 쓰지 않는 것입니다 . 따라서 언제든지 사용하는 특정 종속성의 구현 유형을 쉽게 변경할 수 있습니다. 또한 종속성의 모의 구현을 제공 할 수 있으므로 클래스를 쉽게 테스트 할 수 있습니다. 마지막으로 수업이 더 간단 해집니다. 하고 핵심 책임에 집중할 수 있습니다.

부름 ApplicationContext.getBean() 은 통제의 역전이 아니다! 주어진 bean 이름에 대해 구현 구현을 변경하는 것은 여전히 ​​쉽지만 클래스는 이제 의존성을 제공하기 위해 Spring에 직접 의존하며 다른 방법으로는 얻을 수 없습니다. 테스트 클래스에서 모의 ​​구현을 만들어서 직접 전달할 수는 없습니다. 이것은 기본적으로 의존성 주입 컨테이너로서 Spring의 목적을 무효화합니다.

당신이 말하고 싶은 곳 :

MyClass myClass = applicationContext.getBean("myClass");

예를 들어, 메소드를 선언해야합니다.

public void setMyClass(MyClass myClass) {
   this.myClass = myClass;
}

그런 다음 구성에서 :

<bean id="myClass" class="MyClass">...</bean>

<bean id="myOtherClass" class="MyOtherClass">
   <property name="myClass" ref="myClass"/>
</bean>

그러면 스프링이 자동으로에 주입 myClass됩니다 myOtherClass.

이런 식으로 모든 것을 선언하고 그 근본에는 다음과 같은 것이 있습니다.

<bean id="myApplication" class="MyApplication">
   <property name="myCentralClass" ref="myCentralClass"/>
   <property name="myOtherCentralClass" ref="myOtherCentralClass"/>
</bean>

MyApplication가장 중심적인 클래스이며 프로그램의 다른 모든 서비스에 간접적으로 의존합니다. 부트 스트랩 할 때 main메소드에서 호출 할 수 applicationContext.getBean("myApplication")있지만 getBean()다른 곳에서는 호출 할 필요가 없습니다 !


3
객체를 만들 때 주석 으로 작동하는 것과 관련이 new MyOtherClass()있습니까? 나는 @Autowired에 대해 알고 있지만, 나는 그것을 필드에서만 사용했고 그것은 new MyOtherClass()..
Tim

70
ApplicationContext.getBean ()이 IoC가 아닌 것은 사실이 아닙니다. Niether는 Spring에서 모든 클래스를 인스턴스화 해야 합니다 . 그것은 부적절한 교리입니다. ApplicationContext 자체가 주입되면, 이런 식으로 Bean을 인스턴스화하도록 요청하는 것이 좋습니다. 생성 된 Bean은 처음에 주입 된 ApplicationContext에 따라 다른 구현이 될 수 있습니다. 예를 들어 컴파일 타임에는 알 수 없지만 spring.xml 파일에 정의 된 구현 중 하나와 일치하는 Bean 이름을 기반으로 새 Bean 인스턴스를 동적으로 작성하는 시나리오가 있습니다.
Alex Worden

3
Alex와 동의합니다. 동일한 문제가 있습니다. 팩토리 클래스는 사용자 상호 작용을 통해 런타임에 사용할 Bean 또는 구현 만 알 수 있습니다. 이것이 ContextAware 인터페이스가있는 곳이라고 생각합니다.
Ben

3
@elbek : applicationContext.getBean의존성 주입이 아닙니다 : 서비스 로케이터 로 프레임 워크를 직접 사용하여 프레임 워크에 액세스합니다 .
ColinD

6
@ herman : 나는 오랫동안 그것을 사용하지 않았기 때문에 Spring에 대해 모른다. 그러나 JSR-330 / Guice / Dagger에서는 a Provider<Foo>대신 에 주입하고 필요할 때마다 Foo호출 하여이 작업을 수행 할 것이다 provider.get(). 새로운 인스턴스. 컨테이너 자체에 대한 참조가 없으며 Provider테스트를 위해 쉽게 만들 수 있습니다 .
ColinD 2016 년

64

IoC (Inversion of Control)보다 Service Locator를 선호하는 이유는 다음과 같습니다.

  1. 서비스 로케이터는 다른 사람들이 귀하의 코드를 따르는 것이 훨씬 쉽습니다. IoC는 '매직'이지만 유지 보수 프로그래머는 복잡한 스프링 구성과 수많은 위치를 이해하여 객체의 배선 방법을 파악해야합니다.

  2. IoC는 구성 문제를 디버깅하는 데 끔찍합니다. 특정 클래스의 응용 프로그램에서는 잘못 구성 될 때 응용 프로그램이 시작되지 않으며 디버거에서 진행중인 작업을 단계별로 진행할 수 없습니다.

  3. IoC는 주로 XML 기반입니다 (주석은 개선하지만 여전히 많은 XML이 있습니다). 이는 개발자가 Spring에서 정의한 모든 매직 태그를 알지 못하면 프로그램에서 작업 할 수 없음을 의미합니다. 더 이상 Java를 아는 것만으로는 충분하지 않습니다. 이는 경험이 적은 프로그래머를 방해합니다 (즉, Service Locator와 같은 더 간단한 솔루션이 동일한 요구 사항을 충족 할 때 더 복잡한 솔루션을 사용하는 것은 실제로 디자인이 좋지 않습니다). 또한 XML 문제 진단에 대한 지원은 Java 문제에 대한 지원보다 훨씬 약합니다.

  4. 의존성 주입은 더 큰 프로그램에 더 적합합니다. 대부분의 경우 추가 복잡성은 그만한 가치가 없습니다.

  5. "나중에 구현을 변경하고 싶을 때"를 위해 종종 스프링이 사용됩니다. Spring IoC의 복잡성없이이를 달성하는 다른 방법이 있습니다.

  6. 웹 애플리케이션 (Java EE WAR)의 경우, 스프링 컨텍스트는 컴파일 시점에 효과적으로 바인딩됩니다 (폭발 된 전쟁에서 운영자가 컨텍스트 주위를 문지르지 않는 한). 스프링이 프로퍼티 파일을 사용하도록 할 수 있지만, 서블릿을 사용하여 프로퍼티 파일은 미리 결정된 위치에 있어야합니다. 즉, 같은 상자에 동시에 여러 개의 서블릿을 배포 할 수 없습니다. JNDI와 함께 Spring을 사용하여 서블릿 시작 시간에 특성을 변경할 수 있지만 관리자가 수정 가능한 매개 변수에 JNDI를 사용하는 경우 Spring 자체의 필요성이 줄어 듭니다 (JNDI는 사실상 서비스 로케이터이므로).

  7. Spring을 사용하면 Spring이 메소드로 디스패치하면 프로그램 제어를 잃을 수 있습니다. 이 방법은 편리하며 여러 유형의 응용 프로그램에서 작동하지만 전부는 아닙니다. 초기화 중에 작업 (스레드 등)을 생성해야하거나 스프링이 내용이 WAR에 바인딩 된 시점을 알지 못하는 수정 가능한 리소스가 필요할 때 프로그램 흐름을 제어해야 할 수도 있습니다.

Spring은 트랜잭션 관리에 매우 적합하며 몇 가지 장점이 있습니다. 많은 상황에서 IoC가 과도하게 엔지니어링 될 수 있으며 유지 보수 담당자에게 불필요하게 복잡한 문제가 발생할 수 있습니다. IoC를 먼저 사용하지 않는 방법을 생각하지 않고 자동으로 사용하지 마십시오.


7
또한 ServiceLocator는 항상 Spring의 IoC를 사용하여 코드가 Spring에 의존하지 않고 Spring 주석으로 흩어져 있고 해독 할 수없는 magik을 추상화 할 수 있습니다. 최근 Spring이 지원되지 않는 GoogleAppEngine에 많은 코드를 이식했습니다. ServiceFactory 뒤에 모든 IoC를 숨기고 싶습니다!
Alex Worden

IoC는 빈혈 도메인 모델을 권장합니다. Entity Bean은 자신의 동작을 구현할 수 있도록 서비스를 찾는 방법이 필요합니다. 이 계층에서는 실제로 서비스 로케이터가 필요하지 않습니다.
Joel

4
기괴한. 주석과 함께 Spring을 항상 사용합니다. 실제로 특정 학습 곡선이 관련되어 있지만 지금은 유지 관리, 디버깅, 명확성, 가독성에 문제가 없습니다.
Lawrence

25

application-context.xml에 클래스를 포함하면 getBean을 사용할 필요가 없다는 것이 사실입니다. 그러나 실제로는 불필요합니다. 독립형 애플리케이션을 작성 중이고 application-context.xml에 드라이버 클래스를 포함하지 않으려는 경우 다음 코드를 사용하여 스프링이 드라이버의 종속성을 자동으로 연결하도록 할 수 있습니다.

public class AutowireThisDriver {

    private MySpringBean mySpringBean;    

    public static void main(String[] args) {
       AutowireThisDriver atd = new AutowireThisDriver(); //get instance

       ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(
                  "/WEB-INF/applicationContext.xml"); //get Spring context 

       //the magic: auto-wire the instance with all its dependencies:
       ctx.getAutowireCapableBeanFactory().autowireBeanProperties(atd,
                  AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, true);        

       // code that uses mySpringBean ...
       mySpringBean.doStuff() // no need to instantiate - thanks to Spring
    }

    public void setMySpringBean(MySpringBean bean) {
       this.mySpringBean = bean;    
    }
}

내 응용 프로그램의 일부 측면 (예 : 테스트)을 사용해야하는 일종의 독립형 클래스가있을 때이 작업을 몇 번 수행해야했지만 그렇지 않기 때문에 응용 프로그램 컨텍스트에 포함하고 싶지 않습니다. 실제로 앱의 일부입니다. 또한 이것은 항상 추악하다고 생각한 문자열 이름을 사용하여 Bean을 조회 할 필요가 없도록합니다.


@Autowired주석 과 함께이 방법을 성공적으로 사용할 수있었습니다 .
blong

21

Spring과 같은 것을 사용하는 가장 멋진 이점 중 하나는 객체를 함께 연결할 필요가 없다는 것입니다. Zeus의 헤드 스플릿이 열리고 클래스가 나타나며 필요에 따라 모든 종속성이 작성되고 유선으로 구성됩니다. 마법적이고 환상적입니다.

말을 많이하면할수록 ClassINeed classINeed = (ClassINeed)ApplicationContext.getBean("classINeed");마법이 줄어 듭니다. 코드가 적을수록 거의 항상 좋습니다. 만약 당신의 클래스가 실제로 ClassINeed bean을 필요로한다면 왜 그냥 연결하지 않았습니까?

즉, 첫 번째 객체를 만들어야 할 것이 분명합니다. getBean ()을 통해 bean을 가져 오는 두 가지 주요 메소드에는 아무런 문제가 없지만 사용할 때마다 Spring의 모든 마술을 실제로 사용하지 않기 때문에 피해야합니다.


1
그러나 OP는 "ClassINeed"라고 말하지 않고 "BeanNameINeed"라고 말하며 IoC 컨테이너는 어떤 방식 으로든 구성된 클래스에서 인스턴스를 만들 수 있습니다. 아마도 IoC보다 "서비스 로케이터"패턴과 비슷하지만 연결이 느슨합니다.
HDave

16

동기는 Spring에 명시 적으로 의존하지 않는 코드를 작성하는 것입니다. 이렇게하면 컨테이너를 전환하기로 선택한 경우 코드를 다시 작성할 필요가 없습니다.

컨테이너는 코드에 보이지 않는 것으로 생각하면 요청없이 마법의 요구를 충족시킬 수 있습니다.

의존성 주입은 "서비스 로케이터"패턴에 대한 대응점입니다. 이름으로 종속성을 조회하려는 경우 DI 컨테이너를 제거하고 JNDI와 같은 것을 사용할 수 있습니다.


11

사용 @Autowired또는 것은 ApplicationContext.getBean()정말 같은 일이다. 두 가지 방법으로 컨텍스트에 구성된 Bean을 얻고 두 가지 방법으로 코드가 스프링에 의존합니다. 피해야 할 유일한 것은 ApplicationContext를 인스턴스화하는 것입니다. 이 작업은 한 번만 수행하십시오! 다시 말해,

ApplicationContext context = new ClassPathXmlApplicationContext("AppContext.xml");

응용 프로그램에서 한 번만 사용해야합니다.


아니. 때때로 @Autowired 또는 ApplicationContext.getBean ()은 완전히 다른 빈을 생성 할 수 있습니다. 어떻게 된지 잘 모르겠지만 지금이 문제로 어려움을 겪고 있습니다.
Oleksandr_DJ

4

아이디어는 의존성 주입 ( inversion of control 또는 IoC) 에 의존한다는 것 입니다. 즉, 구성 요소는 필요한 구성 요소로 구성됩니다. 이러한 의존성은 (생성자 또는 설정자를 통해) 주입 됩니다-당신은 스스로를 얻지 못합니다.

ApplicationContext.getBean()컴포넌트 내에서 명시 적으로 Bean의 이름을 지정해야합니다. 대신 IoC를 사용하여 구성에 따라 사용할 구성 요소를 결정할 수 있습니다.

이를 통해 다양한 구성 요소 구현으로 응용 프로그램을 쉽게 다시 연결하거나 모의 변형 (예 : 모의 DAO를 제공하여 테스트 중에 데이터베이스에 충돌하지 않도록 함)을 제공하여 간단한 테스트 방식으로 개체를 구성 할 수 있습니다.


4

다른 사람들은 일반적인 문제를 지적했지만 (유효한 답변입니다) 추가 의견을 하나 제시하겠습니다. 절대로 그렇게해서는 안되는 것이 아니라 가능한 한 적게 수행하는 것입니다.

일반적으로 이것은 부트 스트랩 중에 정확히 한 번만 수행됨을 의미합니다. 그리고 다른 의존성을 해결할 수있는 "루트"빈에 액세스하는 것입니다. 이것은 기본 서블릿과 같이 재사용 가능한 코드 일 수 있습니다 (웹 앱을 개발하는 경우).


4

Spring 구내 중 하나는 커플 링을 피하는 것 입니다. 인터페이스, DI, AOP를 정의하고 사용하며 ApplicationContext.getBean () :-) 사용을 피하십시오


4

이유 중 하나는 테스트 가능성입니다. 이 수업이 있다고 가정 해보십시오.

interface HttpLoader {
    String load(String url);
}
interface StringOutput {
    void print(String txt);
}
@Component
class MyBean {
    @Autowired
    MyBean(HttpLoader loader, StringOutput out) {
        out.print(loader.load("http://stackoverflow.com"));
    }
}

이 콩을 어떻게 테스트 할 수 있습니까? 예를 들면 다음과 같습니다.

class MyBeanTest {
    public void creatingMyBean_writesStackoverflowPageToOutput() {
        // setup
        String stackOverflowHtml = "dummy";
        StringBuilder result = new StringBuilder();

        // execution
        new MyBean(Collections.singletonMap("https://stackoverflow.com", stackOverflowHtml)::get, result::append);

        // evaluation
        assertEquals(result.toString(), stackOverflowHtml);
    }
}

쉬워요?

여전히 주석에 의존하여 Spring에 의존하는 동안 코드를 변경하지 않고 (주석 정의 만) 스프링에 대한 의존성을 제거 할 수 있으며 테스트 개발자는 스프링 작동 방식에 대해 아무것도 알 필요가 없습니다 (어쨌든 그는해야하지만 봄과는 별도로 코드를 검토하고 테스트 할 수 있습니다).

ApplicationContext를 사용할 때 여전히 동일한 작업을 수행 할 수 있습니다. 그러나 ApplicationContext거대한 인터페이스 를 조롱해야합니다 . 더미 구현이 필요하거나 Mockito와 같은 조롱 프레임 워크를 사용할 수 있습니다.

@Component
class MyBean {
    @Autowired
    MyBean(ApplicationContext context) {
        HttpLoader loader = context.getBean(HttpLoader.class);
        StringOutput out = context.getBean(StringOutput.class);

        out.print(loader.load("http://stackoverflow.com"));
    }
}
class MyBeanTest {
    public void creatingMyBean_writesStackoverflowPageToOutput() {
        // setup
        String stackOverflowHtml = "dummy";
        StringBuilder result = new StringBuilder();
        ApplicationContext context = Mockito.mock(ApplicationContext.class);
        Mockito.when(context.getBean(HttpLoader.class))
            .thenReturn(Collections.singletonMap("https://stackoverflow.com", stackOverflowHtml)::get);
        Mockito.when(context.getBean(StringOutput.class)).thenReturn(result::append);

        // execution
        new MyBean(context);

        // evaluation
        assertEquals(result.toString(), stackOverflowHtml);
    }
}

이것은 상당히 가능성이 있지만 대부분의 사람들은 첫 번째 옵션이 더 우아하고 테스트가 더 간단하다는 데 동의 할 것입니다.

실제로 문제가되는 유일한 옵션은 다음과 같습니다.

@Component
class MyBean {
    @Autowired
    MyBean(StringOutput out) {
        out.print(new HttpLoader().load("http://stackoverflow.com"));
    }
}

이를 테스트하려면 많은 노력이 필요하거나 Bean이 각 테스트에서 stackoverflow에 연결하려고 시도합니다. 네트워크 장애가 발생하거나 (혹은 초과 액세스 속도로 인해 stackoverflow의 관리자가 사용자를 차단하면) 무작위로 테스트에 실패하게됩니다.

결론적 ApplicationContext으로 직접 사용이 자동으로 잘못되어 모든 비용을 피해야 한다고 말하고 싶지는 않습니다 . 그러나 더 나은 옵션이 있고 대부분의 경우 더 좋은 옵션을 사용하십시오.


3

getBean ()이 필요한 두 가지 상황 만 발견했습니다.

다른 사람들은 main ()에서 getBean ()을 사용하여 독립형 프로그램의 "main"Bean을 가져 오는 것을 언급했습니다.

getBean ()의 또 다른 용도는 대화 형 사용자 구성이 특정 상황에 대한 Bean 구성을 결정하는 상황입니다. 예를 들어 부트 시스템의 일부는 getBean ()을 scope = 'prototype'Bean 정의와 함께 사용하고 추가 특성을 설정하여 데이터베이스 테이블을 반복합니다. 아마도 응용 프로그램 컨텍스트 XML을 작성 (재)하려고 시도하는 것보다 더 친숙한 데이터베이스 테이블을 조정하는 UI가있을 것입니다.


3

getBean을 사용할 때 또 다른 시간이 있습니다. 이미 존재하는 시스템을 재구성하는 경우 스프링 컨텍스트 파일에서 종속성이 명시 적으로 호출되지 않습니다. getBean을 호출하여 프로세스를 시작할 수 있으므로 한 번에 모두 연결할 필요가 없습니다. 이런 식으로 스프링 구성을 천천히 구축하여 시간이 지남에 따라 각 조각을 제자리에 놓고 비트를 올바르게 정렬 할 수 있습니다. getBean에 대한 호출은 결국 대체 될 것이지만, 코드 구조를 이해하거나 부족할 때 점점 더 많은 Bean을 연결하고 getBean에 대한 더 적은 수의 호출을 사용하는 프로세스를 시작할 수 있습니다.


2

그러나 서비스 로케이터 패턴이 필요한 경우가 여전히 있습니다. 예를 들어 컨트롤러 빈이 있는데이 컨트롤러에는 기본 서비스 빈이있을 수 있으며 구성에 의해 종속성이 주입 될 수 있습니다. 이 컨트롤러가 현재 또는 나중에 호출 할 수있는 추가 또는 새 서비스가 많을 수 있으며 서비스 로케이터가 서비스 Bean을 검색해야합니다.


당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.