Todo lo que querías saber sobre Maven. (Parte 2) - "Proyecto Java de la A a la Z"

Todo sobre Maven: el comienzo Me encanta practicar. Ni siquiera puedes imaginar lo tedioso que puede resultar a veces escribir sobre teoría. Sin embargo, no puedes ir a ningún lado sin ella. La práctica es otra cuestión, por supuesto. Ahora repasemos rápidamente los comandos que describí anteriormente y terminaremos)

Configurando pom.xml

Mientras teorizábamos, obtuvimos un pom.xml bastante bueno:

Ver código

<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://maven.apache.org/POM/4.0.0"
        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>com.github.javarushcommunity</groupId>
   <artifactId>maven-demo</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>Maven Demo Project</name>

   <url>https://github.com/javarushcommunity/maven-demo/</url>

   <licenses>
       <license>
           <name>The Apache Software License, Version 2.0</name>
           <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
       </license>
   </licenses>

   <developers>
       <developer>
           <id>romankh3</id>
           <name>Roman Beskrovnyi</name>
           <email>roman.beskrovnyy@gmail.com</email>
       </developer>
   </developers>

   <scm>
       <connection>git@github.com:javarushcommunity/maven-demo.git</connection>
       <developerConnection>git@github.com:javarushcommunity/maven-demo.git</developerConnection>
       <url>https://github.com/javarushcommunity/maven-demo</url>
   </scm>

   <properties>
       <mockito.version>2.26.0</mockito.version>
       <junit.version>5.5.2</junit.version>
       <image.comparison.version>4.3.0</image.comparison.version>
       <maven.compiler.source>1.8</maven.compiler.source>
       <maven.compiler.target>1.8</maven.compiler.target>
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <javadoc.plugin.version>3.1.1</javadoc.plugin.version>
       <source.plugin.version>3.2.0</source.plugin.version>
   </properties>

   <dependencies>
       <dependency>
           <groupId>org.mockito</groupId>
           <artifactId>mockito-core</artifactId>
           <version>${mockito.version}</version>
           <scope>test</scope>
       </dependency>
       <dependency>
           <groupId>org.junit.jupiter</groupId>
           <artifactId>junit-jupiter-api</artifactId>
           <version>${junit.version}</version>
           <scope>test</scope>
       </dependency>
       <dependency>
           <groupId>com.github.romankh3</groupId>
           <artifactId>image-comparison</artifactId>
           <version>${image.comparison.version}</version>
       </dependency>
   </dependencies>

   <build>
       <plugins>
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-source-plugin</artifactId>
               <version>${source.plugin.version}</version>
               <executions>
                   <execution>
                       <id>attach-sources</id>
                       <goals>
                           <goal>jar</goal>
                       </goals>
                   </execution>
               </executions>
           </plugin>
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-javadoc-plugin</artifactId>
               <version>${javadoc.plugin.version}</version>
               <executions>
                   <execution>
                       <id>attach-javadocs</id>
                       <goals>
                           <goal>jar</goal>
                       </goals>
                   </execution>
               </executions>
           </plugin>
       </plugins>
   </build>
</project>

- ¡Pero para tener algo que compilar, es necesario agregarlo allí! ¿Lógico? - Sí, capitán. bgg Por lo tanto, agreguemos una clase que tendrá un método y dos pruebas. Creemos un esquema de carpetas normal para Maven: En src/main/java crearemos un paquete en el que trabajaremos. Para redactarlo correctamente sería bueno poner al principio el nombre de la organización ( groupId ) y luego el nombre del proyecto. En nuestro caso será así: com.github.javarushcommunity.mavendemo En cuanto a mí, este es un muy buen paquete. En él crearemos la clase ImageComparator , para la cual escribiremos dos pruebas.

Conectando Maven y el proyecto en su conjunto con IDEA

Para que la idea pueda reconocer nuestras dependencias y ofrecer usarlas en el proyecto, debemos hacer varias cosas:

