Cómo crear archivos de guerra

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

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.

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.

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>

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.

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.

Usa la tarea Ant war

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>

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

Otra opción común es gradle.

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

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

En build.gradle, agregue:

apply plugin: 'war'

Luego:

./gradlew war

Utilice el diseño de la respuesta aceptada anterior.

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

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>

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

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

4. ejecutar comando limpio en eclips

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

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