org.springframework.mail.javamail.JavaMailSender

public static void sendDefaultMail(JavaMailSender mailSender, String subject, String text) {
    sendMail(mailSender, "sende[email protected]", "[email protected]", subject, text);
}

public clreplaced MailProviderServiceUnitTest {

    public static final String TENANT = "TEST";

    private String mailConfig;

    private MailProviderService providerService;

    private final JavaMailSender defaultMailSender = new JavaMailSenderImpl();

    @Before
    @SneakyThrows
    public void before() {
        providerService = new MailProviderService(defaultMailSender);
        mailConfig = new String(Files.readAllBytes(Paths.get(getClreplaced().getResource("/mail-config.yml").toURI())));
    }

    @Test
    public void testMailProviderAddedOnInit() {
        replacedertFalse(providerService.isTenantMailSenderExists(TENANT));
        providerService.onInit("/config/tenants/TEST/mail-config.yml", mailConfig);
        replacedertTrue(providerService.isTenantMailSenderExists(TENANT));
    }

    @Test
    public void testMailProviderReturnDefault() {
        replacedertFalse(providerService.isTenantMailSenderExists(TENANT));
        replacedertEquals(defaultMailSender, providerService.getJavaMailSender(TENANT));
    }

    @Test
    public void testNoExceptionOnInvalidConfig() {
        replacedertFalse(providerService.isTenantMailSenderExists(TENANT));
        providerService.onInit("/config/tenants/TEST/mail-config.yml", "sdfsd --- fsdfe");
        replacedertEquals(defaultMailSender, providerService.getJavaMailSender(TENANT));
    }

    @Test
    public void testMailProviderAddedOnRefresh() {
        replacedertFalse(providerService.isTenantMailSenderExists(TENANT));
        providerService.onRefresh("/config/tenants/TEST/mail-config.yml", mailConfig);
        replacedertTrue(providerService.isTenantMailSenderExists(TENANT));
        JavaMailSenderImpl javaMailSender = (JavaMailSenderImpl) providerService.getJavaMailSender(TENANT);
        replacedertNotNull(javaMailSender);
        replacedertEquals("localhost", javaMailSender.getHost());
        replacedertEquals(25, javaMailSender.getPort());
        replacedertEquals("smtp", javaMailSender.getProtocol());
        replacedertEquals("mailuser", javaMailSender.getUsername());
        replacedertEquals("mailpreplaced", javaMailSender.getPreplacedword());
        Properties properties = javaMailSender.getJavaMailProperties();
        replacedertEquals(3, properties.size());
        replacedertEquals("true", properties.getProperty("mail.smtp.starttls.enable"));
        replacedertEquals("true", properties.getProperty("ssl.trust"));
        replacedertEquals("true", properties.getProperty("mail.imap.ssl.enable"));
    }

    @Test
    public void testMailProviderRemoved() {
        replacedertFalse(providerService.isTenantMailSenderExists(TENANT));
        providerService.onRefresh("/config/tenants/TEST/mail-config.yml", mailConfig);
        replacedertTrue(providerService.isTenantMailSenderExists(TENANT));
        providerService.onRefresh("/config/tenants/TEST/mail-config.yml", "");
        replacedertFalse(providerService.isTenantMailSenderExists(TENANT));
    }

    @Test
    public void testMailProviderRecreatedOnRefresh() {
        replacedertFalse(providerService.isTenantMailSenderExists(TENANT));
        providerService.onRefresh("/config/tenants/TEST/mail-config.yml", mailConfig);
        replacedertTrue(providerService.isTenantMailSenderExists(TENANT));
        JavaMailSender mailSender1 = providerService.getJavaMailSender(TENANT);
        providerService.onRefresh("/config/tenants/TEST/mail-config.yml", mailConfig);
        replacedertTrue(providerService.isTenantMailSenderExists(TENANT));
        JavaMailSender mailSender2 = providerService.getJavaMailSender(TENANT);
        replacedertNotNull(mailSender1);
        replacedertNotNull(mailSender2);
        replacedertNotEquals(mailSender1, mailSender2);
    }
}

@RestController
public clreplaced JavamailService {

    private JavaMailSender javaMailSender;

    public JavamailService(JavaMailSender javaMailSender) {
        this.javaMailSender = javaMailSender;
    }

    @GetMapping("/")
    public String send() {
        try {
            SimpleMailMessage message = new SimpleMailMessage();
            message.setTo("[email protected]");
            message.setFrom("[email protected]");
            message.setSubject("My very email");
            message.setText("Very nice content!");
            javaMailSender.send(message);
        } catch (MailException e) {
        // This is ok as we don't have any server available
        }
        return "OK";
    }
}

/**
 * @author Soumyadip Chowdhury
 * @github soumyadip007
 */
@Service("emailService")
public clreplaced EmailService {

    private JavaMailSender mailSender;

    @Autowired
    public EmailService(JavaMailSender mailSender) {
        this.mailSender = mailSender;
    }

    @Async
    public void sendEmail(SimpleMailMessage email) {
        mailSender.send(email);
    }
}

@Bean
public EmailSender emailSender(@Autowired JavaMailSender javaMailSender) {
    return new EmailSmtpSender(javaMailSender);
}

@Service
public clreplaced NotificationService {

    private final JavaMailSender javaMailSender;

    public NotificationService(JavaMailSender javaMailSender) {
        this.javaMailSender = javaMailSender;
    }

    public void notifyUser(String email, String content) {
        SimpleMailMessage mail = new SimpleMailMessage();
        mail.setFrom("[email protected]");
        mail.setSubject("A new message for you");
        mail.setText(content);
        mail.setTo(email);
        this.javaMailSender.send(mail);
    }
}

@Service
public clreplaced EmailService {

    private final JavaMailSender mailSender;

    private final String defaultSender;

    public EmailService(JavaMailSender mailSender, AppProperties appProperties) {
        this.mailSender = mailSender;
        this.defaultSender = appProperties.getDefaultEmailSender();
    }

    public void sendEmail() throws MessagingException {
        MimeMessage message = this.mailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message);
        helper.setFrom(this.defaultSender);
        helper.setTo("[email protected]");
        helper.setText("<h1>Hello World</h1>", true);
        helper.setSubject("Test Email");
        this.mailSender.send(message);
    }
}

@RunWith(SpringRunner.clreplaced)
@SpringBootTest(clreplacedes = SeppApplication.clreplaced)
public abstract clreplaced BaseServiceIntegrationTest {

    @MockBean
    private JavaMailSender javaMailSender;

    @BeforeClreplaced
    public static void beforeClreplaced() {
        System.setProperty("env", "local");
    }

    @AfterClreplaced
    public static void afterClreplaced() {
        System.clearProperty("env");
    }
}

@Autowired(required = false)
public void setJavaMailSender(JavaMailSender javaMailSender) {
    this.javaMailSender = javaMailSender;
}

