JobRunr

https://www.jobrunr.io/en/documentation
Admin
JobRunr is a lightweight library designed for background job processing in Java applications,...
Tokens:117,245
Snippets:1,133
Trust Score:8.3
Update:1 week ago
Show doc for...
Tokens:
Raw
### Clone and run the example project

Source: https://www.jobrunr.io/en/documentation/getting-started/micronaut

Clones the JobRunr Micronaut example repository and starts the application using Gradle.

```bash
git clone https://github.com/jobrunr/jobrunr-examples.git
cd jobrunr-examples/micronaut-app
./gradlew run
```

--------------------------------

### Clone and run the JobRunr Kotlin example project

Source: https://www.jobrunr.io/en/documentation/getting-started/kotlin

Clone the jobrunr-examples repository and run the Kotlin application using Gradle. This is the fastest way to get started with JobRunr in Kotlin.

```bash
git clone https://github.com/jobrunr/jobrunr-examples.git
cd jobrunr-examples/kotlin-app
./gradlew run

```

--------------------------------

### Clone and run the Quarkus example project

Source: https://www.jobrunr.io/en/documentation/getting-started/quarkus

Clones the JobRunr Quarkus example project and starts it in dev mode with Maven.

```bash
git clone https://github.com/jobrunr/jobrunr-examples.git
cd jobrunr-examples/quarkus-app
./mvnw quarkus:dev
```

--------------------------------

### Start the application with Gradle

Source: https://www.jobrunr.io/en/documentation/getting-started/micronaut

Starts the Micronaut application using the Gradle wrapper.

```bash
./gradlew run
```

--------------------------------

### Start the application from scratch with Maven

Source: https://www.jobrunr.io/en/documentation/getting-started/spring

Runs the Spring Boot app using the Maven wrapper.

```bash
./mvnw spring-boot:run
```

--------------------------------

### Start the application from scratch with Gradle

Source: https://www.jobrunr.io/en/documentation/getting-started/spring

Runs the Spring Boot app using the Gradle wrapper.

```bash
./gradlew bootRun
```

--------------------------------

### Start the application with Maven

Source: https://www.jobrunr.io/en/documentation/getting-started/micronaut

Starts the Micronaut application using the Maven wrapper.

```bash
./mvnw mn:run
```

--------------------------------

### Clone and run the JobRunr example project

Source: https://www.jobrunr.io/en/documentation/getting-started/java

Clones the JobRunr example project and runs the Java application using Gradle.

```bash
git clone https://github.com/jobrunr/jobrunr-examples.git
cd jobrunr-examples/java-app
./gradlew run
```

--------------------------------

### Start and stop JobRunr servers with CDI lifecycle events

Source: https://www.jobrunr.io/en/documentation/getting-started/other

Use this @ApplicationScoped bean to start the JobRunrDashboardWebServer and BackgroundJobServer on the StartupEvent and stop them, along with the StorageProvider, on the ShutdownEvent. Both servers were created with startServerOnInit: false, so they must be started manually here.

```java
@ApplicationScoped
public class JobRunrStarter {
    private final BackgroundJobServer backgroundJobServer;
    private final JobRunrDashboardWebServer dashboardWebServer;
    private final StorageProvider storageProvider;

    public JobRunrStarter(BackgroundJobServer backgroundJobServer, JobRunrDashboardWebServer dashboardWebServer, StorageProvider storageProvider) {
        this.backgroundJobServer = backgroundJobServer;
        this.dashboardWebServer = dashboardWebServer;
        this.storageProvider = storageProvider;
    }

    void startup(@Observes StartupEvent event) {
        dashboardWebServer.start();
        backgroundJobServer.start();
    }

    void shutdown(@Observes ShutdownEvent event) {
        backgroundJobServer.stop();
        dashboardWebServer.stop();
        storageProvider.close();
    }
}
```

--------------------------------

### Basic MultiClusterWebServer setup

