Kann Maven ausführbare JARs mit unterschiedlichen Konfigurationen zusammenstellen?

Question

Ich habe ein Projekt mit der folgenden konzeptionellen Struktur:

-- Core project: Contains the main() function 
---- Feature A 
---- Feature B 
---- Feature C 
---- etc. 

ich nach einem Weg suchen folgendes zu sagen maven:

mvn package core--with--featureA--and--featureC

Dieses Beispiel würde aus einer ausführbaren JAR-Datei erstellen Start die main des Kerns, und Eigenschaften A und C auch verpackt/zusammengebaut, aber nicht Merkmal B und andere.

Während die JAR gestartet werden, wissen die main Methode der Lage sein sollte, welche Funktionen sie installiert sind und Bootstrap alle, für zB .:

main() { 
    for(Runnable featureStarter : FeatureList.getFeatures()) { // Gets all features assembled by maven, which are now present in runtime 
    featureStarter.run(); // Starts each feature 
    } 
} 

oder ein rustikales/hartcodiert Beispiel (weniger bevorzugt):

main() { 
    if(isInstalled("FeatureA")) 
    FeatureA.start(); 

    if(isInstalled("FeatureB")) 
    FeatureB.start(); 

    if(isInstalled("FeatureC")) 
    FeatureC.start(); 

} 

Ist das irgendwie möglich?

Danke!

Answer 1

Maven hat Projekte und dann Module..so können Sie 2 Release-Module erstellen, die vom Basisprojekt abhängen. Sie können ein anderes Glas freigeben.

Das folgende Modul enthält nur Konfigurationsdateien in seiner Quelle. Es baut die App auf der Grundlage von Abhängigkeiten auf. Es extrahiert auch andere Eigenschaften aus diesen Abhängigkeiten, die in seinem Build verwendet werden.

Das Problem, das Sie damit haben, ist, dass Sie Reflexion verwenden müssen, um Build-Probleme in Ihrer Haupt-App zu vermeiden. dh es wird nicht kompiliert, wenn es eine Aufnahme nicht auflösen kann.

Ie FeatureA.start()

public void Start(){ 
try { 
      clazz = Class.forName("org.group.ComponentA"); 
     } catch (ClassNotFoundException e) { 
      if (fallbackOk) { 
       clazz = Class.forName("org.group.Component"); 
      } else { 
       throw e; 
      } 
     } 

} 

POM unter