public abstract clreplaced EmailSender<ENreplacedY, RECIPIENT> {

    protected final static String EMAIL_TO_PERSONAL_NAME = "{0} ({1})";

    private final static String EMAIL_ENCODING = "UTF-8";

    private static final String HTML_CONTENT_SUBTYPE = "html";

    private static final String PLAIN_CONTENT_SUBTYPE = "plain";

    protected JavaMailSender mailSender;

    protected abstract void addAttachments(ENreplacedY enreplacedy, RECIPIENT recipient, ArrayList<EmailAttachmentVO> attachments) throws Exception;

    private final MimeMessage createMessage(ENreplacedY enreplacedy, RECIPIENT recipient) throws Exception {
        Date now = new Date();
        MimeMessage mimeMessage = loadMessage(enreplacedy, recipient, now);
        if (mimeMessage != null) {
            return mimeMessage;
        } else {
            mimeMessage = mailSender.createMimeMessage();
            StringBuilder text = new StringBuilder();
            prepareMessage(mimeMessage, enreplacedy, recipient, text, now);
            if (getToCount(mimeMessage) > 0) {
                ArrayList<EmailAttachmentVO> attachments = new ArrayList<EmailAttachmentVO>();
                addAttachments(enreplacedy, recipient, attachments);
                if (attachments.size() > 0) {
                    Multipart multipart = new MimeMultipart();
                    Iterator<EmailAttachmentVO> it = attachments.iterator();
                    MimeBodyPart messageBodyPart = new MimeBodyPart();
                    messageBodyPart.setText(text.toString(), getEncoding(), isHtml() ? HTML_CONTENT_SUBTYPE : PLAIN_CONTENT_SUBTYPE);
                    multipart.addBodyPart(messageBodyPart);
                    while (it.hasNext()) {
                        EmailAttachmentVO attachment = it.next();
                        messageBodyPart = new MimeBodyPart();
                        DataSource source = new ByteArrayDataSource(attachment.getDatas(), attachment.getContentType().getMimeType());
                        messageBodyPart.setDataHandler(new DataHandler(source));
                        messageBodyPart.setFileName(attachment.getFileName());
                        multipart.addBodyPart(messageBodyPart);
                    }
                    mimeMessage.setContent(multipart);
                }
                storeMessage(mimeMessage, enreplacedy, recipient, now);
            }
            return mimeMessage;
        }
    }

    protected String getEncoding() {
        String encoding = null;
        try {
            encoding = ((org.springframework.mail.javamail.JavaMailSenderImpl) mailSender).getDefaultEncoding();
        } catch (Exception e) {
        }
        if (CommonUtil.isEmptyString(encoding)) {
            encoding = EMAIL_ENCODING;
        }
        return encoding;
    }

    public JavaMailSender getMailSender() {
        return mailSender;
    }

    public final int getToCount(MimeMessage mimeMessage) throws Exception {
        if (mimeMessage != null) {
            Address[] to = mimeMessage.getRecipients(javax.mail.Message.RecipientType.TO);
            if (to != null) {
                return to.length;
            }
        }
        return 0;
    }

    protected abstract boolean isHtml();

    protected abstract MimeMessage loadMessage(ENreplacedY enreplacedy, RECIPIENT recipient, Date now) throws Exception;

    public final MimeMessage prepare(ENreplacedY enreplacedy, RECIPIENT recipient) throws Exception {
        return createMessage(enreplacedy, recipient);
    }

    public final int prepareAndSend(ENreplacedY enreplacedy, RECIPIENT recipient) throws Exception {
        return send(prepare(enreplacedy, recipient));
    }

    protected abstract void prepareMessage(MimeMessage mimeMessage, ENreplacedY enreplacedy, RECIPIENT recipient, StringBuilder text, Date now) throws Exception;

    public final int send(MimeMessage mimeMessage) throws Exception {
        int toCount = getToCount(mimeMessage);
        if (toCount > 0) {
            mailSender.send(mimeMessage);
        }
        return toCount;
    }

    public void setMailSender(JavaMailSender mailSender) {
        this.mailSender = mailSender;
    }

    protected abstract void storeMessage(MimeMessage mimeMessage, ENreplacedY enreplacedy, RECIPIENT recipient, Date now) throws Exception;
}

public void setMailSender(JavaMailSender mailSender) {
    this.mailSender = mailSender;
}

/**
 * @author 作者 owen E-mail: [email protected]
 * @version 创建时间：2017年11月24日 下午5:34:47 类说明
 */
@RestController
public clreplaced Controller {

    @Autowired
    private JavaMailSender javaMailSender;

    @GetMapping("/send")
    public String send() {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom("[email protected]");
        message.setTo("[email protected]");
        message.setSubject("测试邮件");
        message.setText("好好学习");
        javaMailSender.send(message);
        return "hello";
    }

    @GetMapping("/send1")
    public String send1() throws MessagingException {
        MimeMessage msg = javaMailSender.createMimeMessage();
        MimeMessageHelper msgHelper = new MimeMessageHelper(msg, true, "utf-8");
        msgHelper.setFrom("[email protected]");
        msgHelper.setTo("[email protected]");
        msgHelper.setSubject("测试发送带附件的邮件");
        msgHelper.setText("测试邮件");
        FileSystemResource file = new FileSystemResource(new File("D:" + File.separator + "20171124150927.jpg"));
        // 添加附件
        msgHelper.addAttachment("20171124150927.jpg", file);
        // Properties prop = new Properties();
        // prop.put("mail.smtp.auth", "true");
        // prop.put("mail.smtp.timeout", "25000");
        // javaMailSender.setJavaMailProperties(prop);
        javaMailSender.send(msg);
        return "hello";
    }
}

@Service
public clreplaced TokenDeliverySystemEmail implements TokenDeliverySystem {

    private static final String BASE_CONFIG_URI = "quizzz.tokens.%s";

    private MessageSource messageSource;

    private JavaMailSender mailSender;

    @Autowired
    public TokenDeliverySystemEmail(MessageSource messageSource, JavaMailSender mailSender) {
        this.messageSource = messageSource;
        this.mailSender = mailSender;
    }

    @Override
    public void sendTokenToUser(TokenModel token, User user, TokenType tokenType) {
        String base_config = String.format(BASE_CONFIG_URI, tokenType.toString().toLowerCase());
        String url = String.format(messageSource.getMessage(base_config + ".url", null, null), user.getId(), token.getToken());
        try {
            sendByMail(user, url, base_config);
        } catch (Exception e) {
            // This runs on a thread so it is too late to notify the user. A
            // re-try mechanism could be put in place.
            e.printStackTrace();
        }
    }

    private void sendByMail(User user, String url, String base_config) {
        String subject = messageSource.getMessage(base_config + ".subject", null, null);
        String body = String.format(messageSource.getMessage(base_config + ".body", null, null), user.getUsername(), url);
        SimpleMailMessage mailMessage = new SimpleMailMessage();
        mailMessage.setTo(user.getEmail());
        mailMessage.setFrom("[email protected]");
        mailMessage.setSubject(subject);
        mailMessage.setText(body);
        mailSender.send(mailMessage);
    }
}

@Bean
Sender sender(JavaMailSender aJavaMailSender) {
    return new EmailSender(aJavaMailSender);
}

/**
 * @author Arik Cohen
 * @since Jan 30, 2018
 */
public clreplaced EmailSender implements Sender {

    @Value("${preplacedwordless.email.from}")
    private String from;

    private final JavaMailSender mailSender;

    public EmailSender(JavaMailSender aMailSender) {
        mailSender = aMailSender;
    }

    @Override
    public void send(String aUserId, String aToken) {
        SimpleMailMessage mailMessage = new SimpleMailMessage();
        mailMessage.setFrom(from);
        mailMessage.setTo(aUserId);
        mailMessage.setSubject("Your signin link");
        mailMessage.setText(String.format("Hello!\nAccess your account here: http://localhost:8080/signin/%s?uid=%s", aToken, aUserId));
        mailSender.send(mailMessage);
    }
}

@RestController
public clreplaced MailController {

    @Autowired
    private JavaMailSender mailSender;

    @RequestMapping(value = "/sendmail", method = RequestMethod.GET)
    public String sendSimpleMail() throws Exception {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom("发送方邮箱");
        message.setTo("接受方邮箱");
        message.setSubject("主题：简单邮件");
        message.setText("测试邮件内容");
        mailSender.send(message);
        return "send success";
    }
}

/**
 * 默认的邮件发送服务类
 *
 * @author ：enilu
 * @date ：Created in 2019/6/11 15:19
 */
