Maven Sources und JavaDocs ins Release-JAR einfügen

Marco13

Top Contributor
Hallo

Wie kann man Maven dazu veranlassen, die während des releasens ausgecheckten sourcen und die erstellten JavaDocs mit in die release-JAR zu packen? Also nicht getrennt nach Sources, Docs und Bins, sondern alles zusammen?

Add-on-Frage für zutiefst von der sinnvollen Verwendbarkeit von Maven überzeugte: Wenn man die Antwort auf obige Frage nicht "zufällig weiß" (weil man das schonmal gemacht hat), wie findet man die Antwort dann systematisch?
 

Wildcard

Top Contributor
Vielleicht geht es einfacher, aber ich hätte es so gemacht:
[XML] <build>
<plugins>
<!-- Zuerst das default-jar deaktivieren -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<executions>
<execution>
<id>default-jar</id>
<phase>none</phase>
<inherited>false</inherited>
</execution>
</executions>
</plugin>

<!-- Danach sicherstellen das javadoc immer gebaut wird bevor das archiv gepackt wird -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-javadoc-plugin</artifactId>
<executions>
<execution>
<id>generate-javadoc</id>
<phase>prepare-package</phase>
<goals>
<goal>javadoc</goal>
</goals>
<inherited>false</inherited>
</execution>
</executions>
</plugin>

<!-- zuletzt das default jar durch ein eigenes assembly ersetzen -->
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
<configuration>
<appendAssemblyId>false</appendAssemblyId>
<descriptors>
<descriptor>src/main/assembly/fatjar.xml</descriptor>
</descriptors>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>[/XML]

Dazu noch ein passendes assembly:
[XML]<assembly
xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
<id>${project.artifact.Id}</id>
<includeBaseDirectory>false</includeBaseDirectory>
<formats>
<format>jar</format>
</formats>
<fileSets>
<fileSet>
<directory>${project.build.outputDirectory}</directory>
<outputDirectory>/</outputDirectory>
</fileSet>
<fileSet>
<directory>${project.build.sourceDirectory}</directory>
<outputDirectory>/source</outputDirectory>
</fileSet>
<fileSet>
<directory>${project.build.directory}/site/apidocs</directory>
<outputDirectory>/javadoc</outputDirectory>
</fileSet>
</fileSets>
</assembly>[/XML]

Es hat allerdings durchaus Vorteile getrennte Archive zu deployen. Bist du dir sicher das du nicht einfach beim Default bleiben und einfach zusätzlich ein Archiv erstellen willst das alles drei enthält?

Add-on-Frage für zutiefst von der sinnvollen Verwendbarkeit von Maven überzeugte: Wenn man die Antwort auf obige Frage nicht "zufällig weiß" (weil man das schonmal gemacht hat), wie findet man die Antwort dann systematisch?
Du musst wissen das Projekte mit Packaging Jar eine vordefinierte Execution des jar plugins mit der id 'default-jar' haben.
Da das jar plugin meines wissens nicht unterstützt Resourcen aus mehreren Verzeichnissen gleichzeitig zu kopieren, muss die default-jar Ausführung deaktiviert werden (phase none).
Mehr Freiheiten beim Archiv bauen gibt dir das assembly Plugin, also verwendest du statt default-jar ein eigenes Assembly um dein Archiv zu beschreiben.
Man kann wohl auch einen eigenen Packaging Type definieren um sich die Konfiguration in der pom zu sparen, aber das ist ehrlich gesagt unerforschtes Land für mich.
 
M

maki

Gast
Add-on-Frage für zutiefst von der sinnvollen Verwendbarkeit von Maven überzeugte: Wenn man die Antwort auf obige Frage nicht "zufällig weiß" (weil man das schonmal gemacht hat), wie findet man die Antwort dann systematisch?
Nun ja, man muss halt wissen was der "maven way" ist.

Maven trennt solche Artifakte eigentlich, wenn man sie dennoch zusammenwerfen will, muss man das Assembly Plugin verwenden wie von Wildcard gezeigt, das assembly plugin ist eigentlich immer gefragt wenn man packaging Anforderungen hat die vom "maven way" so nicht abgedeckt werden bzw. vorgesehen sind.
 

Marco13

Top Contributor
Danke erstmal soweit für die Antworten.

Eigentlich ist mir egal, ob am Source+Doc am Ende mit in der "normalen" JAR sind, oder nochmal eine eigene erstellt wird. Aber vermutlich wäre es besser und "sauberer", wenn man das erstellen der Fat JAR als eigenen Schritt machen und man ihm bei der normalen Erstellung nicht so reinpfuschen würde...?

In bezug auf das "systmatische" Finden der Antwort (und die Antwort an sich), und auch auf die Gefahr hin, dass ich gewisse Gedanken in einer Form zum Ausdruck bringe, für die andere kein Verständnis aufbringen (oder die, plakativ gesagt, als "Maven Bashing" aufgefasst werden - wen das schon nervt, der möge das folgende ignorieren) : Das kann's doch nicht sein :noe: Wenn man für etwas, was man eigentlich auch mit
jar -bla someDirectories fat.jar
erreichen könnte, >80 Zeilen kryptischstes XML schreiben muss, dessen Inhalt (soweit ich das sehe) nicht zielgerichtet und systematisch erschließbar ist, dann läuft da doch irgendwas falsch ???:L

Oder anders: Angenommen man wüßte das mit den Phasen in denen das JAR-Plugin irgendwas macht (auch wenn das nirgendwo wirklich übersichtlich dokumentiert ist, und ein entscheidendes Qualitätskriterium für APIs (neben einer guten Dokumentation) ist, dass man über Interna möglichst wenig wissen muss (und Maven bietet nur eine API, die man mit XML "programmiert"!)), und angenommen man wüßte, wie man diese Funktionalität ausschaltet (mit phase "none" - was irgendwie wie ein Hack aussieht ???:L ), und angenommen, man würde (aufgrund welches Google-Suchergebnisses auch immer) dann auf die Idee kommen, das Assembly-Plugin zu verwenden: Wenn man dann kurz über die Doku zu Assembly scrollt, wird man sicher nicht denken: "Oh, das sieht aber praktisch aus" :noe:

Oder nochmal anders, @Wildcard:
Vielleicht geht es einfacher, aber ich hätte es so gemacht:
Wie findet man heraus, ob es einfacher geht? Vielleicht nicht mit 80 Zeilen in zwei XML-Dateien, sondern mit einem einzelnen, kleinen, zusätzlichen Tag in irgendeinem Plugin wie [c]<packAll>true</packAll>[/c]? Ich hatte zuerst versucht, mit "copy resources" die jeweiligen Dateien an eine Stelle zu kopieren, wo sie von "release plugin" mit eingepackt werden, aber das scheint schwierig zu sein ... vielleicht könnte man es hinkriegen, aber ich habe keine Veranlassung gesehen, dort mehr Zeit zu investieren, weil ich keine Grundlage habe, auf Basis derer ich entscheiden könnte, ob das auch nur ansatzweise ein sinnvoller Weg ist...

Eigentlich wollte ich Maven ja nochmal eine Chance geben, und systematisch anhand einiger kleiner Projekte mit einigen gegenseitigen Abhängigkeiten den Ablauf des Aufbaus eines Maven-Projektes "von der Pike auf" (und unter der Beachtung aller vertretbar erscheinender "Conventions") lernen. Aber ich komme wieder zu dem Schluß, dass das Maven eher ein Golem ist :(
 
M

maki

Gast
In bezug auf das "systmatische" Finden der Antwort (und die Antwort an sich), und auch auf die Gefahr hin, dass ich gewisse Gedanken in einer Form zum Ausdruck bringe, für die andere kein Verständnis aufbringen (oder die, plakativ gesagt, als "Maven Bashing" aufgefasst werden - wen das schon nervt, der möge das folgende ignorieren) : Das kann's doch nicht sein Wenn man für etwas, was man eigentlich auch mit
jar -bla someDirectories fat.jar
erreichen könnte, >80 Zeilen kryptischstes XML schreiben muss, dessen Inhalt (soweit ich das sehe) nicht zielgerichtet und systematisch erschließbar ist, dann läuft da doch irgendwas falsch

Oder anders: Angenommen man wüßte das mit den Phasen in denen das JAR-Plugin irgendwas macht (auch wenn das nirgendwo wirklich übersichtlich dokumentiert ist, und ein entscheidendes Qualitätskriterium für APIs (neben einer guten Dokumentation) ist, dass man über Interna möglichst wenig wissen muss (und Maven bietet nur eine API, die man mit XML "programmiert"!)), und angenommen man wüßte, wie man diese Funktionalität ausschaltet (mit phase "none" - was irgendwie wie ein Hack aussieht ), und angenommen, man würde (aufgrund welches Google-Suchergebnisses auch immer) dann auf die Idee kommen, das Assembly-Plugin zu verwenden: Wenn man dann kurz über die Doku zu Assembly scrollt, wird man sicher nicht denken: "Oh, das sieht aber praktisch aus"
Maven bashing hat in 99,9% der Fälle folgende Ursache: Der "maven way" wird nicht verstanden.

Maven gibt dir viele Dinge vor, auch wie die Artifakte aufgebaut sind, wenn man das weiss, das kann man vermuten, dass die "alles in einer Jar" Anforderung nicht maven konform ist.
Maven hat ein sehr striktes Weltbild von Projekten, Modulen und deren Artifakten.
Maven bietet bereits Mechanismen, JavaDoc, Sourcen etc. als Artifacte zur Verfügung zu stellen, daher ist die Anforderung "alles in einer Jar" als exotisch zu werten ;)
Ein anderer Punkt der oft missverstanden wird: Mit Maven programmiert man keinen Build, sondern man konfiguriert den Build.

Bevor man sich also auf die Suche nach Lösungen zu Problemen macht die man sich selber eingebrokt hat, sollte man die "Maven Gesetze" draufhaben ;)

Sie es mal so: Maven ist auf dem "Weltstandartisierungestrip" und absolut unflexibel, du musst dich anpassen und flexibel sein :)
Maven wird nicht umsonst gerne mit dem Kommunismus verglichen *g*
Jedesmal wenn du eine Konvention umbiegst oder zu umgehen versuchst, kommen Probleme auf dich zu zu, die "Boomerang-Dynamik" eben.

Vorteil: Ein neuer Entwickler braucht in einem Maven Projekt keine Fragen zu stellen wie "wie baut man das?", "wohin kommen meine tests?", "wohin mit meinen ressourcen?", "welche jars brauche ich?", "wie konfiguriere ich meine IDE für das Projekt?" etc. pp.

Plugins muss man nur noch minimal konfigurieren fals überhaupt, ist ja festgelegt wo was zu liegen hat.

Wenn du deine Builds lieber programmieren willst und so sehr flexibel sein möchtest ist Maven nicht das richtige Tool.
 

Marco13

