Java 类javax.mail.Message.RecipientType 实例源码

public void sendMessage (Message oMsg,
                         Address[] aAdrFrom, Address[] aAdrReply,
                         Address[] aAdrTo, Address[] aAdrCc, Address[] aAdrBcc)
  throws NoSuchProviderException,SendFailedException,ParseException,
         MessagingException,NullPointerException {              
  oMsg.addFrom(aAdrFrom);
  if (null==aAdrReply)
    oMsg.setReplyTo(aAdrReply);
  else
    oMsg.setReplyTo(aAdrFrom);
  if (aAdrTo!=null) oMsg.addRecipients(javax.mail.Message.RecipientType.TO, aAdrTo);
  if (aAdrCc!=null) oMsg.addRecipients(javax.mail.Message.RecipientType.CC, aAdrCc);
  if (aAdrBcc!=null) oMsg.addRecipients(javax.mail.Message.RecipientType.BCC, aAdrBcc);
  oMsg.setSentDate(new java.util.Date());
  Transport.send(oMsg);
}

private static void sendEmail(String fromEmail, String toEmail, String subject, String body, boolean html)
throws MessagingException{
    MimeMessage message = new MimeMessage(MAILING_SESSION);
    message.setFrom(new InternetAddress(fromEmail));
    InternetAddress[] addresses = InternetAddress.parse(toEmail);//one or more addresses
    message.addRecipients(RecipientType.TO, addresses);
    message.setReplyTo(addresses);
    message.setSubject(subject);
    String subType;
    if(html){
        subType = "html";
    }else{
        subType = "plain";
    }
    message.setText(body, "UTF-8", subType);
    Transport.send(message);
}

@Async("emailExecutor")
public void sendEmail(EmailVerifyCode code, User user) {
    LOGGER.info("Sending verify email to {} for {}", user.getEmail(), user.getId());
    try {
        mailSender.send(msg -> {
            msg.setFrom(emailSender());
            msg.setRecipients(RecipientType.TO, code.getEmail());
            msg.setSubject(subject());
            msg.setContent(FreeMarkerTemplateUtils.processTemplateIntoString(fmConfig.getTemplate("email/verify-code.ftl"), model(code, user)), "text/html");
        });
    } catch (Throwable e) {
        LOGGER.warn("Couldn't send verify email to {}", user.getEmail(), e);
        return;
    }
    LOGGER.info("Sent verify email to {}", user.getEmail());
}

public boolean sendMsg(String recipient, String subject, String content)
        throws MessagingException {
    // Create a mail object
    Session session = Session.getInstance(props, new Authenticator() {
        // Set the account information session，transport will send mail
        @Override
        protected PasswordAuthentication getPasswordAuthentication() {
            return new PasswordAuthentication(Constants.MAIL_USERNAME, Constants.MAIL_PASSWORD);
        }
    });
    session.setDebug(true);
    Message msg = new MimeMessage(session);
    try {
        msg.setSubject(subject);            //Set the mail subject
        msg.setContent(content,"text/html;charset=utf-8");
        msg.setFrom(new InternetAddress(Constants.MAIL_USERNAME));          //Set the sender
        msg.setRecipient(RecipientType.TO, new InternetAddress(recipient)); //Set the recipient
        Transport.send(msg);
        return true;
    } catch (Exception ex) {
        ex.printStackTrace();
        System.out.println(ex.getMessage());
        return false;
    }

}

public static void sendAccountActivateEmail(String email, String uuid, int userId) {
  Session session;
  try {
    session = getSession();
    MimeMessage message = new MimeMessage(session);
    message.setSubject("������֤��");
    message.setSentDate(new Date());
    message.setFrom(new InternetAddress(FROM));
    message.setRecipient(RecipientType.TO, new InternetAddress(email));
    message.setContent("�����û�"+userId+":������֤��Ϊ��"+uuid,
        "text/html;charset=utf-8");
    message.saveChanges();
    Transport.send(message);
  } catch (Exception e) {
    e.printStackTrace();
  }
}

@Override
public void run() {
    try {
        Multipart mainPart = new MimeMultipart("mixed");
        mainPart.addBodyPart(bodyDestination.get().getBodyPart());
        for (Future<EmailPartDocumentDestination> ad : attachmentDests) mainPart.addBodyPart(ad.get().getBodyPart());

        Message msg = tx.email.newMimeMessage();
        msg.setFrom(new InternetAddress(replacePlainTextParameters(fromPattern, params)));
        msg.addRecipient(RecipientType.TO, new InternetAddress(replacePlainTextParameters(toPattern, params)));
        msg.setSubject(replacePlainTextParameters(subjectPattern, params));
        msg.setContent(mainPart);
        msg.setSentDate(new Date());

        tx.email.send(msg);
    }
    catch (ExecutionException | InterruptedException | MessagingException e) { throw new RuntimeException(e); }
}

