Tutorial

E-Mails mit Java senden

Senden Sie E-Mails aus Java mit dem SDK emailit-java oder per SMTP mit Spring Boot und Jakarta Mail und verifizieren Sie Emailit-Webhooks in einem Spring-Controller.

Aktualisiert am 1. Okt. 2026

Diese Anleitung zeigt, wie Sie E-Mails aus Java mit dem offiziellen SDK emailit-java senden, wie Sie stattdessen den Mail-Starter von Spring Boot oder Jakarta Mail per SMTP verwenden und wie Sie Webhooks in einem Spring-Controller verifizieren.

Voraussetzungen

Java 11 oder neuer. Die Spring-Beispiele verwenden Spring Boot 3, das Java 17 erfordert.
Eine verifizierte Versanddomain, zum Beispiel acme.com.
Ein API-Schlüssel. Ein reiner Sende-Schlüssel, der auf Ihre Domain beschränkt ist, genügt.
Solange Ihr Workspace keinen Produktionszugang hat, können Sie nur an die Konto-E-Mail-Adressen von Workspace-Mitgliedern senden.

SDK installieren

Fügen Sie die Abhängigkeit hinzu, mit der neuesten Version aus dem Repository emailit-java:

pom.xml

<dependency>
  <groupId>com.emailit</groupId>
  <artifactId>emailit-java</artifactId>
  <version>VERSION</version>
</dependency>

build.gradle

implementation 'com.emailit:emailit-java:VERSION'

API-Schlüssel konfigurieren

Stellen Sie den Schlüssel als Umgebungsvariable bereit:

Terminal

export EMAILIT_API_KEY=secret_••••••••••••••••••••••••••••••••

Ordnen Sie ihn in Spring Boot einer Eigenschaft zu, damit Sie ihn injizieren können:

application.properties

emailit.api-key=${EMAILIT_API_KEY}

E-Mail senden

SendEmail.java

import com.emailit.*;
import com.emailit.exception.*;
import com.emailit.params.*;
import java.util.List;

public class SendEmail {
    public static void main(String[] args) throws EmailitException {
        EmailitClient emailit = new EmailitClient(System.getenv("EMAILIT_API_KEY"));

        EmailSendParams params = EmailSendParams.builder()
            .setFrom("Acme <hello@acme.com>")
            .setTo(List.of("ada@example.com"))
            .setSubject("Your order has shipped")
            .setHtml("<p>Order #1042 is on its way.</p>")
            .build();

        EmailitObject email = emailit.emails().send(params);
        System.out.println(email.getString("id")); // em_…
    }
}

Registrieren Sie den Client in Spring Boot einmal als Bean und injizieren Sie ihn dort, wo Sie senden:

EmailitConfig.java

import com.emailit.EmailitClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class EmailitConfig {
    @Bean
    EmailitClient emailitClient(@Value("${emailit.api-key}") String apiKey) {
        return new EmailitClient(apiKey);
    }
}

Fehler behandeln

Das SDK wirft typisierte Exceptions, die von EmailitException erben:

Java

try {
    emailit.emails().send(params);
} catch (RateLimitException e) {
    // 429: back off and retry
} catch (AuthenticationException e) {
    // 401: the API key is missing or invalid
} catch (UnprocessableEntityException e) {
    // 422: for example, the from domain isn't verified
} catch (EmailitException e) {
    log.error("Emailit error {}: {}", e.getHttpStatus(), e.getHttpBody());
}

Alternativ per SMTP senden

Spring Boot

Fügen Sie spring-boot-starter-mail hinzu und konfigurieren Sie das Relay:

application.properties

spring.mail.host=smtp.emailit.com
spring.mail.port=587
spring.mail.username=emailit
spring.mail.password=${EMAILIT_API_KEY}
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true
spring.mail.properties.mail.smtp.starttls.required=true

Senden Sie dann mit JavaMailSender:

WelcomeMailer.java

import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.stereotype.Service;

@Service
public class WelcomeMailer {
    private final JavaMailSender mailSender;

    public WelcomeMailer(JavaMailSender mailSender) {
        this.mailSender = mailSender;
    }

