एकाधिक जार गठबंधन करने के लिए साफ तरीका? वांछित रूप से चींटी

Question

का उपयोग करके मेरे पास कुछ बाहरी जारों पर रनटाइम निर्भरता है जो मैं एक जार में "रेजर" करना चाहता हूं। ये बाह्य निर्भरता बाहरी_जेर्स निर्देशिका में संग्रहीत हैं, और मैं उन्हें सभी को सूचीबद्ध करने में सक्षम नहीं होना चाहूंगा (यानी, मेरी निर्भरता बदलते समय मेरी बिल्ड स्क्रिप्ट को बदलने की आवश्यकता नहीं है)। कोई विचार?

गूगल मुझे ऐसा करने के तरीके पर एक अच्छा जवाब दिया - यदि आप एक निर्भरता के रूप में प्रत्येक जार बाहर लिस्टिंग कोई आपत्ति नहीं है:

http://markmail.org/message/zijbwm46maxzzoo5

मोटे तौर पर, मैं निम्नलिखित की तर्ज पर कुछ चाहते हैं , जो lib. निर्देशिका में सभी जार को out.jar में जोड़ देगा (कुछ सेन ओवरराइट नियमों के साथ)।

http://code.google.com/p/jarjar/

Answer 1

बस चींटी Zip task

<zip destfile="out.jar"> 
    <zipgroupfileset dir="lib" includes="*.jar"/> 
</zip> 

इस के साथ zipgroupfileset का उपयोग सभी शामिल जार पुस्तकालयों 'सामग्री समतल होगा।

Answer 2

आप jarjar की जाँच कर सकता है

<target name="combine-jars"> 
    <mkdir dir="${marshall.dir}"/> 
    <unzip dest="${marshall.dir}"> 
     <fileset dir="${external.jar.dir}"> 
      <include name="**/*.jar"/> 
     </fileset> 
    </unzip> 
    <jar destfile="${combined.jar}" basedir="${marshall.dir"}> 
    <delete dir="${marshall.dir}"/> 
</target> 

कहाँ ${marshall.dir} एक अस्थायी निर्देशिका है, ${external.jar.dir} जहां है जार को रखें, और ${combined.jar} लक्ष्य जार है।

Answer 3

पहले एक मार्शलिंग निर्देशिका में अपनी जार के निकालने का प्रयास करें::