Source: https://www.jobrunr.io/en/documentation/pro/jobrunr-pro-multi-dashboard

Bootstraps a MultiClusterWebServer with default configuration. The dashboard is available at localhost:8000 but won't do much without cluster configuration.

```java
var multiClusterWebServer = new MultiClusterWebServer();
multiClusterWebServer.start();

```

--------------------------------

### Start Quarkus app in dev mode with Maven

Source: https://www.jobrunr.io/en/documentation/getting-started/quarkus

Starts the Quarkus application in dev mode using Maven when building from scratch.

```bash
./mvnw quarkus:dev
```

--------------------------------

### Configure dashboard with Spring configuration

Source: https://www.jobrunr.io/en/documentation/background-methods/dashboard

Enables the dashboard and sets the port via application.properties. The dashboard will be started on the given port.

```properties
jobrunr.dashboard.enabled=true 
jobrunr.dashboard.port=8000

```

--------------------------------

### Start Quarkus app in dev mode with Gradle

Source: https://www.jobrunr.io/en/documentation/getting-started/quarkus

Starts the Quarkus application in dev mode using Gradle when building from scratch.

```bash
./gradlew quarkusDev
```

--------------------------------

### Advanced example: parameter-based mutexes

Source: https://www.jobrunr.io/en/documentation/pro/mutexes

Shows how mutexes can incorporate job parameters, creating separate mutexes per OS. Only one job per OS runs in parallel, even with many files.

```java
public void scanForViruses(File folder) {
    for(String f : folder.list()) {
        scanForViruses(f);
    }
}

public void scanForViruses(String file) {
    BackgroundJob.enqueue(() -> osSpecificVirusScan("LINUX", file));
    BackgroundJob.enqueue(() -> osSpecificVirusScan("WINDOWS", file));
    BackgroundJob.enqueue(() -> osSpecificVirusScan("MACOS", file));
}


@Job(mutex = "virus-scanner/%0")
public void osSpecificVirusScan(String os, String file) {
    System.out.println(String.format("This will result in a mutex virus-scanner/%0", os));
}
```

--------------------------------

### Framework-specific test setup: inject StorageProvider in Spring Boot, Quarkus, Micronaut

Source: https://www.jobrunr.io/en/documentation/testing

Framework-specific test setups for Spring Boot, Quarkus, and Micronaut. Use these to inject the JobRunr StorageProvider instead of retrieving it from the static context, because the static context holds a single instance for the whole JVM and can cause tests to read another context's jobs when run in parallel. Each setup also shows how to disable features (e.g., background job server) for individual tests by setting the relevant property to 'false'.

```java
@SpringBootTest(properties = {
    "jobrunr.database.type=mem",
    "jobrunr.background-job-server.enabled=true",
    "jobrunr.background-job-server.poll-interval-in-seconds=1"
})
class SubscriptionServiceTest {

    @Autowired
    StorageProvider storageProvider;

    // ...

}

```

```java
@QuarkusTest
@TestProfile(SubscriptionServiceTest.SubscriptionServiceTestProfile.class)
class SubscriptionServiceTest {

    @Inject
    StorageProvider storageProvider;

    public static class SubscriptionServiceTestProfile implements QuarkusTestProfile {

        @Override
        public Map<String, String> getConfigOverrides() {
            return Map.of(
                "quarkus.jobrunr.database.type", "mem",
                "quarkus.jobrunr.background-job-server.enabled", "true",
                "quarkus.jobrunr.background-job-server.poll-interval", "1"
            );
        }
    }
}


```

```java
@MicronautTest
@Property(name = "jobrunr.database.type", value = "mem")
@Property(name = "jobrunr.background-job-server.enabled", value = "true")
@Property(name = "jobrunr.background-job-server.poll-interval-in-seconds", value = "1")
class SubscriptionServiceTest {

    @Inject
    StorageProvider storageProvider;
}


```