    public void sendWelcome(String to) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom("Acme <hello@acme.com>");
        message.setTo(to);
        message.setSubject("Welcome to Acme");
        message.setText("Thanks for signing up.");
        mailSender.send(message);
    }
}

Für HTML und Anhänge verwenden Sie MimeMessageHelper.

Jakarta Mail ohne Spring

Reines Jakarta Mail (früher JavaMail) verwendet dieselben Eigenschaften mail.smtp.*:

Java

Properties props = new Properties();
props.put("mail.smtp.host", "smtp.emailit.com");
props.put("mail.smtp.port", "587");
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.starttls.required", "true");

Session session = Session.getInstance(props, new Authenticator() {
    @Override
    protected PasswordAuthentication getPasswordAuthentication() {
        return new PasswordAuthentication("emailit", System.getenv("EMAILIT_API_KEY"));
    }
});

Wenn Port 587 in Ihrem Netzwerk blockiert ist, verwenden Sie 2525 oder 2587 mit denselben Einstellungen. Siehe SMTP-Einstellungen.

Webhooks empfangen

Erstellen Sie einen Webhook und speichern Sie sein Signatur-Secret in EMAILIT_WEBHOOK_SECRET. Nehmen Sie den Body als String entgegen, damit Sie genau das verifizieren, was Emailit signiert hat:

EmailitWebhookController.java

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.HexFormat;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
public class EmailitWebhookController {
    private final ObjectMapper mapper = new ObjectMapper();
    private final String secret = System.getenv("EMAILIT_WEBHOOK_SECRET");

    @PostMapping("/webhooks/emailit")
    public ResponseEntity<Void> receive(
            @RequestBody String body,
            @RequestHeader(value = "X-Emailit-Signature", defaultValue = "") String signature,
            @RequestHeader(value = "X-Emailit-Timestamp", defaultValue = "0") long timestamp) throws Exception {

        if (Math.abs(System.currentTimeMillis() / 1000 - timestamp) > 300 || !isValid(body, signature, timestamp)) {
            return ResponseEntity.status(401).build();
        }

        // The body is a JSON array of up to 100 events.
        for (JsonNode event : mapper.readTree(body)) {
            if ("email.bounced".equals(event.path("type").asText())) {
                String address = event.path("data").path("object").path("to").asText();
                // Stop emailing this address.
            }
        }
        return ResponseEntity.ok().build();
    }

    private boolean isValid(String body, String signature, long timestamp) throws Exception {
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
        byte[] digest = mac.doFinal((timestamp + "." + body).getBytes(StandardCharsets.UTF_8));
        String expected = HexFormat.of().formatHex(digest);
        return MessageDigest.isEqual(
            expected.getBytes(StandardCharsets.UTF_8),
            signature.getBytes(StandardCharsets.UTF_8));
    }
}

Wenn Spring Security aktiviert ist, geben Sie diesen Pfad frei und nehmen Sie ihn vom CSRF-Schutz aus. Geben Sie innerhalb von 30 Sekunden einen 2xx-Status zurück; bei anderen Antworten wird die Anfrage wiederholt. Siehe Anfragesignatur.

Tipps für den Produktivbetrieb

Clients wiederverwenden. Erstellen Sie einen einzigen EmailitClient (oder verlassen Sie sich auf den einen JavaMailSender von Spring) statt einen pro Nachricht.
Asynchron senden. Verwenden Sie für Massen-E-Mails @Async, eine Message Queue oder einen geplanten Job und begrenzen Sie den Durchsatz, um unter Ihren Versandlimits zu bleiben (standardmäßig 2 E-Mails pro Sekunde).
Wiederholungen sicher machen. Wenn Sie nach einem Timeout erneut senden, übergeben Sie mit java.net.http.HttpClient einen Header Idempotency-Key; siehe Idempotenz.
Webhooks deduplizieren, indem Sie jede verarbeitete event_id speichern.

Nächste Schritte

E-Mails per API senden

Anhänge, Planung und Tracking.

Webhook-Event-Typen

Alle Events und ihre Payloads.

SMTP-Fehlerbehebung

Authentifizierungs- und Verbindungsfehler beheben.

SDKs und Bibliotheken

Alle offiziellen Bibliotheken.