Inyección de dependencias

Clase 14 de 23 • Curso de Java para APIs REST 2016

Ernesto Cantu

student•

Aquí dejo el pom.xml para aquellos que lo quieran en maven

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  <modelVersion>4.0.0</modelVersion>  
  
  <groupId>Group-ID</groupId>  
  <artifactId>dependency-injection</artifactId>  
  <version>1.0-SNAPSHOT</version>  
  <packaging>jar</packaging>  
  
  <name>dependency-injection</name>  
  <url>http://maven.apache.org</url>  
  
  <properties>  
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
  </properties>  
  
  <dependencies>  
      
    <dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-context</artifactId>  
    <version>4.2.1.RELEASE</version>  
    </dependency>    
        
    <dependency>  
      <groupId>junit</groupId>  
      <artifactId>junit</artifactId>  
      <version>3.8.1</version>  
      <scope>test</scope>  
    </dependency>  
  </dependencies>  
</project>

Jackson Freire

student•

Gracias por el aporte

Fernando Palacios Palacios

student•

¿el modelo de packaging Java Archetipe, soluciona lo que comentaba de que es una palicacion atandalone?

Edwin Cotrina

student•

Sería bueno que lo hubiese creado desde cero.

Cesar David Ramírez Dimaté

student•

Para crear un proyecto de Gradle desde cero seguir los siguientes pasos:

Crear una carpeta en el workspace de Eclipse llamada++ dependency-injection++
mkdir dependency-injection
Dentro de la carpeta, crear la estructura de carpetas para Gradle.
cd dependency-injection
mkdir -p src/main/java/platzi
Crear un archivo build.gradle con lo siguiente:
nano build.gradle

build.gradle