@Service
public clreplaced DefaultEmailSender implements EmailSender {

    @Autowired
    private JavaMailSender javaMailSender;

    @Override
    public boolean sendEmail(String from, String to, String cc, String replacedle, String content) {
        return sendEmail(from, to, cc, replacedle, content, null, null);
    }

    @Override
    public boolean sendEmail(String from, String to, String cc, String replacedle, String content, String attachmentFilename, InputStreamSource inputStreamSource) {
        MimeMessage message = null;
        try {
            message = javaMailSender.createMimeMessage();
            MimeMessageHelper helper = new MimeMessageHelper(message, true);
            helper.setFrom(from);
            helper.setTo(to);
            if (StringUtils.isNotEmpty(cc)) {
                helper.setCc(cc);
            }
            helper.setSubject(replacedle);
            helper.setText(content, true);
            if (inputStreamSource != null) {
                helper.addAttachment(attachmentFilename, inputStreamSource);
            }
            javaMailSender.send(message);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
}

public clreplaced SendEmailTest extends JframeworkApplicationTests {

    @Autowired
    private JavaMailSender mailSender;

    @Test
    public void send() {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom("jframework");
        message.setTo("[email protected]");
        message.setSubject("主题：简单邮件");
        message.setText("测试邮件内容");
        mailSender.send(message);
    }
}

public void setJavaMailSender(JavaMailSender javaMailSender) {
    this.javaMailSender = javaMailSender;
}

/**
 * 邮件工具类
 * @author Administrator
 */
public clreplaced MailUtil {

    // spring 邮件发送类
    private JavaMailSender javaMailSender;

    // 发件人
    private String from;

    /**
     * @param to 接收人，多人时可逗号分隔
     * @param subject 邮件主题
     * @param text 邮件正文（内容）
     * @throws MessagingException
     */
    public void sendMail(String to, String subject, String text) throws MessagingException {
        // 1. 创建邮件信息
        MimeMessage message = javaMailSender.createMimeMessage();
        // 2. 使用spring邮件工具类
        MimeMessageHelper helper = new MimeMessageHelper(message);
        // 3.收件人
        helper.setTo(to);
        // 4.发件人
        helper.setFrom(from);
        // 5.设置邮件的标题
        helper.setSubject(subject);
        // 6.邮件的内容
        helper.setText(text);
        // 7.发送邮件
        javaMailSender.send(message);
    }

    public void setJavaMailSender(JavaMailSender javaMailSender) {
        this.javaMailSender = javaMailSender;
    }

    public void setFrom(String from) {
        this.from = from;
    }
}

/**
 * Created by CodeCouple.pl
 */
@Service
clreplaced EmailSender {

    private final JavaMailSender javaMailSender;

    EmailSender(JavaMailSender javaMailSender) {
        this.javaMailSender = javaMailSender;
    }

    void sendEmail(String to, String from, String replacedle, String content) {
        SimpleMailMessage mail = new SimpleMailMessage();
        mail.setTo(to);
        mail.setFrom(from);
        mail.setSubject(replacedle);
        mail.setText(content);
        javaMailSender.send(mail);
    }
}

@Service
public clreplaced GmailService implements EmailService {

    @Autowired
    private JavaMailSender mailSender;

    @Autowired
    private Scheduler scheduler;

    @Override
    public Mono<Void> validationLink(Account acct) {
        String link = String.format("http://localhost:8080/verify?email=%s&token=%s", uriEncode(acct.getEmail()), uriEncode(acct.getPreplacedword()));
        String anchor = String.format("<a href='%s'>驗證郵件</a>", link);
        String html = String.format("請按 %s 啟用帳戶或複製鏈結至網址列：<br><br> %s", anchor, link);
        return sendMessage(acct.getEmail(), "Gossip 註冊結果", html);
    }

    @Override
    public Mono<Void> failedRegistration(String acctName, String acctEmail) {
        return sendMessage(acctEmail, "Gossip 註冊結果", String.format("帳戶申請失敗，使用者名稱 %s 或郵件 %s 已存在！", acctName, acctEmail));
    }

    @Override
    public Mono<Void> preplacedwordResetLink(Account acct) {
        String link = String.format("http://localhost:8080/reset_preplacedword?name=%s&email=%s&token=%s", uriEncode(acct.getName()), uriEncode(acct.getEmail()), uriEncode(acct.getPreplacedword()));
        String anchor = String.format("<a href='%s'>重設密碼</a>", link);
        String html = String.format("請按 %s 或複製鏈結至網址列：<br><br> %s", anchor, link);
        return sendMessage(acct.getEmail(), "Gossip 重設密碼", html);
    }

    private Mono<Void> sendMessage(String to, String subject, String text) {
        return Mono.defer(() -> {
            MimeMessage message = mailSender.createMimeMessage();
            try {
                MimeMessageHelper helper = new MimeMessageHelper(message, false);
                message.setContent(text, "text/html; charset=UTF-8");
                helper.setTo(to);
                helper.setSubject(subject);
                helper.setSentDate(new Date());
                mailSender.send(message);
                return Mono.<Void>empty();
            } catch (MessagingException e) {
                throw new RuntimeException(e);
            }
        }).subscribeOn(scheduler);
    }

    private String uriEncode(String text) {
        try {
            return URLEncoder.encode(text, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        }
    }
}

@Service
public clreplaced GmailService implements EmailService {

    @Autowired
    private JavaMailSender mailSender;

    @Override
    public void validationLink(Account acct) {
        String link = String.format("http://localhost:8080/verify?email=%s&token=%s", uriEncode(acct.getEmail()), uriEncode(acct.getPreplacedword()));
        String anchor = String.format("<a href='%s'>驗證郵件</a>", link);
        String html = String.format("請按 %s 啟用帳戶或複製鏈結至網址列：<br><br> %s", anchor, link);
        sendMessage(acct.getEmail(), "Gossip 註冊結果", html);
    }

    @Override
    public void failedRegistration(String acctName, String acctEmail) {
        sendMessage(acctEmail, "Gossip 註冊結果", String.format("帳戶申請失敗，使用者名稱 %s 或郵件 %s 已存在！", acctName, acctEmail));
    }

    @Override
    public void preplacedwordResetLink(Account acct) {
        String link = String.format("http://localhost:8080/reset_preplacedword?name=%s&email=%s&token=%s", uriEncode(acct.getName()), uriEncode(acct.getEmail()), uriEncode(acct.getPreplacedword()));
        String anchor = String.format("<a href='%s'>重設密碼</a>", link);
        String html = String.format("請按 %s 或複製鏈結至網址列：<br><br> %s", anchor, link);
        sendMessage(acct.getEmail(), "Gossip 重設密碼", html);
    }

    private void sendMessage(String to, String subject, String text) {
        MimeMessage message = mailSender.createMimeMessage();
        try {
            MimeMessageHelper helper = new MimeMessageHelper(message, false);
            message.setContent(text, "text/html; charset=UTF-8");
            helper.setTo(to);
            helper.setSubject(subject);
            helper.setSentDate(new Date());
            mailSender.send(message);
        } catch (MessagingException e) {
            throw new RuntimeException(e);
        }
    }

    private String uriEncode(String text) {
        try {
            return URLEncoder.encode(text, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        }
    }
}

@Autowired
public void setJavaMailSender(JavaMailSender javaMailSender) {
    EmailUtil.javaMailSender = javaMailSender;
}

public clreplaced GxMailServiceImpl implements io.graphenee.core.api.GxMailService {

    private JavaMailSender javaMailSender;

    @Override
    public void sendEmail(String subject, String content, String senderEmail, String toEmailList, String ccEmailList, String bccEmailList, Collection<GxMailAttachment> attachments) throws SendMailFailedException {
        MimeMessage message = javaMailSender.createMimeMessage();
        MimeMessageHelper mimeMessage;
        try {
            mimeMessage = new MimeMessageHelper(message, true);
            mimeMessage.setSubject(subject);
            mimeMessage.setText(content);
            if (toEmailList != null)
                mimeMessage.setTo(toEmailList);
            mimeMessage.setFrom(senderEmail);
            mimeMessage.setSentDate(new Date());
            if (!StringUtils.isEmpty(ccEmailList)) {
                if (ccEmailList.contains(";")) {
                    String[] emails = ccEmailList.split(";");
                    mimeMessage.setCc(emails);
                } else
                    mimeMessage.setCc(ccEmailList);
            }
            if (!StringUtils.isEmpty(bccEmailList)) {
                if (bccEmailList.contains(";")) {
                    String[] emails = bccEmailList.split(";");
                    mimeMessage.setBcc(emails);
                } else
                    mimeMessage.setBcc(bccEmailList);
            }
            if (attachments != null) {
                for (GxMailAttachment attachment : attachments) {
                    mimeMessage.addAttachment(attachment.fileName(), attachment.streamSource(), attachment.contentType());
                }
            }
            getJavaMailSender().send(message);
        } catch (MessagingException e) {
            throw new SendMailFailedException(e);
        }
    }

    @Override
    public void sendEmail(String subject, String content, String senderEmail, String toEmailList, String ccEmailList, String bccEmailList) throws SendMailFailedException {
        sendEmail(subject, content, senderEmail, toEmailList, ccEmailList, bccEmailList, null);
    }

    @Override
    public void sendEmail(String subject, String content, String senderEmail, String toEmailList, String ccEmailList) throws SendMailFailedException {
        sendEmail(subject, content, senderEmail, toEmailList, ccEmailList, null);
    }

    @Override
    public void sendEmail(String subject, String content, String senderEmail, String toEmailList) throws SendMailFailedException {
        sendEmail(subject, content, senderEmail, toEmailList, null);
    }

    public JavaMailSender getJavaMailSender() {
        return javaMailSender;
    }

    public void setJavaMailSender(JavaMailSender javaMailSender) {
        this.javaMailSender = javaMailSender;
    }
}

/**
 * 测试：FrameWorkMailSender
 *
 * @author Leon
 * @version 2018/8/18 23:40
 */
public clreplaced FrameWorkMailSender extends BaseTaskEventThread<Mail> {

    @Autowired
    private JavaMailSender javaMailSender;

    private String from;

    public FrameWorkMailSender(String name) {
        super(name);
    }

    @Override
    public short getWorkers() {
        return 2;
    }

    @Override
    public void doWork(Mail task) throws Exception {
        if (task != null) {
            MimeMessage mimeMessage = this.javaMailSender.createMimeMessage();
            MimeMessageHelper mimeMessageHelper = new MimeMessageHelper(mimeMessage);
            mimeMessageHelper.setFrom(from);
            mimeMessageHelper.setSubject(task.getreplacedle());
            mimeMessageHelper.setTo(task.getTo());
            mimeMessageHelper.setText(task.getContent());
            this.javaMailSender.send(mimeMessage);
        }
    }
}

/**
 * Created on Nov, 2020 by @author bobo
 */
public clreplaced SmtpEmailSender implements EmailSender {

    private final JavaMailSender javaMailSender;

    public SmtpEmailSender(JavaMailSender javaMailSender) {
        this.javaMailSender = javaMailSender;
    }

    @Override
    public void send(EmailDetails emailDetails) throws Exception {
        MimeMessage mimeMessage = javaMailSender.createMimeMessage();
        mimeMessage.setSentDate(new Date());
        mimeMessage.setFrom(emailDetails.getFrom());
        mimeMessage.addRecipients(Message.RecipientType.TO, emailDetails.getRecipient());
        mimeMessage.setSubject(emailDetails.getSubject());
        mimeMessage.setText(emailDetails.getBody());
        mimeMessage.saveChanges();
        javaMailSender.send(mimeMessage);
    }
}

@Bean
@ConditionalOnProperty(value = "geekshop.email-options.transport", havingValue = "smtp")
public SmtpEmailSender smtpEmailSender(JavaMailSender javaMailSender) {
    return new SmtpEmailSender(javaMailSender);
}

@Autowired
public void setMailSender(JavaMailSender mailSender) {
    MailUtil.mailSender = mailSender;
}

@RestController
public clreplaced MailController {

    @Autowired
    private JavaMailSender mailSender;

    private FreeMarkerConfigurer freeMarkerConfigurer;

    private String sendUser;

    /**
     * 发送文本标题 文本内容
     */
    @GetMapping("/sendMail")
    public String sendMail() {
        try {
            SimpleMailMessage message = new SimpleMailMessage();
            message.setFrom(sendUser);
            message.setTo("[email protected]");
            message.setSubject("主题邮件");
            message.setText("邮件内容");
            mailSender.send(message);
            return "success";
        } catch (Exception e) {
            e.printStackTrace();
            return "fail";
        }
    }

    /**
     * 发送html内容
     */
    @GetMapping("/sendHtmlMail")
    public String sendHtmlMail() {
        MimeMessage message = null;
        try {
            message = mailSender.createMimeMessage();
            MimeMessageHelper helper = new MimeMessageHelper(message, true);
            helper.setFrom(sendUser);
            helper.setTo("[email protected]");
            helper.setSubject("主题邮件");
            StringBuilder sb = new StringBuilder();
            sb.append("<h1>尊敬的客户您好！</h1>").append("<p>欢迎您访问我的博客 www.fishpro.com.cn</p>");
            helper.setText(sb.toString(), true);
        } catch (Exception e) {
            e.printStackTrace();
            return "fail";
        }
        mailSender.send(message);
        return "success";
    }

    /**
     * 发送附件内容
     */
    @GetMapping("/sendAttachMail")
    public String sendAttachMail() {
        MimeMessage message = null;
        try {
            message = mailSender.createMimeMessage();
            MimeMessageHelper helper = new MimeMessageHelper(message, true);
            helper.setFrom(sendUser);
            helper.setTo("[email protected]");
            helper.setSubject("主题邮件");
            StringBuilder sb = new StringBuilder();
            sb.append("<h1>尊敬的客户您好！</h1>").append("<p>欢迎您访问我的博客 www.fishpro.com.cn</p>");
            helper.setText(sb.toString(), true);
            // 获取附件资源
            FileSystemResource fileSystemResource = new FileSystemResource(new File(""));
            // 把附件资源加入到发送消息中
            helper.addAttachment("", fileSystemResource);
        } catch (Exception e) {
            e.printStackTrace();
            return "fail";
        }
        mailSender.send(message);
        return "success";
    }

    /**
     * 发送带静态资源的邮件
     */
    @GetMapping("/sendInlineMail")
    public String sendInlineMail() {
        MimeMessage message = null;
        try {
            message = mailSender.createMimeMessage();
            MimeMessageHelper helper = new MimeMessageHelper(message, true);
            helper.setFrom(sendUser);
            helper.setTo("fishpro@vip.qq.com");
            helper.setSubject("主题邮件");
            StringBuilder sb = new StringBuilder();
            sb.append("<h1>尊敬的客户您好！</h1>").append("<p>欢迎您访问我的博客 www.fishpro.com.cn</p><p><img src='cid:pic' /></p>");
            helper.setText(sb.toString(), true);
            // 获取附件资源
            FileSystemResource fileSystemResource = new FileSystemResource(new File(""));
            // 把附件资源加入到发送消息中
            helper.addInline("pic", fileSystemResource);
        } catch (Exception e) {
            e.printStackTrace();
            return "fail";
        }
        mailSender.send(message);
        return "success";
    }

    /**
     * 基于 freemarker 模板发送
     */
    @GetMapping("/sendTemplateMail")
    public String sendTemplateMail() {
        MimeMessage message = null;
        try {
            message = mailSender.createMimeMessage();
            MimeMessageHelper helper = new MimeMessageHelper(message, true);
            helper.setFrom(sendUser);
            helper.setTo("[email protected]");
            helper.setSubject("主题邮件");
            Map<String, Object> model = new HashMap<>();
            model.put("welcome", "欢迎您，hello world template email ");
            // 使用 freeMarkerConfigurer 获取模板 index.ftl
            Template template = freeMarkerConfigurer.getConfiguration().getTemplate("index.ftl");
            String html = FreeMarkerTemplateUtils.processTemplateIntoString(template, model);
            helper.setText(html, true);
        } catch (Exception e) {
            e.printStackTrace();
            return "fail";
        }
        mailSender.send(message);
        return "success";
    }
}

@Bean
public Emailer scooldEmailerBean(JavaMailSender mailSender) {
    return new ScooldEmailer(mailSender);
}

/**
 * 默认的邮件发送服务类
 *
 * @author ：enilu
 * @date ：Created in 2019/6/11 15:19
 */
@Service
public clreplaced DefaultEmailSender implements EmailSender {

    @Autowired
    private JavaMailSender javaMailSender;

    @Override
    public boolean sendEmail(String from, String to, String cc, String replacedle, String content) {
        return sendEmail(from, to, cc, replacedle, content, null, null);
    }

    @Override
    public boolean sendEmail(String from, String to, String cc, String replacedle, String content, String attachmentFilename, InputStreamSource inputStreamSource) {
        MimeMessage message = null;
        try {
            message = javaMailSender.createMimeMessage();
            MimeMessageHelper helper = new MimeMessageHelper(message, true);
            helper.setFrom(from);
            helper.setTo(to);
            if (StringUtil.isNotEmpty(cc)) {
                helper.setCc(cc);
            }
            helper.setSubject(replacedle);
            helper.setText(content, true);
            if (inputStreamSource != null) {
                helper.addAttachment(attachmentFilename, inputStreamSource);
            }
            javaMailSender.send(message);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
}

@Service
public clreplaced EmailSenderService {

    @Autowired
    private JavaMailSender mailSender;

    public void sendSimpleEmail(String toEmail, String body, String subject) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom("[email protected]");
        message.setTo(toEmail);
        message.setText(body);
        message.setSubject(subject);
        mailSender.send(message);
        System.out.println("Mail Send...");
    }

    public void sendEmailWithAttachment(String toEmail, String body, String subject, String attachment) throws MessagingException {
        MimeMessage mimeMessage = mailSender.createMimeMessage();
        MimeMessageHelper mimeMessageHelper = new MimeMessageHelper(mimeMessage, true);
        mimeMessageHelper.setFrom("[email protected]");
        mimeMessageHelper.setTo(toEmail);
        mimeMessageHelper.setText(body);
        mimeMessageHelper.setSubject(subject);
        FileSystemResource fileSystem = new FileSystemResource(new File(attachment));
        mimeMessageHelper.addAttachment(fileSystem.getFilename(), fileSystem);
        mailSender.send(mimeMessage);
        System.out.println("Mail Send...");
    }
}

@Service
public clreplaced Mail {

    private final String mailFrom;

    private final JavaMailSender emailSender;

    Mail(@Value("${mail.sender.from}") String mailFrom, JavaMailSender emailSender) {
        this.mailFrom = mailFrom;
        this.emailSender = emailSender;
    }

    public void send(String to, String subject, String text) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom(mailFrom);
        message.setTo(to);
        message.setSubject(subject);
        message.setText(text);
        emailSender.send(message);
    }
}

@Slf4j
@Service
public clreplaced EmailService {

    private final JavaMailSender sender;

    private final String senderEmail;

    @Autowired
    public EmailService(JavaMailSender sender, EmailProperties emailProperties) {
        this.sender = sender;
        this.senderEmail = emailProperties.getAddress();
        if (emailProperties.isDisabled()) {
            log.warn(ConsoleHelper.red("CONFIG (Email): Email sending is disabled"));
        }
    }

    private boolean isDisabled() {
        return !EmailConfiguration.isEmailSet();
    }

    private void setBasicInfo(MimeMessageHelper mailMessage, String from, String to, String subject, String[] bcc) throws MessagingException {
        if (isDisabled())
            return;
        mailMessage.setSubject(subject);
        mailMessage.setFrom(from);
        mailMessage.setTo(to);
        if (bcc != null)
            mailMessage.setBcc(bcc);
    }

    private MimeMessage constructEmail(String emailAddress, String subject, String body, String[] bcc) throws MessagingException {
        MimeMessage mimeMessage = sender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(mimeMessage);
        helper.setText(body);
        setBasicInfo(helper, senderEmail, emailAddress, subject, bcc);
        return mimeMessage;
    }

    private MimeMessage constructHtmlEmail(String emailAddress, String subject, String body, String[] bcc) throws MessagingException {
        MimeMessage mimeMessage = sender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true, "UTF-8");
        helper.setText(body, true);
        setBasicInfo(helper, senderEmail, emailAddress, subject, bcc);
        return mimeMessage;
    }

    private void sendMail(MimeMessage mimeMessage) throws MessagingException {
        if (isDisabled()) {
            try {
                log.warn("Skipping mail because of property override.\n" + "Sender: {}\n" + "Recipients: {}\n" + "Subject: {}\n" + "Content: {}", mimeMessage.getSender(), mimeMessage.getAllRecipients(), mimeMessage.getSubject(), mimeMessage.getContent());
            } catch (IOException e) {
                log.error("Error extracting information", e);
            }
            return;
        }
        if (Strings.isNullOrEmpty(senderEmail)) {
            log.error("Sender Email not configured. Skipping...");
        }
        sender.send(mimeMessage);
        log.debug("Mail Sent!");
    }

    void sendHtmlMail(String email, String subject, String html, String[] bcc) {
        try {
            sendMail(constructHtmlEmail(email, subject, html, bcc));
        } catch (MessagingException e) {
            log.error("Error sending mail", e);
        }
    }

    void sendHtmlMail(String email, String subject, String html) {
        sendHtmlMail(email, subject, html, null);
    }

    public void sendSimpleMail(String email, String subject, String message) {
        try {
            sendMail(constructEmail(email, subject, message, null));
        } catch (MessagingException e) {
            log.error("Error sending mail", e);
        }
    }
}

/**
 * @author: zcbin
 * @replacedle: MailServiceImpl
 * @packageName: com.zcb.minimallwxapi.mail.impl
 * @projectName: minimall
 * @description:
 * @date: 2020/5/25 14:37
 */
@Service
public clreplaced MailServiceImpl implements MailService {

    @Autowired
    private JavaMailSender mailSender;

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

    /**
     * 发送文本邮件
     *
     * @param to      收件人地址
     * @param subject 邮件主题
     * @param content 邮件内容
     * @param cc      抄送地址
     */
    @Override
    public void sendSimpleMail(String to, String subject, String content, String... cc) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom(from);
        message.setTo(to);
        message.setSubject(subject);
        message.setText(content);
        if (ArrayUtil.isNotEmpty(cc)) {
            message.setCc(cc);
        }
        mailSender.send(message);
    }

    /**
     * 发送HTML邮件
     *
     * @param to      收件人地址
     * @param subject 邮件主题
     * @param content 邮件内容
     * @param cc      抄送地址
     * @throws MessagingException 邮件发送异常
     */
    @Override
    public void sendHtmlMail(String to, String subject, String content, String... cc) throws MessagingException {
        MimeMessage message = mailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, true);
        helper.setFrom(from);
        helper.setTo(to);
        helper.setSubject(subject);
        helper.setText(content, true);
        if (ArrayUtil.isNotEmpty(cc)) {
            helper.setCc(cc);
        }
        mailSender.send(message);
    }

    /**
     * 发送带附件的邮件
     *
     * @param to       收件人地址
     * @param subject  邮件主题
     * @param content  邮件内容
     * @param filePath 附件地址
     * @param cc       抄送地址
     * @throws MessagingException 邮件发送异常
     */
    @Override
    public void sendAttachmentsMail(String to, String subject, String content, String filePath, String... cc) throws MessagingException {
        MimeMessage message = mailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, true);
        helper.setFrom(from);
        helper.setTo(to);
        helper.setSubject(subject);
        helper.setText(content, true);
        if (ArrayUtil.isNotEmpty(cc)) {
            helper.setCc(cc);
        }
        FileSystemResource file = new FileSystemResource(new File(filePath));
        String fileName = filePath.substring(filePath.lastIndexOf(File.separator));
        helper.addAttachment(fileName, file);
        mailSender.send(message);
    }

    /**
     * 发送正文中有静态资源的邮件
     *
     * @param to      收件人地址
     * @param subject 邮件主题
     * @param content 邮件内容
     * @param rscPath 静态资源地址
     * @param rscId   静态资源id
     * @param cc      抄送地址
     * @throws MessagingException 邮件发送异常
     */
    @Override
    public void sendResourceMail(String to, String subject, String content, String rscPath, String rscId, String... cc) throws MessagingException {
        MimeMessage message = mailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, true);
        helper.setFrom(from);
        helper.setTo(to);
        helper.setSubject(subject);
        helper.setText(content, true);
        if (ArrayUtil.isNotEmpty(cc)) {
            helper.setCc(cc);
        }
        FileSystemResource res = new FileSystemResource(new File(rscPath));
        helper.addInline(rscId, res);
        mailSender.send(message);
    }
}

