zmusza Maven do kopiowania zależności do target / lib

Jak mogę skopiować zależności środowiska wykonawczego mojego projektu do target/libfolderu?

Tak jak jest teraz, po mvn clean installtym, jak targetfolder zawiera tylko słoik mojego projektu, ale nie ma żadnych zależności w czasie wykonywania.

To działa dla mnie:

<project>
  ...
  <profiles>
    <profile>
      <id>qa</id>
      <build>
        <plugins>
          <plugin>
            <artifactId>maven-dependency-plugin</artifactId>
            <executions>
              <execution>
                <phase>install</phase>
                <goals>
                  <goal>copy-dependencies</goal>
                </goals>
                <configuration>
                  <outputDirectory>${project.build.directory}/lib</outputDirectory>
                </configuration>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>
</project>

Najlepsze podejście zależy od tego, co chcesz zrobić:

• Jeśli chcesz połączyć swoje zależności w plik WAR lub EAR, po prostu ustaw typ opakowania swojego projektu na EAR lub WAR. Maven umieści zależności w odpowiedniej lokalizacji.
• Jeśli chcesz utworzyć plik JAR zawierający kod wraz ze wszystkimi zależnościami, użyj wtyczki asemblera z deskryptorem jar-with-dependencies . Maven wygeneruje pełny plik JAR ze wszystkimi twoimi klasami oraz klasami z dowolnych zależności.
• Jeśli chcesz po prostu interaktywnie wciągnąć swoje zależności do katalogu docelowego, użyj wtyczki zależności do skopiowania plików.
• Jeśli chcesz pobrać zależności dla innego rodzaju przetwarzania, prawdopodobnie będziesz musiał wygenerować własną wtyczkę. Istnieją interfejsy API umożliwiające uzyskanie listy zależności i ich lokalizacji na dysku. Będziesz musiał wziąć to stąd ...

mvn install dependency:copy-dependencies 

Działa dla mnie z katalogiem zależności utworzonym w folderze docelowym. Lubię to!

Spójrz na wtyczkę zależności Maven , a konkretnie na cel dependence: copy-dependencies . Spójrz na przykład pod nagłówkiem Zależność: kopiowanie zależności mojo . Ustaw właściwość konfiguracyjną outputDirectory na $ {basedir} / target / lib (uważam, że będziesz musiał przetestować).

Mam nadzieję że to pomoże.

Proste i eleganckie rozwiązanie w przypadku, gdy trzeba skopiować zależności do katalogu docelowego bez użycia innych faz maven (uważam to za bardzo przydatne podczas pracy z Vaadin).

Kompletny przykład pom:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>
    <groupId>groupId</groupId>
    <artifactId>artifactId</artifactId>
    <version>1.0</version>

    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.1.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-dependency-plugin</artifactId>
                    <executions>
                        <execution>
                            <phase>process-sources</phase>

                            <goals>
                                <goal>copy-dependencies</goal>
                            </goals>

                            <configuration>
                                <outputDirectory>${targetdirectory}</outputDirectory>
                            </configuration>
                        </execution>
                    </executions>
            </plugin>
        </plugins>
    </build>
</project>

Następnie uruchomić mvn process-sources

Zależności pliku jar można znaleźć w /target/dependency

Jeśli chcesz to robić od czasu do czasu (a tym samym nie chcesz zmieniać POM), wypróbuj ten wiersz polecenia:

Zależność mvn: zależność kopiowania -DoutputDirectory = $ {project.build.directory} / lib

Pominięcie ostatniego argumentu powoduje umieszczenie zależności target/dependencies.

Wypróbuj coś takiego:

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>2.4</version>
<configuration>
    <archive>
        <manifest>  
            <addClasspath>true</addClasspath>
            <classpathPrefix>lib/</classpathPrefix>
            <mainClass>MainClass</mainClass>
        </manifest>
    </archive>
    </configuration>
</plugin>
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <version>2.4</version>
    <executions>
        <execution>
            <id>copy</id>
            <phase>install</phase>
            <goals>
                <goal>copy-dependencies</goal>
            </goals>
            <configuration>
                <outputDirectory>
                    ${project.build.directory}/lib
                </outputDirectory>
            </configuration>
        </execution>
    </executions>
</plugin>

Wszystko czego potrzebujesz to następujący fragment kodu w pliku pom.xml build/plugins:

<plugin>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
        <execution>
            <phase>prepare-package</phase>
            <goals>
                <goal>copy-dependencies</goal>
            </goals>
            <configuration>
                <outputDirectory>${project.build.directory}/lib</outputDirectory>
            </configuration>
        </execution>
    </executions>
</plugin>

Powyższe będzie działać w packagefazie po uruchomieniu

mvn clean package

Zależności zostaną skopiowane do katalogu outputDirectory określonego we fragmencie, tj. libW tym przypadku.

Jeśli chcesz to robić tylko od czasu do czasu, nie są wymagane żadne zmiany w pliku pom.xml. Po prostu uruchom następujące polecenie:

mvn clean package dependency:copy-dependencies

Aby zastąpić domyślną lokalizację, czyli ${project.build.directory}/dependenciesdodaj właściwość System o nazwie outputDirectory, tj

    -DoutputDirectory=${project.build.directory}/lib

