자바로 만드는 자동 메일링 시스템 – JavaMailSender 완벽 정복

자바로 만드는 자동 메일링 시스템 – JavaMailSender 완벽 정복

소개

현대 비즈니스 환경에서 이메일은 여전히 가장 중요한 커뮤니케이션 채널 중 하나입니다.

회원가입 확인, 비밀번호 재설정, 주문 확인, 마케팅 캠페인, 뉴스레터 등 다양한 비즈니스 프로세스에서 자동화된 이메일 발송은 필수적입니다.

자바 기반 백엔드 시스템에서 이메일 발송을 구현할 때, Spring Framework의 JavaMailSender는 가장 강력하고 유연한 솔루션을 제공합니다.

이 글에서는 JavaMailSender를 활용하여 확장 가능하고 유지보수가 쉬운 이메일 발송 시스템을 구축하는 방법을 상세히 알아보겠습니다. 단순한 텍스트 이메일부터 HTML 템플릿, 첨부 파일, 대량 발송까지 실무에서 필요한 모든 시나리오를 다룰 것입니다.

---

JavaMailSender란?

JavaMailSender는 Spring Framework에서 제공하는 이메일 발송을 위한 인터페이스로,

자바의 기본 메일 API인 JavaMail(javax.mail)을 추상화하여 더 쉽게 사용할 수 있도록 해줍니다.

복잡한 JavaMail API 대신 간결한 인터페이스를 통해 이메일 발송 기능을 구현할 수 있습니다.

 

JavaMailSender의 주요 장점은 다음과 같습니다:

1. 간결한 API: 복잡한 JavaMail 코드를 추상화하여 깔끔한 인터페이스 제공
2. Spring 생태계와의 통합: Spring의 다른 컴포넌트와 원활하게 연동
3. 다양한 메일 서버 지원: Gmail, Office 365, Amazon SES 등 다양한 SMTP 서버 지원
4. 트랜잭션 지원: 다른 데이터베이스 작업과 함께 트랜잭션 처리 가능
5. 테스트 용이성: 테스트 환경에서 쉽게 목(mock) 처리 가능

---

Spring Boot 환경에서 JavaMailSender 설정하기

Spring Boot 프로젝트에서 JavaMailSender를 사용하기 위한 설정 방법을 알아보겠습니다.

의존성 추가

먼저 build.gradle 또는 pom.xml 파일에 필요한 의존성을 추가합니다.

 

Gradle:

implementation 'org.springframework.boot:spring-boot-starter-mail'

 

Maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-mail</artifactId>
</dependency>

기본 설정 (application.properties/yml)

application.properties 또는 application.yml 파일에 이메일 서버 설정을 추가합니다.

application.properties:

# Gmail SMTP 설정 예시
spring.mail.host=smtp.gmail.com
spring.mail.port=587
spring.mail.username=your-email@gmail.com
spring.mail.password=your-app-password
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true
spring.mail.properties.mail.smtp.connectiontimeout=5000
spring.mail.properties.mail.smtp.timeout=5000
spring.mail.properties.mail.smtp.writetimeout=5000

 

application.yml:

spring:
  mail:
    host: smtp.gmail.com
    port: 587
    username: your-email@gmail.com
    password: your-app-password
    properties:
      mail:
        smtp:
          auth: true
          starttls:
            enable: true
          connectiontimeout: 5000
          timeout: 5000
          writetimeout: 5000

 

주의사항: Gmail을 사용할 경우, 2022년 5월 30일부터 보안 강화로 인해 일반 비밀번호 대신 앱 비밀번호를 사용해야 합니다. 앱 비밀번호는 Google 계정 설정의 '보안' 섹션에서 생성할 수 있습니다.

반응형

환경별 설정 관리

프로덕션과 개발/테스트 환경에서 서로 다른 메일 설정을 사용하는 것이 일반적입니다.

Spring Profile을 활용하여 환경별 설정을 관리하는 방법은 다음과 같습니다:

 

application-dev.yml:

spring:
  mail:
    host: localhost
    port: 1025  # MailHog 같은 로컬 SMTP 서버 사용

application-prod.yml:

spring:
  mail:
    host: smtp.gmail.com
    port: 587
    username: ${MAIL_USERNAME}  # 환경 변수에서 가져오기
    password: ${MAIL_PASSWORD}
    properties:
      mail:
        smtp:
          auth: true
          starttls:
            enable: true

---

기본 이메일 전송 구현하기

이제 JavaMailSender를 사용하여 기본적인 이메일 전송 기능을 구현해보겠습니다.

EmailService 인터페이스 정의

먼저 이메일 서비스 인터페이스를 정의합니다:

package com.example.emailservice.service;

public interface EmailService {
    void sendSimpleMessage(String to, String subject, String text);
    void sendHtmlMessage(String to, String subject, String htmlContent);
}

EmailService 구현

위에서 정의한 인터페이스의 구현 클래스를 작성합니다:

package com.example.emailservice.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.stereotype.Service;

import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;

@Service
public class EmailServiceImpl implements EmailService {