--------------------------------

### Manual configuration with JobRunr.configure()

Source: https://www.jobrunr.io/en/documentation/serialization/gson

Manually configure JobRunr to use GsonJsonMapper when auto-detection fails. This is the primary manual setup.

```java
JobRunr.configure()
  .useJsonMapper(new GsonJsonMapper())
  //...
  .initialize();
```

--------------------------------

### Apply SQL scripts manually

Source: https://www.jobrunr.io/en/documentation/pro/database-migrations

Generate all database related scripts manually using the DatabaseSqlMigrationFileProvider. This allows you to manually setup and update your database.

```bash
java -cp jobrunr-9.0.1.jar org.jobrunr.storage.sql.common.DatabaseSqlMigrationFileProvider {databaseType} ({tablePrefix})

```

--------------------------------

### Configure dashboard with fluent configuration

Source: https://www.jobrunr.io/en/documentation/background-methods/dashboard

Enables the dashboard on the specified port using JobRunr's fluent API. The dashboard will be started on port 8000.

```java
JobRunr.configure()
    .useDashboard(8000)

```

--------------------------------

### Test the subscribe and confirm endpoints with curl

Source: https://www.jobrunr.io/en/documentation/getting-started/kotlin

Use these curl commands to test the JobRunr example endpoints. The subscribe endpoint sends a confirmation email immediately, while the confirm endpoint schedules a welcome email for 3 days from now.

```bash
# Subscribe: sends a confirmation email immediately
curl -X POST "http://localhost:8080/subscribe?email=test@example.com"

# Confirm: schedules a welcome email for 3 days from now
curl -X POST "http://localhost:8080/confirm?email=test@example.com"

```

--------------------------------

### Build subscription server with JobRunr (App.java)

Source: https://www.jobrunr.io/en/documentation/getting-started/java

Creates App.java using Java 25 compact source files (no class declaration). Configures JobRunr with InMemoryStorageProvider, starts the background job server and dashboard, registers a weekly recurring job, and sets up HTTP endpoints /subscribe (fire-and-forget confirmation email) and /confirm (delayed welcome email 3 days later). Both handlers return 202 immediately; jobs are retried if the mail provider is down. InMemoryStorageProvider does not survive restarts.

```java
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpServer;
import org.jobrunr.configuration.JobRunr;
import org.jobrunr.scheduling.BackgroundJob;
import org.jobrunr.scheduling.cron.Cron;
import org.jobrunr.storage.InMemoryStorageProvider;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.time.DayOfWeek;
import java.time.Instant;
import java.time.temporal.ChronoUnit;

void main() throws Exception {
    var emailService = new EmailService();

    JobRunr.configure()  // Using JobRunr Pro? Replace `JobRunr` by `JobRunrPro`
        .useStorageProvider(new InMemoryStorageProvider())
        .useBackgroundJobServer()
        .useDashboard()
        .initialize();

    BackgroundJob.scheduleRecurrently("weekly-digest", Cron.weekly(DayOfWeek.of(1)),
        () -> emailService.sendWeeklyDigest()); 

    var server = HttpServer.create(new InetSocketAddress(8080), 0);

    server.createContext("/subscribe", exchange -> {
        if (!"POST".equalsIgnoreCase(exchange.getRequestMethod())) { respond(exchange, 405, "Method Not Allowed"); return; }
        var email = getEmailFromQueryParams(exchange);
        if (email == null) { respond(exchange, 400, "Missing email parameter"); return; }
        var jobId = BackgroundJob.enqueue(() -> emailService.sendConfirmation(email)); 
        respond(exchange, 202, "Confirmation email queued with job id " + jobId);
    });

    server.createContext("/confirm", exchange -> {
        if (!"POST".equalsIgnoreCase(exchange.getRequestMethod())) { respond(exchange, 405, "Method Not Allowed"); return; }
        var email = getEmailFromQueryParams(exchange);
        if (email == null) { respond(exchange, 400, "Missing email parameter"); return; }
        var jobId = BackgroundJob.schedule(Instant.now().plus(3, ChronoUnit.DAYS),
            () -> emailService.sendWelcome(email)); 
        respond(exchange, 202, "Welcome email scheduled with job id " + jobId);
    });

    server.start();
    IO.println("Listening on http://localhost:8080");
}

String getEmailFromQueryParams(HttpExchange ex) {
    var query = ex.getRequestURI().getQuery();
    if (query == null) return null;
    for (var param : query.split("&")) {
        if (param.startsWith("email=")) return param.substring(6);
    }
    return null;
}

void respond(HttpExchange ex, int status, String body) throws IOException {
    var bytes = body.getBytes();
    ex.sendResponseHeaders(status, bytes.length);
    ex.getResponseBody().write(bytes);
    ex.close();
}
```

