Como criar arquivos de guerra

Question

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.

Answer 1

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.

Answer 2

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.

Answer 3

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

página inicial do Maven

Maven WAR plug-in

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>

Answer 4

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.

Answer 5

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.

1. Baixe e instale Maven
2. Vá a linha de comando run: mvn archetype:generate
3. Siga as etapas levaram -. Escolher o projeto simples java web (18) e um nome adequado
4. Quando é executado com acabamento: mvn eclipse:eclipse
5. Inicie o Eclipse. Escolha Arquivo -> Importar -> projeto existente. Selecione a pasta onde você executou os objetivos MVn.
6. É isso que você deve agora ter um bom começo para um projeto de guerra no eclipse
7. 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.

Answer 6

Use a Ant tarefa guerra

Answer 7

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>

Answer 8

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:

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

2. Go e criar um novo arquivo no "arquivos do projecto" top dir. Você tem única opção jar, mas nomear você arquivar .war *.

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

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

5. Criar o arquivo manualmente ou publicar directamente para o servidor; mas também é construído automaticamente para você pelo Eclipse

Answer 9

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.

Answer 10

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 *

Ligação Referência

Answer 11

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>

Answer 12

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

Answer 13

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

4. executar comand limpa em Eclips

5. run 'guerra prod' fowllowed pelo nome do projeto.

6. Verifique o arquivo de log e encontrar o mesmo arquivo .war no diretório de bancada com a mesma data.