流程

1. 在命令终端中，输入以下命令验证 Maven 是否使用 JDK 11，并且 Maven 版本是否为 3.6.2 或更高版本：

   mvn --version

2. 如果上述命令没有返回 JDK 11，请将 JDK 11 的路径添加到 PATH 环境变量中，然后再次输入上述命令。

3. 要使用 Quarkus Maven 插件创建新项目，请使用以下方法之一：

   • 使用以下命令：

     mvn io.quarkus:quarkus-maven-plugin:1.11.7.Final-redhat-00009:create \
         -DprojectGroupId=<project_group_id> \
         -DprojectArtifactId=<project_artifact_id> \
         -DplatformGroupId=com.redhat.quarkus \
         -DplatformArtifactId=quarkus-universe-bom \
         -DplatformVersion=1.11.7.Final-redhat-00009 \
         -DclassName="<classname>"

     在这个命令中，替换以下值：

     • <project_group_id > ：项目的唯一标识符
     • <project_artifact_id > ：项目名称和项目目录
     • <classname > ：生成的资源的完全限定名称，如 org.acme.quarkus.sample.HelloResource

   • 以互动模式创建项目：

     mvn io.quarkus:quarkus-maven-plugin:1.11.7.Final-redhat-00009:create

     出现提示时，输入所需的属性值。

     注意

     另外，您可以使用以下命令使用项目属性的默认值创建项目：

     mvn io.quarkus:quarkus-maven-plugin:1.11.7.Final-redhat-00009:create -B

     下表列出了您可以使用 create 命令定义的属性：

     属性	默认值	描述
     projectGroupId	org.acme.sample	项目的唯一标识符。
     projectArtifactId	none	项目的名称和项目目录。如果没有指定 projectArtifactId，Maven 插件将启动交互模式。如果目录已存在，则生成会失败。
     projectVersion	1.0-SNAPSHOT	项目的版本。
     platformGroupId	io.quarkus	平台的组 ID。所有现有的平台都由 io.quarkus 提供。但是，您可以更改默认值。
     platformArtifactId	quarkus-universe-bom	平台 BOM 的工件 ID。要使用本地构建的 Quarkus 将 quarkus-universe-bom 添加到 pom.xml 文件中。
     platformVersion	最新平台版本	要用于项目的平台版本。您可以提供一个版本范围，Maven 插件使用最新版本。
     className	None	生成的资源的完全限定名称。创建应用程序后，REST 端点通过以下 URL 公开： http://localhost:8080/$path 如果您使用默认 路径，URL 为 http://localhost:8080/hello。
     path	/hello	资源路径，只有在设置了 className 时。
     extensions	[]	要添加到用逗号分开的项目中的扩展列表。

流程

1. 在文本编辑器中打开 pom.xml 文件。

2. 添加包含以下内容的配置属性：

   • Quarkus Maven 插件的版本
   • Quarkus BOM 的 groupID、artifactID 和版本
   • Maven Surefire 插件的版本

   <properties>
       <quarkus-plugin.version>1.11.7.Final-redhat-00009</quarkus-plugin.version>
       <quarkus.platform.artifact-id>quarkus-universe-bom</quarkus.platform.artifact-id>
       <quarkus.platform.group-id>com.redhat.quarkus</quarkus.platform.group-id>
       <quarkus.platform.version>1.11.7.Final-redhat-00009</quarkus.platform.version>
       <surefire-plugin.version>3.0.0-M5</surefire-plugin.version>
   </properties>

3. 添加 Quarkus GAV （组、工件、版本），并使用 quarkus-universe-bom 文件省略不同 Quarkus 依赖项的版本：

   <dependencyManagement>
       <dependencies>
         <dependency>
           <groupId>${quarkus.platform.group-id}</groupId>
           <artifactId>${quarkus.platform.artifact-id}</artifactId>
           <version>${quarkus.platform.version}</version>
           <type>pom</type>
           <scope>import</scope>
         </dependency>
       </dependencies>
     </dependencyManagement>

4. 添加 Quarkus Maven 插件：

   <build>
       <plugins>
           <plugin>
               <groupId>io.quarkus</groupId>
               <artifactId>quarkus-maven-plugin</artifactId>
               <version>${quarkus.platform.version}</version>
               <executions>
                   <execution>
                       <goals>
                           <goal>build</goal>
                       </goals>
                   </execution>
               </executions>
           </plugin>
       </plugins>
   </build>

