下面列出了javax.mail.Authenticator#javax.mail.Message 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
public void sendEmail(String email, String subjectline, String content) throws UnsupportedEncodingException{
try{
MimeMessage message = new MimeMessage(session);
message.setFrom(new InternetAddress(
Configurations.getConfigurationProperty("poc.cfg.property.smtp.from"),
Configurations.getConfigurationProperty("poc.cfg.property.smtp.fromName")));
message.addRecipient(Message.RecipientType.TO, new InternetAddress(email));
message.setSubject(subjectline);
if(Configurations.getConfigurationProperty("poc.cfg.property.email.type").equalsIgnoreCase("HTML")){
message.setContent(content, "text/html; charset=utf-8");
}
else{
message.setText(content);
}
Transport.send(message);
} catch (MessagingException ex) {
ex.printStackTrace();
POCLogger.logp(Level.SEVERE, CLASSNAME, "callSKFSRestApi", "POC-ERR-5001", ex.getLocalizedMessage());
}
}
@Test
public void testSuccess_simple() throws Exception {
EmailMessage content = createBuilder().build();
sendEmailService.sendEmail(content);
Message message = getMessage();
assertThat(message.getAllRecipients())
.asList()
.containsExactly(new InternetAddress("[email protected]"));
assertThat(message.getFrom())
.asList()
.containsExactly(new InternetAddress("[email protected]"));
assertThat(message.getRecipients(RecipientType.BCC)).isNull();
assertThat(message.getSubject()).isEqualTo("Subject");
assertThat(message.getContentType()).startsWith("multipart/mixed");
assertThat(getInternalContent(message).getContent().toString()).isEqualTo("body");
assertThat(getInternalContent(message).getContentType()).isEqualTo("text/plain; charset=utf-8");
assertThat(((MimeMultipart) message.getContent()).getCount()).isEqualTo(1);
}
@Test
void run_notEmptyFolderAndRepeatedMessages_shouldUpdateIndexes() throws Exception {
// Given
final FolderCrawler folderCrawler = new FolderCrawler(
imapStore, "FolderName", 0, 100, index);
final IMAPMessage message = Mockito.mock(IMAPMessage.class);
doReturn(new String[]{"1337"}).when(message).getHeader("Message-Id");
final IMAPMessage repeatedMessage = Mockito.mock(IMAPMessage.class);
doReturn(new String[]{"313373"}).when(repeatedMessage).getHeader("Message-Id");
index.getFolderMessages("FolderName").add(new MessageId(repeatedMessage));
doReturn(new Message[]{message, repeatedMessage}).when(folder).getMessages(eq(0), eq(100));
// When
folderCrawler.run();
// Then
verify(imapStore, times(1)).getFolder(eq("FolderName"));
assertThat(index.getIndexedMessageCount(), equalTo(1L));
assertThat(index.getSkippedMessageCount(), equalTo(1L));
}
private void assertSenderUnauthorized(String unauthorizedSender) throws IOException {
MimeProperties mp = new MimeProperties();
mp.subject = "Test-Unauthorized-Sender-" + System.currentTimeMillis();
mp.from = unauthorizedSender;
mp.to = getEmail("to-unauthorized-sender-test", EmailMessageField.TO);
mp.body = BODY;
MailService.Message msg = new MailService.Message();
msg.setSubject(mp.subject);
msg.setSender(mp.from);
msg.setTo(mp.to);
msg.setTextBody(BODY);
try {
mailService.send(msg);
fail("Expected IllegalArgumentException with message \"Unauthorized Sender\"");
} catch (IllegalArgumentException e) {
assertTrue("Expected IllegalArgumentException to contain \"Unauthorized Sender\"", e.getMessage().contains("Unauthorized Sender"));
}
}
@Override
protected void collectResponseParameters(Map<String, Object> responseParameters) {
List<Mail> mails = new ArrayList<Mail>();
for (Message message : messages) {
try {
Mail mail = Mail.from(message);
if (downloadAttachments) {
mail.downloadAttachments(attachmentPath);
}
mails.add(mail);
} catch (Exception e) {
LOGGER.error("exception while transforming message to dto", e);
}
}
responseParameters.put(PARAM_MAILS, mails);
mailService.flush();
}
protected String getContentText(Object content) {
if (content == null) {
return null;
}
if (content instanceof String) {
return (String) content;
} else if (content instanceof InputStream) {
return getTextFromStream((InputStream) content);
} else if (content instanceof Message) {
try {
return getTextFromStream(((Message) content).getInputStream());
} catch (Exception e) {
Debug.logError(e, module);
return null;
}
} else {
Debug.logWarning("Content was not a string or a stream; no known handler -- " + content.toString(), module);
return null;
}
}
@Override
public void sendMessage(Message message, Address[] addresses) throws MessagingException {
if ("fail".equals(message.getSubject())) {
throw new MessagingException("failed");
}
if (!ObjectUtils.nullSafeEquals(addresses, message.getAllRecipients())) {
throw new MessagingException("addresses not correct");
}
if (message.getSentDate() == null) {
throw new MessagingException("No sentDate specified");
}
if (message.getSubject() != null && message.getSubject().contains("custom")) {
assertEquals(new GregorianCalendar(2005, 3, 1).getTime(), message.getSentDate());
}
this.sentMessages.add(message);
}
@Test
public void testRetrieve() throws Exception {
assertNotNull(greenMail.getPop3());
final String subject = GreenMailUtil.random();
final String body = GreenMailUtil.random() + "\r\n" + GreenMailUtil.random() + "\r\n" + GreenMailUtil.random();
String to = "[email protected]";
GreenMailUtil.sendTextEmailTest(to, "[email protected]", subject, body);
greenMail.waitForIncomingEmail(5000, 1);
try (Retriever retriever = new Retriever(greenMail.getPop3())) {
Message[] messages = retriever.getMessages(to);
assertEquals(1, messages.length);
assertEquals(subject, messages[0].getSubject());
assertEquals(body, GreenMailUtil.getBody(messages[0]).trim());
// UID
POP3Folder f = (POP3Folder) messages[0].getFolder();
assertNotEquals("UNKNOWN", f.getUID(messages[0]));
}
}
@Test
public void javaMailSenderWithMimeMessage() throws MessagingException {
MockJavaMailSender sender = new MockJavaMailSender();
sender.setHost("host");
sender.setUsername("username");
sender.setPassword("password");
MimeMessage mimeMessage = sender.createMimeMessage();
mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress("[email protected]"));
sender.send(mimeMessage);
assertEquals("host", sender.transport.getConnectedHost());
assertEquals("username", sender.transport.getConnectedUsername());
assertEquals("password", sender.transport.getConnectedPassword());
assertTrue(sender.transport.isCloseCalled());
assertEquals(1, sender.transport.getSentMessages().size());
assertEquals(mimeMessage, sender.transport.getSentMessage(0));
}
@Test
public void writeResolvedEmailTest() throws Exception {
Alert openAlert = JvmGarbageCollectionData.getOpenAlert();
Alert ackAlert = JvmGarbageCollectionData.ackAlert(openAlert);
Alert resolvedAlert = JvmGarbageCollectionData.resolveAlert(ackAlert);
Action resolvedAction = new Action(resolvedAlert.getTriggerId(), "email", "email-to-test", resolvedAlert);
resolvedAction.setProperties(properties);
ActionMessage resolvedMessage = new TestActionMessage(resolvedAction);
Message email = plugin.createMimeMessage(resolvedMessage);
assertNotNull(email);
writeEmailFile(email, this.getClass().getSimpleName() + "-3-resolved.eml");
plugin.process(resolvedMessage);
// Test generates 2 messages on the mail server
assertEquals(2, server.getReceivedMessages().length);
}
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;
}
}
@Test
public void testAllowedHeaders() throws Exception {
assumeEnvironment(Environment.APPSPOT, Environment.CAPEDWARF);
MimeProperties mp = new MimeProperties();
mp.subject = "Allowed-Headers-Test-" + System.currentTimeMillis();
mp.from = getEmail("from-test-header", EmailMessageField.FROM);
mp.to = getEmail("to-test-header", EmailMessageField.TO);
mp.body = BODY;
MailService.Message msg = createMailServiceMessage(mp);
msg.setTextBody(BODY);
// https://developers.google.com/appengine/docs/java/mail/#Sending_Mail_with_Headers
Set<MailService.Header> headers = new HashSet<>();
Map<String, String> headersMap = createExpectedHeaders();
for (Map.Entry entry : headersMap.entrySet()) {
headers.add(new MailService.Header(entry.getKey().toString(), entry.getValue().toString()));
}
msg.setHeaders(headers);
mailService.send(msg);
MimeProperties receivedMp = pollForMatchingMail(mp);
assertHeadersExist(receivedMp, createExpectedHeadersVerifyList(headersMap));
}
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;
}
/**
* 过滤邮件中的 From 和 To,使邮件不允许发件人和收件人一样.
* @param message
* 邮件对象
* @throws MessagingException
* the messaging exception
*/
public static void removeDumplicate(Message message) throws MessagingException {
Address[] from = message.getFrom();
Address[] to = message.getRecipients(Message.RecipientType.TO);
Address[] cc = message.getRecipients(Message.RecipientType.CC);
Address[] bcc = message.getRecipients(Message.RecipientType.BCC);
Address[] tonew = removeDuplicate(from, to);
Address[] ccnew = removeDuplicate(from, cc);
Address[] bccnew = removeDuplicate(from, bcc);
if (tonew != null) {
message.setRecipients(Message.RecipientType.TO, tonew);
}
if (ccnew != null) {
message.setRecipients(Message.RecipientType.CC, ccnew);
}
if (bccnew != null) {
message.setRecipients(Message.RecipientType.BCC, bccnew);
}
}
/**
* Send a regular email.
*
* @param toEmail receiver's email
* @param replyTo email for reply or null
* @param subject
* @param body
*/
public static void sendEmail(String toEmail, String replyTo, String subject, String body) {
Session session = Session.getDefaultInstance(new Properties(), null);
MimeMessage message = new MimeMessage(session);
try {
message.addRecipient(Message.RecipientType.TO,
new InternetAddress(toEmail));
message.setSubject(subject);
message.setText(body);
// set email for reply
if (replyTo != null) {
message.addHeader("Reply-To", replyTo);
}
Transport.send(message);
} catch (MessagingException e){
System.err.println("Email could not be sent.");
}
}
@CoverageIgnore
public static void doSend(String subject, String messageBody, MailInfo mailInfo, Session session) {
String hostname = "";
try {
hostname = InetAddress.getLocalHost().getHostName();
} catch (Exception ignore) {}
try {
Message msg = new MimeMessage(session);
msg.setFrom(new InternetAddress(mailInfo.from, mailInfo.fromName + " " + hostname));
for (String currTo : mailInfo.to.split(",")) {
msg.addRecipient(Message.RecipientType.TO,
new InternetAddress(currTo, mailInfo.toName));
}
msg.setSubject(subject);
msg.setContent(messageBody, "text/html");
Transport.send(msg);
} catch (UnsupportedEncodingException | MessagingException e) {
LOG.error("SendMail error:", e);
}
LOG.info(String.format("Sent email from %s, to %s", mailInfo.from, mailInfo.to));
}
/**
* The match method.
*
* @param msg the date comparator is applied to this Message's
* received date
* @return true if the comparison succeeds, otherwise false
*/
@Override
public boolean match(Message msg) {
Date d;
try {
d = msg.getReceivedDate();
} catch (Exception e) {
return false;
}
if (d == null)
return false;
return d.getTime() >=
System.currentTimeMillis() - ((long)interval * 1000);
}
public static void main(String[] args) throws Exception {
final Properties props = new Properties();
props.load(ClassLoader.getSystemResourceAsStream("mail.properties"));
Session session = Session.getInstance(props, new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(props.getProperty("smtp.username"), props.getProperty("smtp.pass"));
}
});
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress(props.getProperty("address.sender")));
message.setRecipient(Message.RecipientType.TO, new InternetAddress(props.getProperty("address.recipient")));
message.setSubject("Test JavaMail");
message.setText("Hello!\n\n\tThis is a test message from JavaMail.\n\nThank you.");
Transport.send(message);
log.info("Message was sent");
}
@Test
public void writeResolvedEmailTest() throws Exception {
Alert openAlert = UrlAvailabilityData.getOpenAlert();
Alert ackAlert = UrlAvailabilityData.ackAlert(openAlert);
Alert resolvedAlert = UrlAvailabilityData.resolveAlert(ackAlert);
Action resolvedAction = new Action(resolvedAlert.getTriggerId(), "email", "email-to-test", resolvedAlert);
resolvedAction.setProperties(properties);
ActionMessage resolvedMessage = new TestActionMessage(resolvedAction);
Message email = plugin.createMimeMessage(resolvedMessage);
assertNotNull(email);
writeEmailFile(email, this.getClass().getSimpleName() + "-3-resolved.eml");
plugin.process(resolvedMessage);
// Test generates 2 messages on the mail server
assertEquals(2, server.getReceivedMessages().length);
}
@Test
public void shouldIgnoreNullCc() throws Exception {
//Arrange
when(javaMailSender.createMimeMessage()).thenReturn(new MimeMessage((Session) null));
final DefaultEmail email = DefaultEmail.builder()
.from(getCiceroMainMailAddress())
.replyTo(getCiceroSecondayMailAddress())
.to(Lists.newArrayList(new InternetAddress("[email protected]", "[email protected]", "Pomponius Attĭcus")))
.bcc(Lists.newArrayList(new InternetAddress("[email protected]", "Caius Memmius")))
.depositionNotificationTo(new InternetAddress("[email protected]", "Gaius Iulius Caesar Augustus Germanicus"))
.receiptTo(new InternetAddress("[email protected]", "Gaius Iulius Caesar Augustus Germanicus"))
.subject("Laelius de amicitia")
.body("Firmamentum autem stabilitatis constantiaeque eius, quam in amicitia quaerimus, fides est.")
.customHeaders(CUSTOM_HEADERS)
.build();
//Act
MimeMessage message = emailToMimeMessage.apply(email);
//Assert
assertions.assertThat(message.getRecipients(Message.RecipientType.CC)).isNullOrEmpty();
}
/**
* The match method.
*
* @param msg the match is applied to this Message's
* Message-ID header
* @return true if the match succeeds, otherwise false
*/
@Override
public boolean match(Message msg) {
String[] s;
try {
s = msg.getHeader("Message-ID");
} catch (Exception e) {
return false;
}
if (s == null)
return false;
for (int i=0; i < s.length; i++)
if (super.match(s[i]))
return true;
return false;
}
@Before
public void setUp() throws MessagingException, IOException {
Properties properties = new Properties();
properties.put("mail.files.path", "target" + File.separatorChar + "output");
Session session = Session.getDefaultInstance(properties);
transport = new AbstractFileTransport(session, new URLName("AbstractFileDev")) {
@Override
protected void writeMessage(Message message, OutputStream os) throws IOException, MessagingException {
// do nothing
}
@Override
protected String getFilenameExtension() {
return BASE_EXT;
}
};
cleanup();
}
protected void deleteMailsFromUserMailbox(final Properties props, final String folderName, final int start, final int deleteCount,
final String user, final String password) throws MessagingException {
final Store store = Session.getInstance(props).getStore();
store.connect(user, password);
checkStoreForTestConnection(store);
final Folder f = store.getFolder(folderName);
f.open(Folder.READ_WRITE);
final int msgCount = f.getMessageCount();
final Message[] m = deleteCount == -1 ? f.getMessages() : f.getMessages(start, Math.min(msgCount, deleteCount + start - 1));
int d = 0;
for (final Message message : m) {
message.setFlag(Flag.DELETED, true);
logger.info("Delete msgnum: {} with sid {}", message.getMessageNumber(), message.getSubject());
d++;
}
f.close(true);
logger.info("Deleted " + d + " messages");
store.close();
}
private static void sendMail()
throws MessagingException, IOException {
Session session = Session.getInstance(getMailProps(), new javax.mail.Authenticator() {
@Override
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(
getVal("username"),
getVal("password"));
}
});
session.setDebug(getBoolVal("mail.debug"));
LOG.info("Compiling Mail before Sending");
Message message = createMessage(session);
Transport transport = session.getTransport("smtp");
LOG.info("Connecting to Mail Server");
transport.connect();
LOG.info("Sending Mail");
transport.sendMessage(message, message.getAllRecipients());
transport.close();
LOG.info("Reports are sent to Mail");
clearTempZips();
}
@Override
public synchronized void copyMessages(final Message[] msgs, final Folder folder) throws MessagingException {
abortIdle();
checkOpened();
checkExists();
if (msgs == null || folder == null || msgs.length == 0) {
return;
}
if (!folder.exists()) {
throw new FolderNotFoundException(folder.getFullName() + " does not exist", folder);
}
folder.appendMessages(msgs);
}
public static void main(String[] args) throws Exception {
Properties props = new Properties();
String host = "pop.mailinator.com";
String username = "x-test-m";
String password = "mypwdxxx";
String provider = "pop3";
Session session = Session.getDefaultInstance(props, null);
Store store = session.getStore(provider);
store.connect(host, username, password);
Folder inbox = store.getFolder("INBOX");
if (inbox == null) {
System.out.println("No INBOX");
System.exit(1);
}
inbox.open(Folder.READ_ONLY);
Message[] messages = inbox.getMessages();
for (int i = 0; i < messages.length; i++) {
System.out.println("Message " + (i + 1));
messages[i].writeTo(System.out);
}
inbox.close(false);
store.close();
}
private void send(String to, String subj, String body, String contentType) throws Exception {
MimeMessage message = new MimeMessage(session);
message.setFrom(from);
message.setRecipients(Message.RecipientType.TO, InternetAddress.parse(to));
message.setSubject(subj, "UTF-8");
message.setContent(body, contentType);
try (Transport transport = session.getTransport()) {
transport.connect(host, username, password);
transport.sendMessage(message, message.getAllRecipients());
}
log.debug("Mail sent to {}. Subj: {}", to, subj);
log.trace("Mail body: {}", body);
}
private Message fetchMail(String loginId, String password) throws MessagingException, InterruptedException {
ImapServer imapd = mailMock.getImap();
Message msg = null;
while ((msg = retrieveViaImap(imapd.getBindTo(), imapd.getPort(), loginId, password)) == null) {
MILLISECONDS.sleep(100);
}
return msg;
}
@Test
public void javaMailProperties() throws MessagingException {
Properties props = new Properties();
props.setProperty("bogusKey", "bogusValue");
MockJavaMailSender sender = new MockJavaMailSender() {
@Override
protected Transport getTransport(Session sess) throws NoSuchProviderException {
assertEquals("bogusValue", sess.getProperty("bogusKey"));
return super.getTransport(sess);
}
};
sender.setJavaMailProperties(props);
sender.setHost("host");
sender.setUsername("username");
sender.setPassword("password");
MimeMessage mimeMessage = sender.createMimeMessage();
mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress("[email protected]"));
sender.send(mimeMessage);
assertEquals("host", sender.transport.getConnectedHost());
assertEquals("username", sender.transport.getConnectedUsername());
assertEquals("password", sender.transport.getConnectedPassword());
assertTrue(sender.transport.isCloseCalled());
assertEquals(1, sender.transport.getSentMessages().size());
assertEquals(mimeMessage, sender.transport.getSentMessage(0));
}
public void sendMessages(EmailProperties emailProperties, Session session, List<Message> messages) throws AlertException {
Set<String> errorMessages = new HashSet<>();
Set<String> invalidRecipients = new HashSet<>();
for (Message message : messages) {
Address[] recipients = null;
try {
recipients = message.getAllRecipients();
if (Boolean.valueOf(emailProperties.getJavamailOption(EmailPropertyKeys.JAVAMAIL_AUTH_KEY))) {
sendAuthenticated(emailProperties, message, session);
} else {
Transport.send(message);
}
} catch (MessagingException e) {
if (recipients != null) {
Stream.of(recipients).map(Address::toString).forEach(invalidRecipients::add);
}
errorMessages.add(e.getMessage());
logger.error("Could not send this email to the following recipients: {}. Reason: {}", recipients, e.getMessage());
}
}
if (!errorMessages.isEmpty()) {
String errorMessage;
if (invalidRecipients.isEmpty()) {
errorMessage = "Errors sending emails. " + StringUtils.join(errorMessages, ", ");
} else {
errorMessage = "Error sending emails to the following recipients: " + invalidRecipients;
}
throw new AlertException(errorMessage);
}
}