您好,欢迎访问代理记账网站
  • 价格透明
  • 信息保密
  • 进度掌控
  • 售后无忧

以GraalVM原生镜像的方式运行Spring Boot应用程序

Spring Boot &GraalVM–系列共有3个部分:

  • 第1部分:以GraalVM原生镜像运行Spring Boot应用程序
  • 第2部分:使用Docker&Heroku容器运行Spring BootGraalVM原生镜像
  • 第3部分:使用原生镜像maven插件简化Spring Boot GraalVM原生镜像构建

Spring Boot变GraalVM

在我去年的一个项目中,我遇到了一个使用Spring Boot的情况。这个想法是在Kubernetes上运行所有的微服务,而Java(更准确地说:Spring Boot)被称为太慢太胖了。那时候我真的不得不吞下这片药片,感觉不太好。

这个话题我已经琢磨了很久了!在过去的一年里,随着我越来越多地将注意力转移到DevOps的话题上,我没有时间真正做点什么。但我从未真正离开过Spring的世界。随着2020年的开始,我准备回来看看这个领域是否有新的发展。

而且还有!2019年Spring一号站台,安迪·克莱门特和Sébastien Deleuze就如何将Spring Boot应用程序作为GraalVM本机映像运行进行了一次精彩的演讲。两者还推动了关于GitHub上GraalVM支持的Spring实验项目,在那里您可以密切关注每一步的进展。我想亲爱的斯塔布克斯曼真的推了安迪和Sébastien将发布他们在SpringMilestonesMaven存储库上的工作,这样他就可以写关于SpringTips的介绍(但我相信他会在Twitter上澄清)。但要明确的是,所有想马上开始使用Spring&GraalVM的人:

随着SpringFramework计划于2020年秋季发布的5.3版本,可以预期对SpringBoot提供稳定的GraalVM本机映像支持。

但这不应妨碍我们得到我们的手上这个新的有前途的功能!我真的努力为Spring扫清障碍, Java对于Kubernetes来说太慢太胖了

GraalVM原生镜像和Spring Boot

最近有很多关于GraalVM的传言。codecentric博客还提供了一些阅读内容:Enno Lohmann对Quarkus.io的介绍,或者Timo Kockert对GraalVM的介绍(抱歉,仅限德语)。所以我不会在这里过多地挖掘它的秘密。但是由于GraalVM是许多项目的保护伞,我们需要在这里关注一个特殊的子项目: GraalVM Native Image 。由于我们希望减少Spring Boot应用程序的启动时间和内存占用,所以我们将关注这个项目。

GraalVM原生镜像(或本机映像)的配置主要有两种方式:通过JSON文件进行静态配置或通过动态配置。静态配置文件可以手工制作或在Graal原生映像代理的帮助下生成。动态配置能够处理更复杂的情况。这里可以实现一个特殊的通用特性接口。在GraalVM本机映像构建过程中,实现此接口的类将被回调。

通过将传统上在运行时发生的动态魔法转移到本机映像的编译阶段,可以极大地减少Java应用程序的启动时间和内存占用。当我们考虑在普通Java应用程序中使用一点反射时,这已经是一项很重要的工作,当我们考虑Spring时,这将变得更加困难。它的银弹是它最大的缺点,同时当谈到原生映像生成。尽管类路径扫描和“神奇的”自动配置使我们作为开发人员的生活变得更加轻松,但是 GraalVM原生映像构建过程需要处理它

但是Spring团队真的接受了这个大挑战!安迪·克莱门特和Sébastiendeleuze已经作为一个实验项目为Spring提供了一个Graal@AutomaticFeature的实现。现在已经有大量的示例Spring项目使用这个特性来创建GraalVM原生图像。我发现这真是太棒了,真想仔细看看!

用SDKMAN安装GraalVM

别说了!让我们开始吧。正如有倾向的读者已经知道的那样,我总是努力写100%易懂的博客文章。希望这里的这个也不例外,因此您可以在GitHub上找到一个示例项目: https://github.com/jonashackt/spring-boot-graalvm

为了使用GraalVM,我们需要做的第一件事就是安装它。多亏了我的同事克里斯托夫·达尔斯基,我最近才真正喜欢上了SDKMAN。您可以使用它管理jdk和Java工具,比如Maven或GraalVM。为了使用SDKMAN,我们需要在本地安装它:

curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"

如果SDKMAN已经成功安装,那么 sdk list java 命令应该显示SDKMAN能够安装的所有可能的jdk:

$ sdk list java
 
================================================================================
Available Java Versions
================================================================================
 Vendor        | Use | Version      | Dist    | Status     | Identifier
--------------------------------------------------------------------------------
 AdoptOpenJDK  |     | 14.0.0.j9    | adpt    |            | 14.0.0.j9-adpt
               |     | 14.0.0.hs    | adpt    |            | 14.0.0.hs-adpt
               |     | 13.0.2.j9    | adpt    |            | 13.0.2.j9-adpt
... 
 GraalVM       |     | 20.1.0.r11   | grl     |            | 20.1.0.r11-grl
               |     | 20.1.0.r8    | grl     |            | 20.1.0.r8-grl
               |     | 19.3.1.r11   | grl     |            | 19.3.1.r11-grl
...

列表本身要长得多,您可以看到这种方法的奇妙的简单性: 永远不要再弄乱JDK安装! 现在要安装基于JDK11的GraalVM,只需运行:

sdk install java 20.1.0.r11-grl

SDKMAN现在为我们安装GraalVM。要正确配置PATH变量,可能需要重新启动控制台。如果一切顺利,您应该看到 java-version 输出如下:

$ java -version
openjdk version "11.0.7" 2020-04-14
OpenJDK Runtime Environment GraalVM CE 20.1.0 (build 11.0.7+10-jvmci-20.1-b02)
OpenJDK 64-Bit Server VM GraalVM CE 20.1.0 (build 11.0.7+10-jvmci-20.1-b02, mixed mode, sharing)

安装GraalVM原生镜像(本机映像)

如前所述,我们需要GraalVM的子项目Native Image来编译Spring Boot应用程序。因此,GraalVM附带了专用工具 gu– GraalVM更新程序。要列出当前安装的所有GraalVM项目,请运行:

$ gu list
ComponentId              Version             Component name      Origin
--------------------------------------------------------------------------------
graalvm                  20.1.0              GraalVM Core

要安装GraalVM本机映像,只需运行:

gu install native-image

之后,本机映像命令应该可以为我们工作,并且可以进行编译工作:

$ native-image --version
GraalVM Version 20.1.0 (Java Version 11.0.7)

创建一个简单的WebFlux REST-Spring Boot应用程序

为了从Spring Boot应用程序创建GraalVM本机映像,我们至少需要一个。最简单的方法就是现在就创建。所以正如著名的starbuxman所建议的,我们需要从Start-Dot-Spring-Dot-IO开始!

【图片】

在那里,我们应该选择至少2.3.0版本的SpringBoot版本。对Spring的GraalVM本地映像支持还处于初级阶段,而且每天都在进步。所以文件上说:

[选择上面的一个版本]SpringBoot2.3.0.M1(您可能可以使用Boot2.2.X,但不能使用2.1或更早版本)

为了构建一个restfulspring启动应用程序,我们需要在这里选择Spring Reactive Web依赖。下载骨架之后,我们继续创建一个简单的服务。在Spring的Reactive方式中,我们首先需要一个类似 HelloHandler.java 的处理程序:

import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Mono;
 
@Component
public class HelloHandler {
 
    protected static String RESPONSE_TEXT= "Hello Reactive People!";
 
    public Mono<ServerResponse> hello(ServerRequest serverRequest) {
        return ServerResponse
                        .ok()
                        .contentType(MediaType.TEXT_PLAIN)
                        .body(BodyInserters.fromValue(RESPONSE_TEXT));
    }
}

我们还需要一个路由器将HTTP请求路由到我们的处理程序。因此,让我们创建一个 HelloRouter.java

import org.springframework.context.annotation.Bean;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.*;
 
@Component
public class HelloRouter {
 
    @Bean
    public RouterFunction<ServerResponse> route(HelloHandler helloHandler) {
        return RouterFunctions.route(
                RequestPredicates.GET("/hello").and(RequestPredicates.accept(MediaType.TEXT_PLAIN)),
                serverRequest -> helloHandler.hello(serverRequest)
        );
    }
}

现在我们已经准备好了创建一个测试用例 HelloRouterTest.java ——当然,使用非阻塞 org.springframework.web.reactive.function.client.WebClient

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.reactive.server.WebTestClient;
 
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class HelloRouterTest {
 
	@Test void
	should_call_reactive_rest_resource(@Autowired WebTestClient webTestClient) {
		webTestClient.get().uri("/hello")
			.accept(MediaType.TEXT_PLAIN)
			.exchange()
			.expectBody(String.class).isEqualTo(HelloHandler.RESPONSE_TEXT);
	}
}