    private final JavaMailSender emailSender;

    @Autowired
    public EmailServiceImpl(JavaMailSender emailSender) {
        this.emailSender = emailSender;
    }

    @Override
    public void sendSimpleMessage(String to, String subject, String text) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom("noreply@example.com");
        message.setTo(to);
        message.setSubject(subject);
        message.setText(text);

        emailSender.send(message);
    }

    @Override
    public void sendHtmlMessage(String to, String subject, String htmlContent) {
        try {
            MimeMessage message = emailSender.createMimeMessage();
            MimeMessageHelper helper = new MimeMessageHelper(message, true, "UTF-8");

            helper.setFrom("noreply@example.com");
            helper.setTo(to);
            helper.setSubject(subject);
            helper.setText(htmlContent, true);  // true는 HTML 형식을 지원하도록 설정

            emailSender.send(message);
        } catch (MessagingException e) {
            throw new RuntimeException("HTML 이메일 발송 중 오류 발생", e);
        }
    }
}

컨트롤러에서 이메일 서비스 사용

이메일 발송 기능을 API로 노출하는 컨트롤러를 구현해 보겠습니다:

package com.example.emailservice.controller;

import com.example.emailservice.dto.EmailRequest;
import com.example.emailservice.service.EmailService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.validation.Valid;

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

    private final EmailService emailService;

    @Autowired
    public EmailController(EmailService emailService) {
        this.emailService = emailService;
    }

    @PostMapping("/send")
    public ResponseEntity<String> sendEmail(@Valid @RequestBody EmailRequest emailRequest) {
        emailService.sendSimpleMessage(
            emailRequest.getTo(),
            emailRequest.getSubject(),
            emailRequest.getContent()
        );

        return ResponseEntity.ok("이메일이 성공적으로 발송되었습니다.");
    }
}

DTO 클래스 구현

이메일 요청을 위한 DTO 클래스도 구현합니다:

package com.example.emailservice.dto;

import javax.validation.constraints.Email;
import javax.validation.constraints.NotBlank;

public class EmailRequest {

    @NotBlank(message = "수신자 이메일은 필수입니다.")
    @Email(message = "유효한 이메일 형식이 아닙니다.")
    private String to;

    @NotBlank(message = "제목은 필수입니다.")
    private String subject;

    @NotBlank(message = "내용은 필수입니다.")
    private String content;

    // Getters and setters
    public String getTo() {
        return to;
    }

    public void setTo(String to) {
        this.to = to;
    }

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

---

HTML 템플릿을 활용한 이메일 전송

실무에서는 단순 텍스트보다 HTML 형식의 이메일이 많이 사용됩니다.

Spring에서는 Thymeleaf, FreeMarker 등의 템플릿 엔진을 활용하여 HTML 이메일을 생성할 수 있습니다.

Thymeleaf 템플릿 엔진 설정

Thymeleaf를 사용하기 위한 의존성을 추가합니다:

implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'

이메일 템플릿 작성

src/main/resources/templates/email/welcome.html 파일을 생성합니다:

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>환영합니다!</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            line-height: 1.6;
            color: #333;
        }
        .container {
            max-width: 600px;
            margin: 0 auto;
            padding: 20px;
            border: 1px solid #ddd;
            border-radius: 5px;
        }
        .header {
            background-color: #4285f4;
            color: white;
            padding: 10px;
            text-align: center;
            border-radius: 5px 5px 0 0;
        }
        .footer {
            margin-top: 20px;
            text-align: center;
            color: #777;
            font-size: 12px;
        }
        .button {
            display: inline-block;
            background-color: #4285f4;
            color: white;
            padding: 10px 20px;
            text-decoration: none;
            border-radius: 5px;
            margin-top: 15px;
        }
    </style>
</head>
<body>
    <div class="container">
        <div class="header">
            <h1>환영합니다!</h1>
        </div>

        <p>안녕하세요, <strong th:text="${name}">사용자</strong>님!</p>

        <p>저희 서비스에 가입해 주셔서 감사합니다. 아래 버튼을 클릭하여 이메일 주소를 인증해 주세요.</p>

        <p style="text-align: center;">
            <a class="button" th:href="${verificationLink}">이메일 인증하기</a>
        </p>

        <p>버튼이 작동하지 않는 경우, 아래 링크를 복사하여 브라우저에 붙여넣기 해주세요:</p>
        <p th:text="${verificationLink}">https://example.com/verify</p>

        <p>감사합니다!<br>
        서비스 팀 드림</p>

        <div class="footer">
            <p>본 이메일은 자동 발송되었습니다. 회신하지 마세요.</p>
            <p>© 2025 Example Company. All rights reserved.</p>
        </div>
    </div>
</body>
</html>

Thymeleaf 템플릿을 사용한 이메일 발송 서비스 확장

EmailService 인터페이스에 템플릿 기반 메서드를 추가합니다:

void sendTemplateMessage(String to, String subject, String templateName, Map<String, Object> templateModel);

 

구현 클래스에도 해당 메서드를 구현합니다:

package com.example.emailservice.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.stereotype.Service;
import org.thymeleaf.TemplateEngine;
import org.thymeleaf.context.Context;

import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;
import java.util.Map;

@Service
public class EmailServiceImpl implements EmailService {

    private final JavaMailSender emailSender;
    private final TemplateEngine templateEngine;

    @Autowired
    public EmailServiceImpl(JavaMailSender emailSender, TemplateEngine templateEngine) {
        this.emailSender = emailSender;
        this.templateEngine = templateEngine;
    }

    // 기존 메서드 생략...

    @Override
    public void sendTemplateMessage(String to, String subject, String templateName, Map<String, Object> templateModel) {
        try {
            // Thymeleaf context 설정
            Context context = new Context();
            context.setVariables(templateModel);

            // 템플릿 처리
            String htmlContent = templateEngine.process(templateName, context);

            // 이메일 메시지 생성 및 발송
            MimeMessage message = emailSender.createMimeMessage();
            MimeMessageHelper helper = new MimeMessageHelper(message, true, "UTF-8");

            helper.setFrom("noreply@example.com");
            helper.setTo(to);
            helper.setSubject(subject);
            helper.setText(htmlContent, true);

            emailSender.send(message);
        } catch (MessagingException e) {
            throw new RuntimeException("템플릿 이메일 발송 중 오류 발생", e);
        }
    }
}

템플릿 이메일 사용 예시

컨트롤러나 서비스에서 템플릿 이메일을 사용하는 예시입니다:

@Service
public class UserService {

    private final EmailService emailService;

    @Autowired
    public UserService(EmailService emailService) {
        this.emailService = emailService;
    }

    public void registerUser(User user) {
        // 사용자 등록 로직...

        // 가입 확인 이메일 발송
        String verificationToken = generateVerificationToken();
        String verificationLink = "https://example.com/verify?token=" + verificationToken;

        Map<String, Object> templateModel = new HashMap<>();
        templateModel.put("name", user.getName());
        templateModel.put("verificationLink", verificationLink);

        emailService.sendTemplateMessage(
            user.getEmail(),
            "회원가입을 환영합니다!",
            "email/welcome",  // 템플릿 위치: /templates/email/welcome.html
            templateModel
        );
    }

    private String generateVerificationToken() {
        // 토큰 생성 로직...
        return UUID.randomUUID().toString();
    }
}

---

첨부 파일이 있는 이메일 전송

첨부 파일이 있는 이메일을 전송하는 방법을 알아보겠습니다.

EmailService 인터페이스에 메서드 추가

void sendMessageWithAttachment(String to, String subject, String text, String pathToAttachment);

첨부 파일 전송 구현

@Override
public void sendMessageWithAttachment(String to, String subject, String text, String pathToAttachment) {
    try {
        MimeMessage message = emailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, true);  // true는 multipart 메시지 지원

        helper.setFrom("noreply@example.com");
        helper.setTo(to);
        helper.setSubject(subject);
        helper.setText(text);

        // 파일 첨부
        FileSystemResource file = new FileSystemResource(new File(pathToAttachment));
        helper.addAttachment(file.getFilename(), file);

        emailSender.send(message);
    } catch (MessagingException e) {
        throw new RuntimeException("첨부 파일이 있는 이메일 발송 중 오류 발생", e);
    }
}

다중 첨부 파일 지원

여러 파일을 첨부해야 하는 경우를 위한 메서드도 추가합니다:

@Override
public void sendMessageWithAttachments(String to, String subject, String text, List<String> attachmentPaths) {
    try {
        MimeMessage message = emailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, true);

        helper.setFrom("noreply@example.com");
        helper.setTo(to);
        helper.setSubject(subject);
        helper.setText(text);

        // 여러 파일 첨부
        for (String attachmentPath : attachmentPaths) {
            FileSystemResource file = new FileSystemResource(new File(attachmentPath));
            helper.addAttachment(file.getFilename(), file);
        }

        emailSender.send(message);
    } catch (MessagingException e) {
        throw new RuntimeException("다중 첨부 파일이 있는 이메일 발송 중 오류 발생", e);
    }
}

---

대량 메일 발송 처리 전략

마케팅 캠페인이나 뉴스레터 발송과 같이 많은 수의 이메일을 보내야 하는 경우, 효율적인 처리 방법이 필요합니다.

비동기 처리

대량 메일 발송 시 동기적으로 처리하면 시스템 성능에 영향을 줄 수 있습니다.

Spring의 @Async 어노테이션을 활용하여 비동기 처리를 구현해 보겠습니다.

 

먼저 비동기 처리를 활성화합니다:

@Configuration
@EnableAsync
public class AsyncConfig {

    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(25);
        executor.setThreadNamePrefix("EmailExecutor-");
        executor.initialize();
        return executor;
    }
}

 

EmailService 인터페이스에 비동기 메서드를 추가합니다:

@Async
CompletableFuture<Void> sendBulkEmails(List<EmailDetails> emailDetailsList);

 

구현 클래스:

@Async
@Override
public CompletableFuture<Void> sendBulkEmails(List<EmailDetails> emailDetailsList) {
    for (EmailDetails details : emailDetailsList) {
        try {
            sendSimpleMessage(details.getTo(), details.getSubject(), details.getContent());
            // 발송 간격을 두어 서버 과부하 방지
            Thread.sleep(100); 
        } catch (Exception e) {
            // 오류 로깅
            log.error("Failed to send email to {}: {}", details.getTo(), e.getMessage());
        }
    }
    return CompletableFuture.completedFuture(null);
}

메시지 큐 활용

대규모 이메일 발송의 경우 RabbitMQ, Apache Kafka 등의 메시지 큐를 활용하는 것이 좋습니다.

아래는 RabbitMQ를 활용한 예시입니다.

먼저 의존성을 추가합니다:

implementation 'org.springframework.boot:spring-boot-starter-amqp'

 

RabbitMQ 설정:

@Configuration
public class RabbitMQConfig {

    @Bean
    Queue emailQueue() {
        return new Queue("email-queue", true);
    }

    @Bean
    DirectExchange emailExchange() {
        return new DirectExchange("email-exchange");
    }

    @Bean
    Binding binding(Queue emailQueue, DirectExchange emailExchange) {
        return BindingBuilder.bind(emailQueue).to(emailExchange).with("email-routing-key");
    }
}

 

이메일 발송 요청을 큐에 전송하는 서비스:

@Service
public class EmailProducerService {

    private final RabbitTemplate rabbitTemplate;
    private final ObjectMapper objectMapper;

    @Autowired
    public EmailProducerService(RabbitTemplate rabbitTemplate, ObjectMapper objectMapper) {
        this.rabbitTemplate = rabbitTemplate;
        this.objectMapper = objectMapper;
    }

    public void sendEmailToQueue(EmailDetails emailDetails) throws JsonProcessingException {
        String emailJson = objectMapper.writeValueAsString(emailDetails);
        rabbitTemplate.convertAndSend("email-exchange", "email-routing-key", emailJson);
    }

    public void sendBulkEmailsToQueue(List<EmailDetails> emailDetailsList) throws JsonProcessingException {
        for (EmailDetails details : emailDetailsList) {
            sendEmailToQueue(details);
        }
    }
}

 

이메일 메시지를 소비하고 처리하는 서비스:

@Service
public class EmailConsumerService {

    private final EmailService emailService;
    private final ObjectMapper objectMapper;

    @Autowired
    public EmailConsumerService(EmailService emailService, ObjectMapper objectMapper) {
        this.emailService = emailService;
        this.objectMapper = objectMapper;
    }

    @RabbitListener(queues = "email-queue")
    public void consumeEmailMessage(String message) throws IOException {
        EmailDetails emailDetails = objectMapper.readValue(message, EmailDetails.class);
        emailService.sendSimpleMessage(
            emailDetails.getTo(),
            emailDetails.getSubject(),
            emailDetails.getContent()
        );
    }
}

---

이메일 발송 실패 처리와 재시도 메커니즘

실제 운영 환경에서는 네트워크 문제, 서버 과부하 등으로 이메일 발송이 실패할 수 있습니다.

이런 상황을 대비한 재시도 메커니즘을 구현해 보겠습니다.

재시도 설정 구현

Spring Retry를 사용하여 재시도 로직을 구현합니다:

implementation 'org.springframework.retry:spring-retry'
implementation 'org.springframework.boot:spring-boot-starter-aop'

 

애플리케이션 설정:

@Configuration
@EnableRetry
public class RetryConfig {
}

 

EmailService에 재시도 로직 적용:

@Retryable(
    value = {MessagingException.class, MailSendException.class},
    maxAttempts = 3,
    backoff = @Backoff(delay = 1000, multiplier = 2)
)
@Override
public void sendSimpleMessage(String to, String subject, String text) {
    SimpleMailMessage message = new SimpleMailMessage();
    message.setFrom("noreply@example.com");
    message.setTo(to);
    message.setSubject(subject);
    message.setText(text);

    emailSender.send(message);

    log.info("Email sent successfully to: {}", to);
}

@Recover
public void recoverFromEmailFailure(Exception e, String to, String subject, String text) {
    log.error("All retries failed. Email to {} could not be sent", to);
    // DB에 실패 기록 저장, 관리자에게 알림 등의 후속 조치
    emailFailureRepository.save(new EmailFailure(to, subject, e.getMessage()));
}

---

이메일 발송 로깅 및 모니터링

이메일 발송 상태를 추적하고 모니터링하는 방법을 살펴보겠습니다.

이메일 이벤트 추적

이메일 발송 이벤트를 추적하기 위한 엔티티 클래스:

@Entity
@Table(name = "email_events")
public class EmailEvent {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String recipient;
    private String subject;
    private String status;  // SENT, FAILED, DELIVERED, OPENED
    private LocalDateTime timestamp;

    // Getters, setters, constructors
}

 

이메일 이벤트 저장 서비스:

@Service
public class EmailEventService {

    private final EmailEventRepository emailEventRepository;

    @Autowired
    public EmailEventService(EmailEventRepository emailEventRepository) {
        this.emailEventRepository = emailEventRepository;
    }

    public void recordEmailSent(String recipient, String subject) {
        EmailEvent event = new EmailEvent();
        event.setRecipient(recipient);
        event.setSubject(subject);
        event.setStatus("SENT");
        event.setTimestamp(LocalDateTime.now());

        emailEventRepository.save(event);
    }

    public void recordEmailFailed(String recipient, String subject, String errorMessage) {
        EmailEvent event = new EmailEvent();
        event.setRecipient(recipient);
        event.setSubject(subject);
        event.setStatus("FAILED");
        event.setErrorMessage(errorMessage);
        event.setTimestamp(LocalDateTime.now());

        emailEventRepository.save(event);
    }

    public List<EmailEvent> getEmailEventsByRecipient(String recipient) {
        return emailEventRepository.findByRecipientOrderByTimestampDesc(recipient);
    }

    public Map<String, Long> getEmailStatistics(LocalDateTime start, LocalDateTime end) {
        List<EmailEvent> events = emailEventRepository.findByTimestampBetween(start, end);

        Map<String, Long> statistics = events.stream()
            .collect(Collectors.groupingBy(EmailEvent::getStatus, Collectors.counting()));

        return statistics;
    }
}

AOP를 활용한 이메일 발송 로깅

AOP를 사용하여 이메일 발송 로깅을 자동화할 수 있습니다:

@Aspect
@Component
public class EmailLoggingAspect {

    private final EmailEventService emailEventService;
    private final Logger log = LoggerFactory.getLogger(EmailLoggingAspect.class);

    @Autowired
    public EmailLoggingAspect(EmailEventService emailEventService) {
        this.emailEventService = emailEventService;
    }

    @AfterReturning("execution(* com.example.emailservice.service.EmailService.send*(..)) && args(to, subject, ..)")
    public void logSuccessfulEmail(JoinPoint joinPoint, String to, String subject) {
        log.info("Email successfully sent to: {} with subject: {}", to, subject);
        emailEventService.recordEmailSent(to, subject);
    }

    @AfterThrowing(pointcut = "execution(* com.example.emailservice.service.EmailService.send*(..)) && args(to, subject, ..)", 
                   throwing = "exception")
    public void logFailedEmail(JoinPoint joinPoint, String to, String subject, Exception exception) {
        log.error("Failed to send email to: {} with subject: {}. Error: {}", 
                 to, subject, exception.getMessage());
        emailEventService.recordEmailFailed(to, subject, exception.getMessage());
    }
}

---

보안 고려사항

이메일 시스템 구현 시 보안은 매우 중요합니다. 주요 보안 고려사항을 살펴보겠습니다.

민감한 정보 보호

이메일 인증 정보는 매우 민감한 정보이므로 적절히 보호해야 합니다:

1. 환경 변수 사용: 소스 코드에 직접 인증 정보를 입력하지 말고 환경 변수를 사용합니다.

@Configuration
public class EmailConfig {

    @Value("${spring.mail.username}")
    private String emailUsername;

    @Value("${spring.mail.password}")
    private String emailPassword;

    @Bean
    public JavaMailSender getJavaMailSender() {
        JavaMailSenderImpl mailSender = new JavaMailSenderImpl();
        mailSender.setHost("smtp.gmail.com");
        mailSender.setPort(587);

        mailSender.setUsername(emailUsername);
        mailSender.setPassword(emailPassword);

        Properties props = mailSender.getJavaMailProperties();
        props.put("mail.transport.protocol", "smtp");
        props.put("mail.smtp.auth", "true");
        props.put("mail.smtp.starttls.enable", "true");

        return mailSender;
    }
}

2. Spring Vault 또는 AWS Secrets Manager와 같은 보안 저장소 활용:

@Configuration
public class VaultConfig {

    @Autowired
    private VaultOperations vaultOperations;

    @Bean
    public JavaMailSender getJavaMailSender() {
        VaultResponse response = vaultOperations.read("secret/email-credentials");
        Map<String, Object> data = response.getData();

        String username = (String) data.get("username");
        String password = (String) data.get("password");

        JavaMailSenderImpl mailSender = new JavaMailSenderImpl();
        mailSender.setHost("smtp.gmail.com");
        mailSender.setPort(587);

        mailSender.setUsername(username);
        mailSender.setPassword(password);

        // 나머지 설정
        return mailSender;
    }
}

이메일 템플릿 보안

이메일 템플릿을 사용할 때 XSS(Cross-Site Scripting) 취약점을 방지해야 합니다:

1. Thymeleaf의 이스케이프 기능 활용: 기본적으로 Thymeleaf는 HTML 이스케이프를 지원합니다.
2. 사용자 입력 검증: 사용자 입력이 템플릿에 포함될 경우 반드시 검증합니다.

SPF, DKIM, DMARC 설정

이메일 스푸핑과 피싱을 방지하기 위해