Top Contributor
So ähnlich wurde das schon an anderen Stellen gesagt. Ich glaube auch, "den Maven way" zu verstehen, in dem Sinne, dass man eben alles so machen muss, wie es bei Maven vorgeschrieben ist, sonst kommt man in die Hölle. Aber WIE schnell man bei WIE kleinen Abweichungen in die Hölle kommt, finde ich dann doch befremdlich... :(

Dass du sagst, dass man seinen build nicht programmiert sondern konfiguriert irritiert mich aus zwei Gründen: Erstens "konfiguriert" man bei Maven ja nicht, weil dafür gibt's ja Conventions, an die man sich hält, damit man eben keine Configuration mehr braucht :bae: und zweitens weil ich letzte Nacht (irgendwann zwischen 2:00 und 3:00) unter anderem darüber nachgedacht habe, dass das eigentlich doch ein "programmieren" ist - und es vielleicht einfacher wäre, wenn man das auch antizipieren würde, und als Programmiersprache nicht XML verwenden würde, sondern Java... Ich dachte daran, dass man eine Dependency ja z.B. nicht über
Code:
<dependencies>
    <dependency>
      <groupId>group-a</groupId>
      <artifactId>artifact-a</artifactId>
      <version>1.0</version>
    </dependency>
</dependencies>
konfigurieren müßte, sondern auch in irgendeiner Klasse
Java:
addDependency("group-a", "artifact-a", "1.0");
schreiben könnte, oder das Hinzufügen eines JavaDoc-goals ja nicht über
Code:
           <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-javadoc-plugin</artifactId>
                <executions>
                    <execution>
                        <id>generate-javadoc</id>
                        <phase>prepare-package</phase>
                        <goals>
                            <goal>javadoc</goal>
                        </goals>
                        <inherited>false</inherited>
                    </execution>
                </executions>
            </plugin>
passieren müßte, sondern auch über
Java:
getPhase("prepare-package").addGoal(javadocPlugin.getGoal("javadoc"));
oder sogar compilezeitgeprüft über
Java:
getPreparePackagePhase().addGoal(javadocPlugin.getJavaDocGoal());
passieren könnte. Zumindest fände ich es toll, wenn man das so schreiben könnte (auch wenn dann unter der Haube aus 10 Zeilen Code eine 1000 Zeilen POM generiert werden würde).

Einerseits gehe ich davon aus, dass mich die Plugin-Dokus im Moment auf ähnliche Weise erschlagen, wie einen Java-Anfänger eben die API-Doku erschlägt. Aber falls es irgendeinen Vorteil hat, das ganze händisch und auf Basis von unübsichtlichen Dokus in sehr "verbosen" und fehleranfälligen XML-Dateien zu schreiben, erschließt sich mir das ja vielleicht noch irgendwann...

Nur mal nebenbei, um das besser einschätzen zu können: Ist es die "übliche" Strategie bei Maven, in Google stichwortartig nach dem zu suchen, was man machen will, dann zu hoffen, etwas ähnliches zu finden, und es mit möglichst wenigen Änderungen so umzubiegen, dass es (nachdem man es, mangels anderer Möglichkeiten, das festzustellen, ausprobiert hat) anhand der 20 Seiten build-log zu funktionieren scheint...? ???:L
 
M

maki

Gast
Dass du sagst, dass man seinen build nicht programmiert sondern konfiguriert irritiert mich aus zwei Gründen: Erstens "konfiguriert" man bei Maven ja nicht, weil dafür gibt's ja Conventions, an die man sich hält, damit man eben keine Configuration mehr braucht
Hehe... naja, die Plugins darf man schon konfigurieren ;)
Maven gibt ja für verschiedene Projekte (ja nach packaging type) einen Build Life Cycle vor, da kann man sich einhängen, aber nicht seinen eigenen schreiben auf die schnelle, das ist Absicht.
Für Packagingtypen die einen anderen brauchen, braucht man eben ein Maven plugin, war zB. bei OSGi so, und bei GWT. Interessanterweise sind die unterschiede im Detail zu suchen, aber diese haben enorme Auswirkungen.

Maven - Introduction to the Build Lifecycle

Wenn du deinen build programmieren möchtest, hat bygones bestimmt einen Vorschlag für dich: Gradle
Daran hat mich zumindest dein Pseudocode erinnert ;)

Nur mal nebenbei, um das besser einschätzen zu können: Ist es die "übliche" Strategie bei Maven, in Google stichwortartig nach dem zu suchen, was man machen will, dann zu hoffen, etwas ähnliches zu finden, und es mit möglichst wenigen Änderungen so umzubiegen, dass es (nachdem man es, mangels anderer Möglichkeiten, das festzustellen, ausprobiert hat) anhand der 20 Seiten build-log zu funktionieren scheint...?
Ja, so ungefähr ist das, übrigens hab ich früher meine Dependencies nur so gefunden, einfach nach "repo1 maven LIB_NAME" gesucht.
Wenn man allerdings den Maven way nicht so gut kennt, sucht man u.U. nach dingen, die es nicht geben sollte.

Eine Sache die Maven aber für alle besser gemacht hatte: Ein "Standard" Repository Layout für Dependencies, davon profitieren einige Build tools, auch solche, die extra wegen Maven und seiner inflexibilität erfunden wurden ;)

Nachtrag:
bygones Post bez. Gradle: http://www.java-forum.org/ides-tools/85293-maven-vs-gradle.html#post533996
 
Zuletzt bearbeitet von einem Moderator:

kama

Top Contributor
Hallo,

Wenn du deinen build programmieren möchtest, hat bygones bestimmt einen Vorschlag für dich: Gradle
Daran hat mich zumindest dein Pseudocode erinnert ;)
Sieht Gradle sehr ähnlich...


Ja, so ungefähr ist das, übrigens hab ich früher meine Dependencies nur so gefunden, einfach nach "repo1 maven LIB_NAME" gesucht.
Heute gibt es ja glücklicherweise Maven Central Search Engine

Eine Sache die Maven aber für alle besser gemacht hatte: Ein "Standard" Repository Layout für Dependencies, davon profitieren einige Build tools, auch solche, die extra wegen Maven und seiner inflexibilität erfunden wurden ;)
wie Gradle zum Beispiel...

Gruß
Karl Heinz Marbaise
 

Marco13

Top Contributor
@maki (und bygones) Danke für die Info. Gradle hatte bygones schon in einem anderen Thread mal erwähnt, mir war an dem dort genannten aber noch nicht so klar geworden, dass das vielleicht nahe an dem wäre, was ich mir unter einem "Programmatischen Maven" vorstellen würde (und Groovy wollte ich mir ohnehin mal näher ansehen). Unsicherheit blibt trotzdem: Sich für ein Build-System zu entscheiden hat so was endgültiges, ich könnte mir vorstellen, dass der Wechsel schwierig sein kann (Speziell irgendeine 20 KB große POM zu verstehen dürfte unmöglich sein - eigentlich nennt man das "Lava Flow", und das ist ein Antipattern, aber bei Maven scheint das unter dem Motto "Copy and paste once, run everywhere, understand never" schon fast System zu haben... :bahnhof: )
 
B

bygones

Gast
ja deine ideen sind das was gradle im grunde macht.

hier geht man wieder etwas weg vom sturen maven-konfigurations build.

Ich bin immer noch mehr von Gradle ueberzeugt und nutze Maven nur weil ich es muss. Moegen tu ich es nicht - liegt aber auch an der Antipathie gegenueber Sonatypes und vor allem Jason v.Z.

Man schafft mit Gradle ein intuitiveres Buildsystem im Vergleich zum Mavenbuild, der auch nur einen Bruchteil an boilerplate code hat.

Aus meiner Sicht ist das Festhalten an Maven nur der klägliche Versuch bestehende Strukturen aufrechtzuhalten - ähnlich wie bei Ant. Man nutzt es, weil es eben seit Jahren viele nutzen...

my 2 cents

PS: ich bin mal sehr gespannt, da ja nun JFrog (artifactory) ne Kooperation mit Gradle eingeht.

EDIT: jetzt erst gesehen dass meine vorredner das schon verlinkt und erwähnt haben ;-)
 

