Qual é a diferença no maven entre as tags de dependência e plug-in no pom xml?

118

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

Coral
fonte

Respostas:

213

Os plug-ins e as dependências são arquivos Jar.

Mas a diferença entre eles é que a maior parte do trabalho no maven é feita usando plug-ins; enquanto a dependência é 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 plug-in do compilador como uma dependência, pois isso apenas adicionará o plug-in 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 o plugin do spring para executar alguns executáveis ​​do spring [Não tenho certeza para que os plugins do spring são usados. Estou apenas dando um palpite aqui]. Mas você precisa de dependências para executar esses executáveis. E o Junit é marcado como dependência, pois é usado pelo surefire-plugin para executar testes de unidade.

Portanto, podemos dizer que 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 isso responda à sua pergunta!

r9891
fonte
Alguém pode me dizer qual é a diferença entre fase e objetivo em execução? Como eu sabia, a fase está falando sobre o ciclo de vida do maven .. mas por que objetivo de novo? alguma dica? Às vezes vejo pessoas colocando a palavra-chave do ciclo de vida na meta ... (?.?)
Taymedee
@taymedee esta pergunta do SO descreve a diferença: stackoverflow.com/questions/16205778/…
dev_feed
1
@ r981 Sua resposta precisa ser mais clara. Esta resposta é melhor: stackoverflow.com/questions/26292073/…
Digital Impermanence
Acho que o ponto perdido dessa resposta é que: as dependências de nível superior são usadas principalmente pelo seu artefato em vez dos plug-ins.
Gratuito
3
@MichaelPacheco, O que eu quis dizer é que o plugin do spring irá realizar uma certa tarefa de execução de um conjunto de código, que pode ser dependente de algumas bibliotecas, que serão especificadas pelas 'dependências'. Veja um exemplo diferente: você precisa de um compilador para executar um trecho de código; Aqui, seu compilador é um plugin e seu código é o executável. Seu compilador sozinho é capaz de executar qualquer código, mas seu código pode ser dependente de uma biblioteca, digamos apache commons, que será uma dependência. Seu compilador só pode compilar o código quando as dependências estão presentes no classpath. Espero que esteja claro agora.
r9891
37

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

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

Andrew Logvinov
fonte
obrigado pela resposta rápida, desculpe, mas ainda estou confuso, pois sei que JUnit também é um framework e (hibernate, spring) também vem somente no framework, então isso significa que em casos (hibernate, spring) também pode ser configurado em tags de dependência ? espero que você tenha entendido minha pergunta.
Coral
Sim, e até onde eu sei, não existe um plugin do Spring maven. Normalmente, as bibliotecas Spring (ou Hibernate, ou JUnit, ou TestNG etc.) são declaradas como dependências para seu projeto. Se você é novo no maven, recomendo que leia este livro muito bom.
Andrew Logvinov
@AndrewLogvinov - Tenho um projeto multi-pom para teste de automação de API. Um dos projetos do maven possui testes de automação. A seção de construção do pom do projeto tinha apenas 1 plugin - plugin maven surefire com referência a um pacote. A tag de construção inteira foi removida. Você poderia me dizer o que isso significa? obrigado.
MasterJoe
15

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

O que são plug-ins?

Os plug-ins realizam tarefas para uma construção Maven. Eles não estão incluídos no aplicativo.

Estes são o coração de Maven.
Qualquer tarefa executada pelo Maven é realizada por plug-ins .
Existem duas categorias de plug-ins: o builde os reportingplug - ins :

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

De acordo com o objetivo do maven especificado na linha de comando (por exemplo mvn clean, mvn clean packageou mvn site), um estilo de vida específico será usado e um conjunto específico de objetivos de plug-ins será executado.
Há três built-in ciclos de vida de compilação: default, cleane site. O defaultciclo de vida lida com a implantação do projeto, o cleanciclo de vida lida com a limpeza do projeto, enquanto o siteciclo de vida lida com a criação da documentação do site do seu projeto.

Um objetivo de plugin pode estar ligado a uma fase específica de um ciclo de vida específico.
Por exemplo, os maven-compiler-pluginliga por defeito, o compilemeta para a fase do ciclo de vida: compile.
A maioria dos plug-ins maven (plug-ins de núcleo e plug-ins de terceiros) favorecem a convenção em vez da configuração. Portanto, eles geralmente vinculam um objetivo do plugin a uma fase específica para tornar seu uso mais simples.

Isso é mais limpo e menos sujeito 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 são as dependências?

Dependências são artefatos / componentes do Maven necessários no caminho de classe durante a construção do Maven.
Eles podem estar incluídos no aplicativo, mas não necessariamente (veja scopeabaixo).

A maioria das dependências são jar, mas 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 <build><dependencies>parte, a dependencies managementparte ou ainda em uma plugindeclaração ! Na verdade, alguns plug-ins podem precisar de algumas dependências no caminho de classe durante sua execução. Isso não é comum, mas pode acontecer.
Aqui está um exemplo da documentação que mostra isso plugine dependencypode funcionar em conjunto:

Por exemplo, o plug-in Maven Antrun versão 1.2 usa Ant versão 1.6.5, se você quiser usar a versão mais recente do Ant ao executar este plug-in, é necessário adicionar um <dependencies>elemento como o seguinte:

<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 a embalagem ( JARpor padrão) não são comumente especificados. Assim, o formato comum na dependencydeclaração é bastante: groupId:artifactId:version.
Aqui está um exemplo de dependência declarada na <build><dependencies>parte:

<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 compileescopo significa que a dependência está disponível em todos os caminhos de classe de um projeto.

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

Por exemplo, definimos anteriormente o Hibernate como uma compiledependência, pois precisamos dele em todos os lugares: compilação de origem, compilação de teste, tempo de execução e assim por ....
Mas não queremos que as bibliotecas de teste possam ser empacotadas no aplicativo ou referenciadas no código-fonte . Portanto, especificamos o testescopo 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>
davidxxx
fonte
ótima explicação !, já que não sou muito versado em configurar dependências em Java, ainda tenho uma dúvida, estou atualmente trabalhando no IntelliJ, e criei um projeto maven, quando tentei incluir webdriver-ietenho duas opções, ou incluí-lo como pluginsou dependencyincluí ambos para comparar e observei que ambos groupIdtinham exatamente o mesmo, a única diferença era que pluginsnão vinham com uma versão específica, mas dependencyvinham com 0.6.685. Você poderia explicar em termos leigos (em relação a este exemplo) qual é a diferença, qual usar quando. Alguma sugestão?
Anu
1
É difícil dar a resposta mais exata sem ver o seu pom.xml. Mas algo que deve interessar a você é que especificar a versão da dependência é obrigatório (no pom atual ou no pom pai se for uma dependência herdada) em qualquer versão do Maven desde o Maven 3 (provavelmente uma ideia ruim e boa como recurso), especificar a versão do plugin é opcional. O Maven usará a última versão disponível no repositório de lançamento onde o Maven a encontrar. (1/2)
davidxxx
1
Observe que não é uma boa maneira de especificar um plugin. Isso não torna sua construção reproduzível ao longo do tempo ( cwiki.apache.org/confluence/display/MAVEN/… ). Você deve ver um aviso na construção. Então qual é a diferença ?". Os plug-ins executam tarefas para uma construção Maven, enquanto a dependência são bibliotecas (jar ou qualquer outra) necessárias no classpath durante a construção. Se a compilação de seu projeto for a mesma em qualquer caso (usando a biblioteca ou o plugin), isso significa que o plugin está indefeso porque não é usado. (2/2)
davidxxx
6

Se você tem experiência em 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,. Isso é como o maven <dependency></dependency>. Ele baixa os 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/',
  },
}

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

Claro que esta não é uma analogia exata, mas é próxima o suficiente para ajudar a entender isso.

Kevin
fonte
4

Plug-ins são usados ​​para adicionar funcionalidades a Mavenele mesmo (como adicionar eclipsesuporte ou SpringBootsuporte a Mavenetc.). As dependências são necessárias para seu código-fonte para passar qualquer fase do Maven ( compileou testpor exemplo). No caso de JUnito código de teste ser basicamente parte de sua base de código e você chamar JUnitcomandos específicos dentro de suítes de teste e esses comandos não forem fornecidos pelo, Java SDKportanto, JUnitdeve estar presente no momento Mavenem que está em fase de teste e isso é tratado mencionando JUnitcomo uma dependência em seu pom.xmlarquivo.

coffeMug
fonte
1

Maven em seu coração é uma estrutura de execução de plug-in - de acordo com a definição compacta formal e padrão. Para deixar mais claro, os comandos que você usa maven-install/clean/compile/build etcpara criar / executar jars, que às vezes também executamos manualmente. Então, as coisas que você deseja executar (ou configurar ou executar) você basicamente coloca na tag de dependência do mavens pom e a resposta para quem irá executar essas dependências (necessárias para a configuração do ambiente) serão os plugins.

        javac (compiler) dependency.java (dependency) 
Himanshu Ahuja
fonte
1

Resposta de uma linha - compreensão básica

Pluginéuma ferramenta que você usa na execução de sua compilação de maven

Dependência significa qualquer tipo de biblioteca que você usará em seu código

Yogesh Rathi
fonte
0

Um plugin é uma extensão do Maven, algo usado para produzir seu artefato (maven-jar-plugin por exemplo, é usado para, você adivinhar, fazer um jar com suas classes e recursos compilados).

Uma dependência é uma biblioteca necessária para o aplicativo que você está construindo, durante a compilação e / ou teste e / ou tempo de execução.

plugin e dependência

DeC
fonte