5. 可选： 要构建原生应用程序，请添加包括 Maven Surefire 和 Maven Failsafe 插件的特定原生配置集，并启用 原生 软件包类型：

   <profiles>
       <profile>
           <id>native</id>
           <properties>
               <quarkus.package.type>native</quarkus.package.type>
           </properties>
           <build>
               <plugins>
                   <plugin>
                       <groupId>org.apache.maven.plugins</groupId>
                       <artifactId>maven-failsafe-plugin</artifactId>
                       <version>${surefire-plugin.version}</version>
                       <executions>
                           <execution>
                               <goals>
                                   <goal>integration-test</goal>
                                   <goal>verify</goal>
                               </goals>
                               <configuration>
                                   <systemProperties>
                                       <native.image.path>${project.build.directory}/${project.build.finalName}-runner</native.image.path>
                                   </systemProperties>
                               </configuration>
                           </execution>
                       </executions>
                   </plugin>
               </plugins>
           </build>
       </profile>
   </profiles>

   在其名称中包含 IT 的测试会被注解 @NativeImageTest，针对原生可执行文件运行。

流程

1. 使用 Web 浏览器进入到 https://code.quarkus.redhat.com。

2. 指定项目的基本详情：

   1. 输入项目的组名称。名称的格式遵循 Java 软件包命名约定，如 org.acme。
   2. 输入您要用于项目生成的 Maven 工件的名称，如 code-with-quarkus。

   3. 选择您要用来编译和启动应用程序的构建工具。您选择的构建工具决定：

      • 生成的项目的目录结构。
      • 您生成的项目中使用的配置文件格式。

      • 在生成项目后，用来编译和启动应用程序的自定义构建脚本和命令会显示 code.quarkus.redhat.com。

        注意

        红帽提供了对使用 code.quarkus.redhat.com 创建 Quarkus Maven 项目的支持。红帽不支持生成 Gradle 项目。

        

3. 指定应用程序项目的更多详情：

   1. 选择 Configure more options 来显示包含额外应用程序详情的字段。
   2. 输入项目生成的工件中使用的版本。此字段的默认值为 1.0.0-SNAPSHOT。建议使用 语义版本 控制，但如果您偏好使用不同类型的版本控制。

   3. 选择您是否希望 code.quarkus.redhat.com 将示例代码添加到您的项目中。当您从扩展列表中添加标记为 图标的扩展时，您可以启用这个选项，以便在生成项目时为这些扩展自动创建示例类文件和资源文件。当您不添加提供示例代码的任何扩展时，这个选项不会影响您生成的项目。

      
      注意

      code.quarkus.redhat.com 会自动使用红帽构建的 Quarkus 的最新版本。您可在生成项目后手动更改 pom.xml 文件中的 BOM 版本。

4. 从扩展列表中选择您要在应用程序中使用的扩展。所选扩展包含在 Quarkus 应用程序的依赖项中，及其版本由 Quarkus 平台管理，以确保其兼容性。

   您可以启用这个选项来为标记为 图标的扩展自动生成示例代码。

   

   请注意，红帽为列表上的单个扩展 提供不同的支持级别，由每个扩展名称旁的标签表示：

   • 红帽完全支持 SUPPORTED 扩展，用于生产环境中的企业级应用程序。
   • 在 技术预览功能支持范围 下，红帽对生产环境中的 支持 受到有限的支持。
   • 红帽不支持将 DEV-SUPPORT 扩展用于生产环境，但红帽提供的核心功能由红帽开发人员支持用于开发新应用程序。
   • 红帽不支持未标记的扩展用于生产环境。

   • DEPRECATED 扩展计划被提供相同功能的较新的技术或实施替代。

     您可以扩展每个扩展旁边的溢出菜单，以访问您可以使用的附加选项：

     • 在命令行中使用 Quarkus maven 插件，将扩展添加到现有项目。
     • 复制 XML 代码片段，将扩展添加到项目的 pom.xml 文件中。
     • 获取每个扩展的 groupId、artifactId 和 version。

     • 打开扩展指南。

       

