Cómo crear archivos de guerra

96

¿Cuáles son las mejores prácticas para crear archivos war (usando eclipse) para ejecutar en tomcat? tutoriales, enlaces, ejemplos son muy apreciados.


fuente

Respuestas:

98

Puede utilizar Ant para configurar, compilar, WAR e implementar su solución.

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

Luego puede ejecutar un clic en Eclipse para ejecutar ese objetivo Ant. A continuación, se muestran ejemplos de cada uno de los pasos:

Condiciones previas

Asumiremos que tiene su código organizado como:

  • ${basedir}/src: Archivos Java, propiedades, archivos de configuración XML
  • ${basedir}/web: Sus archivos JSP
  • ${basedir}/web/lib: Cualquier JAR necesario en tiempo de ejecución
  • ${basedir}/web/META-INF: Tu manifiesto
  • ${basedir}/web/WEB-INF: Sus archivos web.xml

Preparar

Defina una setuptarea que cree el directorio de distribución y copie cualquier artefacto que necesite WARred directamente:

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

Compilar

Cree sus archivos Java en clases y copie cualquier artefacto que no sea de Java que resida debajo srcpero que deba estar disponible en tiempo de ejecución (por ejemplo, propiedades, archivos 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>

Construye WAR

Crea el propio WAR:

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

Desplegar

Finalmente, puede configurar una tarea para implementar el WAR directamente en su ubicación de implementación de Tomcat:

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

¡Haz clic y listo!

Una vez que todo esto esté configurado, simplemente ejecutando el defaultobjetivo desde Eclipse compilará, WAR e implementará su solución.

La ventaja de este enfoque es que funcionará tanto fuera de Eclipse como dentro de Eclipse y se puede utilizar para compartir fácilmente su estrategia de implementación (por ejemplo, a través del control de código fuente) con otros desarrolladores que también están trabajando en su proyecto.

David Citron
fuente
bueno, quiero implementarlo en tomcat. ¿Cómo debo cambiar el destino?
¿Podría darnos más detalles? Siempre que $ {tomcat.deploydir} apunte a su directorio de implementación de contexto de Tomcat, debería hacerlo. ¿No?
David Citron
1
En el objetivo de guerra hay innecesario '<exclude name = "WEB-INF / **" />'. Ha generado archivos * .class en esta carpeta y excluirlos no funciona. Elimina esta línea de exclusión del objetivo de guerra en el que funciona.
ankitjaininfo
2
Esta respuesta es innecesariamente complicada.
Alex R
38

Siempre he seleccionado Exportar de Eclipse. Construye el archivo war e incluye todos los archivos necesarios. Siempre que haya creado el proyecto como un proyecto web, eso es todo lo que necesita hacer. Eclipse lo hace muy sencillo de hacer.

Software mecánico
fuente
¡Gracias! y por lo que vale, seleccione "Exportar" del menú "Archivo", luego en "Seleccionar un destino de exportación" escriba "WAR" y aparecerá la opción de archivo de guerra.
Brad Parks
4
mi elección para aplicaciones web rápidas y sucias. escribir un script de hormiga solo para obtener un WAR de prueba es demasiado trabajo.
Renan
otra solución en lugar de crear un archivo ant sería ir a la carpeta que desea ajustar en el archivo WAR y ejecutar este comando "jar -cvf name.war *".
MC
Gracias por esto, MUCHO más simple que configurar Maven o Ant (cuando no es necesario).
Simon
23

Usamos Maven (el hermano mayor de Ant) para todos nuestros proyectos java, y tiene un complemento WAR muy ingenioso. Allí se pueden encontrar tutoriales y uso.

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.

Página de inicio de Maven

Complemento WAR de Maven

Configuración de muestra:

<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>
mikek
fuente
1
Te devolví tu punto (aunque no fui yo quien lo eliminó). Maven es sin duda una opción razonable si le sucede (¿quiere?) Encajar en su versión particular de "convención sobre configuración".
David Citron
1
Resulta que me gusta =) Estoy trabajando como CM en un proyecto bastante grande, y agradezco que me hayan hecho el trabajo duro de la configuración del proyecto. Además, el soporte de complementos es maravilloso. Poder tener un proyecto de varios módulos en funcionamiento con un complemento WAR, con Surefire y CheckStyle en cinco minutos es un placer. Ant, aunque más abierta y posiblemente más poderosa, es una molestia en comparación. De todos modos, Maven es un subconjunto de Ant, por lo que si necesita hacer algún script allí, es bienvenido.
mikek
4
Además, la estructura XML de Maven se basa en ANT, y ANT se incorpora como un subconjunto de Maven.
Mikek
14

