java - sacar - que es un archivo war

Cómo crear archivos war (13)

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

** Creación de archivo War en Eclips Proyecto web Gaynemed of grails **

1. Proyecto de importación:

2. Cambiar el archivo datasource.groovy

Me gusta esto: url = "jdbc: postgresql: //18.247.120.101: 8432 / PGMS"

2.chnge AppConfig.xml

3.hasta Java desde el Administrador de tareas:

ejecutar comando limpio en eclips
ejecutar ''prod war'' bajo el nombre del proyecto.
Compruebe el archivo de registro y busque el mismo archivo .war en el directorio del banco de trabajo con la misma fecha.

Código simplificado de Shell para crear archivos WAR desde 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

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 build.gradle, agregue:

apply plugin: ''war''

Entonces:

./gradlew war

Usa el diseño de la respuesta aceptada arriba.

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

PASOS:

Habilitar el soporte de "Archivos de proyecto"; esto podría depender de su proyecto (lo utilicé en el proyecto Java EE / Web). Haga clic derecho en el directorio raíz del proyecto; Configurar -> Añadir soporte de archivos de proyecto.
Vaya y cree un nuevo archivo en el directorio superior "Archivos de proyecto". Solo tiene la opción jar, pero el nombre que archiva * .war.
Configure Fileset-s, es decir, qué archivos se incluirán. Lo más habitual es configurar dos conjuntos de archivos de forma similar a cómo se configura el conjunto de implementación web (propiedad del proyecto).
- copiar / WebContent a /
- copiar / compilar / clases a WEB-INF / classes (crear este conjunto de archivos después de definir el directorio WEB-INF / classes en el archivo)
Es posible que debas modificar la propiedad de exclusión del conjunto de archivos dependiendo de dónde hayas colocado algunos de los archivos de configuración o de que necesites más conjuntos de archivos, pero la idea es que una vez que hayas configurado esto, no necesites cambiarlo.
Construya el archivo manualmente o publíquelo directamente en el servidor; pero Eclipse también lo crea automáticamente

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

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

A continuación, puede ejecutar un clic en Eclipse para ejecutar ese objetivo Ant. Aquí hay ejemplos de cada uno de los pasos:

Condiciones previas

Asumiremos que tiene su código organizado de la siguiente manera:

${basedir}/src : archivos Java, propiedades, archivos de configuración XML
${basedir}/web : sus archivos JSP
${basedir}/web/lib : cualquier JAR requerido en tiempo de ejecución
${basedir}/web/META-INF : su manifiesto
${basedir}/web/WEB-INF : sus archivos web.xml

Preparar

Defina una tarea de setup que crea el directorio de distribución y copia los artefactos que necesitan ser 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 los artefactos que no sean Java que residan bajo src pero que deban estar disponibles 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>

Build WAR

Crea la GUERRA en sí:

<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 WAR directamente en su ubicación de implementación de Tomcat:

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

Haga clic y listo!

Una vez que todo esto esté configurado, simplemente al lanzar el objetivo default desde Eclipse se compilará WAR y desplegará su solución.

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

Si no está seguro de qué hacer y está empezando 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.

Descargar e instalar Maven
Ir a la línea de comando ejecutar: mvn archetype:generate
Siga los pasos sugeridos: elija el proyecto web Java simple (18) y un nombre adecuado.
Cuando esté terminado, ejecuta: mvn eclipse:eclipse
Comience Eclipse. Elija Archivo -> Importar -> Proyecto existente. Seleccione el directorio donde ejecutó los objetivos de mvn.
Eso es todo, ahora deberías tener un muy buen comienzo para un proyecto de guerra en eclipse
Puede crear la guerra en sí ejecutando el mvn package o desplegándolo 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 debes usar las convenciones maven. Pero creo que si recién estás empezando, aprender las convenciones es una buena idea antes de comenzar a hacer las tuyas propias. No hay nada que le impida cambiar / refactorizar a su propio método preferido en un momento posterior.

Espero que esto ayude.

Siempre acabo de seleccionar Exportar desde 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 tendrá que hacer. Eclipse lo hace muy simple de hacer.

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>

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 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 de Java EE), la estructura se crea para usted y también puede indicarle dónde está instalado su Appserver y desplegará e iniciará la aplicación por usted.

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

Usa la WAR

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

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

Página de Maven

Plugin Maven WAR

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>

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

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

Link de referencia