Wildcard

Top Contributor
(Speziell irgendeine 20 KB große POM zu verstehen dürfte unmöglich sein - eigentlich nennt man das "Lava Flow", und das ist ein Antipattern, aber bei Maven scheint das unter dem Motto "Copy and paste once, run everywhere, understand never" schon fast System zu haben... )
Ich benutze Maven auch erst seit ein paar Wochen intensiver, bin aber nach einigen Einstiegshürden sehr positiv überrascht. Die 20 KB große POM an sich ist schon ein Antipattern.
Durch Convention over Configuration und POM Vererbung sollten deine POMs nur aus wenigen Zeilen bestehen. Idealerweise nur Dependencies, Artifact ID, Parent und Metainformationen (Developer samt EMail Adresse, Projektbeschreibung usw.)
Wenn für dich zB das Fat Jar mit Javadoc und Sourcen ein Standardfall ist definierst du das einmal im Parent, schreibst einmal ein Assembly (wie oben) dafür und schon sind deine Buildscripte wieder absolut minimal.
XML finde ich zwar auch eine denkbar schlechte Wahl sowohl für Konfigurationen, als auch zum programmieren, aber das hat man damals einfach so gemacht.
Gibt übrigens auch Polyglot Maven für XML Hasser.
Index | Sonatype

Der Hauptaspekt von Maven ist für mich aber das standartisierte Repository um zu Deployen, Artifakte herunterzuladen und zu suchen. Das hat die Build Welt als solche ein gutes Stück vorran gebracht. Durch die große Verbreitung unterstützt mittlerweile auch jedes andere namenhafte Java Build System Maven Repositories und dadurch kannst du dein Build Tool für jeden Einzelfall neu wählen, da alle ein gemeinsames Repository verwenden können.
 

Marco13

Top Contributor
Ich hatte schon an anderer Stelle gesagt, dass ich von vielen grundsätzlichen Ideen, die hinter Maven stecken, glaube, dass sie gut und sinnvoll sind. Die Wunschvorstellung, beliebige Programmteile standardisiert aus dem Netz abgreifen zu können, hatte ich schon als Java gerade erst erwachsen wurde. Aber so toll, einfach und elegant das mit Maven im Idealfall sein mag, so unerreichbar ist der Idealfall in der Praxis, und so unschön sind die tatsächlichen Ergebnisse.

Der Versuch, den ich da gestartet hatte, war ja freiwillig - einfach nur so, es zwingt einen ja keiner. Und ich wollte es Maven wirklich recht machen. Aber dann: distributionManagement festlegen, weil's in einer lokalen Datei landen soll - äh - ja, OK. TagBase festlegen weil die "trunk/branches/tags"-Struktur bei SVN offenbar von den Conventions abweicht, die Maven einem auferlegt, ... naja, OK. Aber so eine vermeintliche Trivialität wie das Hinzufügen von Source und JavaDoc zum JAR, die ans Unmögliche zu grenzen scheint - warum sollte man sich sowas antun?

Es ist ja toll, wenn man für ein "komplett konventionelles" Projekt nur eine 3-zeilige POM braucht. Aber für ein trival-Projekt, das ich gezielt für Maven anlegen wollte, bin ich jetzt bei ca. 130 Zeilen. Davon habe ich nur einen Teil verstanden, und die 80 auf 2 Dateien verteilten Zeilen, die du gepostet hast, sind noch nicht dabei. Es ist nett, dass du dir diese Arbeit gemacht hast, aber ehrlich: Ich WILL das nicht - das ist doch ein Krampf?! :noe: Und das nur weil ich gerne eine JAR hätte, wo alles drin ist, was man braucht, und die man so direkt auf eine Webseite hochladen kann. So unnormal oder viel verlangt ist das doch nicht...

Ich hasse übrigens XML nicht. Es ist ziemlich "verbose", aber durch seine Struktur eben sehr allgemein und durch Bibliotheken leicht zu verarbeiten. Ich finde aber, dass es an vielen Stellen eingesetzt wird, wo es nicht sinnvoll ist. XML beschreibt eine Struktur, aber keinen Ablauf. Für die "Paradedisziplin" von Maven (was wohl das Dependency management ist?!) ist das schön, aber IMHO nicht für einen Build-Prozess. Vermutlich wurde das einfach von ANT geerbt? Naja, wenigstens keine Lochkarten mehr...

Das ist aber unabhängig davon, dass man das Ziel "Convention over Configuration" nicht dadurch erreichen sollte, dass man die "Configuration" praktisch unmöglich macht - das ist dann nämlich nicht eine Ermutigung dazu, Konventionen einzuhalten, sondern IMHO schlicht unflexibel. Wie bei einer API: Einfache Dinge sollten einfach sein. Schwierige Dinge können schwierig sein. Und wenn es mit einem build-Tool schwierig ist, eine "vollständige" JAR zusammenzupacken, dann ist das schlecht, und läßt (zumindest für mich) die Einfachheit anderer Dinge bedeutungslos werden.

(Die Einfachheit wird ohnehin nur suggeriert, weil die Dinge nur dadurch einfach werden, dass man die fehlende Flexibilität antizipiert und damit die Aufgaben zu computergerecht stupiden und automatisierbaren Abläufen degenerieren. Das ist nicht schlechtes, im Gegenteil, das MUSS man bei komplexeren Softwaresystemen so machen - aber gerade bei denen sollte man doch auch die Möglichkeit haben, darauf zu reagieren, dass die Welt eben nicht perfekt ist, und diese Möglichkeit sehe ich bei Maven nicht. Ich wünsche zumindest niemandem, dass er mal kurz vor einer deadline feststellt, dass er in seiner 20KB-POM (die von einer anderen POM erbt, damit sie nur 20 und nicht 40 KB hat, und die noch ein paar andere XMLs referenziert, und auf irgendwelche abstrusen Settings zurückgreift) noch irgendeinen Fehler suchen muss...)

Ich werde mir Maven (und/oder Gradle & Co) vielleicht nochmal anschauen, wenn ich mal vieeel Zeit habe, aber ... der Aufwand, sich in Maven ernsthaft einzuarbeiten steht in keinem Verhältnis zu einem Klick auf "Create JAR" im Eclipse-Menü - da kann man nämlich eine Checkbox auswählen, um Sources und JavaDocs mit dazuzupacken... ;)
 