1. Dígale a la idea dónde estarán las fuentes del código y dónde estarán las pruebas.
2. Agregue un proyecto maven a la idea.

Para lograr lo primero, necesitas encontrar este ícono: haz clic en él y ve a la sección Módulos . A continuación, debe asignar a las carpetas creadas el marcador requerido, como se muestra en la siguiente figura: Es decir:

• • src/main/java - Fuentes
• • src/main/resources - Recursos
• • src/test/java - Pruebas
• • src/test/resources - Recursos de prueba
• • objetivo - Excluido

Todas estas Fuentes, Recursos, Prueba, Recursos de prueba y Excluidos se pueden encontrar en la línea donde está escrito Marcar como . Seleccione una carpeta y etiquétela en consecuencia. Y el segundo paso es agregar el proyecto maven a IDEA para que pueda hacer su magia. Para hacer esto, debe buscar el archivo pom.xml en IDEA y hacer clic derecho para seleccionar Agregar como proyecto Maven . Y eso es todo, estarás feliz (: Después de esto, aparecerá una placa de Maven a la derecha , que puedes abrir y ejecutar comandos de Maven en ella.

Escribimos fuentes y pruebas para nuestro “proyecto”

Entonces, agregamos Maven a la idea, ahora describamos la clase que actuará como fuente para nosotros:

Comparador de imágenes:

package com.github.javarushcommunity.mavendemo;

import com.github.romankh3.image.comparison.ImageComparison;
import com.github.romankh3.image.comparison.model.ImageComparisonResult;
import com.github.romankh3.image.comparison.model.ImageComparisonState;

import java.awt.image.BufferedImage;

/**
* Class created for answering, does two images the same or not.
*/
public class ImageComparator {

   /**
    * Method, which says the same images or not.
    *
    * @param image1 image1 for comparison
    * @param image2 image2 for comparison
    * @return return true, if images are the same, false - otherwise.
    */
   public boolean isTheSameImages(BufferedImage image1, BufferedImage image2) {
       //Create ImageComparison object
       ImageComparison imageComparison = new ImageComparison(image1, image2);

       //Compare images
       ImageComparisonResult imageComparisonResult = imageComparison.compareImages();

       //Check, that ImageComparisonState is MATCH:
       return ImageComparisonState.MATCH == imageComparisonResult.getImageComparisonState();
   }
}

Creemos pruebas para este propósito. La clase que prueba debe estar en el mismo paquete, solo en src/test/java. La idea lo sabe y tú puedes aprovechar sus capacidades. Para hacer esto, haga clic en el nombre de la clase en el archivo y seleccione Crear prueba en la bombilla que aparece: Se nos pedirá que seleccionemos la configuración para la prueba futura. No instalamos nada, simplemente hacemos clic en Aceptar: para nuestra prueba, tomaremos una comparación de imágenes de las imágenes de prueba y las colocaremos en recursos de prueba (src/test/resource). Después de esto escribiremos dos pruebas. Se comprobará que estas dos imágenes son diferentes. Y en el otro transmitiremos la misma imagen y esperaremos una respuesta de que son iguales. Luego obtenemos la siguiente prueba:

package com.github.javarushcommunity.mavendemo;

import com.github.romankh3.image.comparison.ImageComparisonUtil;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.awt.image.BufferedImage;

@DisplayName("Unit-level testing for ImageComparator")
class ImageComparatorTest {

   private final ImageComparator comparator = new ImageComparator();

   @Test
   public void shouldConfirmImagesNotTheSame() {
       //given
       BufferedImage image1 = ImageComparisonUtil.readImageFromResources("image1.png");
       BufferedImage image2 = ImageComparisonUtil.readImageFromResources("image2.png");

       //when
       boolean theSameImages = comparator.isTheSameImages(image1, image2);

       //then
       Assertions.assertFalse(theSameImages);
   }

   @Test
   public void shouldConfirmImagesTheSame() {
       //given
       BufferedImage image1 = ImageComparisonUtil.readImageFromResources("image1.png");

       //when
       boolean theSameImages = comparator.isTheSameImages(image1, image1);

       //then
       Assertions.assertTrue(theSameImages);
   }
}

Las pruebas son muy sencillas, no me extenderé en ellas. Si está interesado, algún día escribiré un artículo sobre pruebas (escríbalo en los comentarios).

Ejecutar comandos de Maven

Ahora, cuando todo esté listo para ver el trabajo de los equipos, seleccione nuestro proyecto en el complemento Maven y abra Lifecycle en él : Ahora haga clic en compilar y vea qué sucedió: De esto podemos sacar dos conclusiones:

1. Nuestras fuentes fueron compiladas y colocadas en la ruta especificada.
2. El comando fue exitoso: BUILD SUCCESS.

Y realmente, si vamos a la estructura del proyecto y miramos lo que ha cambiado allí, veremos que se ha agregado la carpeta de destino , que aún podemos explorar y encontrar nuestra clase ImageComparator compilada : Ahora me gustaría comenzar un nuevo paquete. comando desde cero. Para hacer esto, ejecutemos (haga clic dos veces) el comando de limpieza : como resultado, se nos dice que hemos eliminado la carpeta de destino , que contenía todo lo que se creó después del comando de compilación . Ejecutemos el comando test : Pruebas ejecutadas: 0... pero escribimos hasta DOS. Es decir, por alguna razón las pruebas no se ejecutaron. La codificación en vivo es así, vayamos a la web) Después de 5 minutos de buscar en Google, descubrí que con JUnit5 necesitas agregar un complemento más:

<plugin>
   <groupId>org.apache.maven.plugins</groupId>
   <artifactId>maven-surefire-plugin</artifactId>
   <version>2.22.2</version>
</plugin>

Agreguémoslo al proyecto, coloquemos la versión en <properties/> lo mejor que podamos y reiniciemos la prueba : ¡Ahora es un asunto diferente! Se realizaron dos pruebas y tuvieron éxito. ¡Fuego! Ahora ejecutamos nuestro paquete y esperamos encontrar el jarnik en la carpeta de destino: es decir, vemos nuevamente que las pruebas han pasado, y después de esto (garantiza que todo en el proyecto está bien) podemos recopilar el proyecto en un archivo. La figura muestra que hay un archivo en los registros de inicio de Maven y en la estructura del proyecto. A continuación tenemos instalar . Gran equipo. Ah, antes de que lo olvide. Se considera una buena práctica limpiar el proyecto antes de ejecutar un nuevo comando ejecutando clean . Esto le evitará tonterías en el futuro; lo garantizo por mi propia experiencia))) Por lo tanto, primero ejecutamos clean y luego instalamos : donde está la flecha, puede ver claramente dónde se encuentra el repositorio local. Según lo que escriben, esto está en camino: /Users/roman_beskrovnyi/.m2 Y el archivo en sí se ubicará aquí: /Users/roman_beskrovnyi/.m2/repository/com/github/javarushcommunity/maven-demo/1.0- INSTANTÁNEA Y si vamos a la terminal e intentamos entrar en la carpeta donde se encuentra el archivo, entonces estará allí: el despliegue no nos mostrará, y no necesitas los demás todavía...

En lugar de salida

Hoy repasamos rápidamente qué es Maven, qué hay, cuáles son los comandos principales que existen. Intenté transmitir esto de forma sencilla y con ejemplos. Todo el código fuente del ejemplo se encuentra en la organización de la comunidad JavaRush en GitHub en el proyecto maven-demo . Escribe todas las preguntas en los comentarios. Como siempre, te sugiero que te suscribas a mi cuenta en Github para no perderte el nuevo código de nuestro proyecto JRTB. Una vez más, no está muerto. Estaba simplemente en estasis))

Al principio de este artículo encontrará una lista de todos los materiales de la serie.