private String getAddresses(MimeMessage mimeMessage, RecipientType recipientType) {
    try {
        Address[] addresses = mimeMessage.getRecipients(recipientType);
        if (addresses == null) {
            return null;
        }
        StringBuilder builder = new StringBuilder();
        Address[] arrayOfAddress1;
        int j = (arrayOfAddress1 = addresses).length;
        for (int i = 0; i < j; i++) {
            Address address = arrayOfAddress1[i];
            InternetAddress ia = (InternetAddress) address;
            builder.append(ia.getAddress()).append(";");
        }
        return builder.substring(0, builder.length() - 1);
    } catch (MessagingException e) {
    }
    return "";
}

public static Mail from(Message message) throws MessagingException, IOException {
  Mail mail = new Mail();

  mail.from = InternetAddress.toString(message.getFrom());
  mail.to =  InternetAddress.toString(message.getRecipients(RecipientType.TO));
  mail.cc = InternetAddress.toString(message.getRecipients(RecipientType.CC));

  mail.subject = message.getSubject();
  mail.sentDate = message.getSentDate();
  mail.receivedDate = message.getReceivedDate();

  mail.messageNumber = message.getMessageNumber();

  if (message instanceof MimeMessage) {
    MimeMessage mimeMessage = (MimeMessage) message;
    // extract more informations
    mail.messageId = mimeMessage.getMessageID();
  }

  processMessageContent(message, mail);

  return mail;
}

protected Message createMessage(SendMailRequest request, Session session) throws Exception {

    Message message = new MimeMessage(session);
    message.setFrom(new InternetAddress(request.getFrom(), request.getFromAlias()));
    message.setRecipients(RecipientType.TO, InternetAddress.parse(request.getTo()));

    if (request.getCc() != null) {
      message.setRecipients(RecipientType.CC, InternetAddress.parse(request.getCc()));
    }
    if (request.getBcc() != null) {
      message.setRecipients(RecipientType.BCC, InternetAddress.parse(request.getBcc()));
    }

    message.setSentDate(new Date());
    message.setSubject(request.getSubject());

    if (hasContent(request)) {
      createMessageContent(message, request);
    } else {
      message.setText("");
    }

    return message;
  }

/**
 * Constructor, creates all internal lists. Populates default from, reply-to, to, cc and bcc if provided in the config file.
 */
public Email() {
    recipients = new ArrayList<>();
    embeddedImages = new ArrayList<>();
    attachments = new ArrayList<>();
    headers = new HashMap<>();

    if (hasProperty(DEFAULT_FROM_ADDRESS)) {
        setFromAddress((String) getProperty(DEFAULT_FROM_NAME), (String) getProperty(DEFAULT_FROM_ADDRESS));
    }
    if (hasProperty(DEFAULT_REPLYTO_ADDRESS)) {
        setReplyToAddress((String) getProperty(DEFAULT_REPLYTO_NAME), (String) getProperty(DEFAULT_REPLYTO_ADDRESS));
    }
    if (hasProperty(DEFAULT_TO_ADDRESS)) {
        addRecipient((String) getProperty(DEFAULT_TO_NAME), (String) getProperty(DEFAULT_TO_ADDRESS), RecipientType.TO);
    }
    if (hasProperty(DEFAULT_CC_ADDRESS)) {
        addRecipient((String) getProperty(DEFAULT_CC_NAME), (String) getProperty(DEFAULT_CC_ADDRESS), RecipientType.CC);
    }
    if (hasProperty(DEFAULT_BCC_ADDRESS)) {
        addRecipient((String) getProperty(DEFAULT_BCC_NAME), (String) getProperty(DEFAULT_BCC_ADDRESS), RecipientType.BCC);
    }
    if (hasProperty(DEFAULT_SUBJECT)) {
        setSubject((String) getProperty(DEFAULT_SUBJECT));
    }
}

/** 
 * ���������������ӵ��ʼ� 
 */  
