精华内容
下载资源
问答
  • 最近需要在项目中获取项目的版本号,最笨的方法莫过于硬编码一个版本号,当然我也是这么干的。不过闲下来的时候突发奇想Spring Boot项目中pom.xml定义的版本号能不能通过API获得呢...

    最近需要在项目中获取项目的版本号,最笨的方法莫过于硬编码一个版本号,当然我也是这么干的。不过闲下来的时候突发奇想Spring Boot项目中pom.xml定义的版本号能不能通过API获得呢?于是利用摸鱼的时间研究了这种无聊透顶的东西。

    目前大多数Spring Boot项目都会打成Jar包,所以什么War包、Ear包的就先不摸索了。

    Jar包的秘密

    我们先解压一个Spring Boot应用Jar包看看里面能不能找到一些蛛丝马迹。在META-INF文件夹中找到了两个相关的东西,一个是MANIFEST.MF

    Manifest-Version: 1.0
    Spring-Boot-Classpath-Index: BOOT-INF/classpath.idx
    Implementation-Title: spring-boot-version
    Implementation-Version: 1.0.23
    Spring-Boot-Layers-Index: BOOT-INF/layers.idx
    Start-Class: cn.felord.SpringBootVersionApplication
    Spring-Boot-Classes: BOOT-INF/classes/
    Spring-Boot-Lib: BOOT-INF/lib/
    Build-Jdk-Spec: 1.8
    Spring-Boot-Version: 2.4.5
    Created-By: Maven Jar Plugin 3.2.0
    Main-Class: org.springframework.boot.loader.JarLauncher
    

    里面包含了我定义的版本号1.0.23Implementation-Version这个值好像通过代码能够获得:

    String version = this.getClass().getPackage().getImplementationVersion()
    

    但是用IDE启动发现version=null,不过用java -jar运行时version = 1.0.23。可能与IDE运行并不是通过jar的方式有关。

    另一个是pom.properties:

    artifactId=spring-boot-version
    groupId=cn.felord
    version=1.0.23
    

    这岂不是读取Properties文件就可以了?

      String path = "META-INF/maven/cn.felord/spring-boot-version/pom.properties";
      ClassPathResource resource = new ClassPathResource(path);
    
      InputStream inputStream = resource.getInputStream();
      try (InputStreamReader reader = new InputStreamReader(inputStream)) {
          try (BufferedReader bufferedReader = new BufferedReader(reader)) {
              bufferedReader.lines()
                                    .forEach(System.out::println);
             }
         } catch (Exception ignored) {
    
      }
    

    依然只能从jar读取,而且比较麻烦。这两种方式都要依赖jar包,有木有不单纯依赖jar包的呢?

    从配置文件读取

    Maven在构建项目时可以通过资源插件将构建属性即pom.xml中的属性注入到指定的资源文件中,具体操作为:

    <build>
      ...
      <resources>
        <!-- include main.properties -->
        <resource>
          <directory>src/main/resources</directory>
          <filtering>true</filtering>
          <includes>
            <include>main.properties</include>
          </includes>
        </resource>
      </resources>
      ...
    </build>
    

    恰好spring-boot-starter-parent中已经设置了这种方式。

          <resource>
            <directory>${basedir}/src/main/resources</directory>
            <filtering>true</filtering>
            <includes>
              <include>**/application*.yml</include>
              <include>**/application*.yaml</include>
              <include>**/application*.properties</include>
            </includes>
          </resource>
    

    如果你是application.properties,你可以通过下面的方式来接收版本号:

    application.version = ${project.version}
    

    如果是application.yaml,你可以通过下面的方式来接收版本号:

    application:
      version: '@project.version@'
    

    然后如何取值就不用多说了吧。这种方式不依赖jar包,使用起来也很简单。

    Spring Boot提供

    Spring Boot其实已经内置了获取项目构建信息的自动配置ProjectInfoAutoConfiguration,它包含一个条件BeanBuildProperties

        @ConditionalOnResource(
            resources = {"${spring.info.build.location:classpath:META-INF/build-info.properties}"}
        )
        @ConditionalOnMissingBean
        @Bean
        public BuildProperties buildProperties() throws Exception {
            return new BuildProperties(this.loadFrom(this.properties
                                                     .getBuild()
                                                     .getLocation(), "build",                                                     this.properties
                                                     .getBuild().getEncoding()));
        }
    

    这个BuildProperties提供了不少构建信息:

    public class BuildProperties extends InfoProperties {
        public BuildProperties(Properties entries) {
            super(processEntries(entries));
        }
    
        public String getGroup() {
            return this.get("group");
        }
    
        public String getArtifact() {
            return this.get("artifact");
        }
    
        public String getName() {
            return this.get("name");
        }
    
        public String getVersion() {
            return this.get("version");
        }
    
        public Instant getTime() {
            return this.getInstant("time");
        }
       } 
    

    其中的条件build-info.properties可以通过Spring Boot插件spring-boot-maven-plugin执行下面的命令生成:

    mvn spring-boot:build-info
    

    我们只需要配置插件为:

    <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <executions>
            <execution>
                <goals>
                    <goal>
                        build-info
                    </goal>
                </goals>
            </execution>
        </executions>
    </plugin>
    

    就能使得BuildProperties生效,我们可以轻松取得相关的信息:

    {
      "version" : "1.0.23",
      "group" : "cn.felord",
      "artifact" : "spring-boot-version",
      "name" : "spring-boot-version",
      "time" : {
        "epochSecond" : 1620664643,
        "nano" : 591000000
      }
    }
    

    总结

    今天介绍了几种从通过API获取项目构建版本信息的方法,有什么用呢?主要用于项目监控,发版审计,DevOps等领域,包括Spring Boot的自定义banner也可以使用。算是一个锦上添花的小Tips,简单了解一下就好。

    往期推荐

    微信继续加持上班摸鱼功能!网友:离被开除更进一步...

    共同创造最好的OS,openEuler Developer Day 报名通道开启

    字节又莫名其妙发奖金了!网友:突然到账五万,吓得我差点报警...

    线上SQL脚本执行错了出事之后互相甩锅怎么办?

    三孩政策来了!网友:65岁没死,要带9个孙儿;限购两套房怎么分?

    推荐关注本文作者:码农小胖哥

    分享高质量编程知识,探讨IT人生

    技术干货,实战技巧,面试技巧,前沿资讯一个都不能少

    展开全文
  • java代码获取项目版本号实例 package com.hzcominfo.application.etl.settings.web.controller.highconfig; import ...

    java代码获取项目版本号实例

    package com.hzcominfo.application.etl.settings.web.controller.highconfig;
    
    import com.hzcominfo.application.common.base.cmpt.web.controller.index.BaseController;
    import org.apache.maven.model.Model;
    import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
    import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import java.io.File;
    import java.io.FileReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.URL;
    import java.util.Properties;
    
    @Controller
    @RequestMapping("/mavenTest/")
    public class MavenTest extends BaseController {
    
        /**
         * 是否是windows系统
         *
         * @return
         */
        private static boolean isWindows() {
            String osName = System.getProperty("os.name");
            if (osName != null && osName.toLowerCase().indexOf("win") >= 0) {
                return true;
            }
            return false;
        }
    
        /**
         * 查看jar包中maven版本号
         *
         * @return
         * @throws IOException
         * @throws XmlPullParserException
         */
        @ResponseBody
        @RequestMapping("test")
        public String getJarPath() throws IOException, XmlPullParserException {
            //查看jar包里面pom.properties版本号
            String jarPath = MavenTest.class.getProtectionDomain().getCodeSource().getLocation().getFile();
            jarPath = java.net.URLDecoder.decode(jarPath, "UTF-8");
            try {
                URL url = new URL("jar:file:" + jarPath + "!/META-INF/maven/com.hzcominfo.application.etl-settings/application-etl-settings/pom.properties");
                InputStream inputStream = url.openStream();
                Properties properties = new Properties();
                properties.load(inputStream);
                String version = properties.getProperty("version");
                return version;
            } catch (Exception e) {
                e.printStackTrace();
                //开发过程中查看pom.xml版本号
                MavenXpp3Reader reader = new MavenXpp3Reader();
                String basePath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
                if (isWindows() && basePath.startsWith("/")) {
                    basePath = basePath.substring(1);
                }
                if (basePath.indexOf("/target/") != -1) {
                    basePath = basePath.substring(0, basePath.indexOf("/target/"));
                }
                Model model = reader.read(new FileReader(new File(basePath + "\\pom.xml")));
                String version = model.getVersion();
                return version;
            }
        }
    }

     

    package com.hzcominfo.application.common.base.cmpt.web.controller.common.util;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.net.URL;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Properties;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import com.alibaba.fastjson.JSONObject;
    import com.hzcominfo.application.common.base.cmpt.web.controller.index.BaseController;
    import com.hzcominfo.application.common.util.DatetimeUtil;
    import com.hzcominfo.application.common.util.StringUtil;
    
    /**
     * 获取项目maven版本号
     *
     * @Author:linzp
     */
    @Controller
    @RequestMapping("/mavenVersion/")
    public class MavenVersion extends BaseController {
    
        @Value("${other.info:Copyright info}")
        private String otherInfo;
        
        /**
         * 查看jar包中maven版本号
         *
         * @return
         */
        @ResponseBody
        @RequestMapping("getVersion")
        public JSONObject getJarPath(String groupId, String artifactId,String jarName, String fileName) {
            JSONObject jSONObject = new JSONObject();
            Map<String, Object> versionInfo = new HashMap<String, Object>();
            //查看jar包里面pom.properties版本号
            try {
    //            String jarPath = MavenVersion.class.getProtectionDomain().getCodeSource().getLocation().getFile();
                String pomVersion = "";
                try{
                    String jarPath = System.getProperty("user.dir") + File.separator + jarName;
                    jarPath = java.net.URLDecoder.decode(jarPath, "UTF-8");
                    logger.info("version info : " + jarPath);
                    URL url = new URL("jar:file:" + jarPath + "!/META-INF/maven/" + groupId + "/" + artifactId + "/pom.properties");
                    Properties properties = new Properties();
                    properties.load(url.openStream());
                    pomVersion = properties.getProperty("version");
                }catch(Exception e){
                    logger.error("read jar or pom error:",e);
                }
                String version = "";
                if(StringUtil.isEmpty(fileName))fileName="version.txt";
    //            if(StringUtil.isNotEmpty(fileName)){
                    File otherInfoFile = new File(System.getProperty("user.dir") + File.separator + fileName);
                    Long filelength = otherInfoFile.length();  
                    byte[] filecontent = new byte[filelength.intValue()];  
                    try {  
                        FileInputStream in = new FileInputStream(otherInfoFile);  
                        in.read(filecontent);  
                        in.close();  
                        version += new String(filecontent, "utf-8");
                    } catch (FileNotFoundException e) {  
                        logger.error("version file not found :" , e);  
                    } catch (IOException e) {  
                        logger.error("version file read error :" , e);  
                    } 
    //            }
                versionInfo.put("versionInfo", version);
                versionInfo.put("pomVersion", pomVersion);
                versionInfo.put("jvmName", System.getProperty("java.vm.name"));
                versionInfo.put("jvmVendor", System.getProperty("java.vm.vendor"));
                versionInfo.put("javaVersion", System.getProperty("java.version"));
                versionInfo.put("otherInfo", otherInfo);
                versionInfo.put("serviceTime", DatetimeUtil.getDate());
                jSONObject.put("result", "0");
                jSONObject.put("versionInfo", versionInfo);
            } catch (Exception e) {
                e.printStackTrace();
                logger.error(e.getMessage());
                jSONObject.put("result", "1");
            }
            return jSONObject;
        }
        public static void aaa(){
    //        System.out.println(MavenVersion.class.getProtectionDomain().getCodeSource().getLocation().getFile());
    //        System.out.println(System.getProperty("java.vm.name"));
            System.out.println(DatetimeUtil.getDate());
        }
        public static void main(String[] args) {
    //        System.out.println(MavenVersion.class.getProtectionDomain().getCodeSource().getLocation().getFile());
            MavenVersion.aaa();
        }
    }
    versionDataFlag = true;
        
        function getVersionInfo(){
        if(versionDataFlag){
            versionDataFlag = false;
            //获取版本号
            $.ajax({
                type: "post",
                datatype: "json",
                async: true,
                url: rootPath + "/mavenVersion/getVersion",
                data: {
                    groupId: "com.hzcominfo.application.etl-settings",
                    artifactId: "application-etl-settings",
                    jarName: "etl.jar",
                    fileName: "version.txt"
                },
                success: function (data) {
                     versionDataFlag = true;
                     var resultObject = JSON.parse(data);
                    if (resultObject.result == "0") {
                        $("#versionInfo").text(resultObject.versionInfo.versionInfo);
                        $("#jvmName").text(resultObject.versionInfo.jvmName);
                        $("#jvmVendor").text(resultObject.versionInfo.jvmVendor);
                        $("#javaVersion").text(resultObject.versionInfo.javaVersion);
                        $("#serviceTime").text(resultObject.versionInfo.serviceTime);
                        //$("#projectVersionA").show();
                    } else {
                        //$("#projectVersionA").remove();
                        $("#versionInfo").text("");
                        $("#jvmName").text("");
                        $("#jvmVendor").text("");
                        $("#javaVersion").text("");
                        $("#serviceTime").text("");
                    } 
                     pageii = layer.open({
                      type: 1,
                      title: '关于',
                      shadeClose: true,
                      shade: 0.8,
                      area: ['400px', '250px'],
                      content: $("#aboutVersion").html() 
                      });
                },
                error: function(data){
                    versionDataFlag = true;
                    $("#versionInfo").text("");
                    $("#jvmName").text("");
                    $("#jvmVendor").text("");
                    $("#javaVersion").text("");
                    $("#serviceTime").text("");
                    pageii = layer.open({
                      type: 1,
                      title: '关于',
                      shadeClose: true,
                      shade: 0.8,
                      area: ['400px', '250px'],
                      content: $("#aboutVersion").html() 
                      });
                }
            });
           }
        }
        function closeAbout(){
            layer.close(pageii);
        }

     

    posted @ 2019-03-27 13:41 A点点圈圈A 阅读( ...) 评论( ...) 编辑 收藏
    展开全文
  • 获取jar版本信息的简单方法

    千次阅读 2017-08-10 10:45:41
    今天把一个java项目转换成maven项目的时候,发现有些包信息不明确,在porm中添加中无法确定哪一个才是我们需要对的。 以Gson为例,拿到我们需要的信息。  用解压软件打开后,能看到一个叫META-INF的目录...

    今天把一个java项目转换成maven项目的时候,发现有些包信息不明确,在porm中添加中无法确定哪一个才是我们需要对的。

    以Gson为例,拿到我们需要的信息。 

    用解压软件打开后,能看到一个叫META-INF的目录。在META-INF文件夹下,找到

    MANIFEST.MF文件,就能找到我们需要的信息。

     如上。

    展开全文
  • 主要介绍了详解SpringBoot获得Maven-pom中版本号和编译时间戳,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 如何查看jar包的版本号

    万次阅读 2018-01-18 09:37:15
    jar包根目录里的META-INF目录下的MANIFEST.MF文件里一般有会记录版本信息,可以到这个文件里查看 打开JavaJAR文件我们经常可以看到文件中包含着一个META-INF目录,这个目录下会有一些文件,其中必有一个MANIFEST....

    前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家。点击跳转到教程。

    jar包根目录里的META-INF目录下的MANIFEST.MF文件里一般有会记录版本信息,可以到这个文件里查看 
      打开Java的JAR文件我们经常可以看到文件中包含着一个META-INF目录,这个目录下会有一些文件,其中必有一个MANIFEST.MF,这个文件描述了该Jar文件的很多信息,下面将详细介绍MANIFEST.MF文件的内容,先来看struts.jar中包含的MANIFEST.MF文件内容: 
    Manifest-Version: 1.0 
    Created-By: Apache Ant 1.5.1 
    Extension-Name: Struts Framework 
    Specification-Title: Struts Framework 
    Specification-Vendor: Apache Software Foundation 
    Specification-Version: 1.1 
    Implementation-Title: Struts Framework 
    Implementation-Vendor: Apache Software Foundation 
    Implementation-Vendor-Id: org.apache 
    Implementation-Version: 1.1 
    Class-Path:  commons-beanutils.jar commons-collections.jar commons-digester.jar commons-logging.jar commons-validator.jar jakarta-oro.jar struts-legacy.jar 
    如果我们把MANIFEST中的配置信息进行分类,可以归纳出下面几个大类: 
    一. 一般属性 
    1. Manifest-Version 
    用来定义manifest文件的版本,例如:Manifest-Version: 1.0 
    2. Created-By 
    声明该文件的生成者,一般该属性是由jar命令行工具生成的,例如:Created-By: Apache Ant 1.5.1 
    3. Signature-Version 
    定义jar文件的签名版本 
    4. Class-Path 
    应用程序或者类装载器使用该值来构建内部的类搜索路径 
    二. 应用程序相关属性 
    1. Main-Class 
    定义jar文件的入口类,该类必须是一个可执行的类,一旦定义了该属性即可通过 java -jar x.jar来运行该jar文件。 
    三. 小程序(Applet)相关属性 
    1. Extendsion-List 
    该属性指定了小程序需要的扩展信息列表,列表中的每个名字对应以下的属性 
    2. <extension>-Extension-Name 
    3. <extension>-Specification-Version 
    4. <extension>-Implementation-Version 
    5. <extension>-Implementation-Vendor-Id 
    5. <extension>-Implementation-URL 
    四. 扩展标识属性 
    1. Extension-Name 
    该属性定义了jar文件的标识,例如Extension-Name: Struts Framework 
    五. 包扩展属性 
    1. Implementation-Title   定义了扩展实现的标题 

     

    2. Implementation-Version   定义扩展实现的版本  // 通常这就是我们要找的版本号

    3. Implementation-Vendor   定义扩展实现的组织  
    4. Implementation-Vendor-Id   定义扩展实现的组织的标识 
    5. Implementation-URL :   定义该扩展包的下载地址(URL) 
    6. Specification-Title   定义扩展规范的标题 
    7. Specification-Version   定义扩展规范的版本 
    8. Specification-Vendor   声明了维护该规范的组织 
    9. Sealed   定义jar文件是否封存,值可以是true或者false (这点我还不是很理解) 
    六. 签名相关属性 
    签名方面的属性我们可以来参照JavaMail所提供的mail.jar中的一段 
    Name: javax/mail/Address.class 
    Digest-Algorithms: SHA MD5 
    SHA-Digest: AjR7RqnN//cdYGouxbd06mSVfI4= 
    MD5-Digest: ZnTIQ2aQAtSNIOWXI1pQpw== 
    这段内容定义类签名的类名、计算摘要的算法名以及对应的摘要内容(使用BASE64方法进行编码) 
    七.自定义属性 
    除了前面提到的一些属性外,你也可以在MANIFEST.MF中增加自己的属性以及响应的值,例如J2ME程序jar包中就可能包含着如下信息 
    MicroEdition-Configuration: CLDC-1.0 
    MIDlet-Name: J2ME_MOBBER Midlet Suite 
    MIDlet-Info-URL: http://www.javayou.com/ 
    MIDlet-Icon: /icon.png 
    MIDlet-Vendor: Midlet Suite Vendor 
    MIDlet-1: mobber,/icon.png,mobber 
    MIDlet-Version: 1.0.0 
    MicroEdition-Profile: MIDP-1.0 
    MIDlet-Description: Communicator 
    关键在于我们怎么来读取这些信息呢?其实很简单,JDK给我们提供了用于处理这些信息的API,详细的信息请见java.util.jar包中,我们可以通过给JarFile传递一个jar文件的路径,然后调用JarFile的getManifest方法来获取Manifest信息。 
    更详细关于JAR文件的规范请见 
    http://java.sun.com/j2se/1.3/docs/guide/jar/jar.html 
    中文说明 

     

     

    http://www-900.ibm.com/developerWorks/cn/java/j-jar/

     

     

    展开全文
  • 经过试验,不管是否是 Jar 包,不管是否是 Tomcat 部署,以下三个方法均可实现。   package test;   public class MyPath {  public static String getProjectPath() {    java.net.URL url = ...
  • java获取系统信息(cpu,内存,硬盘)方法及jar包。还可以直接读出ip地址及使用的网卡。
  • JAVA获得版本号以及字节码编译版本

    千次阅读 2017-06-07 14:26:16
    公司的开发环境比较老,寻找一些jar包的时候总是会纠结对应的编译版本,感觉很麻烦,所以写了一个工具类用于读取class或jar文件的编译版本,供大家参考。 package com.jinggujin.util; import java.io....
  • 有时候查看人家的源代码,但有可能该软件有很多个版本,...当然了如果本身jar包名已经是用版本号来命名的。则不需要这样查看。 可以参看根据详细的说明 https://blog.csdn.net/can007/article/details/8299061 ...
  • 用shell命令一步步获取Java版本号

    千次阅读 2019-09-02 14:48:18
    1、打印java -version命令 echo $(java -version) 输出 java version "1.8.0_171" Java(TM) SE Runtime Environment (build 1.8.0_171-b11) Java HotSpot(TM) 64-Bit Server VM (build 25.171-b11, mixed mode) 2、...
  • java获取svn代码,是看到了scdn上的一位大神杰作来修改的,由于本人的粗心,那位大神的链接地址一时间找不到了。以后看到了一定补上链接,在这里对大神说声抱歉,以下奉上本人修改后的代码。 1.获取...
  • 以前这个gradle都是给Android使用的,万万没想到,Java的其它项目也能使用,甚至能替代maven或者说maven和gradle...产生出来的jar包带上这个git版本号,虽然不似svn那样一个简单的int数字就能说明版本,但是git的hash
  • 21个目标文件 摘要:JAVA源码,媒体网络,山寨QQ,Java聊天程序 Java编写的山寨QQ,多人聊天+用户在线,程序分服务端和客户端,典型C/S结构, 当用户发送第一次请求的时候,验证用户登录,创建一个该qq和服务器端保持...
  • Java读取Apk的版本号,包名,权限信息,支持的最小系统版本等系统等。无论是做后台开发,或者是android开发。有时候需要获取apk文件的版本号,包名,权限,以及支持最小系统版本等信息。比如在做apk更新的时候,如果...
  • maven 简单实用的配置,打包,获取svn版本号、仓库等等实用
  • java常用jar包详解

    万次阅读 多人点赞 2018-11-15 12:57:13
    SUN对于dt.jar的定义:Also includes dt.jar, the DesignTime archive of BeanInfo files that tell interactive development environments (IDE's) how to display the Java components and how to let the dev...
  • 分组表达式的应用 分组语法 (?\<name>exp) 匹配exp,并捕获文本到名称为name的组里,也可以写成(?'name'exp) demo public static void main(String[] args){ String path="userservice-v5";...
  • 项目中,经常把一部分功能独立出来,做一个java project,然后打成jar包供其他项目引用。这时候,如果jar包中需要读取配置文件信息,则很少把该配置打进jar包,因为它不方便修改,更多都是采用jar包读取外部配置文件...
  • 目录获取想要添加的依赖,或者jar包maven添加依赖手动导入jar包最后测试一下,是否添加成功 下面多图预警 获取想要添加的依赖,或者jar包 添加依赖 ,或者下载jar包,都可以去maven网站下载。 进入 Maven仓库:...
  • 一、国外官网获取JDK 历史版本下载方式... 2 二、windows上安装JDK. 6 1、JDK的.exe文件下载... 6 2、查看当前系统是否安装了JDK. 7 3、卸载JDK. 8 5、安装JDK和JRE. 8 6、Windows上配置JDK的环境变量... 11 ...
  • 经过试验,不管是否是 Jar 包,不管是否是 Tomcat 部署,以下三个方法均可实现。   package test;   public class MyPath {  public static String getProjectPath() {    java...
  • 获取JAVA当前进程PID的两种方法

    万次阅读 2017-07-14 19:45:13
    还以为要通过JNI或者通过Runtime.exec执行shell命令等方式才能获取当前进程的进程ID,今天在偶然中看到一种在Java程序里,获取当前进程ID的方法,记录下来,以后应该会用到:) 首先,从JDK1.5之后,Java...
  • 公司的开发环境比较老,寻找一些jar包的时候总是会纠结对应的编译版本,感觉很麻烦,所以写了一个工具类用于读取class或jar文件的编译版本,供大家参考。 package com.jinggujin.util; import java.io....
  •  //操作系统的版本号   super.response2Client(response, jsonObject.toString());   }     /**   * CPU信息   * @throws SigarException   */   @RequestMapping(value = "/cpu")  ...
  • 一、实现目标: 目标一、生成的war包名称根据[项目名称]_[系统版本号]_[SVN版本号]_[打包日期]格式自动生成war包。 目标二、系统主页可以展示当前系统的最新版本信息(以上... [SVN版本号]从SVN服务器获取; [打...
  • java -jar classpath设置

    千次阅读 2016-01-08 20:12:24
    当用java -jar yourJarExe.jar来运行一个经过打包的应用程序的时候,你会发现如何设置-classpath参数应用程序都找不到相应的第三方类,报ClassNotFound错误。实际上这是由于当使用-jar参数运行的时候,java VM会屏蔽...
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
     用JAVA编写了一个小工具,用于检测当前显示器也就是显卡的显示模式,比如分辨率,色彩以及刷新频率等。 Java波浪文字制作方法及源代码 1个目标文件 摘要:Java源码,初学实例,波浪文字  Java波浪文字,一个利用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 49,772
精华内容 19,908
关键字:

java获取当前jar版本号

java 订阅