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

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!

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.

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

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

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

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

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

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

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!

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>

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.

Observe que todo o exemplo que usa

<repository>...</respository> 

requer externa

<repositories>...</repositories> 

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

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 .

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.

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>

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.