--------------------------------

### Run the application with Maven

Source: https://www.jobrunr.io/en/documentation/getting-started/java

Compiles and runs the application from scratch using Maven, specifying the main class as App.

```bash
mvn compile exec:java -Dexec.mainClass=App
```

--------------------------------

### Non-working lambda within lambda example

Source: https://www.jobrunr.io/en/documentation/pro/batches

This example will not work because JobRunr is unable to analyse a lambda within a lambda. The parent job and child jobs are scheduled in the same lambda, which is not supported.

```java
public class NewsletterService {

    @Inject
    private UserRepository userRepository;

    public void sendEmailToAllSubscribers() {
        BackgroundJob.startBatch(() -> {
            List<User> users = userRepository.getAllUsers();
            for(User user : users) {
                BackgroundJob.enqueue(() -> mailService.send(user.getId(), "mail-template-key"));
            }
        });
    }
}

```

--------------------------------

### Run your own Kotlin application with Gradle

Source: https://www.jobrunr.io/en/documentation/getting-started/kotlin

If you are building from scratch, run your application with Gradle using this command.

```bash
./gradlew run

```

--------------------------------

### Create a complex workflow with startBatch and continueWith

Source: https://www.jobrunr.io/en/documentation/pro/batches

Shows a batch job workflow where step1 enqueues and schedules child jobs, and a continuation runs after step1 completes. The schedule uses now().add(24, HOURS) to run a job tomorrow.

```java
public void aComplexWorkflow() {
    String campaignReportLocation = "/path/to/campaign/report/" + campaignId + ".csv";
    BackgroundJob
        .startBatch(this::step1)
        .continueWith(() -> System.out.println("Step 2 which will only run after Step 1 completely succeeded"));
}

public void step1() {
  BackgroundJob.enqueue(() -> System.out.println("Step 1A of batch"));
  BackgroundJob
      .schedule(() -> System.out.println("Step 1B of batch which will run tomorrow"), now().add(24, HOURS))
      .continueWith(() -> System.out.println("Step 1C of batch which will run just after Step 1B has succeeded"));
}
```

--------------------------------

### Manually configure JacksonJsonMapper in JobRunr

Source: https://www.jobrunr.io/en/documentation/serialization/jackson2

Configures JobRunr to use JacksonJsonMapper when auto-detection fails. This is the standard manual setup.

```java
JobRunr.configure()
  .useJsonMapper(new JacksonJsonMapper())
  //...
  .initialize();
```

--------------------------------

### Run DatabaseCreator to create tables

Source: https://www.jobrunr.io/en/documentation/storage

Command to create necessary tables from a terminal. Provide a user with DDL rights. On success, a confirmation message is shown.

```bash
java -cp jobrunr-9.0.1.jar org.jobrunr.storage.sql.common.DatabaseCreator {jdbcUrl} {userName} {password}

```

--------------------------------

### Configure JobRunr with PostgresStorageProvider

Source: https://www.jobrunr.io/en/documentation/storage

