So erstellen Krieg Dateien

Question

Was sind die besten Praktiken der Erstellung Krieg-Dateien (mit Eclipse) auf Tomcat laufen? Tutorials, Links sind Beispiele sehr geschätzt.

Answer 1

Sie können mit Ant einzurichten, zu kompilieren, IST und Ihre Lösung bereitstellen.

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

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

Voraussetzungen

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

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

Einrichten

Definieren Sie eine setup Aufgabe, die das Verteilungsverzeichnis und kopiert alle Artefakte, die direkt zu warred müssen erstellt:

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

Compile

Erstellen Sie Ihre Java-Dateien in Klassen, und kopieren Sie über alle Nicht-Java-Artefakte, die unter src residieren, müssen aber zur Laufzeit (zum Beispiel Eigenschaften, XML-Dateien, etc.) Verfügbar sein:

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

Erstellen Sie die 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 IST direkt in Ihr Tomcat einsetzen Standort bereitstellen:

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

Klicken Sie auf und gehen Sie!

Sobald dies alles eingerichtet ist, einfach das default Ziel von Eclipse-Start kompiliert, Krieg und Ihre Lösung bereitstellen.

Der Vorteil dieses Ansatzes ist, dass es so gut wie innerhalb von Eclipse außerhalb Eclipse arbeitet und kann verwendet werden, um bequem Ihre Implementierungsstrategie (zB über die Quellcodeverwaltung) mit anderen Entwicklern zu teilen, die auch an Ihrem Projekt arbeiten.

Answer 2

Ich habe immer nur Export von Eclipse-ausgewählt. Es baut die WAR-Datei und enthält alle notwendigen Dateien. Sofern Sie erstellt das Projekt als Web-Projekt, das alles, was Sie tun müssen, ist. Eclipse macht es sehr einfach zu tun.

Answer 3

Wir verwenden Maven (Ant Der große Bruder) für alle unsere Java-Projekte, und es hat eine sehr nette WAR-Plugin. Tutorials und Nutzung sind dort zu finden.

Es ist viel einfacher, als Ant, voll kompatibel mit Eclipse (Verwendung Maven Eclipse: Eclipse Eclipse-Projekte erstellen). Und einfach zu konfigurieren

Maven die Homepage

Maven IST-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>

Answer 4

Eine WAR-Datei ist einfach eine JAR-Datei mit einem Krieg Erweiterung, aber was macht es Arbeit ist, 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 blutigen Details:

http://java.sun.com/products/servlet/download.html

Wenn Sie ein neues Web-Projekt in Eclipse erstellen (ich beziehe mich auf die Java EE-Version) wird die Struktur für Sie erstellt und Sie können es auch sagen, wo Ihr Appserver installiert ist, und es wird installieren und starten Sie die Anwendung für Sie .

die „Export-> WAR-Datei“ Option verwenden, werden Sie die WAR-Datei lassen speichern.

Answer 5

Wenn Sie nicht sicher sind, was zu tun ist und von vorne anfangen, dann können Maven helfen Ihnen den Start.

Mit dem Anschluss an die Sie die folgenden Schritte Sie einen neuen Krieg Projekt-Setup perfekt in Eclipse bekommen.

1. Herunterladen und Installieren von Maven
2. Gehen Sie die Befehlszeile ausführen: mvn archetype:generate
3. Folgen Sie den Schritten aufgefordert, -. Die einfache Java-Web-Projekt wählen (18) und einen geeigneten Namen
4. Wenn es fertig ist Lauf: mvn eclipse:eclipse
5. Eclipse starten. Wählen Sie Datei -> Import -> Bestehende Projekt. Wählen Sie das Verzeichnis, in dem Sie die MVN Ziele lief.
6. Das ist es, sollten Sie jetzt einen sehr guten Start in einen Krieg Projekt in Eclipse haben
7. Sie können den Krieg selbst erstellen, indem mvn package läuft oder es bereitstellen, indem Sie einen Server in Eclipse einrichten und einfaches Hinzufügen das Projekt an den Server hinzuzufügen.