@Service
public clreplaced MailService {

    @Autowired
    private JavaMailSender mailSender;

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

    @Async
    public void sendMail(String replacedle, String content, String email) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom(from);
        message.setSubject(replacedle);
        message.setTo(email);
        message.setText(content);
        mailSender.send(message);
    }
}

@RunWith(SpringJUnit4ClreplacedRunner.clreplaced)
@SpringBootTest
public clreplaced ApplicationTests {

    @Autowired
    private JavaMailSender mailSender;

    @Test
    public void sendSimpleMail() throws Exception {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom("[email protected]");
        message.setTo("[email protected]");
        message.setSubject("主题：这是一封测试邮件！");
        message.setText("测试邮件内容");
        mailSender.send(message);
        System.out.println("发送成功！");
    }
}

@Test
public void testMailProviderRecreatedOnRefresh() {
    replacedertFalse(providerService.isTenantMailSenderExists(TENANT));
    providerService.onRefresh("/config/tenants/TEST/mail-config.yml", mailConfig);
    replacedertTrue(providerService.isTenantMailSenderExists(TENANT));
    JavaMailSender mailSender1 = providerService.getJavaMailSender(TENANT);
    providerService.onRefresh("/config/tenants/TEST/mail-config.yml", mailConfig);
    replacedertTrue(providerService.isTenantMailSenderExists(TENANT));
    JavaMailSender mailSender2 = providerService.getJavaMailSender(TENANT);
    replacedertNotNull(mailSender1);
    replacedertNotNull(mailSender2);
    replacedertNotEquals(mailSender1, mailSender2);
}

