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

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?

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!

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.

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>

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.

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.

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) 

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

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.