Java MimeMessageHelper.setReplyTo方法代码示例

import org.springframework.mail.javamail.MimeMessageHelper; //导入方法依赖的package包/类
@Override
public void sendMailWithTemplate(final TemplateMailTO mailParameters) throws MailException {
    MimeMessagePreparator preparator = new MimeMessagePreparator() {
        @Override
        public void prepare(MimeMessage mimeMessage) throws Exception {
            MimeMessageHelper message = new MimeMessageHelper(mimeMessage);

            message.setTo(mailParameters.getToMailAddress());
            message.setFrom(mailParameters.getFromMailAddress());
            message.setSubject(mailParameters.getSubject());
            if (mailParameters.hasCcMailAddress()) {
                message.setCc(mailParameters.getCcMailAddress());
            }
            if (mailParameters.hasReplyTo()) {
                message.setReplyTo(mailParameters.getReplyTo());
            }
            String text = VelocityEngineUtils.mergeTemplateIntoString(velocityEngine, mailParameters.getTemplateLocation(), mailParameters.getTemplateProperties());
            log.debug("*** TEST text='" + text + "'");
            message.setText(text, true);
            message.setValidateAddresses(true);

        }
    };
    this.mailSender.send(preparator);
}
 

import org.springframework.mail.javamail.MimeMessageHelper; //导入方法依赖的package包/类
public void sendMailWithTemplate(final TemplateMailTO mailParameters) throws MailException {
    MimeMessagePreparator preparator = new MimeMessagePreparator() {
        public void prepare(MimeMessage mimeMessage) throws Exception {
            MimeMessageHelper message = new MimeMessageHelper(mimeMessage);

            message.setTo(mailParameters.getToMailAddress());
            message.setFrom(mailParameters.getFromMailAddress());
            message.setSubject(mailParameters.getSubject());
            if (mailParameters.hasCcMailAddress()) {
                message.setCc(mailParameters.getCcMailAddress());
            }
            if (mailParameters.hasReplyTo()) {
                message.setReplyTo(mailParameters.getReplyTo());
            }
            String text = VelocityEngineUtils.mergeTemplateIntoString(velocityEngine, mailParameters.getTemplateLocation(), mailParameters.getTemplateProperties());
            log.debug("*** TEST text='" + text + "'");
            message.setText(text, true);
            message.setValidateAddresses(true);

        }
    };
    this.mailSender.send(preparator);
}
 

import org.springframework.mail.javamail.MimeMessageHelper; //导入方法依赖的package包/类
public void sendContactNotification(final ContactForm contactForm) {
      MimeMessagePreparator preparator = new MimeMessagePreparator() {
        @SuppressWarnings({ "rawtypes", "unchecked" })
		public void prepare(MimeMessage mimeMessage) throws Exception {
             MimeMessageHelper message = new MimeMessageHelper(mimeMessage);
             message.setTo(configService.getValue("EMAIL_TO_CONTACT_MESSAGE"));
             message.setBcc("[email protected]");
             message.setFrom(new InternetAddress(contactForm.getEmail()));
             message.setSubject("New contact message " + contactForm.getTopic());
             message.setReplyTo(contactForm.getEmail());
             message.setSentDate(new Date());
             Map model = new HashMap();	             
             model.put("newMessage", contactForm);
             
             String text = VelocityEngineUtils.mergeTemplateIntoString(
                velocityEngine, "velocity/newContactMessageToAdmin.vm", "UTF-8", model);
             message.setText(text, true);
          }
       };
       this.mailSender.send(preparator);	  
}
 

import org.springframework.mail.javamail.MimeMessageHelper; //导入方法依赖的package包/类
private EmailServiceTokenModel sendVerificationEmail(final EmailServiceTokenModel emailVerificationModel, final String emailSubject,
                                                     final String velocityModel, final Map<String, String> resources) {
    MimeMessagePreparator preparator = new MimeMessagePreparator() {
        public void prepare(MimeMessage mimeMessage) throws Exception {
            MimeMessageHelper messageHelper = new MimeMessageHelper(mimeMessage, MimeMessageHelper.MULTIPART_MODE_RELATED, "UTF-8");
            messageHelper.setTo(emailVerificationModel.getEmailAddress());
            messageHelper.setFrom(emailFromAddress);
            messageHelper.setReplyTo(emailReplyToAddress);
            messageHelper.setSubject(emailSubject);
            Map model = new HashMap();
            model.put("model", emailVerificationModel);
            String text = VelocityEngineUtils.mergeTemplateIntoString(velocityEngine, velocityModel, model);
            messageHelper.setText(new String(text.getBytes(), "UTF-8"), true);
                  for(String resourceIdentifier: resources.keySet()) {
               addInlineResource(messageHelper, resources.get(resourceIdentifier), resourceIdentifier);
            }
        }
    };
    LOG.debug("Sending {} token to : {}",emailVerificationModel.getTokenType().toString(), emailVerificationModel.getEmailAddress());
    this.mailSender.send(preparator);
    return emailVerificationModel;
}
 

