Spring: ¿Por qué conectamos automáticamente la interfaz y no la clase implementada?

Ejemplo

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

¿Alguien puede explicarme esto?

• ¿Cómo sabe la primavera qué tipo polimórfico usar?
• ¿Necesito @Qualifiero @Resource?
• ¿Por qué conectamos automáticamente la interfaz y no la clase implementada?

¿Cómo sabe la primavera qué tipo polimórfico usar?

Siempre y cuando solo haya una implementación única de la interfaz y esa implementación esté anotada con @Componentel escaneo de componentes de Spring habilitado, Spring Framework puede encontrar el par (interfaz, implementación). Si la exploración de componentes no está habilitada, debe definir el bean explícitamente en su application-config.xml (o un archivo de configuración de resorte equivalente).

¿Necesito @Qualifier o @Resource?

Una vez que tenga más de una implementación, deberá calificar cada una de ellas y, durante el cableado automático, deberá usar la @Qualifieranotación para inyectar la implementación correcta, junto con la @Autowiredanotación. Si está utilizando @Resource (semántica J2EE), debe especificar el nombre del bean utilizando el nameatributo de esta anotación.

¿Por qué conectamos automáticamente la interfaz y no la clase implementada?

En primer lugar, siempre es una buena práctica codificar interfaces en general. En segundo lugar, en caso de primavera, puede inyectar cualquier implementación en tiempo de ejecución. Un caso de uso típico es inyectar una implementación simulada durante la etapa de prueba.

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

Su configuración de bean debería verse así:

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

Alternativamente, si habilitó la exploración de componentes en el paquete donde están presentes, entonces debe calificar cada clase de la @Componentsiguiente manera:

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

Entonces workeren MyRunnerserá inyectado con una instancia del tipo B.

También puede causar algunas advertencias en registros como Cglib2AopProxy No se puede usar el método proxy . Y aquí se describen muchas otras razones para esto ¿Por qué siempre tener interfaces de implementación única en las capas de servicio y dao?