¿el modelo de packaging Java Archetipe, soluciona lo que comentaba de que es una palicacion atandalone?
Sería bueno que lo hubiese creado desde cero.
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 consolarepositories {mavenCentral()}sourceCompatibility =1.8// Java 8 para compilartargetCompatibility =1.8// Java 8 para ejecutarmainClassName ="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
IIntelliJ IDEA debe ser promocionado por PLATZI
Con el Patrón de Diseño "Factory" logras lo mismo más elegántemente. Sobretodo puedes
ver lo que estás inyectando.
un singleton es una sola instancia por todo el ciclo de vida de una aplicacion
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();
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.
Me pierdo por completo en clases en las que la base de los codigos ya los tienen creados.
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.
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?
¿cuál es el error que te arroja la consola? supongo que acontece en el momento del build
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.
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;publicclassMessagePrinterWithNew{privateMessageService messageService;//final private MessageService messageService = new HappyMessageService();// ConstructorpublicMessagePrinterWithNew(){}publicvoidprintMessage(){// Utiliza el método abstracto de la interface.System.out.println(this.messageService.getMessage());}// Método set()publicvoidsetMessageService(MessageService messageService){this.messageService= messageService;}}
MessagePrinter.java
package platzi;publicclassMessagePrinter{ final privateMessageService service;// ConstructorpublicMessagePrinter(MessageService service){this.service= service;}publicvoidprintMessage(){// Utiliza el método abstracto de la interface.System.out.println(this.service.getMessage());}}
MessageService.java
package platzi;publicinterfaceMessageService{StringgetMessage();// Define un método abstracto pùblico.}
HappyMessageService.java
package platzi;publicclassHappyMessageServiceimplementsMessageService{ @Override// Implementa el método abstracto de la interface.publicStringgetMessage(){return"Muy feliz :)";}}
SadMessageService.java
package platzi;publicclassSadMessageServiceimplementsMessageService{ @Override// Implementa el método abstracto de la interface.publicStringgetMessage(){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)publicclassTestClass{publicstaticvoidmain(String[] args){MessagePrinterWithNew printer =newMessagePrinterWithNew(); printer.setMessageService(newHappyMessageService()); printer.printMessage(); printer.setMessageService(newSadMessageService()); printer.printMessage();}}
Instalar Gradle en Linux
Verificar las variables de entorno de JAVA_HOME y PATH echo $JAVA_HOME echo $PATH
Descargar Gradle - -
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…
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
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 consolarepositories {mavenCentral()}sourceCompatibility =1.8// Java 8 para compilartargetCompatibility =1.8// Java 8 para ejecutarmainClassName ="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
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.
publicvoidsetMotor(Motor motor){// Método de la clase Vehículothis.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).