Como digo à Maven para usar a última versão de uma dependência?

Agora eu sei que este tópico é antigo, mas ao ler a pergunta e a resposta fornecida parece que o Plugin de versões Maven pode ter sido uma resposta melhor para a sua pergunta:

Em particular, podem ser úteis os seguintes objectivos:

• versões: use-latest-versions procura no pom todas as versões que foram uma versão mais recente e substitui-os pelo mais recente versao.
• versões: use-latest-releases procura no pom por todas as fotografias não instantâneas versões mais recentes liberte-os e substitua-os pelo versão de lançamento mais recente.
• versões: update-properties actualiza as propriedades definidas num projecto de modo a corresponderem a a última versão disponível de dependências específicas. Isto pode ser útil se um conjunto de dependências devem estar todas ligadas a uma versão.

Também estão previstos os seguintes outros objectivos:

• versões: display-dependency-updates scans a dependências do projecto e produz um relatório dos dependências que têm mais recentes versao.
• versões: display-plugin-updates verifica os 'plugins' de um projecto e produz um relatório desses plugins que têm versões mais recentes disponíveis.
• versões: update-parent actualiza a secção pai de um projecto por isso que faz referência ao mais recente versao. Por exemplo, se você usa um POM de raiz corporativa, isto o objetivo pode ser útil se você precisar assegura-te estão a usar o mais recente versão do POM corporativo root.
• versões: update-child-modules actualiza a secção-mãe do módulos-filhos de um projecto a versão corresponde à versão do projecto. Por exemplo, se ter um pom agregador que também o pai para os projetos que ele agregados e as crianças e as versões-mãe ficam fora de sincronia, isto mojo pode ajudar a corrigir as versões do módulos infantis. (Nota: poderá ter de invocar o Maven com a opção-N em ordem para executar este objectivo se o seu o projecto está tão avariado que não é possível compilar por causa da versão mis-match).
• versões: lock-snapshots procura no pom todas as fotografias as versões e substitui-as pelo versão actual da data-limite - Instantâneo ,por exemplo-20090327.172306-4
• versões: desbloquear-instantâneos procura no pom por todas as datas versões bloqueadas da fotografia e substituições eles com ... instantâneo.
• versões: resolução-intervalos procura dependências com intervalos de versões e resolve o intervalo para o específico versão a ser usada.
• versões: use-releases procura no pom por todas as versões instantâneas que foram libertados e substituídos eles com a libertação correspondente versao.
• versões: use-next-releases procura no pom por todas as fotografias não instantâneas versões mais recentes liberte-os e substitua-os pelo próxima versão de lançamento.
• versões: use-next-versions procura no pom por todas as versões que foram uma versão mais recente e substitui-os pela próxima versão.
• versões: commit remove o pom.xml.ficheiros versionsBackup. Formulario metade do "pobre homem" TIPO".
• versões: revert restaura o pom.ficheiros xml do pom.xml.ficheiros versionsBackup. Formulario metade do "pobre homem" TIPO".

Por favor, dê uma vista de olhos a Esta Página (secção "Dependency Version Ranges"). O que você pode querer fazer é algo como

<version>[1.2.3,)</version>

Estes intervalos de versões são implementados em Maven2.

Ao contrário dos outros, acho que há muitas razões pelas quais você pode sempre querer a versão mais recente . Particularmente se você estiver fazendo implantação contínua (nós às vezes temos como 5 lançamentos em um dia) e não quer fazer um Projeto multi-módulo.

O Que eu faço é fazer Hudson / Jenkins fazer o seguinte para cada construção:

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

Isto é, eu uso o plugin de versões e o plugin scm para atualizar as dependências e, em seguida, assiná-lo para o controle de código. Sim, deixei o meu Informador fazer o SCM checkins. (que você tem que fazer de qualquer maneira para o plugin de lançamento maven).

Você irá querer configurar o plugin de versões para apenas actualizar o que quiser:

        <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 o plugin de lançamento para fazer a versão que cuida de-SNAPSHOT e valida que existe uma versão de lançamento de-SNAPSHOT (o que é importante).

Se você fizer o que eu faço você vai obter a versão mais recente para todas as compilações instantâneas e a versão mais recente de lançamento para compilações de lançamento. Os seus builds também serão reproduzivel.

Actualizar

É defeituoso porque para executar o plugin de versões para ajustar as versões todas as versões existentes precisam existir para que o pom seja executado corretamente. Este é o plugin de versões não pode atualizar para a versão mais recente de qualquer coisa, se não pode Encontra a versão referenciada no pom. Isto é realmente bastante irritante, pois muitas vezes limpamos versões antigas por razões de espaço em disco.