jeżeli

• nie chcesz zmieniać pliku pom.xml
• nie chcesz mieć zasięgu testu (np. junit.jar) ani podanych zależności (np. wlfullclient.jar)

oto, co dla mnie zadziałało:

Zależność instalacji mvn: zależność kopiowania -DincludeScope = środowisko wykonawcze -DoutputDirectory = cel / lib

Jeśli chcesz dostarczyć pakiet słoika aplikacji wraz ze wszystkimi jego zależnościami i niektórymi skryptami wywołującymi MainClass, spójrz na wtyczkę appassembler-maven-plugin .

Poniższa konfiguracja wygeneruje skrypty dla systemu Windows i Linux w celu uruchomienia aplikacji (z wygenerowaną ścieżką odwołującą się do wszystkich słoików zależności, pobierz wszystkie zależności (do folderu lib poniżej elementu docelowego / appassembler). Następnie można użyć wtyczki asemblera do spakowania całego katalog appassembler do pliku zip, który jest instalowany / wdrażany wraz ze słoikiem do repozytorium.

  <plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>appassembler-maven-plugin</artifactId>
    <version>1.0</version>
    <executions>
      <execution>
        <id>generate-jsw-scripts</id>
        <phase>package</phase>
        <goals>
          <goal>generate-daemons</goal>
        </goals>
        <configuration>
          <!--declare the JSW config -->
          <daemons>
            <daemon>
              <id>myApp</id>
              <mainClass>name.seller.rich.MyMainClass</mainClass>
              <commandLineArguments>
                <commandLineArgument>start</commandLineArgument>
              </commandLineArguments>
              <platforms>
                <platform>jsw</platform>
              </platforms>              
            </daemon>
          </daemons>
          <target>${project.build.directory}/appassembler</target>
        </configuration>
      </execution>
      <execution>
        <id>assemble-standalone</id>
        <phase>integration-test</phase>
        <goals>
          <goal>assemble</goal>
        </goals>
        <configuration>
          <programs>
            <program>
              <mainClass>name.seller.rich.MyMainClass</mainClass>
              <!-- the name of the bat/sh files to be generated -->
              <name>mymain</name>
            </program>
          </programs>
          <platforms>
            <platform>windows</platform>
            <platform>unix</platform>
          </platforms>
          <repositoryLayout>flat</repositoryLayout>
          <repositoryName>lib</repositoryName>
        </configuration>
      </execution>
    </executions>
  </plugin>
  <plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.2-beta-4</version>
    <executions>
      <execution>
        <phase>integration-test</phase>
        <goals>
          <goal>single</goal>
        </goals>
        <configuration>
          <descriptors>
            <descriptor>src/main/assembly/archive.xml</descriptor>
          </descriptors>
        </configuration>
      </execution>
    </executions>
  </plugin> 

Deskryptorem zestawu (w src / main / assembly) do spakowania direcotry jako zip byłby:

<assembly>
  <id>archive</id>
  <formats>
    <format>zip</format>
  </formats>
  <fileSets>
    <fileSet>
     <directory>${project.build.directory}/appassembler</directory>
     <outputDirectory>/</outputDirectory>
    </fileSet>
  </fileSets>
</assembly>

Jeśli sprawisz, że projekt będzie typem wojny lub ucha, skopiuje zależności.

Możesz użyć wtyczki Shade, aby utworzyć słoik Uber, w którym możesz spakować wszystkie swoje zależności zewnętrzne.

Wystarczy przeliterować to, co już zostało powiedziane w skrócie. Chciałem utworzyć wykonywalny plik JAR, który zawierał moje zależności wraz z moim kodem. To działało dla mnie:

(1) W pom, pod <build> <wtyczki>, zawarłem:

<plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.2-beta-5</version>
    <configuration>
        <archive>
            <manifest>
                <mainClass>dk.certifikat.oces2.some.package.MyMainClass</mainClass>
            </manifest>
        </archive>
        <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
    </configuration>
</plugin>

(2) Uruchamianie zestawu kompilacji mvn: zestaw utworzył pożądany plik my-project-0.1-SNAPSHOT-jar-with-dependencies.jar w katalogu docelowym projektu.

(3) Uruchomiłem JAR z java -jar my-project-0.1-SNAPSHOT-jar-with-dependencies.jar

Jest to ciężkie rozwiązanie do osadzania dużych zależności, ale Maven's Assembly Plugin załatwia sprawę.

@ Odpowiedź bogatego sprzedawcy powinna zadziałać, chociaż w prostszych przypadkach potrzebujesz tylko tego fragmentu przewodnika użytkowania :

<project>
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>2.2.2</version>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Jeśli masz problemy związane z zależnościami, które nie pojawiają się w pliku WEB-INF / lib podczas działania na serwerze Tomcat w Eclipse, spójrz na to:

ClassNotFoundException DispatcherServlet podczas uruchamiania Tomcat (zależności Maven nie zostały skopiowane do wtpwebapps)

Musisz po prostu dodać Zależności Maven we Właściwościach projektu> Zespół wdrożeniowy.