Maven: melhor maneira de vincular JAR externo personalizado ao meu projeto?


151

São meus primeiros dias aprendendo Maven e ainda estou lutando com o básico. Eu tenho um arquivo .jar externo (não disponível nos repositórios públicos) que preciso fazer referência no meu projeto e estou tentando descobrir qual é a minha melhor opção.

É um projeto de pequena escala sem um repositório central para bibliotecas, portanto, ele deve ser um repositório local (de alguma forma adicionado ao controle de origem, não sei se deve funcionar dessa maneira?) Ou o .jar precisa ser armazenado em disco fora de qualquer repositório formal.

1) Qual é a minha melhor opção para adicionar o arquivo .jar às referências do meu projeto com o maven, pois quero que o projeto e a biblioteca estejam no controle de origem?

2) Ainda não consigo fazer com que o Eclipse veja a dependência. Adicionei-o manualmente à seção do pom e ele aparece bem na lista Dependências no m2eclipse. O mvn compile e o mvn package são bem-sucedidos, mas a execução do programa resulta em:

Exception in thread "main" java.lang.Error: Unresolved compilation problems:
        LibraryStuff cannot be resolved to a type

Isso ocorre depois de editar o POM como:

<dependency>
  <groupId>stuff</groupId>
  <artifactId>library</artifactId>
  <version>1.0</version>
  <systemPath>${lib.location}/MyLibrary.jar</systemPath>
  <scope>system</scope>
</dependency>

Devo estar executando o mvn install: install-file, mesmo que eu já tenha o pom.xml editado como acima?

Obrigado!

Respostas:


67

Eu acho que você deve usar mvn install:install-filepara preencher o seu repositório local com os jars da biblioteca, então você deve alterar o escopo do sistema para compilar.

Se você está começando com o maven, sugiro usar o maven diretamente, não os plugins IDE, pois ele adiciona uma camada extra de complexidade.

Quanto ao erro, você coloca os jars necessários em seu caminho de classe? Se você estiver usando tipos da biblioteca, também precisará ter acesso a ele no tempo de execução. Isso não tem nada a ver com o próprio maven.

Eu não entendo por que você deseja colocar a biblioteca no controle de origem - é para código-fonte e não para binário.


36
para mais informações mvn install::install-file: mkyong.com/maven/…
Doug T.

7
Usar mvn install::install-fileem seu repositório local significaria que qualquer pessoa que clonasse seu código-fonte também teria que executar esta etapa do manual. Caso contrário, a compilação será quebrada
imediatamente

que não adicionará o jar ao arquivo de guerra.
Prachi

207

Você pode criar um repositório no projeto, para não precisar run mvn install:install-filetoda vez que trabalhar em um novo computador

<repository>
    <id>in-project</id>
    <name>In Project Repo</name>
    <url>file://${project.basedir}/libs</url>
</repository>

<dependency>
    <groupId>dropbox</groupId>
    <artifactId>dropbox-sdk</artifactId>
    <version>1.3.1</version>
</dependency>

/groupId/artifactId/version/artifactId-verion.jar

detalhes leia esta postagem do blog

https://web.archive.org/web/20121026021311/charlie.cu.cc/2012/06/how-add-external-libraries-maven


2
O uso da solução acima mostrou um aviso ao executar "mvn clean package" - O POM do projeto <nome da dependência> está ausente, sem informações de dependência disponíveis.
Jignesh Gohel

Essa é a melhor solução para os casos em que você precisa adicionar um ou apenas alguns arquivos jar. Obrigado.
Antonio Sesto

2
Ou você pode adicionar dependências locais diretamente como em stackoverflow.com/a/22300875/640378
mauryat

2
Eu tive que usar file: /// $ {project.basedir} / libs (3 barras encaminhadas) em vez de file: // $ {project.basedir} / libs
Loc Phan

2
Se o jar que está sendo instalado não for um jar compilado, você também precisará adicionar um novo arquivo pom para definir os metadados. Para salvar todos esses problemas manuais, eu recomendaria usar mvn install:install-filee copiar toda a estrutura de diretórios do repositório local para o repositório no projeto.
Isen Ng

