Visualizzazione del timestamp del build in un'applicazione

Question

Vorrei visualizzare il timestamp di quando l'applicazione è stata compilata in una casella about. Questo mi permetterà di monitorare diverse versioni dell'applicazione. Come posso recuperare queste informazioni in Java?

Answer 1

È necessario comunicare al processo di compilazione di inserire il timestamp in un file di proprietà Java, da cui l'applicazione può quindi leggerlo. Un'altra buona opzione per metterlo sarebbe il file manifest jar.

Per ant, si desidera utilizzare le attività tstamp e property, vedere this for an example.

Mentre ci sei, potresti anche voler includere un numero di revisione del controllo sorgente.

Answer 2

per Maven:

Nel file di pom.xml, aggiungere il seguente

<resources> 
    <resource> 
    <directory>src/main/resources</directory> 
    <filtering>true</filtering> 
    </resource> 
</resources> 

<filters> 
    <filter>${basedir}/target/filter.properties</filter> 
</filters> 

usare Maven AntRun plugin per generare il tempo di costruzione,

<plugin> 
<groupId>org.apache.maven.plugins</groupId> 
<artifactId>maven-antrun-plugin</artifactId> 
<executions> 
    <execution> 
    <phase>generate-resources</phase> 
    <goals> 
     <goal>run</goal> 
    </goals> 
    <configuration> 
     <tasks> 
     <mkdir dir="${project.build.directory}"/> 
     <tstamp> 
      <format property="last.updated" 
      pattern="yyyy-MM-dd hh:mm:ss"/> 
     </tstamp> 
     <echo file="${basedir}/target/ 
    filter.properties" message="build.time=${last.updated}"/> 
     </tasks> 
    </configuration> 
    </execution> 
</executions> 
</plugin> 

quindi impostare il pom file per utilizzare il file manifest predefinito

<plugin> 
    <groupId>org.apache.maven.plugins</groupId> 
    <artifactId>maven-jar-plugin</artifactId> 
    <version>2.2</version> 
    <configuration> 

     <useDefaultManifestFile>true</useDefaultManifestFile> 

     <!-- 
     <archive> 
      <index>true</index> 
       <manifest> 
       <addClasspath>true</addClasspath> 
       <addDefaultImplementationEntries>true 
       </addDefaultImplementationEntries> 
       <addDefaultSpecificationEntries>true 
       </addDefaultSpecificationEntries> 
      </manifest> 

      <manifestEntries> 
       <Built-By>${user.name}</Built-By> 
       <Build-Jdk>${java.version}</Build-Jdk> 
      </manifestEntries> 
     </archive> 
     --> 
    </configuration> 

</plugin> 

Quindi MANIFEST.MF generato nel file jar sarà simile a questo.

Manifest-Version: 1.0 
Archiver-Version: Plexus Archiver 
Created-By: Apache Maven 
Built-By: admin 
Build-Jdk: 1.5.0_14 
Specification-Title: App Name 
Specification-Version: 0.1 - 2008-02-21 01:03:13 
Specification-Vendor: Company Name 
Implementation-Title: App Name 
Implementation-Version: 0.1 - 2008-02-21 01:03:13 
Implementation-Vendor: Company Name 
Build-Time: 2008-02-21 01:03:13 

Risorse

• This blog

• Maven cook book

---

per ANT

<?xml version="1.0"?> 

<project name="tstamp" basedir="." default="jar"> 
    <property name="src" value="src"/> 
    <property name="obj" value="obj"/> 
<property name="jar" value="tstamp"/> 

<target name="clean"> 
    <delete file="${jar}.jar"/> 
    <delete dir="${obj}"/> 
    <delete dir="${doc}"/> 
</target> 

    <target name="compile"> 
     <javac srcdir="${src}" destdir="${obj}" source="1.4" debug="true" 
deprecation="true" /> 
    </target> 

    <target name="jar" depends="compile"> 
    <tstamp/> 
     <jar jarfile="${jar}-${DSTAMP}${TSTAMP}.jar" compress="true"> 
    <fileset dir="${obj}" includes="**/*"/> 
    <fileset dir="${src}" includes="**/*"/> 
     </jar> 
    </target> 
</project> 
The above build.xml outputs a jarfile named 'tstamp-200307011540.jar' 

Resource

• tstamp documentation

• this blog

Answer 3

C'è una soluzione esperto di molto più semplice che non richiede il plugin antrun. Maven ha una variabile speciale maven.build.timestamp (da Maven 2.1.0-M1).

<plugin> 
    <artifactId>maven-war-plugin</artifactId> <!-- or maven-jar-plugin --> 
    <version>2.2</version> 
    <configuration> 
     <archive> 
      <manifestEntries> 
       <Build-Time>${maven.build.timestamp}</Build-Time> 
      </manifestEntries> 
     </archive> 
    </configuration> 
</plugin> 

Questo produrrà una riga "Build-Time: aaaaMMgg-HHmm". Il formato può essere personalizzato con:

<properties> 
    <maven.build.timestamp.format>yyyy-MM-dd HH:mm</maven.build.timestamp.format> 
</properties> 

Il modello deve essere conforme al formato di SimpleDateFormat.

Riferimento: Maven Documentation

Answer 4

normalmente seguono questo approccio alternativo al MANIFESTO, in quanto questo è facilmente raggiungibile da qualsiasi punto nelle nostre applicazioni.

package com.livngroup.sandbox; 

import java.io.File; 
import java.net.URL; 
import java.net.URLConnection; 
import java.util.Iterator; 

import org.apache.commons.io.FileUtils; 
import org.joda.time.DateTime; 

public enum Versioning { 

    INSTANCE; 

    public final DateTime buildTime; 

    private Versioning() { 
     this.buildTime = this.getLastModifiedDate(); 
    } 

    private DateTime getLastModifiedDate() { 
     try { 
      return new DateTime(this.getLastModifiedFile().lastModified()); 
     } catch (Exception e) { 
      try { 
       URLConnection conn = Versioning.class.getResource(Versioning.class.getSimpleName()+".class").openConnection(); 
       return new DateTime(conn.getLastModified()); 
      } catch (Exception e2) { 
       return new DateTime(0L); //Just a fallback 
      } 
     } 
    } 

    private File getLastModifiedFile() { 
     try { 

      URL url = Versioning.class.getResource(Versioning.class.getSimpleName()+".class"); 

      File dir = new File(url.toURI()).getParentFile().getParentFile().getParentFile().getParentFile().getParentFile(); 
      //System.out.println("classes.dir: "+dir); 

      String[] extensions = null; 

      File lastModifiedFile = null; 
      for (Iterator<File> iterator = FileUtils.iterateFiles(dir, extensions, true); iterator.hasNext();) { 
       File file = iterator.next(); 
       if(lastModifiedFile==null || FileUtils.isFileNewer(file, lastModifiedFile)) { 
        lastModifiedFile = file; 
       } 
      } 

      //System.out.println("lastModified: "+lastModified); 

      return lastModifiedFile; 

     } catch (Exception e) { 
      return null; 
     } 
    } 
} 

Ovviamente il tempo di costruzione può quindi facilmente accessibili come

Versioning.INSTANCE.buildTime