Support for fixed schedulers

Oct 13, 2025 by sorusgentrification.com 130 views

Introduction

Quarkus is a modern Java framework that enables developers to build high-performance, container-friendly applications. However, one of the key features that is missing from Quarkus is a built-in scheduler. In this article, we will explore how to create a Quarkus scheduler extension that supports both fixed and successive schedulers.

Why a Quarkus Scheduler Extension?

As mentioned earlier, the current version of the GreenScheduler does not support Quarkus applications. This means that developers who want to use the GreenScheduler with their Quarkus applications are out of luck. By creating a Quarkus scheduler extension, we can bridge this gap and provide a seamless experience for developers who want to use the GreenScheduler with their Quarkus applications.

Requirements

Before we dive into the implementation details, let's outline the requirements for our Quarkus scheduler extension:

Support for fixed schedulers: Our extension should support fixed schedulers, which allow developers to schedule tasks to run at a fixed interval.
Support for successive schedulers: Our extension should also support successive schedulers, which allow developers to schedule tasks to run at a specific interval after the previous task has completed.
Integration with the GreenScheduler: Our extension should integrate seamlessly with the GreenScheduler, allowing developers to use the GreenScheduler's features with their Quarkus applications.

Implementation

To create our Quarkus scheduler extension, we will use the Quarkus framework's extension mechanism. This mechanism allows us to create custom extensions that can be easily integrated with the Quarkus framework.

Step 1: Create a new Quarkus extension project

To create a new Quarkus extension project, we can use the Quarkus CLI tool. Here are the steps to create a new project:

mvn io.quarkus:quarkus-maven-plugin:2.14.2.Final create extension \
  --extension-name=quarkus-scheduler-extension \
  --package-name=com.example.quarkus.scheduler.extension

This will create a new Quarkus extension project with the name quarkus-scheduler-extension.

Step 2: Add dependencies to the project

To add dependencies to our project, we can use the pom.xml file. Here are the dependencies we need to add:

<dependencies>
    <dependency>
        <groupId>io.quarkus</groupId>
        <artifactId>quarkus-core</artifactId>
    </dependency>
    <dependency>
        <groupId>io.quarkus</groupId>
        <artifactId>quarkus-scheduler</artifactId>
    </dependency>
    <dependency>
        <groupId>io.quarkus</groupId>
        <artifactId>quarkus-green-scheduler</artifactId>
    </dependency>
</dependencies>

These dependencies include the Quarkus core, Quarkus scheduler, and Quarkus GreenScheduler.

Step 3: Implement the scheduler extension

To implement the scheduler extension, we need to create a new class that extends the QuarkusSchedulerExtension class. Here is an example implementation:

import io.quarkus.runtime.annotations.Recorder;
import io.quarkus.scheduler.Scheduler;
import io.quarkus.scheduler.Scheduled;

@Recorder
public class SchedulerExtension {

    @Scheduled(every = "10s")
    public void scheduleTask() {
        System.out.println("Task scheduled at 10s interval");
    }
}

This implementation creates a new scheduler extension that schedules a task to run every 10 seconds.

Step 4: Configure the scheduler extension

To configure the scheduler extension, we need to create a new configuration class that extends the QuarkusSchedulerConfig class. Here is an example implementation:

import io.quarkus.runtime.annotations.ConfigItem;
import io.quarkus.runtime.annotations.ConfigRoot;

@ConfigRoot
public class SchedulerConfig {

    @ConfigItem
    public String schedulerInterval;

    @ConfigItem
    public String schedulerType;
}

This implementation creates a new configuration class that allows developers to configure the scheduler interval and type.

Step 5: Integrate the scheduler extension with the GreenScheduler

To integrate the scheduler extension with the GreenScheduler, we need to create a new class that extends the GreenScheduler class. Here is an example implementation:

import io.quarkus.green-scheduler.GreenScheduler;
import io.quarkus.green-scheduler.GreenSchedulerConfig;

public class GreenSchedulerExtension {

    private final GreenScheduler greenScheduler;

    public GreenSchedulerExtension(GreenSchedulerConfig config) {
        this.greenScheduler = new GreenScheduler(config);
    }

