Primavera: Por que ligamos automaticamente a interface e não a classe implementada?

Exemplo

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

Alguém pode me explicar isso.

• Como a primavera sabe qual tipo polimórfico usar.
• Eu preciso @Qualifierou@Resource ?
• Por que conectamos automaticamente a interface e não a classe implementada?

Como a primavera sabe qual tipo polimórfico usar.

Desde que haja apenas uma única implementação da interface e essa implementação seja anotada com @Componenta verificação de componente do Spring ativada, a estrutura do Spring pode descobrir o par (interface, implementação). Se a varredura de componentes não estiver ativada, você deverá definir explicitamente o bean no seu application-config.xml (ou arquivo de configuração equivalente da primavera).

Preciso de @Qualifier ou @Resource?

Depois de ter mais de uma implementação, você precisará qualificar cada uma delas e, durante a fiação automática, você precisará usar a @Qualifieranotação para injetar a implementação correta, juntamente com a @Autowiredanotação. Se você estiver usando @Resource (semântica J2EE), deverá especificar o nome do bean usando o nameatributo desta anotação.

Por que conectamos automaticamente a interface e não a classe implementada?

Em primeiro lugar, é sempre uma boa prática codificar para interfaces em geral. Em segundo lugar, no caso da primavera, você pode injetar qualquer implementação em tempo de execução. Um caso de uso típico é injetar implementação simulada durante o estágio de teste.

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

Sua configuração de bean deve ficar assim:

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

Como alternativa, se você ativou a varredura de componentes no pacote em que estes estão presentes, você deve qualificar cada classe da @Componentseguinte maneira:

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

Em seguida, workerem MyRunnervai ser injectado com uma instância do tipo B.

Também pode causar alguns avisos em logs como um método Cglib2AopProxy Unable to proxy . E muitas outras razões para isso são descritas aqui. Por que sempre há interfaces de implementação únicas nas camadas de serviço e dao?