Come creare file war


96

Quali sono le migliori pratiche per creare file war (utilizzando eclipse) da eseguire su Tomcat? tutorial, link, esempi sono molto apprezzati.

Risposte:


98

Puoi usare Ant per impostare, compilare, WAR e distribuire la tua soluzione.

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

È quindi possibile eseguire un clic in Eclipse per eseguire tale destinazione Ant. Ecco alcuni esempi di ciascuno dei passaggi:

Presupposti

Daremo per scontato che il tuo codice sia organizzato in questo modo:

  • ${basedir}/src: File Java, proprietà, file di configurazione XML
  • ${basedir}/web: I tuoi file JSP
  • ${basedir}/web/lib: Qualsiasi JAR richiesto in fase di esecuzione
  • ${basedir}/web/META-INF: Il tuo manifest
  • ${basedir}/web/WEB-INF: I tuoi file web.xml

Impostare

Definisci setupun'attività che crei la directory di distribuzione e copi direttamente tutti gli artefatti che devono essere 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>

Compilare

Crea i tuoi file Java in classi e copia su qualsiasi artefatto non Java che risiede srcma deve essere disponibile in fase di runtime (ad esempio proprietà, file XML, ecc.):

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

Costruisci WAR

Crea la WAR stessa:

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

Distribuisci

Infine, puoi impostare un'attività per distribuire WAR direttamente nella posizione di distribuzione di Tomcat:

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

Clicca e vai!

Una volta che tutto questo è stato impostato, semplicemente lanciando l' defaultobiettivo da Eclipse compilerà, WAR e distribuirà la tua soluzione.

Il vantaggio di questo approccio è che funzionerà sia all'esterno di Eclipse che all'interno di Eclipse e può essere utilizzato per condividere facilmente la tua strategia di distribuzione (ad esempio tramite il controllo del codice sorgente) con altri sviluppatori che stanno lavorando al tuo progetto.


bene, voglio distribuirlo a Tomcat. Come devo cambiare il targer?

Potresti approfondire per favore? Finché $ {tomcat.deploydir} punta alla directory di distribuzione del contesto Tomcat, dovrebbe farlo. No?
David Citron

1
Nell'obiettivo di guerra non è necessario "<exclude name =" WEB-INF / ** "/>". Hai generato file * .class in questa cartella ed escluderli non funziona. Rimuovi questa linea di esclusione dal bersaglio di guerra che funziona.
ankitjaininfo

2
Questa risposta è inutilmente complicata.
Alex R

38

Ho sempre selezionato Esporta da Eclipse. Crea il file war e include tutti i file necessari. Se hai creato il progetto come progetto web, è tutto ciò che devi fare. Eclipse lo rende molto semplice da fare.


Grazie! e per quel che vale, seleziona "Esporta" dal menu "File", quindi in "Seleziona una destinazione di esportazione" digita "WAR" e verrà visualizzata l'opzione del file war.
Brad Parks

4
la mia scelta per app web veloci e sporche. scrivere un copione per formiche solo per ottenere un test di WAR è semplicemente troppo faticoso.
Renan

un'altra soluzione invece di creare un file ant sarebbe quella di andare nella cartella che vuoi inserire nel file WAR ed eseguire questo comando "jar -cvf name.war *".
MC

Grazie per questo, MOLTO più semplice della configurazione di Maven o Ant (quando non è necessario).
simon

23

Usiamo Maven (il fratello maggiore di Ant) per tutti i nostri progetti java e ha un plugin WAR molto ingegnoso. Qui è possibile trovare tutorial e utilizzo.

È molto più semplice di Ant, completamente compatibile con Eclipse (usa maven eclipse: eclipse per creare progetti Eclipse) e facile da configurare.

La homepage di Maven

Plugin di Maven WAR

Configurazione di esempio:

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

1
Ti ho restituito il punto (anche se non sono stato io a rimuoverlo). Maven è certamente una scelta ragionevole se ti capita (vuoi?) Di adattarti alla loro particolare versione di "convenzione sulla configurazione".
David Citron,

1
Mi è piaciuto =) Sto lavorando come CM su un progetto piuttosto grande e apprezzo il lavoro duro di configurazione del progetto fatto per me. Inoltre, il supporto per i plugin è meraviglioso. Essere in grado di avere un progetto multi-modulo attivo e funzionante con un plugin WAR, con Surefire e CheckStyle in cinque minuti è un piacere. Ant, sebbene più aperto e probabilmente più potente, è una seccatura in confronto. Ad ogni modo, Maven è un sottoinsieme di Ant, quindi se hai bisogno di fare degli script lì, sei il benvenuto.
mikek

