Como criar arquivos de guerra
Pergunta
O que são as melhores práticas de criação de arquivos de guerra (usando eclipse) para ser executado no tomcat? cursos, links, exemplos são altamente apreciado.
Solução
Você pode usar Ant de configurar, compilação, GUERRA 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 alvo Ant. Aqui estão alguns exemplos de cada uma das etapas:
Pré-requisitos
Vamos supor que você tenha o seu código organizado como:
-
${basedir}/src
: arquivos Java, propriedades, os arquivos de configuração XML -
${basedir}/web
: Seu arquivos JSP -
${basedir}/web/lib
: Qualquer JARs necessários em tempo de execução -
${basedir}/web/META-INF
: Seu manifesto -
${basedir}/web/WEB-INF
: Seus arquivos web.xml
Set up
Defina uma tarefa setup
que cria o diretório de distribuição e copia quaisquer artefatos que precisam ser guerreou 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>
Compilar
Construa seus arquivos Java em classes e copiar sobre quaisquer artefatos não-Java que residem sob src
mas precisam estar disponíveis em 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>
Construir WAR
Criar a própria 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>
Deploy
Finalmente, você pode configurar uma tarefa para implantar o WAR diretamente em seu local de implantação Tomcat:
<target name="deploy">
<copy file="My.war" todir="${tomcat.deploydir}" />
</target>
Clique e vá!
Depois de tudo isso é configurar, basta lançar o alvo default
de Eclipse irá compilar, guerra e implantar sua solução.
A vantagem dessa abordagem é que ele vai trabalhar fora Eclipse, bem como dentro do Eclipse e pode ser usado para facilmente compartilhar sua estratégia de implantação (por exemplo, através de controle de origem) com outros desenvolvedores que também estão trabalhando em seu projeto.
Outras dicas
Eu sempre acabou de selecionar Exportação do Eclipse. Ele constrói o arquivo de guerra e inclui todos os arquivos necessários. Fornecendo você criou o projeto como um projeto web que é tudo que você precisa fazer. Eclipse torna muito simples de fazer.
Nós usamos Maven (irmão mais velho de Ant) para todos os nossos projetos java, e tem um plug-in WAR muito bacana. Tutoriais e uso podem ser encontradas lá.
É muito mais fácil do Ant, totalmente compatível com o Eclipse (use maven eclipse: eclipse para criar projetos Eclipse). E fácil de configurar
Configuração da 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 de guerra é simplesmente um arquivo jar com uma extensão de guerra, mas o que torna o trabalho é 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 Servlet contém os detalhes:
http://java.sun.com/products/servlet/download.html
Se você criar um novo projeto web em 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 que vai implantar e iniciar a aplicação para você .
Usando a opção "file Exportar-> GUERRA" vai deixar você guardar o arquivo de guerra.
Se você não tem certeza o que fazer e está começando do zero, em seguida, Maven pode ajudar você a começar.
Seguindo o a seguir os passos que você pode começar uma nova configuração do projeto de guerra perfeitamente em eclipse.
- Baixe e instale Maven
- Vá a linha de comando run:
mvn archetype:generate
- Siga as etapas levaram -. Escolher o projeto simples java web (18) e um nome adequado
- Quando é executado com acabamento:
mvn eclipse:eclipse
- Inicie o Eclipse. Escolha Arquivo -> Importar -> projeto existente. Selecione a pasta onde você executou os objetivos MVn.
- É isso que você deve agora ter um bom começo para um projeto de guerra no eclipse
- Você pode criar a própria guerra, executando
mvn package
ou implantá-lo através da criação de um servidor em eclipse e simplesmente adicionando adicionando o projeto para o servidor.
Como alguns outros têm a desvantagem de usar maven é que você tem que usar as convenções de Maven. Mas eu acho que se você está apenas começando, aprendendo as convenções é uma boa idéia antes de você começar a fazer o seu próprio. Não há nada para impedi-lo mudando / refatoração para o seu próprio método preferido em um momento posterior.
Espero que isso ajude.
Use a Ant tarefa guerra
Use o código de construção Ant 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 para construí-lo automaticamente usando Eclipse. Claro, se você tem ambiente de integração contínua Ant ou Maven é recomendado. A alternativa de exportação não é muito conveniente porque você tem que configurar cada vez que as propriedades de exportação.
passos:
-
Ativar "Arquivos do projeto" apoio; isso pode depender do seu projeto (eu usei-o no projeto Java EE / Web). Botão direito do mouse diretório raiz do projeto; Configure -.> Adicionar Projeto de Apoio Arquivos
-
Go e criar um novo arquivo no "arquivos do projecto" top dir. Você tem única opção jar, mas nomear você arquivar .war *.
-
Configurar FileSet-s, i quais arquivos a serem incluídos. Típico é configurar dois conjuntos de arquivos semelhantes como a Assembléia de implantação da Web (projeto propriedade) está configurado.
- copy / WebContent para /
- Copiar / build / classes para WEB-INF / classes (criar esta fileset depois de definir o diretório WEB-INF / classes no arquivo)
-
Você pode precisar tweek o conjunto de arquivos excluir propriedades dependendo de onde você colocou alguns dos arquivos de configuração ou você pode precisar de mais conjuntos de arquivos, mas a idéia é que uma vez que você configurou isso você não precisa mudá-lo.
-
Criar o arquivo manualmente ou publicar directamente para o servidor; mas também é construído automaticamente para você pelo Eclipse
Outra opção comum é Gradle.
http://www.gradle.org/docs/current/userguide /application_plugin.html
Para construir o seu arquivo de guerra em um aplicativo web:
Em build.gradle, adicione:
apply plugin: 'war'
Depois:
./gradlew war
Use o layout de resposta aceito acima.
Use este comando fora da pasta WEB-INF. Isso deve criar seu arquivo de guerra. Este é um método mais rápido que eu conheço.
Você vai precisar JDK 1.7+ instalado para conseguir este feito e ambientais variáveis ??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 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 simplista Shell para criar arquivos WAR de um projeto da Web Eclipse dinâmica padrão. sistema usa RAM Arquivo (/ 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
** Fazendo arquivo Guerra no Eclips Gaynemed de projeto web grails **
projeto 1.Import:
2.Change o arquivo DataSource.groovy
Assim: url = "jdbc: postgresql: //18.247.120.101: 8432 / PGMS"
2.chnge AppConfig.xml
3.kill o Java do Gerenciador de tarefas:
-
executar comand limpa em Eclips
-
run 'guerra prod' fowllowed pelo nome do projeto.
-
Verifique o arquivo de log e encontrar o mesmo arquivo .war no diretório de bancada com a mesma data.