33

Isso pode ser facilmente alcançado usando o elemento <scope> aninhado dentro do elemento <dependency>.

Por exemplo:

 <dependencies>
   <dependency>
     <groupId>ldapjdk</groupId>
     <artifactId>ldapjdk</artifactId>
     <scope>system</scope>
     <version>1.0</version>
     <systemPath>${basedir}\src\lib\ldapjdk.jar</systemPath>
   </dependency>
 </dependencies>

Referência: http://www.tutorialspoint.com/maven/maven_external_dependencies.htm


Esse método funciona muito bem quando você possui apenas o Eclipse Embedded Maven e não possui o plug-in de instalação (sistema offline), portanto, não é possível executar a installmeta no projeto dependente. Ofc com um sistema de airgapped e todos os plugins, exceto o plug-in de instalação, é uma situação bastante rara.
Cardin Lee JH

1
Mais limpo e fácil.
Ajay Kumar

como adicionar o caminho de dependência local que está fora da pasta $ {project.basedir}, como eu quero o caminho do $ {basedir} \ src \ lib \ ldapjdk.jar 1 nível acima em outra pasta
Naveen Kumar

Estou recebendo erro -"The POM for … is missing, no dependency information available” even though it exists in Maven Repository
garg10may 17/06

28

O manual do Maven diz para fazer isso:

mvn install:install-file -Dfile=non-maven-proj.jar -DgroupId=some.group -DartifactId=non-maven-proj -Dversion=1 -Dpackaging=jar

4
Este comando instala a lib em seu repositório maven. A desvantagem disso é que, se você tentar trabalhar em um projeto em um computador diferente, precisará executá-lo novamente.
Charlie Wu

25

update Desde então, instalamos nosso próprio servidor Nexus, muito mais fácil e limpo.

