Quais são as melhores práticas de criação de arquivos war (usando eclipse) para rodar no tomcat? tutoriais, links, exemplos são muito apreciados.
Quais são as melhores práticas de criação de arquivos war (usando eclipse) para rodar no tomcat? tutoriais, links, exemplos são muito apreciados.
Respostas:
Você pode usar Ant para configurar, compilar, WAR e implantar sua solução.
<target name="default" depends="setup,compile,buildwar,deploy"></target>Você pode então executar um clique no Eclipse para executar esse destino Ant. Aqui estão alguns exemplos de cada uma das etapas:
Vamos supor que você tenha seu código organizado da seguinte forma:
${basedir}/src: Arquivos Java, propriedades, arquivos de configuração XML${basedir}/web: Seus arquivos JSP${basedir}/web/lib: Quaisquer JARs necessários em tempo de execução${basedir}/web/META-INF: Seu manifesto${basedir}/web/WEB-INF: Seus arquivos web.xmlDefina uma setuptarefa que crie o diretório de distribuição e copie todos os artefatos que precisam ser WARred diretamente:
<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>
Construa seus arquivos Java em classes e copie quaisquer artefatos não Java que residam, srcmas precisam estar disponíveis no tempo de execução (por exemplo, propriedades, arquivos 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>
Crie o próprio 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>
Por fim, você pode configurar uma tarefa para implantar o WAR diretamente no local de implantação do Tomcat:
<target name="deploy">
<copy file="My.war" todir="${tomcat.deploydir}" />
</target>
Depois que tudo isso estiver configurado, basta iniciar o defaultdestino do Eclipse para compilar, fazer o WAR e implementar sua solução.
A vantagem dessa abordagem é que funcionará fora do Eclipse, bem como dentro do Eclipse, e pode ser usada para compartilhar facilmente sua estratégia de implantação (por exemplo, por meio do controle de origem) com outros desenvolvedores que também estão trabalhando em seu projeto.
Sempre selecionei Exportar do Eclipse. Ele cria o arquivo war e inclui todos os arquivos necessários. Desde que você tenha criado o projeto como um projeto da web, isso é tudo o que você precisa fazer. O Eclipse torna muito simples de fazer.
Usamos Maven (irmão mais velho do Ant) para todos os nossos projetos java, e ele tem um plugin WAR muito bacana. Tutoriais e uso podem ser encontrados lá.
É muito mais fácil do que Ant, totalmente compatível com Eclipse (use maven eclipse: eclipse para criar projetos Eclipse) e fácil de configurar.
Configuração de amostra:
<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>
Um arquivo war é simplesmente um arquivo jar com uma extensão war, mas o que o faz funcionar é como o conteúdo é realmente estruturado.
O tutorial J2EE / Java EE pode ser um começo:
http://java.sun.com/j2ee/tutorial/1_3-fcs/doc/WebComponents3.html
E a especificação do Servlet contém os detalhes sangrentos:
http://java.sun.com/products/servlet/download.html
Se você criar um novo projeto web no Eclipse (estou me referindo à versão Java EE), a estrutura é criada para você e você também pode dizer onde seu Appserver está instalado e ele irá implantar e iniciar o aplicativo para você.
Usar a opção "Exportar-> Arquivo WAR" permitirá que você salve o arquivo war.
Se você não tem certeza do que fazer e está começando do zero, o Maven pode ajudá-lo a começar.
Seguindo as etapas abaixo, você pode obter uma nova configuração de projeto de guerra perfeitamente no Eclipse.
mvn archetype:generatemvn eclipse:eclipsemvn packageou implementá-lo configurando um servidor no eclipse e simplesmente adicionando o projeto ao servidor.Como alguns outros disseram, a desvantagem de usar o maven é que você precisa usar as convenções do maven. Mas acho que se você está apenas começando, aprender as convenções é uma boa ideia antes de começar a fazer as suas. Não há nada que o impeça de alterar / refatorar para seu método preferido posteriormente.
Espero que isto ajude.
Use a tarefa Ant war
Use o código de compilação de formiga Eu uso isso para o meu projeto 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>Outra opção seria construí-lo automaticamente usando o Eclipse. Claro, se você tiver um ambiente de integração contínua Ant ou Maven é recomendado. A alternativa de exportação não é muito conveniente porque você tem que configurar todas as vezes as propriedades de exportação.
PASSOS:
Habilitar suporte para "Arquivos de projeto"; isso pode depender do seu projeto (eu usei no projeto Java EE / Web). Clique com o botão direito do mouse no diretório raiz do projeto; Configurar -> Adicionar suporte a arquivos do projeto.
Vá e crie um novo arquivo no diretório superior "Arquivos do projeto". Você tem apenas a opção jar, mas nomeie seu arquivo * .war.
Configure Fileset-s, ou seja, quais arquivos serão incluídos. Típico é configurar dois conjuntos de arquivos semelhantes à configuração do Web Deployment Assembly (propriedade do projeto).
Você pode precisar ajustar a propriedade de exclusão do conjunto de arquivos, dependendo de onde colocou alguns dos arquivos de configuração ou pode precisar de mais conjuntos de arquivos, mas a ideia é que depois de configurar isso, você não precisa alterá-lo.
Construa o arquivo manualmente ou publique-o diretamente no servidor; mas também é criado automaticamente para você pelo Eclipse
Outra opção comum é o gradle.
http://www.gradle.org/docs/current/userguide/application_plugin.html
Para construir seu arquivo war em um aplicativo da web:
Em build.gradle, adicione:
apply plugin: 'war'Então:
./gradlew warUse o layout da resposta aceita acima.
Use o seguinte comando fora da pasta WEB-INF. Isso deve criar seu arquivo de guerra e é o método mais rápido que conheço.
(Você precisará do JDK 1.7+ instalado e das variáveis de ambiente que apontam para o diretório bin do seu JDK.)
jar -cvf projectname.war *Solução mais simples que também atualiza o espaço de trabalho do 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 criar arquivos WAR a partir de um projeto da Web dinâmico padrão do Eclipse. Usa o sistema de arquivos RAM (/ dev / shm) em uma 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** Criação de arquivo de guerra no projeto web Eclips Gaynemed of grails **
1. Projeto de importação:
2. Altere o arquivo datasource.groovy
Assim: url = "jdbc: postgresql: //18.247.120.101: 8432 / PGMS"
2.chnge AppConfig.xml
3. mate o Java do Gerenciador de Tarefas:
executar um comando limpo em eclips
execute 'prod war' seguido pelo nome do projeto.
Verifique o arquivo de log e encontre o mesmo arquivo .war no diretório do workbench com a mesma data.