Como posso dizer que o Maven para usar a versão mais recente de uma dependência?

https://stackoverflow.com/questions/30571

09-06-2019
|

Pergunta

No Maven, as dependências são normalmente definidos como este:

<dependency>
  <groupId>wonderful-inc</groupId>
  <artifactId>dream-library</artifactId>
  <version>1.2.3</version>
</dependency>

Agora, se você estiver trabalhando com bibliotecas que têm freqüentes lançamentos, atualizando constantemente o <version> tag pode ser um pouco chato.Existe alguma maneira de dizer que o Maven para usar sempre a versão mais recente disponível (a partir do repositório)?

Solução

NOTA:

Esta resposta aplica-se a Maven 2 só!O mencionado LATEST e RELEASE metaversions ter caído no Maven 3 "para o bem da reproduzível constrói", mais de 6 anos atrás.Por favor consulte este O Maven 3 com solução de.

Se desejar utilizar sempre a versão mais recente, o Maven tem duas palavras-chave que você pode usar como uma alternativa para a versão intervalos.Você deve usar estas opções com cuidado, pois você não está mais no controle dos plugins/dependências que você está usando.

Quando você depende de um plugin ou uma dependência, você pode usar o valor de versão do mais RECENTE ou a LIBERAÇÃO.Mais RECENTE refere-se ao lançamento mais recente ou a versão de instantâneo de um determinado artefato, mais recentemente implantado artefato em um determinado repositório.LANÇAMENTO refere-se ao último não-instantâneo versão no repositório.Em geral, não é uma prática recomendada para o design de software que depende de um não-específicas versão de um artefato.Se você está desenvolvendo software, você pode querer usar a VERSÃO mais RECENTE ou como uma conveniência para que você não precisará atualizar os números de versão quando uma nova versão de uma biblioteca de terceiros é lançado.Quando você soltar o software, você deve sempre certificar-se de que o seu projeto depende em versões específicas para reduzir as chances de sua construção ou o projeto que está sendo afetado por uma versão do software que não estão sob seu controle.De uso mais RECENTE e SOLTE com cuidado, se em tudo.

Ver o POM Sintaxe seção do Maven livro para obter mais detalhes.Ou veja este doc Dependência Versão Intervalos De, onde:

Um colchete ( [ & ] ) significa "fechado" (inclusive).
Um parêntese ( ( & ) ) significa "abrir" (exclusivo).

Aqui está um exemplo que ilustra as várias opções.No Maven repository, com.foo:a minha-foo tem os seguintes metadados:

<?xml version="1.0" encoding="UTF-8"?><metadata>
  <groupId>com.foo</groupId>
  <artifactId>my-foo</artifactId>
  <version>2.0.0</version>
  <versioning>
    <release>1.1.1</release>
    <versions>
      <version>1.0</version>
      <version>1.0.1</version>
      <version>1.1</version>
      <version>1.1.1</version>
      <version>2.0.0</version>
    </versions>
    <lastUpdated>20090722140000</lastUpdated>
  </versioning>
</metadata>

Se uma dependência em que o artefato é necessária, você tem as seguintes opções (outros versão intervalos de pode ser especificado, é claro, apenas mostrando o que são relevantes aqui):

Declarar uma versão exata (sempre resolver a 1.0.1):

<version>[1.0.1]</version>

Declarar uma versão explícita (sempre resolver a 1.0.1, a menos que uma colisão ocorre, quando o Maven irá selecionar uma versão correspondente):

<version>1.0.1</version>

Declarar um intervalo de versão para todos 1.x (atualmente resolver 1.1.1):

<version>[1.0.0,2.0.0)</version>

Declarar um open-ended intervalo de versão (vai resolver para 2.0.0):

<version>[1.0.0,)</version>

Declarar a versão mais RECENTE (vai resolver para 2.0.0) (removido do maven 3.x)

<version>LATEST</version>

Declarar a versão de LANÇAMENTO (resolverá 1.1.1) (removido do maven 3.x):

<version>RELEASE</version>

Observe que, por padrão, suas próprias implementações irá atualizar o "mais recente" entrada no Maven metadados, mas para atualizar a versão "de entrada", você precisa ativar a versão "perfil" do Super POM Maven.Você pode fazer isso com qualquer um "-Prelease-perfil" ou "-DperformRelease=true"

