Création de systèmes de notification par e-mail synchrones dans Spring Boot : un guide étape par étape

Explorer les principes fondamentaux de la livraison synchrone d'e-mails dans les applications Spring Boot

Dans le monde numérique en évolution rapide d'aujourd'hui, une communication rapide est cruciale pour toute application. Qu'il s'agisse d'une réinitialisation de mot de passe, d'un message de bienvenue ou d'une confirmation de commande, les notifications par e-mail jouent un rôle essentiel dans l'amélioration de l'expérience utilisateur. En tant que développeurs, nous nous retrouvons souvent dans des situations où l'envoi d'une notification par e-mail depuis notre application Spring Boot n'est pas seulement une exigence mais une nécessité.

Dans cette série de blogs, je vais vous guider tout au long du processus de mise en œuvre des notifications par e-mail dans une application Spring Boot. Nous commencerons par les bases : utiliser une approche synchrone pour envoyer des e-mails. Cette méthode garantit que l'e-mail est envoyé immédiatement lors de l'exécution de la demande, fournissant un retour instantané à l'utilisateur.

Bien qu'une approche synchrone soit simple à mettre en œuvre et puisse être efficace pour les petites applications, il est important de comprendre ses limites, en particulier dans les environnements à fort trafic où les performances peuvent être affectées.

Dans cette partie, nous nous concentrerons sur la configuration du projet, la configuration des dépendances nécessaires et l'écriture du code pour envoyer une notification par e-mail de base. À la fin de cet article, vous disposerez d'une application Spring Boot fonctionnelle capable d'envoyer des e-mails de manière synchrone, ouvrant la voie à des sujets plus avancés dans les prochaines parties de cette série.

Configuration du projet

Configuration des dépendances

Dépendance dans votre fichier pom.xml

Données de démarrage Spring Boot JPA

Artefact : spring-boot-starter-data-jpa
Description : Cette dépendance simplifie la persistance des données à l'aide de JPA (Java Persistence API). Il fournit tout le nécessaire pour interagir avec les bases de données, y compris les entités, les référentiels et les transactions. Dans ce projet, il vous permet de sauvegarder et de récupérer facilement les données utilisateur (par exemple, les journaux de courrier électronique, les informations utilisateur) à partir d'une base de données MySQL.

Courriel de démarrage Spring Boot

Artefact : spring-boot-starter-mail
Description : Ce démarreur permet d'envoyer des e-mails depuis votre application Spring Boot. Il comprend les composants nécessaires, tels que JavaMailSender, pour configurer et envoyer des notifications par e-mail en temps réel pour les activités des utilisateurs telles que l'inscription et les confirmations de commande.

*Web de démarrage Spring Boot
*
Artefact : spring-boot-starter-web
Description : Cette dépendance vous aide à créer des services Web RESTful et à diffuser du contenu Web. Il apporte les bibliothèques essentielles comme Spring MVC pour créer des API. Dans ce projet, il permet la création de points de terminaison pour déclencher des notifications par e-mail via des requêtes HTTP.

Connecteur MySQL

Artefact : mysql-connector-j
Description : Il s'agit du pilote JDBC requis pour connecter votre application Spring Boot à une base de données MySQL. Il permet à l'application d'interagir avec la base de données et d'effectuer des actions telles que la lecture et l'écriture de données, telles que le stockage des journaux de courrier électronique ou des informations utilisateur.

Lombok

Artefact : lombok
Description : Lombok est une bibliothèque pratique qui réduit le code passe-partout en générant automatiquement des méthodes courantes telles que les getters, les setters et les constructeurs. Il est marqué comme facultatif dans ce projet et son utilisation peut simplifier le code pour les modèles de données comme User ou EmailLog.

Test de démarrage Spring Boot

Artefact : spring-boot-starter-test
Description : cette dépendance fournit un cadre de test complet pour les applications Spring Boot. Il comprend des bibliothèques telles que JUnit, Mockito et Spring Test pour les tests unitaires et d'intégration. Cela permet de garantir que votre système de notification par e-mail fonctionne comme prévu grâce à des tests automatisés.

Plugin Spring Boot Maven

Artefact : spring-boot-maven-plugin
Description : Ce plugin vous permet de créer et d'exécuter votre application Spring Boot à partir d'une commande Maven. Il simplifie le packaging de votre projet dans un fichier JAR exécutable, facilitant ainsi le déploiement. Il exclut la dépendance Lombok du processus de construction si nécessaire.

Configuration des propriétés de l'application

Pour connecter votre application Spring Boot à un serveur de messagerie, vous pouvez configurer le fichier application.properties ou application.yml avec les paramètres SMTP nécessaires. Vous trouverez ci-dessous un exemple pour chaque format de configuration.

