java 메이븐 - Maven과 jar 파일에 의존성 포함하기




설정 사용법 (12)

위에서 설명한대로 jar-with-dependencies 접근법 같은 (나 같은) 개발자가 아니라면, 필자가 선호하는 빌드 솔루션은 빌드중인 독립형 Java 응용 프로그램이라 할지라도 단순히 WAR 프로젝트를 빌드하는 것입니다.

  1. 정상적인 maven jar-project를 만듭니다. jar-file을 빌드합니다 (의존성없이).

  2. 또한 jar-project가있는 maven war-project (빈 / src / main / webapp / WEB-INF / web.xml 파일 만 사용하여 경고 / 오류가 발생하지 않도록 설정) 의존성을 제거하고, 여러분의 병 프로젝트를 여러분의 전쟁 프로젝트 하에서 <module> 으로 만드십시오. (이 war-project는 모든 jar 파일 종속성을 zip 파일로 래핑하는 간단한 트릭입니다.)

  3. war-project를 생성하여 war-file을 만듭니다.

  4. 배치 단계에서 .war 파일의 이름을 * .zip으로 바꾸고 압축을 풀기 만하면됩니다.

jar 파일과 응용 프로그램을 실행하는 데 필요한 모든 종속 파일을 사용하여 lib 디렉토리 (원하는 위치로 이동할 수 있음)가 있어야합니다.

java -cp 'path/lib/*' MainClass

(classpath의 와일드 카드는 Java-6 이상에서 작동합니다)

제 생각에 이것은 (어셈블리 플러그인으로 뒤죽박죽을 칠 필요가 없으며) 애플리케이션 구조에 대한 명확한 시각을 제공합니다 (모든 종속 항의 버전 번호가 일반보기로 표시됩니다. 모든 것을 단일 jar 파일로 막지 마십시오.)

maven (2.0.9)가 모든 jar 파일을 하나의 jar 파일에 포함하도록 강제하는 방법이 있습니까?

나는 하나의 jar 파일로 빌드 된 프로젝트를 가지고있다. 종속성의 클래스를 jar 파일에도 복사해야합니다.

업데이트 : JAR 파일에 jar 파일을 포함시킬 수 없다는 것을 알고 있습니다. 내가 의존성으로 지정된 항아리를 풀고, 항아리에 클래스 파일을 패키지하는 방법을 찾고있다.


Eclipse Luna 및 m2eclipse에 대한 내 최종 솔루션 : 사용자 정의 클래스 로더 (프로젝트에 5 개의 클래스 만 다운로드하고 추가) : http://git.eclipse.org/c/jdt/eclipse.jdt.ui.git/plain/org.eclipse.jdt.ui/jar%20in%20jar%20loader/org/eclipse/jdt/internal/jarinjarloader/ ; 이 클래스 로더는 one-jar 클래스 로더의 최상이며 매우 빠릅니다.

<project.mainClass>org.eclipse.jdt.internal.jarinjarloader.JarRsrcLoader</project.mainClass> <project.realMainClass>my.Class</project.realMainClass>

JIJConstants의 "Rsrc-Class-Path"에서 "Class-Path"로 편집
mvn clean dependency : 복사 의존성 패키지
씬 클래스 로더가있는 lib 폴더에 종속성이있는 항아리가 만들어집니다.

<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.java</include>
                <include>**/*.properties</include>
            </includes>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
            <includes>
                <include>**/*</include>
            </includes>
            <targetPath>META-INF/</targetPath>
        </resource>
        <resource>
            <directory>${project.build.directory}/dependency/</directory>
            <includes>
                <include>*.jar</include>
            </includes>
            <targetPath>lib/</targetPath>
        </resource>
    </resources>
<pluginManagement>
        <plugins>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <mainClass>${project.mainClass}</mainClass>
                            <classpathPrefix>lib/</classpathPrefix>
                        </manifest>

                        <manifestEntries>
                            <Rsrc-Main-Class>${project.realMainClass}  </Rsrc-Main-Class>
                            <Class-Path>./</Class-Path>
                        </manifestEntries>

                    </archive>
                </configuration>
            </plugin>
<plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </pluginManagement>
</build>

<classifier> 태그를 사용하여 새로 생성 된 jar를 사용할 수 있습니다.

<dependencies>
    <dependency>
        <groupId>your.group.id</groupId>
        <artifactId>your.artifact.id</artifactId>
        <version>1.0</version>
        <type>jar</type>
        <classifier>jar-with-dependencies</classifier>
    </dependency>
</dependencies>

"jar-with-dependencies"설명자가있는 maven-assembly 플러그인을 사용하여이 작업을 수행 할 수 있습니다. 다음은이 작업을 수행하는 pom.xml 중 하나의 관련 청크입니다.

  <build>
    <plugins>
      <!-- any other plugins -->
      <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
        <executions>
          <execution>
            <phase>package</phase>
            <goals>
              <goal>single</goal>
            </goals>
          </execution>
        </executions>
        <configuration>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
        </configuration>
      </plugin>
    </plugins>
  </build>

실행 가능한 jar 파일을 수행하려면 메인 클래스도 설정해야합니다. 따라서 전체 구성이 있어야합니다.

    <plugins>
            <plugin>
                 <artifactId>maven-assembly-plugin</artifactId>
                 <executions>
                     <execution>
                          <phase>package</phase>
                          <goals>
                              <goal>single</goal>
                          </goals>
                      </execution>
                  </executions>
                  <configuration>
                       <!-- ... -->
                       <archive>
                           <manifest>
                                 <mainClass>fully.qualified.MainClass</mainClass>
                           </manifest>
                       </archive>
                       <descriptorRefs>
                           <descriptorRef>jar-with-dependencies</descriptorRef>
                      </descriptorRefs>
                 </configuration>
         </plugin>
   </plugins>

http://fiji.sc/Uber-JAR 는 대안에 대한 훌륭한 설명을 제공합니다.

uber-JAR을 구성하는 세 가지 일반적인 방법은 다음과 같습니다.

  1. 음영이 없습니다. 모든 JAR 파일의 압축을 풀고 단일 JAR 파일로 다시 패키징하십시오.
    • Pro : Java의 기본 클래스 로더와 함께 작동합니다.
    • 단점 : 동일한 경로 (예 : META-INF / services / javax.script.ScriptEngineFactory)를 가진 여러 JAR 파일에있는 파일은 서로 겹쳐 쓰므로 오류가 발생합니다.
    • 도구 : Maven 어셈블리 플러그인, Classworlds Uberjar
  2. 음영 처리. 음영 처리되지 않음과 동일하지만 모든 종속성의 모든 패키지 이름을 바꿉니다 (예 : "shade").
    • Pro : Java의 기본 클래스 로더와 함께 작동합니다. 종속성 버전 충돌 (일부는 아님)을 피하십시오.
    • 단점 : 동일한 경로 (예 : META-INF / services / javax.script.ScriptEngineFactory)를 가진 여러 JAR 파일에있는 파일은 서로 겹쳐 쓰므로 오류가 발생합니다.
    • 도구 : Maven Shade Plugin
  3. JAR의 JAR. 마지막 JAR 파일에는 포함 된 다른 JAR 파일이 들어 있습니다.
    • Pro : 종속성 버전 충돌을 피하십시오. 모든 리소스 파일이 보존됩니다.
    • 단점 : Java가 래핑 된 JAR 파일에서 클래스를로드 할 수 있도록 특별한 "부트 스트랩"클래스 로더를 번들해야합니다. 클래스 로더 문제를 디버깅하는 것은 더욱 복잡해집니다.
    • 도구 : Eclipse JAR 파일 익스포터, One-JAR.

이 답변을보십시오 :