/**
 * <p>
 * 邮件接口
 * </p>
 *
 * @author yangkai.shen
 * @date Created in 2018-11-21 13:49
 */
@Service
public clreplaced MailServiceImpl implements MailService {

    @Autowired
    private JavaMailSender mailSender;

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

    /**
     * 发送文本邮件
     *
     * @param to      收件人地址
     * @param subject 邮件主题
     * @param content 邮件内容
     * @param cc      抄送地址
     */
    @Override
    public void sendSimpleMail(String to, String subject, String content, String... cc) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom(from);
        message.setTo(to);
        message.setSubject(subject);
        message.setText(content);
        if (ArrayUtil.isNotEmpty(cc)) {
            message.setCc(cc);
        }
        mailSender.send(message);
    }

    /**
     * 发送HTML邮件
     *
     * @param to      收件人地址
     * @param subject 邮件主题
     * @param content 邮件内容
     * @param cc      抄送地址
     * @throws MessagingException 邮件发送异常
     */
    @Override
    public void sendHtmlMail(String to, String subject, String content, String... cc) throws MessagingException {
        MimeMessage message = mailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, true);
        helper.setFrom(from);
        helper.setTo(to);
        helper.setSubject(subject);
        helper.setText(content, true);
        if (ArrayUtil.isNotEmpty(cc)) {
            helper.setCc(cc);
        }
        mailSender.send(message);
    }

    /**
     * 发送带附件的邮件
     *
     * @param to       收件人地址
     * @param subject  邮件主题
     * @param content  邮件内容
     * @param filePath 附件地址
     * @param cc       抄送地址
     * @throws MessagingException 邮件发送异常
     */
    @Override
    public void sendAttachmentsMail(String to, String subject, String content, String filePath, String... cc) throws MessagingException {
        MimeMessage message = mailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, true);
        helper.setFrom(from);
        helper.setTo(to);
        helper.setSubject(subject);
        helper.setText(content, true);
        if (ArrayUtil.isNotEmpty(cc)) {
            helper.setCc(cc);
        }
        FileSystemResource file = new FileSystemResource(new File(filePath));
        String fileName = filePath.substring(filePath.lastIndexOf(File.separator));
        helper.addAttachment(fileName, file);
        mailSender.send(message);
    }

    /**
     * 发送正文中有静态资源的邮件
     *
     * @param to      收件人地址
     * @param subject 邮件主题
     * @param content 邮件内容
     * @param rscPath 静态资源地址
     * @param rscId   静态资源id
     * @param cc      抄送地址
     * @throws MessagingException 邮件发送异常
     */
    @Override
    public void sendResourceMail(String to, String subject, String content, String rscPath, String rscId, String... cc) throws MessagingException {
        MimeMessage message = mailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, true);
        helper.setFrom(from);
        helper.setTo(to);
        helper.setSubject(subject);
        helper.setText(content, true);
        if (ArrayUtil.isNotEmpty(cc)) {
            helper.setCc(cc);
        }
        FileSystemResource res = new FileSystemResource(new File(rscPath));
        helper.addInline(rscId, res);
        mailSender.send(message);
    }
}