最后,我们在Maven和命令 mvn clean package 的帮助下构建了我们的应用程序。然后我们应该能够像往常一样使用 java -jar 运行它并在上访问它 localhost:8080/hello :

java -jar target/spring-boot-graal-0.0.1-SNAPSHOT.jar

准备将Spring Boot设置为对Graal本机映像友好

现在,为了能够以本机方式编译我们的Spring Boot应用程序,在执行本机映像命令之前,需要做一些准备:

\1. 将注释类路径扫描从运行时重新定位到构建时

\2. 禁用GCLIB代理的使用

\3. 检测自动配置

\4. 获得Spring Graal @AutomaticFeature

\5. 在pom.xml中设置 start class 元素

\6. 为本机映像命令准备配置变量

\7. 构建应用程序、扩展fat JAR和配置类路径

\8. 制作本机映像命令

1. 将注释类路径扫描从运行时重新定位到构建时

我们需要处理的第一件事是类路径扫描,因为这在运行时已经不可能了。在整个GraalVM buzz启动之前,就已经有了 spring-context-indexer, ,它是一个注释处理器,将注释扫描从运行时推到构建时:

虽然类路径扫描速度非常快,但通过在编译时创建候选对象的静态列表,可以提高大型应用程序的启动性能。在此模式下,作为组件扫描目标的所有模块都必须使用此机制。

在我们的应用程序中使用 spring-context-indexer, 将很容易。只需通过Maven导入即可:

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-indexer</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

这将生成一个 META-INF/spring.components 文件,其中包含通常通过类路径扫描收集的所有spring组件、实体等的列表。

但是我们不必使用 spring-context-indexer ,因为Graal @AutomaticFeature for spring 会自动为我们执行此操作!此外,该特性将追踪导入的带注释类,如 @Import 。它“知道”哪些注释在运行时会导致反射需求,哪些使用GraalVM的注释需要在构建时注册。而且,由于 application.properties 等资源文件也需要在构建时注册,因此该功能也涵盖了这些文件(请记住:编译过程的结果将仅是本机可执行文件)。

2. 禁用GCLIB代理的使用

GraalVM不支持使用GCLIB代理。从springboot2.2开始,GCLIB代理就不再是必需的了。因此,它引入了新的 proxyBeanMethods 选项来避免GCLIB处理。这个示例也在示例项目的 SpringBootHelloApplication.java 中使用:

@SpringBootApplication(proxyBeanMethods = false)
public class SpringBootHelloApplication {
    ...
}

与GCLIB代理不同,GraalVM支持使用JDK代理。它们只需要在构建时注册。这也由Spring-Graal @automatic 特性处理。

3. 检测自动配置

springboot附带了很多自动配置项目,只有在类路径上找到特定的类时,这些项目才会启动。因为这是在运行时完成的,所以它不适用于GraalVM。但是Spring-Graal @automatic 特性也解决了这个问题。它只分析 META-INF/spring.factories 文件,其中通常列出自动配置类。在社区驱动的Spring Boot Starter cxf Spring Boot Starter中可以找到这样一个文件的示例。因此springgraal @AutomaticFeature 再次将工作从运行时拉到构建时,从而消除了运行时自动配置的需要。

4. 获得Spring Graal@AutomaticFeature

正如您已经猜到的:为了将我们的Spring Boot应用程序编译为本机映像,我们需要有最新的 Spring Graal@AutomaticFeature 。当我在2020年3月开始与GraalVM和Spring合作时,没有Maven依赖,因为这个项目处于非常早期的开发阶段。因此,我最初编写了一个脚本 get-spring-feature.sh ,它克隆并构建了该项目以供本地使用。

但是Spring的人走得很快!由于Starbuxman在4月份发布了一篇spring.io帖子,我认为他得到了Andy Clement和Sébastien Deleuze向他发布了一个Maven依赖项,可以在repo.spring.io/milestone上找到

我们开始吧!现在我们不需要手动下载和编译 @AutomaticFeature ,只需在pom.xml中添加一个依赖项即可:

<dependencies>
		<dependency>
			<groupId>org.springframework.experimental</groupId>
			<artifactId>spring-graal-native</artifactId>
			<version>0.6.1.RELEASE</version>
		</dependency>
        ...
        <dependencies>
	<repositories>
		<repository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
		</repository>
	</repositories>
	<pluginRepositories>
		<pluginRepository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
		</pluginRepository>
	</pluginRepositories>

