it-swarm.dev

Qual é a diferença entre o maven entre as tags de dependência e de plugin em pom xml?

Sou novo na ferramenta maven, fiz um projeto com Spring e Hibernate e eles são configurados em pom.xml como plugins, mas o JUnit é marcado sob dependência. Minha pergunta é qual é a lógica por trás de um como um plugin e um como dependência? 

77
Coral

Ambos os plugins e dependências são arquivos Jar. 

Mas a diferença entre eles é que a maior parte do trabalho no maven é feito usando plugins; Considerando que dependency é apenas um arquivo Jar que será adicionado ao classpath durante a execução das tarefas. 

Por exemplo, você usa um plugin do compilador para compilar os arquivos Java. Você não pode usar o plugin-compilador como uma dependência, uma vez que isso só adicionará o plugin ao caminho de classe e não acionará nenhuma compilação. Os arquivos Jar a serem adicionados ao classpath durante a compilação do arquivo serão especificados como uma dependência. 

O mesmo acontece com o seu cenário. Você tem que usar spring-plugin para executar alguns executáveis ​​de Spring [Não tenho certeza sobre o que os plug-ins de mola são usados. Eu estou apenas adivinhando aqui]. Mas você precisa de dependências para executar esses executáveis. E o Junit é marcado sob dependência, já que é usado pelo plugin surefire para executar testes unitários.

Então, podemos dizer, o plugin é um arquivo Jar que executa a tarefa, e a dependência é um Jar que fornece os arquivos de classe para executar a tarefa. 

Espero que responda sua pergunta!

151
r9891

O próprio Maven pode ser descrito como processador de alimentos que possui muitas unidades diferentes que podem ser usadas para realizar diferentes tarefas. Essas unidades são chamadas de plugins. Por exemplo, para compilar o seu projeto, o maven usa maven-compiler-plugin, para executar os testes - maven-surefire-plugin e assim por diante.

Dependência em termos de maven é um pacote de classes do qual seu projeto depende. Pode ser jar, war etc. Por exemplo, se você quer poder escrever o teste JUnit, você terá que usar anotações e classes JUnit, assim você tem que declarar que seu projeto depende do JUnit.

31
Andrew Logvinov

Os plug-ins são usados ​​para adicionar funcionalidades ao próprio Maven (como adicionar suporte a Eclipse ou SpringBoot a Maven etc.). Dependências são necessárias pelo seu código-fonte para passar qualquer fase do Maven (compile ou test por exemplo). No caso de JUnit, já que o código de teste é basicamente parte de sua base de código e você chama JUnit comandos específicos dentro dos conjuntos de teste e esses comandos não são fornecidos por Java SDK, portanto JUnit deve estar presente no momento Maven está na fase de teste e isso é tratado mencionando JUnit como uma dependência no seu arquivo pom.xml.

4
coffeMug

Se você vem de um fundo de front-end como eu e está familiarizado com o Grunt e o npm, pense assim:

Primeiro você executaria, digamos, npm install grunt-contrib-copy --save-dev. Isto é como o <dependency></dependency> do maven. Ele faz o download dos arquivos necessários para executar uma tarefa de construção.

Então você configuraria a tarefa em Gruntfile.js

copy: {
  main: {
    src: 'src/*',
    dest: 'dest/',
  },
}

Isto é como o <plugin>/<plugin> do maven. Você está dizendo à ferramenta de construção o que fazer com o código baixado por npm/<dependency></dependency>.

Claro que isso não é uma analogia exata, mas perto o suficiente para ajudar a envolver sua cabeça em torno dela.

4
Kevin

Plugins e dependências são coisas muito diferentes e são complementares. 

Quais plugins são?

Plugins executam tarefas para uma compilação Maven. Estes não são empacotados no aplicativo. 

Estes são o coração do Maven.
Qualquer tarefa executada pelo Maven é executada por plugins .
Existem duas categorias de plugins: os plugins build e reporting

  • Os plug-ins de compilação serão executados durante a compilação e devem ser configurados no elemento <build/> do POM.
  • Os plugins de relatórios serão executados durante a geração do site e devem ser configurados no elemento <reporting/> do POM. 

De acordo com o objetivo do maven especificado na linha de comando (por exemplo, mvn clean, mvn clean package ou mvn site), um lifecyle específico será usado e um conjunto específico de objetivos de plugins será executado.
Há três ciclos de vida de compilação internos: default, clean e site. O ciclo de vida default manipula sua implementação de projeto, o ciclo de vida clean manipula a limpeza do projeto, enquanto o ciclo de vida site manipula a criação da documentação do site do seu projeto. 