SPF(Sender Policy Framework), DKIM(DomainKeys Identified Mail), DMARC(Domain-based Message Authentication, Reporting & Conformance) 설정을 권장합니다.

이는 DNS 설정을 통해 이루어집니다.

---

실전 프로젝트: 뉴스레터 자동 발송 시스템 구현

지금까지 배운 내용을 활용하여 뉴스레터 자동 발송 시스템을 구현해 보겠습니다.

뉴스레터 구독자 관리

@Entity
@Table(name = "subscribers")
public class Subscriber {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String email;

    private String name;

    private boolean active = true;

    @Column(name = "subscription_date")
    private LocalDateTime subscriptionDate;

    @Column(name = "unsubscribe_token")
    private String unsubscribeToken;

    // Getters, setters, constructors
}

뉴스레터 템플릿 모델

@Entity
@Table(name = "newsletter_templates")
public class NewsletterTemplate {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String name;

    @Column(nullable = false)
    private String subject;

    @Column(nullable = false, columnDefinition = "TEXT")
    private String content;

    @Column(name = "created_at")
    private LocalDateTime createdAt;

    @Column(name = "updated_at")
    private LocalDateTime updatedAt;

    // Getters, setters, constructors
}

뉴스레터 발송 서비스

@Service
public class NewsletterService {

    private final SubscriberRepository subscriberRepository;
    private final NewsletterTemplateRepository templateRepository;
    private final EmailService emailService;
    private final TemplateEngine templateEngine;

    @Autowired
    public NewsletterService(SubscriberRepository subscriberRepository,
                           NewsletterTemplateRepository templateRepository,
                           EmailService emailService,
                           TemplateEngine templateEngine) {
        this.subscriberRepository = subscriberRepository;
        this.templateRepository = templateRepository;
        this.emailService = emailService;
        this.templateEngine = templateEngine;
    }

    @Async
    public void sendNewsletterToAllActiveSubscribers(Long templateId) {
        NewsletterTemplate template = templateRepository.findById(templateId)
            .orElseThrow(() -> new ResourceNotFoundException("Template not found"));

        List<Subscriber> activeSubscribers = subscriberRepository.findByActiveTrue();

        for (Subscriber subscriber : activeSubscribers) {
            Map<String, Object> templateModel = new HashMap<>();
            templateModel.put("name", subscriber.getName());
            templateModel.put("unsubscribeLink", 
                             "https://example.com/unsubscribe?token=" + subscriber.getUnsubscribeToken());

            Context context = new Context();
            context.setVariables(templateModel);

            String content = templateEngine.process(template.getContent(), context);

            try {
                emailService.sendHtmlMessage(subscriber.getEmail(), template.getSubject(), content);
                Thread.sleep(100); // 발송 간격 조절
            } catch (Exception e) {
                // 오류 처리 및 로깅
                log.error("Failed to send newsletter to {}: {}", subscriber.getEmail(), e.getMessage());
            }
        }
    }

    // 구독 및 구독 취소 처리 메서드
    public void subscribe(String email, String name) {
        if (subscriberRepository.existsByEmail(email)) {
            throw new DuplicateResourceException("Email already subscribed");
        }

        Subscriber subscriber = new Subscriber();
        subscriber.setEmail(email);
        subscriber.setName(name);
        subscriber.setActive(true);
        subscriber.setSubscriptionDate(LocalDateTime.now());
        subscriber.setUnsubscribeToken(UUID.randomUUID().toString());

        subscriberRepository.save(subscriber);

        // 환영 이메일 발송
        sendWelcomeEmail(subscriber);
    }

    public void unsubscribe(String token) {
        Subscriber subscriber = subscriberRepository.findByUnsubscribeToken(token)
            .orElseThrow(() -> new ResourceNotFoundException("Invalid unsubscribe token"));

        subscriber.setActive(false);
        subscriberRepository.save(subscriber);

        // 구독 취소 확인 이메일 발송
        sendUnsubscribeConfirmationEmail(subscriber);
    }

    private void sendWelcomeEmail(Subscriber subscriber) {
        Map<String, Object> templateModel = new HashMap<>();
        templateModel.put("name", subscriber.getName());
        templateModel.put("unsubscribeLink", 
                         "https://example.com/unsubscribe?token=" + subscriber.getUnsubscribeToken());

        emailService.sendTemplateMessage(
            subscriber.getEmail(),
            "뉴스레터 구독을 환영합니다!",
            "email/newsletter-welcome",
            templateModel
        );
    }

    private void sendUnsubscribeConfirmationEmail(Subscriber subscriber) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(subscriber.getEmail());
        message.setSubject("뉴스레터 구독 취소 확인");
        message.setText("안녕하세요, " + subscriber.getName() + "님.\n\n"
                      + "뉴스레터 구독이 취소되었습니다. 언제든지 다시 구독하실 수 있습니다.\n\n"
                      + "감사합니다.");

        emailService.sendSimpleMessage(
            subscriber.getEmail(),
            "뉴스레터 구독 취소 확인",
            message.getText()
        );
    }
}