Realmente você precisa de uma ferramenta separada do maven para ajustar as versões (para que você não dependa do arquivo pom para executar corretamente). Escrevi uma ferramenta dessas na linguagem humilde que é Bash. O script irá atualizar as versões como o plugin de versão e verificar o pom de volta para o controle de código. Ele também é executado como 100x mais rápido do que o plugin de versões mvn. Infelizmente não está escrito de uma maneira para uso público, mas se as pessoas estão interessadas eu poderia fazê-lo e colocá-lo em um gist ou github.

Temos cerca de 20 projectos nos seus próprios depósitos com os seus próprios empregos jenkins.
1. quando lançarmos o plugin de lançamento maven é usado. O fluxo de trabalho disso é coberto na documentação do plugin. O plugin de lançamento maven é uma porcaria (e Mas funciona. Um dia planeamos substituir este método por algo mais óptimo.
2. quando um dos projetos é lançado jenkins, em seguida, executa um trabalho especial que vamos chamar de atualização de todas as versões (como jenkins sabe que seu lançamento é uma maneira complicada, em parte, porque o plugin de lançamento maven jenkins é muito ruim também).
3. a actualização de todas as versões job conhece todos os 20 projectos. É na verdade um pom agregador para ser específico com todos os projetos na seção módulos em ordem de dependência. Jenkins executa o nosso Magic groovy / bash foo que irá puxar todos os projetos atualizar as versões para o mais recente e, em seguida, checkin os poms (novamente feito em ordem de dependência com base na seção de módulos).
4. para cada projecto se o pom tiver mudado (devido a uma alteração de versão em alguma dependência), é verificado e, em seguida, imediatamente contactamos jenkins para executar a tarefa correspondente para esse projecto (isto é para preservar a ordem de dependência da compilação caso contrário, você está à mercê do SCM Poll scheduler).

Neste ponto eu sou da opinião que é uma coisa boa ter o lançamento e versão automática 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).

A sintaxe de dependências está localizada na especificação de requisitos da versão de dependências . Aqui está para completar:

Dependências ' version elemento definir requisitos de versão, usado para calcular a versão de dependência efectiva. Os requisitos da versão têm a seguinte sintaxe:

• 1.0: Requisito "suave" em 1.0 (apenas uma recomendação, se corresponder a todos os outros intervalos para a dependência)
• [1.0]:"difícil" requisito de 1.0
• (,1.0]: x
• [1.2,1.3]: 1, 2
• [1.0,2.0): 1, 0
• [1.5,): x > = 1, 5
• (,1.0],[1.2,): x = 1, 2; conjuntos múltiplos são separados por vírgulas
• (,1.1),(1.1,): isto exclui 1, 1 (por exemplo, se se sabe que não trabalhar em combinação com esta biblioteca)

Você está possivelmente dependendo de versões de desenvolvimento que obviamente mudam muito durante o desenvolvimento?

Em vez de aumentar a versão dos lançamentos de desenvolvimento, você poderia apenas usar uma versão instantânea que você sobrepõe quando necessário, o que significa que você não teria que alterar a marca de versão em cada pequena alteração. Algo como 1.0-instantâneo...

Quem estiver a usar o último, por favor, certifique-se que tem-U, caso contrário, a última fotografia não será puxada.

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

Quando esta questão foi colocada Havia algumas falhas com gamas de versões em maven, mas estas foram resolvidas em versões mais recentes de maven. Este artigo capta muito bem como as gamas de versões funcionam e as melhores práticas para entender melhor como a maven compreende as versões: https://docs.oracle.com/middleware/1212/core/MAVEN/maven_version.htm#MAVEN8855

Também irá causar problemas se você estiver tentando definir a versão como propriedade, e referenciá-la em outro lugar onde.

A conclusão é usar as versões -plugin-maven se podes.

Às vezes você não quer usar gamas de versões, porque parece que eles são "lentos" para resolver suas dependências, especialmente quando há entrega contínua no lugar e há toneladas de versões - principalmente durante o desenvolvimento pesado.

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

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

E adicionar o plugin versions-maven ao seu ficheiro pom:

<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>

Então, para actualizar a dependência, você tem que executar os objetivos:

mvn versions:update-properties validate

Se houver uma versão mais recente que a 1.1.1, ela dir-lhe-á:

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

A minha solução em maven 3. 5. 4 ,use nexus, no eclipse:

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

Então em eclipse: atl + F5, e escolher o force update of snapshots/release

Se quiser que o Maven use a versão mais recente de uma dependência, então poderá usar o Plugin Maven das versões e como usar este plugin, o Tim já deu uma boa resposta, siga a sua Resposta.

Resposta ao porquê de já ter sido dado por Pascal Thivent no comentário da Pergunta

Eu realmente não recomendo esta prática (nem usar gamas de versões) para o por causa da reprodutibilidade da construção. Uma construção que começa a subitamente falhar por uma razão desconhecida é muito mais irritante do que actualizar manualmente versao.

Recomendarei 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>