Em nossa empresa, tínhamos alguns frascos que eram comuns, mas não estavam hospedados em nenhum repositório maven, nem queríamos tê-los no armazenamento local. Criamos um repositório mvn (público) muito simples no Github (mas você pode hospedá-lo em qualquer servidor ou localmente):
observe que isso é ideal apenas para gerenciar alguns arquivos jar raramente perseguindo

  1. Crie um repositório no GitHub:
    https://github.com/<user_name>/mvn-repo/

  2. Adicionar repositório no pom.xml
    (observe que o arquivo bruto do caminho completo será um pouco diferente do nome do repositório )

    <repository>
        <id>project-common</id>
        <name>Project Common</name>
        <url>https://github.com/<user_name>/mvn-repo/raw/master/</url>
    </repository>
  3. Adicionar dependência ao host (Github ou servidor privado)
    a. Tudo que você precisa saber é que os arquivos são armazenados no padrão mencionado por @glitch
    /groupId/artifactId/version/artifactId-version.jar
    b. No seu host, crie as pastas para corresponder a esse padrão.
    ou seja, se você tiver um arquivo jar nomeado service-sdk-0.0.1.jar, crie a pasta service-sdk/service-sdk/0.0.1/e coloque o arquivo jar service-sdk-0.0.1.jarnela.
    c. Teste-o tentando baixar o jar de um navegador (no nosso caso:https://github.com/<user_name>/mvn-repo/raw/master/service-sdk/service-sdk/0.0.1/service-sdk-0.0.1.jar

  4. Adicione dependência ao seu arquivo pom.xml:

    <dependency>
        <groupId>service-sdk</groupId>
        <artifactId>service-sdk</artifactId>
        <version>0.0.1</version>
    </dependency>
  5. Aproveitar


bom, que é a solução mais escalável que eu encontrei, graças
Charlie Wu

11

Não use systemPath. Ao contrário do que as pessoas disseram aqui, você pode colocar um jar externo em uma pasta no diretório do projeto com check-out e para que o Maven o encontre como outras dependências. Aqui estão duas etapas cruciais:

  1. Use "mvn install: install-file" com -DlocalRepositoryPath.
  2. Configure um repositório para apontar para esse caminho no seu POM.

É bastante simples e você pode encontrar um exemplo passo a passo aqui: http://randomizedsort.blogspot.com/2011/10/configuring-maven-to-use-local-library.html


8

Maven maneira de adicionar frascos não maven para projeto maven

Projeto Maven e frascos não maven

Adicione os plugins de instalação do maven na sua seção de compilação

<plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-install-plugin</artifactId>
        <version>${version.maven-install-plugin}</version>
        <executions>

            <execution>
                <id>install-external-non-maven1-jar</id>
                <phase>clean</phase>
                <configuration>
                    <repositoryLayout>default</repositoryLayout>
                    <groupId>jar1.group</groupId>
                    <artifactId>non-maven1</artifactId>
                    <version>${version.non-maven1}</version>
                    <file>${project.basedir}/libs/non-maven1.jar</file>
                    <packaging>jar</packaging>
                    <generatePom>true</generatePom>
                </configuration>
                <goals>
                    <goal>install-file</goal>
                </goals>
            </execution>
            <execution>
                <id>install-external-non-maven2-jar</id>
                <phase>clean</phase>
                <configuration>
                    <repositoryLayout>default</repositoryLayout>
                    <groupId>jar2.group</groupId>
                    <artifactId>non-maven2</artifactId>
                    <version>${version.non-maven2}</version>
                    <file>${project.basedir}/libs/non-maven2.jar</file>
                    <packaging>jar</packaging>
                    <generatePom>true</generatePom>
                </configuration>
                <goals>
                    <goal>install-file</goal>
                </goals>
            </execution>
            <execution>
                <id>install-external-non-maven3-jar</id>
                <phase>clean</phase>
                <configuration>
                    <repositoryLayout>default</repositoryLayout>
                    <groupId>jar3.group</groupId>
                    <artifactId>non-maven3</artifactId>
                    <version>${version.non-maven3}</version>
                    <file>${project.basedir}/libs/non-maven3.jar</file>
                    <packaging>jar</packaging>
                    <generatePom>true</generatePom>
                </configuration>
                <goals>
                    <goal>install-file</goal>
                </goals>
            </execution>
        </executions>
    </plugin>

Adicione a dependência

<dependencies>
    <dependency>
        <groupId>jar1.group</groupId>
        <artifactId>non-maven1</artifactId>
        <version>${version.non-maven1}</version>
    </dependency>
    <dependency>
        <groupId>jar2.group</groupId>
        <artifactId>non-maven2</artifactId>
        <version>${version.non-maven2}</version>
    </dependency>
    <dependency>
        <groupId>jar3.group</groupId>
        <artifactId>non-maven3</artifactId>
        <version>${version.non-maven3}</version>
    </dependency>
</dependencies>

Referências Nota Eu sou o proprietário do blog


Como você conhece as versões dos jars e do plug-in de instalação do maven?
OSK

as versões dos frascos são apenas compostas, as versões do plug-in de instalação do maven são as mais recentes
craftsmannadeem

7

Se você encontrar o mesmo problema e estiver usando o spring-boot v1.4 + , poderá fazê-lo dessa maneira.

Existe um includeSystemScope que você pode usar para adicionar dependências de escopo do sistema ao jar.

por exemplo

Estou usando o driver oracle no meu projeto.

<dependency>
        <groupId>com.oracle</groupId>
        <artifactId>ojdbc14</artifactId>
        <version>10.2.0.3.0</version>
        <scope>system</scope>
        <systemPath>${project.basedir}/src/main/resources/extra-jars/ojdbc14-10.2.0.3.0.jar</systemPath>
    </dependency>

então faça includeSystemScope = true para incluir o jar no caminho / BOOT-INF / lib / **

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <configuration>
        <includeSystemScope>true</includeSystemScope>
    </configuration>
</plugin>

e excluir do recurso para evitar a inclusão duplicada, o frasco é bastante gordo ~

<build>
    <testSourceDirectory>src/test/java</testSourceDirectory>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <excludes>
                <exclude>**/*.jar</exclude>
            </excludes>
        </resource>
    </resources>
</build>

Boa sorte!


Eu estava procurando por uma solução como esta, simplesmente porque quando um novo desenvolvedor chega, isso simplifica o procedimento de instalação. Quando você não possui um servidor artefato, é muito mais fácil ter a dependência personalizada em seu projeto. Além disso, quando você usa um IC, essa solução evita instalar manualmente o jar no servidor de CI.
Dalc 16/09/19

Que tal vários frascos ??
mithun_ghose 6/06

4

Mude o seu systemPath .

<dependency>
  <groupId>stuff</groupId>
  <artifactId>library</artifactId>
  <version>1.0</version>
  <systemPath>${project.basedir}/MyLibrary.jar</systemPath>
  <scope>system</scope>
</dependency>

3

O pom.xml examinará seu repositório local para tentar encontrar a dependência que corresponde ao seu artefato. Além disso, você realmente não deveria estar usando o escopo do sistema ou os atributos systemPath, eles normalmente são reservados para itens que estão no JDK e não no JRE

Consulte esta pergunta para saber como instalar artefatos maven.


3

Observe que todo o exemplo que usa

<repository>...</respository> 

requer externa

<repositories>...</repositories> 

etiquetas anexas. Não está claro em alguns exemplos.


2

A melhor solução aqui é instalar um repositório: Nexus ou Artifactory. Se lhe der um lugar para colocar coisas assim, e ainda mais, as coisas serão armazenadas em cache do lado de fora.

Se a coisa com a qual você está lidando é de código aberto, considere a possibilidade de incluir o central.

Veja o guia .


1

Com o Eclipse Oxygen, você pode fazer o seguinte:

  1. Coloque suas bibliotecas em WEB-INF / lib
  2. Projeto -> Configurar caminho de construção -> Adicionar biblioteca -> Biblioteca de aplicativos da Web

O Maven irá levá-los ao instalar o projeto.


3
Em caso afirmativo, outros usuários que puxam meu projeto precisam fazer o mesmo no Eclipse?
cruxi

0

Se o jar externo for criado apenas por um projeto Maven, você poderá copiar todo o projeto em seu sistema e executar um

mvn install

no diretório do projeto. Isso adicionará o jar ao diretório .m2, que é o repositório maven local.

Agora você pode adicionar o

<dependency>
     <groupId>copy-from-the=maven-pom-of-existing-project</groupId>
     <artifactId>copy-from-the=maven-pom-of-existing-project</artifactId>
     <version>copy-from-the=maven-pom-of-existing-project</version>
</dependency>

Isso garantirá que você

mvn exec:java 

trabalho. Se você usar sugerido aqui

<scope>system</scope>

Então você terá que adicionar classes individualmente enquanto estiver executando através da linha de comando.

Você pode adicionar os frascos externos pelo seguinte comando descrito aqui

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

0

A maneira mais eficiente e limpa de encontrar esse problema é usando os Pacotes do Github

  1. Crie um repositório público / privado vazio e simples no GitHub, conforme sua necessidade, se você deseja que seu jar externo seja hospedado publicamente ou não.

  2. Execute o comando maven abaixo para implantar seu jar externo no repositório github criado acima

    mvn deploy:deploy-file \ -DgroupId= your-group-id \ -DartifactId= your-artifact-id \ -Dversion= 1.0.0 -Dpackaging= jar -Dfile= path-to-file \ -DrepositoryId= id-to-map-on-server-section-of-settings.xml \ -Durl=https://maven.pkg.github.com/github-username/github-reponame-created-in-above-step

    O comando acima irá implantar seu jar externo no repositório do GitHub mencionado em -Durl=. Você pode consultar este link em Como implantar dependências como pacotes do GitHub Tutorial de implantação de pacotes do GitHub

  3. Depois que você pode adicionar a dependência usando groupId, artifactIde versionmencionado na etapa anterior em maven pom.xmle corrermvn install

  4. O Maven buscará a dependência do jar externo no registro de pacotes do GitHub e fornecerá em seu projeto maven.

  5. Para que isso funcione, você também precisará configurar o maven settings.xmlpara buscar no registro do pacote GitHub.

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.