@Component
public clreplaced MailHelper {

    @Autowired
    private JavaMailSender mailSender;

    public void sendSimpleMail(String from, String to, String subject, String content) throws Exception {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom(from);
        message.setTo(to);
        message.setSubject(subject);
        message.setText(content);
        mailSender.send(message);
    }
}

/**
 * <pre>
 *  Email发送业务类
 * </pre>
 *
 * <pre>
 * @author mazq
 * 修改记录
 *    修改后版本:     修改人：  修改日期: 2020/07/22 16:15  修改内容:
 * </pre>
 */
@Service
public clreplaced EmailService {

    @Autowired
    MailProperties mailProperties;

    @Autowired
    JavaMailSender javaMailSender;

    /**
     *  发送文本邮件
     * @Author mazq
     * @Date 2020/07/22 16:31
     * @Param [email]
     * @return
     */
    public void sendTextMail(EmailDto email) {
        SimpleMailMessage mailMessage = new SimpleMailMessage();
        mailMessage.setTo(email.getSendTo());
        mailMessage.setSubject(email.getSubject());
        mailMessage.setText(email.getContent());
        mailMessage.setFrom(mailProperties.getUsername());
        javaMailSender.send(mailMessage);
    }

    /**
     *  发送Html邮件
     * @Author mazq
     * @Date 2020/07/22 16:31
     * @Param [email]
     * @return
     */
    public void sendHtmlMail(EmailDto email) throws MessagingException {
        MimeMessage mailMessage = javaMailSender.createMimeMessage();
        MimeMessageHelper messageHelper = new MimeMessageHelper(mailMessage, true);
        messageHelper.setTo(email.getSendTo());
        messageHelper.setSubject(email.getSubject());
        messageHelper.setText(email.getContent(), true);
        messageHelper.setFrom(mailProperties.getUsername());
        javaMailSender.send(mailMessage);
    }

    /**
     *  发送附件邮件
     * @Author mazq
     * @Date 2020/07/22 16:31
     * @Param [email]
     * @return
     */
    public void sendAttachmentMail(EmailDto email) throws MessagingException {
        MimeMessage mailMessage = javaMailSender.createMimeMessage();
        MimeMessageHelper messageHelper = new MimeMessageHelper(mailMessage, true);
        messageHelper.setTo(email.getSendTo());
        messageHelper.setSubject(email.getSubject());
        messageHelper.setText(email.getContent(), true);
        messageHelper.setFrom(mailProperties.getUsername());
        for (String filePath : email.getFilePaths()) {
            FileSystemResource fileSystemResource = new FileSystemResource(new File(filePath));
            messageHelper.addAttachment(fileSystemResource.getFilename(), fileSystemResource);
        }
        javaMailSender.send(mailMessage);
    }

    /**
     *  发送html内嵌图片邮件
     * @Author mazq
     * @Date 2020/07/22 16:31
     * @Param [email]
     * @return
     */
    public void sendInLineImgMail(EmailDto email) throws MessagingException {
        MimeMessage mailMessage = javaMailSender.createMimeMessage();
        MimeMessageHelper messageHelper = new MimeMessageHelper(mailMessage, true);
        messageHelper.setTo(email.getSendTo());
        messageHelper.setSubject(email.getSubject());
        messageHelper.setText(email.getContent(), true);
        messageHelper.setFrom(mailProperties.getUsername());
        FileSystemResource fileSystemResource = new FileSystemResource(new File(email.getInlineImgPath()));
        messageHelper.addInline(email.getInlineImgId(), fileSystemResource);
        javaMailSender.send(mailMessage);
    }
}

@Service
public clreplaced MailSenderService {

    private JavaMailSender javaMailSender;

    @Autowired
    public MailSenderService(JavaMailSender javaMailSender) {
        this.javaMailSender = javaMailSender;
    }

    @Value("${email.from.address}")
    private String fromAddress;

    public void sendMail(SendEmailRequest emailRequest) throws MessagingException {
        sendMailMultipart(emailRequest.getEmail(), emailRequest.getSubject(), emailRequest.getMessage(), null);
    }

    public void sendMail(SendEmailRequest emailRequest, File file) throws MessagingException {
        sendMailMultipart(emailRequest.getEmail(), emailRequest.getSubject(), emailRequest.getMessage(), file);
    }

    private void sendMailMultipart(String toEmail, String subject, String message, File file) throws MessagingException {
        MimeMessage mimeMessage = javaMailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true);
        helper.setFrom(fromAddress);
        helper.setTo(toEmail);
        helper.setSubject(subject);
        helper.setText(message);
        if (file != null) {
            helper.addAttachment(file.getName(), file);
        }
        javaMailSender.send(mimeMessage);
    }
}