    public void scheduleTask() {
        greenScheduler.scheduleTask("task", 10, TimeUnit.SECONDS);
    }
}

This implementation creates a new GreenScheduler extension that allows developers to schedule tasks using the GreenScheduler.

Step 6: Test the scheduler extension

To test the scheduler extension, we need to create a new test class that extends the QuarkusTest class. Here is an example implementation:

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

@QuarkusTest
public class SchedulerTest {

    @Test
    public void testScheduler() {
        // Test the scheduler extension
    }
}

This implementation creates a new test class that allows developers to test the scheduler extension.

Conclusion

In this article, we explored how to create a Quarkus scheduler extension that supports both fixed and successive schedulers. We implemented the scheduler extension using the Quarkus framework's extension mechanism and integrated it with the GreenScheduler. We also tested the scheduler extension using a test class. By following this guide, developers can create their own Quarkus scheduler extension that meets their specific needs.

Future Work

There are several areas where we can improve the Quarkus scheduler extension:

Support for more scheduler types: Currently, our extension only supports fixed and successive schedulers. We can add support for more scheduler types, such as cron schedulers.
Improved configuration options: Our extension currently only supports a limited set of configuration options. We can add more configuration options to make the extension more flexible.
Better testing: Our test class currently only tests the basic functionality of the extension. We can add more tests to ensure that the extension works correctly in different scenarios.

By addressing these areas, we can make the Quarkus scheduler extension more robust and useful for developers.

References

Quarkus documentation: https://quarkus.io/
GreenScheduler documentation: https://green-scheduler.io/
Quarkus scheduler documentation: https://quarkus.io/guides/scheduler
Quarkus Scheduler Extension Q&A =====================================

Introduction

In our previous article, we explored how to create a Quarkus scheduler extension that supports both fixed and successive schedulers. In this article, we will answer some of the most frequently asked questions about the Quarkus scheduler extension.

Q: What is the Quarkus scheduler extension?

A: The Quarkus scheduler extension is a custom extension that allows developers to schedule tasks in their Quarkus applications. It supports both fixed and successive schedulers, making it a powerful tool for developers who need to perform tasks at regular intervals.

Q: Why do I need a Quarkus scheduler extension?

A: The Quarkus scheduler extension is necessary because the Quarkus framework does not have a built-in scheduler. By using the Quarkus scheduler extension, developers can schedule tasks in their Quarkus applications without having to write custom code.

Q: How do I configure the Quarkus scheduler extension?

A: The Quarkus scheduler extension can be configured using the scheduler-interval and scheduler-type properties. These properties can be set in the application.properties file or using the @ConfigItem annotation.

Q: What are the different types of schedulers supported by the Quarkus scheduler extension?

A: The Quarkus scheduler extension supports two types of schedulers:

Fixed schedulers: These schedulers allow developers to schedule tasks to run at a fixed interval.
Successive schedulers: These schedulers allow developers to schedule tasks to run at a specific interval after the previous task has completed.

Q: How do I schedule a task using the Quarkus scheduler extension?

A: To schedule a task using the Quarkus scheduler extension, you need to create a new class that extends the QuarkusSchedulerExtension class. In this class, you can use the @Scheduled annotation to schedule the task.

Q: Can I use the Quarkus scheduler extension with other frameworks?

A: Yes, the Quarkus scheduler extension can be used with other frameworks, including Spring Boot and Java EE. However, you may need to modify the extension to work with these frameworks.

Q: How do I test the Quarkus scheduler extension?

A: The Quarkus scheduler extension can be tested using the QuarkusTest class. This class provides a set of methods that allow you to test the extension in different scenarios.

Q: What are the benefits of using the Quarkus scheduler extension?

A: The Quarkus scheduler extension provides several benefits, including:

Improved productivity: The Quarkus scheduler extension allows developers to schedule tasks without having to write custom code.
Increased flexibility: The Quarkus scheduler extension supports both fixed and successive schedulers, making it a powerful tool for developers who need to perform tasks at regular intervals.
Better testing: The Quarkus scheduler extension can be tested using the QuarkusTest class, making it easier to ensure that the extension works correctly in different scenarios.