jar -combine -out out.jar -in lib/*.jar 

Answer 4

क्या आपने Maven या कुछ अन्य सिस्टम का उपयोग करने पर विचार किया है जो आपकी निर्भरताओं को स्वचालित रूप से प्रबंधित करता है? फिर आपको यह निर्दिष्ट करने की आवश्यकता नहीं होगी कि प्रत्येक लाइब्रेरी कहां स्थित है, उनके नाम क्या हैं, और आपकी प्रत्यक्ष निर्भरताओं की क्या ट्रांजिटिव निर्भरताएं हैं। आप केवल एक ही स्थान पर बताएंगे कि निर्भरता और इसका संस्करण क्या है, और सिस्टम पुस्तकालयों को डाउनलोड करने, कक्षापथ को कॉन्फ़िगर करने और परियोजना के निर्माण की देखभाल करेगा।

Answer 5

व्लादिमीर जवाब एक सही है, लेकिन मुझे लगता है कि वह क्या सुझाव दिया गया है एक बड़ा out.jar है, जो तब एक भी <zipfileset> या ऐसा ही कुछ के रूप में चींटी जार कार्य करने के लिए feeded है में सभी जार repacking निकलता है। यह दो-चरणीय दृष्टिकोण अनावश्यक है। मुझे यकीन नहीं है कि यह चींटी संस्करण से जुड़ा हुआ है, लेकिन मेरे पास Ant 1.7.1 है, और इसके <jar> कार्य <zipgroupfileset> को समझता है, जो सीधे तृतीय पक्ष जार की सभी सामग्री को फ़ीड करने की अनुमति देता है।

<jar destfile="MyApplication.jar"> 
    <zipgroupfileset dir="lib" includes="*.jar" /> 
    <!-- other options --> 
    <manifest> 
    <attribute name="Main-Class" value="Main.MainClass" /> 
    </manifest> 
</jar> 

Answer 6

ठीक है, मैं प्रोग्रामिंग करने के लिए में इतना नहीं कर रहा हूँ - लेकिन कुछ सरल मेरे लिए काम किया ... अगर सवाल का मतलब है - एक करने के लिए जार फ़ाइलों के संयोजन। संभोग, यह मैनुअल, गंदे समाधान है। मैंने बस सभी टैरों को अनदेखा कर दिया ... और फिर .. नई टैर फ़ाइल में अनारक्षित द्वारा बनाई गई सभी निर्देशिकाओं को जोड़कर, एक नई टैर फ़ाइल बनाई गई। इसने काम कर दिया।

Answer 7

मेवेन या अन्य निर्माण उपकरण कक्षा फ़ाइलों के कई संस्करणों के संकल्प को "प्रबंधित" नहीं कर सकते हैं। वास्तव में, मेवेन इन समस्याओं को पहली जगह में, सभी डाउनस्ट्रीम जार फ़ाइलों के संक्रमणीय समावेशन के माध्यम से उत्पन्न करता है जिन्हें स्पष्ट रूप से किसी प्रोजेक्ट द्वारा आवश्यक नहीं है।

मान लीजिए कि किसी परियोजना के संक्रमणीय बंद होने पर (परियोजना द्वारा आवश्यक सभी पुस्तकालयों और मॉड्यूल, और इसकी सभी निर्भर परियोजनाएं, पुनरावर्ती) कक्षा वर्ग के दो संस्करण हैं।मेवेन को संभवतः पता चलेगा कि कौन सा 'सही' है? प्रोग्रामर द्वारा कौन सा उद्देश्य था?

ऐसा इसलिए नहीं हो सकता क्योंकि यह जानकारी तब खो गई जब स्पष्ट निर्भरताओं को संक्रमित लोगों (एक्सएमएल टाइपिंग को बचाने के लिए) में फेंक दिया गया था।

<target name="-post-jar"> 
    <echo>Packaging ${application.title} into a single JAR</echo> 

    <jar destfile="${basedir}${file.separator}${dist.dir}${file.separator}_${ant.project.name}_.jar"> 
     <zipgroupfileset dir="${basedir}${file.separator}${dist.dir}" includes="${ant.project.name}.jar"/> 
     <zipgroupfileset dir="${basedir}${file.separator}${dist.dir}${file.separator}lib" includes="*.jar"/> 
     <manifest> 
      <attribute name="Main-Class" value="${main.class}"/> 
     </manifest> 
    </jar> 
</target> 

Answer 8

यह मेरा समाधान है? :) बस मेवेन-शेड-प्लगइन का उपयोग करें, एक आकर्षण की तरह काम करता है!

<project> 
    ... 
    <build> 
    <plugins> 
     <plugin> 
     <groupId>org.apache.maven.plugins</groupId> 
     <artifactId>maven-shade-plugin</artifactId> 
     <version>1.5</version> 
     <executions> 
      <execution> 
      <phase>package</phase> 
      <goals> 
       <goal>shade</goal> 
      </goals> 
      <configuration> 
       <transformers> 
       <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer"> 
        <mainClass>com.YOUR_COMPANY.YOUR_MAIN_CLASS</mainClass> 
       </transformer> 
       </transformers> 
      </configuration> 
      </execution> 
     </executions> 
     </plugin> 
    </plugins> 
    </build> 
    ... 
</project> 

Answer 9

Maven का उपयोग कर, तुम क्यों नहीं होता हैं:

Answer 10

प्रश्न का उत्तर अच्छी तरह से दिया गया है। मैं एक उपकरण का उल्लेख करना चाहता था जो मुझे उपयोगी लगता है - One-Jar। वन-जार संसाधनों को अधिक स्वच्छता से नियंत्रित करता है (उन सभी को रखकर)। यह अधिक उपयोगी है, तो कोड process MANIFEST files.

नमूना XML वेबसाइट से नकल करने की जरूरत है ..

<import file="one-jar-ant-task.xml"/> 

    <target name="hello" depends="init"> 
     <!-- Build lib.jar --> 
     <javac destdir="${classes.dir}/lib"> 
      <src path="${lib.dir}" /> 
     </javac> 
     <jar destfile="${build.dir}/lib.jar" > 
      <fileset dir="${classes.dir}/lib"/> 
     </jar> 
     <!-- Build classes for main.jar --> 
     <javac destdir="${classes.dir}/src"> 
      <src path="${src.dir}" /> 
      <classpath path="${build.dir}/lib.jar"/> 
     </javac> 
     <!-- Construct the One-JAR file --> 
     <one-jar destfile="hello.jar" manifest="hello.mf"> 
      <main> 
       <!-- Construct main.jar from classes and source code --> 
       <fileset dir="${classes.dir}/src"/> 
      </main> 
      <lib> 
       <fileset file="${build.dir}/lib.jar" /> 
      </lib> 
     </one-jar> 
     <echo> 
      Now you can run the Hello One-JAR example using 
      $ java -jar hello.jar 
     </echo> 

    </target> 

Answer 11

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

उदाहरण मेरे लक्ष्य है कि .jar फ़ाइल का निर्माण किया गया था के लिए

था:

<jar destfile="${plugin.jar}" basedir="${plugin.build.dir}"> 
    <manifest> 
     <attribute name="Author" value="ntg"/> 
     ................................ 
     <attribute name="Plugin-Version" value="${version.entry.commit.revision}"/> 
    </manifest> 
</jar> 

मैं सिर्फ बनाने के लिए यह एक पंक्ति कहा:

<jar ...."> 
    <zipgroupfileset dir="${external-lib-dir}" includes="*.jar"/> 
    <manifest> 
     ................................ 
    </manifest> 
</jar> 

जहां

<property name="external-lib-dir" value="C:\...\eclipseWorkspace\Filter\external\...\lib" /> 

था बाहरी जार के साथ डीआईआर। और यह है ... आप कई ज़िप समूह समूह टैग भी जोड़ सकते हैं।