mvitz

Top Contributor
Also das Release Plugin erwartet genau die SVN Struktur trunk/branches/tags, evtl. ist bei dir der Eintrag zum SVN Repo in der POM falsch oder deine SVN Struktur sieht doch anders aus? ;)

Wieso packst du nicht einfach alle 3 JARs (Source, JavaDoc, Binary) anschließend in ein ZIP und stellst dieses zum Download? Hat vor allem auch den Vorteil, dass wenn ich dein Binary JAR nutzen möchte, die größe meines Assemblies kleiner wird (weil JavaDoc und Source nimmt ja zusätzlich Platz weg).
 
M

maki

Gast
XML besteht nunmal aus 80% Struktur und 20% Inhalt, klar bläht das auf.

Aber dann: distributionManagement festlegen, weil's in einer lokalen Datei landen soll - äh - ja, OK. TagBase festlegen weil die "trunk/branches/tags"-Struktur bei SVN offenbar von den Conventions abweicht, die Maven einem auferlegt, ... naja, OK
k.A. warum du das DistributionManagement konfigurieren willst/musst, TagBase musst du nicht festlegen wenn alles Standard ist, trunk/bracnhes/tags sollte eigentlich reichen, musst du eigentlich nur konfigurieren wenn nicht das Standard SVN Layout benutzt wird.

Und das nur weil ich gerne eine JAR hätte, wo alles drin ist, was man braucht, und die man so direkt auf eine Webseite hochladen kann. So unnormal oder viel verlangt ist das doch nicht...
Doch, es ist "unnormal", zumindest bei Maven, und Maven bietet eben auch eine Lösung dafür: das Assembly Plugin (ist Anfangs verwirrend, sollte aber sehr schnell "klick" machen, ist nämlich recht trivial wenn man das XML Hintergrundrauschen rausfiltert)

"Alles in einer Jar" ist IMHO nicht mehr üblich, Maven und SVN repos dagegen schon, da kannst du deine Jar, Sourcen, JavaDoc etc. pp. hochladen, Nutzer müssen nur noch das Repo befragen und nix mehr manuell runterladen, entpacken, konfigurieren, etc. pp.

Das ist aber unabhängig davon, dass man das Ziel "Convention over Configuration" nicht dadurch erreichen sollte, dass man die "Configuration" praktisch unmöglich macht - das ist dann nämlich nicht eine Ermutigung dazu, Konventionen einzuhalten, sondern IMHO schlicht unflexibel.
Das ist ja genau der Punkt Marco: Wenn jeder seine Projekte komplett anders aufsetzen kann, dann wird er es auch tun.
Das soll aber nicht sein und ja, Maven ist unflexibel, du musst flexibel sein :)

Ich habe schon einige "kaputte" Maven Projekte gesehen und repariert, Ursache war immer dieselbe:
Maven wurde nicht verstanden, nichtmal oberflächlich, dafür war man aber kreativ was Pfade, Dateien, etc. pp. betrifft.
In einem Team dachten die Leute tatsächlich, man könnte den Maven Dependency Mechanismus aushebeln und so wie in Ant/Make einfach Dateien referenzieren.. *g*
Dann wurde versucht Multimodulprojekte von der Kommandozeile nur mit [c]mvn[/c] package zu bauen..
Deren Gesichter hättest du sehen sollen als ich ihnen die Probleme vorgeführt habe (beim ersten mal schlägt der Buiold fehl, beim zweiten bauen klappts es zwar, aber es wurden die falschen versionen rangezogen, etc.pp.)

Ergebniss: Builds die mehrmals täglich "spontan" brechen, das ist nicht gut für die Motivation des Entwicklers und den Fortschritt des Projektes.

Die Moral: Wenn man Maven verwendet, arbeitet man sich gefälligst rein und hält man sich Anfangs zu 100% an die Konventionen, keine Ausnahmen.

So ein Buildsystem ist unstrittig ziemlich wichtig für ein Projekt, das muss laufen, und zwar stabil und reproduzierbar.

Ein Vorteil an Maven ist übrigens, dass nur einer im Team den Build konfigurieren muss, der Rest braucht nur noch [c]mvn clean install[/c] aufzurufen.
 

Marco13

Top Contributor
Bezüglich der vermeintlichen Notwendigkeit der Angabe von Dingen wie distributionManagement und tagBase kann ich nur sagen: Wenn man sich an Tutorials und Standards hält, und dann Fehlermeldungen oder nicht der Spezifikation entsprechendes Verhalten auftreten, hat man die Wahl: Entweder man orientiert sich an dem, was z.B. auf Maven Best Practice Guide - Maven User - Codehaus beschrieben ist (SCNR), oder man tippt die Fehlermeldung und ein paar Stichworte in Google, und Copied+Pastet unverstanden den erstbesten Schnipsel, der, wenn man ihn ausprobiert, das Problem zu lösen scheint. Bisher konnte mir noch keiner sagen, wie man bei Maven systematisch Probleme analysiert und gute Lösungen findet.

Einerseits stimme ich zu, dass die Gefahr besteht, dass man sich nicht an Konventionen hält, wenn man nicht dazu gezwungen wird (indem jede Abweichung davon schmerzhaft wird), aber man könnte auch sagen, dass das dann eine Form von "Mangel an Disziplin" ist. Das eigentliche Bewusstsein für Konventionen und Regeln wird nicht notwendigerweise dadurch geschärft, dass eine Abweichung davon schwierig ist - im Zweifelsfall denken die Leute dann vielleicht einfach, dass Maven eben inhärent sch***-kompliziert ist :oops: :D Und abgesehen von der Frage, bei welchem versteckten Plugin-Flag die Abweichung von der Konvention anfängt und bei welchen default-Settings in der Parent-POM sie aufhört, ist die Angabe von
Code:
<directory>${project.build.directory}/site/apidocs</directory>
nicht schwerer oder leichter als
Code:
<directory>C:/MeinWorkspace/_TEMP/apidocs</directory>
Fehler machen kann man praktisch immer.