buildscript {
	repositories {
		mavenCentral()
	}
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'application' // Para ejecutar 'gradle run' en consola
repositories {
	mavenCentral()
}

sourceCompatibility = 1.8 // Java 8 para compilar
targetCompatibility = 1.8 // Java 8 para ejecutar

mainClassName = "platzi.TestClass" // Ubicación de la clase main.

dependencies {
	compile 'org.springframework:spring-context:4.2.1.RELEASE' // Trae la libreria Spring Context
}

Ctrl + Shift + V: Pegar texto.
Ctrl + X para salir y tecla Y para guardar.
4. Verificar la variable de entorno.
export JAVA_HOME=/usr/lib/jvm/java-8-oracle
echo $JAVA_HOME
5. Crear la carpeta build/libs con el JAR del proyecto.
gradle build
6. Generar los archivos para eclipse.
gradle eclipse
ls -la
7. Correr el proyecto
gradle run

Charles Córdova

student•

IIntelliJ IDEA debe ser promocionado por PLATZI

Roberto Miñagorri

student•

Con el Patrón de Diseño "Factory" logras lo mismo más elegántemente. Sobretodo puedes
ver lo que estás inyectando.

Rubén Soria Quispe Soria Quispe

student•

un singleton es una sola instancia por todo el ciclo de vida de una aplicacion

Fernando Palacios Palacios

student•

vale patron de diseño, pero se puede definir como un componente static, constante, de una propiedad de clase?

private static final Component singleton = new Component();

Cesar David Ramírez Dimaté

student•

Patrón Singleton: Su intención consiste en garantizar que una clase sólo tenga una instancia (un sólo objeto) y proporcionar un punto de acceso global a ella. Esto ayuda al buen manejo de memoria.

En el segundo ejercicio, se utiliza el patrón con el objeto context creado, no es un componente, con el contexto yo ya manejo los objetos instanciados en los beans.

Benjamin De la Cruz

student•

Me pierdo por completo en clases en las que la base de los codigos ya los tienen creados.

Cesar David Ramírez Dimaté

student•

No tanto eso porque igual el código se encuentra en GitHub. Pero en este vídeo si explicó bien línea por línea de código, más que todo la importancia de las anotaciones y como se ve un proyecto con y sin spring para el manejo de dependencias.

Pablo Ramirez Solorzano

student•

En el archivo build.gradle, en la parte de sourceCompatibility y targetCompatibility, no me funcionó con la versión 1.8, pero si con la 1.7, a pesar de que en la linea de comandos con java -version me muestra que tengo la 1.8, por qué pasa esto? y como puedo hacer que me funcione con 1.8?

Jair Israel Avilés Eusebio

student•

¿cuál es el error que te arroja la consola? supongo que acontece en el momento del build

Cesar David Ramírez Dimaté

student•

Raro si está, porq una es para compilar y la otra para generar los jar y los class, crea todo el proyecto desde la consola de gradle para ver si te sucede lo mismo. Puede que sea algo de eclipse.

En build.gradle añade las siguientes líneas.

apply plugin: 'application'
mainClassName = "platzi.TestClass"

Cesar David Ramírez Dimaté

student•

Ejercicio 1 del vídeo. Inyección de dependencias SIN Spring.

Definir las clases Java del Proyecto

Los siguientes archivos deben estar en dependency-injection/src/main/java/platzi/.

MessagePrinterWithNew.java

package platzi;

public class MessagePrinterWithNew {
	private MessageService messageService;
	//final private MessageService messageService = new HappyMessageService();
	
	// Constructor
	public MessagePrinterWithNew() {
	}
	
	public void printMessage() {
		// Utiliza el método abstracto de la interface.
		System.out.println(this.messageService.getMessage());
	}
	
	// Método set()
	public void setMessageService(MessageService messageService) {
		this.messageService = messageService;
	}
}

MessagePrinter.java

package platzi;

public class MessagePrinter {
	final private MessageService service;

	// Constructor
	public MessagePrinter(MessageService service) {
		this.service = service;
	}
	
	public void printMessage() {
		// Utiliza el método abstracto de la interface.
		System.out.println(this.service.getMessage());
	}	
}

MessageService.java

package platzi;

public interface MessageService {
	String getMessage(); // Define un método abstracto pùblico.
}

HappyMessageService.java

package platzi;

public class HappyMessageService implements MessageService {
	
	@Override
	// Implementa el método abstracto de la interface.
	public String getMessage() {
		return "Muy feliz :)";
	}
}

SadMessageService.java

package platzi;

public class SadMessageService implements MessageService {
	
	@Override
	// Implementa el método abstracto de la interface.
	public String getMessage() {
		return "No tan feliz :(";
	}
}

TestClass.java

package platzi;

/**
 * Proyecto que NO utiliza Spring.
 * Se define una clase interface que tiene un método abstracto y se implementa en la clase Happy y Sad con un String diferente.
 * Utiliza la programación estandar, se envía un objeto por parámetro implementando el mensaje para luego ser impreso en otro método.
 **/
 
// Clase Principal (NO utiliza Spring)
public class TestClass {

	public static void main(String[] args) {
		MessagePrinterWithNew printer = new MessagePrinterWithNew();
		printer.setMessageService(new HappyMessageService());
		printer.printMessage();
		printer.setMessageService(new SadMessageService());
		printer.printMessage();
	}
}

Cesar David Ramírez Dimaté

student•

Instalar Gradle en Linux

Verificar las variables de entorno de JAVA_HOME y PATH
echo $JAVA_HOME
echo $PATH
Descargar Gradle - https://gradle.org/gradle-download/ - https://downloads.gradle.org/distributions/gradle-3.3-all.zip
Extraer archivo en Downloads y ejecutar en la terminal.
sudo mv ~/Downloads/gradle-3.3 /opt
sudo gedit /etc/bash.bashrc
Añadir al final del archivo…

export GRADLE_HOME=/opt/gradle-3.3
export PATH=$PATH:$GRADLE_HOME/bin

Cerrar la sesión de usuario y volver a ingresar. Verificar la versión de Gradle en consola
gradle -v

Crear proyecto con Gradle desde cero

Crear carpeta proyecto_gradle
En la consola, ubicarse en la carpeta. /home/desarrollo/Documents/proyecto_gradle
Crear la estructura de nuestro proyecto, se ejecuta el comando:
gradle init --type java-library
Limpiar build anteriores.
gradle clean
Compilar el código y generar los .class
gradle assemble
Nota: recuerda siempre que quieras volver a compilar deberías ejecutar primero el comando gradle clean.
Generar archivo jar
gradle build

Cesar David Ramírez Dimaté

student•

Crear un proyecto de Gradle desde cero

Crear una carpeta en el workspace de Eclipse llamada++ dependency-injection++
mkdir dependency-injection
Dentro de la carpeta, crear la estructura de carpetas para Gradle.
cd dependency-injection
mkdir -p src/main/java/platzi
Crear un archivo build.gradle con lo siguiente:
nano build.gradle

build.gradle

buildscript {
	repositories {
		mavenCentral()
	}
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'application' // Para ejecutar 'gradle run' en consola
repositories {
	mavenCentral()
}

sourceCompatibility = 1.8 // Java 8 para compilar
targetCompatibility = 1.8 // Java 8 para ejecutar

mainClassName = "platzi.TestClass" // Ubicación de la clase main.

dependencies {
	compile 'org.springframework:spring-context:4.2.1.RELEASE' // Trae la libreria Spring Context
}

Cesar David Ramírez Dimaté

student•

El ejemplo de inyección de denpendencias no es bastante claro.

Lo que tengo entendido es un patrón de diseño orientado a objetos, en el que se suministran objetos a una clase en lugar de ser la propia clase quien cree el objeto. Esto permite crear componentes reutilizable. Se complica el flujo cuando se salta de componente a componente, generando así una dependencia (acoplamiento) entre los componentes.

Para implementar este patrón se hace comunmente mediante un “Contenedor DI” por ejemplo mediante un POJO (una clase simple en Java que no depende de ningún framework). El contenedor inyecta a cada objeto los objetos necesarios según las relaciones plasmadas en un archivo de configuración.

En otras palabras, comúnmente se crea una clase y se empiezan a setear atributos de la siguiente manera:
Motor motor = new Motor();
motor.setColor(“negro”); // Se envían datos tipo primitivos.
motor.setMarca(“mazda”);
Con inyección de dependencias se haría de la siguiente manera:
Vehiculo = new Vehiculo();
Motor motor = new Motor();
vehiculo.setMotor(motor); // Se envían datos tipo objeto.

public void setMotor(Motor motor) { // Método de la clase Vehículo
	this.motor = motor;
}

Conclusión: Con inyección de dependencias se envían objetos en vez de datos primitivos y se pueden reutilizar métodos (cómo una interface que utiliza un método abstracto y se puede implementar de varias formas).