In a command terminal, enter the following command to verify that Maven is using JDK 11 or 17, and that the Maven version is 3.8.1 or higher:

mvn --version

If the preceding command does not return JDK 11 or 17, add the path to JDK 11 to the PATH environment variable and enter the preceding command again.

To generate the project, enter one of the following commands:

• If you are using Linux or Apple macOS, enter the following command:

  mvn com.redhat.quarkus.platform:quarkus-maven-plugin:2.2.5.Final-redhat-00007:create \
      -DprojectGroupId=org.acme \
      -DprojectArtifactId=getting-started \
      -DplatformGroupId=com.redhat.quarkus.platform \
      -DplatformVersion=2.2.5.Final-redhat-00007 \
      -DclassName="org.acme.quickstart.GreetingResource" \
      -Dpath="/hello"
  cd getting-started

• If you are using the Microsoft Windows command line, enter the following command:

  mvn com.redhat.quarkus.platform:quarkus-maven-plugin:2.2.5.Final-redhat-00007:create
  -DprojectGroupId=org.acme -DprojectArtifactId=getting-started
  -DplatformGroupId=com.redhat.quarkus.platform
  -DplatformVersion=2.2.5.Final-redhat-00007
  -DclassName="org.acme.quickstart.GreetingResource"
  -Dpath="/hello"

• If you are using the Microsoft Windows Powershell, enter the following command:

  mvn com.redhat.quarkus.platform:quarkus-maven-plugin:2.2.5.Final-redhat-00007:create
  "-DprojectGroupId=org.acme"
  "-DprojectArtifactId=getting-started"
  "-DplatformVersion=2.2.5.Final-redhat-00007"
  "-DplatformGroupId=com.redhat.quarkus.platform"
  "-DclassName=org.acme.quickstart.GreetingResource"
  "-Dpath=/hello"

  These commands create the following elements in the ./getting-started directory:

  • The Maven project directory structure

  • An org.acme.quickstart.GreetingResource resource exposed on /hello

  • Associated unit tests for testing your application in native mode and JVM mode

  • A landing page that is accessible on http://localhost:8080 after you start the application

  • Example Dockerfile.jvm, Dockerfile.native, and Dockerfile.legacy-jar files in the src/main/docker directory

  • The application configuration file

After the directory structure is created, open the pom.xml file in a text editor and examine the contents of the file:

<project>
  ...
  <properties>
     ...
     <quarkus.platform.group-id>com.redhat.quarkus.platform</quarkus.platform.group-id>
     <quarkus.platform.artifact-id>quarkus-bom</quarkus.platform.artifact-id>
     <quarkus.platform.version>2.2.5.Final-redhat-00007</quarkus.platform.version>
     ...
  </properties>
  ...
  <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>
  ...
  <build>
      ...
      <plugins>
        ...
        <plugin>
          <groupId>${quarkus.platform.group-id}</groupId>
          <artifactId>quarkus-maven-plugin</artifactId>
          <version>${quarkus.platform.version}</version>
          <extensions>true</extensions>
          <executions>
            <execution>
              <goals>
                <goal>build</goal>
                <goal>generate-code</goal>
                <goal>generate-code-tests</goal>
              </goals>
            </execution>
          </executions>
        </plugin>
        ...
      </plugins>
      ...
  </build>
 ...
</project>

The Quarkus BOM is included in the <dependencyManagement> section of the pom.xml file. Therefore, you do not need to list the versions of individual Quarkus dependencies in the pom.xml file. In addition, you can see the quarkus-maven-plugin plug-in that is responsible for packaging the application and providing the development mode.

Review the quarkus-resteasy dependency in the pom.xml file. This dependency enables you to develop REST applications:

<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-resteasy</artifactId>
</dependency>

Review the src/main/java/org/acme/quickstart/GreetingResource.java file:

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("/hello")
public class GreetingResource {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return "Hello RESTEasy";
    }
}

This file contains a simple REST endpoint that returns hello as a response to a request that you send to the /hello endpoint.

