Ejemplo de creación de dependencia propia

No se si le pasó a otros en esta clase, pero aun prestando fuerte atención a las anteriores, cuando la vi por primera vez no me quedó claro por qué se tenía que crear el archivo MyConfigurationBean.java; después de devolverme varias veces a clases anteriores y leer detenidamente los aportes (incluso ver videos externos que algunos incluyeron en sus aportes) pude entenderlo un poco más, pero me molestó que no fuera claro en el hilo normal de las clases. Yo creo que es mejor explicar lo que está en esta clase como la base sobre la cual se implementa el patrón de Inversión de Control (lo cual hubiera hecho mucho más clara la clase anterior sobre el tema) y después como se puede hacer de forma diferente por medio de las anotaciones @component, @controller, @cepository y @service. Es una lástima que a veces, en función de hacer cursos prácticos para la gente, se pierda la posibilidad de abordar a profundidad conceptos claves para entender como desarrolladores qué es lo que de verdad hace el código que escribimos.

Quizá sería más claro si en vez de crear una dependencia de tres clases con nombres totalmente random se hiciera un ejemplo real o al menos con algo de contexto.

Si quieres acceder rápido a la implementación de un método sin pasar por la interfaz, presiona Ctrl + Alt y luego clic sobre el método y te lleva a la implementación.

Un diagrama previo hubiera sido de ayuda en este video.

MiConfigureichonBin! 🤪

Esta clase me pareció de lo mas Horrible.

Sería de mucho provecho, antes de codificar los ejemplos, hacer uso de diagramas UML, para ver de una forma sencilla, cómo interactúan las clases, interfaces y demás. De resto, buen video 👌.

Este curso le faltan algunos detalles, los ejemplos deberían ser casos reales, los nombres de los archivos son muy random y si fuera algo real se asimilaria mejor la aplicación

Reto completado.

He utilizado un poco de programacion funcional para reforzar lo aprendido del curso de Platzi, usando Streams.

Dependencia principal

• MyOwnOperation interface:

  public interface MyOwnOperation {
  	List<Integer> generateRandomElements(int maxElement, int maxLimit);
  }
  

• MyOwnOperationImplement class:

  public class MyOwnOperationImplement implements MyOwnOperation{
  	@Override
  	public List<Integer> generateRandomElements(int maxElement, int maxLimit) {
      	return new Random().ints(0, maxElement)
              	.limit(maxLimit)
              	.boxed()    // Regresa un IntStream
                  .collect(Collectors.toList());
     	}
  }
  

Bean con dependencia