<?xml version="1.0" encoding="UTF-8"?> 
<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/xsd/maven-4.0.0.xsd"> 
    <parent> 
     <artifactId>parent-artifact</artifactId> 
     <groupId>com.group</groupId> 
     <version>1.9</version> 
    </parent> 
    <modelVersion>4.0.0</modelVersion> 

    <artifactId>child-artifact</artifactId> 
    <packaging>war</packaging> 

    <name>Child Jar</name> 
    <build> 
     <finalName>Child</finalName> 
     <resources> 
      <resource> 
       <directory>${basedir}/src/conf/log4j</directory> 
       <includes> 
        <include>log4j.properties</include> 
       </includes> 
      </resource> 
      <resource> 
       <directory>${basedir}/src/conf/hibernate</directory> 
       <includes> 
        <include>hibernate.properties</include> 
       </includes> 
       <filtering>true</filtering> 
      </resource> 
     </resources> 
     <plugins> 
      <plugin> 
       <!-- extracts the messages*.properties files from to a staging area --> 
       <groupId>org.apache.maven.plugins</groupId> 
       <artifactId>maven-dependency-plugin</artifactId> 
       <executions> 
        <execution> 
         <id>unpack</id> 
         <phase>generate-sources</phase> 
         <goals> 
          <goal>unpack</goal> 
         </goals> 
         <configuration> 
          <artifactItems> 
           <artifactItem> 
            <groupId>com.group</groupId> 
            <artifactId>componentA</artifactId> 
            <version>${project.version}</version> 
            <type>jar</type> 
            <overWrite>false</overWrite> 
            <outputDirectory>${project.build.directory}/localisation</outputDirectory> 
            <includes>**/messages*.properties</includes> 
           </artifactItem> 
           <artifactItem> 
            <groupId>com.group</groupId> 
            <artifactId>componentB</artifactId> 
            <version>${project.version}</version> 
            <type>war</type> 
            <overWrite>false</overWrite> 
            <outputDirectory>${project.build.directory}/webapp/webstart</outputDirectory> 
           </artifactItem> 
          </artifactItems> 
         </configuration> 
        </execution> 
       </executions> 
      </plugin> 
      <plugin> 
       <!-- copies the messages*.properties files to classes/localisation --> 
       <groupId>org.apache.maven.plugins</groupId> 
       <artifactId>maven-resources-plugin</artifactId> 
       <executions> 
        <execution> 
         <id>unpack</id> 
         <phase>generate-resources</phase> 
         <goals> 
          <goal>copy-resources</goal> 
         </goals> 
         <configuration> 
          <outputDirectory>${basedir}/target/classes/localisation</outputDirectory> 
          <resources> 
           <resource> 
            <directory>${basedir}/target/localisation/org/group/web/resource/localisation/ 
            </directory> 
           </resource> 
          </resources> 
         </configuration> 
        </execution> 
        <execution> 
         <!-- copy webapp for tomcat plugin --> 
         <id>webapp</id> 
         <phase>generate-resources</phase> 
         <goals> 
          <goal>copy-resources</goal> 
         </goals> 
         <configuration> 
          <outputDirectory>${basedir}/target/webapp</outputDirectory> 
          <resources> 
           <resource> 
            <directory>${basedir}/src/webapp/</directory> 
           </resource> 
          </resources> 
         </configuration> 
        </execution> 
       </executions> 
      </plugin> 
      <plugin> 
       <artifactId>maven-war-plugin</artifactId> 
       <configuration> 
        <warSourceDirectory> 
         ${basedir}/src/webapp 
        </warSourceDirectory> 
        <archive> 
         <addMavenDescriptor>false</addMavenDescriptor> 
        </archive> 
        <overlays> 
         <overlay> 
          <groupId>org.group</groupId> 
          <artifactId>componentC</artifactId> 
          <targetPath>webstart</targetPath> 
         </overlay> 
        </overlays> 
       </configuration> 
      </plugin> 
      <plugin> 
       <artifactId>maven-source-plugin</artifactId> 
      </plugin> 
      <plugin> 
       <groupId>org.apache.tomcat.maven</groupId> 
       <artifactId>tomcat6-maven-plugin</artifactId> 
       <version>2.2</version> 
       <configuration> 
        <server>app-tomcat</server> 
        <!--port>${maven.tomcat.port}</port--> 
        <path>/${project.build.finalName}</path> 
        <warSourceDirectory>${basedir}/target/webapp</warSourceDirectory> 
       </configuration> 
       <dependencies> 
        <dependency> 
         <groupId>${jdbc.groupId}</groupId> 
         <artifactId>${jdbc.artifactId}</artifactId> 
         <version>${jdbc.version}</version> 
        </dependency> 
       </dependencies> 
      </plugin> 
      <plugin> 
       <groupId>org.apache.tomcat.maven</groupId> 
       <artifactId>tomcat7-maven-plugin</artifactId> 
       <version>2.2</version> 
       <configuration> 
        <server>app-tomcat</server> 
        <!--port>${maven.tomcat.port}</port--> 
        <path>/${project.build.finalName}</path> 
        <warSourceDirectory>${basedir}/target/webapp</warSourceDirectory> 
       </configuration> 
       <dependencies> 
        <dependency> 
         <groupId>${jdbc.groupId}</groupId> 
         <artifactId>${jdbc.artifactId}</artifactId> 
         <version>${jdbc.version}</version> 
        </dependency> 
       </dependencies> 
      </plugin> 
     </plugins> 
    </build> 
    <repositories> 
     <repository> 
      <!-- for jetty plugin dependencies --> 
      <id>java.net</id> 
      <url>http://download.java.net/maven/2/</url> 
      <snapshots> 
       <enabled>false</enabled> 
       <checksumPolicy>fail</checksumPolicy> 
       <updatePolicy>never</updatePolicy> 
      </snapshots> 
     </repository> 
    </repositories> 
    <dependencies> 
     <dependency> 
      <groupId>org.group</groupId> 
      <artifactId>componentA</artifactId> 
     </dependency> 
     <dependency> 
      <groupId>org.group</groupId> 
      <artifactId>componentB</artifactId> 
     </dependency> 
    </dependencies> 

    <properties> 
    </properties> 

</project> 

Answer 2

Ist es möglich, für Maven Montage ausführbare JAR-Dateien mit unterschiedlichen Konfigurationen?

Ja ist es. Eine relativ einfache Möglichkeit, dies zu tun ist durch maven-assembly-plugin

Verwendung Während die JAR gestartet wird, sollte das Hauptverfahren in der Lage sein, zu wissen, welche Funktionen

installiert Das hat nichts mit Maven zu tun. Es scheint, dass Sie versuchen, Ihr eigenes Modulsystem zu bauen. Es ist zwar nicht unbedingt falsch ist, dies zu tun, können Sie eine vorhandenen Lösungen zu prüfen, dass das schon tun:

• Java service loader kann ein Weg sein, dass zu nähern (in relativ einfachen Fällen).
• OSGi ist de facto Standard für modulare Java-Anwendungen.Ich weiß, eine Menge Leute werden argumentieren (wegen veraltetes Wissen vielleicht) es ist zu schwer/komplex, aber das ist wirklich nicht mehr der Fall. Wenn Sie diesen Weg gehen und von der Leistungsfähigkeit echter Modularität profitieren möchten, können Sie diese base tutorial überprüfen, die eine Multi-Modul-Anwendung enthält. Das Beispiel verwendet bndtools, aber Sie könnten the same with Maven tun.

Answer 3

Warum es kompliziert machen, wenn Sie es einfacher machen können!

Pom Kernprojekt:

<profile> 
      <id>active-Feature-A</id> 
     ... 
     ...    
</profile>   

<profile> 
      <id>active-Feature-B</id> 
     ... 
     ...    
</profile> 

<profile> 
      <id>active-Feature-C</id> 
     ... 
     ...    
</profile> 

Dann:

mvn package -Pactive-Feature-A,active-Feature-B