스케줄링을 활용한 자동 발송

@Configuration
@EnableScheduling
public class SchedulingConfig {
}

@Service
public class ScheduledNewsletterService {

    private final NewsletterService newsletterService;
    private final NewsletterTemplateRepository templateRepository;

    @Autowired
    public ScheduledNewsletterService(NewsletterService newsletterService,
                                    NewsletterTemplateRepository templateRepository) {
        this.newsletterService = newsletterService;
        this.templateRepository = templateRepository;
    }

    // 매주 월요일 오전 9시에 실행
    @Scheduled(cron = "0 0 9 ? * MON")
    public void sendWeeklyNewsletter() {
        // 가장 최근 템플릿 사용
        NewsletterTemplate latestTemplate = templateRepository.findTopByOrderByCreatedAtDesc()
            .orElseThrow(() -> new ResourceNotFoundException("No newsletter template found"));

        newsletterService.sendNewsletterToAllActiveSubscribers(latestTemplate.getId());
    }
}

---

성능 최적화 팁

대규모 이메일 발송 시스템의 성능을 최적화하기 위한 몇 가지 팁을 알아보겠습니다.

연결 풀링 활용

JavaMailSender의 기본 구현체인 JavaMailSenderImpl은 매번 새로운 SMTP 연결을 생성합니다.

성능 향상을 위해 연결 풀링을 활용할 수 있습니다:

@Configuration
public class MailConfig {

    @Bean
    public JavaMailSender javaMailSender() {
        JavaMailSenderImpl mailSender = new JavaMailSenderImpl();
        // 기본 설정...

        // 연결 풀링 설정
        Properties props = mailSender.getJavaMailProperties();
        props.put("mail.smtp.connectiontimeout", "5000");
        props.put("mail.smtp.timeout", "5000");
        props.put("mail.smtp.writetimeout", "5000");
        // 세션 재사용
        props.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
        props.put("mail.transport.protocol", "smtp");
        props.put("mail.smtp.auth", "true");
        props.put("mail.smtp.starttls.enable", "true");
        props.put("mail.debug", "false");

        return mailSender;
    }
}

대량 발송 시 일괄 처리(Batching)

대량의 이메일을 발송할 때는 적절한 배치 크기로 나누어 처리하는 것이 좋습니다:

@Service
public class BulkEmailService {

    private static final int BATCH_SIZE = 100;
    private final EmailService emailService;

    @Autowired
    public BulkEmailService(EmailService emailService) {
        this.emailService = emailService;
    }

