2020 年 JVM 生态报告：Kotlin 成为第二受欢迎的 JVM 语言

2020 年 JVM 生态报告已于近日发布，该报告由 Snyk 和 The Java Magazine（Oracle 的双月刊）联合推出，旨在了解 JDK 的实现、 工具 、平台和应用方面的前景。

该调查于 2019 年下半年进行，有来自全球各个大洲的开发者、架构师和团队负责人等参与其中，最终生成的报告主要包含以下几方面：

• 36％ 的开发人员从 Oracle JDK 切换到了 OpenJDK

Oracle JDK 仍以 34％ 的比例占据主导地位。但在上一年的报告中，这一数据为 70%。一年之内，有 36％ 的开发人员从 Oracle JDK 切换到了 OpenJDK 发行版。

• 仅有 9％ 的参与者愿意为 JDK 支付费用  

这也许解释了大家从 Oracle JDK 转变到 OpenJDK 的原因。

• JDK 9  的发布节奏变化影响了近半数人的付费决定

从 JDK 9 开始，每年的三月和九月都会发布一个新的 Java 版本，这是对 JDK 发布节奏的重大更改。它影响了许多用户的更新策略，因为 6 个月的发布节奏也影响了支持周期。此外，这一更改也对安全性产生了影响，因为安全修复程序没有被反向移植到旧版本。 调查显示，对于至少 41% 的受访者来说，新的节奏影响了他们支持付费的决定。

• 64％ 的用户表示 Java 8 仍然是最常用的   Java SE   版本  

上一年的报告中，这一数据为 79%。随着 2018 年 9 月发布的第一个长期支持版本 Java 11，这种情况正在慢慢改变。参与调查的开发人员中有 1/4 现在正在生产中运行 Java 11。

• Kotlin 超越 Scala 和 Clojure，成为 JVM 上第二大最受欢迎的语言

毋庸多说，大多数 JVM 用户（9/10）使用 Java 作为主要语言。今年，Kotlin 大受欢迎，从去年的 2.4％ 使用率增长到了 5.5％。

Kotlin 是一个基于 JVM 的新的编程语言，由 JetBrains 开发。

• Spring 占据了 Java 生态系统的主导地位  

调查显示，6/10 的人依赖于 Spring Framework 来生成其应用程序。对于第三方开源框架而言，这是一个非常高的市场份额。Spring 已发展成为 Java 生态系统中最主要的框架。其中，Spring 5 的采用率约为 2/3。

服务器端也被 Spring 主导，其中 Spring Boot 占据一半的市场份额，另有近 1/3 的市场采用 Spring MVC。

• IntelliJ IDEA 主导 IDE 市场  

目前，IntelliJ IDEA 是 JVM 社区中使用最广泛的 IDE，有 62％ 的开发人员都在使用它。对大量现成功能的支持以及对 Kotlin 的原生支持，促使 IntelliJ IDEA 越来越受欢迎。排在第二的 EclipseIDE 从去年的 38％ 下降到今年的 20％。Apache NetBeans 稳居第三，市场份额为 10％，与去年大致相同。

• Maven  、Gradle 是最常用的构建工具

https://snyk.io/blog/jvm-ecosystem-report-2020/

最近，Jrebel公布了一份2020 Java生态系统报告，这份报告主要关注开发人员在开发过程中使用的技术。

这份报告包含了技术人员正在用的编程语言、应用程序架构、应用服务器、运行时平台、框架技术、IDE、JRE/JDK版本、数据库、部署模型、构建工具和虚拟化工具等。

2020 Java Technology Report

In our 2020 Java technology report, we look at results of our 2020 Java developer survey related to technology choice. The survey gained nearly 400 responses from Java development professionals around the globe. The survey asked about topics ranging from technologies used, to application performance, and team composition.

Java Technology Survey Results

In this segment of the 2020 Java developer report, we focused on the technologies developers are using during development. Our technology usage questions asked respondents to select their currently used programming language, application architecture, application server, runtime platform, framework technologies, framework configuration, IDE, JRE/JDK distribution, PaaS provider, databases, deployment model, build tools, and virtualization tools. You can see the results for those questions below.

Java Language

At 58%, the majority of respondents reported using Java 8 as the programming language of choice in their main application. Java 11 was the next highest at 23% of respondents. 7% of survey respondents reported using Java 7 or older, with another 6% of respondents reporting using Java 12 or newer. Kotlin and JavaScript were the least-used at 3% and 2% respectively.

For us, it wasn’t a big surprise to see Java 8 as the dominate programming language. It was surprising, however, to see that only 23% of respondents were using Java 11. We think this has to do with the lack of truly impactful updates to Java since Java 8 and the cost to update the JVM. For respondents still working with Java 7 and older, we expect that number to dwindle as more applications continue to migrate to Java 14 or whatever number is currently available.

Kotlin is 2.51%.

Java Application Server

Is application server variety dying? Our survey results show that developers are using Tomcat at nearly five times the rate of the closest competitor. With 61% percent of respondents using Tomcat on their main application, it’s clear that Tomcat is the dominant application server. Indeed, the next highest application server was Jetty at 13%, with WebLogic and WebSphere at 7% and 6% usage respectively. Lastly, JBoss/Wildfly usage came in at 5%.

It’s clear that Tomcat is doing something right to garner such a large share of the market. For me, at least part of that popularity is due to Tomcat’s versatility and its compatibility with other major Java platforms, like Spring Boot, Docker, Hybris, and AWS.
— Curtis Johnson, Product Manager at JRebel