To compile the Quarkus Hello application in development mode, enter the following command from the project directory:

./mvnw quarkus:dev

The following example shows the output of this command:

[INFO] ----------------------< org.acme:getting-started >----------------------
[INFO] Building getting-started 1.0.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- quarkus-maven-plugin:2.2.3.Final-redhat-00013:generate-code (default) @ getting-started ---
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ getting-started ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 2 resources
[INFO]
[INFO] --- maven-compiler-plugin:3.8.1:compile (default-compile) @ getting-started ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to /home/mjurc/Playground/getting-started/target/classes
[INFO]
[INFO] --- quarkus-maven-plugin:2.2.3.Final-redhat-00013:dev (default-cli) @ getting-started ---
[INFO] Invoking org.apache.maven.plugins:maven-resources-plugin:2.6:testResources @ getting-started
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory /home/mjurc/Playground/getting-started/src/test/resources
[INFO] Invoking org.apache.maven.plugins:maven-compiler-plugin:3.8.1:testCompile @ getting-started
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 2 source files to /home/mjurc/Playground/getting-started/target/test-classes
Listening for transport dt_socket at address: 5005
__  ____  __  _____   ___  __ ____  ______
 --/ __ \/ / / / _ | / _ \/ //_/ / / / __/
 -/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/
Powered by Quarkus 2.2.3.Final-redhat-00013
2021-11-23 16:16:19,014 INFO  [io.quarkus] (Quarkus Main Thread) getting-started 1.0.0-SNAPSHOT on JVM (powered by Quarkus 2.2.3.Final-redhat-00013) started in 1.582s. Listening on: http://localhost:8080
2021-11-23 16:16:19,017 INFO  [io.quarkus] (Quarkus Main Thread) Profile dev activated. Live Coding activated.
2021-11-23 16:16:19,018 INFO  [io.quarkus] (Quarkus Main Thread) Installed features: [cdi, resteasy, smallrye-context-propagation]

Enter the following command in a new terminal window to send a request to the endpoint provided by the application:

getting-started curl -w "\n" http://localhost:8080/hello
Hello RESTEasy

To stop the application, press Ctrl+C.

To modify the application and add a companion bean, create the src/main/java/org/acme/quickstart/GreetingService.java file with the following content:

package org.acme.quickstart;

import javax.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class GreetingService {

    public String greeting(String name) {
        return "hello " + name;
    }

}

Edit the src/main/java/org/acme/quickstart/GreetingResource.java to inject the GreetingService and create a new endpoint using it:

package org.acme.quickstart;

import javax.inject.Inject;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import org.jboss.resteasy.annotations.jaxrs.PathParam;

@Path("/hello")
public class GreetingResource {

    @Inject
    GreetingService service;

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    @Path("/greeting/{name}")
    public String greeting(@PathParam String name) {
        return service.greeting(name);
    }

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return "hello";
    }
}

If you stopped the application, enter the following command to restart it:

./mvnw quarkus:dev

To verify that the endpoint returns hello quarkus, enter the following command in a new terminal window:

curl -w "\n" http://localhost:8080/hello/greeting/quarkus
hello quarkus

Open the generated pom.xml file and review the contents:

<plugin>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>${surefire-plugin.version}</version>
    <configuration>
       <systemPropertyVariables>
         <java.util.logging.manager>org.jboss.logmanager.LogManager</java.util.logging.manager>
         <maven.home>${maven.home}</maven.home>
       </systemPropertyVariable>
    </configuration>
</plugin>

Note, that:

• the java.util.logging.manager system property is set to ensure that you application uses the correct log manager for the test.

• the maven.home property points to the location of the settings.xml file in which you can store custom Maven configuration that you want to apply to your project.

Edit the src/test/java/org/acme/quickstart/GreetingResourceTest.java file to match the following content:

package org.acme.quickstart;

import io.quarkus.test.junit.QuarkusTest;
import org.junit.jupiter.api.Test;

import java.util.UUID;

import static io.restassured.RestAssured.given;
import static org.hamcrest.CoreMatchers.is;