Vale a pena enfatizar que qualquer abordagem que permite que o Maven para escolher a dependência versões mais RECENTES e versão intervalos), pode deixá-lo aberto para o tempo de construção de problemas, como versões posteriores podem ter diferentes comportamentos (por exemplo, a dependência plugin anteriormente comutação de um padrão valor de true para false, com resultados confusos).

Portanto, é geralmente uma boa idéia para definir exatamente versões em lançamentos.Como Tim resposta aponta, a o maven-versões-plugin é uma ferramenta útil para a atualização de dependência versões, nomeadamente o versões:use-mais recente-versões e versões:use-mais recente-lançamentos gols.

Outras dicas

Agora eu sei que este tópico é antigo, mas lendo a pergunta e a OP fornecido resposta, ao que parece, O Maven Versões Do Plugin pode realmente ter sido uma melhor resposta para sua pergunta:

Em particular, os seguintes objetivos podem ser usadas:

versões:use-mais recente-versões procura o pom para todas as versões o que tem sido uma versão mais recente e substitui-los com o mais recente versão.
versões:use-mais recente-lançamentos procura o pom para todos os não-INSTANTÂNEO versões que têm sido uma mais recente lançamento e substitui-los com o versão mais recente.
versões:update-propriedades atualizações de propriedades definidas em um projecto, de modo a que eles correspondem a a versão mais recente disponível do dependências específicas.Isso pode ser útil se um conjunto de dependências todos devem ser bloqueado para uma versão.

A seguir, outros objetivos também são fornecidos:

versões:apresentar-dependência-atualizações analisa um projeto de dependências e produz um relatório desses dependências que tenham mais recente versões disponíveis.
versões:apresentar-plugin-atualizações analisa um projeto de plugins e produz um relatório desses plugins que tenham versões mais recentes disponíveis.
versões:update-pai atualizações da secção principal de um projeto tão que referências mais recentes a versão disponível.Por exemplo, se você usar uma empresa de raiz POM, este o objetivo pode ser útil se você precisar certifique-se de usar a última versão de a raiz da empresa POM.
versões:update-criança-módulos actualiza a secção principal da filho de módulos de um projeto, de modo a a versão corresponde à versão do projeto atual.Por exemplo, se você ter um agregador pom que também é o pai para os projetos que ele agregados e as crianças e pai versões ficar fora de sincronia, isso mojo pode ajudar a corrigir as versões do criança módulos.(Observe que você pode precisar invocar o Maven com a opção-N no para executar este objetivo, se o seu projeto é quebrado tão mal que ele não pode criar por causa da versão mis-match).
versões:lock-instantâneos procura o pom para todos -SNAPSHOT versões e substitui-los com o timestamp atual versão de que -INSTANTÂNEO, e.g.-20090327.172306-4
versões:desbloqueio-instantâneos procura o pom para todos carimbo de data / hora bloqueado instantâneo e substitui versões - os com -INSTANTÂNEO.
versões:resolver-intervalos de encontra dependências usando a versão intervalos e resolve o intervalo para o específico a versão a ser utilizada.
versões:use-lançamentos procura o pom para todas as versões SNAPSHOT que foram lançados e substitui - os com o correspondente lançamento versão.
versões:use-next-lançamentos procura o pom para todos os não-INSTANTÂNEO versões que têm sido uma mais recente lançamento e substitui-los com o próxima versão.
versões:use-as próximas versões procura o pom para todas as versões o que tem sido uma versão mais recente e substitui-los com a próxima versão.
versões:commit remove o pom.xml.versionsBackup arquivos.Formas uma metade do built-in "Homem Pobre SCM".
versões:reverter restaura a pom.xml arquivos do pom.xml.versionsBackup arquivos.Formas uma metade do built-in "Homem Pobre SCM".

Apenas pensei em incluir qualquer referência futura.

Por favor, dê uma olhada no nesta página (seção "Dependência Versão Intervalos").O que você deve fazer é algo como

<version>[1.2.3,)</version>

Estes versão intervalos são implementados em Maven2.

Ao contrário de outros, eu acho que há muitas razões por que você pode sempre quer a última versão.Especialmente se você estiver fazendo a implantação contínua (às vezes temos 5 lançamentos em um dia) e não quer fazer um multi-módulo de projeto.

O que eu faço é fazer Hudson/Jenkins fazer o seguinte para cada compilação:

mvn clean versions:use-latest-versions scm:checkin deploy -Dmessage="update versions" -DperformRelease=true

Esse é que é usar o versões do plugin e scm plugin para atualizar as dependências e, em seguida, check-in para controlo de origem.Sim, eu deixei minha CI fazer SCM checkin (que você tem que fazer de qualquer maneira para o maven versão plugin).

