वॉर फाइल्स कैसे बनाएं

Question 1

टॉमकैट पर चलने के लिए युद्ध फ़ाइलों (ग्रहण का उपयोग करके) बनाने की सर्वोत्तम प्रथाएं क्या हैं? ट्यूटोरियल, लिंक, उदाहरण अत्यधिक सराहे जाते हैं।

Question 2

आप अपने समाधान को स्थापित करने, संकलित करने, WAR , और परिनियोजित करने के लिए चींटी का उपयोग कर सकते हैं।

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

फिर आप उस एंट लक्ष्य को चलाने के लिए एक्लिप्स में एक क्लिक निष्पादित कर सकते हैं। यहाँ प्रत्येक चरण के उदाहरण दिए गए हैं:

पूर्व शर्त

हम मान लेंगे कि आपके पास अपना कोड व्यवस्थित है:

${basedir}/src: जावा फाइलें, गुण, 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>

संकलन

अपनी जावा फ़ाइलों को कक्षाओं में बनाएँ और किसी भी गैर-जावा कलाकृतियों पर कॉपी करें जो नीचे रहते हैं, srcलेकिन रनटाइम (जैसे गुण, एक्सएमएल फ़ाइलें, आदि) पर उपलब्ध होने की आवश्यकता है:

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

WAR का निर्माण करें

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>

तैनाती

अंत में, आप WAR को सीधे अपने Tomcat परिनियोजित स्थान पर तैनात करने के लिए एक कार्य सेट कर सकते हैं:

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

क्लिक करें और जाएँ!

एक बार यह सब सेट हो जाने के बाद, केवल defaultग्रहण से लक्ष्य लॉन्च करना , WAR को संकलित करेगा, और आपके समाधान को तैनात करेगा।

इस दृष्टिकोण का लाभ यह है कि यह एक्लिप्स के बाहर के साथ-साथ एक्लिप्स के बाहर भी काम करेगा और इसका उपयोग आपकी तैनाती की रणनीति (जैसे स्रोत नियंत्रण के माध्यम से) को अन्य डेवलपर्स के साथ आसानी से साझा करने के लिए किया जा सकता है जो आपकी परियोजना पर भी काम कर रहे हैं।

Question 3

मैंने हमेशा केवल ग्रहण से निर्यात का चयन किया है। यह युद्ध फाइल बनाता है और इसमें सभी आवश्यक फाइलें शामिल हैं। आप एक वेब परियोजना के रूप में इस परियोजना को प्रदान करना है कि तुम सब करने की ज़रूरत होगी। ग्रहण करना बहुत सरल है।

Question 4

हम अपने सभी जावा प्रोजेक्ट्स के लिए मावेन (चींटी के बड़े भाई) का उपयोग करते हैं, और इसमें बहुत निफ्टी WAR प्लगइन है। ट्यूटोरियल और उपयोग वहाँ पाया जा सकता है।

यह चींटी की तुलना में बहुत आसान है, पूरी तरह से ग्रहण के साथ संगत है ( मावेन ग्रहण का उपयोग करें : ग्रहण परियोजनाओं को बनाने के लिए ग्रहण) और कॉन्फ़िगर करना आसान है।

मावेन का मुखपृष्ठ

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>

Question 5

एक युद्ध फ़ाइल एक युद्ध विस्तार के साथ बस एक जार फ़ाइल है, लेकिन यह क्या काम करता है कैसे सामग्री वास्तव में संरचित है।

J2EE / Java EE ट्यूटोरियल एक शुरुआत हो सकती है:

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

और सर्वलेट विनिर्देशन में विवरण शामिल हैं:

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

यदि आप ग्रहण में एक नया वेब प्रोजेक्ट बनाते हैं (मैं जावा ईई संस्करण की बात कर रहा हूं), तो संरचना आपके लिए बनाई गई है और आप यह भी बता सकते हैं कि आपका अप्प्सवर कहां स्थापित है और यह आपके लिए एप्लिकेशन को तैनात करेगा और शुरू करेगा।

"निर्यात-> WAR फ़ाइल" विकल्प का उपयोग करने से आप युद्ध फ़ाइल को बचा पाएंगे।

Question 6

यदि आप सुनिश्चित नहीं हैं कि क्या करना है और खरोंच से शुरू हो रहे हैं तो मावेन आपको आरंभ करने में मदद कर सकता है।

नीचे दिए गए चरणों का पालन करके आप ग्रहण में पूरी तरह से एक नया युद्ध परियोजना सेटअप प्राप्त कर सकते हैं।

मावेन को डाउनलोड और इंस्टॉल करें
कमांड लाइन रन पर जाएं: mvn archetype:generate
संकेतित चरणों का पालन करें - सरल जावा वेब परियोजना (18) और एक उपयुक्त नाम का चयन करना।
जब इसे पूरा किया जाता है: mvn eclipse:eclipse
ग्रहण शुरू करें। फ़ाइल चुनें -> आयात -> मौजूदा परियोजना। उस निर्देशिका का चयन करें जहाँ आपने mvn गोल चलाया था।
यही कारण है कि अब आपको ग्रहण में एक युद्ध परियोजना के लिए बहुत अच्छी शुरुआत करनी चाहिए
आप mvn packageग्रहण में सर्वर स्थापित करके या केवल सर्वर में प्रोजेक्ट जोड़कर इसे चला या तैनात करके युद्ध का निर्माण कर सकते हैं ।

