Inyección de dependencia "Component"

También funciona inyectar una dependencia con solo la instancia de la interfaz y agregándole las anotaciones pertinentes, sin tener que usar un método constructor:

@Autowired
	@Qualifier("componentTwoImplement")
	private ComponentDependency componentDependency;

En la versión 2.6.3 de Spring, se puede agregar la etiqueta @Primary a la implementación que queramos utilizar, y esta se tomará como la principal.

Estoy entendiendo nadita…

el profesor sabe mucho, pero no sabe enseñar.

En este caso prefiero youtube
https://www.youtube.com/watch?v=7vHzVN0EiQc

Si te llegó aparecer este error:

Esta es la solución, da clic donde dice “Open project settings.” y te aparecerá la siguiente ventana:

En “SDK” darás clic en la lista desplegable, clic en “+ Add SDK” y en “Download JDK”.

Darás clic en la lista desplegable de “Version” y clic en la opción “17” (en el caso que te haya aparecido 17 como en la primera imagen).

Darás clic en el botón “Download”.

Clic en el botón “Ok”.

En la parte de abajo a la derecha aparecerá un mensaje que se esta descargando o instalando la versión.

Una vez instalado, vas al archivo FundamentosApplication.java, clic derecho y clic en la opción que diga al principio “Run” como se ve en la imagen.

Para terminar, te aparecerá en la consola el mensaje que pusiste en el método saludar();

No me marco el error del final pero igual agregue la anotacion de “@Qualifier” y funciono como en el video, aun que algunas personas en los comentarios dice que puedes usar @Primary

@Autowired es muy imporante al momento de autocablear nuestras soluciones, es cierto que hoy dia no es tan recomendada para nuestros proyectos, pero la verdad la idea es hacer el código menos verboso y esto simplifica muchísimo el código fuente.
Por otra parte, @Qualifier: es una anotación que sirve para especificar el tipo de dependencia se esta inyectando con la funcionalidad de diferenciar nuestras abstracciones o uso de clases que implementan una misma interfaz (Según el principio SOLID) porque si usamos concreciones no seria util usar Qualifiers en la mayoría de los casos.

Gracias por la clase. Personalmente, me gusta el Autowired porque no tengo que inferir que esta pasando mientras leo el codigo. Siento que a medida que crece el repositorio, lo hace mas legible.

Lo único que no me gusta del curso es que siento que Michael hace las cosas como al revés y eso puede confundir un poco a las personas, es decir, primero implementa una interface y después la crea y así con otras cosas…

Esta clase me gusto.

Esta parte me pareció super confusa recién empecé con spring, este tipo lo explico soberbio

La anotación @qualifier define una preferencia cuando hay varios beans del mismo tipo.

@Autowired indica de forma explícita la necesidad de inyectar una dependencia en Spring. Hay casos en que esta anotación por sí sola no es suficiente para que Spring comprenda qué bean debe inyectar, este problema lo resuelve la anotacion @qualifier.

Uy, no sabia que el @autowired ahora es opcional

Lo que veo redundante es que al hacer un contructor directamante estamos inyectando la dependencia, no es que Spring lo haga automaticamante sin colocar la anotacion @Autowired, en caso de que no iniciemos la dependencia con algun metodo constructor si o si debemos usar @Autowired ya que es la manera como spring nos ayuda a inyectar esa dependencia.

Hola si usan Lombok, pueden poner esta anotación sin necesidad de usar crear el constructor

@SpringBootApplication
**@RequiredArgsConstructor**
public class FundamentosApplication implements CommandRunner {

	private final ComponentDependency componentDependency;
...........
...........
...........

}

Más de Lombok:
https://projectlombok.org/features/constructor
https://projectlombok.org/features/all

Otra opción que pueden usar es poner el nombre de la dependencia que desean usar en la variable que crean y en el constructor y ya spring sabe que bean usar

private ComponentDependency componentTwoImplement;

	public FundamentosApplication(ComponentDependency componentTwoImplement){
		this.componentTwoImplement = componentTwoImplement;
	}

	public static void main(String[] args) {
		SpringApplication.run(FundamentosApplication.class, args);
	}

	@Override
	public void run(String... args) throws Exception {
		componentTwoImplement.saludar();
	}

En windows, si quieres agregar el constructor de forma mas sencilla, despues de declarar ComponentDependency presiona la combinación de teclas Alt + insert, te aparacerá un recuadro y seleccionas ‘constructor’, enseguida se mostrará otro recuadro con los campos que puedes agregar al constructor, en este caso solo aparecerá el de componentDependency, lo seleccionas, le das enter y listo!! el constructor se genera automáticamente.

totalmente perdido 😦

claramente Platzi debe hacer una actualización de los cursos…

Para poner

System.out.println();

más rápido solo escriban

sout

y luego la tecla tabular.

se implementa una interfas(Tiene un metodo saludar) en una clase, en esa clase se hace la logica de negocio y se inyercata esa dependica a la clase principal para poder hacer algo con ella, como implementar interfaces grafica que me muestre el saludo.

Cuando tenemos dos dependencias del mismo tipo (como en este caso, 2 clases que implementan la misma Interface) al momento de realizar la inyeccion de la dependencia debemos especificar con @Qualifier que tipo de objeto inyectar. @Qualifier se puede usar en combinacion con @Autowired.

Entender esta clase es entender Spring, que buena explicación