Configure JobRunr with a PostgresStorageProvider and a background job server, then initialize.

```java
JobRunr.configure()
    .useStorageProvider(new PostgresStorageProvider(dataSource))
    .useBackgroundJobServer()
    .initialize();

```

--------------------------------

### Set interrupt duration to 90 minutes

Source: https://www.jobrunr.io/en/documentation/deployment

Example of setting the interrupt duration to 90 minutes, sized against the longest-running job.

```properties
jobrunr.background-job-server.interrupt-jobs-await-duration-on-stop=90m

```

--------------------------------

### Configure PostgreSQL DataSource (Quarkus)

Source: https://www.jobrunr.io/en/documentation/storage/postgres

Configure a PostgreSQL DataSource in Quarkus using application.properties. JobRunr automatically detects the existing DataSource when using a framework starter.

```properties
quarkus.datasource.db-kind=postgresql
quarkus.datasource.jdbc.url=jdbc:postgresql://localhost:5432/mydb
quarkus.datasource.username=myuser
quarkus.datasource.password=mypassword
```

--------------------------------

### Schedule a job with JobScheduler bean

Source: https://www.jobrunr.io/en/documentation/background-methods/scheduling-jobs

Use the JobScheduler bean to schedule a job. The example schedules an email to be sent 24 hours from now.

```java
@Inject
private JobScheduler jobScheduler;

jobScheduler.schedule<EmailService>(Instant.now().plus(24, ChronoUnit.HOURS), 
  x -> x.sendNewlyRegisteredEmail());
```

--------------------------------

### Create App.kt with JobRunr and HTTP server

Source: https://www.jobrunr.io/en/documentation/getting-started/kotlin

Main application that configures JobRunr with an in-memory storage provider, background job server, and dashboard, then starts an HTTP server on port 8080. It registers a recurring weekly digest job, enqueues a fire-and-forget confirmation email on POST /subscribe, and schedules a delayed welcome email on POST /confirm. Both handlers return 202 Accepted immediately; jobs are retried automatically if the mail provider is down. Note that InMemoryStorageProvider does not survive restarts.

```kotlin
import com.sun.net.httpserver.HttpExchange
import com.sun.net.httpserver.HttpServer
import org.jobrunr.configuration.JobRunr
import org.jobrunr.scheduling.BackgroundJob
import org.jobrunr.scheduling.cron.Cron
import org.jobrunr.storage.InMemoryStorageProvider
import java.net.InetSocketAddress
import java.time.DayOfWeek
import java.time.Instant
import java.time.temporal.ChronoUnit

fun main() {
    val emailService = EmailService()

    JobRunr.configure()  // Using JobRunr Pro? Replace `JobRunr` with `JobRunrPro`
        .useStorageProvider(InMemoryStorageProvider())
        .useBackgroundJobServer()
        .useDashboard()
        .initialize()

    BackgroundJob.scheduleRecurrently("weekly-digest", Cron.weekly(DayOfWeek.MONDAY)) {
        emailService.sendWeeklyDigest()
    } 

    val server = HttpServer.create(InetSocketAddress(8080), 0)

    server.createContext("/subscribe") { exchange ->
        if (exchange.requestMethod != "POST") { exchange.respond(405, "Method Not Allowed"); return@createContext }
        val email = exchange.getEmailFromQueryParams()
            ?: run { exchange.respond(400, "Missing email parameter"); return@createContext }
        val jobId = BackgroundJob.enqueue { emailService.sendConfirmation(email) } 
        exchange.respond(202, "Confirmation email queued with job id $jobId")
    }

    server.createContext("/confirm") { exchange ->
        if (exchange.requestMethod != "POST") { exchange.respond(405, "Method Not Allowed"); return@createContext }
        val email = exchange.getEmailFromQueryParams()
            ?: run { exchange.respond(400, "Missing email parameter"); return@createContext }
        val jobId = BackgroundJob.schedule(Instant.now().plus(3, ChronoUnit.DAYS)) {
            emailService.sendWelcome(email)
        } 
        exchange.respond(202, "Welcome email scheduled with job id $jobId")
    }

    server.start()
    println("Listening on http://localhost:8080")
}

fun HttpExchange.getEmailFromQueryParams(): String? {
    val q = requestURI.query ?: return null
    val value = q.substringAfter("email=", missingDelimiterValue = "")
    return value.ifEmpty { null }
}

fun HttpExchange.respond(status: Int, body: String) {
    val bytes = body.toByteArray()
    sendResponseHeaders(status, bytes.size.toLong())
    responseBody.write(bytes)
    close()
}

```

