wake-up-neo.net

So erstellen Sie Kriegsdateien

Was sind die bewährten Methoden zum Erstellen von Kriegsdateien (mithilfe von Eclipse) zur Ausführung auf Tomcat? Tutorials, Links, Beispiele werden sehr geschätzt. 

90
ultraman

Sie können Ant verwenden, um Ihre Lösung einzurichten, zu kompilieren, WAR und bereitzustellen.

<target name="default" depends="setup,compile,buildwar,deploy"></target>

Sie können dann in Eclipse einen Klick ausführen, um dieses Ant-Ziel auszuführen. Hier sind Beispiele für jeden der Schritte:

Voraussetzungen

Wir gehen davon aus, dass Sie Ihren Code wie folgt organisiert haben:

  • ${basedir}/src: Java-Dateien, Eigenschaften und XML-Konfigurationsdateien
  • ${basedir}/web: Ihre JSP-Dateien
  • ${basedir}/web/lib: JARs, die zur Laufzeit erforderlich sind
  • ${basedir}/web/META-INF: Ihr Manifest
  • ${basedir}/web/WEB-INF: Ihre web.xml-Dateien

Konfiguration

Definieren Sie eine setup-Task, die das Distributionsverzeichnis erstellt und alle Artefakte kopiert, die direkt WARred sein müssen:

<target name="setup">
    <mkdir dir="dist" />
    <echo>Copying web into dist</echo>
    <copydir dest="dist/web" src="web" />
    <copydir dest="dist/web/WEB-INF/lib" src="${basedir}/../web/WEB-INF/lib" />
</target>

Kompilieren

Bauen Sie Ihre Java-Dateien in Klassen ein und kopieren Sie alle Nicht-Java-Artefakte, die sich unter src befinden, aber zur Laufzeit verfügbar sein müssen (z. B. Eigenschaften, XML-Dateien usw.):

<target name="compile">
    <delete dir="${dist.dir}/web/WEB-INF/classes" />
    <mkdir dir="${dist.dir}/web/WEB-INF/classes" />
    <javac destdir="${dist.dir}/web/WEB-INF/classes" srcdir="src">
        <classpath>
            <fileset dir="${basedir}/../web/WEB-INF/lib">
                  <include name="*" />
            </fileset>
        </classpath>
    </javac>
    <copy todir="${dist.dir}/web/WEB-INF/classes">
        <fileset dir="src">
            <include name="**/*.properties" />
            <include name="**/*.xml" />
        </fileset>
    </copy>
</target>

Krieg bauen

Erstellen Sie den WAR selbst:

<target name="buildwar">
    <war basedir="${basedir}/dist/web" destfile="My.war"
     webxml="${basedir}/dist/web/WEB-INF/web.xml">
        <exclude name="WEB-INF/**" />
        <webinf dir="${basedir}/dist/web/WEB-INF/">
            <include name="**/*.jar" />
        </webinf>
    </war>
</target>

Bereitstellen

Schließlich können Sie eine Aufgabe einrichten, um die WAR direkt an Ihrem Tomcat-Bereitstellungsspeicherort bereitzustellen:

<target name="deploy">
    <copy file="My.war" todir="${Tomcat.deploydir}" />
</target>

Klicken und los!

Nachdem Sie all dies eingerichtet haben, starten Sie einfach das default-Ziel von Eclipse aus, kompilieren, warnen und implementieren Ihre Lösung.

Der Vorteil dieses Ansatzes ist, dass er sowohl außerhalb von Eclipse als auch innerhalb von Eclipse funktioniert und dazu verwendet werden kann, Ihre Bereitstellungsstrategie (z. B. über die Quellcodeverwaltung) problemlos mit anderen Entwicklern zu teilen, die ebenfalls an Ihrem Projekt arbeiten.

94
David Citron

Ich habe immer nur Export aus Eclipse ausgewählt. Es erstellt die Kriegsdatei und enthält alle erforderlichen Dateien. Vorausgesetzt, Sie haben das Projekt als Webprojekt erstellt, das ist alles, was Sie tun müssen. Eclipse macht es sehr einfach.

37
Mech Software

Wir verwenden Maven (Ants großen Bruder) für alle unsere Java-Projekte und es gibt ein sehr geschicktes WAR-Plugin. Tutorials und Verwendung finden Sie dort. 

Es ist viel einfacher als Ant, vollständig kompatibel mit Eclipse (verwenden Sie maven Eclipse: eclipse, um Eclipse-Projekte zu erstellen) und einfach zu konfigurieren.

Maven's Homepage

Maven WAR Plugin

Beispielkonfiguration: 