Wie gesagt, ich werde mir das ganze wohl nochmal ansehen, weil ich bei den im Raum stehenden Möglichkeiten
1. Alle Maven-Benutzer sind masochistische *******
2. Ich habe da irgendwas noch nicht richtig verstanden
doch SEHR, SEHR lange dazu tendiere, die Ursache bei mir, d.h. bei der zweiten Möglichkeit zu suchen ;) Aber ... ohne im Wiederspruch dazu zu anmaßend erscheinen zu wollen, es gibt Indizien dafür, das ich nicht komplett verblödet bin, und nicht nur deswegen ist zumindest die Frage gerechtfertigt, ob man da nicht doch manche Sachen vielleicht ... "zugänglicher" und leichter handhabbar machen könnte...
 
M

maki

Gast
Bisher konnte mir noch keiner sagen, wie man bei Maven systematisch Probleme analysiert und gute Lösungen findet.
Maven ist eine Blackbox, solange alles funktioniert macht es einen recht überschaubaren Eindruck, wenn dann allerdings Probleme auftauchen, wird es schwierig, von Fehlermeldungs-Googelei über Debugausgaben-Buchstabenfriedhof-Archälogie bis Sourcecode-leserei der Plugins habe ich schon alles durch..
Wichtig ist imho, dass man zumindest weiss welches Plugin die Probleme bereitet, dann kann man besser suchen.
Oft geung sind veraltete Pluginversionen der Grund, oder allzu neue Versionen der Plugins ;)
Nicht umsonst gehört es zu den Best-Practices , im PluginManagement die Versionen aller genutzten Plugins festzulegen.

Das eigentliche Bewusstsein für Konventionen und Regeln wird nicht notwendigerweise dadurch geschärft, dass eine Abweichung davon schwierig ist - im Zweifelsfall denken die Leute dann vielleicht einfach, dass Maven eben inhärent sch***-kompliziert ist
IMHO schon, ist ganz einfach: Weichst du von den Konventionen ab, kommst du in die Hölle, sehr schnell sogar *g*
Wie gesagt, wie komplex Maven wirklich ist findet man erst dann heraus, wenn es nicht mehr funktioniert.
Die Komplexität kann man aber händeln, Erfahrungsgemäss würde ich aber keinen Neuling ein komplexes Mavenprojekt alleine aufsetzen lassen, hilft keinem wirklich.

Wie gesagt, ich werde mir das ganze wohl nochmal ansehen, weil ich bei den im Raum stehenden Möglichkeiten
1. Alle Maven-Benutzer sind masochistische *******
2. Ich habe da irgendwas noch nicht richtig verstanden
Ersteres ist auf jedenfall wahr Marco.. *g*

Aber ... ohne im Wiederspruch dazu zu anmaßend erscheinen zu wollen, es gibt Indizien dafür, das ich nicht komplett verblödet bin, und nicht nur deswegen ist zumindest die Frage gerechtfertigt, ob man da nicht doch manche Sachen vielleicht ... "zugänglicher" und leichter handhabbar machen könnte...
Wirst lachen, aber ich finde Maven zugänglich und *relativ* einfach, wenn man sich an die Regeln hält.
Maven zu nutzen ist wirklich simpel, viel einfacher geht es imho gar nicht, das aufsetzen von Projekten ist auch nicht soo schwer wenn man die Konventionen kennt, echte Komplexität kommt erst dann hinzu, wenn es nicht mehr nach Standard laufen soll.
Die Konventionen sind einer der Knackpunkte, sehr oft versuchen Leute etwas zu machen, dass so nicht vorgesehen war in Maven und wundern sich dann... Maven bietet eigentlich für sehr vieles eigene Wege an, die muss man halt kennen bevor man selber kreativ wird (Ja, Kreativität ist im Zusammenhang mit Maven ein negativer Begriff).

Bist mit deiner Meinung nicht alleine, über Maven ist schon viel gesagt/gestritten worden, gibt viele die damit nicht klarkommen (wollen), gibt ja genug Alternativen mittlerweile.
Bei Ant, Gradle etc. pp. baust du dir deinen Build für dein Projekt selber, fängst mit nix an.
Bei Maven musst du halt dafür sorgen, dass sich dein Projekt an Maven anpasst, dafür ist bei Maven eigentlich fast alles bzw. sehr vieles schon da.

*maven fan*
 

Marco13

Top Contributor
Ich hab's nochmal from Scratch versucht, bereit zu akzeptieren, dass am Ende keine vollständige JAR rauskommt. Erkenntnisse:
- Man MUSS anscheinend eine tagBase angeben - erstens, weil es unter Maven - Guide to using the release plugin so steht, und zweitens, weil sonst entweder "trunk/branches/tags" im checkout-Folder landet oder er die Tags in den trunk packt
- Man MUSS anscheinend ein distributionManagement angeben, denn auf der Seite steht auch
If the distributionManagement element is not configured within the pom.xml file then the deployment of the artifact will fail.
Wenn man da irgendeinen Zielpfad einfügt wird das Ergebnis irgendwo hin deployt (und die Versuchung, dort als Zielpfad sowas wie "C:\Recycled\" anzugeben ist schon sehr groß)

Jetzt sind es schon wieder 80 Zeilen für ein "eigentlich leeres" Projekt, bei dem ich keine Abweichung von irgendwelchen Konventionen erkennen kann :bahnhof:

Sicher ist das alles ganz toll, wenn es erstmal aufgesetzt ist. Und für diejenigen, die es nur anwenden müssen, ist es auch toll. Aber wenn dieser Effekt, dass man sich kaum noch traut, etwas zu ändern, schon auftritt, bevor das Projekt überhaupt richtig aufgesetzt ist, erscheint mir das nicht sehr zielführend.

Code:
<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">
  <modelVersion>4.0.0</modelVersion>

  <groupId>de.javagl</groupId>
  <artifactId>JavaGL-Obj</artifactId>
  <version>0.0.2-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>JavaGL-Obj</name>
  <url>http://www.javagl.de</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <scm>
    <developerConnection>scm:svn:file:///C:/Repositories/JavaGL-Obj/trunk</developerConnection>
  </scm>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-source-plugin</artifactId>
        <version>2.1.2</version>
        <executions>
          <execution>
            <id>attach-sources</id>
            <goals>
              <goal>jar</goal>
            </goals>
          </execution>
        </executions>
      </plugin>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-javadoc-plugin</artifactId>
        <version>2.8</version>
        <executions>
          <execution>
            <id>attach-javadocs</id>
            <goals>
              <goal>jar</goal>
            </goals>
          </execution>
        </executions>
      </plugin>

      <plugin>
        <artifactId>maven-release-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <tagBase>file:///C:/Repositories/JavaGL-Obj/tags</tagBase>
        </configuration>
      </plugin>

    </plugins>
  </build>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <distributionManagement>
    <repository>
      <id>file-repository</id>
      <name>Local Repository</name>
      <url>file://${user.dir}/target/deploy/repository</url>
    </repository>
    <site>
      <id>local-site</id>
      <name>Local deployed site</name>
      <url>file://${user.dir}/target/deploy/site</url>
    </site>
  </distributionManagement>

</project>
(Nur nochmal zur Erinnerung: Die Alternative hierzu wären zwei Klicks in Menüs in Eclipse, und dort wäre das Ergebnis eine vollständige JAR, wie man sie mit Maven nur erhalten könnte, wenn zu obigem XML nochmal mindestens genausoviel dazukäme).

Fühlt man sich irgendwie zu einer coolen, nerdigen "In-Group" zugehörig, wenn man sagt, dass man das "gut" findet...?! ???:L :bae: ;)
 

