Leitfaden für den einfachen E-Mail-Dienst (AWS SES) mit Spring Boot und Spring Cloud

Einleitung

AWS SES (einfacher E-Mail-Service) ist ein einfach einzurichtender Dienst zum Senden und Empfangen von E-Mails. Die Verwaltung eines E-Mail-Systems vor Ort ist normalerweise schwierig, knifflig und mühsam, daher ist die Auslagerung des Prozesses eine beliebte Wahl.

Wir können Amazon SES verwenden, um Transaktions-E-Mails, Marketing-E-Mails oder jede andere Art von Benachrichtigungs-E-Mails an unsere Kunden zu senden. Es ist eine erschwingliche Lösung für Unternehmen jeder Größe, die E-Mails verwenden, um mit ihren Kunden in Kontakt zu treten, da es auf der zuverlässigen und skalierbaren Infrastruktur von basiert Amazon Web Services (AWS).

Zum Senden von Massen-E-Mails kann jede Anwendung mit Amazon SES interagieren. Wir zahlen nur für die E-Mails, die wir tatsächlich versenden, unabhängig davon, ob es sich um Transaktions-E-Mails oder Marketing-E-Mails handelt. Darüber hinaus werden von Amazon SES eine Reihe von Konfigurationen unterstützt, darunter dedizierte, gemeinsam genutzte oder eigene IP-Adressen. Unternehmen können mithilfe von Zustellbarkeits-Dashboards und Berichten zu Absenderinformationen dafür sorgen, dass jede E-Mail zählt.

In diesem Leitfaden werden wir eine AWS SES-Instanz in einer Region konfigurieren und dann integrieren Spring Cloud für AWS das ist ein Unterprojekt von Frühlingswolke. Wir werden verschiedene Szenarien ausprobieren, um E-Mails aus unserer Anwendung zu versenden.

Hinweis: Den gesamten verwendeten Quellcode finden Sie im Handbuch auf Github.

Lebenszyklus des Sendens einer E-Mail mit AWS SES

Schauen wir uns an, wie der Lebenszyklus einer von einer Anwendung gesendeten E-Mail bis zum Zielpostfach reicht:

• Eine Anwendung, in unserem Fall der Spring Cloud-Code, fordert AWS SES auf, eine E-Mail an einen oder mehrere Empfänger zu senden.

• SES überprüft zunächst die Anfrage und erstellt bei Genehmigung eine E-Mail-Nachricht mit den Spezifikationen der Anfrage. Diese E-Mail-Nachricht hat eine Kopfzeile, einen Textkörper und einen Umschlag und entspricht RFC 5322Definition des Internet-Nachrichtenformats von .

• SES überträgt die Nachricht dann über das Internet an den Empfänger des Empfängers. Sobald die Nachricht an SES übergeben wird, wird sie oft sofort übertragen, wobei der erste Zustellversuch typischerweise innerhalb von Millisekunden erfolgt.

• Zu diesem Zeitpunkt gibt es mehrere Ergebnisse. Zum Beispiel:

  • Erfolgreiche Lieferung: Der Internetdienstanbieter (ISP) akzeptiert die E-Mail und sendet sie an den vorgesehenen Empfänger.
  • Harter Aufprall: Da die Adresse des Empfängers ungültig ist, lehnt der ISP die E-Mail ab. Der ISP sendet die Hard-Bounce-Benachrichtigung zurück an Amazon SES, das den Absender per E-Mail oder durch Veröffentlichung in einem Amazon Simple Notification Service (Amazon SNS)-Thema benachrichtigt, das für den Empfang dieser Benachrichtigung eingerichtet wurde.
  • Weiches Aufprallen: Aufgrund von Bedingungen wie dem vollen Posteingang des Empfängers, der nicht vorhandenen Domäne oder vorübergehenden Umständen wie dem ISP, der zu beschäftigt ist, um die Anfrage zu bearbeiten, kann der ISP die E-Mail möglicherweise nicht an den Empfänger zustellen. Der ISP wiederholt dann die E-Mail bis zu einer bestimmten Anzahl von Malen und sendet SES eine Soft-Bounce-Nachricht. Wenn SES die E-Mail nicht innerhalb des angegebenen Zeitrahmens zustellen kann, veröffentlicht es das Ereignis entweder in einem SNS-Thema oder sendet eine Hard-Bounce-Nachricht per E-Mail.
  • Beschwerde: Die E-Mail wird vom Empfänger in seinem E-Mail-Programm als Spam eingestuft. Eine Beschwerdebenachrichtigung wird an Amazon SES übermittelt, das sie dann an den Absender weiterleitet, wenn Amazon SES und der ISP eine Rückkopplungsschleife eingerichtet haben.
  • Automatische Antwort: Der ISP des Empfängers benachrichtigt Amazon SES über eine automatische Antwort des Empfängers, z. B. eine Abwesenheitsnotiz, und Amazon SES leitet die Benachrichtigung an den Absender weiter.