<plugin>
    <groupId>org.Apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>2.1-alpha-2</version>
    <configuration>
        <outputDirectory>${project.build.directory}/tmp/</outputDirectory>
        <workDirectory>${project.build.directory}/tmp/war/work</workDirectory>
        <webappDirectory>${project.build.webappDirectory}</webappDirectory>
        <cacheFile>${project.build.directory}/tmp/war/work/webapp-cache.xml</cacheFile>
        <nonFilteredFileExtensions>
            <nonFilteredFileExtension>pdf</nonFilteredFileExtension>
            <nonFilteredFileExtension>png</nonFilteredFileExtension>
            <nonFilteredFileExtension>gif</nonFilteredFileExtension>
            <nonFilteredFileExtension>jsp</nonFilteredFileExtension>
        </nonFilteredFileExtensions>
        <webResources>
            <resource>
                <directory>src/main/webapp/</directory>
                <targetPath>WEB-INF</targetPath>
                <filtering>true</filtering>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </webResources>
        <warName>Application</warName>
    </configuration>
</plugin>
22
mikek

Eine Kriegsdatei ist einfach eine JAR-Datei mit einer Kriegserweiterung, was jedoch dazu führt, dass der Inhalt tatsächlich strukturiert ist.

Das J2EE/Java EE-Tutorial kann ein Anfang sein:

http://Java.Sun.com/j2ee/tutorial/1_3-fcs/doc/WebComponents3.html

Und die Servlet-Spezifikation enthält die blutigen Details:

http://Java.Sun.com/products/servlet/download.html

Wenn Sie in Eclipse ein neues Webprojekt erstellen (ich beziehe mich auf die Java EE-Version), wird die Struktur für Sie erstellt. Sie können auch angeben, wo Ihr Appserver installiert ist, und die Anwendung wird für Sie bereitgestellt und gestartet.

Mit der Option "Export-> WAR-Datei" können Sie die Kriegsdatei speichern. 

14
boxofrats

Wenn Sie sich nicht sicher sind, was Sie tun sollen und von vorne anfangen, kann Maven Ihnen beim Start helfen.

Durch Befolgen der folgenden Schritte können Sie ein perfektes neues Kriegsprojekt in Eclipse einrichten.

  1. Laden Sie herunter und installieren Sie Maven
  2. Gehen Sie zum Befehlszeilenlauf: mvn archetype:generate
  3. Befolgen Sie die angezeigten Schritte, indem Sie das einfache Java-Webprojekt (18) und einen geeigneten Namen auswählen.
  4. Wenn es fertig ist, führen Sie Folgendes aus: mvn Eclipse:eclipse
  5. Starten Sie Eclipse. Wählen Sie Datei -> Importieren -> Vorhandenes Projekt. Wählen Sie das Verzeichnis aus, in dem Sie die MVN-Ziele ausgeführt haben.
  6. Sie sollten jetzt einen sehr guten Start in ein Kriegsprojekt in Eclipse haben
  7. Sie können den Krieg selbst erstellen, indem Sie mvn package ausführen oder implementieren, indem Sie einen Server in Eclipse einrichten und das Projekt einfach zum Server hinzufügen.

Wie einige andere schon gesagt haben, ist der Nachteil von Maven, dass man die Konventionen von Maven verwenden muss. Aber ich denke, wenn Sie gerade erst anfangen, ist es eine gute Idee, die Konventionen zu erlernen, bevor Sie Ihre eigenen machen. Es gibt nichts, was Sie daran hindern könnte, zu einem späteren Zeitpunkt Ihre eigene bevorzugte Methode zu ändern.

Hoffe das hilft.

12
Pablojim

Verwenden Sie die Ant-Kriegsaufgabe

4
Ilya Boyandin

Verwenden Sie einen Ant-Build-Code Ich verwende diesen für mein Projekt-SMS.

<property name="WEB-INF" value="${basedir}/WebRoot/WEB-INF" />
<property name="OUT" value="${basedir}/out" />
<property name="WAR_FILE_NAME" value="mywebapplication.war" />
<property name="TEMP" value="${basedir}/temp" />

<target name="help">
    <echo>
        --------------------------------------------------
        compile - Compile
        archive - Generate WAR file
        --------------------------------------------------
    </echo>
</target>

<target name="init">
    <delete dir="${WEB-INF}/classes" />
    <mkdir dir="${WEB-INF}/classes" />
</target>

<target name="compile" depends="init">
    <javac srcdir="${basedir}/src" 
                destdir="${WEB-INF}/classes" 
                classpathref="libs">
    </javac>
</target>

<target name="archive" depends="compile">
    <delete dir="${OUT}" />
    <mkdir dir="${OUT}" />
    <delete dir="${TEMP}" />
    <mkdir dir="${TEMP}" />
    <copy todir="${TEMP}" >
        <fileset dir="${basedir}/WebRoot">
        </fileset>
    </copy>
    <move file="${TEMP}/log4j.properties" 
                    todir="${TEMP}/WEB-INF/classes" />
    <war destfile="${OUT}/${WAR_FILE_NAME}" 
                    basedir="${TEMP}" 
                    compress="true" 
                    webxml="${TEMP}/WEB-INF/web.xml" />
    <delete dir="${TEMP}" />
</target>

<path id="libs">
    <fileset includes="*.jar" dir="${WEB-INF}/lib" />
</path>

3
sms

Eine andere übliche Option ist Gradle. 

http://www.gradle.org/docs/current/userguide/application_plugin.html