@Service
public clreplaced MailService {

    private final Logger log = LoggerFactory.getLogger(getClreplaced());

    private JavaMailSender mailSender;

    private MailContentBuilderService mailContentBuilderService;

    @Autowired
    public MailService(JavaMailSender mailSender, MailContentBuilderService mailContentBuilderService) {
        this.mailSender = mailSender;
        this.mailContentBuilderService = mailContentBuilderService;
    }

    public void prepareAndSendMail(String cc, String from, List<String> to, String subject, String mailMessageUrlOrBody, Map<String, Object> placeholderValues, final String attachmentUrl, final Boolean isPlainMessage) throws Exception {
        mailSender.send(buildMimeMessagePreparator(cc, from, to, subject, mailMessageUrlOrBody, placeholderValues, attachmentUrl, isPlainMessage));
    }

    public void prepareTemplateAndSendMail(String from, List<String> to, String subject, String mailMessageUrlOrBody, Map<String, Object> placeholderValues, final String attachmentUrl, final Boolean isPlainMessage) throws Exception {
        mailSender.send(prepareTemplateBuildMimeMessagePreparator(from, to, subject, mailMessageUrlOrBody, placeholderValues, attachmentUrl, isPlainMessage));
    }

    public void prepareTemplateAndSendMail(String from, List<String> to, String subject, String mailContent, final String attachmentUrl) throws Exception {
        mailSender.send(buildMimeMessagePreparator(from, to, subject, mailContent, attachmentUrl));
    }

    private MimeMessagePreparator buildMimeMessagePreparator(String cc, String from, List<String> to, String subject, String mailMessageUrlOrBody, Map<String, Object> placeholderValues, final String attachmentUrl, final Boolean isPlainMessage) {
        MimeMessagePreparator messagePreparator = mimeMessage -> {
            MimeMessageHelper messageHelper = new MimeMessageHelper(mimeMessage, true);
            messageHelper.setFrom(from);
            if (!StringUtils.isEmpty(cc)) {
                messageHelper.setCc(cc);
            }
            String[] toMailList = to.toArray(new String[to.size()]);
            messageHelper.setTo(toMailList);
            messageHelper.setSubject(subject);
            if (StringUtils.isNotEmpty(attachmentUrl) && isHttpUrl(attachmentUrl)) {
                URL url = new URL(attachmentUrl);
                String filename = url.getFile();
                byte[] fileContent = getFileContent(url);
                messageHelper.addAttachment(filename, new ByteArrayResource(fileContent));
            }
            String content = StringUtils.EMPTY;
            if (isPlainMessage) {
                content = mailContentBuilderService.buildPlainTextMail(mailMessageUrlOrBody, placeholderValues);
            } else {
                if (!isHttpUrl(mailMessageUrlOrBody)) {
                    File template = new ClreplacedPathResource("templates/".concat(mailMessageUrlOrBody).concat(".html")).getFile();
                    content = mailContentBuilderService.buildPlainTextMail(FileUtils.readFileToString(template, "UTF-8"), placeholderValues);
                } else {
                    String mailBody = mailContentBuilderService.getRemoteMailContent(mailMessageUrlOrBody);
                    content = mailContentBuilderService.buildPlainTextMail(mailBody, placeholderValues);
                }
            }
            messageHelper.setText(content, true);
        };
        return messagePreparator;
    }

    private MimeMessagePreparator prepareTemplateBuildMimeMessagePreparator(String from, List<String> to, String subject, String mailMessageUrlOrBody, Map<String, Object> templateModelValues, final String attachmentUrl, final Boolean isPlainMessage) {
        MimeMessagePreparator messagePreparator = mimeMessage -> {
            MimeMessageHelper messageHelper = new MimeMessageHelper(mimeMessage, true);
            messageHelper.setFrom(from);
            String[] toMailList = to.toArray(new String[to.size()]);
            messageHelper.setTo(toMailList);
            messageHelper.setSubject(subject);
            if (StringUtils.isNotEmpty(attachmentUrl) && isHttpUrl(attachmentUrl)) {
                URL url = new URL(attachmentUrl);
                String filename = url.getFile();
                byte[] fileContent = getFileContent(url);
                messageHelper.addAttachment(filename, new ByteArrayResource(fileContent));
            }
            String content = StringUtils.EMPTY;
            if (isPlainMessage) {
                content = mailContentBuilderService.buildPlainTextMail(mailMessageUrlOrBody, templateModelValues);
            } else {
                if (!isHttpUrl(mailMessageUrlOrBody)) {
                    File template = new ClreplacedPathResource("templates/".concat(mailMessageUrlOrBody).concat(".html")).getFile();
                    content = mailContentBuilderService.buildPlainTextMail(FileUtils.readFileToString(template, "UTF-8"), templateModelValues);
                } else {
                    content = processTemplate(mailMessageUrlOrBody, templateModelValues);
                }
            }
            messageHelper.setText(content, true);
        };
        return messagePreparator;
    }

    private MimeMessagePreparator buildMimeMessagePreparator(String from, List<String> to, String subject, String mailContent, final String attachmentUrl) {
        MimeMessagePreparator messagePreparator = mimeMessage -> {
            MimeMessageHelper messageHelper = new MimeMessageHelper(mimeMessage, true);
            messageHelper.setFrom(from);
            String[] toMailList = to.toArray(new String[to.size()]);
            messageHelper.setTo(toMailList);
            messageHelper.setSubject(subject);
            messageHelper.setText(mailContent, true);
            if (StringUtils.isNotEmpty(attachmentUrl) && isHttpUrl(attachmentUrl)) {
                URL url = new URL(attachmentUrl);
                String filename = url.getFile();
                byte[] fileContent = getFileContent(url);
                messageHelper.addAttachment(filename, new ByteArrayResource(fileContent));
            }
        };
        return messagePreparator;
    }

    @SuppressWarnings("deprecation")
    public String processTemplate(String templateUrl, Map<String, Object> model) {
        try {
            if (templateUrl != null) {
                String mailBody = mailContentBuilderService.getRemoteMailContent(templateUrl);
                Configuration cfg = new Configuration();
                cfg.setObjectWrapper(new DefaultObjectWrapper());
                Template t = new Template(UUID.randomUUID().toString(), new StringReader(mailBody), cfg);
                Writer out = new StringWriter();
                t.process(model, out);
                return out.toString();
            }
        } catch (Exception exception) {
            Log.error(exception.getMessage());
        }
        return null;
    }

    private byte[] getFileContent(URL attachmentUrl) throws IOException {
        HttpURLConnection connection = (HttpURLConnection) attachmentUrl.openConnection();
        InputStream inputStream = connection.getInputStream();
        /* String filename = attachmentUrl.getFile();
        filename = filename.substring(filename.lastIndexOf('/') + 1);*/
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        IOUtils.copy(inputStream, baos);
        inputStream.close();
        baos.close();
        return baos.toByteArray();
    }

    private boolean isHttpUrl(String url) {
        return new UrlValidator().isValid(url);
    }
}

public clreplaced MailNotifierTest {

    private final Instance instance = Instance.create(InstanceId.of("cafebabe")).register(Registration.create("application-name", "http://localhost:8081/actuator/health").managementUrl("http://localhost:8081/actuator").serviceUrl("http://localhost:8081/").build());

    private JavaMailSender sender;

    private MailNotifier notifier;

    private InstanceRepository repository;

    @Before
    public void setup() {
        repository = mock(InstanceRepository.clreplaced);
        when(repository.find(instance.getId())).thenReturn(Mono.just(instance));
        sender = mock(JavaMailSender.clreplaced);
        when(sender.createMimeMessage()).thenAnswer(args -> new MimeMessage(Session.getInstance(new Properties())));
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        ClreplacedLoaderTemplateResolver resolver = new ClreplacedLoaderTemplateResolver();
        resolver.setTemplateMode(TemplateMode.HTML);
        resolver.setCharacterEncoding(StandardCharsets.UTF_8.name());
        templateEngine.addTemplateResolver(resolver);
        notifier = new MailNotifier(sender, repository, templateEngine);
        notifier.setTo(new String[] { "[email protected]" });
        notifier.setCc(new String[] { "[email protected]" });
        notifier.setFrom("SBA <[email protected]>");
        notifier.setBaseUrl("http://localhost:8080");
        notifier.setTemplate("/META-INF/spring-boot-admin-server/mail/status-changed.html");
    }

    @Test
    public void should_send_mail_using_default_template() throws IOException, MessagingException {
        Map<String, Object> details = new HashMap<>();
        details.put("Simple Value", 1234);
        details.put("Complex Value", singletonMap("Nested Simple Value", "99!"));
        StepVerifier.create(notifier.notify(new InstanceStatusChangedEvent(instance.getId(), instance.getVersion(), StatusInfo.ofDown(details)))).verifyComplete();
        ArgumentCaptor<MimeMessage> mailCaptor = ArgumentCaptor.forClreplaced(MimeMessage.clreplaced);
        verify(sender).send(mailCaptor.capture());
        MimeMessage mail = mailCaptor.getValue();
        replacedertThat(mail.getSubject()).isEqualTo("application-name (cafebabe) is DOWN");
        replacedertThat(mail.getRecipients(Message.RecipientType.TO)).containsExactly(new InternetAddress("[email protected]"));
        replacedertThat(mail.getRecipients(Message.RecipientType.CC)).containsExactly(new InternetAddress("[email protected]"));
        replacedertThat(mail.getFrom()).containsExactly(new InternetAddress("SBA <[email protected]>"));
        replacedertThat(mail.getDataHandler().getContentType()).isEqualTo("text/html;charset=UTF-8");
        String body = extractBody(mail.getDataHandler());
        replacedertThat(body).isEqualTo(loadExpectedBody("expected-default-mail"));
    }

    @Test
    public void should_send_mail_using_custom_template_with_additional_properties() throws IOException, MessagingException {
        notifier.setTemplate("/de/codecentric/boot/admin/server/notify/custom-mail.html");
        notifier.getAdditionalProperties().put("customProperty", "HELLO WORLD!");
        StepVerifier.create(notifier.notify(new InstanceStatusChangedEvent(instance.getId(), instance.getVersion(), StatusInfo.ofDown()))).verifyComplete();
        ArgumentCaptor<MimeMessage> mailCaptor = ArgumentCaptor.forClreplaced(MimeMessage.clreplaced);
        verify(sender).send(mailCaptor.capture());
        MimeMessage mail = mailCaptor.getValue();
        String body = extractBody(mail.getDataHandler());
        replacedertThat(body).isEqualTo(loadExpectedBody("expected-custom-mail"));
    }

    // The following tests are rather for AbstractNotifier
    @Test
    public void should_not_send_mail_when_disabled() {
        notifier.setEnabled(false);
        StepVerifier.create(notifier.notify(new InstanceStatusChangedEvent(instance.getId(), instance.getVersion(), StatusInfo.ofUp()))).verifyComplete();
        verifyNoMoreInteractions(sender);
    }

    @Test
    public void should_not_send_when_unknown_to_up() {
        StepVerifier.create(notifier.notify(new InstanceStatusChangedEvent(instance.getId(), instance.getVersion(), StatusInfo.ofUp()))).verifyComplete();
        verifyNoMoreInteractions(sender);
    }

    @Test
    public void should_not_send_on_wildcard_ignore() {
        notifier.setIgnoreChanges(new String[] { "*:UP" });
        StepVerifier.create(notifier.notify(new InstanceStatusChangedEvent(instance.getId(), instance.getVersion(), StatusInfo.ofUp()))).verifyComplete();
        verifyNoMoreInteractions(sender);
    }

    @Test
    public void should_not_propagate_error() {
        Notifier notifier = new AbstractStatusChangeNotifier(repository) {

            @Override
            protected Mono<Void> doNotify(InstanceEvent event, Instance application) {
                return Mono.error(new IllegalStateException("test"));
            }
        };
        StepVerifier.create(notifier.notify(new InstanceStatusChangedEvent(instance.getId(), instance.getVersion(), StatusInfo.ofUp()))).verifyComplete();
    }

    private String loadExpectedBody(String resource) throws IOException {
        return StreamUtils.copyToString(this.getClreplaced().getResourcereplacedtream(resource), StandardCharsets.UTF_8);
    }

    private String extractBody(DataHandler dataHandler) throws IOException {
        ByteArrayOutputStream os = new ByteArrayOutputStream(4096);
        dataHandler.writeTo(os);
        return os.toString(StandardCharsets.UTF_8.name()).replaceAll("\\r?\\n", "\n");
    }
}