另外,请确保Spring Milestones repository定义已经就绪,因为Maven Central现在没有该库!

5. 在pom.xml中设置start-class元素

为了能够执行本机映像编译过程,我们需要提供带有Spring Boot主类全名的命令。

首先,我为 compile.sh 脚本提供了一个参数,稍后我们将查看该参数。但是,由于本机image maven插件也依赖于此设置,我发现在应用程序的pom.xml中提供此类的名称是可以的:

<properties>
		...
		<start-class>io.jonashackt.springbootgraal.SpringBootHelloApplication</start-class>
	</properties>

我们只需要在pom.xml中设置这个类一次,这也很好。我们不需要再麻烦这个参数,因为我们可以在下面的步骤中自动依赖它。

6. 为本机映像命令准备配置变量

我敢肯定,当Spring在2020年底正式发布Graal完全支持时,这里所描述的步骤将不再是必要的,Starbuxman的Spring.io文章也指出了让Maven插件在适当的地方完成繁重工作的方向。但是现在在开发的早期阶段,我发现更深入地了解如何执行 native-image 命令非常有帮助。这对我来说是有回报的——尤其是在这篇文章的后期和下面的博文中。

在spring-graal-native-samples项目中有很多使用编译脚本的好例子。所以让我们试着从中得出我们自己的结论。示例项目中也提供了完整的脚本:

#!/usr/bin/env bash
 
echo "[-->] Detect artifactId from pom.xml"
ARTIFACT=$(mvn -q \
-Dexec.executable=echo \
-Dexec.args='${project.artifactId}' \
--non-recursive \
exec:exec);
echo "artifactId is '$ARTIFACT'"
 
echo "[-->] Detect artifact version from pom.xml"
VERSION=$(mvn -q \
  -Dexec.executable=echo \
  -Dexec.args='${project.version}' \
  --non-recursive \
  exec:exec);
echo "artifact version is $VERSION"
 
echo "[-->] Detect Spring Boot Main class ('start-class') from pom.xml"
MAINCLASS=$(mvn -q \
-Dexec.executable=echo \
-Dexec.args='${start-class}' \
--non-recursive \
exec:exec);
echo "Spring Boot Main class ('start-class') is 'MAINCLASS'"

脚本的第一部分专门定义GraalVM本机映像编译所需的变量。在Maven exec插件的帮助下,可以简单地从pom.xml派生变量 ARTIFACTVERSIONMAINCLASS

7. 构建应用程序、扩展fat JAR和配置类路径

compile.sh 脚本的下一节中,我们清理( aka remove )目标目录,并通过众所周知的 mvn package 命令构建Spring Boot应用程序:

echo "[-->] Cleaning target directory & creating new one"
rm -rf target
mkdir -p target/native-image
 
echo "[-->] Build Spring Boot App with mvn package"
mvn -DskipTests package

构建之后,需要扩展Spring Boot fat JAR,并将类路径设置为结果的内容。另外, Spring Graal @AutomaticFeature 也需要在类路径上可用。因此,我们需要 compile.sh 脚本中 spring-graal-native-0.6.1.RELEASE.jar 文件的正确路径:

echo "[-->] Expanding the Spring Boot fat jar"
JAR="$ARTIFACT-$VERSION.jar"
cd target/native-image
jar -xvf ../$JAR >/dev/null 2>&1
cp -R META-INF BOOT-INF/classes
 
echo "[-->] Set the classpath to the contents of the fat jar (where the libs contain the Spring Graal AutomaticFeature)"
LIBPATH=`find BOOT-INF/lib | tr '\n' ':'`
CP=BOOT-INF/classes:$LIBPATH

8. 制作本机映像命令

现在终于可以通过许多适当的配置选项触发GraalVM本机映像编译了。如果您需要关于如何配置适合您的SpringBoot应用程序的本机映像命令的灵感,我建议您研究spring-graal-native-samples项目。这些参数现在需要适应不同类型的Spring应用程序,并且看起来非常不同,这取决于您是使用基于Tomcat的应用程序(包括 springdatarest )还是使用基于Netty的反应式应用程序(如本例中所示)。例如,可能需要用 --initializeatbuildtime=class.name.here 定义具体类。您还可以努力完成 native-image 命令抛出的所有异常。有时候除了这个没有别的办法。我也很确定这会随着2020年春季的发布而改变。

我们基于Netty的反应式应用程序的本机映像命令如下所示:

time native-image \
  --no-server \
  --no-fallback \
  -H:+TraceClassInitialization \
  -H:Name=$ARTIFACT \
  -H:+ReportExceptionStackTraces \
  -Dspring.graal.remove-unused-autoconfig=true \
  -Dspring.graal.remove-yaml-support=true \
  -cp $CP $MAINCLASS;

目前,大多数Spring Boot应用程序都可以依赖一些参数。尤其应该使用 --no server 标志来确保编译过程产生可再现的结果(GraalVM中现在有一个公开的问题)。另外,当涉及到Spring编译时, Spring Graal@AutomaticFeature 会处理两个默认选项:允许不完整的类路径和在运行时报告不支持的元素。如果我们使用 @AutomaticFeature ,就不需要明确地定义它们。

其他选项需要显式定义: --no fallback 在常规JVM上禁用回退,并强制执行纯本机映像运行时。如果出现问题,参数 -H:+traceClassification-H:+ReportExceptionStackTraces 都将有助于调试。

所有这些参数前面都有 -Dspring.graal 。是Spring Graal特性特定的配置选项。我们在这里使用 -Dspring.graal.remove unused autoconfig=true-Dspring.graal.remove yaml support=true 来实现更快的编译和更小的可执行文件。

最后,需要使用 -H:Name=$ARTIFACT和-cp$cp$MAINCLASS 等其他参数来指定可执行文件的名称和正确的类路径,以便本机映像编译工作。这些文档还提供了本机映像命令可能需要的所有配置参数的列表。

在严重情况下,可能需要将 Spring Graal@Automatic 功能与最初提到的GraalVM代理一起使用。这些文件涵盖了如何进行这种“混合”执行。

运行本机映像编译

现在我们到了我们想去的地方。我们已经准备好了运行本机图像编译的一切。只需执行:

./compile.sh

编译步骤确实需要时间(取决于您的硬件!)。在我的MacBook Pro 2017上,这大约需要3到4分钟。当我们使用 --no server 选项时,您还可以猜测我的机器有多少RAM,因为这个选项还告诉本机映像编译获取大约80%的系统内存。我准备了一个小的记录,这样您就可以看到编译过程是如何工作的:

如果控制台显示以下内容:

[spring-boot-graal:93927]   (typeflow):  74,606.04 ms, 12.76 GB
[spring-boot-graal:93927]    (objects):  58,480.01 ms, 12.76 GB
[spring-boot-graal:93927]   (features):   8,413.90 ms, 12.76 GB
[spring-boot-graal:93927]     analysis: 147,776.93 ms, 12.76 GB
[spring-boot-graal:93927]     (clinit):   1,578.42 ms, 12.76 GB
[spring-boot-graal:93927]     universe:   4,909.40 ms, 12.76 GB
[spring-boot-graal:93927]      (parse):   6,885.61 ms, 12.78 GB
[spring-boot-graal:93927]     (inline):   6,594.06 ms, 12.78 GB
[spring-boot-graal:93927]    (compile):  33,040.00 ms, 12.79 GB
[spring-boot-graal:93927]      compile:  50,001.85 ms, 12.79 GB
[spring-boot-graal:93927]        image:   8,963.82 ms, 12.79 GB
[spring-boot-graal:93927]        write:   2,414.18 ms, 12.79 GB
[spring-boot-graal:93927]      [total]: 232,479.88 ms, 12.79 GB
 
real	3m54.635s
user	16m16.765s
sys	1m55.756s

您现在可以启动第一个GraalVM本机应用程序了!。多酷啊?!!您只需运行生成的可执行文件 /target/native-image/spring-graal-vm :

$ ./target/native-image/spring-graal-vm
 
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::
 
2020-05-01 10:25:31.200  INFO 42231 --- [           main] i.j.s.SpringBootHelloApplication         : Starting SpringBootHelloApplication on PikeBook.fritz.box with PID 42231 (/Users/jonashecht/dev/spring-boot/spring-boot-graalvm/target/native-image/spring-boot-graal started by jonashecht in /Users/jonashecht/dev/spring-boot/spring-boot-graalvm/target/native-image)
2020-05-01 10:25:31.200  INFO 42231 --- [           main] i.j.s.SpringBootHelloApplication         : No active profile set, falling back to default profiles: default
2020-05-01 10:25:31.241  WARN 42231 --- [           main] io.netty.channel.DefaultChannelId        : Failed to find the current process ID from ''; using a random value: 635087100
2020-05-01 10:25:31.245  INFO 42231 --- [           main] o.s.b.web.embedded.netty.NettyWebServer  : Netty started on port(s): 8080
2020-05-01 10:25:31.245  INFO 42231 --- [           main] i.j.s.SpringBootHelloApplication         : Started SpringBootHelloApplication in 0.078 seconds (JVM running for 0.08)

