Comment créer des fichiers war

Vous pouvez utiliser Ant à configurer, compiler, La GUERRE, et le déploiement de votre solution.

<target name="default" depends="setup,compile,buildwar,deploy"></target>

Vous pouvez alors exécuter un clic dans Eclipse exécuter la cible Ant. Voici des exemples de chacune des étapes:

Conditions préalables

Nous allons supposer que vous avez votre code organisés comme:

• ${basedir}/src: Fichiers Java, les propriétés des fichiers de configuration XML
• ${basedir}/web: Vos fichiers JSP
• ${basedir}/web/lib: Tous les Pots nécessaires à l'exécution
• ${basedir}/web/META-INF: Votre manifeste
• ${basedir}/web/WEB-INF: Votre web.xml fichiers

Configurer

Définir un setup tâche qui crée le répertoire de distribution et des copies de tous les artefacts qui doivent être Affrontés 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

Construire vos fichiers Java dans les classes et les copier sur un non-Java des objets qui se trouvent sous src mais doivent être disponibles au moment de l'exécution (par exemple, des propriétés, des 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 la GUERRE

Créer de la GUERRE elle-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 de déploiement de la GUERRE directement dans votre Tomcat déployer emplacement:

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

Et cliquez sur go!

Une fois que tout cela est mis en place, il suffit de lancer la default cible à partir d'Eclipse pour compiler, de la GUERRE, et le déploiement de votre solution.

L'avantage de cette approche est qu'il fonctionne en dehors d'Eclipse ainsi que dans Eclipse et peut être utilisé pour partager facilement votre stratégie de déploiement (par exemple, via le contrôle de la source) avec d'autres développeurs, qui travaillent également sur votre projet.

Nous utiliser Maven (Ant grand frère) pour tous nos projets java, et elle a un très chouette GUERRE plugin. Des tutoriels et de l'utilisation qui peut être trouvé là.

C'est beaucoup plus facile que la Fourmi, entièrement compatible avec Eclipse (utiliser maven eclipse:eclipse pour créer des projets Eclipse) et facile à configurer.

Maven de la page d'accueil

Maven GUERRE 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>

Si vous n'êtes pas sûr de quoi faire et commence à partir de zéro alors Maven peut vous aider à obtenir commencé.

En suivant la procédure ci-dessous, vous pouvez obtenir une nouvelle guerre de configuration de projet parfaitement dans eclipse.

1. Télécharger et installer Maven
2. Aller de la ligne de commande exécuter: mvn archetype:generate
3. Suivre l'invité étapes - le choix de la simple java web du projet (18) et un nom approprié.
4. Lorsqu'elle est terminée, exécutez: mvn eclipse:eclipse
5. Début De L'Éclipse. Choisissez Fichier -> Import -> projet Existant. Sélectionnez le répertoire où vous avez exécuté l'mvn objectifs.
6. C'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 de la guerre elle-même en exécutant mvn package ou de le déployer par la mise en place d'un serveur dans eclipse et simplement en ajoutant des ajoutant des le projet sur le serveur.

Comme certains l'ont dit, l'inconvénient de l'utilisation de maven est que vous devez utiliser les conventions de maven. Mais je pense que si vous êtes commencer juste dehors, l'apprentissage des conventions est une bonne idée avant de vous commencer à faire vos propres. Il n'y a rien pour vous empêcher de vous changer/refactoring à votre propre méthode préférée à un moment plus tard.

Espère que cette aide.

Utiliser ant code
- Je l'utiliser 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 est de gradle.

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

Pour construire votre fichier war dans une application web:

Dans la construction.gradle, ajouter:

apply plugin: 'war'

Alors:

./gradlew war

Utiliser la mise en page à partir accepté la réponse ci-dessus.

Solution plus simple qui actualise également le workspace 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>

**De faire de la Guerre de fichier dans Eclips Gaynemed de grain de projet web **

1.Projet d'importation:

2.Modifier 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:

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

2. run 'prod guerre" fowllowed par nom de projet.

3. Consultez le fichier journal et trouvez le même .fichier war dans le répertoire de workbench avec la même date.