mvitz

Top Contributor
Also mir sind direkt mal zwei Sachen aufgefallen:

1)
[XML]<developerConnection>scm:svn:file:///C:/Repositories/JavaGL-Obj/trunk</developerConnection>[/XML]
muss afaik folgendermaßen aussehen:
[XML]<developerConnection>scm:svn:file:///C:/Repositories/JavaGL-Obj</developerConnection>[/XML]
dann sollte auch das Release Plugin mit dem Standard SVN Layout klarkommen.

2) Du musst ja auch das Javadoc und Source nicht an das JAR Goal packen, du willst beides ja auch bestimmt nicht immer mitbauen, sondern nur zu bestimmten Zeitpunkten (z.B. Release). Da reicht dann auch ein vorheriger manueller Aufruf von
Code:
mvn package javadoc:jar source:jar
bzw. ich bin mir gerade gar nicht sicher, ob das Release Plugin das nicht sogar selber macht (kanns gerade nicht testen, da ich hier keinen SVN Windows Konsolen Client installiert habe).
 

Marco13

Top Contributor
Das zweite ... ja... hm... ich muss wohl mal sehen, ob sich irgendwie erschließen läßt, ob das Bauen oder nicht-Bauen von Source+Doc nun "Convention" ist oder nicht . Ich finde eigentlich schon, aber es schien mir bisher so, als wäre das explizite Einbauen dieser goals auch beim release-Plugin notwendig (zumindest in meinem einzigen "echten" Maven-Projekt, wo aber bei den source+doc+Plugins noch mehr Krämpfe notwendig sind, damit sie machen, was sie sollen :( )

Das erste... hatte ich auf deinen Hinweis hin so versucht, aber dann hat er eben das ganze SVN-Projektverzeichnis (also die Unterverzeichnisse trunk,tags,branches) ins 'checkout' geholt, und dann ging natürlich gar nichts mehr ... vielleicht liegt da ein Fehler bei meinem SVN-Setup vor (die Fehlerbehandlung, Fehlermeldungen, und Tipps zur Vermeidung von Fehlern sind ja eher dürftig), aber ich wüßte nicht, was daran falsch sein sollte... :bahnhof:
 
M

maki

Gast
Würde sagen dass der "trunk" am Ende doch richtig ist, aber anscheinend hast du einen bug im release plugin gefunden, denn laut Doku sollte das genauso funktionieren.
Nehme mal an, dass das release plugin ein Problem damit hat dass dein SVN repo nur ein Projekt enthält und trunk/branches/tags direkt im Root steckt.
 

Marco13

Top Contributor
Hm. Wie auch beim schon weiter oben angedeuteten Punkt gehe ich in solchen Fällen lange davon aus, dass ich irgendwas falsch gemacht habe, bevor ich ernsthaft in Erwägung ziehe, dass ein Programm/Plugin das angeblich tausende Leute mit spielerischer Leichtigkeit erfolgreich benutzen so einen Fehler hat. Ich hatte z.B. auch in Erwägung gezogen, dass er SO sehr auf Conventions pocht, dass er nur den Pfad zur repostory-root bekommen will, und als Projektnamen "sowieso" die artifactId annimmt, aber ... sich sowas alles durch Trial & Error mit Kommandozeile+XML zusammenzuraten... dafür ist mir eigentlich meine Zeit zu schade... :bahnhof:
 
M

maki

Gast
Ja, wir hatten doch das Thema maven-release-plugin beim letzten mal, ist mit Abstand eines der umstrittensten Plugins für Maven.
Würde darauf in kleinen Projekten eher verzichten, vor allem wenn kein Repomanager genutzt wird.
 

Marco13

Top Contributor
Wenn das Taggen im SVN und das Versionieren auch noch wegfallen, bleibt an für mich nutzbarer Funktionalität eigentlich nur noch, dass ich an der Kommandozeile einen Haufen Befehle eingebe, damit er JARs baut, die ich nicht gebrauchen kann. Das macht dann insgesamt wohl nicht viel Sinn. Vielleicht ergibt sich ja mal ein Projekt, bei dem Maven wirklich nützlich ist. Im Moment kann ich mir kaum vorstellen, wie das aussehen sollte, aber man weiß ja nie ;)
 
M

maki

Gast
Hast du es mal mit einer anderen Repo struktur probiert? (also trunk/tag/branch nicht im root)
Naja, wie gesagt, am release plugin sind schon erfahrene Mavennutzer gescheitert.

k.A. was du mit "einen haufen Befehle eingeben" meinst, [c]mvn clean install[/c] reicht wenn du nicht releasen und deployen willst.

Ich arbeite seit Ende 2007 fast ausschliesslich mit Maven und finde es immer nützlich, passt bei mir zu jedem Projekt, ausser Eclipse RCPs, aber selbst da soll es mittlerweile ganz gut gehen.
 

Wildcard

Top Contributor
Wir sind gerade dabei einige hundert Projekte von Ant auf Maven umzustellen. Die Artifakt Verwaltung wird wesentlich vereinfacht, statt wie bisher alle Abhängigkeiten an 3 Stellen zu pflegen ist jetzt alles zentral und zehntausende Zeilen Ant Scripts werden durch schlanke poms ersetzt.
Für ein Projekt macht es IMO keinen großen Unterschied, aber die hunderte Ant Scripts die wir zu verwalten hatten waren ein Alptraum zu warten.
Das Problem ist die Flexibilität. Ant gibt dir viele Möglichkeiten und die wurden zum Teil schamlos ausgenutzt.
Für eine Enterprise Umgebung ist diese Art der Kreativität in Build Scripten IMO sehr negativ.
Maven hat auch den Vorteil das wir neue Entwickler meist nicht groß darin schulen müssen, denn anders als bei der bisherigen selbst gebauten Artifakt Verwaltung kennen sich neue Entwickler oft schon mit Maven aus und m2eclipse übernimmt das meiste automatisch.
 