Você vai querer configurar as versões do plugin para atualizar somente o que você deseja:

        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>versions-maven-plugin</artifactId>
            <version>1.2</version>
            <configuration>
                <includesList>com.snaphop</includesList>
                <generateBackupPoms>false</generateBackupPoms>
                <allowSnapshots>true</allowSnapshots>
            </configuration>
        </plugin>

Eu uso a versão plugin para fazer o lançamento, que cuida de INSTANTÂNEO e valida que há uma versão do SNAPSHOT (que é importante).

Se você fizer o que eu disser você vai ter a versão mais recente para todos os instantâneo cria e o mais recente lançamento da versão para compilações de versão.Suas construções também será reproduzido.

Atualização

Eu observei alguns comentários a fazer algumas especificidades deste fluxo de trabalho.Eu vou dizer que não usar este método mais e a grande razão por que o maven versões do plugin é buggy e, em geral, é inerentemente falho.

Ele é falho porque para executar as versões do plugin para ajustar as versões de todas as versões existentes precisam existir para o pom para executar corretamente.Que é o versões do plugin não pode atualizar para a versão mais recente de qualquer coisa, se ele não pode encontrar a versão referenciada no pom.Isso é realmente muito chato, como nós, muitas vezes, limpeza de versões antigas para o espaço em disco razões.

Realmente você precisa de uma ferramenta separada do maven para ajustar as versões (para não depender do pom arquivo para executar corretamente).Eu tenho escrito como uma ferramenta no humildes o idioma que é o Bash.O script de atualização de versões, como a versão do plugin e verifique o pom para controlo de origem.Ele também funciona como 100x mais rápido do que o mvn versões do plugin.Infelizmente não é escrito de uma forma para uso público, mas se as pessoas estão interessadas podia fazer isso e colocá-lo em um gist ou github.

Indo de volta para o fluxo de trabalho, como alguns comentários perguntado sobre o que é isso que fazemos:

Temos 20 ou mais projetos em seus próprios repositórios com o seu próprio jenkins empregos
Quando lançamos o maven versão do plugin é usado.O fluxo de trabalho de que é coberto na documentação do plugin.O maven versão do plugin espécie de chupa (e eu estou sendo gentil), mas ela não funciona.Um dia a gente está pensando em substituir esse método com algo mais ideal.
Quando um dos projetos fica liberado jenkins, em seguida, executa um trabalho especial, vamos chamar a atualização de todas as versões de trabalho (como jenkins sabe seu um lançamento é complicado forma, em parte, porque o maven jenkins versão do plugin é muito ruim assim).
A atualização de todas as versões de emprego sabe sobre todos os 20 projetos.Na verdade é um agregador de pom para ser mais específico com todos os projetos na seção de módulos na ordem de dependência.Jenkins é executado nossa magia groovy/bash foo que vai puxar todos os projetos de atualização de versões para o mais recente e, em seguida, disponibilizar o poms (novamente o feito em ordem de dependência com base nos módulos de seção).
Para cada projeto, se o pom foi alterado (por causa de uma alteração de versão em alguma dependência) é verificada e, em seguida, nós imediatamente ping jenkins para executar a tarefa correspondente para o projeto (isso é para preservar a dependência de compilação, a fim caso contrário, você está à mercê do SCM Enquete programador).

Nesse ponto, eu sou da opinião de que é uma boa coisa para ter o lançamento e o auto versão de uma ferramenta separada de sua construção geral de qualquer maneira.

Agora você pode pensar que o maven classificar uma merda por causa dos problemas listados acima, mas este, na verdade, seria bastante difícil com uma ferramenta de compilação que não tem um declarativa fácil de analisar extensível sintaxe (aka XML).

Na verdade, nós personalizado adicionar atributos XML através de namespaces para ajudar dica bash/scripts groovy (e.g.não atualizar esta versão).

As dependências de sintaxe está localizado no Dependência Versão De Especificação De Requisitos a documentação.Aqui é para a integralidade:

Dependências' version elemento definir requisitos de versão, utilizada para calcular eficaz de dependência versão.Requisitos de versão têm a seguinte sintaxe:

1.0:"Soft" exigência 1.0 (apenas uma recomendação, se corresponder a todas as outras faixas para a dependência)

[1.0]:"Rígido" exigência 1.0

(,1.0]:x <= 1.0

[1.2,1.3]:1.2 <= x <= 1.3

[1.0,2.0):1.0 <= x < 2.0