    public void sendBulkEmails(List<EmailDetails> allEmails) {
        int totalEmails = allEmails.size();
        int batchCount = (totalEmails + BATCH_SIZE - 1) / BATCH_SIZE; // 올림 계산

        for (int i = 0; i < batchCount; i++) {
            int fromIndex = i * BATCH_SIZE;
            int toIndex = Math.min(fromIndex + BATCH_SIZE, totalEmails);

            List<EmailDetails> batch = allEmails.subList(fromIndex, toIndex);

            // 각 배치를 비동기로 처리
            CompletableFuture.runAsync(() -> {
                for (EmailDetails email : batch) {
                    try {
                        emailService.sendSimpleMessage(
                            email.getTo(),
                            email.getSubject(),
                            email.getContent()
                        );
                        Thread.sleep(100); // 발송 간격 조절
                    } catch (Exception e) {
                        // 오류 처리
                        log.error("Failed to send email to {}: {}", email.getTo(), e.getMessage());
                    }
                }
            });

            // 배치 간 간격 조절
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

템플릿 캐싱

자주 사용되는 이메일 템플릿은 캐싱하여 성능을 향상시킬 수 있습니다:

@Service
public class CachedTemplateService {

    private final TemplateEngine templateEngine;
    private final CacheManager cacheManager;

    @Autowired
    public CachedTemplateService(TemplateEngine templateEngine, CacheManager cacheManager) {
        this.templateEngine = templateEngine;
        this.cacheManager = cacheManager;
    }

    public String processTemplate(String templateName, Map<String, Object> model) {
        String cacheKey = templateName + "_" + calculateModelHash(model);
        Cache cache = cacheManager.getCache("emailTemplates");

        if (cache != null) {
            String cachedContent = cache.get(cacheKey, String.class);
            if (cachedContent != null) {
                return cachedContent;
            }
        }

        Context context = new Context();
        context.setVariables(model);

        String processedTemplate = templateEngine.process(templateName, context);

        if (cache != null) {
            cache.put(cacheKey, processedTemplate);
        }

        return processedTemplate;
    }

    private String calculateModelHash(Map<String, Object> model) {
        // 간단한 해시 계산 로직
        return String.valueOf(model.hashCode());
    }
}

---

자주 발생하는 문제와 해결 방법

이메일 시스템 구현 시 자주 발생하는 문제와 해결 방법을 정리해 보겠습니다.

1. 인증 오류

문제: SMTP 서버 인증 실패

해결 방법:

• 사용자 이름과 비밀번호가 정확한지 확인
• Gmail의 경우 보안 수준이 낮은 앱 액세스 설정 또는 앱 비밀번호 설정 확인
• 2단계 인증이 활성화된 경우 앱 비밀번호 사용

@PostConstruct
public void testConnection() {
    try {
        emailSender.testConnection();
        log.info("Email server connection successful");
    } catch (MailAuthenticationException e) {
        log.error("Email authentication failed: {}", e.getMessage());
        // 관리자에게 알림
    } catch (Exception e) {
        log.error("Email connection test failed: {}", e.getMessage());
    }
}

2. SSL/TLS 문제

문제: SSL/TLS 연결 실패

해결 방법:

• 적절한 포트 사용 (Gmail: 587 for TLS, 465 for SSL)
• 올바른 SSL/TLS 설정

Properties props = new Properties();
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.ssl.trust", "smtp.gmail.com");
props.put("mail.smtp.ssl.protocols", "TLSv1.2");

3. 이메일이 스팸으로 분류됨

문제: 보낸 이메일이 수신자의 스팸함으로 들어감

해결 방법:

• SPF, DKIM, DMARC 레코드 설정
• 이메일 콘텐츠에 스팸 필터 트리거 단어 피하기
• 올바른 발신자 주소 사용

4. HTML 렌더링 문제

문제: 이메일 클라이언트에서 HTML이 제대로 렌더링되지 않음

해결 방법:

• 인라인 CSS 사용
• 테이블 기반 레이아웃 사용 (이메일 클라이언트 호환성 향상)
• 다양한 이메일 클라이언트에서 테스트

// MimeMessageHelper 설정 시
MimeMessageHelper helper = new MimeMessageHelper(message, true, "UTF-8");
helper.setText(htmlContent, true);  // true는 HTML로 해석

5. 문자 인코딩 문제

문제: 한글 등 특수 문자가 깨짐

해결 방법:

• 올바른 문자 인코딩 설정 (UTF-8)
• 메시지 헤더에 문자셋 명시

MimeMessageHelper helper = new MimeMessageHelper(message, true, "UTF-8");
helper.setSubject(MimeUtility.encodeText(subject, "UTF-8", "B"));

---

마치며

이 글에서는 자바와 Spring Framework를 활용하여 강력하고 유연한 이메일 발송 시스템을 구현하는 방법을 살펴보았습니다. JavaMailSender의 기본 사용법부터 템플릿 적용, 첨부 파일 처리, 대량 발송, 성능 최적화까지 다양한 주제를 다루었습니다.

실무에서는 이메일 발송이 단순한 기능처럼 보이지만, 확장성, 안정성, 보안 등 다양한 측면을 고려해야 합니다.

이 글에서 다룬 방법과 패턴을 활용하여 비즈니스 요구사항에 맞는 최적화된 이메일 시스템을 구축하시기 바랍니다.

 

기억해야 할 핵심 포인트:

1. Spring Boot와 JavaMailSender를 활용하면 쉽게 이메일 발송 기능 구현 가능
2. 템플릿 엔진을 활용하여 유지보수가 쉬운 이메일 템플릿 관리
3. 비동기 처리 및 메시지 큐를 활용하여 대량 메일 처리 최적화
4. 재시도 메커니즘으로 안정성 확보
5. 로깅 및 모니터링으로 이메일 발송 추적
6. 보안 고려사항을 적용하여 안전한 이메일 시스템 구축

효율적인 이메일 시스템은 사용자 경험 향상과 비즈니스 성과에 직접적인 영향을 미칩니다.

이 글이 여러분의 이메일 시스템 구현에 도움이 되길 바랍니다.

---

관련 참조 링크

공식 문서

• Spring Boot Mail 공식 문서
• Spring Framework JavaMailSender 레퍼런스
• Thymeleaf 공식 문서
• Jakarta Mail API 문서

템플릿 엔진 및 관련 기술

• Thymeleaf 이메일 템플릿 가이드
• FreeMarker 템플릿 엔진
• Velocity 템플릿 엔진

이메일 서비스 제공업체

• Gmail SMTP 설정 가이드
• Amazon SES 개발자 가이드
• SendGrid 이메일 API
• Mailgun API 문서

성능 및 모니터링

• Spring Boot Actuator
• Micrometer 메트릭 수집
• RabbitMQ Spring Boot 통합
• Apache Kafka Spring Boot 통합

보안 및 인증

• Spring Security 공식 문서
• OAuth 2.0 이메일 인증
• Spring Vault 통합 가이드

이메일 표준 및 프로토콜

• RFC 5321 - SMTP 프로토콜
• RFC 5322 - 인터넷 메시지 형식
• SPF, DKIM, DMARC 설정 가이드

테스트 도구

• MailHog - 로컬 SMTP 테스트 도구
• GreenMail - 자바 이메일 테스트 라이브러리
• WireMock - API 목킹 도구

추가 학습 자료

• Spring Boot 공식 가이드
• Baeldung Spring Email 튜토리얼
• Java Email 모범 사례