ball-bearings-with-quarkus Project

This project was implemented by @themaxens in the computer science course (year 2020) at the DHBW Mosbach. The task was completed as part of a student's project work.

Table of Contents

1. What is the project about?
2. Technologies
3. Documentation
4. Dev Container - Prerequisites
5. Running the application in dev mode
6. Packaging and running the application
7. Creating a native executable
8. Contribution

What is the project about?

In this project, a Reactive RESTful Web Service was implemented, which calculates the life time of ball bearings in an O-arrangement. The usual CRUD operations (Create, Read, Update and Delete) are available.

The software was designed according to the architectural pattern of Hexagonal Architecture which is based on ports and adapters. The book "Designing Hexagonal Architecture with Java" by Davi Vieira gives a good overview of the concepts of hexagonal architecture.

Technologies

This project uses Quarkus, the Supersonic Subatomic Java Framework. If you want to learn more about Quarkus, please visit its website: https://quarkus.io/.

Additional technologies used:

• Gradle as a build tool
• PostgreSQL database
• Hibernate as an object-relational mapper
• Docker (used for development containers)
• quarkus-junit5 and rest-assured for testing the application - the implemented test cases are located here

Have a look at the dependencies in build.gradle for a complete overview.

Documentation

There is also a detailed documentation (written in latex) for this project. Have a look at the file content.tex.

The corresponding PDF file can be found in this repo under the tab Actions. Select the top pass of the workflow compile-latex and then navigate to Artifacts. There you can download the associated PDF with the name INF20B_Max_4706893_T3101.

The Github workflow always generates a new PDF if there is a change in the /docs folder during a pull request (see Contribution).

Dev Container - Prerequisites

You can develop the application in a development container, in which all necessary dependencies have already been resolved. You can start right away with coding.

To do this, the following tools must be installed:

1. Docker Desktop
2. Visual Studio Code
3. Remote Development Extension for VSCode

Also have a look at chapter 3 (Remote development) in the latex documentation for more information.

Running the application in dev mode

You can run your application in dev mode that enables live coding using:

./gradlew quarkusDev

NOTE: Quarkus now ships with a Dev UI, which is available in dev mode only at http://localhost:8080/q/dev/.

Packaging and running the application

The application can be packaged using:

./gradlew build

It produces the quarkus-run.jar file in the build/quarkus-app/ directory. Be aware that it’s not an über-jar as the dependencies are copied into the build/quarkus-app/lib/ directory.

The application is now runnable using java -jar build/quarkus-app/quarkus-run.jar.

If you want to build an über-jar, execute the following command:

./gradlew build -Dquarkus.package.type=uber-jar

The application, packaged as an über-jar, is now runnable using java -jar build/*-runner.jar.

Creating a native executable

You can create a native executable using:

./gradlew build -Dquarkus.package.type=native

Or, if you don't have GraalVM installed, you can run the native executable build in a container using:

./gradlew build -Dquarkus.package.type=native -Dquarkus.native.container-build=true

You can then execute your native executable with: ./build/ball-bearings-with-quarkus-1.0.0-SNAPSHOT-runner

If you want to learn more about building native executables, please consult https://quarkus.io/guides/gradle-tooling.

Contribution

Here, you will find the contribution guide.