Uma meta de plug-in pode estar vinculada a uma fase específica de um ciclo de vida específico.
Por exemplo, o maven-compiler-plugin liga por padrão a meta compile à fase do ciclo de vida: compile.
A maioria dos plug-ins do maven (tanto os plugins principais quanto os plugins de terceiros) favorecem a convenção sobre a configuração. Então, esses geralmente vinculam uma meta de plug-in a uma fase específica para tornar seu uso mais simples. 

Isso é mais limpo e menos propenso a erros: 

<plugin>
  <artifactId>maven-compiler-plugin</artifactId>
  <version>3.7.0</version>
</plugin>

do que :

<plugin>
  <artifactId>maven-compiler-plugin</artifactId>
  <version>3.7.0</version>
  <executions>
    <execution>
        <phase>compile</phase>
        <goals>
            <goal>compile</goal>
        </goals>
    </execution>
  </executions>
</plugin>

Quais dependências são?

Dependências são artefatos/componentes do Maven necessários no caminho de classe durante a compilação do Maven.
Eles podem ser empacotados no aplicativo, mas não necessariamente (veja o scope abaixo). 

A maioria das dependências é jar mas estes também podem ser outros tipos de arquivos: war, ear, test-jar, ejb-client ... ou ainda POM ou BOM.
Em um pom.xml, as dependências podem ser especificadas em vários lugares: a parte <build><dependencies>, a parte dependencies management ou ainda em uma declaração plugin! De fato, alguns plugins podem precisar ter algumas dependências no classpath durante sua execução. Isso não é comum, mas isso pode acontecer.
Aqui está um exemplo da documentation que mostra que plugin e dependency podem funcionar juntos: 

Por exemplo, o Maven Antrun Plugin versão 1.2 usa a versão Ant 1.6.5, se você quiser usar a versão Ant mais recente ao executar este plugin, você precisa adicionar o elemento <dependencies> da seguinte forma:

<project>
  ...
  <build>
    <plugins>
      <plugin>
        <groupId>org.Apache.maven.plugins</groupId>
        <artifactId>maven-antrun-plugin</artifactId>
        <version>1.2</version>
        ...
        <dependencies>
          <dependency>
            <groupId>org.Apache.ant</groupId>
            <artifactId>ant</artifactId>
            <version>1.7.1</version>
          </dependency>
          <dependency>
            <groupId>org.Apache.ant</groupId>
            <artifactId>ant-launcher</artifactId>
            <version>1.7.1</version>
          </dependency>
         </dependencies>
      </plugin>
    </plugins>
  </build>
  ...
</project>

No Maven, as dependências são referenciadas em um formato específico:
groupId:artifactId:packaging:classifier:version.
O classificador (que é opcional) e o pacote (JAR por padrão) geralmente não são especificados. Portanto, o formato comum na declaração dependency é: groupId:artifactId:version.
Aqui está um exemplo de dependência declarada na parte <build><dependencies>

<build>
   <dependencies>
      <dependency>
         <groupId>org.hibernate</groupId>
         <artifactId>hibernate-core</artifactId>
         <version>5.2.14.Final</version>
      </dependency>
   <dependencies>
</build>

Ao contrário de um plugin, uma dependência tem um escopo.
O escopo padrão é compile. Esse é o escopo mais comumente necessário (convenção sobre configuração novamente).
O escopo compile significa que a dependência está disponível em todos os classpaths de um projeto. 

O escopo define em quais caminhos de classe a dependência deve ser adicionada. Por exemplo, nós precisamos disso na compilação e no tempo de execução, ou apenas para compilação e execução de testes? 

Por exemplo, definimos anteriormente o Hibernate como uma dependência compile, pois precisamos dele em todos os lugares: compilação de origem, compilação de teste, tempo de execução e assim por diante.
Mas não queremos que as bibliotecas de teste possam ser empacotadas no aplicativo ou referenciadas no código-fonte. Então, especificamos o escopo test para eles: 

<build>
   <dependencies>
     <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-engine</artifactId>
        <version>5.1.0</version>
        <scope>test</scope>
     </dependency>
   <dependencies>
</build>
4
davidxxx

O Maven, em sua essência, é uma estrutura de execução de plugins - de acordo com a definição formal e padrão do compact. Para tornar isso mais claro, os comandos que você usa como maven-install/clean/compile/build etc para criar/executar jars, que às vezes executamos manualmente também. Então, as coisas que você quer rodar (ou configurar ou executar) você basicamente as coloca na tag de dependência do mavens pom e a resposta para quem vai rodar essas dependências (necessárias para configuração do ambiente) são os plugins.

        javac (compiler) dependency.Java (dependency) 
1
Himanshu Ahuja