Pour application.properties

spring.application.name=Synchronous-Email-Notifier
server.port=8080

spring.datasource.url=jdbc:mysql://localhost:3306/synchronous_email_notifier
spring.datasource.username=root
spring.datasource.password=ayush@123

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

spring.mail.host=smtp.gmail.com
spring.mail.port=587
spring.mail.username=shri@gmail.com
spring.mail.password=
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true

Für application.yml

spring:
  mail:
    host: smtp.example.com
    port: 587
    username: your-email@example.com
    password: your-email-password
    properties:
      mail:
        smtp:
          auth: true
          starttls:
            enable: true

Host: Dies ist die SMTP-Serveradresse. Ersetzen Sie smtp.example.com durch die Adresse Ihres tatsächlichen SMTP-Anbieters (z. B. smtp.gmail.com für Gmail oder smtp.mail.yahoo.com für Yahoo).

Port: Port 587 wird typischerweise zum Senden von E-Mails über TLS (Transport Layer Security) verwendet. Wenn Ihr E-Mail-Anbieter SSL unterstützt, können Sie Port 465 verwenden.

Benutzername: Die E-Mail-Adresse, von der aus Sie die E-Mails senden. Stellen Sie sicher, dass Sie es durch das tatsächliche E-Mail-Konto ersetzen.

Passwort: Das Passwort für Ihr E-Mail-Konto. Wenn Sie Dienste wie Gmail nutzen, wird aus Sicherheitsgründen empfohlen, ein App-Passwort anstelle Ihres tatsächlichen Kontopassworts zu verwenden. Erwägen Sie außerdem die Verwendung von Umgebungsvariablen für vertrauliche Informationen wie Passwörter.

SMTP-Authentifizierung: Dies ermöglicht die Authentifizierung für Ihren SMTP-Server, die erforderlich ist, wenn Ihr E-Mail-Anbieter einen gültigen Benutzernamen und ein gültiges Passwort erfordert.

STARTTLS: Dadurch wird sichergestellt, dass die Verbindung zum E-Mail-Server per TLS verschlüsselt wird. Es ist entscheidend für eine sichere Kommunikation.

Projekteinrichtung

User.java zum Speichern der Benutzer-Mail und anderer Informationen in der Datenbank. Hier senden wir die E-Mail an alle Benutzer, die in der Datenbank vorhanden sind.

@Entity
@AllArgsConstructor
@NoArgsConstructor
@Data
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private int id;
    private String name;
    private String email;
    private String phoneNumber;
}

UserService.java

public interface UserService {
    public void saveUser(User user);
}

UserServiceImpl.java

public class UserServiceImpl implements UserService {

    @Autowired
    private UserRepository userRepository;

    @Override
    public void saveUser(User user) {
        userRepository.save(user);
    }
}

EmailController.java

@RestController
@RequestMapping("/api/email")
public class EmailController {

    @Autowired
    EmailService emailService;

    @Autowired
    UserService userService;

    @PostMapping("/saveUser")
    public String saveUser(@RequestBody User user) {
        userService.saveUser(user);
        return "User saved successfully";
    }
}

Die EmailService-Schnittstelle definiert einen Vertrag zum Senden von E-Mails in einer Java-Anwendung. Es enthält eine Methode sendEmail, die drei Parameter akzeptiert: die E-Mail-Adresse des Empfängers (to), den E-Mail-Betreff (subject) und den E-Mail-Inhalt (body). Die Implementierung dieser Schnittstelle ermöglicht eine einfache Integration für E-Mail-Benachrichtigungen.

package com.ayshriv.Synchronous_Email_Notifier.service;

public interface EmailService {
    void sendEmail(String to, String subject,String body);
}

Diese EmailServiceImpl-Klasse implementiert die EmailService-Schnittstelle und bietet die Funktionalität zum Senden von E-Mails mit Springs JavaMailSender. Es verwendet eine SimpleMailMessage, um den Empfänger (an), den Betreff (Betreff) und den Text (Text) festzulegen. Der javaMailSender wird automatisch mithilfe der @Autowired-Annotation von Spring eingefügt. Wenn während des E-Mail-Versandvorgangs Ausnahmen auftreten, werden diese abgefangen und in der Konsole protokolliert.

package com.ayshriv.Synchronous_Email_Notifier.service.impl;

import com.ayshriv.Synchronous_Email_Notifier.service.EmailService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.stereotype.Service;

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

    public void sendEmail(String to, String subject,String body)
    {
        try {
            SimpleMailMessage simpleMailMessage=new SimpleMailMessage();
            simpleMailMessage.setTo(to);
            simpleMailMessage.setSubject(subject);
            simpleMailMessage.setText(body);
            javaMailSender.send(simpleMailMessage);
        }
        catch (Exception exception)
        {
            System.out.println(exception.getMessage());
        }
    }
}