So erstellen Sie Ihre Kriegsdatei in einer Web-App:

Fügen Sie in build.gradle Folgendes hinzu:

apply plugin: 'war'

Dann:

./gradlew war

Verwenden Sie das Layout aus der oben angegebenen akzeptierten Antwort.

2
Charlie Dalsass

Eine andere Option wäre, es automatisch mit Eclipse zu erstellen. Bei einer kontinuierlichen Integrationsumgebung wird natürlich Ant oder Maven empfohlen. Die Exportalternative ist nicht sehr praktisch, da Sie jedes Mal die Exporteigenschaften konfigurieren müssen.

SCHRITTE:

  1. Aktivieren Sie die Unterstützung für "Projektarchive". Dies kann von Ihrem Projekt abhängen (ich habe es in einem Java EE/Web-Projekt verwendet). Klicken Sie mit der rechten Maustaste auf das Projektstammverzeichnis. Konfigurieren -> Projektarchiv-Unterstützung hinzufügen.

  2. Erstellen Sie ein neues Archiv im oberen Verzeichnis "Projektarchiv". Sie haben nur eine JAR-Option, aber Sie nennen * .war.

  3. Konfigurieren Sie Dateisätze, d. H. Welche Dateien enthalten sein sollen. Normalerweise konfigurieren Sie zwei Dateigruppen ähnlich wie die Web Deployment Assembly (Projekteigenschaft) konfiguriert ist.

    • kopiere/WebContent nach /
    • copy/build/classes in WEB-INF/classes (Erstellen Sie diese Dateigruppe, nachdem Sie das Verzeichnis WEB-INF/classes im Archiv definiert haben.)
  4. Möglicherweise müssen Sie die Eigenschaft zum Ausschließen der Dateisatzgruppe abwägen, abhängig davon, wo Sie einige der Konfigurationsdateien abgelegt haben, oder Sie benötigen möglicherweise mehr Dateigruppen. Wenn Sie dies jedoch konfiguriert haben, müssen Sie sie nicht mehr ändern.

  5. Erstellen Sie das Archiv manuell oder veröffentlichen Sie es direkt auf dem Server. wird aber auch automatisch von Eclipse für Sie erstellt

2
arpadf

Verwenden Sie diesen Befehl außerhalb des WEB-INF-Ordners. Dies sollte Ihre Kriegsdatei erstellen. Dies ist eine schnellste Methode, die ich kenne. 

Sie benötigen das JDK 1.7+, um diese Funktion und Umgebungsvariablen zu erhalten, die auf das bin-Verzeichnis Ihres JDK zeigen.

jar -cvf projectname.war *

Referenzlink

1
XChikuX

Einfacher Shell-Code zum Erstellen von WAR-Dateien aus einem dynamischen dynamischen Eclipse-Webprojekt. Verwendet RAM Dateisystem (/ dev/shm) auf einer Linux-Plattform.

#!/bin/sh

UTILITY=$(basename $0)

if [ -z "$1" ] ; then
    echo "usage: $UTILITY [-s] <web-app-directory>..."
    echo "       -s ..... With source"
    exit 1
fi

if [ "$1" == "-s" ] ; then
    WITH_SOURCE=1
    shift
fi

while [ ! -z "$1" ] ; do
    WEB_APP_DIR=$1

    shift

    if [ ! -d $WEB_APP_DIR ] ; then
        echo "\"$WEB_APP_DIR\" is not a directory"
        continue
    fi

    if [ ! -d $WEB_APP_DIR/WebContent ] ; then
        echo "\"$WEB_APP_DIR\" is not a Web Application directory"
        continue
    fi

    TMP_DIR=/dev/shm/${WEB_APP_DIR}.$$.tmp
    WAR_FILE=/dev/shm/${WEB_APP_DIR}.war

    mkdir $TMP_DIR

    pushd $WEB_APP_DIR > /dev/null
    cp -r WebContent/* $TMP_DIR
    cp -r build/* $TMP_DIR/WEB-INF
    [ ! -z "$WITH_SOURCE" ] && cp -r src/* $TMP_DIR/WEB-INF/classes
    cd $TMP_DIR > /dev/null
    [ -e $WAR_FILE ] && rm -f $WAR_FILE
    jar cf $WAR_FILE .
    ls -lsF $WAR_FILE
    popd > /dev/null

    rm -rf $TMP_DIR
done
0
Joe Horvath

Einfachere Lösung, die auch den Eclipse-Arbeitsbereich aktualisiert:

<?xml version="1.0" encoding="UTF-8"?>
<project name="project" default="default">    
    <target name="default">
        <war destfile="target/MyApplication.war" webxml="web/WEB-INF/web.xml">
            <fileset dir="src/main/Java" />
            <fileset dir="web/WEB-INF/views" />
            <lib dir="web/WEB-INF/lib"/>
            <classes dir="target/classes" />
        </war>
        <Eclipse.refreshLocal resource="MyApplication/target" depth="infinite"/>
    </target>
</project>
0
Alex R