Another major aspect is its cost, it’s free. Hard for management to say no to that! Previously, the lack of support surrounding the application server was one of the core reasons people had used to use application servers like Websphere, Weblogic, and JBoss. It appears that what has happened is Java architecture companies have decided the best way to support application servers is within their architecture as opposed to exclusively in the application server.

Java Runtime Platform

The far and away favorite selection for runtime platform is Spring Boot at 83%. Spring Boot, of course, has been the preferred Java framework for several years now. That’s due, at least in part, to the increased adoption of microservices for Java applications in recent years. At 2% of total respondents, Spring was tied for the second most popular choice, with respondents not using a runtime platform also reporting in at 2% of the total. Respondents using Dropwizard, Micronaut, Vert.x, or custom platforms each came in at 1% a piece.

Java Framework Technologies

This question asked participants to select the application frameworks and technologies being used on their main project. This question allowed for multiple response as most applications use a variety of different framework technologies.

At 86%, most respondents were working with Spring. 51% of respondents reported working with persistence technologies like Hibernate, OpenJPA, or EclipseLink. 27% reported using server-side rendering technologies like JSP, JSF, Thymeleaf, FreeMarker, or GWT. 26% reported using JAX-RS or JAX-WS technologies like Jersey, RESTEasy, CXF, or Axis. For reactive frameworks, 11% of respondents reported using technologies like Vert.x, Akka, RxJava, or Project Reactor. Lastly, 7% of respondents reported using enterprise JavaBeans in their main project.

Java Framework Configuration

For framework configuration, we found that most respondents were using @Annotations on classes, methods, and fields, or using external xml, yaml or similar files. 68% of users reported using @Annotations, with 67% of users using external xml, yaml, or similar files. 18% of respondents were configuring with code added to methods that run during initialization.

Java IDE

In this question, we asked developers to list the Integrated Development Environment (IDE) they use professionally. As recently as a few years ago, developers would have questioned the value of spending money on an IDE.

But, with 82% of respondents using IntelliJ IDEA, it’s clear that this paid IDE is well worth the price of admission. The next most used IDE, Eclipse, comes in at 24% with VSCode coming in at 10%. Lastly, 4% of respondents reported using NetBeans in a professional capacity. Netbeans has really lost all its interest through the years with even VSCode passing it in this survey.

JRE/JDK Distribution

In this survey question, we asked respondents to select the JRE/JDK distribution they use. And, in one of the more surprising results from this survey, we found that nearly 50 percent of respondents were using the paid Oracle JDK. That’s 13% more than respondents using Oracle OpenJDK — which reported in at 36%.

We think that may be due to two reasons: 1. The large Java 8 developer demographic represented in our survey. We think that the number of developers using Java 8 suggests that the project hasn’t been updated in a long period of time which could be what has kept the applications in the Oracle distribution. 2. The support provided by Oracle JDK may be more important than we thought.

It was very surprising to see how many of our survey respondents are paying for Oracle JDK. I fully expected the open source options to have a much larger market share.
— Curtis Johnson, Product Manager at JRebel

Aside from Oracle OpenJDK and Oracle JDK, 10% respondents reported using AdoptOpenJDK, while another 2% reported using Azul Zulu.

Java PaaS Provider

In this question, we asked respondents to select which PaaS provider they used. Of the 60% of respondents using a PaaS provider, 43% use AWS, 14% use Microsoft Azure, and 12% use Google Cloud Platform. Lesser-used providers included Pivotal Cloud Foundry at 4%, with SAP Cloud Platform and IBM Cloud at 2% each.

Java Database

In this question, we asked respondents to select the database(s) they’re currently using. The most popular was PostgreSQL at 47%, with Oracle DB a close second at 42%. Next up was MySQL, with 28% of respondents reporting usage. MongoDB was in fourth place, with 12% of respondents. The least-used databases included SQL, NoSQL, and Cassandra with 7%, 6%, and 4% usage, respectively.

Java Deployment Model

In this question, we asked respondents to tell us which deployment model they use. The most popular deployment model, at 46%, was to run the application as a JAR. 44% of respondents reported deploying onto an application server, while 5% of respondents reported using a platform like Hybris or Liferay to deploy their application.

Java Build Tools

For build tools, we asked developers to pick the tool they use on their main application. Expectedly, Maven and Gradle were the most-used tools. But, perhaps reflecting the amount of respondents working in mobile development, Gradle was the more popular of the two. We don’t think that this reflects the reality of Maven vs Gradle adoption — but it’s interesting to see, regardless. Our survey found that 47% of respondents were using Gradle as a build tool for their main application, while 44% were using Maven. Ant usage trailed both at 7% of respondents.

Java Virtualization Tools

In this question, we asked developers which virtualization tools they use. Far and away the most commonly-used tool was Docker, at 74%. Considering the percentage of Java developers using microservices, this wasn’t a big surprise. Kubernetes was the second most popular virtualization tool at 35%, which shows the continued growth Kubernetes has experienced over the last couple years.

With the way Kubernetes has grown it wouldn’t be surprising to see it play a dominating role in the market in coming years. VMware and Vagrant made up the last two significantly used tools, with 18% and 5% usage respectively. Lastly, 14% of respondents reported not using a virtualization tool.

Final Thoughts

Microservices have profoundly impacted the technologies that developers use during application development. And, as companies continue to transition to and create microservices-based applications, we expect technology choices to trend toward facilitating that architecture and the needs of developers working within them.

Additional Resources

Want to see more insights from our 2020 Java developer report? You can view the report overview, and Java microservices report segments by clicking the links below.

• 2020 Java Productivity Report

• 2020 Trends in Java Development Webinar

• 2020 Java Productivity Report Overview

• 2020 Java Microservices Report

https://www.jrebel.com/blog/2020-java-technology-report