Comment créer des fichiers de guerre

je viens de sélectionner Export à partir D'Eclipse. Il génère le fichier war et inclut tous les fichiers nécessaires. Si 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 de Ant) pour tous nos projets java, et il a un très joli plugin WAR. Tutoriels et usage peuvent être trouvés là.

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.

Maven de la page d'accueil

Maven GUERRE plugin

Configuration De L'Échantillon:

<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 est la façon 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 Gore:

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

si vous créez un nouveau projet Web dans Eclipse (je me réfère à la version Java EE), la structure est créée pour vous et vous pouvez également lui dire où votre Applserver est installé et il se déploiera et lancera l'application pour vous.

en utilisant l'option" Exporter->fichier de guerre " vous permettra de sauvegarder le fichier de guerre.

si vous n'êtes pas sûr de savoir 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.

1. télécharger et installer Maven
2. Aller à la ligne de commande exécuter: mvn archetype:generate
3. suivez les étapes indiquées - choisir le simple java web project (18) et un nom approprié.
4. quand il est terminé, exécuter: mvn eclipse:eclipse
5. Start Eclipse. Choisissez Fichier -> Importer -> projet Existant. Sélectionnez le répertoire où vous avez exécuté l'mvn objectifs.
6. Qu'est ce que vous devriez maintenant avoir un très bon début d'une guerre de projet dans eclipse
7. vous pouvez créer la guerre elle-même en lançant mvn package ou la déployer en mettant en place un serveur dans eclipse et en ajoutant simplement ajouter le projet à la serveur.

comme d'autres ont dit l'inconvénient d'utiliser maven est que vous devez utiliser les conventions maven. Mais je pense que si vous venez juste de commencer, apprendre les conventions est une bonne idée avant de commencer à faire les vôtres. Il n'y a rien pour vous empêcher de changer/reconfigurer à votre propre méthode préférée à un moment ultérieur.

Espérons que cette aide.

Utiliser le Ant la guerre tâche

utiliser ant code de construction 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>

une autre option serait de le construire automatiquement en utilisant Eclipse. Bien sûr, si vous avez un environnement d'intégration continue Ant ou Maven est recommandé. L'exportation alternative n'est pas très pratique car vous devez configurer à chaque fois que l'exportation des propriétés.

SUIT:

1. activer" Archives de projet " support; cela pourrait dépendre de votre projet (je l'ai utilisé sur Java EE/Web project). Cliquez avec le bouton droit de la souris sur le répertoire racine du projet; configurer -> ajouter le Support des Archives du projet.

2. allez créer une nouvelle archive dans les" archives de projet". Vous n'avez que l'option jar, mais nommez votre archive *.guerre.

3. Configure Fileset-s, I. e quels fichiers inclure. La configuration typique est de configurer deux fichiers similaires à la configuration de L'assemblage de déploiement Web (propriété du projet).

   • copier /WebContent /
   • copier/construire/classes vers WEB-INF/classes (créer ce fichier après avoir défini le répertoire WEB-INF / classes dans l'archive)

4. vous pourriez avoir besoin de tweeter la propriété fileset exclude en fonction de l'endroit où vous avez placé certains fichiers de configuration ou vous pourriez avoir besoin de plus de fichiers, mais l'idée est qu'une fois que vous avez configuré ceci vous n'avez pas besoin de le changer.

5. construisez l'archive manuellement ou publiez directement sur le serveur; mais est aussi construit automatiquement pour vous par Eclipse

une autre option courante est gradle.

http://www.gradle.org/docs/current/userguide/application_plugin.html

pour construire votre fichier war dans une application web:

Dans la construction.Grad, ajouter:

apply plugin: 'war'

puis:

./gradlew war

utilisez la disposition de la réponse acceptée ci-dessus.

solution plus simple qui rafraîchit é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>

Simpliste Shell code pour la création de la GUERRE des fichiers à partir d'un standard de l'Éclipse de Projet Web dynamique. Utilise le système de fichiers RAM (/dev / shm) sur une plate-forme Linux.

#!/bin/sh

UTILITY=$(basename "151900920")

if [ -z "" ] ; then
    echo "usage: $UTILITY [-s] <web-app-directory>..."
    echo "       -s ..... With source"
    exit 1
fi

if [ "" == "-s" ] ; then
    WITH_SOURCE=1
    shift
fi

while [ ! -z "" ] ; do
    WEB_APP_DIR=

    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

utilisez cette commande en dehors du dossier WEB-INF. Cela devrait créer votre fichier war. Ce est une méthode 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

**de Faire de la Guerre de fichier dans Eclips Gaynemed de grain de projet web **

1.Projet d'importation:

2.Changer la source de données.groovy fichier

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

2.chnge AppConfig.xml

3.tuer la Java à partir du Gestionnaire des Tâches:

4. exécuter le nettoyage, le système comand dans eclips

5. run "prod war" suivi du nom du projet.

6. vérifiez le fichier journal et trouvez le même .fichier war dans le répertoire de workbench avec la même date.