Como adicionar arquivos jar locais a um projeto Maven?

Como adiciono arquivos jar locais (ainda não parte do repositório Maven) diretamente nas fontes de biblioteca do meu projeto?

Instale o JAR no seu repositório Maven local da seguinte maneira:

mvn install:install-file \
   -Dfile=<path-to-file> \
   -DgroupId=<group-id> \
   -DartifactId=<artifact-id> \
   -Dversion=<version> \
   -Dpackaging=<packaging> \
   -DgeneratePom=true

Onde cada um se refere a:

<path-to-file>: o caminho para o arquivo a ser carregado, por exemplo → c:\kaptcha-2.3.jar

<group-id>: o grupo em que o arquivo deve ser registrado, por exemplo, → com.google.code

<artifact-id>: o nome do artefato para o arquivo, por exemplo, → kaptcha

<version>: a versão do arquivo, por exemplo, → 2.3

<packaging>: a embalagem do arquivo, por exemplo, → jar

Referência

• Maven FAQ: Eu tenho um jar que eu quero colocar no meu repositório local. Como posso copiá-lo?
• Uso do Maven Install Plugin: O install:install-fileobjetivo

Você pode adicionar dependências locais diretamente (como mencionado no projeto build maven com bibliotecas de propriedades incluídas ) assim:

<dependency>
    <groupId>com.sample</groupId>
    <artifactId>sample</artifactId>
    <version>1.0</version>
    <scope>system</scope>
    <systemPath>${project.basedir}/src/main/resources/Name_Your_JAR.jar</systemPath>
</dependency>

Atualizar

Em novas versões, esse recurso é marcado como obsoleto, mas ainda está funcionando e ainda não foi removido (você vê apenas um aviso no log durante o início do processo) Foi levantado um problema no grupo maven sobre este https://issues.apache.org/jira/browse/MNG-6523 (Você pode participar e descrever por que esse recurso é útil em alguns casos). Espero que esse recurso permaneça lá!

Se você está me perguntando, desde que o recurso não seja removido, eu uso isso para fazer dependência de apenas um arquivo jar impertinente no meu projeto que não se encaixa no repositório. Se esse recurso for removido, bem, há muitas boas respostas aqui, das quais posso escolher mais tarde!

Em primeiro lugar, gostaria de dar crédito por esta resposta a um usuário anônimo do Stack Overflow - tenho certeza de que já vi uma resposta semelhante aqui antes - mas agora não consigo encontrá-la.

A melhor opção para ter arquivos JAR locais como uma dependência é criar um repositório Maven local. Esse repositório nada mais é do que uma estrutura de diretórios adequada com arquivos pom nele.

Para o meu exemplo: eu tenho meu projeto mestre no ${master_project}local e o subprojeto1 está ativado ${master_project}/${subproject1}.

Então eu criar um repositório Maven em: ${master_project}/local-maven-repo.

No arquivo pom no subprojeto1 localizado em ${master_project}/${subproject1}/pom.xml, o repositório precisa ser especificado, o que levaria o caminho do arquivo como um parâmetro de URL:

<repositories>
    <repository>
        <id>local-maven-repo</id>
        <url>file:///${project.parent.basedir}/local-maven-repo</url>
    </repository>
</repositories>

A dependência pode ser especificada como para qualquer outro repositório. Isso torna seu repositório pom independente. Por exemplo, quando o JAR desejado estiver disponível no Maven central, você só precisará excluí-lo do seu repositório local e ele será retirado do repositório padrão.

    <dependency>
        <groupId>org.apache.felix</groupId>
        <artifactId>org.apache.felix.servicebinder</artifactId>
        <version>0.9.0-SNAPSHOT</version>
    </dependency>

A última coisa, mas não menos importante, é adicionar o arquivo JAR ao repositório local usando a opção -DlocalRepositoryPath da seguinte maneira:

mvn org.apache.maven.plugins:maven-install-plugin:2.5.2:install-file  \
    -Dfile=/some/path/on/my/local/filesystem/felix/servicebinder/target/org.apache.felix.servicebinder-0.9.0-SNAPSHOT.jar \
    -DgroupId=org.apache.felix -DartifactId=org.apache.felix.servicebinder \
    -Dversion=0.9.0-SNAPSHOT -Dpackaging=jar \
    -DlocalRepositoryPath=${master_project}/local-maven-repo

Depois que o arquivo JAR é instalado, seu repositório Maven pode ser confirmado em um repositório de códigos, e toda a configuração é independente do sistema. ( Exemplo de trabalho no GitHub ).