5. 选择 Generate your application 来确认您的选择并显示覆盖页面，其中包含包含您生成的项目的存档的下载链接。覆盖屏幕还显示可用于编译和启动应用程序的自定义命令。
6. 选择 Download the ZIP，将生成的项目文件的归档保存到机器中。
7. 提取存档的内容。

8. 进入包含您提取的项目文件的目录：

   cd <directory_name>

9. 以开发模式编译并启动应用程序：

   ./mvnw compile quarkus:dev

流程

1. 导航到 Quarkus 项目目录。

2. 要列出可用的扩展，请输入以下命令：

   ./mvnw quarkus:list-extensions

3. 要为项目添加扩展，请输入以下命令，其中 <extension> 为您要添加的扩展的组、工件、版本(GAV)：

   ./mvnw quarkus:add-extension -Dextensions="<extension>"

   例如，要添加 Agroal 扩展，请输入以下命令：

   ./mvnw quarkus:add-extension -Dextensions="io.quarkus:quarkus-agroal"

4. 要搜索特定扩展，请在 -Dextensions= 之后输入扩展名称或部分名称。以下示例搜索在名称中包含文本 jdbc、groal 和 non-exist-ent 的扩展：

   ./mvnw quarkus:add-extension -Dextensions=jdbc,agroal,non-exist-ent

   这个命令返回以下结果：

   ❌ Multiple extensions matching 'jdbc'
       * io.quarkus:quarkus-jdbc-h2
       * io.quarkus:quarkus-jdbc-mariadb
       * io.quarkus:quarkus-jdbc-postgresql
       Be more specific e.g using the exact name or the full gav.
   ✅ Adding extension io.quarkus:quarkus-agroal
   ❌ Cannot find a dependency matching 'non-exist-ent', maybe a typo?
   [...]

5. 要安装特定文本字符串返回的所有扩展，请在 -Dextensions= 之后输入扩展名称或部分名称。以下示例搜索并安装以 hibernate- 开头的所有扩展：

   ./mvnw quarkus:add-extension -Dextensions="hibernate-*"

CodeReady Studio 或 Eclipse

1. 在 CodeReady Studio 或 Eclipse 中，点 File → Import。
2. 选择 Maven → Existing Maven Project。
3. 在下一屏幕中，选择项目的 root 位置。此时会出现找到的模块列表。
4. 选择生成的项目并点 Finish。

5. 要启动应用程序，请在新终端窗口中输入以下命令：

   ./mvnw compile quarkus:dev

IntelliJ

1. 在 IntelliJ 中，完成以下任务之一：

   • 选择 File → New → Project From Existing Sources。
   • 在 Welcome 页面上，选择 Import project。
2. 选择项目根目录。
3. 从外部模型选择 Import project，然后选择 Maven。
4. 检查选项，然后单击 Next。
5. 点 Finish。

6. 要启动应用程序，请在新终端窗口中输入以下命令：

   ./mvnw compile quarkus:dev

Apache NetBeans

1. 选择 File → Open Project。
2. 选择 项目根目录。
3. 单击 Open Project。

4. 要启动应用程序，请在新终端窗口中输入以下命令：

   ./mvnw compile quarkus:dev

Visual Studio Code

1. 安装 Java 扩展包。
2. 在 Visual Studio Code 中，打开您的项目目录。项目作为 Maven 项目加载。

流程

1. 在文本编辑器中打开 application.properties 文件。

2. 编辑您要更改并保存文件的属性值。

   下表列出了您可以更改的属性：

   属性	描述	类型	Default（默认）
   quarkus.package.main-class	应用程序的入口点。在大多数情况下，您应该更改此值。	字符串	io.quarkus.runner.GeneratedMain
   quarkus.package.type	请求的输出类型。	字符串	JAR
   quarkus.package.uber-jar	Java 运行程序是否应打包为 uber-JAR。	布尔值	false
   quarkus.package.manifest.add-implementation-entries	实施信息是否应包含在运行程序 JAR 文件的 MANIFEST.MF 文件中。	布尔值	true
   quarkus.package.user-configured-ignored-entries	不应复制到输出工件的文件。	string (list)
   quarkus.package.runner-suffix	应用到运行程序 JAR 文件的后缀。	字符串	-runner
   quarkus.package.output-directory	应用程序构建的输出文件夹。这相对于构建系统目标目录解析。	字符串
   quarkus.package.output-name	最终工件的名称。	字符串

