Tudo o que você queria saber sobre Maven. (Parte 2) - "Projeto Java de A a Z"

Tudo sobre Maven: o começo que adoro praticar. Você nem imagina como às vezes pode ser tedioso escrever sobre teoria. No entanto, você não pode ir a lugar nenhum sem ela. A prática é outra questão, claro. Agora vamos passar rapidamente pelos comandos que descrevi anteriormente e terminaremos)

Configurando pom.xml

Enquanto teorizávamos, obtivemos um pom.xml muito bom:

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>

- Mas para ter algo para compilar é preciso adicionar lá! Lógico? - Sim capitão. bgg Portanto, vamos adicionar uma classe que terá um método e dois testes para ela. Vamos criar um esquema de pastas normal para o Maven: Em src/main/java criaremos um pacote no qual trabalharemos. Para compor corretamente, seria bom colocar o nome da organização ( groupId ) no início e depois o nome do projeto. No nosso caso será assim: com.github.javarushcommunity.mavendemo Quanto a mim, este é um pacote muito bom. Nele criaremos a classe ImageComparator , para a qual escreveremos dois testes.

Conectando o Maven e o projeto como um todo ao IDEA

Para que a ideia seja capaz de reconhecer nossas dependências e se oferecer para utilizá-las no projeto, precisamos fazer várias coisas:

1. Diga a ideia de onde estarão as fontes do código e onde estarão os testes.
2. Adicione um projeto maven à ideia.

Para conseguir o primeiro, você precisa encontrar este ícone: Clique nele e vá para a seção Módulos . A seguir, é necessário atribuir às pastas criadas o marcador necessário, conforme mostrado na figura abaixo: Ou seja:

• • src/main/java - Fontes
• • src/main/resources - Recursos
• • src/test/java - Testes
• • src/test/resources - Recursos de teste
• • alvo - excluído

Todas essas Fontes, Recursos, Teste, Recursos de Teste e Excluídos podem ser encontradas na linha onde está escrito Marcar como . Selecione uma pasta e rotule-a de acordo. E o segundo passo é adicionar o projeto maven ao IDEA para que ele possa fazer sua mágica. Para fazer isso, você precisa encontrar o arquivo pom.xml no IDEA e clicar com o botão direito para selecionar Add as Maven Project . E é isso, você ficará feliz (: Depois disso, uma placa Maven aparecerá à direita , que você pode abrir e executar comandos do Maven nela.

Escrevemos fontes e testes para nosso “projeto”

Então, adicionamos Maven à ideia, agora vamos descrever a classe que atuará como fonte para nós:

Comparador de imagens:

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();
   }
}

Vamos criar testes para esse fim. A classe que testa deve estar no mesmo pacote, apenas em src/test/java. A ideia sabe disso e você pode aproveitar suas capacidades. Para fazer isso, clique no nome da classe no próprio arquivo e selecione Criar teste na lâmpada que aparece: Seremos solicitados a selecionar as configurações para o teste futuro. Não instalamos nada, apenas clique em OK: Para nosso teste, faremos uma comparação de imagens das imagens de teste e as colocaremos em recursos de teste (src/test/resource). Depois disso, escreveremos dois testes. Verificaremos se essas duas imagens são diferentes. E na outra transmitiremos a mesma imagem e esperaremos uma resposta de que são iguais. Então obtemos o seguinte teste:

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);
   }
}

Os testes são muito simples, não vou me alongar neles. Se você estiver interessado, algum dia escreverei um artigo sobre testes (escreva sobre isso nos comentários).

Executar comandos do Maven

Agora, quando tudo estiver pronto para ver o trabalho das equipes, selecione nosso projeto no plugin Maven e abra nele o Lifecycle : Agora clique em compilar e veja o que aconteceu: Disto podemos tirar duas conclusões:

1. Nossas fontes foram compiladas e colocadas no caminho especificado.
2. O comando foi bem-sucedido - BUILD SUCCESS.

E realmente, se formos para a estrutura do projeto e olharmos o que mudou lá, veremos que a pasta de destino foi adicionada , que ainda podemos explorar e encontrar nossa classe ImageComparator compilada : Agora gostaria de iniciar um novo pacote comando do zero. Para fazer isso, vamos executar (clicar duas vezes) o comando clean : Como resultado, somos informados de que excluímos a pasta de destino , que continha tudo o que foi criado após o comando de compilação . Vamos executar o comando test : Tests run: 0... mas escrevemos até DOIS. Ou seja, por algum motivo os testes não foram executados. A codificação ao vivo é assim, vamos para a web) Após 5 minutos pesquisando no Google, descobri que com o JUnit5 você precisa adicionar mais um plugin:

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

Vamos adicioná-lo ao projeto, colocar a versão em <properties/> da melhor maneira possível e reiniciar o teste : agora é outra coisa! Dois testes foram executados e foram bem-sucedidos. Fogo! Agora executamos nosso pacote e esperamos encontrar o jarnik na pasta de destino : Ou seja, vemos novamente que os testes passaram, e depois disso (garante que tudo no projeto está bom) podemos coletar o projeto em um arquivo. A figura mostra que há um arquivo nos logs de inicialização do maven e na estrutura do projeto. Em seguida temos install . Grande time. Ah, antes que eu esqueça. É considerada uma boa prática limpar o projeto antes de executar um novo comando executando clean . Isso o salvará de bobagens no futuro - garanto por minha própria experiência))) Portanto, primeiro executamos clean e depois instalamos : Onde está a seta, você pode ver claramente onde o repositório local está localizado. Com base no que eles escrevem, este é o meu caminho: /Users/roman_beskrovnyi/.m2 E o arquivo em si estará localizado aqui: /Users/roman_beskrovnyi/.m2/repository/com/github/javarushcommunity/maven-demo/1.0- INSTANTÂNEO E se formos ao terminal e tentarmos entrar na pasta onde está o arquivo, então ele estará lá: o deploy não nos mostrará, e você não precisa dos outros ainda...

Em vez de saída

Hoje examinamos rapidamente o que é Maven, o que existe, quais são os principais comandos que existe. Tentei transmitir isso de forma simples e com exemplos. Todo o código-fonte do exemplo está localizado na organização da comunidade JavaRush no GitHub no projeto maven-demo . Escreva todas as perguntas nos comentários. Como de costume, sugiro que você assine minha conta no Github para não perder o novo código do nosso projeto JRTB. Mais uma vez, ele não está morto. Ele estava simplesmente em êxtase))

Uma lista de todos os materiais da série está no início deste artigo.