Quelles sont les meilleures pratiques pour créer des fichiers war (en utilisant eclipse) à exécuter sur tomcat? les tutoriels, liens, exemples sont très appréciés.
Quelles sont les meilleures pratiques pour créer des fichiers war (en utilisant eclipse) à exécuter sur tomcat? les tutoriels, liens, exemples sont très appréciés.
Réponses:
Vous pouvez utiliser Ant pour configurer, compiler, WAR et déployer votre solution.
<target name="default" depends="setup,compile,buildwar,deploy"></target>Vous pouvez ensuite exécuter un clic dans Eclipse pour exécuter cette cible Ant. Voici des exemples de chacune des étapes:
Nous supposerons que votre code est organisé comme suit:
${basedir}/src: Fichiers Java, propriétés, fichiers de configuration XML${basedir}/web: Vos fichiers JSP${basedir}/web/lib: Tous les fichiers JAR requis au moment de l'exécution${basedir}/web/META-INF: Votre manifeste${basedir}/web/WEB-INF: Vos fichiers web.xmlDéfinissez une setuptâche qui crée le répertoire de distribution et copie tous les artefacts qui doivent être WARred directement:
<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>Construisez vos fichiers Java en classes et copiez sur tous les artefacts non-Java qui résident sous srcmais doivent être disponibles au moment de l'exécution (par exemple, propriétés, fichiers XML, etc.):
<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>Créez le WAR lui-même:
<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>Enfin, vous pouvez configurer une tâche pour déployer le WAR directement dans votre emplacement de déploiement Tomcat:
<target name="deploy">
<copy file="My.war" todir="${tomcat.deploydir}" />
</target>Une fois tout cela configuré, il vous suffit de lancer la defaultcible depuis Eclipse pour compiler, WAR et déployer votre solution.
L'avantage de cette approche est qu'elle fonctionnera aussi bien en dehors d'Eclipse qu'au sein d'Eclipse et peut être utilisée pour partager facilement votre stratégie de déploiement (par exemple via le contrôle de code source) avec d'autres développeurs qui travaillent également sur votre projet.
J'ai toujours juste sélectionné Exporter depuis Eclipse. Il construit le fichier war et inclut tous les fichiers nécessaires. Fournir que vous avez créé le projet en tant que projet Web, c'est tout ce que vous aurez à faire. Eclipse le rend très simple à faire.
Nous utilisons Maven (le grand frère d'Ant) pour tous nos projets java, et il a un plugin WAR très astucieux. Vous y trouverez des didacticiels et des utilisations.
C'est beaucoup plus facile que Ant, entièrement compatible avec Eclipse (utilisez maven eclipse: eclipse pour créer des projets Eclipse) et facile à configurer.
Exemple de configuration:
<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 fichier war est simplement un fichier jar avec une extension war, mais ce qui le fait fonctionner, c'est la manière dont le contenu est réellement structuré.
Le tutoriel J2EE / Java EE peut être un début:
http://java.sun.com/j2ee/tutorial/1_3-fcs/doc/WebComponents3.html
Et la spécification Servlet contient les détails sanglants:
http://java.sun.com/products/servlet/download.html
Si vous créez un nouveau projet Web dans Eclipse (je fais référence à la version Java EE), la structure est créée pour vous et vous pouvez également lui indiquer où votre serveur d'applications est installé et il déploiera et démarrera l'application pour vous.
L'utilisation de l'option "Exporter-> Fichier WAR" vous permettra de sauvegarder le fichier war.
Si vous ne savez pas quoi faire et que vous partez de zéro, Maven peut vous aider à démarrer.
En suivant les étapes ci-dessous, vous pouvez obtenir une nouvelle configuration de projet de guerre parfaitement dans eclipse.
mvn archetype:generatemvn eclipse:eclipsemvn packageou en la déployant en configurant un serveur dans eclipse et en ajoutant simplement l'ajout du projet au serveur.Comme certains l'ont dit, l'inconvénient de l'utilisation de maven est que vous devez utiliser les conventions maven. Mais je pense que si vous débutez, apprendre les conventions est une bonne idée avant de commencer à créer les vôtres. Rien ne vous empêche de changer / refactoriser ultérieurement votre méthode préférée.
J'espère que cela t'aides.
Utilisez la tâche Ant war
Utiliser le code de construction de fourmi J'utilise ceci pour mon projet 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>Une autre option serait de le construire automatiquement en utilisant Eclipse. Bien sûr, si vous disposez d'un environnement d'intégration continue, Ant ou Maven est recommandé. L'alternative d'exportation n'est pas très pratique car vous devez configurer à chaque fois les propriétés d'exportation.
PAS:
Activer la prise en charge des "Archives de projet"; cela peut dépendre de votre projet (je l'ai utilisé sur un projet Java EE / Web). Cliquez avec le bouton droit sur le répertoire racine du projet; Configurer -> Ajouter la prise en charge des archives de projet.
Allez créer une nouvelle archive dans le répertoire supérieur "Project Archives". Vous n'avez que l'option jar, mais vous nommez archive * .war.
Configurez les ensembles de fichiers, c'est-à-dire les fichiers à inclure. Il est courant de configurer deux ensembles de fichiers de la même manière que l'assembly de déploiement Web (propriété du projet) est configuré.
Vous devrez peut-être modifier la propriété d'exclusion de l'ensemble de fichiers en fonction de l'endroit où vous avez placé certains des fichiers de configuration ou vous pourriez avoir besoin de plus d'ensembles de fichiers, mais l'idée est qu'une fois que vous avez configuré cela, vous n'avez pas besoin de le changer.
Créer l'archive manuellement ou publier directement sur le serveur; mais est également automatiquement construit pour vous par Eclipse
Une autre option courante est gradle.
http://www.gradle.org/docs/current/userguide/application_plugin.html
Pour créer votre fichier war dans une application Web:
Dans build.gradle, ajoutez:
apply plugin: 'war'Ensuite:
./gradlew warUtilisez la mise en page de la réponse acceptée ci-dessus.
Utilisez la commande suivante en dehors du dossier WEB-INF. Cela devrait créer votre fichier de guerre et c'est la méthode la plus rapide que je connaisse.
(Vous aurez besoin du JDK 1.7+ installé et des variables d'environnement qui pointent vers le répertoire bin de votre JDK.)
jar -cvf projectname.war *Solution plus simple qui actualise également l'espace de travail 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>Code Shell simpliste pour créer des fichiers WAR à partir d'un projet Web dynamique Eclipse standard. Utilise le système de fichiers RAM (/ dev / shm) sur une plate-forme 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** Création d'un fichier War dans le projet Web Eclips Gaynemed of grails **
1. projet d'importation:
2.Modifiez le fichier datasource.groovy
Comme ceci: url = "jdbc: postgresql: //18.247.120.101: 8432 / PGMS"
2.chnge AppConfig.xml
3. tuez le Java à partir du gestionnaire de tâches:
exécuter la commande propre dans les éclipses
lancez 'prod war' suivi du nom du projet.
Vérifiez le fichier journal et recherchez le même fichier .war dans le répertoire de Workbench avec la même date.