public static void main(String[] args) {
// Get the Properties and Create a default session
Properties prop = System.getProperties();
prop.setProperty("mail.server.com", "127.0.0.1");
Session session = Session.getDefaultInstance(prop);
try {
// Set the mail headers
MimeMessage msg = new MimeMessage(session);
msg.setFrom(new InternetAddress("*****@*****.**"));
msg.addRecipient(Message.RecipientType.TO, new InternetAddress("*****@*****.**"));
msg.setSubject("First Mail");
// Create the mime body and attachments
MimeBodyPart msgBody = new MimeBodyPart();
msgBody.setContent("Hello World", "text/html");
MimeBodyPart attFile = new MimeBodyPart();
attFile.attachFile("RecvMail.java");
Multipart partMsg = new MimeMultipart();
partMsg.addBodyPart(msgBody);
partMsg.addBodyPart(attFile);
msg.setContent(partMsg);
Transport.send(msg);
System.out.println("Message Successfully sent...");
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String to = "*****@*****.**"; // change accordingly
String from = "*****@*****.**"; // change accordingly
String host = "smtp.gmail.com"; // or IP address
// Get the session object
Properties properties = System.getProperties();
properties.setProperty("mail.smtp.host", host);
Session session = Session.getDefaultInstance(properties);
// compose the message
try {
MimeMessage message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
message.setSubject("Ping");
message.setText("Hello, this is example of sending email ");
// Send message
Transport.send(message);
System.out.println("message sent successfully....");
} catch (MessagingException mex) {
mex.printStackTrace();
}
}
public static void sendMail(String mailMessage) {
String to = "*****@*****.**";
String from = "FlotaWeb";
String host = "mail.arabesque.ro";
Properties properties = System.getProperties();
properties.setProperty("mail.smtp.host", host);
Session session = Session.getDefaultInstance(properties);
try {
MimeMessage message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
message.setSubject("Distributie");
message.setText(mailMessage);
Transport.send(message);
} catch (MessagingException e) {
logger.error(Utils.getStackTrace(e));
}
}
/** Sends Emails to Customers who have not submitted their Bears */
public static void BearEmailSendMessage(String msgsubject, String msgText, String msgTo) {
try {
BearFrom = props.getProperty("BEARFROM");
// To = props.getProperty("TO");
SMTPHost = props.getProperty("SMTPHOST");
Properties mailprops = new Properties();
mailprops.put("mail.smtp.host", SMTPHost);
// create some properties and get the default Session
Session session = Session.getDefaultInstance(mailprops, null);
// create a message
Message msg = new MimeMessage(session);
// set the from
InternetAddress from = new InternetAddress(BearFrom);
msg.setFrom(from);
InternetAddress[] address = InternetAddress.parse(msgTo);
msg.setRecipients(Message.RecipientType.TO, address);
msg.setSubject(msgsubject);
msg.setContent(msgText, "text/plain");
Transport.send(msg);
} // end try
catch (MessagingException mex) {
USFEnv.getLog().writeCrit("Message not sent", null, null);
} catch (Exception ex) {
USFEnv.getLog().writeCrit("Message not sent", null, null);
}
} // end BearEmailSendMessage
public static void main(String[] args) throws MessagingException, IOException {
IMAPFolder folder = null;
Store store = null;
String subject = null;
Flag flag = null;
try {
Properties props = System.getProperties();
props.setProperty("mail.store.protocol", "imaps");
props.setProperty("mail.imap.host", "imap.googlemail.com");
SimpleAuthenticator authenticator =
new SimpleAuthenticator("*****@*****.**", "hhy8611hhyy");
Session session = Session.getDefaultInstance(props, null);
// Session session = Session.getDefaultInstance(props, authenticator);
store = session.getStore("imaps");
// store.connect("imap.googlemail.com","*****@*****.**", "hhy8611hhyy");
// store.connect("imap.googlemail.com","*****@*****.**", "hhy8611hhyy");
store.connect("*****@*****.**", "hhy8611hhy");
// folder = (IMAPFolder) store.getFolder("[Gmail]/Spam"); // This doesn't work for other email
// account
folder = (IMAPFolder) store.getFolder("inbox"); // This works for both email account
if (!folder.isOpen()) folder.open(Folder.READ_WRITE);
Message[] messages = messages = folder.getMessages(150, 150); // folder.getMessages();
System.out.println("No of get Messages : " + messages.length);
System.out.println("No of Messages : " + folder.getMessageCount());
System.out.println("No of Unread Messages : " + folder.getUnreadMessageCount());
System.out.println("No of New Messages : " + folder.getNewMessageCount());
System.out.println(messages.length);
for (int i = 0; i < messages.length; i++) {
System.out.println(
"*****************************************************************************");
System.out.println("MESSAGE " + (i + 1) + ":");
Message msg = messages[i];
// System.out.println(msg.getMessageNumber());
// Object String;
// System.out.println(folder.getUID(msg)
subject = msg.getSubject();
System.out.println("Subject: " + subject);
System.out.println("From: " + msg.getFrom()[0]);
System.out.println("To: " + msg.getAllRecipients()[0]);
System.out.println("Date: " + msg.getReceivedDate());
System.out.println("Size: " + msg.getSize());
System.out.println(msg.getFlags());
System.out.println("Body: \n" + msg.getContent());
System.out.println(msg.getContentType());
}
} finally {
if (folder != null && folder.isOpen()) {
folder.close(true);
}
if (store != null) {
store.close();
}
}
}
public void mail(String toAddress, String subject, String body) {
Properties props = new Properties();
props.put("mail.smtp.host", host);
props.put("mail.smtp.port", port);
props.put("mail.smtp.ssl.enable", true);
Authenticator authenticator = null;
if (login) {
props.put("mail.smtp.auth", true);
authenticator =
new Authenticator() {
private PasswordAuthentication pa = new PasswordAuthentication(username, password);
@Override
public PasswordAuthentication getPasswordAuthentication() {
return pa;
}
};
}
Session s = Session.getInstance(props, authenticator);
s.setDebug(debug);
MimeMessage email = new MimeMessage(s);
try {
email.setFrom(new InternetAddress(from));
email.setRecipient(Message.RecipientType.TO, new InternetAddress(toAddress));
email.setSubject(subject);
email.setSentDate(new Date());
email.setText(body);
Transport.send(email);
} catch (MessagingException ex) {
ex.printStackTrace();
}
}
public static void main(String[] args) throws MessagingException, IOException {
Properties props = new Properties();
try (InputStream in = Files.newInputStream(Paths.get("mail", "mail.properties"))) {
props.load(in);
}
List<String> lines = Files.readAllLines(Paths.get(args[0]), Charset.forName("UTF-8"));
String from = lines.get(0);
String to = lines.get(1);
String subject = lines.get(2);
StringBuilder builder = new StringBuilder();
for (int i = 3; i < lines.size(); i++) {
builder.append(lines.get(i));
builder.append("\n");
}
Console console = System.console();
String password = new String(console.readPassword("Password: "));
Session mailSession = Session.getDefaultInstance(props);
// mailSession.setDebug(true);
MimeMessage message = new MimeMessage(mailSession);
message.setFrom(new InternetAddress(from));
message.addRecipient(RecipientType.TO, new InternetAddress(to));
message.setSubject(subject);
message.setText(builder.toString());
Transport tr = mailSession.getTransport();
try {
tr.connect(null, password);
tr.sendMessage(message, message.getAllRecipients());
} finally {
tr.close();
}
}
public void send() {
// Your SMTP server address here.
String smtpHost = "myserver.jeffcorp.com";
// The sender's email address
String from = "*****@*****.**";
// The recepients email address
String to = "*****@*****.**";
Properties props = new Properties();
// The protocol to use is SMTP
props.put("mail.smtp.host", smtpHost);
Session session = Session.getDefaultInstance(props, null);
try {
InternetAddress[] address = {new InternetAddress(to)};
MimeMessage message;
message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.setRecipients(Message.RecipientType.TO, to);
message.setSubject("Hello from Jeff");
message.setSentDate(sendDate);
message.setText("Hello Jeff, \nHow are things going?");
Transport.send(message);
System.out.println("email has been sent.");
} catch (Exception e) {
System.out.println(e);
}
}
public Email() {
props = new Properties();
toList = new ArrayList<InternetAddress>();
ccList = new ArrayList<InternetAddress>();
bccList = new ArrayList<InternetAddress>();
props.put("mail.smtp.host", mailSmtpHost);
// props.put("mail.smtp.host", "mcadlx01.servers.mc.franklin.edu");
props.put("mail.user", "*****@*****.**");
Session session = Session.getInstance(props, null);
msg = new MimeMessage(session);
}
static {
properties.put("mail.smtp.auth", "true");
properties.put("mail.smtp.starttls.enable", "true");
properties.put("mail.smtp.host", "smtp.gmail.com");
properties.put("mail.smtp.port", "587");
// try {
// properties.load( new FileInputStream("mail.properties"));
// } catch (IOException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
}
protected void sendInit() throws Exception {
// Set smtp properties
Properties s_props = new Properties();
s_props.put("mail.smtp.host", mailHost);
s_props.put("mail.smtp.port", mailPort);
s_props.put("mail.smtp.connectiontimeout", mailConnTimeout);
s_props.put("mail.smtp.timeout", mailSmtpTimeout);
// Creating messaging session
Session session = Session.getInstance(s_props, null);
session.setDebug(debug);
// Creating transport object for smtp
transport = session.getTransport("smtp");
transport.connect(mailHost, mailUser, mailPass);
}
public static void sfSendEmail(String subject, String message) throws Exception {
String SMTP_HOST_NAME = "smtp.gmail.com";
String SMTP_PORT = "465";
// message = "Test Email Notification From Monitor";
// subject = "Test Email Notification From Monitor";
String from = "*****@*****.**";
String[] recipients = {
"*****@*****.**", "*****@*****.**", "*****@*****.**"
};
String SSL_FACTORY = "javax.net.ssl.SSLSocketFactory";
// String[] recipients = { "*****@*****.**"};
// String[] recipients = { "*****@*****.**", "*****@*****.**",
// "*****@*****.**", "*****@*****.**", "*****@*****.**",
// "*****@*****.**", "*****@*****.**"};
// String[] recipients = {"*****@*****.**"};
Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());
boolean debug = true;
Properties props = new Properties();
props.put("mail.smtp.host", SMTP_HOST_NAME);
props.put("mail.smtp.auth", "true");
// props.put("mail.debug", "true");
props.put("mail.smtp.port", SMTP_PORT);
props.put("mail.smtp.socketFactory.port", SMTP_PORT);
props.put("mail.smtp.socketFactory.class", SSL_FACTORY);
props.put("mail.smtp.socketFactory.fallback", "false");
Session session =
Session.getDefaultInstance(
props,
new Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(
"*****@*****.**", "els102sensorweb");
}
});
// session.setDebug(debug);
Message msg = new MimeMessage(session);
InternetAddress addressFrom = new InternetAddress(from);
msg.setFrom(addressFrom);
InternetAddress[] addressTo = new InternetAddress[recipients.length];
for (int i = 0; i < recipients.length; i++) {
addressTo[i] = new InternetAddress(recipients[i]);
}
msg.setRecipients(Message.RecipientType.TO, addressTo);
// Setting the Subject and Content Type
msg.setSubject(subject);
msg.setContent(message, "text/plain");
Transport.send(msg);
System.out.println("Sucessfully Sent mail to All Users");
}
public static Properties getProps() {
logger.log(level, "NNTP.loadMessages...");
try {
props.load(PropertiesReader.class.getResourceAsStream("/nntp.properties"));
} catch (IOException ex) {
Logger.getLogger(PropertiesReader.class.getName()).log(Level.SEVERE, null, ex);
}
// this.getClass().getResourceAsStream("/nntp.properties");
// logger.log(level, props.toString());
return props;
}
public void init() throws Exception {
// 设置属性
Properties props = new Properties();
props.put("mail.smtp.host", sendHost);
props.put("mail.smtp.auth", "true"); // SMTP服务器需要身份验证
ma =
new Authenticator() {
public PasswordAuthentication getPasswordAuthentication() {
System.out.println("call getPasswordAuthentication()");
return new PasswordAuthentication(username, password);
}
};
session = Session.getDefaultInstance(props, ma);
// 创建Store对象
store = session.getStore(receiveProtocol);
// 连接到邮件服务器上的账户
store.connect(receiveHost, null, null);
}
// Dovrebbe inviare una mail, not tested
public void inviteUser(String email) throws SQLException, EmailException {
String to;
to = testEmail(email);
String from = "*****@*****.**";
String host = "localhost"; // testing
Properties properties = System.getProperties();
properties.setProperty("mail.smtp.host", host);
Session mailSession = Session.getDefaultInstance(properties);
try {
MimeMessage message = new MimeMessage(mailSession);
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
message.setSubject("Sei stato invitato ad iscriverti a" + " Phd-platform.");
message.setText("localhost:8080/phd-platform/register.jsp"); // test
Transport.send(message);
} catch (MessagingException ex) {
ex.printStackTrace();
}
}
/**
* Create an empty MimeMessage object with all properties set
*
* @param from Sender address
* @param replyTo Reply-to address (null to omit)
* @param to Array of target addresses
* @param cc Array of CC addresses - or null
* @param subject Subject
*/
private static MimeMessage createMessage(
String from, String replyTo, String[] to, String[] cc, String subject)
throws MessagingException {
Properties p = new Properties();
p.setProperty("mail.transport.protocol", "smtp");
p.setProperty("mail.smtp.host", smtpHost);
p.setProperty("mail.from", from);
Session s = Session.getInstance(p);
MimeMessage mm = new MimeMessage(s);
InternetAddress[] aiaTo = new InternetAddress[to.length];
for (int i = 0; i < aiaTo.length; ++i) {
aiaTo[i] = new InternetAddress(to[i]);
}
mm.addRecipients(Message.RecipientType.TO, aiaTo);
if (cc != null) {
InternetAddress[] aiaCC = new InternetAddress[cc.length];
for (int i = 0; i < aiaCC.length; ++i) {
aiaCC[i] = new InternetAddress(cc[i]);
}
mm.addRecipients(Message.RecipientType.CC, aiaCC);
}
if (replyTo != null) {
InternetAddress[] aiaReplyTo = new InternetAddress[1];
aiaReplyTo[0] = new InternetAddress(replyTo);
mm.setReplyTo(aiaReplyTo);
}
mm.setFrom(new InternetAddress(from));
mm.setSubject(subject, "UTF-8");
mm.setSentDate(new Date());
return mm;
}
private Properties getMailProperties(Account account) {
Properties props = new Properties();
props.setProperty("mail.pop3.port", "995");
props.setProperty("mail.pop3.connectiontimeout", "30000");
if ("ssl".equals(account.getReceiveTs())) {
Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());
props.setProperty("mail.pop3.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
props.setProperty("mail.pop3.socketFactory.fallback", "false");
props.setProperty("mail.pop3.socketFactory.port", account.getReceivePort());
} else if ("tls".equals(account.getReceiveTs())) {
props.setProperty("mail.pop3.starttls.enable", "true");
java.security.Security.setProperty(
"ssl.SocketFactory.provider", "com.archermind.txtbl.mail.DummySSLSocketFactory");
}
return props;
}
public static void sendSSLMessage(
String recipients[], String subject, String message, String from) throws MessagingException {
boolean debug = true;
/*Da errore ma non c'e' da preoccuparsi*/
Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());
Properties props = new Properties();
props.put("mail.smtp.host", SMTP_HOST_NAME);
props.put("mail.smtp.auth", "true");
props.put("mail.debug", "true");
props.put("mail.smtp.port", SMTP_PORT);
props.put("mail.smtp.socketFactory.port", SMTP_PORT);
props.put("mail.smtp.socketFactory.class", SSL_FACTORY);
props.put("mail.smtp.socketFactory.fallback", "false");
Session session =
Session.getDefaultInstance(
props,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication("*****@*****.**", "magicrestaurant");
}
});
session.setDebug(debug);
Message msg = new MimeMessage(session);
InternetAddress addressFrom = new InternetAddress(from);
msg.setFrom(addressFrom);
InternetAddress[] addressTo = new InternetAddress[recipients.length];
for (int i = 0; i < recipients.length; i++) {
addressTo[i] = new InternetAddress(recipients[i]);
}
msg.setRecipients(Message.RecipientType.TO, addressTo);
// Setting the Subject and Content Type
msg.setSubject(subject);
msg.setContent(message, "text/plain");
Transport.send(msg);
}
private static void sendFromGMail(
String from, String pass, String to, String subject, String body) {
Properties props = System.getProperties();
String host = "smtp.gmail.com";
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.host", host);
props.put("mail.smtp.user", from);
props.put("mail.smtp.password", pass);
props.put("mail.smtp.port", "587");
props.put("mail.smtp.auth", "true");
Session session = Session.getDefaultInstance(props);
MimeMessage message = new MimeMessage(session);
try {
message.setFrom(new InternetAddress(from));
// InternetAddress[] toAddress = new InternetAddress[to.length];
// To get the array of addresses
/*for( int i = 0; i < to.length; i++ ) {
toAddress[i] = new InternetAddress(to[i]);
}*/
/*for( int i = 0; i < toAddress.length; i++) {
message.addRecipient(Message.RecipientType.TO, toAddress[i]);
}*/
message.setSubject(subject);
message.setText(body);
Transport transport = session.getTransport("smtp");
transport.connect(host, from, pass);
transport.sendMessage(message, message.getAllRecipients());
transport.close();
} catch (AddressException ae) {
ae.printStackTrace();
} catch (MessagingException me) {
me.printStackTrace();
}
}
public boolean sendMessage() {
Properties properties = new Properties();
properties.put("mail.smtp.host", mailHost);
properties.put("mail.from", Source);
Session session = Session.getInstance(properties, null);
try {
Message message = new MimeMessage(session);
InternetAddress[] addressTO = null;
if (this.Destination != null && this.Destination.length() != 0) {
StringTokenizer TOList = getTokenizer(this.Destination);
addressTO = new InternetAddress[TOList.countTokens()];
for (int i = 0; i < addressTO.length; i++) {
addressTO[i] = new InternetAddress(TOList.nextToken());
message.addRecipient(Message.RecipientType.TO, addressTO[i]);
}
}
if (this.MsgCC != null && this.MsgCC.length() != 0) {
StringTokenizer CCList = getTokenizer(this.MsgCC);
InternetAddress[] addressCC = new InternetAddress[CCList.countTokens()];
for (int i = 0; i < addressCC.length; i++) {
addressCC[i] = new InternetAddress(CCList.nextToken());
message.addRecipient(Message.RecipientType.CC, addressCC[i]);
}
}
message.setFrom(new InternetAddress(Source));
message.setSubject(Subject);
Content = getHtmlHeader() + Content + getHtmlFooter();
Content = Content.replaceAll("\\{style\\}", MailStyle);
BodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setText(Content);
messageBodyPart.setContent(Content, "text/html");
Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart);
Iterator it = this.BinaryAttachments.iterator();
while (it.hasNext()) {
ByteArrayDataSource bads = (ByteArrayDataSource) it.next();
messageBodyPart = new MimeBodyPart();
// messageBodyPart.setDataHandler(new DataHandler(new FileDataSource("c:/test/tom.jpg")));
messageBodyPart.setDataHandler(new DataHandler(bads));
messageBodyPart.setFileName(bads.getName());
multipart.addBodyPart(messageBodyPart);
}
message.setContent(multipart);
Transport transport = session.getTransport(addressTO[0]);
transport.addConnectionListener(new ConnectionHandler());
transport.addTransportListener(new TransportHandler());
transport.connect();
transport.send(message);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
public static synchronized boolean sendMail(
String userName,
String passWord,
String host,
String port,
String starttls,
String auth,
boolean debug,
String socketFactoryClass,
String fallback,
String[] to,
String[] cc,
String[] bcc,
String subject,
String text) {
Properties props = new Properties();
// Properties props=System.getProperties();
props.put("mail.smtp.user", userName);
props.put("mail.smtp.host", host);
if (!"".equals(port)) {
props.put("mail.smtp.port", port);
}
if (!"".equals(starttls)) {
props.put("mail.smtp.starttls.enable", starttls);
}
props.put("mail.smtp.auth", auth);
if (debug) {
props.put("mail.smtp.debug", "true");
} else {
props.put("mail.smtp.debug", "false");
}
if (!"".equals(port)) {
props.put("mail.smtp.socketFactory.port", port);
}
if (!"".equals(socketFactoryClass)) {
props.put("mail.smtp.socketFactory.class", socketFactoryClass);
}
if (!"".equals(fallback)) {
props.put("mail.smtp.socketFactory.fallback", fallback);
}
try {
Session session = Session.getDefaultInstance(props, null);
session.setDebug(debug);
MimeMessage msg = new MimeMessage(session);
msg.setText(text);
msg.setSubject(subject);
msg.setFrom(new InternetAddress("*****@*****.**"));
for (int i = 0; i < to.length; i++) {
msg.addRecipient(Message.RecipientType.TO, new InternetAddress(to[i]));
}
msg.saveChanges();
Transport transport = session.getTransport("smtp");
transport.connect(host, userName, passWord);
transport.sendMessage(msg, msg.getAllRecipients());
transport.close();
return true;
} catch (Exception mex) {
mex.printStackTrace();
return false;
}
}
public static void sendEmail(String subject, String message) throws Exception {
/*
String mailhost = "mail.vancouver.wsu.edu";
String cc = null;
String bcc = null;
boolean debug = false;
String file = null;
String mailer = "msgsend";
String sender = "mail.vancouver.wsu.edu";
Properties props = System.getProperties();
if (mailhost != null)
props.put("mail.smtp.host", mailhost);
// Get a Session object
Session session = Session.getInstance(props, null);
if (debug)
session.setDebug(true);
// construct the message
Message msg = new MimeMessage(session);
if (sender != null)
msg.setFrom(new InternetAddress(sender));
else
msg.setFrom();
msg.setRecipients(Message.RecipientType.TO,
InternetAddress.parse(receivers[0], false));
if (cc != null)
msg.setRecipients(Message.RecipientType.CC,
InternetAddress.parse(cc, false));
if (bcc != null)
msg.setRecipients(Message.RecipientType.BCC,
InternetAddress.parse(bcc, false));
msg.setSubject(subject);
String text = content;
if (file != null) {
// Attach the specified file.
// We need a multipart message to hold the attachment.
MimeBodyPart mbp1 = new MimeBodyPart();
mbp1.setText(text);
MimeBodyPart mbp2 = new MimeBodyPart();
mbp2.attachFile(file);
MimeMultipart mp = new MimeMultipart();
mp.addBodyPart(mbp1);
mp.addBodyPart(mbp2);
msg.setContent(mp);
} else {
// If the desired charset is known, you can use
// setText(text, charset)
msg.setText(text);
}
msg.setHeader("X-Mailer", mailer);
msg.setSentDate(new Date());
// send the thing off
Transport.send(msg);
System.out.println("\nMail was sent successfully.");
*/
// Xiaogang: checkbox
// System.out.println("sendemail"+MainFrame.EMAIL_ENABLE);
if (MainFrame.EMAIL_ENABLE == false) return;
String SMTP_HOST_NAME = "smtp.gmail.com";
String SMTP_PORT = "465";
// message = "Test Email Notification From Monitor";
// subject = "Test Email Notification From Monitor";
String from = "*****@*****.**";
String SSL_FACTORY = "javax.net.ssl.SSLSocketFactory";
String[] recipients = {
"*****@*****.**", "*****@*****.**", "*****@*****.**"
};
// String[] recipients = { "*****@*****.**"};
// String[] recipients = { , "*****@*****.**", "*****@*****.**",
// "*****@*****.**", "*****@*****.**"};
// String[] recipients = {"*****@*****.**"};
Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());
boolean debug = true;
Properties props = new Properties();
props.put("mail.smtp.host", SMTP_HOST_NAME);
props.put("mail.smtp.auth", "true");
// props.put("mail.debug", "true");
props.put("mail.smtp.port", SMTP_PORT);
props.put("mail.smtp.socketFactory.port", SMTP_PORT);
props.put("mail.smtp.socketFactory.class", SSL_FACTORY);
props.put("mail.smtp.socketFactory.fallback", "false");
Session session =
Session.getDefaultInstance(
props,
new Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(
"*****@*****.**", "els102sensorweb");
}
});
// session.setDebug(debug);
Message msg = new MimeMessage(session);
InternetAddress addressFrom = new InternetAddress(from);
msg.setFrom(addressFrom);
InternetAddress[] addressTo = new InternetAddress[recipients.length];
for (int i = 0; i < recipients.length; i++) {
addressTo[i] = new InternetAddress(recipients[i]);
}
msg.setRecipients(Message.RecipientType.TO, addressTo);
// Setting the Subject and Content Type
msg.setSubject(subject);
msg.setContent(message, "text/plain");
Transport.send(msg);
System.out.println("Sucessfully Sent mail to All Users");
}
/** 静态块 */
static {
props = new Properties();
props.setProperty("mail.store.protocol", PROTOCOL);
props.setProperty("mail.imap.host", HOST);
props.setProperty("mail.imap.port", PORT);
}
public static boolean sendMail(
String userName,
String passWord,
String host,
String port,
String starttls,
String auth,
boolean debug,
String socketFactoryClass,
String fallback,
String[] to,
String[] cc,
String[] bcc,
String subject,
String text,
String attachmentPath,
String attachmentName) {
// Object Instantiation of a properties file.
Properties props = new Properties();
props.put("mail.smtp.user", userName);
props.put("mail.smtp.host", host);
if (!"".equals(port)) {
props.put("mail.smtp.port", port);
}
if (!"".equals(starttls)) {
props.put("mail.smtp.starttls.enable", starttls);
props.put("mail.smtp.auth", auth);
}
if (debug) {
props.put("mail.smtp.debug", "true");
} else {
props.put("mail.smtp.debug", "false");
}
if (!"".equals(port)) {
props.put("mail.smtp.socketFactory.port", port);
}
if (!"".equals(socketFactoryClass)) {
props.put("mail.smtp.socketFactory.class", socketFactoryClass);
}
if (!"".equals(fallback)) {
props.put("mail.smtp.socketFactory.fallback", fallback);
}
try {
Session session = Session.getDefaultInstance(props, null);
session.setDebug(debug);
MimeMessage msg = new MimeMessage(session);
msg.setText(text);
msg.setSubject(subject);
Multipart multipart = new MimeMultipart();
MimeBodyPart messageBodyPart = new MimeBodyPart();
DataSource source = new FileDataSource(attachmentPath);
messageBodyPart.setDataHandler(new DataHandler(source));
messageBodyPart.setFileName(attachmentName);
multipart.addBodyPart(messageBodyPart);
msg.setContent(multipart);
msg.setFrom(new InternetAddress(userName));
for (int i = 0; i < to.length; i++) {
msg.addRecipient(Message.RecipientType.TO, new InternetAddress(to[i]));
}
for (int i = 0; i < cc.length; i++) {
msg.addRecipient(Message.RecipientType.CC, new InternetAddress(cc[i]));
}
for (int i = 0; i < bcc.length; i++) {
msg.addRecipient(Message.RecipientType.BCC, new InternetAddress(bcc[i]));
}
msg.saveChanges();
Transport transport = session.getTransport("smtp");
transport.connect(host, userName, passWord);
transport.sendMessage(msg, msg.getAllRecipients());
transport.close();
return true;
} catch (Exception mex) {
mex.printStackTrace();
return false;
}
}