public clreplaced Mailer implements Serializable {

    @Autowired
    private JavaMailSender mailSender;

    @Autowired
    private MessageSource messages;

    @Autowired
    private Environment env;

    @RabbitListener(queues = "#{resendTokenMailQueue.name}")
    public void onResendVerificationToken(ResendToken resendToken) {
        // System.out.println("onResendVerificationToken is executed");
        if (resendToken != null)
            resendVerificationToken(resendToken.getUser(), resendToken.getOldToken());
    }

    public void resendVerificationToken(AppUser user, VerificationToken token) {
        final SimpleMailMessage email = constructResendVerificationTokenEmail(user, token);
        System.out.println("New token is : " + token.getToken());
        if (SEND_MAIL == true)
            mailSender.send(email);
        System.out.println(email);
    }

    private final SimpleMailMessage constructResendVerificationTokenEmail(final AppUser user, final VerificationToken newToken) {
        SimpleMailMessage email = new SimpleMailMessage();
        email.setTo(user.getEmail());
        email.setSubject("Resend Registration Token");
        email.setText("New token is " + newToken.getToken());
        email.setFrom(env.getProperty("support.email"));
        return email;
    }

    @RabbitListener(queues = "#{registrationTokenMailQueue.name}")
    public void onRegistrationToken(RegistrationToken registrationToken) throws InterruptedException {
        // System.out.println("onRegistrationToken is executed");
        registrationTokenEmail(registrationToken.getEvent(), registrationToken.getUser(), registrationToken.getToken());
    }

    public void registrationTokenEmail(OnRegistrationCompleteEvent event, AppUser user, String token) {
        final SimpleMailMessage email = constructRegistrationEmailMessage(event, user, token);
        if (SEND_MAIL == true)
            mailSender.send(email);
        System.out.println(email);
    }

    private final SimpleMailMessage constructRegistrationEmailMessage(final OnRegistrationCompleteEvent event, final AppUser user, final String token) {
        final String recipientAddress = user.getEmail();
        final String subject = "Registration Confirmation";
        // final String confirmationUrl = event.getAppUrl() +
        // "/registrationConfirm.html?token=" + token;
        // final String message = messages.getMessage("message.regSucc", null,
        // event.getLocale());
        final SimpleMailMessage email = new SimpleMailMessage();
        email.setTo(recipientAddress);
        email.setSubject(subject);
        // just sending token
        email.setText("Token is " + token);
        email.setFrom(env.getProperty("support.email"));
        return email;
    }

    @RabbitListener(queues = "#{resetPreplacedwordTokenMailQueue.name}")
    public void onResetPreplacedwordToken(PreplacedwordResetToken preplacedwordResetToken) throws InterruptedException {
        // System.out.println("onRegistrationToken is executed");
        resetPreplacedwordTokenEmail(preplacedwordResetToken.getUser(), preplacedwordResetToken.getToken());
    }

    public void resetPreplacedwordTokenEmail(AppUser user, String resetPreplacedwordToken) {
        final SimpleMailMessage email = constructResetTokenEmail(user, resetPreplacedwordToken);
        if (SEND_MAIL == true)
            mailSender.send(email);
    }

    private final SimpleMailMessage constructResetTokenEmail(final AppUser user, final String preplacedwordToken) {
        SimpleMailMessage email = new SimpleMailMessage();
        email.setTo(user.getEmail());
        email.setSubject("Reset Preplacedword Token");
        email.setText("New token is " + preplacedwordToken);
        email.setFrom(env.getProperty("support.email"));
        return email;
    }
}

public clreplaced MailClient {

    private final JavaMailSender javaMailSender;

    private final Properties properties;

    private final String username;

    private final String preplacedword;

    public MailClient(Properties properties, String username, String preplacedword) {
        this.properties = properties;
        this.username = username;
        this.preplacedword = preplacedword;
        this.javaMailSender = createJavaMailSender();
    }

    public void sendMessage(String from, String to, String body) throws MessagingException {
        MimeMessage message = javaMailSender.createMimeMessage();
        message.setFrom(new InternetAddress(from));
        message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
        message.setText(body);
        javaMailSender.send(message);
    }

    public List<Message> receiveMessages() {
        Session session = Session.getInstance(properties);
        Folder folderInbox = null;
        Store store = null;
        try {
            // connects to the message store
            store = session.getStore("pop3");
            store.connect(username, preplacedword);
            // opens the inbox folder
            folderInbox = store.getFolder("INBOX");
            folderInbox.open(Folder.READ_ONLY);
            // fetches new messages from server
            Message[] messages = folderInbox.getMessages();
            return Arrays.asList(messages);
        } catch (NoSuchProviderException ex) {
            System.out.println("No provider for protocol: pop3");
            throw new RuntimeException(ex);
        } catch (MessagingException ex) {
            System.out.println("Could not connect to the message store");
            throw new RuntimeException(ex);
        } finally {
            // disconnect
            try {
                if (folderInbox != null) {
                    folderInbox.close(false);
                }
                if (store != null) {
                    store.close();
                }
            } catch (MessagingException e) {
                throw new RuntimeException(e);
            }
        }
    }

    @NotNull
    private JavaMailSenderImpl createJavaMailSender() {
        JavaMailSenderImpl javaMailSender = new JavaMailSenderImpl();
        javaMailSender.setJavaMailProperties(properties);
        javaMailSender.setUsername(username);
        javaMailSender.setPreplacedword(preplacedword);
        return javaMailSender;
    }
}

@Service
public clreplaced MailServiceImpl implements MailService {

    @Autowired
    private JavaMailSender mailSender;

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

    /**
     * 发送文本邮件
     *
     * @param to      收件人地址
     * @param subject 邮件主题
     * @param content 邮件内容
     * @param cc      抄送地址
     */
    @Override
    public void sendSimpleMail(String to, String subject, String content, String... cc) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom(from);
        message.setTo(to);
        message.setSubject(subject);
        message.setText(content);
        message.setCc(cc);
        mailSender.send(message);
    }
}

@RequiredArgsConstructor
public clreplaced EmailSmtpSender implements EmailSender {

    private final JavaMailSender emailSender;

    @SneakyThrows
    @Override
    public void sentEmail(EmailAddress to, String subject, String html, String text, EmailAddress from) {
        MimeMessage message = emailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, MimeMessageHelper.MULTIPART_MODE_MIXED_RELATED, StandardCharsets.UTF_8.name());
        helper.setTo(convert(to));
        helper.setSubject(subject);
        helper.setText(text, html);
        helper.setFrom(convert(from));
        emailSender.send(message);
    }

    @SneakyThrows
    protected InternetAddress convert(EmailAddress email) {
        return new InternetAddress(email.getEmail(), email.getName());
    }
}

/**
 * 同步发送邮件(不包含重试机制)
 */
public static boolean sendMail(JavaMailSender javaMailSender, MimeMessage message) {
    javaMailSender.send(message);
    return true;
}

See More Examples