Wenn die Zustellung fehlschlägt, gibt Amazon SES einen Fehler an den Absender zurück und löscht die E-Mail.

Einrichten von Amazon SES

Im Gegensatz zu anderen AWS-Services muss praktisch keine SES-Instanz erstellt werden, da alle neuen AWS-Konten standardmäßig in der AWS SES-Sandbox platziert werden. Jedes AWS-Konto hat standardmäßig Sandbox-Zugriff für AWS SES in den verfügbaren Regionen.

Im Sandbox-Modus können wir E-Mails nur an verifizierte Identitäten senden. Eine Domain oder E-Mail-Adresse, die wir zum Senden einer E-Mail verwenden, ist eine verifizierte Identität. Wir müssen jede Identität, die wir verwenden möchten, konstruieren und validieren From, To, Source, Sender, oder Return-Path Adresse, bevor wir eine E-Mail mit SES im Sandbox-Modus senden können. Durch die Verwendung von Amazon SES zur Überprüfung der Identität können wir unser Eigentum nachweisen und die illegale Nutzung stoppen.

Um Betrug zu vermeiden und den Ruf einer IP-Adresse zu wahren, enthält AWS SES Beschränkungen für das Senden von E-Mails. Diese Einschränkungen geben die maximale Anzahl von E-Mails pro Sekunde und das tägliche E-Mail-Limit für jeden Benutzer an. Wenn Sie sich mit dem AWS Support Center in Verbindung setzen, können wir solche Kontingente nach Region festlegen.

Lassen Sie uns Identitäten überprüfen. Melden Sie sich bei der AWS-Konsole an und suchen Sie nach „Einfacher Amazon-E-Mail-Dienst"

Dann klicke auf "Identität erstellen“, um eine E-Mail oder eine Domain zur Überprüfung hinzuzufügen. In unserem Fall werden wir eine E-Mail zur Bestätigung hinzufügen.

Sobald die Identität erstellt ist, können wir die Details überprüfen.

Die Identität, die wir geschaffen haben, geht in „Überprüfung ausstehend" Bühne. In diesem Stadium muss der Benutzer die Verifizierungsmail von AWS prüfen und den Anweisungen folgen, um die E-Mail verifizieren zu lassen.

Als nächstes müssen wir „Zugangsschlüssel" und "geheimer Schlüssel“ für die Authentifizierung und Autorisierung unserer Anwendung bei SES. Um das zu generieren, müssen wir eine Benutzergruppe erstellen und dieser Gruppe einen Benutzer hinzufügen. Wenn wir diesen Benutzer erstellen, generiert AWS einen Zugriffsschlüssel und einen geheimen Schlüssel. Also lasst uns umleiten zu „IAM“ in der AWS-Konsole und erstellen Sie eine Benutzergruppe.

Dann müssen wir hinzufügen „Administratorzugriff”-Berechtigung für diese Gruppe für SES.

Schließlich fügen wir der obigen Gruppe einen Benutzer hinzu.

Als nächstes müssen wir die Gruppe für Berechtigungen auswählen.

Kopieren Sie schließlich den auf dem Bildschirm angezeigten Zugriffsschlüssel und Geheimschlüssel zur weiteren Verwendung.

Senden von E-Mails mit Spring Cloud Project

Projektaufbau

Lassen Sie uns ein Spring Cloud-Projekt starten und die Anwendungsfälle für die Integration mit SES durchgehen. Der einfachste Weg, mit einem Skelettprojekt zu beginnen, ist via Frühlings-Initialisierung:

Wir haben hinzugefügt Frühlingsnetz für REST-MVC, Apache Freemarker um HTML-basierte E-Mail-Vorlagen zu generieren, Java-Mail-Absender um eine E-Mail zu senden und Chili (optionale Boilerplate-reduzierende Bibliothek) Abhängigkeiten. Darüber hinaus müssen wir relevante Abhängigkeiten für Spring Cloud AWS und SES hinzufügen. Für Spring Cloud AWS werden wir eine separate Spring Cloud AWS BOM in unserer hinzufügen pom.xml Datei mit dieser Block:

<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>io.awspring.cloud</groupId>
			<artifactId>spring-cloud-aws-dependencies</artifactId>
			<version>2.3.0</version>
			<type>pom</type>
			<scope>import</scope>
		</dependency>
	</dependencies>
</dependencyManagement>

Um schließlich die Unterstützung für SES hinzuzufügen, müssen wir die Modulabhängigkeit einbeziehen, die als Startermodul verfügbar ist spring-cloud-starter-aws-ses:

<dependency>
	<groupId>io.awspring.cloud</groupId>
	<artifactId>spring-cloud-starter-aws-ses</artifactId>
</dependency>

spring-cloud-starter-aws-ses enthält die transitiven Abhängigkeiten für spring-cloud-starter-aws und spring-cloud-aws-sesdem „Vermischten Geschmack“. Seine spring-cloud-aws-ses Modul für SES enthält zwei Klassen: SimpleEmailServiceMailSender und SimpleEmailServiceJavaMailSender.

• Das SimpleEmailServiceMailSender Klasse verwendet Amazon Simple Email Service zum Senden von E-Mails. Die Java Mail API ist keine Voraussetzung für diese Implementierung. Es kann verwendet werden, um einfache E-Mail-Nachrichten ohne Anhänge zu versenden.
• Das SimpleEmailServiceJavaMailSender -Klasse ermöglicht das Versenden von E-Mails, die Anhänge und andere Mime-Elemente enthalten.

Das deckt also alle unsere Grundbedürfnisse ab!

Bohnen konfigurieren

Wie oben besprochen, müssen wir zwei Arten von Bohnen definieren: SimpleEmailServiceMailSender und SimpleEmailServiceJavaMailSender. Wir können einfach den Zugriffsschlüssel und den geheimen Schlüssel als Anmeldeinformationen übergeben und a konfigurieren MailSender Bean, die wir zum Versenden von E-Mails verwenden:

@Configuration
public class SesConfig {

    @Value("${cloud.aws.credentials.access-key}")
    private String accessKey;

    @Value("${cloud.aws.credentials.secret-key}")
    private String secretKey;

    @Value("${cloud.aws.region.static}")
    private String region;

    @Bean
    public AmazonSimpleEmailService amazonSimpleEmailService() {
        BasicAWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey);
        return AmazonSimpleEmailServiceClientBuilder.standard()
                .withCredentials(new AWSStaticCredentialsProvider(credentials))
                .withRegion(region)
                .build();
    }

    @Bean
    public MailSender mailSender(AmazonSimpleEmailService amazonSimpleEmailService) {
        return new SimpleEmailServiceMailSender(amazonSimpleEmailService);
    }

    @Bean
    public JavaMailSender javaMailSender(AmazonSimpleEmailService amazonSimpleEmailService) {
        return new SimpleEmailServiceJavaMailSender(amazonSimpleEmailService);
    }
}

Um E-Mails mit Anhängen zu versenden, müssen wir die konfigurieren SimpleEmailServiceJavaMailSender das ist eine Umsetzung der JavaMailSender -Schnittstelle aus der Mail-Abstraktion von Spring.

Wir werden auch die Eigenschaften definieren, aus denen die Informationen abgerufen werden sollen application.yml:

cloud:
  aws:
    region:
      static: eu-central-1
      auto: false
    stack:
      auto: false
    credentials:
      access-key: ********
      secret-key: **************************

Senden einer einfachen E-Mail

Wir können einfache E-Mails mit versenden SimpleEmailServiceMailSender Bean, die wir oben konfiguriert haben. Lassen Sie uns eine Service-Schicht definieren, um diese Bean zu verwenden:

@Service
public class EmailService {

    @Autowired
    private MailSender mailSender;

    public void sendMessage(SimpleMailMessage simpleMailMessage) {
        this.mailSender.send(simpleMailMessage);
    }
}

Wir rufen die send() Methode in der MailSender Bean, um unsere E-Mail zu senden. Wir müssen auch die passieren SimpleMailMessage das würde Attribute wie enthalten from, to, der Text und Betreff unserer E-Mail. Also definieren wir a Controller -Klasse, um den obigen Dienst mithilfe einer REST-API aufzurufen:

@RestController
public class EmailController {

    @Autowired
    private EmailService emailService;

    @PostMapping("/sendEmail")
    public String sendMessage(@RequestBody EmailDetails emailDetails) {
        SimpleMailMessage simpleMailMessage = new SimpleMailMessage();
        simpleMailMessage.setFrom(emailDetails.getFromEmail());
        simpleMailMessage.setTo(emailDetails.getToEmail());
        simpleMailMessage.setSubject(emailDetails.getSubject());
        simpleMailMessage.setText(emailDetails.getBody());
        emailService.sendMessage(simpleMailMessage);

        return "Email sent successfully";
    }
}

Wenn wir nun die Anwendung ausführen und die folgende Schleife ausführen, wird eine E-Mail an die verifizierte E-Mail-Adresse gesendet:

curl -i -X POST 
   -H "Content-Type:application/json" 
   -d 
'{
  "fromEmail": "[email protected]",
  "toEmail": "[email protected]",
  "subject": "test email",
  "body": "Hi, This is a test email."
}' 
 'http://localhost:8080/sendEmail'

Als nächstes können wir uns bei der E-Mail-Adresse des Empfängers anmelden und überprüfen, ob der Empfänger die E-Mail erhalten hat.

Senden einer einfachen E-Mail mit Anhang

Wir definieren eine Dienstschicht, um den Anhang als MIME weiterzugeben, und legen die anderen E-Mail-Attribute wie z from, to, Text und Betreff:

@Service
public class EmailService {

    @Autowired
    private JavaMailSender javaMailSender;

    public void sendMessageWithAttachment(SimpleMailMessage simpleMailMessage) {

        try {
            MimeMessage message = javaMailSender.createMimeMessage();

            
            MimeMessageHelper helper = new MimeMessageHelper(
                    message,
                    MimeMessageHelper.MULTIPART_MODE_MIXED_RELATED,
                    StandardCharsets.UTF_8.name());

            
            helper.addAttachment("logo.png", new ClassPathResource("logo.png"));
            helper.setTo(Objects.requireNonNull(simpleMailMessage.getTo()));
            helper.setText(Objects.requireNonNull(simpleMailMessage.getText()));
            helper.setSubject(Objects.requireNonNull(simpleMailMessage.getSubject()));
            helper.setFrom(Objects.requireNonNull(simpleMailMessage.getFrom()));
            javaMailSender.send(message);

        } catch (MessagingException e) {
            System.err.println("Exception: " + e.getMessage());
        }
    }
}

Hier verwenden wir MimeMessageHelper um eine E-Mail mit Anhang zu erstellen. Abschließend definieren wir Controller Schicht zu übergeben SimpleMailMessage Attribute:

@RestController
public class EmailController {

    @Autowired
    private EmailService emailService;

    @PostMapping("/sendEmailWithAttachment")
    public String sendMessageWithAttachment(@RequestBody EmailDetails emailDetails) {
        SimpleMailMessage simpleMailMessage = new SimpleMailMessage();
        simpleMailMessage.setFrom(emailDetails.getFromEmail());
        simpleMailMessage.setTo(emailDetails.getToEmail());
        simpleMailMessage.setSubject(emailDetails.getSubject());
        simpleMailMessage.setText(emailDetails.getBody());
        emailService.sendMessageWithAttachment(simpleMailMessage);

        return "Email sent successfully";
    }
}

Wenn wir nun die Anwendung ausführen und die folgende Schleife ausführen, wird eine E-Mail an die verifizierte E-Mail-Adresse gesendet:

curl -i -X POST 
   -H "Content-Type:application/json" 
   -d 