Concordo que ter JARs comprometidos com repo código fonte não é uma boa prática, mas na vida real, soluções rápidas e sujas às vezes são melhores que um repo Nexus completo para hospedar um JAR que você não pode publicar.

Crie uma nova pasta, digamos local-maven-repona raiz do seu projeto Maven.

Basta adicionar um repositório local dentro <project>do seu pom.xml:

<repositories>
    <repository>
        <id>local-maven-repo</id>
        <url>file:///${project.basedir}/local-maven-repo</url>
    </repository>
</repositories>

Em seguida, para cada jar externo que você deseja instalar, acesse a raiz do seu projeto e execute:

mvn deploy:deploy-file -DgroupId=[GROUP] -DartifactId=[ARTIFACT] -Dversion=[VERS] -Durl=file:./local-maven-repo/ -DrepositoryId=local-maven-repo -DupdateReleaseInfo=true -Dfile=[FILE_PATH]

Gostaria dessa solução - use maven-install-pluginno arquivo pom:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-install-plugin</artifactId>
    <version>2.5.2</version>
    <executions>
        <execution>
            <phase>initialize</phase>
            <goals>
                <goal>install-file</goal>
            </goals>
            <configuration>
                <file>lib/yourJar.jar</file>
                <groupId>com.somegroup.id</groupId>
                <artifactId>artefact-id</artifactId>
                <version>x.y.z</version>
                <packaging>jar</packaging>
            </configuration>
        </execution>
    </executions>
</plugin>

Nesse caso, você pode executar mvn initializee o jar será instalado no repositório maven local. Agora, este jar está disponível durante qualquer etapa do maven nesta máquina (não se esqueça de incluir essa dependência como qualquer outra dependência do maven no pom com <dependency></dependency>tag). Também é possível vincular a instalação do jar não para a initializeetapa, mas para qualquer outra etapa que você desejar.

<dependency>
    <groupId>group id name</groupId>
    <artifactId>artifact name</artifactId>
    <version>version number</version>
    <scope>system</scope>
    <systemPath>jar location</systemPath>
</dependency>

Sim, você pode ter, mas não é uma boa ideia.

Em vez disso, instale todos esses frascos em repositórios de máquinas

Veja também

• Como criar um projeto maven com bibliotecas de propriatery incluídas

A maneira realmente rápida e suja é apontar para um arquivo local:

<dependency>
      <groupId>sample</groupId>  
       <artifactId>com.sample</artifactId>  
       <version>1.0</version> 
      <scope>system</scope>
      <systemPath>C:\DEV\myfunnylib\yourJar.jar</systemPath>
</dependency>

No entanto, isso permanecerá apenas na sua máquina (obviamente), pois, para compartilhar, geralmente faz sentido usar um arquivo m2 adequado (nexus / artifactory) ou se você não possui nenhum desses itens ou não deseja configurar um maven local arquivo estruturado e configure um "repositório" em seu pom: local:

<repositories>
    <repository>
        <id>my-local-repo</id>
        <url>file://C:/DEV//mymvnrepo</url>
    </repository>
</repositories>

controlo remoto:

<repositories>
    <repository>
        <id>my-remote-repo</id>
        <url>http://192.168.0.1/whatever/mavenserver/youwant/repo</url>
    </repository>
</repositories>

para isso, também é possível um caminho relativo usando a variável basedir:

<url>file:${basedir}</url>

Adicione seu próprio JAR local no arquivo POM e use-o no maven build.

mvn install:install-file -Dfile=path-to-jar -DgroupId=owngroupid -DartifactId=ownartifactid -Dversion=ownversion -Dpackaging=jar

Por exemplo:

mvn install:install-file -Dfile=path-to-jar -DgroupId=com.decompiler -DartifactId=jd-core-java -Dversion=1.2 -Dpackaging=jar

Em seguida, adicione-o ao POM assim:

Uma maneira é fazer o upload para o seu próprio gerenciador de repositório Maven (como o Nexus). É uma boa prática ter um gerenciador de repositório próprio de qualquer maneira.

Outra maneira interessante que vi recentemente é incluir o Maven Install Plugin no seu ciclo de vida de construção: Você declara no POM para instalar os arquivos no repositório local. É uma sobrecarga pequena, mas pequena, e nenhuma etapa manual envolvida.

http://maven.apache.org/plugins/maven-install-plugin/install-file-mojo.html

Claro que você pode adicionar jarros a essa pasta. Mas talvez não seja o que você deseja alcançar ...

Se você precisar desses jarros para compilação, verifique esta pergunta relacionada: Posso adicionar jarros ao maven 2 build classpath sem instalá-los?

Além disso, antes que alguém o sugira, NÃO use o escopo do sistema.