流程

1. 将插件配置添加到 pom.xml 文件中：

   <project>
       [...]
         <plugin>
             <groupId>io.quarkus</groupId>
             <artifactId>quarkus-bootstrap-maven-plugin</artifactId>
             <version>${quarkus-plugin.version}</version>
         </plugin>
       [...]
   </project>

2. 要列出应用程序的构建依赖项树，请输入以下命令：

   ./mvnw quarkus-bootstrap:build-tree

3. 这个命令的输出应类似以下示例：

   [INFO] --- quarkus-bootstrap-maven-plugin:1.11:build-tree (default-cli) @ getting-started ---
   [INFO] org.acme:getting-started:jar:1.0-SNAPSHOT
   [INFO] └─ io.quarkus:quarkus-resteasy-deployment:jar:1.11 (compile)
   [INFO]    ├─ io.quarkus:quarkus-resteasy-server-common-deployment:jar:1.11 (compile)
   [INFO]    │  ├─ io.quarkus:quarkus-core-deployment:jar:1.11 (compile)
   [INFO]    │  │  ├─ commons-beanutils:commons-beanutils:jar:1.9.3 (compile)
   [INFO]    │  │  │  ├─ commons-logging:commons-logging:jar:1.2 (compile)
   [INFO]    │  │  │  └─ commons-collections:commons-collections:jar:3.2.2 (compile)
   ...

流程

1. 打开 Getting Started 项目 pom.xml 文件，并验证该文件是否包含 native 配置集：

   <profiles>
       <profile>
           <id>native</id>
           <properties>
               <quarkus.package.type>native</quarkus.package.type>
           </properties>
       </profile>
   </profiles>

   注意

   使用 Quarkus native 配置集允许您运行原生可执行文件和原生镜像测试。

2. 使用以下方法之一构建原生可执行文件：

   1. 使用 Docker 构建原生可执行文件：

      ./mvnw package -Pnative -Dquarkus.native.container-build=true

   2. 使用 Podman 构建原生可执行文件：

      ./mvnw package -Pnative -Dquarkus.native.container-build=true -Dquarkus.native.container-runtime=podman

      这些命令在 目标 目录中创建 get-started the guestfish-runner 二进制文件。

      重要

      在分析和优化过程中，将 Quarkus 应用程序编译到原生可执行文件中会消耗大量内存。您可以通过设置 quarkus.native.native-image-xmx 配置属性来限制原生编译过程中使用的内存量。设置低内存限值可能会增加构建时间。如需了解更多详细信息，请参阅 原生可执行配置属性。

3. 运行原生可执行文件：

   ./target/getting-started-*-runner

   构建原生可执行文件时，启用了 prod 配置集，并使用 prod 配置集运行 Quarkus 原生测试。您可以使用 quarkus.test.native-image-profile 属性进行修改。

流程

1. 打开 pom.xml 文件，并验证 native 配置集是否包含以下元素：

   <plugin>
       <groupId>org.apache.maven.plugins</groupId>
       <artifactId>maven-failsafe-plugin</artifactId>
       <version>${surefire-plugin.version}</version>
       <executions>
           <execution>
               <goals>
                   <goal>integration-test</goal>
                   <goal>verify</goal>
               </goals>
               <configuration>
                   <systemPropertyVariables>
                       <native.image.path>${project.build.directory}/${project.build.finalName}-runner</native.image.path>
                       <java.util.logging.manager>org.jboss.logmanager.LogManager</java.util.logging.manager>
                       <maven.home>${maven.home}</maven.home>
                   </systemPropertyVariables>
               </configuration>
           </execution>
       </executions>
   </plugin>

   failsafe-maven-plugin 运行集成测试，并指示生成的原生可执行文件的位置。