[1.5,):x >= 1.5

(,1.0],[1.2,):x <= 1.0 ou x >= 1.2;vários conjuntos são separados por vírgula

(,1.1),(1.1,):isso exclui 1.1 (por exemplo, se ele é conhecido por não funcionam em combinação com esta biblioteca)

No seu caso, você poderia fazer algo como <version>[1.2.3,)</version>

Você, possivelmente, dependendo versões de desenvolvimento que, obviamente, mudar muito durante o desenvolvimento?

Em vez de incrementar a versão de versões de desenvolvimento, você poderia usar apenas um instantâneo de versão que substitui, quando necessário, o que significa que você não tem que alterar a versão de etiqueta, em cada pequena alteração.Algo como 1.0-INSTANTÂNEO...

Mas talvez o que você está tentando alcançar algo mais ;)

Quem já está usando o mais RECENTE, por favor, certifique-se de que você tem-U caso contrário, o mais recente snapshot não vai ser puxado.

mvn -U dependency:copy -Dartifact=com.foo:my-foo:LATEST
// pull the latest snapshot for my-foo from all repositories

Pelo tempo que esta questão foi colocada lá estavam algumas torções com a versão intervalos em que o maven, mas estes têm sido resolvido em versões mais recentes do maven.Este artigo capta muito bem como a versão intervalos de trabalho e melhores práticas para entender melhor como o maven entende versões: https://docs.oracle.com/middleware/1212/core/MAVEN/maven_version.htm#MAVEN8855

A verdade é que mesmo em 3.x ele ainda funciona, surpreendentemente, a projetos de cria e implanta.Mas o mais RECENTE RELEASE/palavra-chave causando problemas no m2e e eclipse em todo o lugar, TAMBÉM projetos depende da dependência que implantou através da mais RECENTE/RELEASE falhar para reconhecer a versão.

Ele também irá causar problema se você tentar definir a versão, como propriedade, e fazer referência a ele em qualquer outro lugar.

Então, a conclusão é a de usar o versões-maven-plugin se você pode.

Às vezes você não deseja usar a versão intervalos, porque parece que eles são "lentos", para resolver suas dependências, especialmente quando existe uma entrega contínua, em lugar e há toneladas de versões, principalmente durante grande desenvolvimento.

Uma solução seria usar o versões-maven-plugin.Por exemplo, você pode declarar uma propriedade:

<properties>
    <myname.version>1.1.1</myname.version>
</properties>

e adicionar as versões-maven-plugin para o seu pom arquivo:

<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>versions-maven-plugin</artifactId>
            <version>2.3</version>
            <configuration>
                <properties>
                    <property>
                        <name>myname.version</name>
                        <dependencies>
                            <dependency>
                                <groupId>group-id</groupId>
                                <artifactId>artifact-id</artifactId>
                                <version>latest</version>
                            </dependency>
                        </dependencies>
                    </property>
                </properties>
            </configuration>
        </plugin>
    </plugins>
</build>

Em seguida, a fim de atualizar a dependência, você terá de executar os objetivos:

mvn versions:update-properties validate

Se houver uma versão mais recente do que 1.1.1, ele vai dizer:

[INFO] Updated ${myname.version} from 1.1.1 to 1.3.2

Se você deseja que o Maven deve usar a versão mais recente de uma dependência, em seguida, você pode usar Versões Maven Plugin e como usar este plugin, Tim já deu uma boa resposta, siga seu responder.

Mas como desenvolvedor, eu não recomendo este tipo de práticas.POR quê?

resposta do por que já é dado por Pascal Thivent no comentário da pergunta

Eu realmente não recomendo esta prática (nem usando a versão intervalos) para a questão de construir a reprodutibilidade.Uma compilação que começa, de repente, falhar por um motivo desconhecido é a maneira mais chato do que atualizar manualmente um número de versão.

Vou recomendar este tipo de prática:

<properties>
    <spring.version>3.1.2.RELEASE</spring.version>
</properties>

<dependencies>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>

</dependencies>

ele é de fácil manutenção e fácil de depurar.Você pode atualizar o seu POM em nenhum momento.

A MINHA solução no maven 3.5.4 ,usar o nexus, no eclipse:

<dependency>
    <groupId>yilin.sheng</groupId>
    <artifactId>webspherecore</artifactId>
    <version>LATEST</version> 
</dependency>

em seguida, no eclipse: atl + F5, e escolha o force update of snapshots/release

ele trabalha para mim.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow