Quali sono le migliori pratiche per creare file war (utilizzando eclipse) da eseguire su Tomcat? tutorial, link, esempi sono molto apprezzati.
Quali sono le migliori pratiche per creare file war (utilizzando eclipse) da eseguire su Tomcat? tutorial, link, esempi sono molto apprezzati.
Risposte:
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:
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.xmlDefinisci 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>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>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>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>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.
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.
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.
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 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.
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.
mvn archetype:generatemvn eclipse:eclipsemvn 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.
Usa il compito Ant war
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>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:
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.
Vai e crea un nuovo archivio nella directory superiore "Archivi del progetto". Hai solo l'opzione jar, ma il nome dell'archivio * .war.
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).
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.
Costruisci manualmente l'archivio o pubblicalo direttamente sul server; ma è 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 war in un'app Web:
In build.gradle, aggiungi:
apply plugin: 'war'Poi:
./gradlew warUsa il layout dalla risposta accettata sopra.
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 *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>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** 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:
eseguire il comando pulito in eclissi
eseguire "prod war" consentito dal nome del progetto.
Controllare il file di registro e trovare lo stesso file .war nella directory del workbench con la stessa data.