Outro caso interessante é quando você deseja ter em seu projeto frascos de maven privados. Convém manter os recursos do Maven para resolver dependências transitivas. A solução é bastante fácil.

1. Crie uma pasta libs no seu projeto

2. Adicione as seguintes linhas ao seu arquivo pom.xml

   <properties><local.repository.folder>${pom.basedir}/libs/</local.repository.folder>
   </properties>
   
   <repositories>
      <repository>
           <id>local-maven-repository</id>
           <url>file://${local.repository.folder}</url>
           <releases>
               <enabled>true</enabled>
           </releases>
           <snapshots>
               <enabled>true</enabled>
           </snapshots>
      </repository>
   </repositories>

3. Abra a pasta .m2 / repository e copie a estrutura de diretórios do projeto que você deseja importar para a pasta libs .

Por exemplo, suponha que você queira importar a dependência

<dependency>
    <groupId>com.mycompany.myproject</groupId>
    <artifactId>myproject</artifactId>
    <version>1.2.3</version>
</dependency>

Basta ir em .m2 / repository e você verá a seguinte pasta

com / minhaempresa / meuprojeto / 1.2.3

Copie tudo na sua pasta libs (novamente, incluindo as pastas em .m2 / repository ) e pronto.

linha de comando :

mvn install:install-file -Dfile=c:\kaptcha-{version}.jar -DgroupId=com.google.code
-DartifactId=kaptcha -Dversion={version} -Dpackaging=jar

Parte importante da dependência é: $ {pom.basedir} (em vez de apenas $ {basedir})

<dependency>
    <groupId>org.example</groupId>
    <artifactId>example</artifactId>
    <version>1.0</version>
    <scope>system</scope>
    <systemPath>${pom.basedir}/src/lib/example.jar</systemPath>
</dependency>

Eu acho que uma solução melhor para esse problema é usar o maven-install-plugin para instalar automaticamente os arquivos no momento da instalação. É assim que eu o configurei para o meu projeto.

Primeiro, adicione o caminho (onde você armazena os .jars locais) como uma propriedade.

<properties>
    <local.sdk>/path/to/jar</local.sdk>
</properties>

Em seguida, pluginsadicione um plug-in para instalar os jars ao compilar.

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-install-plugin</artifactId>
    <version>2.5.2</version>
    <executions>
        <execution>
            <id>1</id>
            <phase>initialize</phase>
            <goals>
                <goal>install-file</goal>
            </goals>
            <configuration>
                <groupId>com.local.jar</groupId> 
                <artifactId>appengine-api</artifactId>
                <version>1.0</version>
                <packaging>jar</packaging>
                <file>${local.sdk}/lib/impl/appengine-api.jar</file>
            </configuration>
        </execution>
        <execution>
            <id>appengine-api-stubs</id>
            <phase>initialize</phase>
            <goals>
                <goal>install-file</goal>
            </goals>
            <configuration>
                <groupId>com.local.jar</groupId>
                <artifactId>appengine-api-stubs</artifactId>
                <version>1.0</version>
                <packaging>jar</packaging>
                <file>${local.sdk}/lib/impl/appengine-api-stubs.jar</file>
            </configuration>
        </execution>
    </executions>
</plugin>

Finalmente, nas dependências, você pode adicionar os jars

<dependency>
    <groupId>com.local.jar</groupId>
    <artifactId>appengine-api</artifactId>
    <version>1.0</version>
</dependency>

<dependency>
    <groupId>com.local.jar</groupId>
    <artifactId>appengine-api-stubs</artifactId>
    <version>1.0</version>
    <scope>test</scope>
</dependency>

Configurando seu projeto assim, o projeto continuará sendo construído mesmo quando você o levar para outro computador (já que ele possui todos os arquivos jar no caminho especificado pela propriedade local.sdk).

Para groupIdusar um nome exclusivo, apenas para garantir que não haja conflitos.

Agora, quando você mvn installou mvn testos frascos locais serão adicionados automaticamente.

A maneira preferida seria criar seu próprio repositório remoto.

Veja aqui para detalhes sobre como fazê-lo. Dê uma olhada na seção ' Upload para um repositório remoto '.

Quero compartilhar um código no qual você possa carregar uma pasta cheia de potes. É útil quando um provedor não possui um repositório público e você precisa adicionar muitas bibliotecas manualmente. Decidi criar um .bat em vez de chamar diretamente para o maven, pois poderia haver erros de falta de memória. Foi preparado para um ambiente Windows, mas é fácil adaptá-lo ao SO Linux:

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;
import java.util.jar.Attributes;
import java.util.jar.JarFile;
import java.util.jar.Manifest;