Diese EmailScheduler-Klasse ist ein Spring-Dienst, der eine geplante Aufgabe verwendet, um in regelmäßigen Abständen E-Mails an alle Benutzer in der Datenbank zu senden. Die Klasse funktioniert wie folgt:

Es verwendet @Scheduled mit einem Cron-Ausdruck ("0 0/1 * 1/1 * ?"), um die fetchUsersAndSendEmail-Methode jede Minute auszuführen.
Die Methode ruft eine Liste aller Benutzer aus dem UserRepository ab und sendet über den EmailService eine E-Mail an jeden Benutzer.
Jede gesendete E-Mail hat den Betreff „Demotext für E-Mail“ und den Text „Demo“.

package com.ayshriv.Synchronous_Email_Notifier.schduler;

import com.ayshriv.Synchronous_Email_Notifier.entity.User;
import com.ayshriv.Synchronous_Email_Notifier.repository.UserRepository;
import com.ayshriv.Synchronous_Email_Notifier.service.EmailService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class EmailScheduler {
    @Autowired
    private UserRepository userRepository;

    @Autowired
    private EmailService emailService;

    @Scheduled(cron = "0 0/1 * 1/1 * ?")
    public void fetchUsersAndSendEmail()
    {
        List<User> users = userRepository.findAll();
        for (User user:users)
        {
            emailService.sendEmail(user.getEmail(),"Demo text for email","Demo");
        }
    }
}

Die EmailScheduler-Klasse im Synchronous Email Notifier-Projekt automatisiert den Versand von Marketing-E-Mails an Benutzer in bestimmten Intervallen. Mithilfe der @Scheduled-Annotation von Spring wird jede Minute eine Aufgabe ausgeführt, alle Benutzer aus dem UserRepository abgerufen und E-Mails über den EmailService gesendet. Dieses Setup ist ideal für Unternehmen, um die Zustellung von Marketing-E-Mails, Newslettern oder wichtigen Benachrichtigungen ohne manuelles Eingreifen zu automatisieren. Der Zeitplan kann mithilfe von Cron-Ausdrücken angepasst werden, sodass E-Mails flexibel täglich, wöchentlich oder in einer beliebigen benutzerdefinierten Häufigkeit gesendet werden können, was es zu einem leistungsstarken Tool für zeitbasierte E-Mail-Kampagnen macht.

Benutzer speichern

Abschluss

Die EmailScheduler-Klasse im Synchronous Email Notifier-Projekt zeigt eine praktische und effiziente Möglichkeit, den Prozess des E-Mail-Versands an Benutzer zu automatisieren. Durch die Nutzung der @Scheduled-Annotation von Spring Boot und der Flexibilität von Cron-Ausdrücken plant diese Klasse die Ausführung der E-Mail-Versandaufgabe jede Minute. Das UserRepository ruft alle Benutzerdatensätze ab, während der EmailService dafür sorgt, dass jeder Benutzer eine E-Mail mit vordefiniertem Inhalt erhält.

Dieser Ansatz ist äußerst nützlich für Marketingzwecke, bei denen Unternehmen in bestimmten Zeitintervallen regelmäßig E-Mails wie Newsletter, Werbeangebote oder Benachrichtigungen versenden müssen. Das Setup stellt sicher, dass E-Mails ohne manuellen Aufwand konsistent an alle Benutzer gesendet werden. Diese Automatisierung reduziert den Zeit- und Arbeitsaufwand für Kommunikationsprozesse und ermöglicht es Marketingfachleuten, sich auf die Erstellung effektiver Kampagnen zu konzentrieren.

Die Möglichkeit, die Häufigkeit dieser E-Mails anzupassen, z. B. den täglichen, wöchentlichen oder monatlichen Versand, macht dies zu einem vielseitigen Tool für Marketingkampagnen. Darüber hinaus können Sie den Inhalt dynamisch ändern, um die Nachrichten an verschiedene Benutzer oder Anlässe anzupassen. Insgesamt vereinfacht und rationalisiert diese Lösung den Prozess geplanter Marketing-E-Mails und macht ihn skalierbar und an verschiedene Geschäftsanforderungen anpassbar.

Sie können auf GitHub auf den vollständigen Quellcode des Synchronous Email Notifier-Projekts zugreifen. https://github.com/ishrivasayush/email-scheduling-application.git

Dieses Projekt zeigt, wie man Spring Boot verwendet, um Marketing-E-Mails mit einem Planer zu automatisieren. Fühlen Sie sich frei, es zu erkunden und einen Beitrag zu leisten!

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!