Un archivo war es simplemente un archivo jar con una extensión war, pero lo que lo hace funcionar es cómo está estructurado el contenido.

El tutorial de J2EE / Java EE puede ser un comienzo:

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

Y la especificación de Servlet contiene los detalles sangrientos:

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

Si crea un nuevo proyecto web en Eclipse (me refiero a la versión Java EE), la estructura se crea para usted y también puede decirle dónde está instalado su servidor de aplicaciones 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.

boxofrats
fuente
12

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. Descarga e instala Maven
  2. Vaya a la línea de comando ejecutar: mvn archetype:generate
  3. Siga los pasos indicados: elija el proyecto web java simple (18) y un nombre adecuado.
  4. Cuando haya terminado, ejecute: mvn eclipse:eclipse
  5. Inicie 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í ejecutándola mvn packageo desplegándola configurando un servidor en eclipse y simplemente agregando y agregando el proyecto al servidor.

Como han dicho otros, la desventaja de usar maven es que debes usar las convenciones de maven. Pero creo que si recién está comenzando, aprender las convenciones es una buena idea antes de comenzar a hacer las suyas propias. No hay nada que le impida cambiar / refactorizar a su propio método preferido en un momento posterior.

Espero que esto ayude.

Pablojim
fuente
3

Use el código de compilación de ant. Lo uso 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>

SMS
fuente
2

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 tienes que configurar cada vez las propiedades de exportación.

PASOS:

  1. Habilitar la compatibilidad con "Archivos del proyecto"; esto podría depender de su proyecto (lo usé en el proyecto Java EE / Web). Haga clic con el botón derecho en el directorio raíz del proyecto; Configurar -> Agregar soporte de archivos del proyecto.

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

  3. Configure conjuntos de archivos, es decir, qué archivos se incluirán. Lo habitual es configurar dos conjuntos de archivos de forma similar a como se configura el ensamblado de implementación web (propiedad del proyecto).

    • copiar / WebContent a /
    • copiar / build / classes en WEB-INF / classes (cree este conjunto de archivos después de definir el directorio WEB-INF / classes en el archivo)
  4. Es posible que deba modificar la propiedad de exclusión del conjunto de archivos dependiendo de dónde colocó algunos de los archivos de configuración o es posible que necesite más conjuntos de archivos, pero la idea es que una vez que haya configurado esto, no es necesario que lo cambie.

  5. Cree el archivo manualmente o publíquelo directamente en el servidor; pero también lo crea automáticamente Eclipse

arpadf
fuente
2

Utilice el siguiente comando fuera de la carpeta WEB-INF. Esto debería crear su archivo de guerra y es el método más rápido que conozco.

(Necesitará tener JDK 1.7+ instalado y variables de entorno que apunten al directorio bin de su JDK).

jar -cvf projectname.war *

Link de referencia

XChikuX
fuente
0

Solución más simple 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>
Alex R
fuente
0

Código Shell simplista para crear archivos WAR a partir de un proyecto web dinámico estándar de Eclipse. 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
Joe Horvath
fuente
-3

** Archivo Making War en el proyecto web Eclips Gaynemed of Grails **

1.Proyecto de importación:

2.Cambie el archivo datasource.groovy

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

2.cambiar AppConfig.xml

3.matar Java desde el Administrador de tareas:

  1. ejecutar comando limpio en eclips

  2. ejecutar 'prod war' con el permiso del nombre del proyecto.

  3. Compruebe el archivo de registro y busque el mismo archivo .war en el directorio de workbench con la misma fecha.

Ratnesh Kumar
fuente