@QuarkusTest
public class GreetingResourceTest {

    @Test
    public void testHelloEndpoint() {
        given()
          .when().get("/hello")
          .then()
             .statusCode(200)
             .body(is("hello"));
    }

    @Test
    public void testGreetingEndpoint() {
        String uuid = UUID.randomUUID().toString();
        given()
          .pathParam("name", uuid)
          .when().get("/hello/greeting/{name}")
          .then()
            .statusCode(200)
            .body(is("hello " + uuid));
    }

}

To run these tests from Maven, enter the following command:

./mvnw test

By default, tests run on port 8081 so they do not conflict with the running application. In Quarkus, the RestAssured dependency is configured to use this port. If you want to use a different client, use the @TestHTTPResource annotation to directly inject the URL of the tested application into a field on the Test class. This field can be of the type String, URL or URI. You can also provide the test path in this annotation. For example, to test a servlet mapped to /myservlet, add the following lines to your test:

@TestHTTPResource("/myservlet")
URL testUrl;

If necessary, specify the test port in the quarkus.http.test-port configuration property.

To package your Quarkus Getting Started project, enter the following command in the root directory:

./mvnw package

This command produces the following JAR files in the /target directory:

• getting-started-1.0-0-SNAPSHOT.jar: Contains the classes and resources of the projects. This is the regular artifact produced by the Maven build.

• quarkus-app/quarkus-run.jar: Is an executable JAR file. This file is not an uber-JAR file because the dependencies are copied into the target/lib directory.

  When your application is running in development mode, you must press Ctrl+C to stop your application. You will encounter a port conflict when you try to package your application when development mode is enabled.

Enter the following command to start your application:

java -jar target/quarkus-app/quarkus-run.jar

Navigate to https://code.quarkus.redhat.com using a web browser.

Specify basic details about your project:

1. Enter a group name for your project. The name format follows the Java package naming convention, for example, org.acme.

2. Enter a name that you want to use for Maven artifacts generated from your project, for example, code-with-quarkus.

3. Select the build tool you want to use to compile and start your application. The build tool that you choose determines:

   • the directory structure of your generated project

   • the format of configuration files used in your generated project

   • the custom build script and command for compiling and starting your application that code.quarkus.redhat.com displays for you after you generate your project

     Red Hat provides support for using code.quarkus.redhat.com to create Quarkus Maven projects only.

     

Specify additional details about your application project:

1. Select Configure more options to display the fields that contain further application details.

2. Enter a version that is used in artifacts generated from your project. The default value of this field is 1.0.0-SNAPSHOT. Using semantic versioning is recommended, but you can use a different type of versioning if you prefer.

3. Select whether you want code.quarkus.redhat.com to add starter code to your project. When you add extensions that are marked with CODE to your project from the list of extensions, you can enable this option to automatically create example class files and resource files for those extensions when you generate your project. This option does not affect your generated project when you do not add any extensions that provide an example code.

   

   code.quarkus.redhat.com automatically uses the latest release of Red Hat build of Quarkus. You can manually change the BOM version in the pom.xml file after you generate your project.

Select the extensions you want to use in your application from the list of extensions. The selected extensions are included as dependencies of your Quarkus application, with their versions being managed by the Quarkus platform for ensuring their compatibility. Ensure that you do not use the RESTEasy and RESTEasy Reactive extensions in the same project.

The quark icon () next to an extension indicates that the extension is part of the Red Hat build of Quarkus platform release. Red Hat recommends that you use extensions from the same platform, because they are tested and verfied together, and thus are easier to use and upgrade.

You can enable the option to automatically generate starter code for extensions that are marked with CODE.

Select Generate your application to confirm your choices and display the overlay screen with the download link for the archive that contains your generated project. The overlay screen also shows the custom command that you can use to compile and start your application.

Select Download the ZIP to save the archive with the generated project files to your machine.

Extract the contents of the archive.

Navigate to the directory that contains your extracted project files:

cd <directory_name>

Compile and start your application in development mode:

./mvnw quarkus:dev