4
Oltre alla struttura XML di Maven basata su ANT e ANT incorporata come sottoinsieme di Maven.
mikek

14

Un file war è semplicemente un file jar con un'estensione war, ma ciò che lo fa funzionare è come il contenuto è effettivamente strutturato.

Il tutorial J2EE / Java EE può essere un inizio:

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

E la specifica Servlet contiene i dettagli cruenti:

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

Se crei un nuovo progetto web in Eclipse (mi riferisco alla versione Java EE), la struttura viene creata per te e puoi anche dirgli dove è installato il tuo Appserver e distribuirà e avvierà l'applicazione per te.

Utilizzando l'opzione "Esporta-> File WAR" potrai salvare il file war.


12

Se non sei sicuro di cosa fare e stai iniziando da zero, Maven può aiutarti a iniziare.

Seguendo i passaggi seguenti puoi ottenere una nuova configurazione del progetto di guerra perfettamente in eclipse.

  1. Scarica e installa Maven
  2. Vai alla riga di comando esegui: mvn archetype:generate
  3. Segui i passaggi richiesti: scegli il semplice progetto web java (18) e un nome adatto.
  4. Quando è finito, esegui: mvn eclipse:eclipse
  5. Avvia Eclipse. Scegli File -> Importa -> Progetto esistente. Seleziona la directory in cui hai eseguito gli obiettivi mvn.
  6. Ecco, ora dovresti iniziare molto bene un progetto di guerra in Eclipse
  7. Puoi creare la guerra stessa eseguendola mvn packageo distribuendola configurando un server in eclipse e aggiungendo semplicemente il progetto al server.

Come alcuni altri hanno detto, lo svantaggio di usare Maven è che devi usare le convenzioni Maven. Ma penso che se sei appena agli inizi, imparare le convenzioni è una buona idea prima di iniziare a crearne di tue. Non c'è niente che ti impedisca di cambiare / refactoring al tuo metodo preferito in un secondo momento.

Spero che questo ti aiuti.



3

Usa il codice di build ant. Lo uso per il mio SMS di progetto

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


2

Un'altra opzione sarebbe quella di crearlo automaticamente usando Eclipse. Ovviamente se hai un ambiente di integrazione continua è consigliato Ant o Maven. L'alternativa di esportazione non è molto comoda perché bisogna configurare ogni volta le proprietà di esportazione.

PASSI:

  1. Abilita il supporto "Archivi di progetto"; questo potrebbe dipendere dal tuo progetto (l'ho usato su Java EE / progetto Web). Fare clic con il pulsante destro del mouse sulla directory principale del progetto; Configura -> Aggiungi supporto per archivi di progetto.

  2. Vai e crea un nuovo archivio nella directory superiore "Archivi del progetto". Hai solo l'opzione jar, ma il nome dell'archivio * .war.

  3. Configurare i set di file, ovvero quali file includere. Tipico è configurare due set di file in modo simile a come è configurato il Web Deployment Assembly (proprietà del progetto).

    • copia / WebContent a /
    • copia / build / classes in WEB-INF / classes (crea questo set di file dopo aver definito la directory WEB-INF / classes nell'archivio)
  4. Potrebbe essere necessario modificare la proprietà di esclusione del set di file a seconda di dove sono stati inseriti alcuni file di configurazione o potrebbe essere necessario più set di file, ma l'idea è che una volta configurato questo non è necessario modificarlo.

  5. Costruisci manualmente l'archivio o pubblicalo direttamente sul server; ma è anche creato automaticamente per te da Eclipse



2

Usa il seguente comando fuori dalla cartella WEB-INF. Questo dovrebbe creare il tuo file war ed è il metodo più veloce che conosco.

(Avrai bisogno di JDK 1.7+ installato e di variabili di ambiente che puntano alla directory bin del tuo JDK.)

jar -cvf projectname.war *

Link di riferimento


0

Soluzione più semplice che aggiorna anche l'area di lavoro di 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>

0

Codice Shell semplicistico per la creazione di file WAR da un progetto Web dinamico Eclipse standard. Utilizza il file system RAM (/ dev / shm) su una piattaforma 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

-3

** Creazione di file War nel progetto web Eclips Gaynemed of grails **

Progetto 1.Import:

2. Modificare il file datasource.groovy

In questo modo: url = "jdbc: postgresql: //18.247.120.101: 8432 / PGMS"

2.chnge AppConfig.xml

3.uccidere Java da Task Manager:

  1. eseguire il comando pulito in eclissi

  2. eseguire "prod war" consentito dal nome del progetto.

  3. Controllare il file di registro e trovare lo stesso file .war nella directory del workbench con la stessa data.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.