• MyOwnBeanWithDependency interface:

  public class MyOwnBeanWithDependencyImplement implements MyOwnBeanWithDependency{
  	private MyOwnOperation myOwnOperation;
  
  	public MyOwnBeanWithDependencyImplement(MyOwnOperation myOwnOperation) {
  		this.myOwnOperation = myOwnOperation;
  	}
  	
  	@Override
  	public void displayElements() {
  		System.out.println("Llamamos a MyOwnOperationImplement para generar lista aleatoria");
  		List<Integer> randNums = this.myOwnOperation.generateRandomElements(500, 10);
  		randNums.forEach(System.out::println);
  		System.out.println("Hola desde mi implementacion de un bean con dependencia usando Streams y Listas");
  	}
  

Configuracion

    @Bean
    public MyOwnOperation beanOperationMyOwn() {
        return new MyOwnOperationImplement();
    }

    @Bean
    public MyOwnBeanWithDependency beanOperationMyOwnWithDependency(MyOwnOperation myOwnOperation){
        return new MyOwnBeanWithDependencyImplement(myOwnOperation);
    }

Main

 public FundamentosApplication(@Qualifier("componentTwoImplement") ComponentDependency componentDependency,
                                  MyBean myBean,
                                  MyBeanWithDependency myBeanWithDependency,
                                  MyOwnBeanWithDependency myOwnBeanWithDependency) {
        this.componentDependency = componentDependency;
        this.myBean = myBean;
        this.myBeanWithDependency = myBeanWithDependency;
        this.myOwnBeanWithDependency = myOwnBeanWithDependency;
    }

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

    @Override
    public void run(String... args) throws Exception {
        this.componentDependency.saludar();
        this.myBean.print();
        this.myBeanWithDependency.printWithDependency();
        this.myOwnBeanWithDependency.displayElements();
    }

totalmente incomprensible este video, sin dar ejemplos y con nombres repetidos y redundantes, muchos tuvimos que repetirlo varias veces, no creo que sea la manera.

En la capa repository creo la clase Persona:

@Repository
public class Persona implements PersonaMethods{

    private int edad=32;
    private String nombre="Mauricio";

    public int getEdad() {
        return edad;
    }

    public void setEdad(int edad) {
        this.edad = edad;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    @Override
    public void saludar() {
        System.out.println("Hola "+getNombre()+" tienes "+getEdad()+" años cumplidos.");
    }
}

Al mismo nivel la interface PersonaMethods:

public interface PersonaMethods {

    void saludar();

}

En “FundamentosAplication” añado la línea en la parte superior:

private Persona persona;

El constructor queda así:

public FundamentosApplication(@Qualifier("componentTwoImplement")ComponentDependency componentDependency, MyBean myBean, MyBeanWithDependency myBeanWithDependency, Persona persona){
		this.componentDependency=componentDependency;
		this.myBean=myBean;
		this.myBeanWithDependency=myBeanWithDependency;
		this.persona=persona;
	}

Y el método run:

@Override
	public void run(String... args) throws Exception {
		componentDependency.saludar();
		myBean.print();
		myBeanWithDependency.printwithdependency();
		persona.saludar();
	}

El log del run arroja lo anterior realizado en el curso y:

“Hola Mauricio tienes 32 años cumplidos.”

Reto Completado!!

Me costó mucho entender desde un inicio, he repetido más de 7 veces este video, al final si he comprendido pero requiere pausar y entender la lógica. Soy una persona muy visual y como consejo, ayuda mucho plantearlo visualmente y tener claro lo que hace cada clase. No hay que desanimarse si se puede !

que clase mas mala, no se entiende nada.

Creo que seria mucho mejor agregar un ejemplo mas realista que nombres tan poco recordables como MyBeanWithDependency

Esta clase es confusa por los nombres que le da a las clases e interfaces, si no tenes buenos fundamentos de POO va a ser un calvario, de lo contrario no es tan dificil solo tienen que cambiar los nombres y listo.

La verdad he entendido poco en este curso, lastima es la primera vez que me pasa con un curso en platzi, la verdad tocará buscar info en otros cursos.

En windows o linux Ubuntu Para sobreescribir métodos de forma mas rápida (te será muy util cuando tengas que implementar varios métodos) lleva el cursor a la línea donde se muestre el subrallado rojo indicando error, enseguida usa la combinación de teclas Alt + Enter, se mostrará un recuadro y presionas la opción ‘Implement methods’, se mostrará otro recuadro con todos los métodos de la interfaz que implementaste, selecciona los métodos y presiona OK o Enter.

Creo que no se explicó bien.

No se entiende, falta mucha didactica en este curso.

Esta clase me dejo con dolores de cabeza 😵‍💫, muy loco todo, pero se va entendiendo poco a poco.

CUando ya has trabajado con el lenguaje JAVA y tienes manejo de el entiendes como funciona, me gusta saber con funciona la inyeccion de dependencias manuelmente.

La verdad es que yo ya no puedo continuar mas con este curso, llego hasta aqui, la organizacion y tematica del curso se encuentra bien pero el profesor definitivamente no tiene vocacion de profesor

Pues me tomó un video seguir el código y una segunda mirada para entenderlo. Podría ser mejor la explicación, pero si se tiene algo de paciencia puedes aprender mucho de él. Pero para alguien que sea bastante nuevo en programación, lo veo un poco complicado.

Entiendo que es un poco difícil de entender pero en verdad es buena la estructura que adopta. Anexo un gráfico donde explica lo que él hace :

//Inyectando la dependencia Yema en Clara.
//----------------------------------------

//En package "bean"
	//Creamos la interfaz "Yema"
public interface Yema {
    int numberOfChikens();
}

	//Creamos la clase que lo implmenenta, "YemaImplement".
public class YemaImplements implements Yema{

    @Override
    public int numberOfChikens() {
        return 2;
    }
}

	//Creamos la interface "Clarar"
public interface Clara {

    void print();
}

	//Creamos la class que lo implementa, "ClaraImplemente"
public class ClaraImplement implements Clara{
    Yema yema;
    public ClaraImplement(Yema yema) {
        this.yema = yema;
    }
    @Override
    public void print() {
        yema.numberOfChikens();
        System.out.println("Contengo " + yema.numberOfChikens() + " pollitos :3");
    }
}

//En package Configuration
	//En la clase MyConfiguration agregamos.
		@Bean
    public Yema beanOperationYema() {
        return new YemaImplements();
    }

    @Bean
    public Clara beanOperationClara(Yema yema) {
        return new ClaraImplement(yema);
    }

//En la clase donde se encuentra el main (). Solo inyectamos la dependenia clara, lo pasamos por el constructor y ejecutamos su método print().

//Respuesta de consola: Contengo 2 pollitos :3

Java jamás me ha gustado, y juro que puse todo de mi parte ya que es para un puesto laboral pero aun así no entendí nada al profesor, valoro el esfuerzo pero mucho de los errores y dudas que se me dieron los resolví investigando

nota importante para que funcione el paquete configuration, las clases impl van sin anotación

creo que le falta mas detalle al maestro en su explicacion , me quedo duda sobre el @Configuration , pero en este link se explica mejor: https://www.arquitecturajava.com/spring-configuration/

package com.fundamentosplatzi.springboot.fundamentos.bean;

public interface MyMatrixOperations {
    Integer[][] matrixMultiplication(Integer[][] matrix1, Integer[][] matrix2) throws Exception;
    Integer[][] randomMatrixGenerator(Integer rows, Integer columns, Integer topNumber, Integer LoweNumber);
    Integer[] getColumn(Integer columnNumber,Integer[][] matrix);
    void printMatrix(Integer[][] matrix);
}

package com.fundamentosplatzi.springboot.fundamentos.bean;

public interface MyVectorOperations {
    Integer dotProduct(Integer[] vector1, Integer[] vector2) throws  Exception;
}

package com.fundamentosplatzi.springboot.fundamentos.bean;

import org.springframework.beans.factory.annotation.Autowired;

public class MyMatrixOperationsImplement implements  MyMatrixOperations{

    MyVectorOperations myVectorOperations;

    @Autowired
    public MyMatrixOperationsImplement(MyVectorOperations myVectorOperations) {
        this.myVectorOperations = myVectorOperations;
    }

    @Override
    public Integer[][] matrixMultiplication(Integer[][] matrix1, Integer[][] matrix2) throws Exception {
        if (matrix1[0].length == matrix2.length){
            Integer[][] result = new Integer[matrix1.length][matrix2[0].length];
            for (int i = 0; i < matrix1.length; i++){
                Integer[] row = matrix1[i];
                for (int j = 0; j < matrix2[0].length; j++) {
                    Integer[] column = getColumn(j, matrix2);
                    result[i][j] = myVectorOperations.dotProduct(row, column);
                }
            }
            return result;
        }
        else{
            throw  new Exception("It is not possible to multiply, the number of columns of matrix 1 is different from the number of rows of matrix 2.");
        }
    }

    @Override
    public Integer[][] randomMatrixGenerator(Integer rows, Integer columns, Integer topNumber, Integer lowerNumber) {
        //System.out.println("Rows -> " + rows);
        //System.out.println("Columns -> " + columns);
         Integer[][] randomMatrix = new Integer[rows][columns];
         for (int i = 0; i < rows; i++){
             //System.out.println("   i -> " + i);
             for (int j = 0; j < columns; j++){
                 //System.out.println("       j -> " + j);
                 double randomDouble = Math.random();
                 Integer randomInteger = (int) (lowerNumber + Math.floor(randomDouble*(topNumber - lowerNumber + 1)));
                 randomMatrix[i][j] = randomInteger;
             }
         }
         return randomMatrix;
    }

    @Override
    public Integer[] getColumn(Integer columnNumber, Integer[][] matrix) {
        Integer[] column = new Integer[matrix.length];
        for (int i = 0; i < matrix.length; i++) {
            column[i] = matrix[i][columnNumber];
        }
        return column;
    }

    @Override
    public void printMatrix(Integer[][] matrix) {
        for (int j = 0; j < matrix.length; j++){
            Integer[] row = matrix[j];
            System.out.print("|");
            for (int i = 0; i < row.length; i++){
                System.out.print(row[i]);
                if ((row.length - i) == 1){
                    System.out.print("|\n");
                }
                else{
                    System.out.print(" ");
                }
            }
        }
        System.out.print("\n");
    }
}

<package com.fundamentosplatzi.springboot.fundamentos.bean;

public class MyVectorOperationsImplement implements MyVectorOperations{
    @Override
    public Integer dotProduct(Integer[] vector1, Integer[] vector2) throws Exception{
        if(vector1.length == vector2.length){
            Integer result = 0;
            for (int i = 0; i < vector1.length; i++){
                result += vector1[i]*vector2[i];
            }
            return result;
        }
        else{
            throw  new Exception("There cannot be a dot product between two vectors of different sizes.");
        }
    }
}> 

Me gusto como se inyecta dependencias dentro de otras dependencias

Esto ahorra mucho código!, esto de los beans y la inyección de las dependencias está nice.

Reto cumplido

Todo bien con el curso hasta este video. los nombres de los metodos no son adecuados para aprender de buena forma como funciona el flujo de Spring Boot

No entendí apenas nada

esta dependencia trae otra depedencia como parametro…
vamos a pasar este metodo, este metodo no perdon, esta interfaz…
…tenemos un error
Me voló la cabeza

Como recomendación, para efectos pedagógicos sería mejor elaborar ejercicios de problemas reales y con diagramas, sino los conceptos quedan muy abstractos.

En mi caso, en este punto me salí a ver un tutorial de un CRUD simple con este framework que aunque no explicara conceptos, entendí cómo funciona en conjunto Spring Boot y ahora sí estoy logrando entender mejor estos ejemplos de los Inyección de Dependencias, porque ya comprendo su funcionalidad en problemas del mundo real.

Mi solución al reto:
Implemente una interfaz calculadora y una clase que lo implementa que tienen operaciones basicas como suma, resta, multiplicación, division, potencia, y el valor de pi. Por otro lado implemente una interfaz FigurasGeometricas que es implementada por Circulo con dos funciones imprimir el area y perimetro, Circulo inyecta como dependencia la interfaz Calculadora, para poder utilizar ciertos metodos como multiplicacion, potencia y pi.

package com.fundamentosplatzi.springboot.fundamentos.bean;

public interface Calculadora {
    double sum(double firstNumer, double SecondNumber);
    double multiplicacion(double firstNumber, double SecondNumber);
    double resta(double firstNumer, double SecondNumber);
    double division(double firstNumer, double SecondNumber);
    double pi();
    double potencia(double base, double exponente);
}

public class CalculadoraImplement implements Calculadora{
    @Override
    public double sum(double firstNumer, double SecondNumber) {
        return firstNumer + SecondNumber;
    }

    @Override
    public double multiplicacion(double firstNumer, double SecondNumber) {
        return firstNumer * SecondNumber;
    }

    @Override
    public double resta(double firstNumer, double SecondNumber) {
        return firstNumer - SecondNumber;
    }

    @Override
    public double division(double firstNumer, double SecondNumber) {
        return firstNumer / SecondNumber;
    }

    @Override
    public double pi() {
        return Math.PI;
    }

    @Override
    public double potencia(double base, double exponente) {
        return Math.pow(base, exponente);
    }
}

public interface FigurasGeometricas {
    void printArea();
    void printPerimetro();
}

public class Circulo implements FigurasGeometricas{
    private Calculadora calculadora;
    private double radio;

    public Circulo(Calculadora calculadora, double radio) {
        this.calculadora = calculadora;
        this.radio = radio;
    }

    @Override
    public void printArea() { //pi * (radio^2)
        System.out.println(calculadora.multiplicacion(calculadora.pi(), calculadora.potencia(radio, 2)));
    }


    @Override
    public void printPerimetro() { //2 * pi * radio
        System.out.println(calculadora.multiplicacion(calculadora.multiplicacion(2, calculadora.pi()), radio));
    }
}

//Configuración:

@Bean
    public Calculadora calculadoraOperation(){
        return new CalculadoraImplement(); //Clase que implementa la interfaz.
    }
    @Bean
    public FigurasGeometricas figurasGeometricasOperation(Calculadora calculadora){
        return new Circulo(calculadora, 1.5); //Clase que implementa la interfaz.
    }

@SpringBootApplication
	public class FundamentosApplication implements CommandLineRunner {
		private FigurasGeometricas figurasGeometricas;
		public FundamentosApplication(
				FigurasGeometricas figurasGeometricas
		){
			this.figurasGeometricas = figurasGeometricas;
		}
		public static void main(String[] args) {
			SpringApplication.run(com.fundamentosplatzi.springboot.fundamentos.FundamentosApplication.class, args);
		}

		@Override
		public void run(String... args) throws Exception {
			figurasGeometricas.printArea(); //area de un circulo
		}
}

@SpringBootApplication
	public class FundamentosApplication implements CommandLineRunner {
		private FigurasGeometricas figurasGeometricas;
		public FundamentosApplication(
				FigurasGeometricas figurasGeometricas
		){
			this.figurasGeometricas = figurasGeometricas;
		}
		public static void main(String[] args) {
			SpringApplication.run(com.fundamentosplatzi.springboot.fundamentos.FundamentosApplication.class, args);
		}

		@Override
		public void run(String... args) throws Exception {
			figurasGeometricas.printArea(); //area de un circulo
		}
}

Me marie con tantos implements

esta muy confuso todo, no se le entiende.

Recomiendo pasar de este curso y entrar directamente al curso de Spring, notarán la diferencia en la forma en la que los profesores explican este tipo de conceptos.

Bastante malo el curso hasta ahora

Menos mal es sólo fundamentos por q terminan enrredando a la gente!!

La intención de mostrar la inyección de dependencias era buena idea pero la forma de mostrarlo deja mucho que desear.
Concuerdo con varios de los comentarios publicados referente a este punto.

La verdad es que el cursor deja mucho que desear, no hay ni graficos, ni ejemplos practicos, y no se hace facil de seguir, el profesor claramente sabe lo que hace, pero a la hora de transmitir le falta trabajo.

Creo que el propósito de este video es explicar es como se hacia la inyección de dependencias antes de spring boot es decir trabajando con java ee.

Yo lo hice un poco distinto. Comparto el aporte.

Ok ya entendi, creo un myBeanWithDependency para luego llamar un myBean y luego hacer uso myBeanImplementacion y enviarle un myBeanWithDependency que recibe como parametro un numero .-. No entiendos

La forma en cómo pude entender el flujo es la siguiente (plasmado a través de un diagrama de dependencia).

Reto cumplido!

reto Cumplido!

Reto cumplido!

https://prnt.sc/1apvnuo

Está buena la clase, pero los ejemplos que hace, son demasiado abstractos. Muy dificil de seguirla!!!

Lo que me gusta hasta ahora es lo práctico del curso y veo que toma en consideración la separación de componentes en sus distintas capas. En este punto, el uso de componentes genéricos nos ha mostrado muy bien cómo funciona la inyección de dependencias.

Faltó explicar la estrategia para usar la clase de configuración, su anotación respectiva @Configuration, y la anotación @Bean; al menos indicar que @Bean es un concepto básico de Spring Core, ya que aplicarlo sin este aviso tomará desprevenidos a quienes están recién aprendiendo a desarrollar aplicaciones con Spring Framework y entraron directamente a Spring Boot. Sin duda, para alguien con algo de experiencia le resultará más fácil entenderlo o sabrá cómo darle la vuelta a sus dudas.

Anotación de componente
@Component

Derivados (implementaciones) de @Component “estereotipos”
@Controller, @Service, @Persistence

Definir un Spring Bean en el contexto de Spring
@Bean

buenas tardes,

comparto reto.

interface de la dependencia.

package com.fundamentosplatzi.springboot.fundamentos.bean;

public interface MyChallengeDependencySubtraction {
    void subtractionNumber();
}

implementacion de la dependencia

package com.fundamentosplatzi.springboot.fundamentos.bean;

public class MyChallengeDependencySubtractionImplement implements MyChallengeDependencySubtraction {

    /*
        Inyeccion de dependencia
     */
    MyChallengeIsPair myChallengeIsPair;

    public MyChallengeDependencySubtractionImplement(MyChallengeIsPair myChallengeIsPair) {
        this.myChallengeIsPair = myChallengeIsPair;
    }

    @Override
    public void subtractionNumber() {
        int numero = 12;
        System.out.println("Este numero es: " + myChallengeIsPair.isPair(numero));
        System.out.println("La resta del numero es: " + (numero - (numero - 1)));
    }
}

interface del bean

/*
    Bean que valida si el numero es par o impar
 */
public interface MyChallengeIsPair {
    String isPair(int number);
}

implementacion del bean

package com.fundamentosplatzi.springboot.fundamentos.bean;

public class MyChallengeIsPairImplement implements MyChallengeIsPair {
    @Override
    public String isPair(int number) {
        String status = "";
        boolean operation = number % 2 == 0;

        if (operation) {
            status = "PAR";
        } else {
            status = "IMPAR";
        }
        return status;
    }
}

configuracion del bean

package com.fundamentosplatzi.springboot.fundamentos.configuration;

import com.fundamentosplatzi.springboot.fundamentos.bean.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/*
    Configuracion adicional de nuestros beans
 */
@Configuration
public class MyConfigurationBean {
    @Bean
    public MyChallengeIsPair myOperationChallenge() {
        return new MyChallengeIsPairImplement();
    }

    @Bean
    public MyChallengeDependencySubtraction myOperationDependency(MyChallengeIsPair myChallengeIsPair) {
        return new MyChallengeDependencySubtractionImplement(myChallengeIsPair);
    }
}

llamado clase principal

package com.fundamentosplatzi.springboot.fundamentos;

import com.fundamentosplatzi.springboot.fundamentos.bean.MyBean;
import com.fundamentosplatzi.springboot.fundamentos.bean.MyBeanWithDependency;
import com.fundamentosplatzi.springboot.fundamentos.bean.MyChallengeDependencySubtraction;
import com.fundamentosplatzi.springboot.fundamentos.component.ComponentDependency;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/*
clase que tiene el metodo encargado de inicializar el proyecto
 */
@SpringBootApplication
public class FundamentosApplication implements CommandLineRunner {
    private MyChallengeDependencySubtraction myChallengeDependencySubtraction;

public FundamentosApplication(                                  MyChallengeDependencySubtraction myChallengeDependencySubtraction) {
        this.myChallengeDependencySubtraction = myChallengeDependencySubtraction;
    }


    @Override
    public void run(String... args) throws Exception {
        myBeanWithDependency.printWithDependency();
        myChallengeDependencySubtraction.subtractionNumber();
    }
}

Gracias.

Reto:

1. defino la interfaz IMyBeanChallenge que tendrá dos métodos, una función que devuelve una cadena y un procedimiento que imprime una lista de número hasta llegar a un tope.

public interface IMyBeanChallenge {
    void imprimeNumerosHasta();
    String queSoy();
}

1. defino la interfaz IMyBeanChallengeGiveANumber para capturar un número aleatorio:

public interface IMyBeanChallengeGiveANumber {
    int aNumber(int n);
}

1. implemento la obtención del número aleatorio:

public class MyBeanChallengeGiveANumberImplement implements IMyBeanChallengeGiveANumber{
    @Override
    public int aNumber(int n) {
        return (int) (Math.random()*n);
    }
}

1. implemento la interfaz en la clase MyBeanChallengeImplement inyectando la obtención de números aleatoria:

public class MyBeanChallengeImplement implements IMyBeanChallenge{

    private int number = 0;
    private int tope = 0;

    private IMyBeanChallengeGiveANumber iMyBeanChallengeGiveANumber;
    @Autowired
    public MyBeanChallengeImplement(IMyBeanChallengeGiveANumber iMyBeanChallengeGiveANumber) {
        this.iMyBeanChallengeGiveANumber = iMyBeanChallengeGiveANumber;
        this.tope = 15;
        setNumber(this.tope);
    }

    public void setNumber(int t){
        this.number = iMyBeanChallengeGiveANumber.aNumber(t);
    }

    public int getNumber(){
        return this.number;
    }

    @Override
    public void imprimeNumerosHasta() {
        for(int i = 1; i <= this.getNumber(); i++){
            System.out.println(i);
        }
    }

    @Override
    public String queSoy() {
        return "Soy la implementación que imprime números hasta " + this.getNumber() + " inyectado aleatoriamente.";
    }
}

1. implemento la configuración de los bean creados:

@Configuration
public class MyBeanConfiguration {

    @Bean
    public IMyBeanChallengeGiveANumber beanChallengeGiveANumber(){
        return new MyBeanChallengeGiveANumberImplement();
    }

    @Bean
    public IMyBeanChallenge beanChallenge(IMyBeanChallengeGiveANumber iMyBeanChallengeGiveANumber){
        return new MyBeanChallengeImplement(iMyBeanChallengeGiveANumber);
    }
}

1. implemento la clase principal de la aplicación inyectando la implementación que muestra un listado de número hasta el tope aleatorio:

@SpringBootApplication
public class MiBeanChallengeApplication implements CommandLineRunner {

    private IMyBeanChallenge iMyBeanChallenge;
    @Autowired
    public MiBeanChallengeApplication(IMyBeanChallenge iMyBeanChallenge) {
        this.iMyBeanChallenge = iMyBeanChallenge;
    }

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

    @Override
    public void run(String... args) throws Exception {
        System.out.println(iMyBeanChallenge.queSoy());
        iMyBeanChallenge.imprimeNumerosHasta();
    }
}

Respuesta:

:: Spring Boot ::                (v2.6.7)
Soy la implementación que imprime números hasta 14 inyectado aleatoriamente.
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Mi reto lo resolví creando dos beans

• CartelesBean interfaz con un método imprimirMensajeDecorado() que imprimé un mensaje en pantalla. La clase que implementa la interfaz, usa la dependencia DecoradorStringBean en la implementación del método. Esta dependencia se le pasa por parámetro en el constructor.

public interface CartelesBean {

    public void imprimirMensajeDecorado(String mensaje);
}

public class CartelesImpl implements CartelesBean {
    private DecorarStringBean decorarStringBean;

    public CartelesImpl(DecorarStringBean decorarStringBean) {
        this.decorarStringBean = decorarStringBean;
    }


    @Override
    public void imprimirMensajeDecorado(String mensaje) {
        System.out.println(this.decorarStringBean.decorar(mensaje));
    }
}

• DecoradorStringBean interfaz con un método decorar(String texto). La implementación del método retorna el string concatenado con otras cadenas.

public interface DecorarStringBean {
    String decoracion = "-_-_-_- #";
    public String decorar(String texto);
}

public class DecorarStringImpl implements DecorarStringBean {
    @Override
    public String decorar(String texto) {
        return this.decoracion + texto + this.decoracion;
    }
}

En la configuración está estos métodos

@Configuration
public class BeansConfiguration {
    @Bean
    public DecorarStringBean decorarStringBean() {
        return new DecorarStringImpl();
    }

    @Bean
    public CartelesBean cartelesBean(DecorarStringBean decorarStringBean) {
        return new CartelesImpl(decorarStringBean);
    }

}

Finalmente en la clase Application usé la dependencia CartelesBean

@SpringBootApplication
public class Application implements CommandLineRunner {

    private CartelesBean cartelesBean;


    public Application(CartelesBean cartelesBean) {
        this.cartelesBean = cartelesBean;
    }


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

    @Override
    public void run(String... args) {
        cartelesBean.imprimirMensajeDecorado("Este mensaje se modifica con una dependencia");
    }
}

Aquí se observa lo que se imprime por consola

• _ - _ - _ - #Este mensaje se modifica con una dependencia- _ - _ - _ - #
  Process finished with exit code 0

Reto cumplido!!

Reto completado.
Ha sido uno sencillito, quiero imprimir el objeto persona de la clase MyPersonaImplement con sus atributos, nombre apellido y edad, esta edad se calcula a traves de un metodo llamado calcularEdad, que recibe un date y hace una serie de operaciones para calcular la edad. En la clase MyOperationSaludarWithDependency uso la interfaz MyPersona y a traves de los metodos puestos recojo los valores del nombre, apellido y el metodo para calcular la edad. Bueno, dejo el codigo.

Interfaz myPersona

public interface MyPersona {
    String getNombre();
    String getApellido();
    int getEdad();
    void setEdad(int edad);
    int calcularEdad();
}

Clase MyPersonaImplement que implementa la interfaz

public class MyPersonaImplement implements MyPersona{
    private String nombre = "Juan";
    private String apellido = "Perez";
    private Date fechanac = new Date(0);
    private int edad;

    @Override
    public String getNombre() {
        return nombre;
    }
    @Override
    public String getApellido() {
        return apellido;
    }
    @Override
    public int getEdad() {
        return edad;
    }
    @Override
    public void setEdad(int edad) {
        this.edad = edad;
    }
    @Override
    public int calcularEdad() {
        GregorianCalendar gcNac = new GregorianCalendar();
        gcNac.setTime(fechanac);
        GregorianCalendar ahora = new GregorianCalendar();
        int anios = ahora.get(Calendar.YEAR)-gcNac.get(Calendar.YEAR);
        if(gcNac.get(Calendar.DAY_OF_YEAR)>ahora.get(Calendar.DAY_OF_YEAR))
            anios--;
        return anios;
    }
}

Interfaz MyOperationSaludarWithDependency

public interface MyOperationSaludarWithDependency {
    void saludar();
}

Y el objeto MyOperationSaludarWithDependencyImplement que tiene la dependencia de la interfaz MyPersona

public class MyOperationSaludarWithDependencyImplement implements MyOperationSaludarWithDependency {
    private MyPersona myPersona;

    public MyOperationSaludarWithDependencyImplement(MyPersona myPersona) {
        this.myPersona = myPersona;
    }
    @Override
    public void saludar() {
        myPersona.setEdad(myPersona.calcularEdad());
        System.out.println("Hola, me llamo "+myPersona.getNombre()+" "+myPersona.getApellido()+", y tengo "+myPersona.getEdad()+" anyos");
    }

La clase MyConfigurationBean

@Configuration
public class MyConfigurationBean {
@Bean 
MyPersona myPersonaOperation(){
        return new MyPersonaImplement();
    }
    @Bean
    public MyOperationSaludarWithDependency beanOperationSaludarWithDependency(MyPersona myPersona){
        return new MyOperationSaludarWithDependencyImplement(myPersona);
    }
}

Y por ultimo la clase FundamentosAplikeichon jaajaja

@SpringBootApplication
public class FundamentosApplication implements CommandLineRunner {
	private MyOperationSaludarWithDependency myOperationSaludarWithDependency;
public FundamentosApplication(@Qualifier("componentImplement") MyOperationSaludarWithDependency myOperationSaludarWithDependency) {
this.myOperationSaludarWithDependency = myOperationSaludarWithDependency;
	}
	public static void main(String[] args) {
		SpringApplication.run(FundamentosApplication.class, args);
	}
@Override
	public void run(String... args) {
	myOperationSaludarWithDependency.saludar();
	}
}

Es uno sencillito por si alguien quisiera usarlo. Un saludo y nunca pareis de aprender.

Bien !! Reto hecho y avanzando

https://bit.ly/3ujILxM

Reto cumplido 😄
Reto 01

En mi caso hice unas pruebas, cuando la implementacion de las dependencias se hacen desde un implement con @Component se puede inyectar por constructor o con la Anotacion @Autowired. Pero cuando se hacen por medio de configuracion de @Bean me generar error al utilizar el @Autowired, me obliga a inyectarlas por constructor… Interesenta clase de como inyectar dependencias…

Están incompletos los archivos de la clase

Definitivamente el mayor problema con está clase es el tema de los nombres, cambie un poco los nombres para que no fueran tan parecidos y así comprender un poco mejor, pero es muy muy fácil perderse entre tantos archivos con nombres tan parecidos y procesos de implementación iguales