public static void sendResetPasswordEmail(AcctUser user,String resetPassHref) {  
    Session session = getSession();  
    MimeMessage message = new MimeMessage(session);  
    try {  
        message.setSubject("�һ������ʻ�������");  
        message.setSentDate(new Date());  
        message.setFrom(new InternetAddress(FROM));  
        message.setRecipient(RecipientType.TO, new InternetAddress(user.getEmail()));  
        message.setContent("Ҫʹ���µ�����, ��ʹ������������������:<br/><a href='"+resetPassHref+"'>���������������</a> SpringBBS","text/html;charset=utf-8");  
        // �����ʼ�  
        Transport.send(message);  
    } catch (Exception e) {  
        e.printStackTrace();  
    }  
}

/**
 * Sends a link to the generated overall invoice in GCS.
 *
 * <p>Note the users receiving the e-mail should have access to the object or bucket, via an
 * authorization mechanism such as IAM.
 */
void emailInvoiceLink() {
  // TODO(larryruili): Add read permissions for appropriate buckets.
  try {
    String beamBucket = beamBucketUrl.replaceFirst("gs://", "");
    Message msg = emailService.createMessage();
    msg.setFrom(new InternetAddress(alertSenderAddress));
    for (String recipient : invoiceEmailRecipients) {
      msg.addRecipient(RecipientType.TO, new InternetAddress(recipient));
    }
    msg.setSubject(String.format("Domain Registry invoice data %s", yearMonth.toString()));
    msg.setText(
        String.format(
            "Link to invoice on GCS:\nhttps://storage.cloud.google.com/%s/%s",
            beamBucket,
            String.format(
                "%s%s-%s.csv",
                BillingModule.RESULTS_DIRECTORY_PREFIX,
                BillingModule.OVERALL_INVOICE_PREFIX,
                yearMonth.toString())));
    emailService.sendMessage(msg);
  } catch (MessagingException e) {
    // TODO(larryruili): Replace with retrier with final failure email settings.
    logger.warning(e, "E-mail service failed due to %s");
  }
}

/**
 * Address message.
 *
 * @param msg message, may not be null.
 * @throws MessagingException thrown if error addressing message.
 */
private final void addressMessage(final Message msg) throws MessagingException {

   if (from != null) {
      msg.setFrom(getAddress(from));
   } else {
      msg.setFrom();
   }

   if (to != null && !to.isEmpty()) {
      msg.setRecipients(RecipientType.TO, parseAddress(to));
   }

   //Add CC recipients if defined.
   if (cc != null && !cc.isEmpty()) {
      msg.setRecipients(RecipientType.CC, parseAddress(cc));
   }

   //Add BCC recipients if defined.
   if (bcc != null && !bcc.isEmpty()) {
      msg.setRecipients(RecipientType.BCC, parseAddress(bcc));
   }
}

/** */
   @org.junit.Test
public void testTwoLists() throws Exception
{
       Assume.assumeTrue(ResinTestSetup.exists());
    MailingListMixin ml2 = new MailingListMixin(this.admin, null);

    MimeMessage msg = this.createMimeMessage(this.pers.getAddress(), this.ml.getAddress());
    msg.addRecipient(RecipientType.TO, ml2.getAddress());
    Transport.send(msg);
    Thread.sleep(1000);

    assertEquals(0, this.fallback.getMessages().size());
    assertEquals(0, this.smtp.countSubject(TEST_SUBJECT));
    assertEquals(1, this.admin.getArchiver().countMailByList(this.ml.getId()));
    assertEquals(1, this.admin.getArchiver().countMailByList(ml2.getId()));
}

/** */
   @org.junit.Test
public void testTwoFallthroughs() throws Exception
{
       Assume.assumeTrue(ResinTestSetup.exists());
    PersonInfoMixin pers2 = new PersonInfoMixin();
    PersonInfoMixin pers3 = new PersonInfoMixin();

    MimeMessage msg = this.createMimeMessage(this.pers.getAddress(), pers2.getAddress());
    msg.addRecipient(RecipientType.TO, pers3.getAddress());
    Transport.send(msg);
    Thread.sleep(1000);

    assertEquals(2, this.fallback.getMessages().size());
    assertEquals(0, this.smtp.countSubject(TEST_SUBJECT));
    assertEquals(0, this.admin.getArchiver().countMailByList(this.ml.getId()));
}

/** */
   @org.junit.Test