Wie einige andere gesagt haben der Nachteil Maven zu verwenden, ist, dass Sie die Maven-Konventionen verwenden. Aber ich denke, wenn Sie gerade erst anfangen, die Konventionen zu lernen ist eine gute Idee, bevor Sie beginnen Ihre eigenen. Es gibt nichts, Sie zu stoppen Ändern / Refactoring Ihr eigenes bevorzugtes Verfahren zu einem späteren Zeitpunkt.

Hope, das hilft.

Answer 6

Mit der Ant Krieg Aufgabe

Answer 7

Mit Ant Build-Code Ich benutze dies 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>

Answer 8

Eine andere Möglichkeit wäre, es zu bauen automatisch mit Eclipse. Natürlich, wenn Sie die kontinuierliche Integration Umgebung Ant oder Maven haben empfohlen. Der Export Alternative ist nicht sehr bequem, weil Sie jedes Mal der Exporteigenschaften konfigurieren.

SCHRITTE:

1. Aktivieren "Projekt Archives" zu unterstützen; Dies könnte auf Ihrem Projekt ab (habe ich es auf Java EE / Web-Projekt). Rechtsklick-Projekt Stammverzeichnis; Konfigurieren. -> Project Archiv Unterstützung

2. Gehen und ein neues Archiv im „Projektarchiv“ top dir erstellen. Sie haben nur jar Option, aber Namen, den Sie archivieren * .war.

3. Konfigurieren Fileset-s, das heißt, was aufgenommen werden Dateien. Typisch ist zwei Dateigruppen ähnlich zu konfigurieren, wie die Web Deployment Assembly (Projekteigenschaft) konfiguriert ist.

   • Kopieren / WebContent auf /
   • copy / build / Klassen WEB-INF / classes (erstellen Sie diese Dateigruppe, nachdem Sie die WEB-INF / classes im Archiv definieren)

4. Sie müssen möglicherweise die fileset ausschließen Eigenschaft tweek je nachdem, wo Sie einige der Konfigurationsdateien platziert oder Sie könnten mehr Dateigruppen benötigen, aber die Idee ist, dass, sobald Sie diese konfiguriert Sie müssen es nicht ändern.

5. Erstellen Sie das Archiv manuell oder veröffentlichen direkt an den Server; sondern ist auch für Sie Eclipse automatisch erstellt

Answer 9

Eine weitere häufige Option ist gradle.

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

Um die WAR-Datei in einem Web-App zu erstellen:

In build.gradle hinzufügen:

apply plugin: 'war'

Dann:

./gradlew war

Verwenden Sie das Layout von akzeptierter Antwort oben.

Answer 10

Mit diesem Befehl außerhalb der WEB-INF-Ordner. Dies sollte Ihre WAR-Datei erstellen. Dies ist eine schnellste Methode, die ich kenne.

Sie JDK müssen 1.7+ installieren diese Leistung und Umgebungsvariablen zu erreichen, die in das Verzeichnis ist Ihr JDK verweisen.

jar -cvf projectname.war *

Referenz-Link

Answer 11

Einfachere Lösung, die auch den Eclipse-Workspace 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>

Answer 12

Simplistic Shell-Code für WAR-Dateien von einem Standard-Erstellung von dynamischen Web-Projekt Eclipse-. 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

Answer 13

**, das Krieg-Datei in Eclips Gaynemed von Grails Web-Projekt **

1.Importieren Projekt:

2.Ändern der datasource.groovy Datei

Wie diese: url = "jdbc: postgresql: //18.247.120.101: 8432 / PGMS"

2.chnge AppConfig.xml

3.kill die Java von Task-Manager:

4. laufen sauber comand in eclips

5. run 'prod Krieg' fowllowed von Projektnamen ein.

6. die Protokolldatei prüfen und die gleiche Datei im Verzeichnis .war der Werkbank mit demselben Datum finden.