Cómo crear archivos de guerra
https://stackoverflow.com/questions/1001714
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
¿Cuáles son las mejores prácticas para crear archivos de guerra (usando eclipse) para ejecutar en tomcat? tutoriales, enlaces, ejemplos son muy apreciados.
Solución
Puede usar Ant para configurar, compilar, WAR , e implementa su solución.
<target name="default" depends="setup,compile,buildwar,deploy"></target>
Luego 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 como:
-
$ {basedir} / src: archivos Java, propiedades, archivos de configuración XML -
$ {basedir} / web: sus archivos JSP -
$ {basedir} / web / lib: cualquier JAR requerido en el tiempo de ejecución -
$ {basedir} / web / META-INF: Su manifiesto -
$ {basedir} / web / WEB-INF: sus archivos web.xml
Configurar
Defina una tarea setup que cree el directorio de distribución y copie cualquier artefacto que necesite ser WARR 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 sobre cualquier artefacto que no sea Java que resida bajo src pero que necesite 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 la propia GUERRA:
<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>
Implementar
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>
¡Haz clic y listo!
Una vez configurado todo esto, simplemente iniciando el 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 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.
Otros consejos
Siempre he seleccionado 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.
Usamos Maven (el hermano mayor de Ant) para todos nuestros proyectos Java, y tiene un complemento WAR muy ingenioso. Tutoriales y 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.
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 se estructura realmente 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 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 Appserver e implementará e iniciará la aplicación por usted .
Utilizando el " Exportar > archivo WAR " La opción te permitirá guardar el archivo war.
Si no está seguro de qué hacer y está empezando desde cero, Maven puede ayudarlo a comenzar.
Siguiendo los pasos a continuación puedes obtener una nueva configuración de proyecto de guerra perfectamente en eclipse.
- Descargue e instale Maven
- Ir a la línea de comandos ejecutar:
arquetipo mvn: generar - Siga los pasos indicados: elija el proyecto web java simple (18) y un nombre adecuado.
- Cuando termine, ejecute:
mvn eclipse: eclipse - Inicie Eclipse. Elija Archivo - > Importar - > Proyecto existente. Seleccione el directorio donde ejecutó los objetivos mvn.
- Eso es todo, ahora debería tener un muy buen comienzo para un proyecto de guerra en eclipse
- Puede crear la guerra misma ejecutando
mvn packageo desplegarla configurando un servidor en eclipse y simplemente agregando agregar el proyecto al servidor.
Como otros han dicho, la desventaja de usar maven es que tienes que 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. No hay nada que le impida cambiar / refactorizar su propio método preferido más adelante.
Espero que esto ayude.
Utilice la Tarea de guerra de hormigas
Usar código de compilación de ant Lo uso para mi proyecto de 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 debe configurar cada vez las propiedades de exportación.
STEPS:
-
Habilitar " Archivos de proyecto " apoyo; esto podría depender de su proyecto (lo usé en Java EE / proyecto web). Haga clic con el botón derecho en el directorio raíz del proyecto; Configurar - > Añadir soporte para archivos de proyecto.
-
Vaya y cree un nuevo archivo en " Archivos de proyecto " dir. superior Solo tiene la opción jar, pero el nombre archiva * .war.
-
Configure Fileset-s, es decir, qué archivos se incluirán. Lo típico es configurar dos conjuntos de archivos similares a la configuración del ensamblaje de implementación web (propiedad del proyecto).
- copy / WebContent a /
- copiar / crear / clases en WEB-INF / classes (cree este conjunto de archivos después de definir el directorio WEB-INF / classes en el archivo)
-
Es posible que deba modificar la propiedad de exclusión del conjunto de archivos según la ubicación de algunos de los archivos de configuración o que necesite más conjuntos de archivos, pero la idea es que una vez que haya configurado esto no tenga que cambiarlo.
-
Cree el archivo manualmente o publíquelo directamente en el servidor; Eclipse también lo construye automáticamente
Otra opción común es gradle.
http://www.gradle.org/docs/current/userguide /application_plugin.html
Para construir tu archivo war en una aplicación web:
En build.gradle, agrega:
apply plugin: 'war'
Entonces:
./gradlew war
Utilice el diseño de la respuesta aceptada anterior.
Utilice este comando fuera de la carpeta WEB-INF. Esto debería crear tu archivo de guerra. Este es un método más rápido que conozco.
Necesitarás JDK 1.7+ instalado para lograr esta hazaña y las variables de entorno que apuntan al directorio bin de tu JDK.
jar -cvf projectname.war *
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 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 <*>)
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
** Creación de un archivo War en Eclips Gaynemed del proyecto web Grails **
1.Importar proyecto:
2.Cambie el archivo datasource.groovy
Así: url = " jdbc: postgresql: //18.247.120.101: 8432 / PGMS "
2. Cambiar AppConfig.xml
3.mata a Java desde el Administrador de tareas:
-
ejecutar comando limpio en eclips
-
ejecute 'prod war' profundizado por el nombre del proyecto.
-
Verifique el archivo de registro y encuentre el mismo archivo .war en el directorio de Workbench con la misma fecha.