--------------------------------

### Provide EventTransport bean in Micronaut

Source: https://www.jobrunr.io/en/documentation/pro/instant-job-processing

Define an EventTransport bean in a Micronaut configuration class. This example uses MulticastEventTransport with a specific UDP URI.

```java
@Singleton
EventTransport eventTransport() {
    return new MulticastEventTransport(URI.create("udp://239.76.159.181:8379"));
}
```

--------------------------------

### Configure SQL Server datasource with HikariCP and JobRunr

Source: https://www.jobrunr.io/en/documentation/storage/sql-server

Create a HikariCP DataSource for SQL Server and use it with JobRunr's SqlStorageProviderFactory. This is for manual configuration when not using a framework starter.

```java
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:sqlserver://localhost:1433;databaseName=mydb");
config.setUsername("myuser");
config.setPassword("mypassword");
DataSource dataSource = new HikariDataSource(config);

JobRunr.configure()
    .useStorageProvider(SqlStorageProviderFactory.using(dataSource))
    .useBackgroundJobServer()
    .initialize();
```

--------------------------------

### Provide EventTransport producer in CDI

Source: https://www.jobrunr.io/en/documentation/pro/instant-job-processing

Define an EventTransport producer method in a CDI environment. This example uses MulticastEventTransport with a specific UDP URI.

```java
@Produces
@Singleton
EventTransport eventTransport() {
    return new MulticastEventTransport(URI.create("udp://239.76.159.181:8379"));
}
```

--------------------------------

### Provide EventTransport bean in Spring

Source: https://www.jobrunr.io/en/documentation/pro/instant-job-processing

Define an EventTransport bean in a Spring configuration class. This example uses MulticastEventTransport with a specific UDP URI.

```java
@Bean
EventTransport eventTransport() {
    return new MulticastEventTransport(URI.create("udp://239.76.159.181:8379"));
}
```

--------------------------------

### Configure JobRunr in application.properties

Source: https://www.jobrunr.io/en/documentation/getting-started/spring

Minimal configuration to enable the background job server and dashboard, and use an in-memory database. The first two properties are false by default; the in-memory store does not survive restarts and should be replaced with a real database before production.

```properties
jobrunr.background-job-server.enabled=true
jobrunr.dashboard.enabled=true
jobrunr.database.type=mem
```

--------------------------------

### Schedule a job with JobRequestScheduler bean

Source: https://www.jobrunr.io/en/documentation/background-methods/scheduling-jobs

Use the JobRequestScheduler bean to schedule a job request. The example schedules a SendNewlyRegisteredEmailJobRequest to be sent 24 hours from now.

```java
@Inject
private JobRequestScheduler jobRequestScheduler;

jobRequestScheduler.schedule(Instant.now().plus(24, ChronoUnit.HOURS), 
  new SendNewlyRegisteredEmailJobRequest());
```

--------------------------------

### Configure JobRunr with CockroachDB using HikariCP

Source: https://www.jobrunr.io/en/documentation/storage/cockroachdb

Configure a HikariCP DataSource with the PostgreSQL JDBC URL and use it with SqlStorageProviderFactory. This is for manual configuration without a framework starter.