जैसा कि कुछ अन्य लोगों ने कहा है कि मावेन का उपयोग करने का नकारात्मक पक्ष यह है कि आपको मावेन सम्मेलनों का उपयोग करना होगा। लेकिन मुझे लगता है कि यदि आप अभी शुरुआत कर रहे हैं, तो सम्मेलनों को सीखना एक अच्छा विचार है इससे पहले कि आप अपना खुद का निर्माण शुरू करें। बाद में एक बिंदु पर आपको अपनी पसंद के तरीके को बदलने / रिफैक्ट करने से रोकने के लिए कुछ भी नहीं है।

उम्मीद है की यह मदद करेगा।

Question 7

चींटी युद्ध कार्य का उपयोग करें

Question 8

चींटी बिल्ड कोड का उपयोग करें मैं अपने प्रोजेक्ट एसएमएस के लिए इसका उपयोग करता हूं

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

Question 9

एक और विकल्प यह होगा कि इसे ग्रहण का उपयोग करके स्वचालित रूप से बनाया जाए। बेशक अगर आपके पास निरंतर एकीकरण वातावरण है चींटी या मावेन की सिफारिश की जाती है। निर्यात विकल्प बहुत सुविधाजनक नहीं है क्योंकि आपको हर बार निर्यात गुणों को कॉन्फ़िगर करना होगा।

कदम:

"प्रोजेक्ट अभिलेखागार" समर्थन सक्षम करें; यह आपकी परियोजना पर निर्भर हो सकता है (मैंने इसे जावा ईई / वेब परियोजना पर उपयोग किया है)। राइट-क्लिक करें प्रोजेक्ट रूट निर्देशिका; कॉन्फ़िगर करें -> प्रोजेक्ट अभिलेखागार सहायता जोड़ें।
जाओ और "प्रोजेक्ट आर्काइव्स" शीर्ष डायर में एक नया संग्रह बनाएं। आपके पास केवल जार विकल्प है, लेकिन नाम आप संग्रह * .war।
Fileset-s को कॉन्फिगर करें, यानी किन फाइल्स को शामिल करना है। वेब डिप्लॉयमेंट असेंबली (प्रोजेक्ट प्रॉपर्टी) को कॉन्फ़िगर करने के तरीके के समान दो फ़ाइलों को कॉन्फ़िगर करना है।
- कॉपी / वेबकंटेंट /
- WEB-INF / कक्षाओं में कॉपी / निर्माण / कक्षाएं (संग्रह में WEB-INF / कक्षाएं निर्देशिका को परिभाषित करने के बाद यह फाइलसेट बनाएं)
जहाँ आप कुछ कॉन्फिगरेशन फाइल रखते हैं या आपको अधिक फाइलसेट्स की आवश्यकता हो सकती है, उसके आधार पर आपको फाइलसेट को बाहर करने की आवश्यकता हो सकती है, लेकिन विचार यह है कि एक बार इसे कॉन्फ़िगर करने के बाद आपको इसे बदलने की आवश्यकता नहीं है।
संग्रह को मैन्युअल रूप से बनाएं या सीधे सर्वर पर प्रकाशित करें; लेकिन ग्रहण द्वारा स्वचालित रूप से आपके लिए बनाया गया है

Question 10

एक और आम विकल्प है ग्रेडल।

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

एक वेब ऐप में अपनी युद्ध फाइल बनाने के लिए:

बिल्ड.ग्रेड में, जोड़ें:

apply plugin: 'war'

फिर:

./gradlew war

ऊपर दिए गए उत्तर से लेआउट का उपयोग करें।

Question 11

WEB-INF फ़ोल्डर के बाहर निम्न कमांड का उपयोग करें। यह आपकी युद्ध फाइल बनाना चाहिए और मुझे पता है कि सबसे तेज तरीका है।

(आपको JDK 1.7+ स्थापित और पर्यावरण चर की आवश्यकता होगी जो आपके JDK की बिन निर्देशिका को इंगित करते हैं।)

jar -cvf projectname.war *

संदर्भ लिंक

Question 12

सरल समाधान जो ग्रहण कार्यक्षेत्र को भी ताज़ा करता है:

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

Question 13

मानक ग्रहण डायनामिक वेब प्रोजेक्ट से WAR फ़ाइलों को बनाने के लिए सरलीकृत शैल कोड। लिनक्स प्लेटफ़ॉर्म पर RAM फ़ाइल सिस्टम (/ dev / shm) का उपयोग करता है।

#!/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

Question 14

** ग्रहण वेब प्रोजेक्ट में युद्ध की फाइल बनाना

1. आयात परियोजना:

2. datasource.groovy फ़ाइल को बदलें

इस तरह: url = "jdbc: postgresql: //18.247.120.101: 8432 / PGT"

2.chnge AppConfig.xml

3. टास्क मैनेजर से जावा को भरें:

ग्रहणों में स्वच्छ कोम चलाएं
प्रोजेक्ट नाम से 'फुल वॉर' चला।
लॉग फ़ाइल की जाँच करें और उसी तारीख के साथ कार्यक्षेत्र की निर्देशिका में .war फ़ाइल खोजें।