วิธีสร้างไฟล์สงคราม

แนวทางปฏิบัติที่ดีที่สุดในการสร้างไฟล์ war (โดยใช้ eclipse) เพื่อรันบน tomcat มีอะไรบ้าง? แบบฝึกหัดลิงค์ตัวอย่างเป็นที่นิยมอย่างมาก

คุณสามารถใช้Antเพื่อตั้งค่าคอมไพล์WARและปรับใช้โซลูชันของคุณ

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

จากนั้นคุณสามารถดำเนินการคลิกเพียงครั้งเดียวใน Eclipse เพื่อเรียกใช้ Ant เป้าหมายนั้น ตัวอย่างของแต่ละขั้นตอนมีดังนี้

เงื่อนไขเบื้องต้น

เราจะถือว่าคุณมีการจัดระเบียบรหัสของคุณดังนี้:

• ${basedir}/src: ไฟล์ Java, คุณสมบัติ, ไฟล์กำหนดค่า XML
• ${basedir}/web: ไฟล์ JSP ของคุณ
• ${basedir}/web/lib: JAR ใด ๆ ที่จำเป็นในรันไทม์
• ${basedir}/web/META-INF: รายการของคุณ
• ${basedir}/web/WEB-INF: ไฟล์ web.xml ของคุณ

ติดตั้ง

กำหนดsetupงานที่สร้างไดเร็กทอรีการแจกจ่ายและคัดลอกอาร์ติแฟกต์ใด ๆ ที่จำเป็นต้องได้รับการ WARred โดยตรง:

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

รวบรวม

สร้างไฟล์ Java ของคุณเป็นคลาสและคัดลอกสิ่งประดิษฐ์ที่ไม่ใช่ Java ที่อยู่ภายใต้srcแต่จำเป็นต้องพร้อมใช้งานในรันไทม์ (เช่นคุณสมบัติไฟล์ XML ฯลฯ ):

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

สร้างสงคราม

สร้างสงครามเอง:

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

ปรับใช้

สุดท้ายคุณสามารถตั้งค่างานเพื่อปรับใช้ WAR โดยตรงในตำแหน่งปรับใช้ Tomcat ของคุณ:

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

คลิกเลย!

เมื่อตั้งค่าทั้งหมดแล้วเพียงแค่เรียกใช้defaultเป้าหมายจาก Eclipse ก็จะคอมไพล์ WAR และปรับใช้โซลูชันของคุณ

ข้อดีของแนวทางนี้คือจะทำงานนอก Eclipse และภายใน Eclipse และสามารถใช้เพื่อแบ่งปันกลยุทธ์การปรับใช้ของคุณได้อย่างง่ายดาย (เช่นผ่านการควบคุมแหล่งที่มา) กับนักพัฒนาอื่น ๆ ที่กำลังทำงานในโครงการของคุณ

ฉันเลือกส่งออกจาก Eclipse เสมอ สร้างไฟล์สงครามและรวมไฟล์ที่จำเป็นทั้งหมด การให้คุณสร้างโปรเจ็กต์เป็นโปรเจ็กต์เว็บนั่นคือทั้งหมดที่คุณต้องทำ Eclipse ทำให้ง่ายมากที่จะทำ

เราใช้ Maven (พี่ใหญ่ของ Ant) สำหรับโปรเจ็กต์ java ทั้งหมดของเราและมีปลั๊กอิน WAR ที่ดีมาก สามารถดูบทแนะนำและการใช้งานได้ที่นั่น

ง่ายกว่า Ant มากเข้ากันได้กับ Eclipse (ใช้maven eclipse: eclipseเพื่อสร้างโปรเจ็กต์ Eclipse) และกำหนดค่าได้ง่าย

หน้าแรกของ Maven

ปลั๊กอิน Maven WAR

การกำหนดค่าตัวอย่าง:

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

ไฟล์ war เป็นเพียงไฟล์ jar ที่มีนามสกุล war แต่สิ่งที่ทำให้มันใช้งานได้คือเนื้อหามีโครงสร้างอย่างไร

บทช่วยสอน J2EE / Java EE สามารถเริ่มต้นได้:

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

และข้อกำหนดของ Servlet ประกอบด้วยรายละเอียดที่เต็มไปด้วยเลือด:

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

ถ้าคุณสร้างโปรเจ็กต์เว็บใหม่ใน Eclipse (ฉันหมายถึงเวอร์ชัน Java EE) โครงสร้างจะถูกสร้างขึ้นสำหรับคุณและคุณยังสามารถบอกได้ว่า Appserver ของคุณติดตั้งไว้ที่ใดและจะปรับใช้และเริ่มแอปพลิเคชันให้คุณ

การใช้ตัวเลือก "ส่งออก -> ไฟล์สงคราม" จะช่วยให้คุณสามารถบันทึกไฟล์สงครามได้

หากคุณไม่แน่ใจว่าต้องทำอย่างไรและกำลังเริ่มต้นใหม่ Maven สามารถช่วยคุณเริ่มต้นได้

โดยทำตามขั้นตอนด้านล่างคุณจะได้รับการตั้งค่าโครงการสงครามใหม่อย่างสมบูรณ์แบบในคราส