```java
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:postgresql://localhost:26257/mydb");
config.setUsername("myuser");
config.setPassword("mypassword");
DataSource dataSource = new HikariDataSource(config);

JobRunr.configure()
    .useStorageProvider(SqlStorageProviderFactory.using(dataSource))
    .useBackgroundJobServer()
    .initialize();

```

--------------------------------

### Schedule a job with BackgroundJob.schedule

Source: https://www.jobrunr.io/en/documentation/background-methods/scheduling-jobs

Use BackgroundJob.schedule to postpone a method invocation by a specified delay. The example schedules an email to be sent 24 hours from now.

```java
BackgroundJob.schedule<EmailService>(Instant.now().plus(24, ChronoUnit.HOURS), 
  x -> x.sendNewlyRegisteredEmail());
```

--------------------------------

### Configure server tags via Fluent API andTags

Source: https://www.jobrunr.io/en/documentation/pro/server-tags

Configure server tags for the BackgroundJobServer using the fluent API. Pass all the tags for that server as strings or string constants. When configuring server tags, specify all the tags for that server.

```java
JobRunrPro
    .configure()
    .useBackgroundJobServer(usingStandardBackgroundJobServerConfiguration().andTags(LINUX, MACOS))
    ...

```

--------------------------------

### MailService with injected dependencies

Source: https://www.jobrunr.io/en/documentation/background-methods/background-jobs-dependencies

Example of a Spring component with constructor-injected dependencies (EmailRenderer, UserRepository, Environment) used by a background job method sendMail().

```java
@Component
public class MailService {
    
    private EmailRenderer emailRenderer;
    private UserRepository userRepository;
    private Environment environment;
    
    public MailService(EmailRenderer emailRenderer, UserRepository userRepository, Environment environment) {
        this.emailRenderer = emailRenderer;
        this.userRepository = userRepository;
        this.environment = environment;
    }
    
    public void sendMail(UUID userId, String templateId) {
    	User user = userRepository.getById(userId);
        String htmlEmail = emailRenderer.renderEmail(user, templateId);
        sendMail(user.getEmailAddress(), htmlEmail);
    }
    
    private void sendMail(String to, String htmlContent) {
    	Session session = Session.getInstance(prop, null);
    	Message message = new MimeMessage(session);
      message.setFrom(new InternetAddress(env.getProperty("mail.from")));
      message.setRecipients(
        Message.RecipientType.TO, InternetAddress.parse(to));
      message.setSubject(env.getProperty("mail.subject"));

      MimeBodyPart mimeBodyPart = new MimeBodyPart();
      mimeBodyPart.setContent(htmlContent, "text/html");
      Multipart multipart = new MimeMultipart();
      multipart.addBodyPart(mimeBodyPart);
      message.setContent(multipart);
      Transport.send(message);
    }
    
    private Properties getSmtpProperties() {
    	Properties prop = new Properties();
        prop.put("mail.smtp.host", env.getProperty("smtp.host"));
        prop.put("mail.smtp.port", "25");
        return prop;
    }
    
}
```

--------------------------------

### Unsupported passing IoC service as parameter

Source: https://www.jobrunr.io/en/documentation/background-methods

This example fails because the MyService instance is passed as a parameter to the lambda, but it is not available during analysis. It will throw a NullPointerException.

```java
BackgroundJob.<MyService>enqueue(x -> doWork(x));
```

--------------------------------

### Unsupported multiple method calls in lambda

Source: https://www.jobrunr.io/en/documentation/background-methods

This example is not supported because it contains two method calls, which would result in two jobs. It will fail.

```java
BackgroundJob.enqueue(() -> {
  myService.createPDF();
  myService.sendPDF();
);
```

--------------------------------

### Configure URL-based license key provider in JobRunrPro

Source: https://www.jobrunr.io/en/documentation/pro/installation