Java JAR 파일로 실행되는 설치 프로그램을 작성 중이며 설치 디렉토리의 적절한 위치에 WAR 및 JAR 파일의 압축을 풀어야합니다. 의존성 플러그인은 패키지 단계에서 복사 목표로 사용될 수 있으며, Maven 저장소 (WAR 파일 포함)에 파일을 다운로드하고 필요할 때마다 쓸 수 있습니다. 나는 출력 디렉토리를 $ {project.build.directory} / classes로 바꾼 다음 정상적인 JAR 작업이 내 파일을 잘 포함한다는 결과를 얻는다. 그런 다음 압축을 풀어 설치 디렉토리에 쓸 수 있습니다.

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<executions>
    <execution>
        <id>getWar</id>
        <phase>package</phase>
        <goals>
            <goal>copy</goal>
        </goals>
        <configuration>
            <artifactItems>
                <artifactItem>
                    <groupId>the.group.I.use</groupId>
                    <artifactId>MyServerServer</artifactId>
                    <version>${env.JAVA_SERVER_REL_VER}</version>
                    <type>war</type>
                    <destFileName>myWar.war</destFileName>
                </artifactItem>
            </artifactItems>
            <outputDirectory>${project.build.directory}/classes</outputDirectory>
        </configuration>
    </execution>
</executions>


메이븐을 제쳐두고 JAR 라이브러리를 메인 JAR 파일에 넣을 수는 있지만 자신 만의 클래스 로더를 사용해야 할 것이다.

이 프로젝트를 확인하십시오 : One-JAR 링크 텍스트


음영 메이븐 플러그인이 있습니다. 의존성을 패키지하고 이름을 변경 하는 데 사용할 수 있습니다 (클래스 경로의 종속성 문제점을 생략).


Maven 2의 경우 올바른 방법은 Maven2 Assembly Plugin 을 사용하는 것입니다. Maven2 Assembly Plugin미리 정의 된 설명자 파일 을 가지고 있으며 명령 줄에서 사용할 수 있습니다.

mvn assembly:assembly -DdescriptorId=jar-with-dependencies

이 jar을 실행 가능하게하려면 플러그인 구성에 실행할 기본 클래스를 추가하십시오.

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-assembly-plugin</artifactId>
  <configuration>
    <archive>
      <manifest>
        <mainClass>my.package.to.my.MainClass</mainClass>
      </manifest>
    </archive>
  </configuration>
</plugin>

일반 빌드 프로세스의 일부로 해당 어셈블리를 만들려면 single 또는 directory-single 목표 ( assembly 목표 만 명령 줄에서 실행해야 함)를 라이프 사이클 단계 ( package 가 의미가 있음)로 바인딩해야합니다 이:

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-assembly-plugin</artifactId>
  <executions>
    <execution>
      <id>create-my-bundle</id>
      <phase>package</phase>
      <goals>
        <goal>single</goal>
      </goals>
      <configuration>
        <descriptorRefs>
          <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
        ...
      </configuration>
    </execution>
  </executions>
</plugin>

필요에 맞게 configuration 요소를 적용하십시오 (예 : 매니페스트 사용법).


        <!-- Method 1 -->
        <!-- Copy dependency libraries jar files to a separated LIB folder -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <configuration>
                <outputDirectory>${project.build.directory}/lib</outputDirectory>
                <excludeTransitive>false</excludeTransitive> 
                <stripVersion>false</stripVersion>
            </configuration>
            <executions>
                <execution>
                    <id>copy-dependencies</id>
                    <phase>package</phase>
                    <goals>
                        <goal>copy-dependencies</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
        <!-- Add LIB folder to classPath -->
        <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>
                    </manifest>
                </archive>
            </configuration>
        </plugin>


        <!-- Method 2 -->
        <!-- Package all libraries classes into one runnable jar -->
        <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <executions>
              <execution>
                <phase>package</phase>
                <goals>
                  <goal>single</goal>
                </goals>
              </execution>
            </executions>
            <configuration>
              <descriptorRefs>
                <descriptorRef>jar-with-dependencies</descriptorRef>
              </descriptorRefs>
            </configuration>
        </plugin>            

이것은 옵션 일 수도 있습니다. jar 파일을 빌드 할 수 있습니다.

<build>
    <plugins>
        <plugin>
            <!-- Build an executable JAR -->
            <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>WordListDriver</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
    </plugins>
</build>






java maven-2 jar packaging