In modern web applications, security is of paramount importance. One-time passwords (OTPs) are widely used for secure user authentication and transaction verification. However, generating OTPs and sending them via email can be a time-consuming process, potentially affecting the responsiveness of your application. To address this, we will learn how to implement asynchronous OTP generation and email sending in a Spring Boot application.
By using CompletableFuture and the @Async annotation, we can achieve non-blocking behavior, allowing our application to handle other tasks while generating OTPs and sending emails in the background.
Prerequisites:
- Basic knowledge of Java and Spring Boot.
- A working Spring Boot project with a configured JavaMailSender for sending emails.
- An understanding of RESTful APIs and Spring controllers.
This is blog is part of this Banking Portal Api https://github.com/abhi9720/BankingPortal-API/
1. Project Setup: Before we begin, make sure you have set up a Spring Boot project and have a basic understanding of Spring Boot configurations.
2. Implementing Asynchronous OTP Generation: In this step, we will create a service class responsible for OTP generation and database operations.
Creating the OTPService Interface:
public interface OTPService {
String generateOTP(String accountNumber);
CompletableFuture<Boolean> sendOTPByEmail(String email, String name, String accountNumber, String otp);
boolean validateOTP(String accountNumber, String otp);
}
Implementing the OTPServiceImpl Class:
@Service
public class OTPServiceImpl implements OTPService {
@Autowired
private EmailService emailService;
@Override
public String generateOTP(String accountNumber) {
Random random = new Random();
int otpValue = 100_000 + random.nextInt(900_000);
String otp = String.valueOf(otpValue);
// Save the new OTP information in the database
OtpInfo otpInfo = new OtpInfo();
otpInfo.setAccountNumber(accountNumber);
otpInfo.setOtp(otp);
otpInfo.setGeneratedAt(LocalDateTime.now());
otpInfoRepository.save(otpInfo);
return otp;
}
@Override
@Async
public CompletableFuture<Boolean> sendOTPByEmail(String email, String name, String accountNumber, String otp) {
// Compose the email content
String subject = "OTP Verification";
String emailText = emailService.getOtpLoginEmailTemplate(name, "xxx" + accountNumber.substring(3), otp);
CompletableFuture<Void> emailSendingFuture = emailService.sendEmail(email, subject, emailText);
return emailSendingFuture.thenApplyAsync(result -> true)
.exceptionally(ex -> {
ex.printStackTrace();
return false;
});
}
// ... Other Code
}
Configuring Asynchronous Execution: Ensure that the @EnableAsync annotation is present in your main application class to enable asynchronous processing.
@ SpringBootApplication
@ EnableAsync
public class YourApplication {
// Application setup and configuration code // ...
}
3. Sending OTP via Email Asynchronously: Now, let’s focus on the implementation of the EmailService responsible for sending emails.
Creating the EmailService Interface:
public interface EmailService {
public CompletableFuture<Void> sendEmail(String to, String subject, String text);
public String getOtpLoginEmailTemplate(String name,String accountNumber, String otp) ;
}
Implementing the EmailServiceImpl Class:
@Service
public class EmailServiceImpl implements EmailService {
private final JavaMailSender mailSender;
@Autowired
public EmailServiceImpl(JavaMailSender mailSender) {
this.mailSender = mailSender;
}
@Override
@Async
public CompletableFuture<Void> sendEmail(String to, String subject, String text) {
CompletableFuture<Void> future = new CompletableFuture<>();
try {
MimeMessage message = mailSender.createMimeMessage();
MimeMessageHelper helper = new MimeMessageHelper(message, true);
helper.setTo(to);
// No need to set the "from" address; it is automatically set by Spring Boot based on your properties
helper.setSubject(subject);
helper.setText(text, true); // Set the second parameter to true to send HTML content
mailSender.send(message);
future.complete(null); // Indicate that the email sending is successful
} catch (MessagingException e) {
e.printStackTrace();
future.completeExceptionally(e); // Indicate that the email sending failed
}
return future;
}
@Override
public String getOtpLoginEmailTemplate(String name, String accountNumber, String otp) {
// Create the formatted email template with the provided values
String emailTemplate = "<div style=\"font-family: Helvetica,Arial,sans-serif;min-width:1000px;overflow:auto;line-height:2\">"
+ "<div style=\"margin:50px auto;width:70%;padding:20px 0\">"
+ "<div style=\"border-bottom:1px solid #eee\">"
+ "<a href=\"https://piggybank.netlify.app/\" style=\"font-size:1.4em;color: #00466a;text-decoration:none;font-weight:600\">piggybank</a>"
+ "</div>"
+ "<p style=\"font-size:1.1em\">Hi, " + name + "</p>"
+ "<p style=\"font-size:0.9em;\">Account Number: " + accountNumber + "</p>"
+ "<p>Thank you for choosing OneStopBank. Use the following OTP to complete your Log In procedures. OTP is valid for 5 minutes</p>"
+ "<h2 style=\"background: #00466a;margin: 0 auto;width: max-content;padding: 0 10px;color: #fff;border-radius: 4px;\">" + otp + "</h2>"
+ "<p style=\"font-size:0.9em;\">Regards,<br />OneStopBank</p>"
+ "<hr style=\"border:none;border-top:1px solid #eee\" />"
+ "<p>piggybank Inc</p>"
+ "<p>1600 Amphitheatre Parkway</p>"
+ "<p>California</p>"
+ "</div>"
+ "</div>";
return emailTemplate;
}
}
// application.properties
spring.mail.host=smtp.gmail.com
spring.mail.port=587
spring.mail.username=example@gmail.com
spring.mail.password=xxxxxxxxxxxxxxxx
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true
4. Creating the RESTful API: Now, let’s create a RESTful API to demonstrate the asynchronous OTP generation and email sending process.
// DTO For Receving OTP request
public class OtpRequest {
private String accountNumber;
public String getAccountNumber() {
return accountNumber;
}
public void setAccountNumber(String accountNumber) {
this.accountNumber = accountNumber;
}
}
@RestController
public class OTPController {
@Autowired
private OTPService otpService;
@PostMapping("/generate-otp")
public ResponseEntity<?> generateOtp(@RequestBody OtpRequest otpRequest) {
String accountNumber = otpRequest.getAccountNumber();
// Fetch the user by account number to get the associated email
User user = userService.getUserByAccountNumber(accountNumber);
if (user == null) {
return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("User not found for the given account number");
}
// Generate OTP and save it in the database
String otp = otpService.generateOTP(accountNumber);
// Send the OTP to the user's email address asynchronously
CompletableFuture<Boolean> emailSendingFuture = otpService.sendOTPByEmail(user.getEmail(), user.getName(), accountNumber, otp);
// Wait for the email sending process to complete and handle the response
try {
boolean otpSent = emailSendingFuture.get(); // This will block until the email sending is complete
if (otpSent) {
// Return JSON response with success message
return ResponseEntity.ok().body("{\"message\": \"OTP sent successfully\"}");
} else {
// Return JSON response with error message
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("{\"message\": \"Failed to send OTP\"}");
}
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
// Return JSON response with error message
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("{\"message\": \"Failed to send OTP\"}");
}
}
}
5. Testing the Asynchronous OTP Generation and Email Sending: Now that we have implemented the API, you can use tools like Postman to send a POST request to/generate-otp with the required data. The API will return a response indicating the status of the OTP generation and email sending.
For Any Reference Checkout this repo : https://github.com/abhi9720/BankingPortal-API/
Top comments (0)