Jak tworzyć pliki wojenne

Jakie są najlepsze praktyki tworzenia plików wojennych (przy użyciu zaćmienia) do uruchamiania na tomcat? tutoriale, linki, przykłady są bardzo cenione.

Możesz użyć Ant do konfigurowania, kompilowania, WAR i wdrażania rozwiązania.

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

Następnie możesz wykonać jedno kliknięcie w Eclipse, aby uruchomić ten cel Ant. Oto przykłady każdego z kroków:

Warunki wstępne

Zakładamy, że masz zorganizowany kod w następujący sposób:

• ${basedir}/src: Pliki Java, właściwości, pliki konfiguracyjne XML
• ${basedir}/web: Twoje pliki JSP
• ${basedir}/web/lib: Wszystkie pliki JAR wymagane w czasie wykonywania
• ${basedir}/web/META-INF: Twój manifest
• ${basedir}/web/WEB-INF: Twoje pliki web.xml

Ustawiać

Zdefiniuj setupzadanie, które tworzy katalog dystrybucyjny i kopiuje wszystkie artefakty, które mają być bezpośrednio objęte WARred:

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

Skompilować

Zbuduj pliki Java w klasy i skopiuj wszystkie artefakty inne niż Java, które znajdują się pod nimi, srcale muszą być dostępne w czasie wykonywania (np. Właściwości, pliki XML itp.):

<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

Utwórz samą WOJNĘ:

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

Rozmieścić

Na koniec możesz skonfigurować zadanie, aby wdrożyć WAR bezpośrednio w lokalizacji wdrożenia Tomcat:

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

Kliknij i gotowe!

Gdy wszystko zostanie skonfigurowane, po prostu uruchom defaultcel z Eclipse, aby skompilować, WOJNA i wdrożyć rozwiązanie.

Zaletą tego podejścia jest to, że będzie działać poza Eclipse, a także w Eclipse i może być używane do łatwego udostępniania strategii wdrażania (np. Poprzez kontrolę źródła) innym programistom, którzy również pracują nad Twoim projektem.

Zawsze wybierałem Export from Eclipse. Tworzy plik wojenny i zawiera wszystkie niezbędne pliki. Zakładając, że utworzyłeś projekt jako projekt internetowy, to wszystko, co musisz zrobić. Eclipse sprawia, że ​​jest to bardzo proste.

Używamy Mavena (starszego brata Anta) do wszystkich naszych projektów java i ma on bardzo fajną wtyczkę WAR. Można tam znaleźć tutoriale i sposób użycia.

Jest dużo łatwiejszy niż Ant, w pełni kompatybilny z Eclipse (użyj maven eclipse: eclipse do tworzenia projektów Eclipse) i łatwy w konfiguracji.

Strona główna Mavena

Wtyczka Maven WAR

Przykładowa konfiguracja:

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

Plik wojenny to po prostu plik jar z rozszerzeniem war, ale to, co sprawia, że ​​działa, to faktyczna struktura zawartości.

Samouczek J2EE / Java EE może być początkiem:

http://java.sun.com/j2ee/tutorial/1_3-fcs/doc/WebComponents3.html

A specyfikacja serwletu zawiera krwawe szczegóły:

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

Jeśli utworzysz nowy projekt internetowy w Eclipse (mam na myśli wersję Java EE), struktura zostanie utworzona dla Ciebie i możesz również powiedzieć, gdzie jest zainstalowany Twój Appserver, a on wdroży i uruchomi aplikację za Ciebie.

Użycie opcji „Eksportuj-> plik WAR” pozwoli Ci zapisać plik wojny.

Jeśli nie masz pewności, co robić i zaczynasz od zera, Maven może Ci pomóc.

Postępując zgodnie z poniższymi krokami, możesz idealnie skonfigurować nowy projekt wojenny w czasie zaćmienia.

1. Pobierz i zainstaluj Maven
2. Przejdź do wiersza poleceń, uruchom: mvn archetype:generate
3. Postępuj zgodnie z wyświetlanymi instrukcjami - wybierz prosty projekt WWW w języku Java (18) i odpowiednią nazwę.
4. Po zakończeniu uruchom: mvn eclipse:eclipse
5. Uruchom Eclipse. Wybierz Plik -> Importuj -> Istniejący projekt. Wybierz katalog, w którym uruchomiłeś cele mvn.
6. To wszystko, powinieneś mieć teraz bardzo dobry początek projektu wojennego w czasie zaćmienia
7. Możesz stworzyć samą wojnę, uruchamiając ją mvn packagelub wdrażając, konfigurując serwer w eclipse i po prostu dodając projekt do serwera.

Jak niektórzy powiedzieli, wadą używania mavena jest to, że musisz używać konwencji mavena. Ale myślę, że jeśli dopiero zaczynasz, nauczenie się konwencji to dobry pomysł, zanim zaczniesz tworzyć własne. Nic nie powstrzyma Cię później przed zmianą / refaktoryzacją do własnej preferowanej metody.

Mam nadzieję że to pomoże.

Użyj zadania Wojna mrówek

Użyj kodu kompilacji Ant Używam tego dla mojego projektu 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>

Inną opcją byłoby automatyczne zbudowanie go za pomocą Eclipse. Oczywiście jeśli masz środowisko ciągłej integracji polecamy Ant lub Maven. Alternatywa eksportu nie jest zbyt wygodna, ponieważ za każdym razem musisz konfigurować właściwości eksportu.

KROKI:

1. Włącz obsługę „archiwów projektów”; może to zależeć od twojego projektu (użyłem go w projekcie Java EE / Web). Kliknij prawym przyciskiem myszy katalog główny projektu; Konfiguruj -> Dodaj obsługę archiwów projektu.

2. Idź i utwórz nowe archiwum w katalogu głównym „Project Archives”. Masz tylko opcję jar, ale nazwa archiwum * .war.

3. Skonfiguruj zestawy plików, tj. Jakie pliki mają zostać dołączone. Typowa jest konfiguracja dwóch zestawów plików w sposób podobny do konfiguracji Web Deployment Assembly (właściwości projektu).

   • copy / WebContent to /
   • skopiuj / build / classes do WEB-INF / classes (utwórz ten zestaw plików po zdefiniowaniu katalogu WEB-INF / classes w archiwum)

4. Może być konieczne zmodyfikowanie właściwości wykluczania zestawu plików w zależności od tego, gdzie umieściłeś niektóre pliki konfiguracyjne lub możesz potrzebować więcej zestawów plików, ale pomysł jest taki, że po skonfigurowaniu nie musisz go zmieniać.

5. Zbuduj archiwum ręcznie lub opublikuj bezpośrednio na serwerze; ale jest również automatycznie tworzony przez Eclipse

Inną powszechną opcją jest gradle.

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

Aby zbudować plik wojenny w aplikacji internetowej:

W pliku build.gradle dodaj:

apply plugin: 'war'

Następnie:

./gradlew war

Użyj układu z zaakceptowanej odpowiedzi powyżej.

Użyj następującego polecenia poza folderem WEB-INF. To powinno stworzyć plik wojenny i jest najszybszą metodą, jaką znam.

(Będziesz potrzebował zainstalowanego JDK 1.7+ i zmiennych środowiskowych wskazujących na katalog bin twojego JDK.)

jar -cvf projectname.war *

Link referencyjny

Prostsze rozwiązanie, które również odświeża przestrzeń roboczą Eclipse:

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

Uproszczony kod powłoki do tworzenia plików WAR ze standardowego dynamicznego projektu internetowego Eclipse. Używa systemu plików RAM (/ dev / shm) na platformie Linux.

#!/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

** Tworzenie pliku War w projekcie internetowym Eclips Gaynemed of Grails **

1. Importuj projekt:

2. Zmień plik datasource.groovy

Na przykład: url = "jdbc: postgresql: //18.247.120.101: 8432 / PGMS"

2. zmień AppConfig.xml

3. zabić Java z Menedżera zadań:

4. uruchom czyste polecenie w zaćmieniach

5. uruchom „wojnę prod” obsługiwaną przez nazwę projektu.

6. Sprawdź plik dziennika i znajdź ten sam plik .war w katalogu Workbencha z tą samą datą.