So erstellen Sie Kriegsdateien

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

Mit Ant können Sie Ihre Lösung einrichten, kompilieren, WAR und bereitstellen.

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

Sie können dann einen Klick in Eclipse 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, XML-Konfigurationsdateien
• ${basedir}/web: Ihre JSP-Dateien
• ${basedir}/web/lib: Alle zur Laufzeit erforderlichen JARs
• ${basedir}/web/META-INF: Dein Manifest
• ${basedir}/web/WEB-INF: Ihre web.xml-Dateien

Konfiguration

Definieren Sie eine setupAufgabe, die das Verteilungsverzeichnis erstellt und alle Artefakte kopiert, die direkt mit WARred versehen werden 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

Erstellen Sie Ihre Java-Dateien in Klassen und kopieren Sie alle Nicht-Java-Artefakte, die sich unter befinden, srcaber 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>

Build WAR

Erstellen Sie das 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-Bereitstellungsort bereitzustellen:

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

Klicken und los!

Sobald dies alles eingerichtet ist, defaultwird Ihre Lösung durch einfaches Starten des Ziels über Eclipse kompiliert, WAR und bereitgestellt.

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

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

Wir verwenden Maven (Ants großer Bruder) für alle unsere Java-Projekte und es hat 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.

Mavens 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>

Eine Kriegsdatei ist einfach eine JAR-Datei mit einer Kriegserweiterung. Damit funktioniert sie jedoch, wie 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 wichtigsten 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 und 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 War-Datei speichern.

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

Wenn Sie die folgenden Schritte ausführen, können Sie ein neues Kriegsprojekt perfekt in Eclipse einrichten.

1. Laden Sie Maven herunter und installieren Sie es
2. Gehen Sie zur Befehlszeile: mvn archetype:generate
3. Befolgen Sie die angeforderten Schritte - wählen Sie das einfache Java-Webprojekt (18) und einen geeigneten Namen.
4. Wenn es fertig ist, laufen Sie: 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. Das war's, Sie sollten jetzt einen sehr guten Start in ein Kriegsprojekt in Eclipse haben
7. Sie können den Krieg selbst erstellen, indem Sie ihn ausführen mvn packageoder bereitstellen, indem Sie einen Server in Eclipse einrichten und das Hinzufügen des Projekts zum Server hinzufügen.

Wie einige andere gesagt haben, besteht der Nachteil der Verwendung von Maven darin, dass Sie die Maven-Konventionen verwenden müssen. Aber ich denke, wenn Sie gerade erst anfangen, ist es eine gute Idee, die Konventionen zu lernen, bevor Sie anfangen, Ihre eigenen zu machen. Nichts hindert Sie daran, zu einem späteren Zeitpunkt auf Ihre bevorzugte Methode umzusteigen / umzugestalten.

Hoffe das hilft.

Verwenden Sie die Ameisenkriegsaufgabe

Verwenden Sie Ant Build Code Ich verwende diesen für meine 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>

Eine andere Möglichkeit wäre, es automatisch mit Eclipse zu erstellen. Wenn Sie eine kontinuierliche Integrationsumgebung haben, wird natürlich Ant oder Maven empfohlen. Die Exportalternative ist nicht sehr praktisch, da Sie die Exporteigenschaften jedes Mal konfigurieren müssen.

SCHRITTE:

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

2. Erstellen Sie ein neues Archiv im oberen Verzeichnis "Projektarchive". Sie haben nur die Option jar, aber benennen Sie das Archiv * .war.

3. Konfigurieren Sie Dateigruppen, dh welche Dateien enthalten sein sollen. In der Regel werden zwei Dateigruppen ähnlich wie die Web Deployment Assembly (Projekteigenschaft) konfiguriert.

   • Kopieren Sie / WebContent nach /
   • Kopieren / Erstellen / Klassen nach WEB-INF / Klassen (Erstellen Sie diese Dateigruppe, nachdem Sie das Verzeichnis WEB-INF / Klassen im Archiv definiert haben.)

4. Möglicherweise müssen Sie die Eigenschaft zum Ausschließen von Dateigruppen tweeken, je nachdem, wo Sie einige der Konfigurationsdateien abgelegt haben, oder Sie benötigen möglicherweise weitere Dateigruppen. Die Idee ist jedoch, dass Sie diese nach der Konfiguration nicht mehr ändern müssen.

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

Eine weitere häufige 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 akzeptierten Antwort.

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

(Sie benötigen JDK 1.7+ und Umgebungsvariablen, die auf das bin-Verzeichnis Ihres JDK verweisen.)

jar -cvf projectname.war *

Referenzlink

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>

Einfacher Shell-Code zum Erstellen von WAR-Dateien aus einem dynamischen Standard-Eclipse-Webprojekt. Verwendet das 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

** Erstellen einer Kriegsdatei in Eclips Gaynemed von Grails-Webprojekt **

1. Projekt importieren:

2.Ändern Sie die Datei datasource.groovy

So: url = "jdbc: postgresql: //18.247.120.101: 8432 / PGMS"

2.chnge AppConfig.xml

3. Töten Sie Java im Task-Manager:

4. Führen Sie einen sauberen Befehl in Eclips aus

5. Führen Sie "Prod War" nach Projektnamen aus.

6. Überprüfen Sie die Protokolldatei und suchen Sie dieselbe WAR-Datei im Verzeichnis der Workbench mit demselben Datum.