Frameworks a los chapazos: Maven (Parte 2/2)

Más Maven

Aun quedan temas por cubrir como herencia, super POM, Standard Directory Layout, Repositorios, Plugins, Arquetipos, instalación

Instalación

Podemos salir de la instlación, fácil, rápido y para toda la familia. Simplemente googleamos 'download maven' y el primer enlace deberia ser este:

https://maven.apache.org/download.cgi

Procedimiento

Descargar los archivos binarios en zip o tar.zip según sistema operativo
Alojarlos en alguna carpeta que nos resulte cómoda
Setear esa ruta como M2_HOME (este nombre es por conveniencia) y agregarla al PATH del sistema incluyendo a la carpeta bin donde se encuentra el comando mvn, (set en Windows y export en linux y mac)
verificar instalación en la terminal con el comando mvn --version ó -v en su versión corta:

Herencia en Maven

En Maven, la herencia se refiere a la capacidad de un proyecto (o módulo) para heredar configuraciones y propiedades de un proyecto padre. Esto es útil para gestionar configuraciones comunes y evitar la duplicación de código.

¿Cómo Funciona?

En el pom.xml la herencia define un proyecto hijo hereda las configuraciones del proyecto padre.

Proyecto Padre (pom.xml):

<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/POM/4.0.0/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>parent-project</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
   
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>5.3.8</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

Proyecto Hijo (pom.xml):

<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/POM/4.0.0/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.example</groupId>
        <artifactId>parent-project</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <artifactId>child-project</artifactId>
</project>

En este ejemplo, el proyecto hijo hereda las dependencias y configuraciones definidas en el proyecto padre, para el caso concreto mostrado, el hijo cuenta como dependencia spring-core-5.3.8 porque su padre la declara como dependencia y se funciona como en la vida real, se heredan muchas caracteristicas de nuestros padres.

¿Qué es el Super POM?

El Super POM es el archivo de configuración base de Maven que se aplica a todos los proyectos. Define los valores predeterminados y comportamientos generales para todos los proyectos Maven. A términos de java, el super POM viene a ser como la clase Object, de la cúal todo heredan ímplicitamente de ésta, atributos y comportamientos.

Características del Super POM:

Ubicación: El Super POM está integrado en Maven y no se encuentra en tu proyecto.
Configuraciones Predeterminadas: Incluye configuraciones predeterminadas para el proceso de construcción, como plugins predeterminados y propiedades. Ejemplo de Configuración en el Super POM
No puedes ver ni modificar el Super POM directamente, pero puedes consultar su contenido en la documentación de Maven(https://maven.apache.org/ref/3.8.4/maven-model/maven.html#super-pom).
O pueder ir a el xml, dentro del jar(la versión puede variar, pero coincide con la versión de maven) y está en la carpeta de instalación:
```
$MAVEN_HOME/lib/maven-model-builder-3.6.3.jar/org/apache/maven/model/pom-4.0.0.xml
```

Aquí podemos encontrar la definición del repositorio de maven central, la estructura de directorios, librerías básicas entre otras definiciones.

Standard Directory Layout

El Standard Directory Layout es la estructura de directorios recomendada para proyectos Maven. Facilita la organización del código fuente, recursos, pruebas, y otros archivos importantes.
Estructura de Directorios:

project-root/
|-- src/
|   |-- main/
|   |   |-- java/          # Código fuente principal
|   |   |-- resources/     # Recursos (archivos de configuración, imágenes, etc.)
|   |-- test/
|       |-- java/          # Código fuente de pruebas
|       |-- resources/     # Recursos de pruebas
|-- target/                # Archivos generados (compilaciones, artefactos)
|-- pom.xml                # Archivo de configuración de Maven

Puede sobrescribir esta estructura de carpetas en tu pom, pero ¿para qué hacerlo?.

Repositorios

Los repositorios son ubicaciones donde Maven almacena artefactos (librerías, proyectos) y sus dependencias. Maven utiliza repositorios para buscar e instalar dependencias necesarias para el proyecto.

Tipos de Repositorios

Repositorio Local: Almacena artefactos en tu máquina local (usualmente en el directorio .m2/repository).
Repositorio Central: El repositorio predeterminado al que Maven se conecta para descargar dependencias. Maven Central es el repositorio central más conocido.
Repositorios Remotos: Otros repositorios externos que puedes configurar en tu archivo pom.xml.

Ejemplo de Configuración de Repositorios en pom.xml

<repositories>
    <repository>
        <id>my-repo</id>
        <url>https://my.repo.url/repository</url>
    </repository>
</repositories>

¿Qué son los Plugins en Maven?

Los plugins se definen en el archivo pom.xml y se configuran en la sección de <build>.
Ejemplo de Configuración de Plugin

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
            </configuration>
        </plugin>
    </plugins>
</build>

Arquetipos

Un arquetipo es una plantilla para crear proyectos Maven nuevos. Define una estructura de proyecto predeterminada y puede incluir archivos de configuración básicos, código de muestra, y otros recursos.

Crear un Proyecto Usando un Arquetipo:

mvn archetype:generate -DgroupId=com.example -DartifactId=my-project -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Esto creará un nuevo proyecto basado en el arquetipo maven-archetype-quickstart.

[Métodos] Serializar y Deserializar objetos con Java

La serialización y deserialización son dos procesos utilizados en programación para convertir datos como texto o incluso un objeto de una clase, a un formato de código binario para almacenarlo o transmitirlo, y luego revertir ese proceso en otro momento o lugar para recuperar los datos originales.

Tomemos como ejemplo la sigueinte clase Persona

public class Persona implements Serializable {
    private static final long serialVersionUID = 1L; // Identificador de versión para la serialización
    private String nombre;
    private int edad;
    private String ciudad;

    // CONSTRUCTORES
    // GETTERS y SETTERS
}

Es una simple clase en java que implementa la interfaz Serializable, de la cual cobra sentido el atributo serialVersionUID ya este número de versión nos indicará a la hora de deserializar si la clase ha sufrido algún cambio o modificación.

El siguiente ejemplo, muestra un método main que:

Instancia un objeto de la clase Persona
Serializa el objeto y lo guarda en un archivo, misma ubicación donde se está ejecutando, bajo el nombre de "persona.ser"
Por último, este fragmento de Deserialización pudiera estar en otro lado, pero hace lo propio deserializando un archivo "persona.ser", en la misma ubicación que la ejecución y lo lleva a un objeto Persona

    public static void main(String[] args) {
        // Crear una instancia de Persona
        Persona persona = new Persona("Darío", 35, "Buenos Aires");

        // Serialización
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("persona.ser"))) {
            oos.writeObject(persona);
            System.out.println("Persona serializada correctamente.");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // Deserialización
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("persona.ser"))) {
            Persona personaDeserializada = (Persona) ois.readObject();
            System.out.println("Persona deserializada: " + personaDeserializada);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

Por último, nuestra propia implementación para reutilizar en métodos independientes:

Serializar

    public static void serializarObjeto(Object objeto, String ubicacion, String nombreArchivo) {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(ubicacion + File.separator + nombreArchivo))) {
            oos.writeObject(objeto);
            System.out.println("Objeto serializado correctamente en: " + ubicacion + File.separator + nombreArchivo);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

Deserializar

    // Método para deserializar un objeto desde un archivo
    public static Object deserializarObjeto(String ubicacion, String nombreArchivo, String nombreClase) {
        Object objetoDeserializado = null;
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(ubicacion + File.separator + nombreArchivo))) {
            objetoDeserializado = ois.readObject();
            System.out.println("Objeto deserializado correctamente desde: " + ubicacion + File.separator + nombreArchivo);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return objetoDeserializado;
    }

Uso

    public static void main(String[] args) {
        // Ejemplo de serialización y deserialización
        Persona persona = new Persona("Dario", 35, "Buenos Aires");

        // Serialización
        serializarObjeto(persona, "ruta/del/directorio", "persona.ser");

        // Deserialización
        Persona personaDeserializada = (Persona) deserializarObjeto("ruta/del/directorio", "persona.ser", Persona.class.getName());
        System.out.println("Persona deserializada: " + personaDeserializada);
    }