'{
  "fromEmail": "[email protected]",
  "toEmail": "[email protected]",
  "subject": "test email",
  "body": "Hi, This is a test email with attachment."
}' 
 'http://localhost:8080/sendEmailWithAttachment'

Als nächstes können wir uns bei der E-Mail-Adresse des Empfängers anmelden und überprüfen, ob der Empfänger die E-Mail erhalten hat.

Vorlagen-E-Mail mit Anhang senden

Die vorherigen Anwendungsfälle, die wir gesehen haben, eignen sich gut für Entwicklungs- oder Testszenarien, aber in der Produktion verwenden wir im Allgemeinen eine E-Mail-Vorlage mit Variablen, die durch die Antworten einer API ersetzt würden. Wir hatten zuvor die Abhängigkeit für hinzugefügt Apache Freemarker. Wir werden es verwenden, um eine Vorlage zu definieren und zur Verarbeitung zu laden!

Dazu definieren wir zunächst eine einfache Vorlage, benennen sie als email-template.ftl und legen Sie es in templates Ordner unter resources:

<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <title>StackAbuse Email</title>
</head>

<body>
<table width="100%" border="0" cellspacing="0" cellpadding="0">
    <tr>
        <td align="center" valign="top" bgcolor="#838383"
            style="background-color: #838383;"><br> <br>
            <table width="600" border="0" cellspacing="0" cellpadding="0">
                <tr>
                    <td align="center" valign="top" bgcolor="#d3be6c"
                        style="background-color: #d3be6c; font-family: Arial,
                         Helvetica, sans-serif; font-size: 13px; color: #000000;
                          padding: 0px 15px 10px 15px;">

                        <div style="font-size: 48px; color:blue;">
                            <b>StackAbuse</b>
                        </div>

                        <div style="font-size: 24px; color: #555100;">
                            <br> Sending Email using Spring Cloud with <b>FreeMarker</b> template !!! <br>
                        </div>
                        <div>
                            <br> Want to learn a new technology or become an in-demand full-stack developer?<br>
                            <br> We teach the skills you need to level up in your career.<br>
                            <br>"Sharing knowledge is the biggest learning" <br> <br>
                            <br> <br> <b>${Name}</b><br>${location}<br>
                            <br>
                        </div>
                    </td>
                </tr>
            </table> <br> <br></td>
    </tr>
</table>
</body>
</html>

Als nächstes müssen wir eine Konfigurationsklasse definieren, um die Vorlage aus dem Pfad zu laden und als Bean hinzuzufügen. Dazu definieren wir FreeMarkerConfigurationFactoryBean:

@Configuration
public class FreemarkerConfig {

    @Primary
    @Bean
    public FreeMarkerConfigurationFactoryBean factoryBean() {
        FreeMarkerConfigurationFactoryBean bean = new FreeMarkerConfigurationFactoryBean();
        bean.setTemplateLoaderPath("classpath:/templates");
        return bean;
    }
}

Als Nächstes definieren wir unsere Serviceebene, um diese Vorlage zu laden und eine endgültige Nachricht zu erstellen, die an SES gesendet wird:

@Service
public class EmailService {
    
    @Autowired
    private JavaMailSender javaMailSender;

    @Autowired
    private Configuration config;
    
    public void sendTemplateMessageWithAttachment(SimpleMailMessage simpleMailMessage) {

        try {
            MimeMessage message = javaMailSender.createMimeMessage();

            
            MimeMessageHelper helper = new MimeMessageHelper(
                    message,
                    MimeMessageHelper.MULTIPART_MODE_MIXED_RELATED,
                    StandardCharsets.UTF_8.name());

            Template t = config.getTemplate("email-template.ftl");
            Map model = new HashMap();
            model.put("Name", "StackAbuse Admin");
            model.put("location", "Bangalore, India");
            String html = FreeMarkerTemplateUtils.processTemplateIntoString(t, model);

            
            helper.addAttachment("logo.png", new ClassPathResource("logo.png"));
            helper.setTo(Objects.requireNonNull(simpleMailMessage.getTo()));
            helper.setText(html, true);
            helper.setSubject(Objects.requireNonNull(simpleMailMessage.getSubject()));
            helper.setFrom(Objects.requireNonNull(simpleMailMessage.getFrom()));
            javaMailSender.send(message);

        } catch (MessagingException | IOException | TemplateException e) {
            System.err.println("Exception: " + e.getMessage());
        }
    }

Abschließend definieren wir a Controller Ebene, um die dynamischen E-Mail-Attribute zu übergeben:

@RestController
public class EmailController {

