Cara membuat file perang

Apa praktik terbaik untuk membuat file perang (menggunakan gerhana) untuk dijalankan di kucing jantan? tutorial, tautan, contoh sangat dihargai.

Anda dapat menggunakan Ant untuk menyiapkan, mengompilasi, PERANG , dan menerapkan solusi Anda.

<target name="default" depends="setup,compile,buildwar,deploy"></target>

Anda kemudian dapat mengeksekusi satu klik di Eclipse untuk menjalankan target Ant itu. Berikut adalah contoh dari setiap langkah tersebut:

Prasyarat

Kami akan berasumsi bahwa Anda telah mengatur kode Anda seperti:

• ${basedir}/src: File Java, properti, file konfigurasi XML
• ${basedir}/web: File JSP Anda
• ${basedir}/web/lib: JAR apa pun yang diperlukan saat runtime
• ${basedir}/web/META-INF: Manifes Anda
• ${basedir}/web/WEB-INF: File web.xml Anda

Mempersiapkan

Tentukan setuptugas yang membuat direktori distribusi dan menyalin semua artefak yang perlu DIHANGAT secara langsung:

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

Menyusun

Bangun file Java Anda ke dalam kelas dan salin artefak non-Java apa pun yang berada di bawah srctetapi harus tersedia saat runtime (misalnya properti, file XML, dll.):

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

Bangun PERANG

Buat WAR itu sendiri:

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

Menyebarkan

Terakhir, Anda dapat menyiapkan tugas untuk menerapkan WAR langsung ke lokasi penerapan Tomcat Anda:

<target name="deploy">
    <copy file="My.war" todir="${tomcat.deploydir}" />
</target>

Klik dan pergi!

Setelah semua ini diatur, cukup luncurkan file default target dari Eclipse akan mengkompilasi, PERANG, dan menerapkan solusi Anda.

Keuntungan dari pendekatan ini adalah bahwa ia akan bekerja di luar Eclipse serta di dalam Eclipse dan dapat digunakan untuk dengan mudah membagikan strategi penerapan Anda (misalnya melalui kontrol sumber) dengan pengembang lain yang juga mengerjakan proyek Anda.

Saya selalu memilih Ekspor dari Eclipse. Itu membangun file perang dan menyertakan semua file yang diperlukan. Asalkan Anda membuat proyek sebagai proyek web, itu saja yang perlu Anda lakukan. Eclipse membuatnya sangat mudah untuk dilakukan.

Kami menggunakan Maven (kakak Ant) untuk semua proyek java kami, dan memiliki plugin WAR yang sangat bagus. Tutorial dan penggunaan dapat ditemukan di sana.

Ini jauh lebih mudah daripada Ant, sepenuhnya kompatibel dengan Eclipse (gunakan maven eclipse: eclipse untuk membuat proyek Eclipse) dan mudah dikonfigurasi.

Beranda Maven

Plugin Maven WAR

Konfigurasi Sampel:

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

File perang hanyalah file jar dengan ekstensi perang, tetapi yang membuatnya berfungsi adalah bagaimana konten sebenarnya disusun.

Tutorial J2EE / Java EE bisa menjadi permulaan:

http://java.sun.com/j2ee/tutorial/1_3-fcs/doc/WebComponents3.html

Dan spesifikasi Servlet berisi detail berdarah:

http://java.sun.com/products/servlet/download.html

Jika Anda membuat proyek web baru di Eclipse (saya mengacu pada versi Java EE), struktur dibuat untuk Anda dan Anda juga dapat memberitahukannya di mana Appserver Anda diinstal dan itu akan menerapkan dan memulai aplikasi untuk Anda.

Menggunakan opsi "Ekspor-> WAR file" akan memungkinkan Anda menyimpan file perang.

Jika Anda tidak yakin apa yang harus dilakukan dan memulai dari awal maka Maven dapat membantu Anda memulai.

Dengan mengikuti langkah-langkah di bawah ini Anda bisa mendapatkan pengaturan proyek perang baru dengan sempurna di eclipse.

