Gradle configuration
Configure your project as indicated in the Gradle configuration page.
At the moment there is no way of automatically generating a new project using the Quarkus Gradle plugin, luckily setting up a Quarkus project with Gradle is very simple. You only need to add the Quarkus Gradle plugin like this:
plugins {
id 'java'
id 'io.quarkus' version '0.16.0'
}
or, if you use the Gradle Kotlin DSL:
plugins {
java
id("io.quarkus") version "0.16.0"
}
Gradle configuration for a local SNAPSHOT version of Quarkus
This paragraph is relevant for those who want to use a locally built version of Quarkus, instead of an official release. It appears the configuration described above will not work in this case due to an issue in Gradle. There is a workaround though that looks a bit more verbose but nevertheless works for both locally built and offically released versions.
buildscript {
repositories {
mavenLocal()
}
dependencies {
classpath "io.quarkus:quarkus-gradle-plugin:$0.16.0"
}
}
plugins {
id 'java'
}
apply plugin: 'io.quarkus'
Creating a new project
For now we have to manually create a Gradle project file for Quarkus. Here is a complete sample file for a simple REST project:
plugins {
id 'java'
id 'io.quarkus' version '0.16.0' (1)
}
repositories {
mavenCentral()
}
dependencies { (2)
implementation enforcedPlatform('io.quarkus:quarkus-bom:0.16.0')
implementation 'io.quarkus:quarkus-resteasy'
}
1 | The Quarkus plugin needs to be applied. |
2 | We include the Quarkus BOM using Gradle’s relevant syntax and add RESTEasy dependency since we are developing a REST application similar to the getting started example.
Quarkus also need this dependency for running tests, to provide this we use the implementation configuration. |
Here’s the same build script, using the Gradle Kotlin DSL:
plugins {
java
id("io.quarkus") version "0.16.0"
}
repositories {
mavenCentral()
}
dependencies {
implementation(enforcedPlatform("io.quarkus:quarkus-bom:0.16.0"))
implementation("io.quarkus:quarkus-resteasy")
}
Enable Tests
Quarkus uses Junit5 and to enable it in Gradle we need to add a section to our build file:
test {
useJUnitPlatform()
}
To follow up our Rest example from above, we would also need to add two test dependencies:
testCompile group: 'io.quarkus', name: 'quarkus-junit5', version: '0.16.0'
testCompile group: 'io.rest-assured', name: 'rest-assured', version: '3.3.0'
Note: Quarkus do not allow both QuarkusTests and SubstrateTests to run in the same test run.
SubstrateTests should be seen as integration tests and moved to a different folder
as recommended here:
Configuring integration tests.
Quarkus supports running Substrate tests with Gradle, but the buildNative
task is required to be completed first.
Dealing with extensions
From inside a Quarkus project, you can obtain a list of the available extensions with:
./gradlew listExtensions
Functionality to automatically add extensions to your Gradle project is not implemented yet (coming soon).
Development mode
Quarkus comes with a built-in development mode. Run your application with:
./gradlew quarkusDev
You can then update the application sources, resources and configurations. The changes are automatically reflected in your running application. This is great to do development spanning UI and database as you see changes reflected immediately.
quarkusDev
enables hot deployment with background compilation, which means that when you modify
your Java files or your resource files and refresh your browser these changes will automatically take effect.
This works too for resource files like the configuration property file.
The act of refreshing the browser triggers a scan of the workspace, and if any changes are detected the
Java files are compiled, and the application is redeployed, then your request is serviced by the
redeployed application. If there are any issues with compilation or deployment an error page will let you know.
Hit CTRL+C
to stop the application.
Debugging
You can run a Quarkus application in debug mode using:
./gradlew quarkusDev --debug=true
Then, attach your debugger to localhost:5005
.
Import in your IDE
Once you have a project generated, you can import it in your favorite IDE. The only requirement is the ability to import a Gradle project.
Eclipse
In Eclipse, click on: File → Import
.
In the wizard, select: Gradle → Existing Gradle Project
.
On the next screen, select the root location of the project.
The next screen list the found modules; select the generated project and click on Finish
. Done!
In a separated terminal, run ./gradlew quarkusDev
, and enjoy a highly productive environment.
IntelliJ
In IntelliJ:
-
From inside IntelliJ select
File → New → Project From Existing Sources…
or, if you are on the welcome dialog, selectImport project
. -
Select the project root
-
Select
Import project from external model
andGradle
-
Next a few times (review the different options if needed)
-
On the last screen click on Finish
In a separated terminal or in the embedded terminal, run ./gradlew quarkusDev
. Enjoy!
Apache Netbeans
In Netbeans:
-
Select
File → Open Project
-
Select the project root
-
Click on
Open Project
In a separated terminal or the embedded terminal, go to the project root and run ./gradlew quarkusDev
. Enjoy!
Visual Studio Code
Open the project directory in VS Code. If you have installed the Java Extension Pack (grouping a set of Java extensions), the project is loaded as a Gradle project.
Building a native executable
Native executables make Quarkus applications ideal for containers and serverless workloads.
Make sure to have GRAALVM_HOME
configured and pointing to GraalVM version 1.0.0-rc16.
Create a native executable using: ./gradlew buildNative
.
A native executable will be present in build/
.
Build a container friendly executable
The native executable will be specific to your operating system. To create an executable that will run in a container, use the following:
./gradlew buildNative --docker-build=true
The produced executable will be a 64 bit Linux executable, so depending on your operating system it may no longer be runnable. However, it’s not an issue as we are going to copy it to a Docker container.
Building Uber-Jars
Quarkus Gradle plugin supports the generation of Uber-Jars by specifying an --uber-jar
argument as follows:
./gradlew quarkusBuild --uber-jar
When building an Uber-Jar you can specify entries that you want to exclude from the generated jar by using the --ignored-entry
argument:
./gradlew quarkusBuild --uber-jar --ignored-entry=META-INF/file1.txt
The entries are relative to the root of the generated Uber-Jar. You can specify multiple entries by adding extra --ignored-entry
arguments.