如何在Spring Boot中按用户设定的数据库时间调度邮件或任务

Hey there! Great that you already have a basic Spring Boot email setup in place—we can build right on top of that to add scheduled reminders based on user-set times stored in your database. Here's a step-by-step breakdown to make this work:

1. Update Your Database Model #

First, you'll need an entity to store user reminder details. Create a Reminder class that tracks all necessary info, including the scheduled time, recipient, and whether the email has been sent:

import jakarta.persistence.*;
import java.time.LocalDateTime;

@Entity
@Table(name = "reminders")
public class Reminder {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String userId; // Or link to your User entity if you have one
    private String recipientEmail;
    private String emailSubject;
    private String emailBody;
    private LocalDateTime reminderDateTime;
    private boolean isSent = false;

    // Getters and setters
}

Add a repository interface to handle database operations for reminders:

import org.springframework.data.jpa.repository.JpaRepository;
import java.time.LocalDateTime;
import java.util.List;

public interface ReminderRepository extends JpaRepository<Reminder, Long> {
    List<Reminder> findByIsSentFalseAndReminderDateTimeLessThanEqual(LocalDateTime now);
}

2. Build the Scheduled Task #

Next, create a component that runs at regular intervals to check for pending reminders and send emails. First, enable scheduling in your app by adding @EnableScheduling to your main Spring Boot application class.

Then, the scheduled task component:

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.util.List;

@Component
public class ReminderScheduler {
    private final ReminderRepository reminderRepository;
    private final EmailService emailService; // Inject your existing email service

    public ReminderScheduler(ReminderRepository reminderRepository, EmailService emailService) {
        this.reminderRepository = reminderRepository;
        this.emailService = emailService;
    }

    // Run every minute (adjust cron expression as needed)
    @Scheduled(cron = "0 * * * * ?")
    @Transactional
    public void sendPendingReminders() {
        LocalDateTime now = LocalDateTime.now();
        // Fetch all unsent reminders that are due or overdue
        List<Reminder> pendingReminders = reminderRepository.findByIsSentFalseAndReminderDateTimeLessThanEqual(now);

        for (Reminder reminder : pendingReminders) {
            try {
                // Use your existing email service to send the email
                emailService.sendEmail(
                    reminder.getRecipientEmail(),
                    reminder.getEmailSubject(),
                    reminder.getEmailBody()
                );
                // Mark as sent once successful
                reminder.setIsSent(true);
                reminderRepository.save(reminder);
            } catch (Exception e) {
                // Log the error or add retry logic here
                System.err.println("Failed to send reminder " + reminder.getId() + ": " + e.getMessage());
            }
        }
    }
}

3. Integrate with Your Existing Email Service #

Since you already have a working email implementation, just make sure your EmailService (or whatever you've named it) has a method like sendEmail(String to, String subject, String body) that handles the actual email dispatch. Reuse that logic directly in the scheduler.

4. Key Considerations #

• Timezone Consistency: Ensure your database and Spring Boot app use the same timezone (set via spring.jackson.time-zone in application.properties or application.yml) to avoid mismatched reminder times.
• Avoid Duplicate Sends: For high-traffic apps, consider using database locks or optimistic locking (add a version field to Reminder) to prevent multiple scheduler instances from processing the same reminder.
• Retry Logic: If email sending fails (e.g., SMTP issues), add a retry mechanism (like using Spring Retry) instead of just marking it as failed immediately.
• Performance: If you expect many reminders, add an index on is_sent and reminder_date_time to speed up the query, and consider pagination for large result sets.

5. REST API Endpoint for Setting Reminders #

Don't forget to add an endpoint to let users create reminders via your frontend:

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;

@RestController
public class ReminderController {
    private final ReminderRepository reminderRepository;

    public ReminderController(ReminderRepository reminderRepository) {
        this.reminderRepository = reminderRepository;
    }

    @PostMapping("/reminders")
    public Reminder createReminder(@RequestBody Reminder reminder) {
        // Validate the reminderDateTime is in the future (optional but recommended)
        if (reminder.getReminderDateTime().isBefore(LocalDateTime.now())) {
            throw new IllegalArgumentException("Reminder time must be in the future");
        }
        return reminderRepository.save(reminder);
    }
}

That's it! This setup will periodically check your database for due reminders and send emails using your existing email implementation.

内容的提问来源于stack exchange，提问作者raman dangol