    @Autowired
    private EmailService emailService;

    @PostMapping("/sendTemplateEmailWithAttachment")
    public String sendTemplateMessageWithAttachment(@RequestBody EmailDetails emailDetails) {
        SimpleMailMessage simpleMailMessage = new SimpleMailMessage();
        simpleMailMessage.setFrom(emailDetails.getFromEmail());
        simpleMailMessage.setTo(emailDetails.getToEmail());
        simpleMailMessage.setSubject(emailDetails.getSubject());
        simpleMailMessage.setText(emailDetails.getBody());
        emailService.sendTemplateMessageWithAttachment(simpleMailMessage);

        return "Email sent successfully";
    }
}

Wenn wir nun die Anwendung ausführen und die folgende Schleife ausführen, wird eine E-Mail an die verifizierte E-Mail-Adresse gesendet:

curl -i -X POST 
   -H "Content-Type:application/json" 
   -d 
'{
  "fromEmail": "[email protected]",
  "toEmail": "[email protected]",
  "subject": "test email",
  "body": "Hi, This is a test template email with attachment."
}' 
 'http://localhost:8080/sendTemplateEmailWithAttachment'

Als nächstes können wir uns bei der E-Mail-Adresse des Empfängers anmelden und überprüfen, ob der Empfänger die E-Mail erhalten hat:

Senden personalisierter E-Mails mit Vorlagen in AWS SES

Im vorherigen Anwendungsfall haben wir eine statische Vorlage zum Senden von E-Mails verwendet. Wie können wir die dynamische Gestaltung von Vorlagen für unterschiedliche Zwecke und unterschiedliche Empfängertypen ermöglichen? Mit AWS SES können wir E-Mail-Vorlagen erstellen, um personalisierte E-Mails in einem einzigen Vorgang an ein oder mehrere Ziele zu senden.

Wir können bis zu 10,000 E-Mail-Vorlagen pro Amazon SES-Konto erstellen. Jede Vorlage kann bis zu 500 KB groß sein, einschließlich der Text- und HTML-Teile. Wir können bei jedem Anruf bis zu 50 Ziele senden.

Lassen Sie uns also schnell eine E-Mail-Vorlage erstellen. Zuerst können wir eine JSON-Datei mit der folgenden Vorlage definieren:

{
  "Template": {
    "TemplateName": "MyTemplate",
    "SubjectPart": "Greetings from {{name}}!",
    "HtmlPart": "


StackAbuse

Sending Email using Spring Cloud with AWS SES Email template !!!

Want to learn a new technology or become an in-demand full-stack developer?

We teach the skills you need to level up in your career.

"Sharing knowledge is the biggest learning"



{{name}}
{{location}}



",
    "TextPart": "Dear {{name}},rnHere is your StackAbuse Email."
  }
}

Diese Vorlage enthält die folgenden Attribute:

• Vorlagenname: Enthält den Namen der Vorlage.
• BetreffTeil: Enthält die Betreffzeile der E-Mail. Auf diesem Inhalt sind möglicherweise Ersatz-Tags vorhanden. Diese Tags sind wie folgt formatiert: {{tagname}}. Sie können einen Wert für eingeben {{tagname}} für jedes Ziel beim Senden der E-Mail.
• HtmlPart: Enthält den HTML-Text der E-Mail und kann auch Ersatz-Tags enthalten.
• TextTeil: Dies stellt den Textkörper der E-Mail dar. Diese Version der E-Mail wird an Empfänger gesendet, deren E-Mail-Clients keine HTML-E-Mails anzeigen. Auf diesem Inhalt sind möglicherweise Ersatz-Tags vorhanden.

Wir können diese Datei speichern als mytemplate.json. Schließlich können wir einen AWS CLI-Befehl verwenden, um die Vorlage wie folgt zu erstellen:

$ aws ses create-template --cli-input-json file://mytemplate.json