1. Unduh dan pasang Maven
2. Jalankan baris perintah: mvn archetype:generate
3. Ikuti langkah-langkah yang diminta - memilih proyek web java sederhana (18) dan nama yang sesuai.
4. Setelah selesai jalankan: mvn eclipse:eclipse
5. Mulai Eclipse. Pilih File -> Impor -> Proyek yang ada. Pilih direktori tempat Anda menjalankan tujuan mvn.
6. Itu saja Anda sekarang harus memiliki awal yang sangat baik untuk proyek perang di gerhana
7. Anda dapat membuat perang itu sendiri dengan menjalankan mvn packageatau menyebarkannya dengan menyiapkan server di eclipse dan cukup menambahkan proyek ke server.

Seperti yang dikatakan beberapa orang, sisi negatif dari penggunaan maven adalah Anda harus menggunakan konvensi maven. Tetapi saya pikir jika Anda baru memulai, mempelajari konvensi adalah ide yang baik sebelum Anda mulai membuatnya sendiri. Tidak ada yang menghentikan Anda mengubah / refactoring ke metode pilihan Anda sendiri di kemudian hari.

Semoga ini membantu.

Gunakan tugas perang Semut

Gunakan kode ant build Saya menggunakan ini untuk SMS proyek saya

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

Pilihan lainnya adalah membuatnya secara otomatis menggunakan Eclipse. Tentu saja jika Anda memiliki lingkungan integrasi berkelanjutan Ant atau Maven direkomendasikan. Alternatif ekspor sangat tidak nyaman karena Anda harus mengonfigurasi setiap kali properti ekspor.

LANGKAH:

1. Aktifkan dukungan "Arsip Proyek"; ini mungkin tergantung pada proyek Anda (saya menggunakannya pada proyek Java EE / Web). Klik kanan direktori akar proyek; Konfigurasi -> Tambahkan Dukungan Arsip Proyek.

2. Pergi dan buat arsip baru di direktori atas "Arsip Proyek". Anda hanya memiliki opsi jar, tetapi beri nama Anda arsip * .war.

3. Konfigurasi Fileset-s, yaitu file apa yang akan dimasukkan. Biasanya adalah untuk mengkonfigurasi dua kumpulan file yang serupa dengan bagaimana Web Deployment Assembly (properti proyek) dikonfigurasi.

   • salin / WebContent ke /
   • salin / build / kelas ke WEB-INF / kelas (buat kumpulan file ini setelah Anda menentukan direktori WEB-INF / kelas di arsip)

4. Anda mungkin perlu mengubah properti fileset exclude tergantung di mana Anda meletakkan beberapa file konfigurasi atau Anda mungkin memerlukan lebih banyak kumpulan file, tetapi idenya adalah setelah Anda mengkonfigurasi ini, Anda tidak perlu mengubahnya.

5. Buat arsip secara manual atau publikasikan langsung ke server; tetapi juga dibuat secara otomatis untuk Anda oleh Eclipse

Pilihan umum lainnya adalah gradle.

http://www.gradle.org/docs/current/userguide/application_plugin.html

Untuk membuat file perang Anda di aplikasi web:

Di build.gradle, tambahkan:

apply plugin: 'war'

Kemudian:

./gradlew war

Gunakan tata letak dari jawaban yang diterima di atas.

Gunakan perintah berikut di luar folder WEB-INF. Ini akan membuat file perang Anda dan merupakan metode tercepat yang saya tahu.

(Anda akan membutuhkan JDK 1.7+ variabel lingkungan dan terinstal yang mengarah ke direktori bin JDK Anda.)

jar -cvf projectname.war *

Tautan Referensi

Solusi yang lebih sederhana yang juga menyegarkan ruang kerja 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>

Kode Shell sederhana untuk membuat file WAR dari Proyek Web dinamis Eclipse standar. Menggunakan sistem File RAM (/ dev / shm) pada platform 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

** Membuat file Perang di Eclips Gaynemed of grails web project **

1. proyek impor:

2. Ubah file sumber data.groovy

Seperti ini: url = "jdbc: postgresql: //18.247.120.101: 8432 / PGMS"

2.chnge AppConfig.xml

3. bunuh Java dari Task Manager:

4. jalankan perintah bersih di gerhana

5. menjalankan 'perang prod' mengikuti nama proyek.

6. Periksa file log dan temukan file .war yang sama di direktori meja kerja dengan tanggal yang sama.