Cómo crear archivos war

Siempre he seleccionado Exportar desde Eclipse. Construye el archivo war e incluye todos los archivos necesarios. Siempre que hayas creado el proyecto como un proyecto web, eso es todo lo que necesitas hacer. Eclipse hace que sea muy fácil de hacer.

Usamos Maven (el hermano mayor de Ant) para todos nuestros proyectos Java, y tiene un plugin de GUERRA muy ingenioso. Los tutoriales y el uso se pueden encontrar allí.

Es mucho más fácil que Ant, totalmente compatible con Eclipse (use maven eclipse:eclipse para crear proyectos de Eclipse) y fácil de configurar.

La página principal de Maven

Maven WAR plugin

Ejemplo de configuración:

<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 archivo war es simplemente un archivo jar con una extensión war, pero lo que lo hace funcionar es cómo se estructura realmente el contenido.

El tutorial J2EE / Java EE puede ser un comienzo:

Http://java.sun.com/j2ee/tutorial/1_3-fcs/doc/WebComponents3.html

Y la especificación Servlet contiene los detalles sangrientos:

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

Si crea un nuevo proyecto web en Eclipse (me refiero al Java EE versión), la estructura se crea para usted y también puede indicarle dónde está instalado su Appserver y se implementará e iniciará la aplicación por usted.

El uso de la opción "Exportar->Archivo WAR" le permitirá guardar el archivo war.

Si no está seguro de qué hacer y está comenzando desde cero, Maven puede ayudarlo a comenzar.

Siguiendo los pasos a continuación, puede obtener una nueva configuración de proyecto de guerra perfectamente en eclipse.

1. Descargar e instalar Maven
2. Ir a la línea de comandos ejecutar: mvn archetype:generate
3. Siga los pasos solicitados: elija el simple java web project (18) y un nombre adecuado.
4. Cuando se termina ejecutar: mvn eclipse:eclipse
5. Iniciar Eclipse. Elija Archivo - > Importar - >Proyecto existente. Seleccione el directorio donde ejecutó los objetivos mvn.
6. Eso es todo ahora deberías tener un muy buen comienzo para un proyecto de guerra en eclipse
7. Puede crear la guerra en sí ejecutando mvn package o implementarla configurando un servidor en eclipse y simplemente agregando agregar el proyecto al servidor.

Como algunos otros han dicho, la desventaja de usar maven es que tienes que usar las convenciones maven. Pero creo que si usted está empezando, el aprendizaje de la convenciones es una buena idea antes de empezar a hacer su propia. No hay nada que te impida cambiar / refactorizar a tu propio método preferido en un momento posterior.

Espero que esto ayude.

Usa la tarea Ant war

Utilice el código de compilación ant Yo uso esto para mi proyecto 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>

Otra opción sería construirlo automáticamente usando Eclipse. Por supuesto, si tiene un entorno de integración continua, se recomienda Ant o Maven. La alternativa de exportación no es muy conveniente porque tiene que configurar cada vez que las propiedades de exportación.

PASOS:

1. Habilite el soporte para "Archivos de proyecto"; esto podría depender de su proyecto (lo usé en Java EE/Web project). Haga clic derecho en el directorio raíz del proyecto; Configure - > Add Project Archives Apoyo.

2. Vaya y cree un nuevo archivo en el directorio superior" Archivos del proyecto". Solo tiene la opción jar, pero el nombre que archive*.guerra.

3. Configure Fileset-s, es decir, qué archivos se incluirán. Lo típico es configurar dos conjuntos de archivos de forma similar a cómo se configura el Ensamblaje de implementación web (propiedad del proyecto).

   • copiar / contenido web a /
   • copie/build / classes a WEB-INF/classes (cree este conjunto de archivos después de definir el directorio WEB-INF/classes en el archivo)

4. Es posible que necesite tweek la propiedad fileset exclude dependiendo de dónde colocó algunos de los archivos de configuración o puede que necesite más conjuntos de archivos, pero la idea es que una vez que haya configurado esto no necesita cambiarlo.

5. Compile el archivo manualmente o publique directamente en el servidor; pero también se compila automáticamente para usted por Eclipse

Otra opción común es gradle.

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

Para construir su archivo war en una aplicación web:

En construcción.gradle, añadir:

apply plugin: 'war'

Entonces:

./gradlew war

Utilice el diseño de la respuesta aceptada anterior.

Solución más sencilla que también actualiza el espacio de trabajo de 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>

Código de shell simplista para crear archivos WAR a partir de un proyecto web dinámico Eclipse estándar. Utiliza el sistema de archivos RAM (/dev / shm) en una plataforma 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

Utilice este comando fuera de la carpeta WEB-INF. Esto debería crear tu archivo war. Este es el método más rápido que conozco.

Necesitará JDK 1.7+ instalado para lograr esta hazaña y las variables de entorno que apuntan al directorio bin de su JDK.

jar -cvf projectname.war *

Enlace De Referencia

* * Haciendo archivo War en Eclips Gaynemed of grails web project * *

1.Proyecto de importación:

2.Cambie el origen de datos.groovy file

Así:url="jdbc: postgresql://18.247.120.101: 8432 / PGMS"

2.chnge AppConfig.xml

3.matar a Java desde el Administrador de tareas:

1. Ejecutar comando limpio en eclips

2. Ejecutar 'prod war' seguido por el nombre del proyecto.

3. Compruebe el archivo de registro y encuentre el mismo .archivo war en el directorio de banco de trabajo con la misma fecha.