eclipse आज - क्लासपाथ के कई संस्करण के बीच चुनने के लिए चींटी स्क्रिप्ट




का चंद्र (3)

मैं चींटी लिपियों के लिए नया हूँ

नीचे आवश्यकता का वर्णन है

मेरे कार्यक्षेत्र में, विभिन्न परियोजनाएं हैं और मुझे आरएडी और ग्रहण आईडीई के साथ-साथ वेबस्पेयर, टॉमकैट और जेबस पर्यावरण पर अपना प्रोजेक्ट काम करना होगा .. मैंने परियोजना विशेष रूप से आरएडी और वेबस्पेयर और ग्रहण पर प्रोजेक्ट का काम करने के लिए बनाया है टॉमकेट एन जेबॉस ..

लेकिन कई फाइलों में बदलाव हैं जैसे कि क्लासपाथ n कुछ कॉन्फ़िग फाइलें

यह मुझे कार्यक्षेत्र के तीन संस्करणों के साथ छोड़ देता है

लेकिन मेरा विचार है कि क्लासपाथ के एकाधिक संस्करण के साथ एक वर्कस्पेस होना चाहिए। classpath_eclipse, classpath_rad आदि .. और एक चींटी स्क्रिप्ट है, जो उस प्रारूप के आधार पर सही फाइलों के बीच चयन करेगी, जिस पर निर्भर है

तो दोस्तों, कुछ तरीकों से सुझाव देते हैं कि मैं इस दृष्टिकोण को कैसे लागू कर सकता हूं। चींटी के लिए पूरी तरह से नया ।: /


Answers

मैं जटिल वर्गपथों के प्रबंधन के लिए अपाचे आईवी का उपयोग करने का सुझाव देता हूं। यह आपकी बिल्ड निर्भरताओं को एक अलग ivy.xml फ़ाइल में बाह्य बनाता है।

दूसरे, आइवी स्वचालित रूप से ऐसी निर्भरताएं डाउनलोड कर सकते हैं, जिससे स्रोत नियंत्रण के तहत आपकी परियोजना के आकार को कम कर सकते हैं।

अंत में, पहली नज़र में यह समाधान बेहद जटिल दिखाई दे सकता है। इसका फायदा यह है कि यह अन्य निर्माण प्रौद्योगिकियों जैसे कि मावेन के साथ संगत है।

उदाहरण

ivy.xml

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

इस उदाहरण में कोड SLF4J एपीआई जार के खिलाफ संकलित करता है, लेकिन रन-टाइम पर विभिन्न लॉगिंग कार्यान्वयन उपयोग करता है:

<ivy-module version="2.0">
    <info organisation="com.myspotontheweb" module="demo"/>

    <configurations>
        <conf name="compile" description="Required to compile application"/>
        <conf name="runtime.simple"  description="Runtime environment with minimal logging" extends="compile"/>
        <conf name="runtime.complex" description="Runtime environment with logback enabled" extends="compile"/>
        <conf name="test"    description="Required for test only" extends="runtime.simple"/>
        <conf name="build"   description="ANT tasks used by build"/>
    </configurations>

    <dependencies>
        <!-- compile dependencies -->
        <dependency org="org.slf4j" name="slf4j-api" rev="1.6.4" conf="compile->default"/>

        <!-- simple runtime dependencies -->
        <dependency org="org.slf4j" name="slf4j-simple" rev="1.6.4" conf="runtime.simple->default"/>

        <!-- complex runtime dependencies -->
        <dependency org="ch.qos.logback" name="logback-classic" rev="1.0.3" conf="runtime.complex->default"/>

        <!-- test dependencies -->
        <dependency org="junit" name="junit" rev="4.10" conf="test->default"/>

        <!-- Build dependencies -->
        <dependency org="org.codehaus.groovy" name="groovy-all" rev="1.8.6" conf="build->default"/>
    </dependencies>

</ivy-module>

टिप्पणियाँ:

  • विस्तार की सुविधा जार यूनियन सेट बनाने में सक्षम बनाता है
  • डिफ़ॉल्ट रूप से आइवी माइवेन सेंट्रल (एक खुली रिपोजिटरी जो अब लगभग 9 0% जावा ओपन सोर्स सॉफ़्टवेयर होस्ट करता है) से डाउनलोड करेगा।
  • Conf विशेषता का उपयोग करके आप अपने स्थानीय रूप से परिभाषित कॉन्फ़िगरेशन के एक या अधिक के खिलाफ एक अपवाद जुटा सकते हैं।
  • आइवी का उपयोग 3 पार्टी एएनटी कार्य निर्भरता को प्रबंधित करने के लिए भी किया जा सकता है

