TAREA ACADÉMICA 2

DOCENTE: ROSANGELA ABREGÚ MARCOS

CURSO: TALLER DE PROGRAMACION

INTERGRANTES: CÓDIGO

 Benjamin Justo Atoche López U22101319

 Jhon Alvarado Espejo U21309552
 Raul Salvador Pinedo Osco U21321082
 Eduardo Leonardo Diaz Diaz U22241529
 Fabian Garcia Champi U21201692
INDICE
Introducción: ................................................................................................................. 3
I. Conceptos de los módulos en Java: .......................................................................... 3
 Módulo: .............................................................................................................. 3
 Dependencia: ..................................................................................................... 3
 Exportación: ....................................................................................................... 3
II. Creación de módulos en Java: .................................................................................. 4
 Definir un archivo de descripción del módulo: .................................................... 4
 Estructurar el código en paquetes: ..................................................................... 4
 Especificar las dependencias: ............................................................................ 4
III. Compilación y despliegue de módulos en Java: ....................................................... 5
 Compilación ....................................................................................................... 6
 Despliegue ......................................................................................................... 6
V. Creación de JARs en Java (continuación): ............................................................... 7
VI. Ventajas de los módulos en Java: ........................................................................... 9
 Modularidad y encapsulación: .......................................................................... 10
 Control de dependencias:................................................................................. 10
 Mejor rendimiento: ........................................................................................... 10
 Mayor seguridad: ............................................................................................. 10
VII. Conclusiones: ....................................................................................................... 10
VIII. Referencias Bibliográficas: .................................................................................. 10
Introducción:

Los módulos en Java son una parte fundamental del desarrollo de aplicaciones, ya que
permiten organizar y estructurar el código en unidades independientes y reutilizables.
En este documento, exploraremos los conceptos fundamentales de los módulos en
Java, su proceso de creación, compilación, despliegue y la creación de archivos JAR
(Java Archive) para distribuirlos.

I. Conceptos de los módulos en Java:

Los módulos en Java son una forma de encapsular clases y recursos relacionados en
una unidad coherente. Proporcionan una manera de modularizar una aplicación y
gestionar sus dependencias. Algunos conceptos clave son:

 Módulo:
Es una unidad de código que agrupa clases y recursos relacionados. Un módulo tiene
un nombre y una descripción de sus dependencias.

 Dependencia:
Representa la relación entre dos módulos, donde uno de ellos necesita acceder a las
clases o recursos proporcionados por el otro.

 Exportación:
Un módulo puede exportar paquetes, lo que significa que los otros módulos pueden
acceder a las clases y recursos contenidos en esos paquetes.
II. Creación de módulos en Java:

Para crear un módulo en Java, es necesario seguir los siguientes pasos:

 Definir un archivo de descripción del módulo:

Se crea un archivo llamado module-info.java en la raíz del proyecto. Este archivo
contiene información sobre el nombre del módulo, las dependencias y los paquetes que
se exportarán.

 Estructurar el código en paquetes:

Es importante organizar el código en paquetes lógicos y coherentes dentro del proyecto.

 Especificar las dependencias:

En el archivo module-info.java, se declaran las dependencias que el módulo necesita
para funcionar correctamente.
III. Compilación y despliegue de módulos en Java:

Una vez que se ha creado un módulo en Java, es necesario compilarlo y desplegarlo.

Los pasos son los siguientes:
  Compilación
Se utiliza el comando javac para compilar los archivos fuente del proyecto, incluido el
archivo module-info.java. Durante la compilación, se generan archivos .class
correspondientes a las clases del módulo.

Empaquetado en un JAR: Después de la compilación, se puede empaquetar el módulo

y sus dependencias en un archivo JAR utilizando la herramienta jar de Java. El archivo
JAR contiene los archivos .class y el archivo module-info.class.

 Despliegue
Una vez que se ha creado el archivo JAR, se puede desplegar en un entorno de
ejecución de Java, como un servidor de aplicaciones o una máquina virtual Java (JVM).
El entorno de ejecución utiliza la información del archivo module-info.class para cargar
y gestionar los módulos.
V. Creación de JARs en Java (continuación):

Crear un archivo de manifiesto: El archivo de manifiesto especifica la configuración del

archivo JAR y contiene metadatos sobre el módulo o la aplicación. Se puede crear
manualmente o utilizando la herramienta jar con el argumento c para generar un archivo
de manifiesto predeterminado.
Empaquetar los archivos en el JAR: Utilizando la herramienta jar, se empaquetan los
archivos y directorios del módulo en el JAR. Esto se logra con el argumento cf seguido
del nombre del archivo JAR y los archivos y directorios que se incluirán.
Especificar el archivo de manifiesto: El archivo de manifiesto se especifica al crear el
JAR utilizando el argumento m seguido del nombre del archivo de manifiesto.

Incluir dependencias: Si el módulo depende de otras bibliotecas externas, se pueden

incluir en el JAR utilizando el argumento m seguido de la ruta de las bibliotecas.

VI. Ventajas de los módulos en Java:

Los módulos en Java ofrecen varias ventajas en el desarrollo de aplicaciones:
  Modularidad y encapsulación:
Los módulos permiten dividir una aplicación en componentes coherentes y reutilizables,
facilitando el mantenimiento y la evolución del código.

 Control de dependencias:
Los módulos proporcionan un mecanismo para gestionar y controlar las dependencias
entre componentes, lo que mejora la estabilidad y la compatibilidad de la aplicación.

 Mejor rendimiento:
Al limitar las dependencias y especificar explícitamente los paquetes que se exportan,
los módulos en Java pueden mejorar el rendimiento de la aplicación al reducir la carga
de clases y recursos innecesarios.

 Mayor seguridad:
Los módulos en Java promueven la encapsulación y restringen el acceso no autorizado
a clases y recursos, lo que contribuye a una mayor seguridad en la aplicación.

VII. Conclusiones:

En este documento, hemos explorado los conceptos fundamentales de los módulos en

Java, desde su creación hasta su despliegue y la creación de archivos JAR. Los
módulos proporcionan una forma efectiva de modularizar y organizar el código, lo que
facilita el desarrollo, la mantenibilidad y la distribución de aplicaciones Java. Con un
enfoque en la modularidad, Java se ha vuelto más flexible y escalable, permitiendo a los
desarrolladores crear aplicaciones más robustas y eficientes.

A medida que continuamos avanzando en el desarrollo de aplicaciones Java,

comprender y utilizar los módulos se vuelve cada vez más relevante. Aprovechar al
máximo esta característica puede impulsar el rendimiento y la calidad de nuestras
aplicaciones, mejorando así la experiencia de los usuarios y facilitando el desarrollo y
mantenimiento a largo plazo.

VIII. Referencias Bibliográficas:

Oracle Documentation: Java Platform, Standard Edition (Java SE) - Module System.
Disponible en:
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/module/packag
e-summary.html

Oracle Java Tutorials: The Java Module System. Disponible en:

https://docs.oracle.com/javase/tutorial/java/javaOO/modules.html

Baeldung: Java 9 Modules - An Introduction. Disponible en:

https://www.baeldung.com/java-9-modularity

Java Magazine: Java 9 and the Future of Modularity. Disponible en:

https://blogs.oracle.com/javamagazine/java-9-and-the-future-of-modularity

JUnit.org: Java 9 Module System Tutorial. Disponible en:

https://junit.org/junit5/docs/current/user-guide/#running-tests-build-modular-java