Jak tworzyć pliki wojenne

Zawsze wybierałem eksport z Eclipse. Buduje plik wojny i zawiera wszystkie niezbędne pliki. Pod warunkiem, że stworzyłeś projekt jako projekt internetowy, to wszystko, co musisz zrobić. Eclipse sprawia, że jest to bardzo proste do zrobienia.

Używamy Mavena (starszego brata Anta) do wszystkich naszych projektów java, i ma bardzo sprytną wtyczkę wojenną. Tutoriale i użycie można znaleźć tam.

Strona główna Mavena

Maven WAR plugin

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 war jest po prostu plikiem jar z rozszerzeniem war, ale to, co sprawia, że działa, to sposób, w jaki zawartość jest faktycznie zorganizowana.

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

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

A Specyfikacja Servleta zawiera gory szczegoly:

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

Jeśli stworzysz nowy projekt WWW w Eclipse (mam na myśli Java EE wersja), struktura jest stworzona dla Ciebie i możesz również powiedzieć, gdzie jest zainstalowany Appserver i wdroży i uruchomi aplikację dla Ciebie.

Użycie opcji "Export- > plik wojenny" pozwoli Ci zapisać plik wojenny.

Jeśli nie jesteś pewien, co robić i zaczynasz od zera, Maven może pomóc Ci zacząć.

Wykonując poniższe kroki możesz uzyskać nową konfigurację projektu wojennego w eclipse.

1. Pobierz i zainstaluj Maven
2. Uruchom wiersz poleceń: mvn archetype:generate
3. wykonaj odpowiednie kroki-wybierz prosty projekt java web (18) i odpowiednią nazwę.
4. po zakończeniu uruchom: mvn eclipse:eclipse
5. Rozpocznij Eclipse. Wybierz Plik - > Importuj - >Istniejący projekt. Wybierz katalog, w którym uruchomiłeś bramki mvn.
6. to jest to, powinieneś teraz mieć bardzo dobry początek projektu wojennego w eclipse
7. możesz stworzyć samą wojnę uruchamiając mvn package lub wdrożyć ją poprzez skonfigurowanie serwera w eclipse i po prostu dodanie projektu do serwera.

Jak niektórzy inni mówili minusem korzystania z Mavena jest to, że musisz używać konwencji Mavena. Ale myślę, że jeśli dopiero zaczynasz, uczysz się konwencje to dobry pomysł, zanim zaczniesz tworzyć własne. Nic nie powstrzyma cię przed zmianą / refaktoryzacją na preferowaną metodę w późniejszym momencie.

Użyj zadania Ant war

Użyj kodu budowy ant Używam tego do 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 zbudowanie go automatycznie przy użyciu Eclipse. Oczywiście jeśli masz ciągłą integrację środowiska Ant lub Maven jest zalecane. Alternatywa eksportu nie jest zbyt wygodna, ponieważ musisz każdorazowo konfigurować właściwości eksportu.

kroki:

1. Włącz obsługę "Archiwum projektów"; może to zależeć od Twojego projektu(użyłem go w Java EE / Web project). Kliknij prawym przyciskiem myszy główny katalog projektu; Konfiguracja - > Dodaj archiwa projektu Wsparcie.

2. Idź i utwórz nowe archiwum w" archiwum projektu " Top reż. Masz tylko opcję jar, ale podaj nazwę archiwum*.wojna.

3. Konfiguracja Fileset-s, czyli jakie pliki mają być dołączone. Typowe jest skonfigurowanie dwóch zestawów plików podobnych do konfiguracji Web Deployment Assembly (właściwość project).

   • 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. W zależności od tego, gdzie umieściłeś niektóre pliki konfiguracyjne, być może będziesz musiał dodać tweeta do właściwości fileset exclude lub potrzebujesz więcej zestawów plików, ale chodzi o to, że po skonfigurowaniu tej właściwości nie musisz jej zmieniać.

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

Inną powszechną opcją jest gradle.

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

Aby zbudować plik wojny w aplikacji internetowej:

W budowie.gradle, dodaj:

apply plugin: 'war'

Wtedy:

./gradlew war

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

Prostsze rozwiązanie odświeżające również obszar roboczy 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 wojennych ze standardowego projektu Eclipse dynamic Web. 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

Użyj tego polecenia poza folderem WEB-INF. To powinno stworzyć Twój plik wojenny. To najszybsza metoda jaką znam.

Będziesz potrzebował zainstalowanego JDK 1.7+ i zmiennych środowiskowych, które wskazują na katalog bin twojego JDK.

jar -cvf projectname.war *

Link Referencyjny

**Making War file in Eclips Gaynemed of grails web project * *

1.Import projektu:

2.Zmień źródło danych.groovy file

Like this: url= "JDBC: postgresql: / / 18.247.120.101: 8432 / PGMS"

2.chnge AppConfig.xml

3.Zabij Javę z Menedżera zadań:

1. Uruchom clean comand w eclips

2. Uruchom "prod war" pod nazwą projektu.

3. Sprawdź plik dziennika i znajdź to samo .plik war w katalogu stół warsztatowy z tą samą datą.