संस्करण संख्या को टेक्स्ट फ़ाइल

Question

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

संपादित करें: मैंने दो कस्टम असेंबली बनाने के लिए मैवेन असेंबली प्लगइन और दो वर्णक का उपयोग करके सफलतापूर्वक इसे किया। एक में एक निर्देशिका-एकल लक्ष्य होता है और यह फ़िल्टरिंग के आधार पर अद्यतन संस्करण.txt के साथ एक फ़ोल्डर बनाता है। फिर एक ही लक्ष्य वाला दूसरा व्यक्ति वास्तव में ज़िप फ़ाइल को संकुल करता है। यह बहुत ही सुरुचिपूर्ण प्रतीत होता है और मुझे लगता है कि यह पूरी तरह से अद्यतन फ़ोल्डर के साथ मेवेन रेपो की तारीख ठीक से ऊपर नहीं होगा। अगर ऐसा करने का एक बेहतर तरीका है तो कृपया मुझे बताएं।

Answer 1

ज़रूर के हिस्से के रूप में प्रतिस्थापित किया जाएगा का उपयोग की जरूरत है। src/मुख्य/संसाधनों में कहीं एक पाठ फ़ाइल बनाएँ, इसे कहते version.txt (या जो भी)

फ़ाइल सामग्री:

${project.version} 

अपने pom.xml में

अब, निर्माण तत्व के अंदर, इस ब्लॉक कर दिया:

<build> 
    <resources> 
    <resource> 
     <directory>src/main/resources</directory> 
     <filtering>true</filtering> 
     <includes> 
     <include>**/version.txt</include> 
     </includes> 
    </resource> 
    <resource> 
     <directory>src/main/resources</directory> 
     <filtering>false</filtering> 
     <excludes> 
     <exclude>**/version.txt</exclude> 
     </excludes> 
    </resource> 
    ... 
    </resources> 
</build> 

प्रत्येक निर्माण के बाद, फ़ाइल (जिसे आप लक्ष्य/कक्षाओं में पा सकते हैं) में वर्तमान संस्करण होगा।

अब अगर आप फ़ाइल को कहीं और स्थानांतरित करना चाहते हैं, तो आपको शायद maven-antrun-plugin के माध्यम से एक चींटी कार्य निष्पादित करने की आवश्यकता होगी।

कुछ इस तरह:

<build> 
    ... 
    <plugins> 
     <plugin> 
     <artifactId>maven-antrun-plugin</artifactId> 
     <version>1.4</version> 
     <executions> 
      <execution> 
      <phase>process-resources</phase> 
      <configuration> 
       <tasks> 
       <copy file="${project.build.outputDirectory}/version.txt" 
        toFile="..." overwrite="true" /> 
       </tasks> 
      </configuration> 
      <goals> 
       <goal>run</goal> 
      </goals> 
      </execution> 
     </executions> 
     </plugin> 
    </plugins> 
</build> 

Answer 2

क्या आप के लिए filtering

कहा जाता है बात कर रहे हैं आप एक विशेष संसाधन के आधार पर फ़िल्टर सक्षम करने के लिए, और फिर ${project.version} जो अपने निर्माण

Answer 3

तुम भी एक संस्करण जानकारी फ़ाइल का उत्पादन करने के लिए एक ग्रूवी स्क्रिप्ट का उपयोग कर सकते हैं। मुझे यह विधि अधिक पसंद है क्योंकि आपको असेंबली-प्लगइन के डिस्क्रिप्टर में सामान को बाहर करने की आवश्यकता नहीं है। यदि आप जेनकींस/हडसन (उदाहरण के लिए oug BUILD_ID आदि ...) से बना रहे हैं तो आप वैकल्पिक रूप से उपलब्ध सामानों को वैकल्पिक रूप से उपलब्ध कराने के लिए इस विधि का उपयोग भी कर सकते हैं। pom.xml में

