Come creare file di guerra
https://stackoverflow.com/questions/1001714
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Quali sono le migliori pratiche per creare file di guerra (usando eclipse) da eseguire su Tomcat? tutorial, collegamenti, esempi sono molto apprezzati.
Soluzione
Puoi utilizzare Ant per impostare, compilare, WAR e distribuisci la tua soluzione.
<target name="default" depends="setup,compile,buildwar,deploy"></target>
È quindi possibile eseguire un clic in Eclipse per eseguire quel target Ant. Ecco alcuni esempi di ciascuno dei passaggi:
Presupposti
Supponiamo che tu abbia il tuo codice organizzato come:
-
$ {basedir} / src: file Java, proprietà, file di configurazione XML -
$ {basedir} / web: i tuoi file JSP -
$ {basedir} / web / lib: eventuali JAR richiesti in fase di esecuzione -
$ {basedir} / web / META-INF: manifest -
$ {basedir} / web / WEB-INF: i tuoi file web.xml
Imposta
Definisci un'attività setup che crea la directory di distribuzione e copia tutti gli artefatti che devono essere WARred direttamente:
<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>
Compila
Crea i tuoi file Java in classi e copiali su tutti gli artefatti non Java che risiedono in src ma devono essere disponibili in fase di esecuzione (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>
Build WAR
Crea lo stesso WAR:
<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>
Deploy
Infine, è possibile impostare un'attività per distribuire il WAR direttamente nella posizione di distribuzione di Tomcat:
<target name="deploy">
<copy file="My.war" todir="${tomcat.deploydir}" />
</target>
Fai clic e vai!
Una volta impostato tutto questo, semplicemente lanciando il target default da Eclipse compilerà, WAR e distribuirà la tua soluzione.
Il vantaggio di questo approccio è che funzionerà all'esterno di Eclipse e all'interno di Eclipse e può essere utilizzato per condividere facilmente la strategia di distribuzione (ad esempio tramite il controllo del codice sorgente) con altri sviluppatori che stanno lavorando anche al progetto.
Altri suggerimenti
Ho sempre selezionato Esporta da Eclipse. Crea il file di guerra e include tutti i file necessari. A condizione che tu abbia creato il progetto come progetto web, è tutto ciò che devi fare. Eclipse rende tutto molto semplice.
Usiamo Maven (il fratello maggiore di Ant) per tutti i nostri progetti java, e ha un plugin WAR molto elegante. Tutorial e utilizzo sono disponibili qui.
È molto più semplice di Ant, completamente compatibile con Eclipse (usa maven eclipse: eclipse per creare progetti Eclipse) e facile da configurare.
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>
Un file di guerra è semplicemente un file jar con estensione di guerra, ma ciò che lo fa funzionare è come il contenuto è effettivamente strutturato.
Il tutorial E2 J2EE / Java può essere un inizio:
http://java.sun.com/j2ee/ tutorial / 1_3-FCS / doc / WebComponents3.html
E la specifica Servlet contiene i dettagli gory:
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 verrà distribuito e avvia l'applicazione per te .
Uso del file " Export- > WAR " L'opzione ti permetterà di salvare il file di guerra.
Se non sei sicuro di cosa fare e stai ricominciando da zero, allora Maven può aiutarti a iniziare.
Seguendo i passaggi seguenti puoi ottenere una nuova configurazione del progetto di guerra perfettamente in eclissi.
- Scarica e installa Maven
- Esegui la riga di comando:
mvn archetype: generate - Seguire i passaggi richiesti: scegliere il semplice progetto Web Java (18) e un nome adatto.
- Al termine, esegui:
mvn eclipse: eclipse - Avvia Eclipse. Scegli File - > Importa - > Progetto esistente. Seleziona la directory in cui hai eseguito gli obiettivi mvn.
- Ecco, ora dovresti iniziare molto bene un progetto di guerra in eclissi
- Puoi creare la guerra stessa eseguendo
pacchetto mvno distribuirla configurando un server in eclipse e semplicemente aggiungendo l'aggiunta del progetto al server.
Come altri hanno già detto, il lato negativo dell'utilizzo di Maven è che devi usare le convenzioni di Mavé. Ma penso che se hai appena iniziato, imparare le convenzioni è una buona idea prima di iniziare a fare le tue. Non c'è nulla che possa impedirti di cambiare / refactoring al tuo metodo preferito in un secondo momento.
Spero che questo aiuti.
Usa il codice build ant Lo uso per il mio progetto 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>
Un'altra opzione sarebbe quella di costruirlo automaticamente usando Eclipse. Naturalmente, se si dispone di un ambiente di integrazione continua, si consiglia Ant o Maven. L'alternativa di esportazione non è molto conveniente perché devi configurare ogni volta le proprietà di esportazione.
STEPS:
-
Abilita " Archivi progetto " supporto; 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 agli archivi di progetto.
-
Vai e crea un nuovo archivio in " Archivi progetto " top dir. Hai solo l'opzione jar, ma assegna un nome all'archivio * .war.
-
Configura Fileset-s, ovvero quali file includere. Tipico è configurare due set di file in modo simile alla configurazione di Web Deployment Assembly (proprietà del progetto).
- copia / WebContent in /
- copia / build / classes in WEB-INF / classes (crea questo set di file dopo aver definito la directory WEB-INF / classes nell'archivio)
-
Potrebbe essere necessario modificare la proprietà di esclusione del set di file a seconda della posizione in cui sono stati posizionati alcuni file di configurazione o potrebbero essere necessari più set di file, ma l'idea è che una volta configurato questo non è necessario modificarlo.
- / p>
-
Crea l'archivio manualmente o pubblica direttamente sul server; ma viene anche creato automaticamente per te da Eclipse
Un'altra opzione comune è Gradle.
http://www.gradle.org/docs/current/userguide /application_plugin.html
Per creare il tuo file di guerra in un'app Web:
In build.gradle, aggiungi:
apply plugin: 'war'
Quindi:
./gradlew war
Utilizza il layout dalla risposta accettata sopra.
Utilizzare questo comando al di fuori della cartella WEB-INF. Questo dovrebbe creare il tuo file di guerra. Questo è un metodo più veloce che conosco.
Avrai bisogno di JDK 1.7+ installato per raggiungere questa impresa e le variabili d'ambiente che puntano alla directory bin del tuo JDK.
jar -cvf projectname.war *
Soluzione più semplice che aggiorna anche l'area di lavoro 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>
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 <*>)
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
** Creazione del file di guerra in Eclips Gaynemed del progetto web Grails **
1.Importa progetto:
2.Cambia il file datasource.groovy
In questo modo: url = " jdbc: postgresql: //18.247.120.101: 8432 / PGMS "
2.chnge AppConfig.xml
3.kill Java da Task Manager:
-
esegui il comando clean in eclips
-
esegui 'prod war' imitato dal nome del progetto.
-
Controlla il file di registro e trova lo stesso file .war nella directory di workbench con la stessa data.