build.xml

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

<project name="demo" default="build" xmlns:ivy="antlib:org.apache.ivy.ant">

    <target name="init">
        <ivy:resolve/>

        <ivy:report todir='${ivy.reports.dir}' graph='false' xml='false'/>

        <ivy:cachepath pathid="compile.path" conf="compile"/>
        <ivy:cachepath pathid="runtime.simple.path" conf="runtime.simple"/>
        <ivy:cachepath pathid="runtime.complex.path" conf="runtime.complex"/>
        <ivy:cachepath pathid="test.path"    conf="test"/>
        <ivy:cachepath pathid="build.path"   conf="build"/>
    </target>
    ..
    ..

आइवी पुनः प्राप्त कार्य का उपयोग आपके अनुप्रयोग के पैकेजिंग चरण के दौरान एक निर्देशिका को पॉप्युलेट करने के लिए किया जाता है:

<target name="war">
    <ivy:retrieve pattern="${build.dir}/libs/[artifact].[ext]" conf="runtime.complex"/>

    <war destfile="myapp.war" webxml="src/metadata/myapp.xml">
        <fileset dir="${src.dir}/html/myapp"/>
        <fileset dir="${src.dir}/jsp/myapp"/>
        <lib dir="${build.dir}/libs"/>
        <classes dir="${build.dir}/classes"/>
    </war>
</target>

IDE कॉन्फ़िगरेशन फ़ाइलें

आईवी के लिए एक ग्रहण प्लगइन उपलब्ध है।

एम्बेडेड ग्रूवी कार्य का उपयोग करते हुए IDE कॉन्फ़िगरेशन फ़ाइलों को भी बनाना संभव है। निम्नलिखित एक ग्रहण उदाहरण है:

<target name="eclipse">
    <taskdef name="groovy" classname="org.codehaus.groovy.ant.Groovy" classpathref="build.path"/>

    <ivy:cachefileset setid="libfiles" conf="compile"/>

    <groovy>
    <arg value="${src.dir}"/>
    <arg value="${build.dir}/classes"/>

    import groovy.xml.MarkupBuilder

    //
    // Generate the project file
    //
    project.log("Creating .project")

    new File(".project").withWriter { writer ->
        def xml = new MarkupBuilder(writer)

        xml.projectDescription() {
            name(project.name)
            comment()
            projects()
            buildSpec() {
                buildCommand() {
                    name("org.eclipse.jdt.core.javabuilder")
                    arguments()
                }
            }
            natures() {
                nature("org.eclipse.jdt.core.javanature")
            }
        }
    }

    //
    // Generate the classpath file
    //
    // The "lib" classpathentry fields are populated using the ivy artifact report
    //
    project.log("Creating .classpath")

    new File(".classpath").withWriter { writer ->
        def xml = new MarkupBuilder(writer)

        xml.classpath() {
            classpathentry(kind:"src",    path:args[0])
            classpathentry(kind:"output", path:args[1])
            classpathentry(kind:"con",    path:"org.eclipse.jdt.launching.JRE_CONTAINER")

            project.references.libfiles.each {
                classpathentry(kind:"lib", path:it)
            }
        }
    }
    </groovy>        
</target>

मैं उस दृष्टिकोण को साझा करना चाहूंगा जिसे मैंने अंत में लागू किया था।

वहाँ project config xmls , settings और कुछ project config xmls थे जो रनटाइम पर निर्भर थे।

प्रत्येक प्रोजेक्ट में हमने प्रत्येक फ़ाइल का runtime_classpah और runtime_settings और configxml_runtime संस्करण बनाया है।

ant में एक target बनाया गया जो runtime को परम के रूप में लेता है, प्रत्येक प्रोजेक्ट के ऊपर आईट्रेट करता है और classpath_runtime की classpath_runtime सामग्रियों की प्रतिलिपि बनाता है, setting_runtime to settings

और एक लक्ष्य जो configxml सामग्री के साथ configxml_runtime


शीघ्र? Hm ... Ctrl + Shift + G के साथ सभी संदर्भ खोजें, फिर दृश्य मेनू (ड्रॉपडाउन त्रिकोण) के माध्यम से Search दृश्य (परिणाम) में फ़िल्टर करें। आप इन्हें फ़िल्टर करने के लिए वहां Reads चुन सकते हैं।

शॉर्टकट : चर के लिए कर्सर, मेनू Search > Write Access > Workspace । डिफ़ॉल्ट रूप से असाइन कीबाइंडिंग नहीं है, लेकिन आप इसे सामान्य रूप से कर सकते हैं ( Preferences > General > Keys )।





eclipse ant rad