这篇文章首先介绍了在SpringBoot中如何获得项目的编译时间和版本号,并向外提供接口,然后介绍了介绍了新版maven获得时间戳时区错误的解决方案,最后介绍了把时间戳加到包名的两种方法。
SpringBoot项目获得编译时间戳和版本号,然后提供接口大概分为以下步骤:
application.yml
在 pom文件 properties 中添加两个属性
properties
<properties> <!--maven.build.timestamp保存了maven编译时间戳--> <timestamp>${maven.build.timestamp}</timestamp> <!--指定时间格式--> <maven.build.timestamp.format>yyyy-MM-dd HH:mm:ss</maven.build.timestamp.format> </properties> 用Maven属性渲染application.yml 在pom文件build中配置 <build> <resources> <resource> <directory>src/main/resources</directory> <filtering>true</filtering> </resource> </resources> </build> 在application.yml中配置 不能使用${} app: version: @project.version@ build: time: @timestamp@ 创建AppController,提供接口 Get /app package cn.yshow.modules.sys.controller; import cn.yshow.common.utils.restResult.RestResult; import cn.yshow.common.utils.restResult.ResultGenerator; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Value; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import java.util.HashMap; import java.util.Map; * @author zhaod zhaodongxx@outlook.com * @version v1.0 * @since 2018/12/16 16:19 @Slf4j @RestController @RequestMapping("/app") public class AppController { * 当前版本 @Value("${app.version}") private String version; * 打包时间 @Value("${app.build.time}") private String buildTime; @GetMapping public RestResult uploadImg() { Map<String,String> ret = new HashMap<>(); ret.put("version",version); ret.put("buildTime",buildTime); //RestResult是我封装的返回对象 return ResultGenerator.genSuccessResult(ret); 用YAPI测试如下 maven.build.timestamp时区错误解决方案 在Maven 3.2.2+中, maven.build.timestamp已被重新定义,显示UTC中的时间,比中国时间慢8个小时。可以使用插件build-helper-maven-plugin获得本时区的时间 在plugins块添加插件,这个配置与官网不一样,按照官网的配置方式会报错 <project> <build> <!--指定包名 --> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> <plugins> <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <id>timestamp-property</id> <goals> <goal>timestamp-property</goal> </goals> </execution> </executions> <configuration> <name>build.time</name> <pattern>yyyy-MM-dd HH:mm</pattern> <timeZone>GMT+8</timeZone> </configuration> </plugin> </plugins> </build> </project> 经过上述处理后,属性${build.time}已经代表GMT-8时区的时间 application.yml配置如下 app: version: @project.version@ build: time: @build.time@ IDEA 编译项目不会调用 maven 生命周期,导致安装的 plugin 不被执行。虽然 maven 自带变量可以被替换,但是自定义变量却不会被替换。 可以将 IDEA 的 Build 与 maven goal 绑定起来,在 build 之前执行 maven goal,IDEA 右侧 Maven Projects -> LifeCycle -> compile 勾选 Execute After Build和Execute After Rebuild ,如下图 把时间戳加到包名 两种方法不要重复,否则 方法一:把时间戳加到版本号 <project> <versioin> 0.0.5.${build.time} </version> </project> 方法二:把时间戳直接加到包名 <project> <build> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> </build> </project> maven 打包时间戳问题 这篇文章介绍了在SpringBoot中如何获得项目的编译时间和版本号,主要分为以下步骤在pom文件中获取maven的build time配置pom,用maven中的变量替换资源文件中的属性提供接口Maven中获得编译时间在 pom文件properties 中添加两个属性&amp;amp;amp;amp;amp;lt;properties&amp;amp;amp;amp;amp;gt; &amp;amp;amp;amp;amp;lt;!--maven.build 今天发布项目到测试环境, 发布完成后, 一直启动不起来, 查看日志发现java.lang.OutOfMemoryError: Java heap space. java.lang.OutOfMemoryError: Java heap space Dumping heap to /dump/dump.hprof Unable to create /dump/dump.hprof: File e... <!--指定时间格式--> <maven.build.timestamp.format>yyyy-MM-dd HH:mm:ss</maven.build.timestamp.format> <!--maven.build.timestamp保存了maven编译时间戳--& Maven中的dependencyManagement 意义 **1、**在Maven中dependencyManagement的作用其实相当于一个对所依赖jar包进行版本管理的管理器。 **2、**pom.xml文件中,jar的版本判断的两种途径 如果dependencies里的dependency自己没有声明version元素,那么maven就会到dependencyManagement里面去找有没有对该artifactId和groupId进行过版本声明,如果有,就继承它,如果没有就会报错,告诉你必 <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <!-- 工程主入口--> 在 Spring Boot 中,依赖的版本号通常是在 POM 文件中管理的,这是因为 Spring Boot 带有许多预定义的依赖项,这些依赖项是在 Spring Boot 的 POM 文件中定义的。当您使用 Spring Boot Starter 依赖项时,它会传递引用这些依赖项。 当多个依赖项定义了相同的库时,Maven 将使用最接近您项目中的依赖项的版本。以下是 Maven 中的依赖项解析顺序: 1. 本地的 repository 2. 中央 repository 3. 远程的其他 repository 当 Maven 找到相同的库时,它将使用最近的版本。在一个依赖项中指定的版本优先级高于传递依赖项中的版本。如果您需要强制使用特定版本的库,可以在您项目的 POM 文件中直接指定它们的版本号。 对于 Spring Boot 应用程序,建议使用 Spring Boot 的版本管理方式管理您的依赖项版本。Spring Boot 使用的版本管理方法可以确保所有的依赖项都是兼容的,并且可以提供一致的开发体验。如果您需要使用不在 Spring Boot 管理的库,可以通过在您的 POM 文件中显式指定版本号来覆盖 Spring Boot 的版本号。
<properties> <!--maven.build.timestamp保存了maven编译时间戳--> <timestamp>${maven.build.timestamp}</timestamp> <!--指定时间格式--> <maven.build.timestamp.format>yyyy-MM-dd HH:mm:ss</maven.build.timestamp.format> </properties>
用Maven属性渲染application.yml 在pom文件build中配置 <build> <resources> <resource> <directory>src/main/resources</directory> <filtering>true</filtering> </resource> </resources> </build> 在application.yml中配置 不能使用${} app: version: @project.version@ build: time: @timestamp@ 创建AppController,提供接口 Get /app package cn.yshow.modules.sys.controller; import cn.yshow.common.utils.restResult.RestResult; import cn.yshow.common.utils.restResult.ResultGenerator; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Value; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import java.util.HashMap; import java.util.Map; * @author zhaod zhaodongxx@outlook.com * @version v1.0 * @since 2018/12/16 16:19 @Slf4j @RestController @RequestMapping("/app") public class AppController { * 当前版本 @Value("${app.version}") private String version; * 打包时间 @Value("${app.build.time}") private String buildTime; @GetMapping public RestResult uploadImg() { Map<String,String> ret = new HashMap<>(); ret.put("version",version); ret.put("buildTime",buildTime); //RestResult是我封装的返回对象 return ResultGenerator.genSuccessResult(ret); 用YAPI测试如下 maven.build.timestamp时区错误解决方案 在Maven 3.2.2+中, maven.build.timestamp已被重新定义,显示UTC中的时间,比中国时间慢8个小时。可以使用插件build-helper-maven-plugin获得本时区的时间 在plugins块添加插件,这个配置与官网不一样,按照官网的配置方式会报错 <project> <build> <!--指定包名 --> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> <plugins> <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <id>timestamp-property</id> <goals> <goal>timestamp-property</goal> </goals> </execution> </executions> <configuration> <name>build.time</name> <pattern>yyyy-MM-dd HH:mm</pattern> <timeZone>GMT+8</timeZone> </configuration> </plugin> </plugins> </build> </project> 经过上述处理后,属性${build.time}已经代表GMT-8时区的时间 application.yml配置如下 app: version: @project.version@ build: time: @build.time@ IDEA 编译项目不会调用 maven 生命周期,导致安装的 plugin 不被执行。虽然 maven 自带变量可以被替换,但是自定义变量却不会被替换。 可以将 IDEA 的 Build 与 maven goal 绑定起来,在 build 之前执行 maven goal,IDEA 右侧 Maven Projects -> LifeCycle -> compile 勾选 Execute After Build和Execute After Rebuild ,如下图 把时间戳加到包名 两种方法不要重复,否则 方法一:把时间戳加到版本号 <project> <versioin> 0.0.5.${build.time} </version> </project> 方法二:把时间戳直接加到包名 <project> <build> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> </build> </project> maven 打包时间戳问题 这篇文章介绍了在SpringBoot中如何获得项目的编译时间和版本号,主要分为以下步骤在pom文件中获取maven的build time配置pom,用maven中的变量替换资源文件中的属性提供接口Maven中获得编译时间在 pom文件properties 中添加两个属性&amp;amp;amp;amp;amp;lt;properties&amp;amp;amp;amp;amp;gt; &amp;amp;amp;amp;amp;lt;!--maven.build 今天发布项目到测试环境, 发布完成后, 一直启动不起来, 查看日志发现java.lang.OutOfMemoryError: Java heap space. java.lang.OutOfMemoryError: Java heap space Dumping heap to /dump/dump.hprof Unable to create /dump/dump.hprof: File e... <!--指定时间格式--> <maven.build.timestamp.format>yyyy-MM-dd HH:mm:ss</maven.build.timestamp.format> <!--maven.build.timestamp保存了maven编译时间戳--& Maven中的dependencyManagement 意义 **1、**在Maven中dependencyManagement的作用其实相当于一个对所依赖jar包进行版本管理的管理器。 **2、**pom.xml文件中,jar的版本判断的两种途径 如果dependencies里的dependency自己没有声明version元素,那么maven就会到dependencyManagement里面去找有没有对该artifactId和groupId进行过版本声明,如果有,就继承它,如果没有就会报错,告诉你必 <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <!-- 工程主入口--> 在 Spring Boot 中,依赖的版本号通常是在 POM 文件中管理的,这是因为 Spring Boot 带有许多预定义的依赖项,这些依赖项是在 Spring Boot 的 POM 文件中定义的。当您使用 Spring Boot Starter 依赖项时,它会传递引用这些依赖项。 当多个依赖项定义了相同的库时,Maven 将使用最接近您项目中的依赖项的版本。以下是 Maven 中的依赖项解析顺序: 1. 本地的 repository 2. 中央 repository 3. 远程的其他 repository 当 Maven 找到相同的库时,它将使用最近的版本。在一个依赖项中指定的版本优先级高于传递依赖项中的版本。如果您需要强制使用特定版本的库,可以在您项目的 POM 文件中直接指定它们的版本号。 对于 Spring Boot 应用程序,建议使用 Spring Boot 的版本管理方式管理您的依赖项版本。Spring Boot 使用的版本管理方法可以确保所有的依赖项都是兼容的,并且可以提供一致的开发体验。如果您需要使用不在 Spring Boot 管理的库,可以通过在您的 POM 文件中显式指定版本号来覆盖 Spring Boot 的版本号。
在pom文件build中配置
build
<build> <resources> <resource> <directory>src/main/resources</directory> <filtering>true</filtering> </resource> </resources> </build> 在application.yml中配置 不能使用${} app: version: @project.version@ build: time: @timestamp@ 创建AppController,提供接口 Get /app package cn.yshow.modules.sys.controller; import cn.yshow.common.utils.restResult.RestResult; import cn.yshow.common.utils.restResult.ResultGenerator; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Value; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import java.util.HashMap; import java.util.Map; * @author zhaod zhaodongxx@outlook.com * @version v1.0 * @since 2018/12/16 16:19 @Slf4j @RestController @RequestMapping("/app") public class AppController { * 当前版本 @Value("${app.version}") private String version; * 打包时间 @Value("${app.build.time}") private String buildTime; @GetMapping public RestResult uploadImg() { Map<String,String> ret = new HashMap<>(); ret.put("version",version); ret.put("buildTime",buildTime); //RestResult是我封装的返回对象 return ResultGenerator.genSuccessResult(ret); 用YAPI测试如下 maven.build.timestamp时区错误解决方案 在Maven 3.2.2+中, maven.build.timestamp已被重新定义,显示UTC中的时间,比中国时间慢8个小时。可以使用插件build-helper-maven-plugin获得本时区的时间 在plugins块添加插件,这个配置与官网不一样,按照官网的配置方式会报错 <project> <build> <!--指定包名 --> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> <plugins> <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <id>timestamp-property</id> <goals> <goal>timestamp-property</goal> </goals> </execution> </executions> <configuration> <name>build.time</name> <pattern>yyyy-MM-dd HH:mm</pattern> <timeZone>GMT+8</timeZone> </configuration> </plugin> </plugins> </build> </project> 经过上述处理后,属性${build.time}已经代表GMT-8时区的时间 application.yml配置如下 app: version: @project.version@ build: time: @build.time@ IDEA 编译项目不会调用 maven 生命周期,导致安装的 plugin 不被执行。虽然 maven 自带变量可以被替换,但是自定义变量却不会被替换。 可以将 IDEA 的 Build 与 maven goal 绑定起来,在 build 之前执行 maven goal,IDEA 右侧 Maven Projects -> LifeCycle -> compile 勾选 Execute After Build和Execute After Rebuild ,如下图 把时间戳加到包名 两种方法不要重复,否则 方法一:把时间戳加到版本号 <project> <versioin> 0.0.5.${build.time} </version> </project> 方法二:把时间戳直接加到包名 <project> <build> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> </build> </project> maven 打包时间戳问题 这篇文章介绍了在SpringBoot中如何获得项目的编译时间和版本号,主要分为以下步骤在pom文件中获取maven的build time配置pom,用maven中的变量替换资源文件中的属性提供接口Maven中获得编译时间在 pom文件properties 中添加两个属性&amp;amp;amp;amp;amp;lt;properties&amp;amp;amp;amp;amp;gt; &amp;amp;amp;amp;amp;lt;!--maven.build 今天发布项目到测试环境, 发布完成后, 一直启动不起来, 查看日志发现java.lang.OutOfMemoryError: Java heap space. java.lang.OutOfMemoryError: Java heap space Dumping heap to /dump/dump.hprof Unable to create /dump/dump.hprof: File e... <!--指定时间格式--> <maven.build.timestamp.format>yyyy-MM-dd HH:mm:ss</maven.build.timestamp.format> <!--maven.build.timestamp保存了maven编译时间戳--& Maven中的dependencyManagement 意义 **1、**在Maven中dependencyManagement的作用其实相当于一个对所依赖jar包进行版本管理的管理器。 **2、**pom.xml文件中,jar的版本判断的两种途径 如果dependencies里的dependency自己没有声明version元素,那么maven就会到dependencyManagement里面去找有没有对该artifactId和groupId进行过版本声明,如果有,就继承它,如果没有就会报错,告诉你必 <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <!-- 工程主入口--> 在 Spring Boot 中,依赖的版本号通常是在 POM 文件中管理的,这是因为 Spring Boot 带有许多预定义的依赖项,这些依赖项是在 Spring Boot 的 POM 文件中定义的。当您使用 Spring Boot Starter 依赖项时,它会传递引用这些依赖项。 当多个依赖项定义了相同的库时,Maven 将使用最接近您项目中的依赖项的版本。以下是 Maven 中的依赖项解析顺序: 1. 本地的 repository 2. 中央 repository 3. 远程的其他 repository 当 Maven 找到相同的库时,它将使用最近的版本。在一个依赖项中指定的版本优先级高于传递依赖项中的版本。如果您需要强制使用特定版本的库,可以在您项目的 POM 文件中直接指定它们的版本号。 对于 Spring Boot 应用程序,建议使用 Spring Boot 的版本管理方式管理您的依赖项版本。Spring Boot 使用的版本管理方法可以确保所有的依赖项都是兼容的,并且可以提供一致的开发体验。如果您需要使用不在 Spring Boot 管理的库,可以通过在您的 POM 文件中显式指定版本号来覆盖 Spring Boot 的版本号。
<build> <resources> <resource> <directory>src/main/resources</directory> <filtering>true</filtering> </resource> </resources> </build> 在application.yml中配置 不能使用${}
在application.yml中配置
不能使用${}
${}
app: version: @project.version@ build: time: @timestamp@ 创建AppController,提供接口 Get /app package cn.yshow.modules.sys.controller; import cn.yshow.common.utils.restResult.RestResult; import cn.yshow.common.utils.restResult.ResultGenerator; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Value; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import java.util.HashMap; import java.util.Map; * @author zhaod zhaodongxx@outlook.com * @version v1.0 * @since 2018/12/16 16:19 @Slf4j @RestController @RequestMapping("/app") public class AppController { * 当前版本 @Value("${app.version}") private String version; * 打包时间 @Value("${app.build.time}") private String buildTime; @GetMapping public RestResult uploadImg() { Map<String,String> ret = new HashMap<>(); ret.put("version",version); ret.put("buildTime",buildTime); //RestResult是我封装的返回对象 return ResultGenerator.genSuccessResult(ret); 用YAPI测试如下 maven.build.timestamp时区错误解决方案 在Maven 3.2.2+中, maven.build.timestamp已被重新定义,显示UTC中的时间,比中国时间慢8个小时。可以使用插件build-helper-maven-plugin获得本时区的时间 在plugins块添加插件,这个配置与官网不一样,按照官网的配置方式会报错 <project> <build> <!--指定包名 --> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> <plugins> <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <id>timestamp-property</id> <goals> <goal>timestamp-property</goal> </goals> </execution> </executions> <configuration> <name>build.time</name> <pattern>yyyy-MM-dd HH:mm</pattern> <timeZone>GMT+8</timeZone> </configuration> </plugin> </plugins> </build> </project> 经过上述处理后,属性${build.time}已经代表GMT-8时区的时间 application.yml配置如下 app: version: @project.version@ build: time: @build.time@ IDEA 编译项目不会调用 maven 生命周期,导致安装的 plugin 不被执行。虽然 maven 自带变量可以被替换,但是自定义变量却不会被替换。 可以将 IDEA 的 Build 与 maven goal 绑定起来,在 build 之前执行 maven goal,IDEA 右侧 Maven Projects -> LifeCycle -> compile 勾选 Execute After Build和Execute After Rebuild ,如下图 把时间戳加到包名 两种方法不要重复,否则 方法一:把时间戳加到版本号 <project> <versioin> 0.0.5.${build.time} </version> </project> 方法二:把时间戳直接加到包名 <project> <build> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> </build> </project> maven 打包时间戳问题 这篇文章介绍了在SpringBoot中如何获得项目的编译时间和版本号,主要分为以下步骤在pom文件中获取maven的build time配置pom,用maven中的变量替换资源文件中的属性提供接口Maven中获得编译时间在 pom文件properties 中添加两个属性&amp;amp;amp;amp;amp;lt;properties&amp;amp;amp;amp;amp;gt; &amp;amp;amp;amp;amp;lt;!--maven.build 今天发布项目到测试环境, 发布完成后, 一直启动不起来, 查看日志发现java.lang.OutOfMemoryError: Java heap space. java.lang.OutOfMemoryError: Java heap space Dumping heap to /dump/dump.hprof Unable to create /dump/dump.hprof: File e... <!--指定时间格式--> <maven.build.timestamp.format>yyyy-MM-dd HH:mm:ss</maven.build.timestamp.format> <!--maven.build.timestamp保存了maven编译时间戳--& Maven中的dependencyManagement 意义 **1、**在Maven中dependencyManagement的作用其实相当于一个对所依赖jar包进行版本管理的管理器。 **2、**pom.xml文件中,jar的版本判断的两种途径 如果dependencies里的dependency自己没有声明version元素,那么maven就会到dependencyManagement里面去找有没有对该artifactId和groupId进行过版本声明,如果有,就继承它,如果没有就会报错,告诉你必 <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <!-- 工程主入口--> 在 Spring Boot 中,依赖的版本号通常是在 POM 文件中管理的,这是因为 Spring Boot 带有许多预定义的依赖项,这些依赖项是在 Spring Boot 的 POM 文件中定义的。当您使用 Spring Boot Starter 依赖项时,它会传递引用这些依赖项。 当多个依赖项定义了相同的库时,Maven 将使用最接近您项目中的依赖项的版本。以下是 Maven 中的依赖项解析顺序: 1. 本地的 repository 2. 中央 repository 3. 远程的其他 repository 当 Maven 找到相同的库时,它将使用最近的版本。在一个依赖项中指定的版本优先级高于传递依赖项中的版本。如果您需要强制使用特定版本的库,可以在您项目的 POM 文件中直接指定它们的版本号。 对于 Spring Boot 应用程序,建议使用 Spring Boot 的版本管理方式管理您的依赖项版本。Spring Boot 使用的版本管理方法可以确保所有的依赖项都是兼容的,并且可以提供一致的开发体验。如果您需要使用不在 Spring Boot 管理的库,可以通过在您的 POM 文件中显式指定版本号来覆盖 Spring Boot 的版本号。
app: version: @project.version@ build: time: @timestamp@ 创建AppController,提供接口 Get /app
创建AppController,提供接口 Get /app
AppController
Get /app
package cn.yshow.modules.sys.controller; import cn.yshow.common.utils.restResult.RestResult; import cn.yshow.common.utils.restResult.ResultGenerator; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Value; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import java.util.HashMap; import java.util.Map; * @author zhaod zhaodongxx@outlook.com * @version v1.0 * @since 2018/12/16 16:19 @Slf4j @RestController @RequestMapping("/app") public class AppController { * 当前版本 @Value("${app.version}") private String version; * 打包时间 @Value("${app.build.time}") private String buildTime; @GetMapping public RestResult uploadImg() { Map<String,String> ret = new HashMap<>(); ret.put("version",version); ret.put("buildTime",buildTime); //RestResult是我封装的返回对象 return ResultGenerator.genSuccessResult(ret); 用YAPI测试如下 maven.build.timestamp时区错误解决方案 在Maven 3.2.2+中, maven.build.timestamp已被重新定义,显示UTC中的时间,比中国时间慢8个小时。可以使用插件build-helper-maven-plugin获得本时区的时间 在plugins块添加插件,这个配置与官网不一样,按照官网的配置方式会报错 <project> <build> <!--指定包名 --> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> <plugins> <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <id>timestamp-property</id> <goals> <goal>timestamp-property</goal> </goals> </execution> </executions> <configuration> <name>build.time</name> <pattern>yyyy-MM-dd HH:mm</pattern> <timeZone>GMT+8</timeZone> </configuration> </plugin> </plugins> </build> </project> 经过上述处理后,属性${build.time}已经代表GMT-8时区的时间 application.yml配置如下 app: version: @project.version@ build: time: @build.time@ IDEA 编译项目不会调用 maven 生命周期,导致安装的 plugin 不被执行。虽然 maven 自带变量可以被替换,但是自定义变量却不会被替换。 可以将 IDEA 的 Build 与 maven goal 绑定起来,在 build 之前执行 maven goal,IDEA 右侧 Maven Projects -> LifeCycle -> compile 勾选 Execute After Build和Execute After Rebuild ,如下图 把时间戳加到包名 两种方法不要重复,否则 方法一:把时间戳加到版本号 <project> <versioin> 0.0.5.${build.time} </version> </project> 方法二:把时间戳直接加到包名 <project> <build> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> </build> </project> maven 打包时间戳问题 这篇文章介绍了在SpringBoot中如何获得项目的编译时间和版本号,主要分为以下步骤在pom文件中获取maven的build time配置pom,用maven中的变量替换资源文件中的属性提供接口Maven中获得编译时间在 pom文件properties 中添加两个属性&amp;amp;amp;amp;amp;lt;properties&amp;amp;amp;amp;amp;gt; &amp;amp;amp;amp;amp;lt;!--maven.build 今天发布项目到测试环境, 发布完成后, 一直启动不起来, 查看日志发现java.lang.OutOfMemoryError: Java heap space. java.lang.OutOfMemoryError: Java heap space Dumping heap to /dump/dump.hprof Unable to create /dump/dump.hprof: File e... <!--指定时间格式--> <maven.build.timestamp.format>yyyy-MM-dd HH:mm:ss</maven.build.timestamp.format> <!--maven.build.timestamp保存了maven编译时间戳--& Maven中的dependencyManagement 意义 **1、**在Maven中dependencyManagement的作用其实相当于一个对所依赖jar包进行版本管理的管理器。 **2、**pom.xml文件中,jar的版本判断的两种途径 如果dependencies里的dependency自己没有声明version元素,那么maven就会到dependencyManagement里面去找有没有对该artifactId和groupId进行过版本声明,如果有,就继承它,如果没有就会报错,告诉你必 <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <!-- 工程主入口--> 在 Spring Boot 中,依赖的版本号通常是在 POM 文件中管理的,这是因为 Spring Boot 带有许多预定义的依赖项,这些依赖项是在 Spring Boot 的 POM 文件中定义的。当您使用 Spring Boot Starter 依赖项时,它会传递引用这些依赖项。 当多个依赖项定义了相同的库时,Maven 将使用最接近您项目中的依赖项的版本。以下是 Maven 中的依赖项解析顺序: 1. 本地的 repository 2. 中央 repository 3. 远程的其他 repository 当 Maven 找到相同的库时,它将使用最近的版本。在一个依赖项中指定的版本优先级高于传递依赖项中的版本。如果您需要强制使用特定版本的库,可以在您项目的 POM 文件中直接指定它们的版本号。 对于 Spring Boot 应用程序,建议使用 Spring Boot 的版本管理方式管理您的依赖项版本。Spring Boot 使用的版本管理方法可以确保所有的依赖项都是兼容的,并且可以提供一致的开发体验。如果您需要使用不在 Spring Boot 管理的库,可以通过在您的 POM 文件中显式指定版本号来覆盖 Spring Boot 的版本号。
package cn.yshow.modules.sys.controller; import cn.yshow.common.utils.restResult.RestResult; import cn.yshow.common.utils.restResult.ResultGenerator; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Value; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import java.util.HashMap; import java.util.Map; * @author zhaod zhaodongxx@outlook.com * @version v1.0 * @since 2018/12/16 16:19 @Slf4j @RestController @RequestMapping("/app") public class AppController { * 当前版本 @Value("${app.version}") private String version; * 打包时间 @Value("${app.build.time}") private String buildTime; @GetMapping public RestResult uploadImg() { Map<String,String> ret = new HashMap<>(); ret.put("version",version); ret.put("buildTime",buildTime); //RestResult是我封装的返回对象 return ResultGenerator.genSuccessResult(ret); 用YAPI测试如下
用YAPI测试如下
YAPI
maven.build.timestamp时区错误解决方案 在Maven 3.2.2+中, maven.build.timestamp已被重新定义,显示UTC中的时间,比中国时间慢8个小时。可以使用插件build-helper-maven-plugin获得本时区的时间 在plugins块添加插件,这个配置与官网不一样,按照官网的配置方式会报错 <project> <build> <!--指定包名 --> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> <plugins> <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <id>timestamp-property</id> <goals> <goal>timestamp-property</goal> </goals> </execution> </executions> <configuration> <name>build.time</name> <pattern>yyyy-MM-dd HH:mm</pattern> <timeZone>GMT+8</timeZone> </configuration> </plugin> </plugins> </build> </project> 经过上述处理后,属性${build.time}已经代表GMT-8时区的时间 application.yml配置如下 app: version: @project.version@ build: time: @build.time@ IDEA 编译项目不会调用 maven 生命周期,导致安装的 plugin 不被执行。虽然 maven 自带变量可以被替换,但是自定义变量却不会被替换。 可以将 IDEA 的 Build 与 maven goal 绑定起来,在 build 之前执行 maven goal,IDEA 右侧 Maven Projects -> LifeCycle -> compile 勾选 Execute After Build和Execute After Rebuild ,如下图 把时间戳加到包名 两种方法不要重复,否则 方法一:把时间戳加到版本号 <project> <versioin> 0.0.5.${build.time} </version> </project> 方法二:把时间戳直接加到包名 <project> <build> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> </build> </project> maven 打包时间戳问题 这篇文章介绍了在SpringBoot中如何获得项目的编译时间和版本号,主要分为以下步骤在pom文件中获取maven的build time配置pom,用maven中的变量替换资源文件中的属性提供接口Maven中获得编译时间在 pom文件properties 中添加两个属性&amp;amp;amp;amp;amp;lt;properties&amp;amp;amp;amp;amp;gt; &amp;amp;amp;amp;amp;lt;!--maven.build 今天发布项目到测试环境, 发布完成后, 一直启动不起来, 查看日志发现java.lang.OutOfMemoryError: Java heap space. java.lang.OutOfMemoryError: Java heap space Dumping heap to /dump/dump.hprof Unable to create /dump/dump.hprof: File e... <!--指定时间格式--> <maven.build.timestamp.format>yyyy-MM-dd HH:mm:ss</maven.build.timestamp.format> <!--maven.build.timestamp保存了maven编译时间戳--& Maven中的dependencyManagement 意义 **1、**在Maven中dependencyManagement的作用其实相当于一个对所依赖jar包进行版本管理的管理器。 **2、**pom.xml文件中,jar的版本判断的两种途径 如果dependencies里的dependency自己没有声明version元素,那么maven就会到dependencyManagement里面去找有没有对该artifactId和groupId进行过版本声明,如果有,就继承它,如果没有就会报错,告诉你必 <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <!-- 工程主入口--> 在 Spring Boot 中,依赖的版本号通常是在 POM 文件中管理的,这是因为 Spring Boot 带有许多预定义的依赖项,这些依赖项是在 Spring Boot 的 POM 文件中定义的。当您使用 Spring Boot Starter 依赖项时,它会传递引用这些依赖项。 当多个依赖项定义了相同的库时,Maven 将使用最接近您项目中的依赖项的版本。以下是 Maven 中的依赖项解析顺序: 1. 本地的 repository 2. 中央 repository 3. 远程的其他 repository 当 Maven 找到相同的库时,它将使用最近的版本。在一个依赖项中指定的版本优先级高于传递依赖项中的版本。如果您需要强制使用特定版本的库,可以在您项目的 POM 文件中直接指定它们的版本号。 对于 Spring Boot 应用程序,建议使用 Spring Boot 的版本管理方式管理您的依赖项版本。Spring Boot 使用的版本管理方法可以确保所有的依赖项都是兼容的,并且可以提供一致的开发体验。如果您需要使用不在 Spring Boot 管理的库,可以通过在您的 POM 文件中显式指定版本号来覆盖 Spring Boot 的版本号。
maven.build.timestamp
在Maven 3.2.2+中, maven.build.timestamp已被重新定义,显示UTC中的时间,比中国时间慢8个小时。可以使用插件build-helper-maven-plugin获得本时区的时间
build-helper-maven-plugin
在plugins块添加插件,这个配置与官网不一样,按照官网的配置方式会报错
plugins
<project> <build> <!--指定包名 --> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> <plugins> <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <id>timestamp-property</id> <goals> <goal>timestamp-property</goal> </goals> </execution> </executions> <configuration> <name>build.time</name> <pattern>yyyy-MM-dd HH:mm</pattern> <timeZone>GMT+8</timeZone> </configuration> </plugin> </plugins> </build> </project> 经过上述处理后,属性${build.time}已经代表GMT-8时区的时间 application.yml配置如下 app: version: @project.version@ build: time: @build.time@ IDEA 编译项目不会调用 maven 生命周期,导致安装的 plugin 不被执行。虽然 maven 自带变量可以被替换,但是自定义变量却不会被替换。 可以将 IDEA 的 Build 与 maven goal 绑定起来,在 build 之前执行 maven goal,IDEA 右侧 Maven Projects -> LifeCycle -> compile 勾选 Execute After Build和Execute After Rebuild ,如下图 把时间戳加到包名 两种方法不要重复,否则 方法一:把时间戳加到版本号 <project> <versioin> 0.0.5.${build.time} </version> </project> 方法二:把时间戳直接加到包名 <project> <build> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> </build> </project> maven 打包时间戳问题 这篇文章介绍了在SpringBoot中如何获得项目的编译时间和版本号,主要分为以下步骤在pom文件中获取maven的build time配置pom,用maven中的变量替换资源文件中的属性提供接口Maven中获得编译时间在 pom文件properties 中添加两个属性&amp;amp;amp;amp;amp;lt;properties&amp;amp;amp;amp;amp;gt; &amp;amp;amp;amp;amp;lt;!--maven.build 今天发布项目到测试环境, 发布完成后, 一直启动不起来, 查看日志发现java.lang.OutOfMemoryError: Java heap space. java.lang.OutOfMemoryError: Java heap space Dumping heap to /dump/dump.hprof Unable to create /dump/dump.hprof: File e... <!--指定时间格式--> <maven.build.timestamp.format>yyyy-MM-dd HH:mm:ss</maven.build.timestamp.format> <!--maven.build.timestamp保存了maven编译时间戳--& Maven中的dependencyManagement 意义 **1、**在Maven中dependencyManagement的作用其实相当于一个对所依赖jar包进行版本管理的管理器。 **2、**pom.xml文件中,jar的版本判断的两种途径 如果dependencies里的dependency自己没有声明version元素,那么maven就会到dependencyManagement里面去找有没有对该artifactId和groupId进行过版本声明,如果有,就继承它,如果没有就会报错,告诉你必 <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <!-- 工程主入口--> 在 Spring Boot 中,依赖的版本号通常是在 POM 文件中管理的,这是因为 Spring Boot 带有许多预定义的依赖项,这些依赖项是在 Spring Boot 的 POM 文件中定义的。当您使用 Spring Boot Starter 依赖项时,它会传递引用这些依赖项。 当多个依赖项定义了相同的库时,Maven 将使用最接近您项目中的依赖项的版本。以下是 Maven 中的依赖项解析顺序: 1. 本地的 repository 2. 中央 repository 3. 远程的其他 repository 当 Maven 找到相同的库时,它将使用最近的版本。在一个依赖项中指定的版本优先级高于传递依赖项中的版本。如果您需要强制使用特定版本的库,可以在您项目的 POM 文件中直接指定它们的版本号。 对于 Spring Boot 应用程序,建议使用 Spring Boot 的版本管理方式管理您的依赖项版本。Spring Boot 使用的版本管理方法可以确保所有的依赖项都是兼容的,并且可以提供一致的开发体验。如果您需要使用不在 Spring Boot 管理的库,可以通过在您的 POM 文件中显式指定版本号来覆盖 Spring Boot 的版本号。
<project> <build> <!--指定包名 --> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> <plugins> <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <id>timestamp-property</id> <goals> <goal>timestamp-property</goal> </goals> </execution> </executions> <configuration> <name>build.time</name> <pattern>yyyy-MM-dd HH:mm</pattern> <timeZone>GMT+8</timeZone> </configuration> </plugin> </plugins> </build> </project> 经过上述处理后,属性${build.time}已经代表GMT-8时区的时间 application.yml配置如下
经过上述处理后,属性${build.time}已经代表GMT-8时区的时间
${build.time}
application.yml配置如下
app: version: @project.version@ build: time: @build.time@ IDEA 编译项目不会调用 maven 生命周期,导致安装的 plugin 不被执行。虽然 maven 自带变量可以被替换,但是自定义变量却不会被替换。 可以将 IDEA 的 Build 与 maven goal 绑定起来,在 build 之前执行 maven goal,IDEA 右侧 Maven Projects -> LifeCycle -> compile 勾选 Execute After Build和Execute After Rebuild ,如下图 把时间戳加到包名 两种方法不要重复,否则 方法一:把时间戳加到版本号 <project> <versioin> 0.0.5.${build.time} </version> </project> 方法二:把时间戳直接加到包名 <project> <build> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> </build> </project> maven 打包时间戳问题 这篇文章介绍了在SpringBoot中如何获得项目的编译时间和版本号,主要分为以下步骤在pom文件中获取maven的build time配置pom,用maven中的变量替换资源文件中的属性提供接口Maven中获得编译时间在 pom文件properties 中添加两个属性&amp;amp;amp;amp;amp;lt;properties&amp;amp;amp;amp;amp;gt; &amp;amp;amp;amp;amp;lt;!--maven.build 今天发布项目到测试环境, 发布完成后, 一直启动不起来, 查看日志发现java.lang.OutOfMemoryError: Java heap space. java.lang.OutOfMemoryError: Java heap space Dumping heap to /dump/dump.hprof Unable to create /dump/dump.hprof: File e... <!--指定时间格式--> <maven.build.timestamp.format>yyyy-MM-dd HH:mm:ss</maven.build.timestamp.format> <!--maven.build.timestamp保存了maven编译时间戳--& Maven中的dependencyManagement 意义 **1、**在Maven中dependencyManagement的作用其实相当于一个对所依赖jar包进行版本管理的管理器。 **2、**pom.xml文件中,jar的版本判断的两种途径 如果dependencies里的dependency自己没有声明version元素,那么maven就会到dependencyManagement里面去找有没有对该artifactId和groupId进行过版本声明,如果有,就继承它,如果没有就会报错,告诉你必 <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <!-- 工程主入口--> 在 Spring Boot 中,依赖的版本号通常是在 POM 文件中管理的,这是因为 Spring Boot 带有许多预定义的依赖项,这些依赖项是在 Spring Boot 的 POM 文件中定义的。当您使用 Spring Boot Starter 依赖项时,它会传递引用这些依赖项。 当多个依赖项定义了相同的库时,Maven 将使用最接近您项目中的依赖项的版本。以下是 Maven 中的依赖项解析顺序: 1. 本地的 repository 2. 中央 repository 3. 远程的其他 repository 当 Maven 找到相同的库时,它将使用最近的版本。在一个依赖项中指定的版本优先级高于传递依赖项中的版本。如果您需要强制使用特定版本的库,可以在您项目的 POM 文件中直接指定它们的版本号。 对于 Spring Boot 应用程序,建议使用 Spring Boot 的版本管理方式管理您的依赖项版本。Spring Boot 使用的版本管理方法可以确保所有的依赖项都是兼容的,并且可以提供一致的开发体验。如果您需要使用不在 Spring Boot 管理的库,可以通过在您的 POM 文件中显式指定版本号来覆盖 Spring Boot 的版本号。
app: version: @project.version@ build: time: @build.time@ IDEA 编译项目不会调用 maven 生命周期,导致安装的 plugin 不被执行。虽然 maven 自带变量可以被替换,但是自定义变量却不会被替换。 可以将 IDEA 的 Build 与 maven goal 绑定起来,在 build 之前执行 maven goal,IDEA 右侧 Maven Projects -> LifeCycle -> compile 勾选 Execute After Build和Execute After Rebuild ,如下图
IDEA 编译项目不会调用 maven 生命周期,导致安装的 plugin 不被执行。虽然 maven 自带变量可以被替换,但是自定义变量却不会被替换。
可以将 IDEA 的 Build 与 maven goal 绑定起来,在 build 之前执行 maven goal,IDEA 右侧 Maven Projects -> LifeCycle -> compile 勾选 Execute After Build和Execute After Rebuild ,如下图
Build
maven goal
Maven Projects
LifeCycle
compile
Execute After Build
Execute After Rebuild
把时间戳加到包名 两种方法不要重复,否则 方法一:把时间戳加到版本号 <project> <versioin> 0.0.5.${build.time} </version> </project> 方法二:把时间戳直接加到包名 <project> <build> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> </build> </project> maven 打包时间戳问题 这篇文章介绍了在SpringBoot中如何获得项目的编译时间和版本号,主要分为以下步骤在pom文件中获取maven的build time配置pom,用maven中的变量替换资源文件中的属性提供接口Maven中获得编译时间在 pom文件properties 中添加两个属性&amp;amp;amp;amp;amp;lt;properties&amp;amp;amp;amp;amp;gt; &amp;amp;amp;amp;amp;lt;!--maven.build 今天发布项目到测试环境, 发布完成后, 一直启动不起来, 查看日志发现java.lang.OutOfMemoryError: Java heap space. java.lang.OutOfMemoryError: Java heap space Dumping heap to /dump/dump.hprof Unable to create /dump/dump.hprof: File e... <!--指定时间格式--> <maven.build.timestamp.format>yyyy-MM-dd HH:mm:ss</maven.build.timestamp.format> <!--maven.build.timestamp保存了maven编译时间戳--& Maven中的dependencyManagement 意义 **1、**在Maven中dependencyManagement的作用其实相当于一个对所依赖jar包进行版本管理的管理器。 **2、**pom.xml文件中,jar的版本判断的两种途径 如果dependencies里的dependency自己没有声明version元素,那么maven就会到dependencyManagement里面去找有没有对该artifactId和groupId进行过版本声明,如果有,就继承它,如果没有就会报错,告诉你必 <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <!-- 工程主入口--> 在 Spring Boot 中,依赖的版本号通常是在 POM 文件中管理的,这是因为 Spring Boot 带有许多预定义的依赖项,这些依赖项是在 Spring Boot 的 POM 文件中定义的。当您使用 Spring Boot Starter 依赖项时,它会传递引用这些依赖项。 当多个依赖项定义了相同的库时,Maven 将使用最接近您项目中的依赖项的版本。以下是 Maven 中的依赖项解析顺序: 1. 本地的 repository 2. 中央 repository 3. 远程的其他 repository 当 Maven 找到相同的库时,它将使用最近的版本。在一个依赖项中指定的版本优先级高于传递依赖项中的版本。如果您需要强制使用特定版本的库,可以在您项目的 POM 文件中直接指定它们的版本号。 对于 Spring Boot 应用程序,建议使用 Spring Boot 的版本管理方式管理您的依赖项版本。Spring Boot 使用的版本管理方法可以确保所有的依赖项都是兼容的,并且可以提供一致的开发体验。如果您需要使用不在 Spring Boot 管理的库,可以通过在您的 POM 文件中显式指定版本号来覆盖 Spring Boot 的版本号。
两种方法不要重复,否则
方法一:把时间戳加到版本号
<project> <versioin> 0.0.5.${build.time} </version> </project> 方法二:把时间戳直接加到包名 <project> <build> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> </build> </project> maven 打包时间戳问题 这篇文章介绍了在SpringBoot中如何获得项目的编译时间和版本号,主要分为以下步骤在pom文件中获取maven的build time配置pom,用maven中的变量替换资源文件中的属性提供接口Maven中获得编译时间在 pom文件properties 中添加两个属性&amp;amp;amp;amp;amp;lt;properties&amp;amp;amp;amp;amp;gt; &amp;amp;amp;amp;amp;lt;!--maven.build 今天发布项目到测试环境, 发布完成后, 一直启动不起来, 查看日志发现java.lang.OutOfMemoryError: Java heap space. java.lang.OutOfMemoryError: Java heap space Dumping heap to /dump/dump.hprof Unable to create /dump/dump.hprof: File e... <!--指定时间格式--> <maven.build.timestamp.format>yyyy-MM-dd HH:mm:ss</maven.build.timestamp.format> <!--maven.build.timestamp保存了maven编译时间戳--& Maven中的dependencyManagement 意义 **1、**在Maven中dependencyManagement的作用其实相当于一个对所依赖jar包进行版本管理的管理器。 **2、**pom.xml文件中,jar的版本判断的两种途径 如果dependencies里的dependency自己没有声明version元素,那么maven就会到dependencyManagement里面去找有没有对该artifactId和groupId进行过版本声明,如果有,就继承它,如果没有就会报错,告诉你必 <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <!-- 工程主入口--> 在 Spring Boot 中,依赖的版本号通常是在 POM 文件中管理的,这是因为 Spring Boot 带有许多预定义的依赖项,这些依赖项是在 Spring Boot 的 POM 文件中定义的。当您使用 Spring Boot Starter 依赖项时,它会传递引用这些依赖项。 当多个依赖项定义了相同的库时,Maven 将使用最接近您项目中的依赖项的版本。以下是 Maven 中的依赖项解析顺序: 1. 本地的 repository 2. 中央 repository 3. 远程的其他 repository 当 Maven 找到相同的库时,它将使用最近的版本。在一个依赖项中指定的版本优先级高于传递依赖项中的版本。如果您需要强制使用特定版本的库,可以在您项目的 POM 文件中直接指定它们的版本号。 对于 Spring Boot 应用程序,建议使用 Spring Boot 的版本管理方式管理您的依赖项版本。Spring Boot 使用的版本管理方法可以确保所有的依赖项都是兼容的,并且可以提供一致的开发体验。如果您需要使用不在 Spring Boot 管理的库,可以通过在您的 POM 文件中显式指定版本号来覆盖 Spring Boot 的版本号。
<project> <versioin> 0.0.5.${build.time} </version> </project> 方法二:把时间戳直接加到包名
方法二:把时间戳直接加到包名
<project> <build> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> </build> </project> maven 打包时间戳问题 这篇文章介绍了在SpringBoot中如何获得项目的编译时间和版本号,主要分为以下步骤在pom文件中获取maven的build time配置pom,用maven中的变量替换资源文件中的属性提供接口Maven中获得编译时间在 pom文件properties 中添加两个属性&amp;amp;amp;amp;amp;lt;properties&amp;amp;amp;amp;amp;gt; &amp;amp;amp;amp;amp;lt;!--maven.build 今天发布项目到测试环境, 发布完成后, 一直启动不起来, 查看日志发现java.lang.OutOfMemoryError: Java heap space. java.lang.OutOfMemoryError: Java heap space Dumping heap to /dump/dump.hprof Unable to create /dump/dump.hprof: File e... <!--指定时间格式--> <maven.build.timestamp.format>yyyy-MM-dd HH:mm:ss</maven.build.timestamp.format> <!--maven.build.timestamp保存了maven编译时间戳--& Maven中的dependencyManagement 意义 **1、**在Maven中dependencyManagement的作用其实相当于一个对所依赖jar包进行版本管理的管理器。 **2、**pom.xml文件中,jar的版本判断的两种途径 如果dependencies里的dependency自己没有声明version元素,那么maven就会到dependencyManagement里面去找有没有对该artifactId和groupId进行过版本声明,如果有,就继承它,如果没有就会报错,告诉你必 <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <!-- 工程主入口--> 在 Spring Boot 中,依赖的版本号通常是在 POM 文件中管理的,这是因为 Spring Boot 带有许多预定义的依赖项,这些依赖项是在 Spring Boot 的 POM 文件中定义的。当您使用 Spring Boot Starter 依赖项时,它会传递引用这些依赖项。 当多个依赖项定义了相同的库时,Maven 将使用最接近您项目中的依赖项的版本。以下是 Maven 中的依赖项解析顺序: 1. 本地的 repository 2. 中央 repository 3. 远程的其他 repository 当 Maven 找到相同的库时,它将使用最近的版本。在一个依赖项中指定的版本优先级高于传递依赖项中的版本。如果您需要强制使用特定版本的库,可以在您项目的 POM 文件中直接指定它们的版本号。 对于 Spring Boot 应用程序,建议使用 Spring Boot 的版本管理方式管理您的依赖项版本。Spring Boot 使用的版本管理方法可以确保所有的依赖项都是兼容的,并且可以提供一致的开发体验。如果您需要使用不在 Spring Boot 管理的库,可以通过在您的 POM 文件中显式指定版本号来覆盖 Spring Boot 的版本号。
<project> <build> <finalName> ${project.artifactId}-${project.version}-${build.time} </finalName> </build> </project>
maven 打包时间戳问题 这篇文章介绍了在SpringBoot中如何获得项目的编译时间和版本号,主要分为以下步骤在pom文件中获取maven的build time配置pom,用maven中的变量替换资源文件中的属性提供接口Maven中获得编译时间在 pom文件properties 中添加两个属性&amp;amp;amp;amp;amp;lt;properties&amp;amp;amp;amp;amp;gt; &amp;amp;amp;amp;amp;lt;!--maven.build 今天发布项目到测试环境, 发布完成后, 一直启动不起来, 查看日志发现java.lang.OutOfMemoryError: Java heap space. java.lang.OutOfMemoryError: Java heap space Dumping heap to /dump/dump.hprof Unable to create /dump/dump.hprof: File e... <!--指定时间格式--> <maven.build.timestamp.format>yyyy-MM-dd HH:mm:ss</maven.build.timestamp.format> <!--maven.build.timestamp保存了maven编译时间戳--& Maven中的dependencyManagement 意义 **1、**在Maven中dependencyManagement的作用其实相当于一个对所依赖jar包进行版本管理的管理器。 **2、**pom.xml文件中,jar的版本判断的两种途径 如果dependencies里的dependency自己没有声明version元素,那么maven就会到dependencyManagement里面去找有没有对该artifactId和groupId进行过版本声明,如果有,就继承它,如果没有就会报错,告诉你必 <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.8</version> <executions> <execution> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <!-- 工程主入口--> 在 Spring Boot 中,依赖的版本号通常是在 POM 文件中管理的,这是因为 Spring Boot 带有许多预定义的依赖项,这些依赖项是在 Spring Boot 的 POM 文件中定义的。当您使用 Spring Boot Starter 依赖项时,它会传递引用这些依赖项。 当多个依赖项定义了相同的库时,Maven 将使用最接近您项目中的依赖项的版本。以下是 Maven 中的依赖项解析顺序: 1. 本地的 repository 2. 中央 repository 3. 远程的其他 repository 当 Maven 找到相同的库时,它将使用最近的版本。在一个依赖项中指定的版本优先级高于传递依赖项中的版本。如果您需要强制使用特定版本的库,可以在您项目的 POM 文件中直接指定它们的版本号。 对于 Spring Boot 应用程序,建议使用 Spring Boot 的版本管理方式管理您的依赖项版本。Spring Boot 使用的版本管理方法可以确保所有的依赖项都是兼容的,并且可以提供一致的开发体验。如果您需要使用不在 Spring Boot 管理的库,可以通过在您的 POM 文件中显式指定版本号来覆盖 Spring Boot 的版本号。