我们的Spring Boot 应用程序在 0.078秒 内启动!!

比较启动时间和内存占用

好吧,最初的目标是以闪电般的速度运行我们钟爱的Spring Boot应用程序,并消除Java对于云本地部署来说太慢太胖的“争论”。因此,让我们来看看我们可以运行的“普通”Spring Boot应用程序:

$ java -jar target/spring-boot-graal-0.0.1-SNAPSHOT.jar
 
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::             (v2.3.0.M4)
 
2020-04-30 15:40:21.187  INFO 40149 --- [           main] i.j.s.SpringBootHelloApplication         : Starting SpringBootHelloApplication v0.0.1-SNAPSHOT on PikeBook.fritz.box with PID 40149 (/Users/jonashecht/dev/spring-boot/spring-boot-graalvm/target/spring-boot-graal-0.0.1-SNAPSHOT.jar started by jonashecht in /Users/jonashecht/dev/spring-boot/spring-boot-graalvm)
2020-04-30 15:40:21.190  INFO 40149 --- [           main] i.j.s.SpringBootHelloApplication         : No active profile set, falling back to default profiles: default
2020-04-30 15:40:22.280  INFO 40149 --- [           main] o.s.b.web.embedded.netty.NettyWebServer  : Netty started on port(s): 8080
2020-04-30 15:40:22.288  INFO 40149 --- [           main] i.j.s.SpringBootHelloApplication         : Started SpringBootHelloApplication in 1.47 seconds (JVM running for 1.924)

标准方式需要大约 1.47秒 启动,它使用了大约 491 MB 的RAM,这为我们概括了一个简单的 top 命令:

PID    COMMAND      %CPU TIME     #TH  #WQ  #POR MEM  PURG CMPR PGRP  PPID STATE    BOOSTS    %CPU_ME %CPU_OTHRS UID  FAULTS  COW  MSGS MSGR SYSBSD SYSM CSW    PAGE IDLE POWE
40862  java         0.1  00:05.46 27   1    112  491M 0B   0B   40862 1592 sleeping *0[1]     0.00000 0.00000    501  136365  1942 5891 2919 52253+ 8577 21848+ 7148 733+ 0.8

现在与之相比,使用本机编译的Spring Boot应用程序,我们已经看到启动时间只有 78毫秒 。此外,我们的应用程序仅消耗 30 MB 的RAM:

PID    COMMAND      %CPU TIME     #TH  #WQ  #POR MEM  PURG CMPR PGRP  PPID STATE    BOOSTS    %CPU_ME %CPU_OTHRS UID  FAULT COW  MSGS MSGR SYSB SYSM CSW  PAGE IDLE POWE INST CYCL
42231  spring-boot- 0.0  00:00.08 7    1    38   30M  0B   0B   42231 1592 sleeping *0[1]     0.00000 0.00000    501  17416 2360 77   20   2186 186  174  27   2    0.0  0    0

因此,对于一个默认的Spring应用程序,我们有大约500mb的内存消耗,一个本机编译的Spring应用程序只有30mb。 这意味着我们可以用一个标准Spring微服务所需的相同数量的RAM来运行15个以上的Spring微服务! 呜呼!更不用说启动时间了。大约1.5秒而不是78毫秒。因此,即使我们的Kubernetes集群也应该能够以闪电般的速度扩展我们的Spring Boot应用程序!

以闪电般的速度启动–Spring Boot和GraalVM

我完全震惊于SpringBoot和本地编译的GraalVM图像之间的结合是多么成功。感谢Spring团队和springgraal@AutomaticFeature项目的出色工作,我们已经能够看到即将到来的内容。到2020年,我将不再接受任何人告诉我Java/Spring对于真正的云本地部署来说太慢太胖了!当然,还有很长的路要走,生产部署应该等到2020年秋季,春季正式发布全面的GraalVM原生映像支持。但没有理由不从今天开始,看看这些伟大的功能。


分享:

低价透明

统一报价,无隐形消费

金牌服务

一对一专属顾问7*24小时金牌服务

信息保密

个人信息安全有保障

售后无忧

服务出问题客服经理全程跟进