Spring: Dlaczego autowireujemy interfejs, a nie zaimplementowaną klasę?

Przykład

interface IA
{
  public void someFunction();
}

@Resource(name="b")
class B implements IA
{
  public void someFunction()
  {
    //busy code block
  }
  public void someBfunc()
  {
     //doing b things
  }
}

@Resource(name="c")
class C implements IA
{
  public void someFunction()
  {
    //busy code block
  }
  public void someCfunc()
  {
     //doing C things
  }
}

class MyRunner
{

  @Autowire
  @Qualifier("b") 
  IA worker;

  worker.someFunction();
}

Czy ktoś może mi to wyjaśnić.

• Skąd wiosna wie, jakiego typu polimorficznego użyć.
• Czy potrzebuję @Qualifierczy @Resource?
• Dlaczego autowireujemy interfejs, a nie zaimplementowaną klasę?

Skąd wiosna wie, jakiego typu polimorficznego użyć.

Dopóki istnieje tylko jedna implementacja interfejsu i ta implementacja jest opatrzona adnotacją z @Componentwłączonym skanowaniem komponentów Springa, Spring Framework może znaleźć parę (interfejs, implementacja). Jeśli skanowanie komponentów nie jest włączone, musisz jawnie zdefiniować komponent bean w pliku application-config.xml (lub w równoważnym pliku konfiguracyjnym sprężyny).

Czy potrzebuję @Qualifier lub @Resource?

Gdy masz więcej niż jedną implementację, musisz zakwalifikować każdą z nich, a podczas automatycznego okablowania musisz użyć @Qualifieradnotacji, aby wstrzyknąć właściwą implementację wraz z @Autowiredadnotacją. Jeśli używasz @Resource (semantyka J2EE), powinieneś określić nazwę ziarna, używając nameatrybutu tej adnotacji.

Dlaczego autowireujemy interfejs, a nie zaimplementowaną klasę?

Po pierwsze, ogólnie rzecz biorąc, dobrą praktyką jest kodowanie interfejsów. Po drugie, w przypadku wiosny możesz wstrzyknąć dowolną implementację w czasie wykonywania. Typowym przypadkiem użycia jest wstrzyknięcie fałszywej implementacji na etapie testowania.

interface IA
{
  public void someFunction();
}


class B implements IA
{
  public void someFunction()
  {
    //busy code block
  }
  public void someBfunc()
  {
     //doing b things
  }
}


class C implements IA
{
  public void someFunction()
  {
    //busy code block
  }
  public void someCfunc()
  {
     //doing C things
  }
}

class MyRunner
{
     @Autowire
     @Qualifier("b") 
     IA worker;

     ....
     worker.someFunction();
}

Twoja konfiguracja fasoli powinna wyglądać następująco:

<bean id="b" class="B" />
<bean id="c" class="C" />
<bean id="runner" class="MyRunner" />

Alternatywnie, jeśli włączyłeś skanowanie komponentów w pakiecie, w którym są one obecne, powinieneś zakwalifikować każdą klasę @Componentw następujący sposób:

interface IA
{
  public void someFunction();
}

@Component(value="b")
class B implements IA
{
  public void someFunction()
  {
    //busy code block
  }
  public void someBfunc()
  {
     //doing b things
  }
}


@Component(value="c")
class C implements IA
{
  public void someFunction()
  {
    //busy code block
  }
  public void someCfunc()
  {
     //doing C things
  }
}

@Component    
class MyRunner
{
     @Autowire
     @Qualifier("b") 
     IA worker;

     ....
     worker.someFunction();
}

Następnie workerw MyRunnerbędą wstrzyknięto przykład typu B.

Może również powodować pewne ostrzeżenia w dziennikach, takie jak metoda Cglib2AopProxy Unable to proxy . I wiele innych powodów tego jest opisanych tutaj. Dlaczego zawsze mają pojedyncze interfejsy implementacji w warstwach usług i dao?