Comment créer des fichiers de guerre

Question

Quelles sont les meilleures pratiques en matière de création de fichiers war (avec eclipse) à exécuter sur tomcat? des tutoriels, des liens, des exemples sont très appréciés.

Answer 1

Vous pouvez utiliser Ant pour configurer, href = "http: // ant.apache.org/manual/Tasks/war.html "rel =" noreferrer "> WAR et déployez 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:

Conditions préalables

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

Configurer

Définissez une tâche setup qui crée le répertoire de distribution et copie tous les artefacts devant être détruits 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>

Compiler

Construisez vos fichiers Java en classes et copiez tous les artefacts non Java résidant sous src mais devant être disponibles au moment de l'exécution (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>

Construire une guerre

Créez le fichier 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>

Déployer

Enfin, vous pouvez configurer une tâche pour déployer le fichier WAR directement dans votre emplacement de déploiement Tomcat:

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

Cliquez et c'est parti!

Une fois tout cela configuré, il vous suffit de lancer la cible par défaut à partir d'Eclipse pour compiler, WAR et déployer votre solution.

L’avantage de cette approche est qu’elle fonctionnera à la fois dans Eclipse et dans Eclipse et peut être utilisée pour partager facilement votre stratégie de déploiement (par exemple via le contrôle de source) avec d’autres développeurs travaillant également sur votre projet.

Answer 2

J'ai toujours juste sélectionné Exporter depuis Eclipse. Il construit le fichier war et inclut tous les fichiers nécessaires. Si vous avez créé le projet en tant que projet Web, il vous suffira de le faire. Eclipse le rend très simple à faire.

Answer 3

Nous utilisons Maven (le grand frère de Ant) pour tous nos projets java, et il possède un plugin WAR très astucieux. Des tutoriels et des utilisations peuvent être trouvés ici.

C’est beaucoup plus simple que Ant, entièrement compatible avec Eclipse (utilisez maven eclipse: eclipse pour créer des projets Eclipse) et facile à configurer.

page d'accueil de Maven

Maven WAR plugin

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>

Answer 4

Un fichier war est simplement un fichier jar avec une extension war, mais ce qui le rend efficace est la façon dont son 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 de Java EE), la structure est créée pour vous et vous pouvez également lui indiquer l'emplacement de votre serveur Appserver. Il déploiera et démarrera l'application pour vous. .

Utilisation du fichier "Exporter & Gt; WAR" Cette option vous permettra de sauvegarder le fichier war.

Answer 5

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 obtiendrez une nouvelle configuration de projet de guerre parfaitement en éclipse.

1. Téléchargez et installez Maven
2. Aller à la ligne de commande, exécuter: archetype mvn: générer
3. Suivez les étapes proposées - choisissez le projet Web Java simple (18) et un nom approprié.
4. Une fois l'opération terminée: mvn eclipse: eclipse
5. Lancez Eclipse. Choisissez Fichier - > Importer - > Projet existant. Sélectionnez le répertoire dans lequel vous avez exécuté les objectifs mvn.
6. Voilà, vous devriez maintenant avoir un très bon début pour un projet de guerre en éclipse
7. Vous pouvez créer la guerre elle-même en exécutant le package mvn ou la déployer en configurant un serveur dans eclipse et en ajoutant simplement le projet au serveur.

Comme d'autres l'ont déjà 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 / de refactoriser votre méthode préférée par la suite.

J'espère que cela vous aidera.

Answer 6

Utilisez la tâche de guerre contre les ant.

Answer 7

Utiliser le code de compilation ant Je l'utilise 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>

Answer 8

Une autre option serait de le construire automatiquement à l’aide d’Eclipse. Bien sûr, si vous avez 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.

ÉTAPES:

1. Activer " Archives du projet " soutien; 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 un support aux archives du projet.

2. Allez créer une nouvelle archive dans les "Archives du projet". top dir. Vous n’avez que l’option jar, mais vous nommez l’archive * .war.

3. Configurez Fileset-s, c’est-à-dire quels fichiers doivent être inclus. En règle générale, vous configurez deux ensembles de fichiers de la même manière que Web Deployment Assembly (propriété du projet).

   • copier / WebContent dans /
   • copie / build / classes dans WEB-INF / classes (créez cet ensemble de fichiers après avoir défini le répertoire WEB-INF / classes dans l'archive)

4. Vous devrez peut-être modifier la propriété d'exclusion de fichiers en fonction de l'emplacement où vous avez placé certains des fichiers de configuration ou vous aurez peut-être besoin de davantage de fichiers, mais l'idée est qu'une fois que vous avez configuré cela, vous n'avez pas besoin de le modifier. / p>

5. Construisez l’archive manuellement ou publiez directement sur le serveur; mais est également construit automatiquement pour vous par Eclipse

Answer 9

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 war

Utilisez la présentation de la réponse acceptée ci-dessus.

Answer 10

Utilisez cette commande en dehors du dossier WEB-INF. Cela devrait créer votre fichier de guerre. C'est la méthode la plus rapide que je connaisse.

Vous aurez besoin de JDK 1.7+ installé pour réaliser cet exploit et les variables d'environnement qui pointent vers le répertoire bin de votre JDK.

jar -cvf projectname.war *

Lien de référence

Answer 11

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>

Answer 12

Code Shell simpliste permettant de 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 <*>)

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

Answer 13

** Création d'un fichier de guerre dans le projet Web Eclips Gaynemed of Grails **

1.Importer le projet:

2.Changez le fichier datasource.groovy

Comme ceci: url = "jdbc: postgresql: //18.247.120.101: 8432 / PGMS"

2.chnge AppConfig.xml

3. maîtrisez Java à partir du gestionnaire de tâches:

4. lancez une commande propre dans les éclipses

5. lancez 'prod war', en fonction du nom du projet.

6. Consultez le fichier journal et trouvez le même fichier .war dans le répertoire du plan de travail avec la même date.