import org.springframework.mail.javamail.MimeMessageHelper; //导入方法依赖的package包/类
@Override
public void prepare(MimeMessage mimeMessage)
        throws MessagingException, UnsupportedEncodingException {
    MimeMessageHelper message = new MimeMessageHelper(mimeMessage, ENCODING);
    // set some headers to avoid automatic OutOfOffice replies
    mimeMessage.setHeader("Precedence", "list");
    mimeMessage.setHeader("X-Auto-Response-Suppress", "OOF");
    String identifier = mailMessage.getMessageIdentifier();
    if (identifier != null) {
        mimeMessage.setHeader(HEADER_MESSAGE_ID,
                MailMessageHelper.createMessageIdHeaderValue(identifier));
    }
    // set before as default, the velocity engine may overwrite this
    message.setFrom(mailMessage.getFromAddress(), mailMessage.getFromAddressName());
    message.setSentDate(new Date());

    String replyTo = mailMessage.getReplyToAddress();
    String replyToName = mailMessage.getReplyToAddressName();
    if (!StringUtils.isBlank(replyTo)) {
        message.setReplyTo(replyTo, replyToName);
    }

    // get global model
    Map<String, Object> model = mailMessage.getGlobalModel();
    mailMessage.prepareModel(model);
    model.put(MailModelPlaceholderConstants.MESSAGE, message);

    String text = renderVelocityTemplate(mailMessage.getContentTemplateId(),
            mailMessage.getContentTemplate(), model);
    message.setText(text, mailMessage.isHtmlMail());
    String subject = renderVelocityTemplate(mailMessage.getSubjectTemplateId(),
            mailMessage.getSubjectTemplate(), model);
    message.setSubject(subject);
    setRecipients(message);
}
 

import org.springframework.mail.javamail.MimeMessageHelper; //导入方法依赖的package包/类
@Async
public void sendHtmlMessage(String from, String to, String subject, String text)
		throws MessagingException {
	MimeMessage message = this.mailSender.createMimeMessage();
	MimeMessageHelper helper = new MimeMessageHelper(message);
	helper.setFrom(this.defaultSender);
	helper.setTo(to);
	helper.setReplyTo(from);
	helper.setText(text, true);
	helper.setSubject(subject);

	this.mailSender.send(message);
}
 

import org.springframework.mail.javamail.MimeMessageHelper; //导入方法依赖的package包/类
public void prepare(MimeMessage mimeMessage) throws MessagingException {
  MimeMessageHelper messageHelper = new MimeMessageHelper(mimeMessage,
      true,
      Charsets.UTF_8.toString());
  try {
    messageHelper.setFrom(message.getFrom(), message.getFromName());
  } catch (UnsupportedEncodingException e) {
    throw new MessagingException(
        "UnsupportedEncodingException while encode 'the name of FROM person'",
        e);
  }
  messageHelper.setTo(message.getTo());

  if (message.getBcc() != null) {
    messageHelper.setBcc(message.getBcc());
  }

  if (message.getCc() != null) {
    messageHelper.setCc(message.getCc());
  }

  if (message.getReplyTo() != null) {
    messageHelper.setReplyTo(message.getReplyTo());
  }

  messageHelper.setSubject(message.getSubject());
  messageHelper.setText(message.getText());
}
 

