Como criar arquivos de guerra

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.

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:

Condições prévias

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.xml

Configuração

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

Compilar

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>

Construir WAR

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>

Implantar

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>

Clique e vá!

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.

Homepage do Maven

Plugin Maven WAR

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.

1. Baixe e instale o Maven
2. Vá para a linha de comando e execute: mvn archetype:generate
3. Siga as etapas solicitadas - escolhendo o projeto java web simples (18) e um nome adequado.
4. Quando terminar, execute: mvn eclipse:eclipse
5. Inicie o Eclipse. Escolha Arquivo -> Importar -> Projeto existente. Selecione o diretório onde você executou os objetivos do mvn.
6. É isso, agora você deve ter um bom começo para um projeto de guerra em eclipse
7. Você pode criar o próprio war executando mvn 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:

1. 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.

2. 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.

3. 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).

   • copiar / WebContent para /
   • copiar / construir / classes para WEB-INF / classes (criar este conjunto de arquivos depois de definir o diretório WEB-INF / classes no arquivo)

4. 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.

5. 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 war

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

Link de Referência

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:

4. executar um comando limpo em eclips

5. execute 'prod war' seguido pelo nome do projeto.

6. Verifique o arquivo de log e encontre o mesmo arquivo .war no diretório do workbench com a mesma data.