nunca utilizado @Autowired, que tienden a preferir el uso de parámetros en los constructores, pero a veces es difícil entender lo que significan los parámetros, especialmente si tiene muchos parámetros; en ese caso, prefiero usar el enfoque "Constructor" descrito en Java efectivo. El constructor recibe el objeto de compilación (que tiene definidores) y se construye con él. Los atributos inyectados de la clase son finales (inmutabilidad), la clase "Builder" contiene setters pero no getters (no es necesario ya que lo declaramos como una clase interna de la clase que se está construyendo), y no se necesitan setters para ser creado sólo para la primavera:
<bean id="runnable" class="MyClass">
<constructor-arg>
<bean class="MyClass$Builder">
<property name="p1" value="p1Value"/>
<property name="p2" value="p2Value"/>
<property name="p3" value="p3Value"/>
<property name="p4" value="p4Value"/>
</bean>
</constructor-arg>
</bean>
código de clase:
public class MyClass {
private final String p1;
private final String p2;
private final String p3;
private final String p4;
public MyClass(Builder builder) {
this.p1 = builder.p1;
this.p2 = builder.p2;
this.p3 = builder.p3;
this.p4 = builder.p4;
}
...
public static class Builder {
private String p1;
private String p2;
private String p3;
private String p4;
public void setP1(String p1) {
this.p1 = p1;
}
... and so on
}
}
Esta respuesta implica que "codificación de interfaces" significa que cada clase debe implementar una interfaz separada. Esto no es lo que significa el principio, como se describe en el libro de GoF. En realidad, solo se aplica para casos en los que necesita, o ya tiene, dos tipos de objetos separados, uno para la abstracción (interfaz) y otro para una implementación de esa abstracción. –
Creo que es probable que descubras que las clases que necesitan inyectarse entre sí en una aplicación común de Spring son ** clases de ** servicios, como 'Dao's, etc. He descubierto que un gran número de ellas podría posiblemente tenga implementaciones alternativas –
Sí, cuando tiene implementaciones múltiples se aplica el principio "codificar a la interfaz, no la implementación". Pero decir cosas como "si codifica a las interfaces ..." sin un contexto claro es engañoso, y los desarrolladores menos experimentados pueden malinterpretarlo fácilmente.El uso excesivo de interfaces separadas causa un gran daño, IMO. –