Configures the built-in UrlLicenseKeyProvider by passing an HTTP, HTTPS, or file URL to andLicenseKeyProvider. The provider has a 5-second timeout by default; if retrieval fails, it returns null and retries according to the schedule.

```java
JobRunrPro
    .configure()
    // ...
    .useBackgroundJobServer(usingStandardBackgroundJobServerConfiguration()
        .andLicenseKeyProvider("https://example.com/license-key")
    )
    // ...

```

--------------------------------

### Configure observability integrations (Jaeger, Micrometer, OpenTelemetry)

Source: https://www.jobrunr.io/en/documentation/pro/observability

Configuration to enable observability integrations. Set the Jaeger root URL, enable Micrometer observability, or enable OpenTelemetry observability.

```properties
# enable linking from within the JobRunr Pro Dashboard to your Tracing Provider
jobrunr.dashboard.integrations.observability.jaeger.root-url=http://localhost:16686/

# if you prefer Micrometer
jobrunr.jobs.metrics.micrometer-observability.enabled=true

# or, if you prefer OpenTelemetry
jobrunr.jobs.metrics.otel-observability.enabled=true

```

--------------------------------

### Configure custom LicenseKeyProvider in JobRunrPro

Source: https://www.jobrunr.io/en/documentation/pro/installation

Configures a custom LicenseKeyProvider by passing an instance to andLicenseKeyProvider. The provider is queried on initialization, every 5 seconds when no license is available, and once per day during normal operation (master server only).

```java
JobRunrPro
    .configure()
    // ...
    .useBackgroundJobServer(usingStandardBackgroundJobServerConfiguration()
        .andLicenseKeyProvider(new MyCustomLicenseKeyProvider())
    )
    // ...

```

--------------------------------

### Home and About components and export App

Source: https://www.jobrunr.io/en/documentation/pro/replace-jobs

Define simple Home and About functional components. Then export the App component as the default export for use in the entry point (e.g., index.js).

```javascript
const Home = () => <div>Home Page</div>;
const About = () => <div>About Page</div>;
export default App;
```

--------------------------------

### Configure PostgreSQL DataSource (Spring Boot)

Source: https://www.jobrunr.io/en/documentation/storage/postgres

Configure a PostgreSQL DataSource in Spring Boot using application.properties. JobRunr automatically detects the existing DataSource when using a framework starter.

```properties
spring.datasource.url=jdbc:postgresql://localhost:5432/mydb
spring.datasource.username=myuser
spring.datasource.password=mypassword
```

--------------------------------

### Enqueue a JobRequest using JobRequestScheduler

Source: https://www.jobrunr.io/en/documentation/background-methods/enqueueing-jobs

Enqueues a background job using the JobRequestScheduler bean. The handler for MyJobRequest is resolved by the IoC framework when the job starts.

```java
@Inject
private JobRequestScheduler jobRequestScheduler;
 
jobRequestScheduler.enqueue(new MyJobRequest());

```

--------------------------------

### Maven settings.xml with JobRunr Pro credentials

Source: https://www.jobrunr.io/en/documentation/pro/installation

Add your provided Maven repository credentials to the settings.xml file. The server id must match the repository id 'JobRunrPro'.

```xml
<settings>
    <servers>
        <server>
            <id>JobRunrPro</id>
            <username>${jobrunrProAccess.userName}</username>
            <password>${jobrunrProAccess.password}</password>
        </server>
    </servers>
</settings>
```

--------------------------------

### Provide JacksonJsonMapper as a singleton (DI)

Source: https://www.jobrunr.io/en/documentation/serialization/jackson2

Defines a JacksonJsonMapper bean as a singleton for dependency injection frameworks. This example is typical for frameworks like Micronaut or Dagger.

```java
import org.jobrunr.utils.mapper.JsonMapper;

@Singleton
public JsonMapper jsonMapper() {
  return new JacksonJsonMapper();
}
```
Tokens:
Raw