Excluir todas as dependências transitivas de uma única dependência

No Maven2, para excluir uma única dependência transitiva, eu tenho que fazer algo assim:

<dependency>
  <groupId>sample.group</groupId>
  <artifactId>sample-artifactB</artifactId>
  <version>1</version>
   <exclusions>
     <exclusion>
       <groupId>sample.group</groupId>
       <artifactId>sample-artifactAB</artifactId>
     </exclusion>
   </exclusions>
</dependency>

O problema com essa abordagem é que eu tenho que fazer isso para todas as dependências transitivas contribuídas por sample-artifactB.

Existe uma maneira de usar algum tipo de curinga para excluir todas as dependências transitivas de uma só vez, em vez de uma por uma?

Para o maven2, não há como fazer o que você descreve. Para o maven 3, existe. Se você estiver usando o maven 3, consulte outra resposta para esta pergunta

Para o maven 2, eu recomendo criar seu próprio pom personalizado para a dependência que tem suas <exclusões>. Para projetos que precisam usar essa dependência, configure a dependência para seu pom personalizado em vez do artefato típico. Embora isso não permita necessariamente excluir todas as dependências transitivas com uma única <exclusão>, permite que você precise gravar sua dependência apenas uma vez e todos os seus projetos não precisem manter listas de exclusão longas e desnecessárias.

O que funcionou para mim (pode ser um recurso mais recente do Maven) é apenas fazer curingas no elemento de exclusão.

Eu tenho um projeto de vários módulos que contém um módulo "app" que é referenciado em dois módulos empacotados em WAR. Um desses módulos empacotados com WAR realmente precisa apenas das classes de domínio (e ainda não as separei do módulo de aplicativo). Eu achei que isso funcionava:

<dependency>
    <groupId>${project.groupId}</groupId>
    <artifactId>app</artifactId>
    <version>${project.version}</version>
    <exclusions>
        <exclusion>
            <groupId>*</groupId>
            <artifactId>*</artifactId>
        </exclusion>
    </exclusions>
</dependency>

O curinga em groupId e artifactId exclui todas as dependências que normalmente seriam propagadas para o módulo usando essa dependência.

Uma coisa que achei útil:

Se você colocar a dependência com as exclusões na seção dependencyManagement do POM pai do seu projeto ou em um POM importável de gerenciamento de dependências, não será necessário repetir a exclusão (ou a versão).

Por exemplo, se o POM pai tiver:

<dependencyManagement>
    <dependencies>
    ...         
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.2.1</version>
            <exclusions>
                <exclusion>
                    <groupId>junit</groupId>
                    <artifactId>junit</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
     ....
  </dependencies>
</dependencyManagement>

Em seguida, os módulos em seu projeto podem simplesmente declarar a dependência como:

        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
        </dependency>

O POM pai especificará a versão e as exclusões. Eu uso essa técnica para quase todos os nossos projetos e elimina muita repetição.

Há três anos, eu recomendei o uso da versão 99 não existe, mas agora descobri uma maneira melhor, principalmente porque a versão 99 está offline:

No POM pai do seu projeto, use o maven-enforcer-plugin para falhar na compilação se a dependência indesejada se infiltrar na compilação. Isso pode ser feito usando a regra de dependências banidas do plug-in :

<plugin>
    <artifactId>maven-enforcer-plugin</artifactId>
    <version>1.0.1</version>
    <executions>
        <execution>
            <id>only-junit-dep-is-used</id>
            <goals>
                <goal>enforce</goal>
            </goals>
            <configuration>
                <rules>
                    <bannedDependencies>
                        <excludes>
                            <exclude>junit:junit</exclude>
                        </excludes>
                    </bannedDependencies>
                </rules>
            </configuration>
        </execution>
    </executions>
</plugin>

Então, quando isso alertar sobre uma dependência indesejada, exclua-a na <dependencyManagement>seção do POM pai :

<dependency>
    <groupId>org.springframework.batch</groupId>
    <artifactId>spring-batch-test</artifactId>
    <version>2.1.8.RELEASE</version>
    <exclusions>
        <exclusion>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </exclusion>
    </exclusions>
</dependency>

Dessa forma, a dependência indesejada não será exibida acidentalmente (ao contrário de uma <exclusion>que é fácil de esquecer), ela não estará disponível mesmo durante o tempo de compilação (ao contrário do providedescopo), não haverá dependências falsas (ao contrário da versão 99) e será ' funcionará sem um repositório personalizado (diferente da versão 99). Essa abordagem funcionará mesmo com a versão do artefato, classificadores, escopo ou um groupId inteiro - consulte a documentação para obter detalhes.

Eu uso a seguinte solução alternativa: em vez de tentar excluir o artefato em todas as dependências apropriadas, desenho a dependência como "fornecida" no nível superior. Por exemplo, para evitar o envio de xml-apis "seja qual for a versão":

    <dependency>
        <groupId>xml-apis</groupId>
        <artifactId>xml-apis</artifactId>
        <version>[1.0,]</version>
        <scope>provided</scope>
    </dependency>

Atualmente, não há como excluir mais de uma dependência transitiva por vez, mas há uma solicitação de recurso para isso no site do Maven JIRA:

https://issues.apache.org/jira/browse/MNG-2315

Existe uma solução alternativa para isso, se você definir o escopo de uma dependência como tempo de execução , as dependências transitivas serão excluídas. Embora esteja ciente, isso significa que você precisará adicionar processamento adicional se desejar compactar a dependência do tempo de execução.

Para incluir a dependência de tempo de execução em qualquer pacote, é possível usar a meta de cópia do plug-in maven-dependency-plugin para um artefato específico .

se você precisar excluir todas as dependências transitivas de um artefato de dependência que você incluirá em um assembly, poderá especificar isso no descritor do assembly-plugin:

<assembly>
    <id>myApp</id>
    <formats>
        <format>zip</format>
    </formats>
    <dependencySets>
        <dependencySet>
            <useTransitiveDependencies>false</useTransitiveDependencies>
            <includes><include>*:struts2-spring-plugin:jar:2.1.6</include></includes>
        </dependencySet>
    </dependencySets>
</assembly>

Se você desenvolver no Eclipse, poderá, no gráfico de dependência do Editor POM (guias avançadas ativadas), procurar a dependência que deseja excluir do seu projeto e, em seguida:

clique com o botão direito do mouse -> "Excluir artefato Maven ..." e o Eclipse fará a exclusão para você sem a necessidade de descobrir em qual dependência a biblioteca está vinculada.

Qual é o seu motivo para excluir todas as dependências transitivas?

Se houver um artefato específico (como log comum) que você precise excluir de todas as dependências, a abordagem Versão 99 Não Existe pode ajudar.

Atualização 2012: não use essa abordagem. Use o maven-enforcer-plugin e exclusões . A versão 99 produz dependências falsas e o repositório da versão 99 está offline (existem espelhos semelhantes, mas você também não pode confiar neles para ficar online para sempre; é melhor usar apenas o Maven Central).

Em uma questão semelhante, tive a dependência desejada declarada com o escopo fornecido. Com essa abordagem, as dependências transitivas são buscadas, mas NÃO são incluídas na fase do pacote, que é o que você deseja. Também gosto desta solução em termos de manutenção, porque não há pom, nem pom personalizado como na solução da whaley, necessária para manter; você só precisa fornecer a dependência específica no contêiner e ser feito

Use o último maven no seu caminho de classe. Ele removerá os artefatos duplicados e manterá o último artefato.