public void testFallthroughPlusList() throws Exception
{
       Assume.assumeTrue(ResinTestSetup.exists());
    PersonInfoMixin pers2 = new PersonInfoMixin();

    MimeMessage msg = this.createMimeMessage(this.pers.getAddress(), this.ml.getAddress());
    msg.addRecipient(RecipientType.TO, pers2.getAddress());
    Transport.send(msg);
    Thread.sleep(1000);

    assertEquals(1, this.fallback.getMessages().size());
    assertEquals(0, this.smtp.countSubject(TEST_SUBJECT));
    assertEquals(1, this.admin.getArchiver().countMailByList(this.ml.getId()));
}

/**
 * @param name         The name to use as fixed name or as default (depending on <code>fixedName</code> flag). Regardless of that flag, if a name
 *                     is <code>null</code>, the other one will be used.
 * @param fixedName    Determines if the given name should be used as override.
 * @param emailAddress An RFC2822 compliant email address, which can contain a name inside as well.
 */
@Nonnull
public static Recipient interpretRecipient(@Nullable final String name, boolean fixedName, @Nonnull final String emailAddress, @Nullable final RecipientType type) {
    try {
        final InternetAddress parsedAddress = InternetAddress.parse(emailAddress, false)[0];
        final String relevantName = (fixedName || parsedAddress.getPersonal() == null)
                ? defaultTo(name, parsedAddress.getPersonal())
                : defaultTo(parsedAddress.getPersonal(), name);
        return new Recipient(relevantName, parsedAddress.getAddress(), type);
    } catch (final AddressException e) {
        // InternetAddress failed to parse the email address even in non-strict mode
        // just assume the address was too complex rather than plain wrong, and let our own email validation
        // library take care of it when sending the email
        return new Recipient(name, emailAddress, type);
    }
}

@Override
public void alert(AlertContext alertContext) {
    Message message = new MimeMessage(getSession());
    List<String> recipients = getRecipients(alertContext);
    Address[] addresses = parseAddresses(recipients);

    try {
        message.setRecipients(RecipientType.TO, addresses);
        message.setSubject(getSubject(alertContext));
        message.setText(getText(alertContext));

        message.setHeader("X-Mailer", getMailer());
        Date timeStamp = new Date();
        message.setSentDate(timeStamp);

        Transport.send(message);
    } catch (MessagingException e) {
        throw new RuntimeException("Could not send alert email!", e);
    }
}

/**
 * For debugging
 */
public void displayMessages() {

    try {
        Folder inbox = store.getFolder("INBOX");
        inbox.open(Folder.READ_WRITE);

        int count = inbox.getMessageCount();
        Message[] messages = inbox.getMessages(1, count);
        for (Message message : messages) {
            if (!message.getFlags().contains(Flags.Flag.SEEN)) {
                Address[] fromAddresses = message.getFrom();
                System.out.println("...................");
                System.out.println("\t From: " + fromAddresses[0].toString());
                System.out.println("\t To: " + parseAddresses(message.getRecipients(RecipientType.TO)));
                System.out.println("\t CC: " + parseAddresses(message.getRecipients(RecipientType.CC)));
                System.out.println("\t Subject: " + message.getSubject());
                System.out.println("\t Sent Date:" + message.getSentDate().toString());
                try {
                    System.out.println(message.getContent().toString());
                } catch (Exception ex) {
                    System.out.println("Error reading content!!");
                    ex.printStackTrace();
                }
            }
        }

        inbox.close(false);
        store.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

@Asynchronous
public void send(@Observes Email email) {
    try {
        MimeMessage msg = new MimeMessage(session);
        msg.setHeader("Content-Type", "text/html;charset=UTF-8");
        msg.setSubject(email.getSubject(), defaultEncoding);
        msg.setContent(email.getBody(), MediaType.TEXT_HTML);

        Address[] internetAdress;
        if (email.getAddress() != null) {
            internetAdress = new Address[email.getAddress().size()];
            for (int i = 0; i < email.getAddress().size(); i++) {
                internetAdress[i] = new InternetAddress(email.getAddress()
                        .get(i));
            }
            msg.setRecipients(RecipientType.TO, internetAdress);
        }

        Transport.send(msg);
    } catch (MessagingException e) {
        System.out.println(e);
    }
}

public boolean send(String address, String subject, String content) {

    LOG.debug("sending message [" + subject + "] to [" + address + "]");

    MimeMessage msg = sender.createMimeMessage();

    try {
        msg.setRecipient(RecipientType.TO, new InternetAddress(address));
        msg.setSubject(subject);
        msg.setText(content);

        sender.send(msg);

    } catch (Exception e) {
        LOG.error("failed sending email to [" 
                + address + "]" + " subject [" 
                + subject + "] content[" 
                + content + "]");
        return false;
    }
    return false;
}