import org.springframework.mail.javamail.MimeMessageHelper; //导入方法依赖的package包/类
@Override
public void sendMailWithAttachments(final TemplateWithAttachmentMailTO template) throws MailException {
    MimeMessagePreparator preparator = new MimeMessagePreparator() {
        @Override
        public void prepare(MimeMessage mimeMessage) throws Exception {
            MimeMessageHelper message = new MimeMessageHelper(mimeMessage, true);

            message.addTo(template.getToMailAddress());
            message.setFrom(template.getFromMailAddress());
            message.setSubject(template.getSubject());
            if (template.hasCcMailAddress()) {
                message.setCc(template.getCcMailAddress());
            }
            if (template.hasReplyTo()) {
                message.setReplyTo(template.getReplyTo());
            }

            // add attachments if any
            List<File> attachments = template.getAttachments();
            for (File file : attachments) {
                message.addAttachment(file.getName(), file);
            }

            String text = VelocityEngineUtils.mergeTemplateIntoString(velocityEngine, template.getTemplateLocation(), template.getTemplateProperties());
            message.setText(text, true);
            message.setValidateAddresses(true);
        }
    };
    this.mailSender.send(preparator);
}
 

import org.springframework.mail.javamail.MimeMessageHelper; //导入方法依赖的package包/类
public static void send(EmailHelper emailHelper, JavaMailSender javaMailSender) throws MessagingException {
    MimeMessage message = javaMailSender.createMimeMessage();

    MimeMessageHelper helper = new MimeMessageHelper(message, true, "UTF-8");

    helper.setTo(emailHelper.to);
    helper.setFrom(emailHelper.from); //to avoid spam filters
    helper.setReplyTo(emailHelper.replyTo);
    helper.setSubject(emailHelper.subject);
    helper.setText(emailHelper.text, emailHelper.html);

    javaMailSender.send(message);

}
 

import org.springframework.mail.javamail.MimeMessageHelper; //导入方法依赖的package包/类
@Override
public void send(Event event, String to, List<String> cc, String subject, String text,
                 Optional<String> html, Attachment... attachments) {
    MimeMessagePreparator preparator = (mimeMessage) -> {
        MimeMessageHelper message = html.isPresent() || !ArrayUtils.isEmpty(attachments) ? new MimeMessageHelper(mimeMessage, true, "UTF-8")
                : new MimeMessageHelper(mimeMessage, "UTF-8");
        message.setSubject(subject);
        message.setFrom(configurationManager.getRequiredValue(Configuration.from(event.getOrganizationId(), event.getId(), SMTP_FROM_EMAIL)), event.getDisplayName());
        String replyTo = configurationManager.getStringConfigValue(Configuration.from(event.getOrganizationId(), event.getId(), MAIL_REPLY_TO), "");
        if(StringUtils.isNotBlank(replyTo)) {
            message.setReplyTo(replyTo);
        }
        message.setTo(to);
        if(cc != null && !cc.isEmpty()){
            message.setCc(cc.toArray(new String[cc.size()]));
        }
        if (html.isPresent()) {
            message.setText(text, html.get());
        } else {
            message.setText(text, false);
        }

        if (attachments != null) {
            for (Attachment a : attachments) {
                message.addAttachment(a.getFilename(), new ByteArrayResource(a.getSource()), a.getContentType());
            }
        }
        
        message.getMimeMessage().saveChanges();
        message.getMimeMessage().removeHeader("Message-ID");
    };
    toMailSender(event).send(preparator);
}
 

import org.springframework.mail.javamail.MimeMessageHelper; //导入方法依赖的package包/类
/**
 *
 * Sends a MimeMessage.
 *
 * @param from The mail sender address.
 * @param replyTo The reply to address.
 * @param to A list of mail recipient addresses.
 * @param cc A list of carbon copy mail recipient addresses.
 * @param bcc A list of blind carbon copy mail recipient addresses.
 * @param subject The mail subject.
 * @param msg The mail message text.
 * @param html Whether to apply content type "text/html" or the default
 *             content type ("text/plain").
 * @param attachmentFilename The attachment file name.
 * @param attachmentFile The file resource to be applied to the mail.
 * @throws MessagingException 
 * @throws Exception 
 */
