By Version

Edit this Page

Sending emails using SMTP

This guide demonstrates how your Quarkus application can send emails using an SMTP server. This is a getting started guide. Check the Quarkus Mailer Reference documentation for more complete explanation about the mailer and its usage.

Requisitos previos

To complete this guide, you need:

Roughly 15 minutes
An IDE
JDK 17+ installed with JAVA_HOME configured appropriately
Apache Maven 3.9.9
Optionally the Quarkus CLI if you want to use it
Optionally Mandrel or GraalVM installed and configured appropriately if you want to build a native executable (or Docker if you use a native container build)
The SMTP hostname, port and credentials, and an email address
cURL

Arquitectura

In this guide, we will build an application:

exposing an HTTP endpoint,
sending email when the endpoint receives an HTTP request.

The application will demonstrate how to send emails using the imperative and reactive mailer APIs.

Attachments, inlined attachments, templating, testing and more advanced configuration are covered in the Mailer Reference documentation.

Solución

We recommend that you follow the instructions in the next sections and create the application step by step. However, you can go right to the completed example.

Clone el repositorio Git: git clone https://github.com/quarkusio/quarkus-quickstarts.git o descargue un archivo.

The solution is located in the mailer-quickstart directory.

Create the Maven Project

En primer lugar, necesitamos un nuevo proyecto. Cree un nuevo proyecto con el siguiente comando:

CLI

quarkus create app org.acme:mailer-quickstart \
    --extension='rest,mailer,qute' \
    --no-code
cd mailer-quickstart

To create a Gradle project, add the --gradle or --gradle-kotlin-dsl option.

For more information about how to install and use the Quarkus CLI, see the Quarkus CLI guide.

Maven

mvn io.quarkus.platform:quarkus-maven-plugin:3.16.3:create \
    -DprojectGroupId=org.acme \
    -DprojectArtifactId=mailer-quickstart \
    -Dextensions='rest,mailer,qute' \
    -DnoCode
cd mailer-quickstart

To create a Gradle project, add the -DbuildTool=gradle or -DbuildTool=gradle-kotlin-dsl option.

For Windows users:

If using cmd, (don’t use backward slash \ and put everything on the same line)
If using Powershell, wrap -D parameters in double quotes e.g. "-DprojectArtifactId=mailer-quickstart"

This command generates a Maven structure including the following extensions:

Quarkus REST (formerly RESTEasy Reactive) used to expose REST endpoints
Mailer so that we can send emails
Qute, our template engine

If you already have your Quarkus project configured, you can add the mailer extension to your project by running the following command in your project base directory:

CLI

quarkus extension add mailer

Maven

./mvnw quarkus:add-extension -Dextensions='mailer'

Gradle

./gradlew addExtension --extensions='mailer'

This will add the following to your pom.xml:

pom.xml

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

build.gradle

implementation("io.quarkus:quarkus-mailer")

Open the generated project in your IDE. In a terminal, navigate to the project and start your application in dev mode:

CLI

quarkus dev

Maven

./mvnw quarkus:dev

Gradle

./gradlew --console=plain quarkusDev

Implement the HTTP endpoint

First, create the src/main/java/org/acme/MailResource.java file, with the following content:

package org.acme;

import io.quarkus.mailer.Mail;
import io.quarkus.mailer.Mailer;
import io.smallrye.common.annotation.Blocking;

import jakarta.inject.Inject;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;

@Path("/mail")                                                          (1)
public class MailResource {

    @Inject Mailer mailer;                                              (2)

    @GET                                                                (3)
    @Blocking                                                           (4)
    public void sendEmail() {
        mailer.send(
                Mail.withText("quarkus@quarkus.io",                     (5)
                    "Ahoy from Quarkus",
                    "A simple email sent from a Quarkus application."
                )
        );
    }

}

1	Configure the root path of our HTTP endpoint
2	Inject the `Mailer` object managed by Quarkus
3	Create a method that will handle the HTTP GET request on `/mail`
4	Because we are using Quarkus REST and the imperative mailer, we need to add the `@Blocking` annotation. We will see later the reactive variant.
5	Create a `Mail` object by configuring the to recipient, the subject and body

The MailResource class implements the HTTP API exposed by our application. It handles GET request on `http://localhost:8080/mail.

So, if in another terminal, you run:

> curl http://localhost:8080/mail

You should see in the application log something like:

INFO  [quarkus-mailer] (executor-thread-0) Sending email Ahoy from Quarkus from null to [quarkus@quarkus.io], text body:
A simple email sent from a Quarkus application.
html body:
<empty>

As the application runs in dev mode, it simulates the sending of the emails. It prints it in the log, so you can check that what was about to be sent.

This section used the imperative mailer API. It blocks the caller thread until the mail is sent.

The Quarkus Mailpit extension is very handy for testing emails. It provides Dev Services for Mailpit, a nice UI for testing and debugging email sending.

Using the reactive mailer

The last section use the imperative mailer. Quarkus also offers a reactive API.

Mutiny

The reactive mailer uses Mutiny reactive types. If you are not familiar with Mutiny, check Mutiny - an intuitive reactive programming library.

In the same class, add:

@Inject
ReactiveMailer reactiveMailer;                          (1)

@GET
@Path("/reactive")                                      (2)
public Uni<Void> sendEmailUsingReactiveMailer() {       (3)
    return reactiveMailer.send(                         (4)
                Mail.withText("quarkus@quarkus.io",
                    "Ahoy from Quarkus",
                    "A simple email sent from a Quarkus application using the reactive API."
                )
        );
}

1	Inject the reactive mailer. The class to import is `io.quarkus.mailer.reactive.ReactiveMailer`.
2	Configure the path to handle GET request on `/mail/reactive`. Note that because we are using the reactive API, we don’t need `@Blocking`
3	The method returns a `Uni<Void>` which completes when the mail is sent. It does not block the caller thread.
4	The API is similar to the imperative one except that the `send` method returns a `Uni<Void>`.

Now, in your terminal, run

> curl http://localhost:8080/mail/reactive

You should see in the application log something like:

INFO  [quarkus-mailer] (vert.x-eventloop-thread-11) Sending email Ahoy from Quarkus from null to [quarkus@quarkus.io], text body:
A simple email sent from a Quarkus application using the reactive API.
html body:
<empty>

Configuring the mailer

It’s time to configure the mailer to not simulate the sending of the emails. The Quarkus mailer is using SMTP, so make sure you have access to an SMTP server.

In the src/main/resources/application.properties file, you need to configure the host, port, username, password as well as the other configuration aspect. Note that the password can also be configured using system properties and environment variables. See the configuration reference guide for details.

Configuration of popular mail services is covered in the reference guide.

Once you have configured the mailer, if you call the HTTP endpoint as shown above, you will send emails.

Conclusion

This guide has shown how to send emails from your Quarkus application. The mailer reference guide provides more details about the mailer usage and configuration such as:

Requisitos previos
Arquitectura
Solución
Create the Maven Project
- Implement the HTTP endpoint
Using the reactive mailer
Configuring the mailer
Conclusion

Sending emails using SMTP

Requisitos previos

Arquitectura

Solución

Create the Maven Project

Implement the HTTP endpoint

Using the reactive mailer

Configuring the mailer

Conclusion

Related content

On the same extensions

On the same topics