public class CreateMavenRepoApp {

    private static final String OCB_PLUGIN_FOLDER = "C://your_folder_with_jars";

    public static void main(String[] args) throws IOException {

    File directory = new File();
    //get all the files from a directory
    PrintWriter writer = new PrintWriter("update_repo_maven.bat", "UTF-8");
    writer.println("rem "+ new Date());  
    File[] fList = directory.listFiles();
    for (File file : fList){
        if (file.isFile()){               
        String absolutePath = file.getAbsolutePath() ;
        Manifest  m = new JarFile(absolutePath).getManifest();
        Attributes attributes = m.getMainAttributes();
        String symbolicName = attributes.getValue("Bundle-SymbolicName");

        if(symbolicName!=null &&symbolicName.contains("com.yourCompany.yourProject")) {
            String[] parts =symbolicName.split("\\.");
            String artifactId = parts[parts.length-1];
            String groupId = symbolicName.substring(0,symbolicName.length()-artifactId.length()-1);
            String version = attributes.getValue("Bundle-Version");
            String mavenLine= "call mvn org.apache.maven.plugins:maven-install-plugin:2.5.1:install-file -Dfile="+ absolutePath+" -DgroupId="+ groupId+" -DartifactId="+ artifactId+" -Dversion="+ version+" -Dpackaging=jar ";
            writer.println(mavenLine);          
        }

        }
    }
    writer.close();
    }

}

Depois de executar este main a partir de qualquer IDE, execute o update_repo_maven.bat.

Esta é uma sintaxe curta para versões mais recentes:

mvn install:install-file -Dfile=<path-to-file>

Funciona quando o JAR foi construído pelo Apache Maven - o caso mais comum. Em seguida, ele conterá um pom.xml em uma subpasta do diretório META-INF, que será lido por padrão.

Fonte: http://maven.apache.org/guides/mini/guide-3rd-party-jars-local.html

Veja também ...

<scope>compile</scope>

Dependências do Maven . Esse é o padrão, mas, em alguns casos, encontrei explicitamente definindo esse escopo também como Maven para encontrar bibliotecas locais no repositório local.

Por alguma razão, no aplicativo da Web para o qual estou dando manutenção, nem a solução de Alireza Fattahi nem a solução de JJ Roman funcionaram corretamente. Nos dois casos, a compilação corre bem (vê o frasco), mas a embalagem falha ao incluir o frasco dentro da guerra.

A única maneira de conseguir fazê-lo funcionar foi colocar o frasco /src/main/webapp/WEB-INF/lib/e combiná-lo com a solução de Fattahis ou Roman.

Observe que NÃO é necessariamente uma boa ideia usar um repositório local. Se este projeto for compartilhado com outras pessoas, todos os outros terão problemas e perguntas quando não funcionar, e o jar não estará disponível nem no seu sistema de controle de origem!

Embora o repositório compartilhado seja a melhor resposta, se você não puder fazer isso por algum motivo, a incorporação do jar é melhor do que um repositório local. O conteúdo de repositório somente local pode causar muitos problemas, especialmente com o tempo.

No seu repositório local, você pode instalar seu jar emitindo os comandos

 mvn install:install-file -Dfile=<path-to-file> -DgroupId=<group-id> \
-DartifactId=<artifact-id> -Dversion=<version> -Dpackaging=<packaging>

Siga este link útil para fazer o mesmo no site de mkyoung. Você também pode verificar o guia do maven para o mesmo

Para instalar jar de terceiros, chame o comando como abaixo

mvn install:install-file -DgroupId= -DartifactId= -Dversion= -Dpackaging=jar -Dfile=path

1. instalação mvn

Você pode escrever o código abaixo na linha de comando ou, se estiver usando o eclipse embutido, clique com o botão direito do mouse em projeto -> Executar como -> execute configurações ... -> no painel esquerdo, clique com o botão direito em Maven Build -> nova configuração -> escreva o código em Objetivos e no diretório base: $ {project_loc: NameOfYourProject} -> Executar

mvn install:install-file
   -Dfile=<path-to-file>
   -DgroupId=<group-id>
   -DartifactId=<artifact-id>
   -Dversion=<version>
   -Dpackaging=<packaging>
   -DgeneratePom=true

Onde cada um se refere a:

<caminho para o arquivo>: o caminho para o arquivo a ser carregado, por exemplo - -> c: \ kaptcha-2.3.jar

<id do grupo>: o grupo em que o arquivo deve ser registrado em, por exemplo - -> com.google.code

<id do artefato>: o nome do artefato para o arquivo, por exemplo - -> kaptcha