Marco13

Top Contributor
Meine bisherigen Erfahrungen sind eben: Unhandlich durch XML und Kommandozeile, Dokumentation im Stil von "kopier' dir dieses Snippet und pass' die Namen an", nichtssagende Fehlermeldungen, und nicht zuletzt dass man eben viel konfigurieren muss, aber das, was man vielleicht gerne konfigurieren würde, nicht mit vertretbarem Aufwand konfigurieren kann - und wenn doch, gibt es keine Möglichkeit, rauszufinden, wie...

Der Aufwand zum Bauen eines Projektes ist hochgradig nicht-Linear mit der Anzahl, Schachtelung und Versionierungs-Granularität der Abhängigkeiten. Bei einer einzelnen JAR geht es um einen Klick auf "Create JAR", oder eine 50-Zeilen-POM - aber bei einem Projekt mit vielen geschachtelten Abhängigkeiten geht es um stundenlanges Gefrickel, oder eine 100-Zeilen POM - da wäre mir letzteres auch lieber.

Da ich glaube, dass in Zukunft diese Fragmentierung von Projekten noch drastisch zunehmen wird, glaube ich auch, dass es sinnvoll sein könnte, sich damit auszukennen. Aber ... ich habe für dieses "Test-Projekt" jetzt schon sehr viel Zeit investiert, und bin eigentlich keinen Schritt weiter... unter anderem habe ich ein paar Mal das SVN-Repo gelöscht und neu erstellt, weil die ersten 10 Tags nur waren: "Maven macht jetzt ein Release" (und es nie wie gewünscht funktioniert hat - nebnebei hat er Version 0.0.10 dann auch wieder als 0.0.1 interpretiert, und dann war natürlich ohnehin alles vermurkst :autsch: ). Vielleicht probiere ich nochmal mit anderen Layouts rum, aber ... eigentlich würde ich lieber programmieren... :reflect:
 

mvitz

Top Contributor
Also ich habs gerade mit einem frischen Maven 3.0.3 getestet:

[XML] <developerConnection>scm:svn:file:///C:/Repositories/JavaGL-Obj</developerConnection>[/XML] führt bei mir dazu, dass im richtigen Ordner getagt wird. Was du genau mit auschecken meinst, ist mir nicht klar. Ich habe den Projekt normal mit SVN ausgecheckt.
 

Marco13

Top Contributor
Das Release-Plugin erstellt ja automatisch ein Tag vom aktuellen Stand, und checkt dann genau diesen Tag aus (der dann gebaut wird). Und da hat er eben das Projekt-Wurzelverzeichnis mit trunk/tags/branches ausgechekt, und nicht den Inhalt von 'trunk'. Vielleicht probiere ich nochmal irgendwann ein bißchen rum.
(BTW: "Maven" ist doch eigentlich ... "nichts" - kommt es nicht praktisch ausschließlich auf die Versionen der Plugins an, ob es sich vielleicht anders verhält? ???:L ).
 

mvitz

Top Contributor
Stimmt in der Tat, aber nach ein paar Versuchen funktioniert bei mir folgendes ohne Probleme (baut beim Release sogar Javadoc und Sources automatisch:

[XML]<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">
<modelVersion>4.0.0</modelVersion>

<groupId>de.mvitz.examples.maven</groupId>
<artifactId>basic</artifactId>
<version>1.0.1-SNAPSHOT</version>

<scm>
<developerConnection>scm:svn:file:///opt/svn/maven-test/trunk</developerConnection>
</scm>

<distributionManagement>
<repository>
<id>local-filesystem</id>
<name>Local Filesystem Repository</name>
<url>file:///opt</url>
</repository>
</distributionManagement>

</project>[/XML]
 

Marco13

Top Contributor
Bei Maven - Guide to using the release plugin steht, dass man die TagBase angeben muss. Durch Intervallschachtelung herauszufinden, welche Zeile der POM entgegen der Spezifikation vielleicht weggelassen werden kann, wäre der Schritt, den man machen könnte, wenn erstmal alles funktionieren würde. Ich meine, ich hätte diese Variante schon ausprobeirt, aber ehrlich gesagt bin ich da jetzt nicht mehr 100% sicher - war einfach zu viel Trial&Error-Gefrickel...
Ob und inwieweit da noch Unterschiede zwischen Linux und Win bestehen, kann ich auch nicht einschätzen.
Aber vielleicht bastle ich nächste Woche nochmal weiter. Danke für all die Hinweise so weit.
 
G

Guest2

Gast
Moin,

ohne primär jetzt was zum Thema Maven + Subversion sagen zu können (hab selber den Umstieg von Ant zu Maven genutzt, um auch von SVN auf Git umzusteigen), so ist die erste Seite, die ich bei Problemen mit einzelnen Plugins aufrufe, immer die Seite des jeweiligen Plugins selber. Und da die normalerweise auch immer eine "Maven-Site" ist, sprich also praktisch immer gleich aufgebaut ist, gibt es alle relevanten Informationen auch immer in einer bekannten Form ohne erst viel lesen zu müssen (die Vorteile von conventions ;)) Der Nachteil ist nur, dass man erst wissen muss, welches Plugin man braucht.

Die Seite des release-plugin wirft entsprechend aus:

http://maven.apache.org/plugins/maven-release-plugin/prepare-mojo.html#tagBase hat gesagt.:
The tag base directory in SVN, you must define it if you don't use the standard svn layout (trunk/tags/branches). For example, asf - Revision 1144685: /maven/plugins/tags. The URL is an SVN URL and does not include the SCM provider and protocol.

http://maven.apache.org/plugins/maven-release-plugin/usage.html hat gesagt.:
Set where to tag the files in Subversion
This example shows how to set the repository location for all tags to be created in Subversion. Note that this is not needed if you use the standard SVN layout, where the root project is in trunk, and there is a sibling tags directory.

Viele Grüße,
Fancy
 

Ähnliche Java Themen

Neue Themen


Oben