Als Nächstes definieren wir eine Dienstebene, um Attribute zu definieren und E-Mail-Vorlagen zu senden:

@Service
public class EmailService {

    @Autowired
    private AmazonSimpleEmailService simpleEmailService;

    public void sendTemplatedMessage(SimpleMailMessage simpleMailMessage) {

        Destination destination = new Destination();
        List toAddresses = new ArrayList();
        String[] emails = simpleMailMessage.getTo();
        Collections.addAll(toAddresses, Objects.requireNonNull(emails));
        destination.setToAddresses(toAddresses);

        SendTemplatedEmailRequest templatedEmailRequest = new SendTemplatedEmailRequest();
        templatedEmailRequest.withDestination(destination);
        templatedEmailRequest.withTemplate("MyTemplate");
        templatedEmailRequest.withTemplateData("{ "name":"StackAbuse Admin", "location": "Bangalore, India"}");
        templatedEmailRequest.withSource(simpleMailMessage.getFrom());
        simpleEmailService.sendTemplatedEmail(templatedEmailRequest);
    }
}

Wir können mehrere hinzufügen Destination Adressen, um Massen-E-Mails an mehrere Empfänger zu senden. Wir verwenden die sendTemplatedEmail() Methode aus dem AmazonSimpleEmailService Benutzeroberfläche, um diese E-Mail-Vorlage zu senden. Wir müssen auch die zu ersetzenden Ersatz-Tags im HTML-Text unserer Vorlage übergeben, die wir zuvor erstellt haben.

Abschließend definieren wir a Controller Ebene zum Definieren der REST-API zum Übergeben der Attribute:

@RestController
public class EmailController {

    @Autowired
    private EmailService emailService;

    @PostMapping("/sendAWSTemplatedEmail")
    public String sendTemplatedMessage(@RequestBody EmailDetails emailDetails) {
        SimpleMailMessage simpleMailMessage = new SimpleMailMessage();
        simpleMailMessage.setFrom(emailDetails.getFromEmail());
        simpleMailMessage.setTo(emailDetails.getToEmail());
        simpleMailMessage.setSubject(emailDetails.getSubject());
        simpleMailMessage.setText(emailDetails.getBody());
        emailService.sendTemplatedMessage(simpleMailMessage);

        return "Email sent successfully";
    }
}

Als nächstes können wir beim Ausführen der App Folgendes ausführen curl So senden Sie E-Mail-Vorlagen:

curl -i -X POST 
   -H "Content-Type:application/json" 
   -d 
'{
  "fromEmail": "[email protected]",
  "toEmail": "[email protected]",
  "subject": "Greetings from StackAbuse Admin",
  "body": "Hi, This is a AWS templated email."
}' 
 'http://localhost:8080/sendAWSTemplatedEmail'

Jetzt bekommt der Empfänger endlich eine vorgefertigte E-Mail zu sehen:

Produktionszugriff anfordern

Schließlich müssen wir, um E-Mails an beliebige Empfänger zu senden, unabhängig davon, ob die Adresse oder Domäne des Empfängers validiert ist, unser Konto letztendlich aus der Sandbox entfernen. Alle unsere Identitäten, einschließlich From, Source, Sender und Return-Path Adressen, müssen noch verifiziert werden. Wir können eine Anfrage für Produktionszugriff über das „Konto Übersicht“ Seite wie folgt:

Wir können die Anfrage senden, indem wir alle oben genannten Details von der AWS-Konsole ausfüllen. Dasselbe kann auch über die AWS CLI übermittelt werden. Dies wäre hilfreich, wenn wir den Zugriff für eine große Anzahl von Identitäten anfordern müssen und den Prozess automatisieren möchten.

Zusammenfassung

In diesem Artikel wurden die wichtigsten Ideen von Amazon Simple Email Service (SES) und den Bibliotheken behandelt, die von Spring Cloud AWS als Schnittstelle angeboten werden. Darüber hinaus haben wir eine Spring Boot-Anwendung mit einer REST-API erstellt, die E-Mails über das Spring Cloud AWS SES-Modul senden kann.

Sie sollten jetzt ein solides Verständnis dafür haben, was Amazon Simple Email Service (SES) ist und wie Sie ihn zum Senden von E-Mails verwenden.