<version>: a versão do arquivo, por exemplo -> 2.3

<embalagem>: a embalagem do arquivo, por exemplo - -> jar

Depois de instalado, apenas declara jar em pom.xml.

 <dependency>
      <groupId>com.google.code</groupId>
      <artifactId>kaptcha</artifactId>
      <version>2.3</version>
 </dependency>

Etapa 1: configure maven-install-plugino objetivo com o install-fileseupom.xml

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-install-plugin</artifactId>
    <executions>
        <execution>
            <id>install-external-non-maven-jar-MWS-Client-into-local-maven-repo</id>
            <phase>clean</phase>
            <configuration>
                <repositoryLayout>default</repositoryLayout>
                <groupId>com.amazonservices.mws</groupId>
                <artifactId>mws-client</artifactId>
                <version>1.0</version>
                <file>${project.basedir}/lib/MWSClientJavaRuntime-1.0.jar</file>
                <packaging>jar</packaging>
                <generatePom>true</generatePom>
            </configuration>
            <goals>
                <goal>install-file</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Certifique-se de editar o filecaminho com base no caminho real do arquivo (recomendado é colocar esses frascos externos que não sejam de maven dentro de alguma pasta, digamos lib, e coloque essa libpasta dentro do seu projeto para usar o caminho relativo específico do projeto e evitar adicionar sistemas caminho absoluto específico.

Se você tiver vários frascos externos, repita o mesmo <execution>para outros frascos dentro do mesmo maven-install-plugin.

Etapa 2: Depois de configurar o maven-install-plugincomo mostrado acima no seu pom.xmlarquivo, você deverá usar esses jars no seu, pom.xmlcomo de costume:

    <dependency>
        <groupId>com.amazonservices.mws</groupId>
        <artifactId>mws-client</artifactId>
        <version>1.0</version>
    </dependency>

Observe que maven-install-pluginapenas copia seus jars externos para o .m2repositório maven local . É isso aí. Ele não inclui automaticamente esses frascos como dependências importantes para o seu projeto.

É um ponto menor, mas às vezes fácil de perder.

Eu tive o mesmo erro para um conjunto de dependências no meu pom.xml. As versões das dependências não foram especificadas no pom.xml e foram mencionadas no repositório pai. Por alguma razão, os detalhes da versão não estavam sendo sincronizados com este repositório. Daí eu inseri manualmente as versões usando a tag e funcionou como um encanto. Pouco tempo necessário para procurar as versões no pai e especificar aqui. Mas isso pode ser feito apenas para os frascos que estão mostrando o erro do artefato e ele funciona. Espero que isso ajude alguém.

No Apache Maven 3.5.4, tive que adicionar aspas duplas. Sem aspas duplas, não funcionou para mim.

exemplo: mvn install: install-file "-Dfile = local no arquivo jar" "-DgroupId = id do grupo" "-DartifactId = id do artefato" "-Dversion = version" "-Dpackaging = package type"

1. Crie um diretório de repositório local do Maven. A raiz do seu projeto deve ser algo assim para começar:

yourproject
+- pom.xml
+- src

2. Adicione um diretório de repositório Maven padrão chamado repo para o grupo com.example e versão 1.0:

yourproject
+- pom.xml
+- src
+- repo

3. Implantar o artefato No repositório, o Maven pode implantar o artefato para você usando o objetivo mvn deploy: deploy-file:

mvn deploy:deploy-file -Durl=file:///pathtoyour/repo -Dfile=your.jar -DgroupId=your.group.id -DartifactId=yourid -Dpackaging=jar -Dversion=1.0

4. instale o arquivo pom correspondente ao seu jar para que seu projeto possa encontrar jar durante a compilação do maven a partir do repositório local:

mvn install:install-file -Dfile=/path-to-your-jar-1.0.jar -DpomFile=/path-to-your-pom-1.0.pom

5. adicione repositório em seu arquivo pom:

<repositories>
    <!--other repositories if any-->
    <repository>
        <id>project.local</id>
        <name>project</name>
        <url>file:${project.basedir}/repo</url>
    </repository>
</repositories>

6. adicione a dependência no seu pom:

<dependency>
    <groupId>com.groupid</groupId>
    <artifactId>myid</artifactId>
    <version>1.0</version>
</dependency>

ESTA RESPOSTA É APENAS PARA USUÁRIOS DA ECLIPSE:

Se você estiver usando o Eclipse, coloque o jar no lib /, clique com o botão direito do mouse no nome do jar e clique em "add to build path". O Eclipse criará uma "biblioteca referenciada" e colocará o jar para você

Resolveu a importação do jar imediatamente no programa para mim