1. ดาวน์โหลดและติดตั้งMaven
2. ไปที่บรรทัดคำสั่งรัน: mvn archetype:generate
3. ทำตามขั้นตอนที่แจ้ง - เลือกโปรเจ็กต์เว็บ java แบบง่าย (18) และชื่อที่เหมาะสม
4. เมื่อเสร็จสิ้นให้รัน: mvn eclipse:eclipse
5. เริ่ม Eclipse เลือกไฟล์ -> นำเข้า -> โครงการที่มีอยู่ เลือกไดเร็กทอรีที่คุณเรียกใช้เป้าหมาย mvn
6. ตอนนี้คุณควรเริ่มต้นโครงการสงครามในคราสได้อย่างดี
7. คุณสามารถสร้างสงครามได้เองโดยการรันmvn packageหรือปรับใช้โดยการตั้งค่าเซิร์ฟเวอร์ใน eclipse และเพิ่มการเพิ่มโปรเจ็กต์ลงในเซิร์ฟเวอร์

ดังที่คนอื่น ๆ กล่าวไว้ว่าข้อเสียของการใช้ maven คือคุณต้องใช้ maven conventions แต่ฉันคิดว่าถ้าคุณเพิ่งเริ่มต้นการเรียนรู้อนุสัญญาเป็นความคิดที่ดีก่อนที่คุณจะเริ่มสร้างด้วยตัวเอง ไม่มีอะไรที่จะหยุดคุณเปลี่ยน / ปรับโครงสร้างเป็นวิธีการที่คุณต้องการได้ในภายหลัง

หวังว่านี่จะช่วยได้

ใช้ภารกิจสงครามมด

ใช้รหัสสร้างมดที่ฉันใช้สำหรับ 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>

ใช้คำสั่งต่อไปนี้นอกโฟลเดอร์ WEB-INF สิ่งนี้ควรสร้างไฟล์สงครามของคุณและเป็นวิธีที่เร็วที่สุดที่ฉันรู้

(คุณจะต้องติดตั้ง JDK 1.7+ และตัวแปรสภาพแวดล้อมที่ชี้ไปที่ไดเร็กทอรี bin ของ JDK ของคุณ)

jar -cvf projectname.war *

ลิงค์อ้างอิง

อีกทางเลือกหนึ่งคือสร้างโดยอัตโนมัติโดยใช้ Eclipse แน่นอนว่าหากคุณมีสภาพแวดล้อมการผสานรวมอย่างต่อเนื่องขอแนะนำให้ใช้ Ant หรือ Maven ทางเลือกในการส่งออกไม่สะดวกนักเนื่องจากคุณต้องกำหนดค่าทุกครั้งที่คุณสมบัติการส่งออก

ขั้นตอน:

1. เปิดใช้งานการสนับสนุน "Project Archives" สิ่งนี้อาจขึ้นอยู่กับโปรเจ็กต์ของคุณ (ฉันใช้กับ Java EE / Web project) คลิกขวาที่ไดเรกทอรีรากของโครงการ กำหนดค่า -> เพิ่มการสนับสนุนโครงการที่เก็บถาวร

2. ไปและสร้างที่เก็บถาวรใหม่ใน dir ชั้นนำของ "Project Archives" คุณมีตัวเลือก jar เท่านั้น แต่ตั้งชื่อให้คุณเก็บ * .war

3. กำหนดค่า Fileset-s นั่นคือไฟล์ที่จะรวม โดยทั่วไปคือการกำหนดค่าชุดไฟล์สองชุดที่คล้ายคลึงกับการกำหนดค่า Web Deployment Assembly (คุณสมบัติโครงการ)

   • คัดลอก / WebContent ถึง /
   • คัดลอก / สร้าง / คลาสไปยัง WEB-INF / คลาส (สร้างชุดไฟล์นี้หลังจากที่คุณกำหนดไดเร็กทอรี WEB-INF / คลาสในไฟล์เก็บถาวร)

4. คุณอาจต้องใช้คุณสมบัติการยกเว้นชุดไฟล์สองครั้งขึ้นอยู่กับตำแหน่งที่คุณวางไฟล์กำหนดค่าไว้บางไฟล์หรือคุณอาจต้องการชุดไฟล์เพิ่มเติม แต่แนวคิดก็คือเมื่อคุณกำหนดค่าแล้วคุณไม่จำเป็นต้องเปลี่ยนแปลง

5. สร้างไฟล์เก็บถาวรด้วยตนเองหรือเผยแพร่ไปยังเซิร์ฟเวอร์โดยตรง แต่ยังสร้างขึ้นโดยอัตโนมัติสำหรับคุณโดย Eclipse

อีกทางเลือกหนึ่งที่พบบ่อยคือ gradle

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

ในการสร้างไฟล์สงครามของคุณในเว็บแอป:

ใน build.gradle เพิ่ม:

apply plugin: 'war'

จากนั้น:

./gradlew war

ใช้เค้าโครงจากคำตอบที่ยอมรับด้านบน

โซลูชันที่ง่ายกว่าซึ่งรีเฟรชเวิร์กสเปซ 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>

โค้ด Simplistic Shell สำหรับสร้างไฟล์ WAR จาก Eclipse dynamic Web Project มาตรฐาน ใช้ระบบไฟล์ RAM (/ dev / shm) บนแพลตฟอร์ม 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

** การสร้างไฟล์ War ใน Eclips Gaynemed ของโครงการเว็บ grails **

1. โครงการนำเข้า:

2. เปลี่ยนไฟล์ datasource.groovy

ดังนี้ url = "jdbc: postgresql: //18.247.120.101: 8432 / PGMS"

2. ขยาย AppConfig.xml

3. ฆ่า Java จาก Task Manager:

4. เรียกใช้ comand ที่สะอาดใน eclips

5. เรียกใช้ 'prod war' โดยใช้ชื่อโครงการ

6. ตรวจสอบไฟล์บันทึกและค้นหาไฟล์. war เดียวกันในไดเร็กทอรีของ workbench ที่มีวันที่เดียวกัน