<plugin> 
    <groupId>org.codehaus.mojo.groovy</groupId> 
    <artifactId>groovy-maven-plugin</artifactId> 
    <version>1.0-beta-3</version> 
    <executions> 
     <execution> 
     <phase>test</phase> 
     <goals> 
      <goal>execute</goal> 
     </goals> 
     <configuration> 
      <source> 
     <![CDATA[ 
     println("==== Creating version.txt ===="); 
     File mainDir = new File("src/main"); 
     if(mainDir.exists() && !mainDir.isDirectory()) { 
      println("Main dir does not exist, wont create version.txt!"); 
      return; 
     } 
     File confDir = new File("src/main/conf"); 
     if(confDir.exists() && !confDir.isDirectory()) { 
      println("Conf dir is not a directory, wont create version.txt!"); 
      return; 
     } 
     if(!confDir.exists()) { 
      confDir.mkdir(); 
     } 
     File versionFile = new File("src/main/conf/version.txt"); 
     if(versionFile.exists() && versionFile.isDirectory()) { 
      println("Version file exists and is directory! Wont overwrite"); 
      return; 
     } 
     if(versionFile.exists() && !versionFile.isDirectory()) { 
      println("Version file already exists, overwriting!"); 
     } 
     println("Creating Version File"); 
     BufferedWriter writer = new BufferedWriter(new FileWriter(versionFile)); 

     writer.write("groupId = ${project.groupId}"); 
     writer.newLine(); 
     writer.write("artifactId = ${project.artifactId}"); 
     writer.newLine(); 
     writer.write("version = ${project.version}"); 
     writer.newLine(); 
     writer.write("timestamp = ${maven.build.timestamp}"); 

     String buildTag = ""; 
     String buildNumber = ""; 
     String buildId = ""; 
     try { 
      buildTag = "${BUILD_TAG}"; 
      buildNumber = "${BUILD_NUMBER}"; 
      buildId = "${BUILD_ID}"; 

      writer.write("BUILD_TAG = " + buildTag + "\n"); 
      writer.write("BUILD_NUMBER = " + buildNumber + "\n"); 
      writer.write("BUILD_ID = " + buildId + "\n"); 

     } catch (Exception e) { 
      println("============= Could not find BUILD_TAG probably this is not a Jenkins/Hudson build ==========="); 
     } 

     writer.close(); 
     ]]> 
      </source> 
     </configuration> 
     </execution> 
    </executions> 
    </plugin> 

और फिर अपने विधानसभा प्लगइन प्लगइन है कि इस तरह दिखेगा::

<plugin> 
    <artifactId>maven-assembly-plugin</artifactId> 
    <version>2.2.1</version> 
    <!-- Produce the all-dependencies-included jar for java classloaders --> 
    <executions> 
     <execution> 
     <id>all</id> 
     <phase>package</phase> 
     <goals> 
      <goal>single</goal> 
     </goals> 
     <configuration> 
      <finalName>${project.artifactId}</finalName> 
      <descriptors> 
      <descriptor>dist-all.xml</descriptor> 
      </descriptors> 
     </configuration> 
     </execution> 
    </executions> 
    </plugin> 

तो तुम एक फ़ाइल पैदा करने ग्रूवी इस तरह pom.xml में स्क्रिप्ट के लिए होता है

और अंत में अपने विधानसभा वर्णनकर्ता जिले-all.xml इस प्रकार दिखाई देगा:

<?xml version="1.0" encoding="UTF-8"?> 
<assembly> 
    <id>all</id> 
    <formats> 
    <format>dir</format> 
    <format>zip</format> 
    </formats> 
    <includeBaseDirectory>false</includeBaseDirectory> 
    <fileSets> 
    <fileSet> 
     <directory>target</directory> 
     <outputDirectory></outputDirectory> 
     <includes> 
     <include>*.jar</include> 
     </includes> 
    </fileSet> 
    <fileSet> 
     <directory>src/main/conf</directory> 
     <outputDirectory></outputDirectory> 
     <includes> 
     <include>**</include> 
     </includes> 
    </fileSet> 
    </fileSets> 
</assembly> 

Answer 4

स्टेशन का प्रयोग करें ndard META-INF\MANIFEST.MF (फिर आप संस्करण प्राप्त करने के लिए जावा कोड getClass().getPackage().getImplementationVersion() का उपयोग कर सकते हैं)

के लिए।इस विन्यास युद्ध उपयोग:

<plugin> 
    <artifactId>maven-war-plugin</artifactId> 
    <version>2.1</version> 
    <configuration> 
     <archive>     
      <manifest> 
       <addDefaultImplementationEntries>true</addDefaultImplementationEntries> 
       <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries> 
      </manifest> 
     </archive> 
    </configuration> 
</plugin> 

, निर्माण के दौरान प्रकट जोड़ने यही होगा, या आप mvn war:manifest

देखें कॉल कर सकते हैं भी How to get package version at running Tomcat?

Answer 5

Maven 3 में, उपयोग Sean's answer अपने version.txt फ़ाइल बनाने के लिए (मेरा है बिल्ड तिथि और सक्रिय प्रोफाइल के साथ यहां दिखाया गया है:

${project.version}-${profileID} 
${buildDate} 

संपत्ति जोड़ने 012 उत्पादन इस तरह दिखता है

<plugin> 
    <groupId>org.apache.maven.plugins</groupId> 
    <artifactId>maven-resources-plugin</artifactId> 
    <version>3.0.2</version> 
    <executions> 
     <execution> 
      <id>copy-resources</id> 
      <phase>validate</phase> 
      <goals> 
       <goal>copy-resources</goal> 
      </goals> 
      <configuration> 
       <outputDirectory>${basedir}</outputDirectory> 
       <resources> 
        <resource> 
         <directory>${basedir}/target/.../[version.txt dir]/version.txt</directory> 
         <includes> 
          <include>version.txt</include> 
         </includes> 
         <filtering>true</filtering> 
        </resource> 
       </resources> 
      </configuration> 
     </execution> 
    </executions> 
</plugin> 

:

<properties> 
    <profileID>profileName</profileID> 
</properties> 

उपयोग Maven कॉपी-संसाधन निर्देशिका ऐसे ${basedir} के रूप में या ${basedir}/target तक पहुँचने के लिए आसान एक पर फ़ाइल की प्रतिलिपि करने के लिए: प्रोफाइल, जैसे से प्रत्येक के लिए

1.2.3-profileName 
yymmdd_hhmm 

Answer 6

एक संभावना maven-properties-plugin का उपयोग कर सभी परियोजना गुणों को स्टोर करने की संभावना है।
फिर आप मानक (हालांकि बहुत व्यावहारिक नहीं) Java Properties API का उपयोग कर इन गुणों को पढ़ सकते हैं।

 <!-- Build properties to a file --> 
     <plugin> 
      <groupId>org.codehaus.mojo</groupId> 
      <artifactId>properties-maven-plugin</artifactId> 
      <version>1.0.0</version> 
      <executions> 
       <execution> 
        <phase>generate-resources</phase> 
        <goals> <goal>write-project-properties</goal> </goals> 
        <configuration> 
         <outputFile> ${project.build.outputDirectory}/build.properties </outputFile> 
        </configuration> 
       </execution> 
      </executions> 
     </plugin> 

इस दृष्टिकोण के साथ सावधान रहो के रूप में यह गुण है कि settings.xml से खत्म करने के लिए प्रकाशित किया, यह भी नहीं जा सकते लीक कर सकते हैं।

Answer 7

शॉन के उत्तर में जोड़ने के लिए, आप संस्करण फ़ाइल को संसाधन के भीतर लक्ष्यपथ पैरामीटर का उपयोग कर जार के भीतर किसी फ़ोल्डर स्थान पर ले जा सकते हैं। निम्न कोड जार के भीतर 'संसाधन' नामक फ़ोल्डर बनाता है और उस फ़ोल्डर में टेक्स्ट फ़ाइल (संस्करण.नंबर) पाई जाती है।

<resource> 
    <directory>resources</directory> 
    <targetPath>resources</targetPath> 
    <filtering>true</filtering> 
    <includes> 
     <include>version.number</include> 
    </includes> 
</resource> 
<resource> 
    <directory>resources</directory> 
    <filtering>false</filtering> 
    <excludes> 
     <exclude>version.number</exclude> 
    </excludes> 
</resource> 

Answer 8

मैंने अभी यह चींटी कार्य के साथ किया है।

<echo file="version.txt">${project.version}</echo>