2. 打开 src/test/java/org/acme/quickstart/NativeGreetingResourceIT.java 文件，并验证该文件是否包含以下内容：

   package org.acme.quickstart;
   
   
   import io.quarkus.test.junit.NativeImageTest;
   
   @NativeImageTest 1
   public class NativeGreetingResourceIT extends GreetingResourceTest { 2
   
       // Run the same tests
   
   }

   1

   在测试前，使用从原生文件启动应用程序的另一个测试运行程序。可执行文件使用 Failsafe Maven 插件 中配置的 native.image.path 系统属性检索。

   2

   这个示例扩展了 GreetingResourceTest，但您也可以创建新的测试。

3. 运行测试：

   ./mvnw verify -Pnative

   以下示例显示了这个命令的输出：

   ./mvnw verify -Pnative
   ...
   [getting-started-1.0-SNAPSHOT-runner:18820]     universe:     587.26 ms
   [getting-started-1.0-SNAPSHOT-runner:18820]      (parse):   2,247.59 ms
   [getting-started-1.0-SNAPSHOT-runner:18820]     (inline):   1,985.70 ms
   [getting-started-1.0-SNAPSHOT-runner:18820]    (compile):  14,922.77 ms
   [getting-started-1.0-SNAPSHOT-runner:18820]      compile:  20,361.28 ms
   [getting-started-1.0-SNAPSHOT-runner:18820]        image:   2,228.30 ms
   [getting-started-1.0-SNAPSHOT-runner:18820]        write:     364.35 ms
   [getting-started-1.0-SNAPSHOT-runner:18820]      [total]:  52,777.76 ms
   [INFO]
   [INFO] --- maven-failsafe-plugin:2.22.1:integration-test (default) @ getting-started ---
   [INFO]
   [INFO] -------------------------------------------------------
   [INFO]  T E S T S
   [INFO] -------------------------------------------------------
   [INFO] Running org.acme.quickstart.NativeGreetingResourceIT
   Executing [/data/home/gsmet/git/quarkus-quickstarts/getting-started/target/getting-started-1.0-SNAPSHOT-runner, -Dquarkus.http.port=8081, -Dtest.url=http://localhost:8081, -Dquarkus.log.file.path=build/quarkus.log]
   2019-04-15 11:33:20,348 INFO  [io.quarkus] (main) Quarkus 999-SNAPSHOT started in 0.002s. Listening on: http://[::]:8081
   2019-04-15 11:33:20,348 INFO  [io.quarkus] (main) Installed features: [cdi, resteasy]
   [INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.387 s - in org.acme.quickstart.NativeGreetingResourceIT
   ...

   注意

   Quarkus 在自动失败原生测试前等待 60 秒启动。您可以使用 quarkus.test.native-image-wait-time 系统属性更改此持续时间。

   您可以使用以下命令来扩展等待时间，其中 < duration&gt; 是等待的时间（以秒为单位）：

   ./mvnw verify -Pnative -Dquarkus.test.native-image-wait-time=<duration>

流程

1. 要在开发模式下启动 Quarkus，请在包含 Quarkus 应用程序 pom.xml 文件的目录中输入以下命令：

   ./mvnw quarkus:dev

2. 更改应用程序并保存文件。

3. 刷新浏览器以触发工作区的扫描。

   如果检测到任何更改，则会重新编译 Java 文件并重新部署应用程序。然后，您的请求由重新部署的应用提供服务。如果编译或部署存在问题，则会出现错误页面。

   在开发模式中，调试器被激活并侦听端口 5005。

4. 可选：要在运行应用程序前等待调试器附加，请包括 -Dsuspend ：

   ./mvnw quarkus:dev -Dsuspend

5. 可选： 要防止调试器运行，请包含 -Ddebug=false ：

   ./mvnw quarkus:dev -Ddebug=false

通过系统属性控制调试器

1. 更改 debug 系统属性的以下值之一，其中 PORT 是调试器侦听的端口：

   • false ：JVM 从禁用调试模式开始。
   • true ：JVM 以 debug 模式启动，并侦听端口 5005。
   • 客户端 ：JVM 以客户端模式启动，并尝试连接到 localhost:5005。
   • PORT ：JVM 以 debug 模式启动，并侦听 PORT。

2. 更改 suspend 系统属性的值。Quarkus 以 debug 模式启动时使用此属性。

   • Y 或 true ：调试模式 JVM 启动挂起。
   • N 或 false ：调试模式 JVM 启动而不挂起。