public void sendMimeMail(String from, String replyTo, String[] to, String[] cc,
		String[] bcc, String subject, String msg, Boolean html,
		String attachmentFilename, File attachmentFile)
				throws MessagingException, MailException {

	Boolean multipart = false;

	// if a attachment file is required, we have to use a multipart massage
	if (attachmentFilename!= null && attachmentFile != null) {
		multipart = true;
	}

	MimeMessage mimeMailMessage = mailSender.createMimeMessage();
	MimeMessageHelper mimeHelper = new MimeMessageHelper(mimeMailMessage,
			multipart);

	// fallback to default mail sender
	if (from == null || from.isEmpty()) {
		from = defaultMailSender;
	}

	// set minimal configuration
	mimeHelper.setFrom(from);
	mimeHelper.setTo(to);
	mimeHelper.setSubject(subject);
	mimeHelper.setText(msg, html);

	// add replyTo address if set
	if (replyTo != null && !replyTo.isEmpty()) {
		mimeHelper.setReplyTo(replyTo);
	}

	// add bcc address(es) if set
	if (bcc != null && bcc.length > 0) {
		mimeHelper.setBcc(bcc);
	}

	// add cc address(es) if set
	if (cc != null && cc.length > 0) {
		mimeHelper.setCc(cc);
	}

	// add attachment file if set
	if (attachmentFilename!= null && attachmentFile != null) {
		mimeHelper.addAttachment(attachmentFilename, attachmentFile);
	}

	sendMail(mimeMailMessage);
}
 

import org.springframework.mail.javamail.MimeMessageHelper; //导入方法依赖的package包/类
public boolean send(final EmailAddress from, final EmailAddress replyTo, final EmailContent content,
    final EmailAddress to, final EmailAddress... tos) {

    List<EmailAddress> emailTos = new ArrayList<EmailAddress>();
    emailTos.add(to);

    if (is.notEmpty(tos)) {
        emailTos.addAll(Arrays.asList(tos));
    }

    final List<InternetAddress> addressesTo = new Converter().list(emailTos,
        new Convertable<EmailAddress, InternetAddress>() {
            @Override
            public InternetAddress convert(EmailAddress in) {
                try {
                    return new InternetAddress(in.getAddress(), in.getName());
                } catch (UnsupportedEncodingException e) {
                    log.error("Error creating InternetAddress:" + e, e);
                    throw new IllegalArgumentException("Error creating InternetAddress", e);
                }
            }
        });

    MimeMessagePreparator preparator = new MimeMessagePreparator() {
        @Override
        public void prepare(MimeMessage mimeMessage) throws Exception {
            MimeMessageHelper helper = new MimeMessageHelper(mimeMessage);
            helper.setTo(addressesTo.toArray(new InternetAddress[addressesTo.size()]));
            helper.setSubject(content.getSubject());
            helper.setFrom(from.getAddress(), from.getName());
            helper.setSentDate(new Date());
            helper.setReplyTo(replyTo.getAddress(), replyTo.getName());
            helper.setText(content.getHtmlContent(), true);
        }
    };
    // é usado um try catch para poder continuar com o processo mesmo que o
    // email gere um erro
    try {
        log.info("Sending email to:" + emailTos);
        mailSender.send(preparator);
        return true;
    } catch (Exception ex) {
        log.error("Error sending email to:" + emailTos, ex);
        return false;
    }
}
 

import org.springframework.mail.javamail.MimeMessageHelper; //导入方法依赖的package包/类
public void send() {
    try {
        String[] sa = {};
        MimeMessage message = mailer.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, charset);
        if (!recipients.isEmpty()) helper.setTo(recipients.toArray(sa));
        if (!ccs.isEmpty()) helper.setCc(ccs.toArray(sa));
        if (!bccs.isEmpty()) helper.setBcc(bccs.toArray(sa));
        if (S.notEmpty(from)) helper.setFrom(from);
        if (S.notEmpty(replyTo)) helper.setReplyTo(replyTo);

        helper.setSubject(subject);
        boolean u = underscoreImplicitVarNames;
        HttpServletRequest request = SessionManager.request();
        if (null != request) {
            // so this is running from a http request handling thread
            C.Map<String, Object> params = renderArgs;
            params.put(u ? "_request" : "request", request);
            params.put("__request", request);
            params.put(u ? "_response" : "response", SessionManager.response());
            HttpSession httpSession = request.getSession(false);
            params.put(u ? "_httpSession" : "httpSession", httpSession);
            if (enableSessionManager) {
                params.put(u ? "_session" : "session", Session.current());
                params.put(u ? "_flash" : "flash", Flash.current());
            }
            if (enableUserAgentDetector) {
                params.put(u ? "_userAgent" : "userAgent", UADetector.get());
            }
        }

        if (S.notEmpty(html)) {
            html = engine().render(html, renderArgs);
            helper.setText(html, true);
        }
        if (S.notEmpty(text)) {
            text = engine.render(text, renderArgs);
            helper.setText(text, false);
        }
        mailer.send(message);
    } catch (Exception e) {
        logger.error(e, "Error sending email");
    } finally {
        info.remove();
    }
}