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();
}
}
/** Method for checking if the message has attachments. */
public boolean hasAttachments() throws java.io.IOException, MessagingException {
boolean hasAttachments = false;
if (message.isMimeType("multipart/*")) {
Multipart mp = (Multipart) message.getContent();
if (mp.getCount() > 1) hasAttachments = true;
}
return hasAttachments;
}
public void send() {
Properties props = new Properties();
props.setProperty("mail.transport.protocol", "smtp");
props.put("mail.smtp.host", SMTP_HOST_NAME);
Session mailSession = Session.getDefaultInstance(props);
// mailSession.setDebug(true);
Transport transport;
try {
transport = mailSession.getTransport();
MimeMessage message = new MimeMessage(mailSession);
message.setFrom(new InternetAddress(userName));
message.setSubject(subject);
message.addRecipient(Message.RecipientType.TO, new InternetAddress(recipient));
if (!cc.equals("")) {
message.addRecipient(Message.RecipientType.CC, new InternetAddress(cc));
}
if (!bcc.equals("")) {
message.addRecipient(Message.RecipientType.BCC, new InternetAddress(bcc));
}
// create the message part
MimeBodyPart messageBodyPart = new MimeBodyPart();
// fill message
messageBodyPart.setText(content);
Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart);
if (fList != null) {
Iterator<File> i = fList.iterator();
// part two is attachment
while (i.hasNext()) {
File file = (File) i.next();
messageBodyPart = new MimeBodyPart();
DataSource source = new FileDataSource(file);
messageBodyPart.setDataHandler(new DataHandler(source));
messageBodyPart.setFileName(file.getName());
multipart.addBodyPart(messageBodyPart);
}
}
// Put parts in message
message.setContent(multipart);
Transport.send(message);
transport.close();
} catch (Exception e) {
e.printStackTrace();
}
}
/** Returns the body of the message (if it's plain text). */
public String getBody() throws MessagingException, java.io.IOException {
Object content = message.getContent();
if (message.isMimeType("text/plain")) {
return (String) content;
} else if (message.isMimeType("multipart/alternative")) {
Multipart mp = (Multipart) message.getContent();
int numParts = mp.getCount();
for (int i = 0; i < numParts; ++i) {
if (mp.getBodyPart(i).isMimeType("text/plain"))
return (String) mp.getBodyPart(i).getContent();
}
return "";
} else if (message.isMimeType("multipart/*")) {
Multipart mp = (Multipart) content;
if (mp.getBodyPart(0).isMimeType("text/plain"))
return (String) mp.getBodyPart(0).getContent();
else return "";
} else return "";
}
private void doit(String[] argv) {
String to = null,
subject = null,
from = null,
replyTo = null,
cc = null,
bcc = null,
url = null;
String mailhost = null;
String mailer = "MsgSend";
String protocol = null, host = null, user = null, password = null, record = null;
String filename = null, msg_text = null, inline_filename = null;
boolean debug = false;
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
int optind;
for (optind = 0; optind < argv.length; optind++) {
if (argv[optind].equals("-T")) {
protocol = argv[++optind];
} else if (argv[optind].equals("-X")) {
msg_text = argv[++optind];
} else if (argv[optind].equals("-H")) {
host = argv[++optind];
} else if (argv[optind].equals("-U")) {
user = argv[++optind];
} else if (argv[optind].equals("-P")) {
password = argv[++optind];
} else if (argv[optind].equals("-M")) {
mailhost = argv[++optind];
} else if (argv[optind].equals("-f")) {
filename = argv[++optind];
} else if (argv[optind].equals("-i")) {
inline_filename = argv[++optind];
} else if (argv[optind].equals("-s")) {
subject = argv[++optind];
} else if (argv[optind].equals("-o")) { // originator (from)
from = argv[++optind];
} else if (argv[optind].equals("-r")) { // reply-to
replyTo = argv[++optind];
} else if (argv[optind].equals("-c")) {
cc = argv[++optind];
} else if (argv[optind].equals("-b")) {
bcc = argv[++optind];
} else if (argv[optind].equals("-L")) {
url = argv[++optind];
} else if (argv[optind].equals("-d")) {
debug = true;
} else if (argv[optind].equals("--")) {
optind++;
break;
} else if (argv[optind].startsWith("-")) {
System.err.println(USAGE_TEXT);
System.exit(1);
} else {
break;
}
}
try {
if (optind < argv.length) {
// XXX - concatenate all remaining arguments
to = argv[optind];
System.out.println("To: " + to);
} else {
System.out.print("To: ");
System.out.flush();
to = in.readLine();
}
if (subject == null) {
System.out.print("Subject: ");
System.out.flush();
subject = in.readLine();
} else {
System.out.println("Subject: " + subject);
}
Properties props = System.getProperties();
// XXX - could use Session.getTransport() and Transport.connect()
// XXX - assume we're using SMTP
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 (from != null) msg.setFrom(new InternetAddress(from));
else msg.setFrom();
if (reply_to_list == null && replyTo != null) {
reply_to_list = new InternetAddress[1];
reply_to_list[0] = new InternetAddress(replyTo);
msg.setReplyTo(reply_to_list);
} else msg.setReplyTo(reply_to_list);
if (dis_list == null) {
dis_list = new InternetAddress[1];
dis_list[0] = new InternetAddress(to);
}
msg.setRecipients(Message.RecipientType.TO, dis_list);
if (cc != null) msg.setRecipients(Message.RecipientType.CC, InternetAddress.parse(cc, false));
if (bcc != null)
msg.setRecipients(Message.RecipientType.BCC, InternetAddress.parse(bcc, false));
// in-line file contents if specified
if (inline_filename != null) {
msg_text = readFile(inline_filename);
}
// create and fill the first message part
MimeBodyPart mbp1 = new MimeBodyPart();
mbp1.setText(msg_text);
// create the Multipart and add the text part
Multipart mp = new MimeMultipart();
mp.addBodyPart(mbp1);
// create additional message part(s)
// attach the file or files to the message
if (filename != null) {
MimeBodyPart mbp = new MimeBodyPart();
FileDataSource fds = new FileDataSource(filename);
mbp.setDataHandler(new DataHandler(fds));
mbp.setFileName(fds.getName());
mp.addBodyPart(mbp);
mbp1.setText(msg_text + "\n\nAttachment: " + filename);
System.out.println("Added attachment: " + filename);
}
if (attachments != null) {
Iterator i = attachments.iterator();
StringBuffer list = null;
while (i.hasNext()) {
String name = (String) i.next();
MimeBodyPart mbp = new MimeBodyPart();
FileDataSource fds = new FileDataSource(name);
mbp.setDataHandler(new DataHandler(fds));
mbp.setFileName(fds.getName());
mp.addBodyPart(mbp);
if (list == null) {
list = new StringBuffer(name);
} else {
list.append(", " + name);
}
System.out.println("Added attachment: " + name);
mbp1.setText(msg_text + "\nAttachment(s): " + list);
}
}
// add the Multipart to the message
msg.setContent(mp);
msg.setSubject(subject);
// jgfrun collect(in, msg);
msg.setHeader("X-Mailer", mailer);
msg.setSentDate(new Date());
// send the thing off
Transport.send(msg);
System.out.println("Mail was sent successfully.");
// Keep a copy, if requested.
if (record != null) {
// Get a Store object
Store store = null;
if (url != null) {
URLName urln = new URLName(url);
store = session.getStore(urln);
store.connect();
} else {
if (protocol != null) store = session.getStore(protocol);
else store = session.getStore();
// Connect
if (host != null || user != null || password != null) store.connect(host, user, password);
else store.connect();
}
// Get record Folder. Create if it does not exist.
Folder folder = store.getFolder(record);
if (folder == null) {
System.err.println("Can't get record folder.");
System.exit(1);
}
if (!folder.exists()) folder.create(Folder.HOLDS_MESSAGES);
Message[] msgs = new Message[1];
msgs[0] = msg;
folder.appendMessages(msgs);
System.out.println("Mail was recorded successfully.");
}
} catch (Exception e) {
System.err.println("Could not MsgSend.doit");
e.printStackTrace();
}
} // doit
public static void dumpPart(Part p, biz.systempartners.claims.ClaimsViewer claimsViewer)
throws Exception {
if (p instanceof Message) dumpEnvelope((Message) p);
/**
* Dump input stream ..
*
* <p>InputStream is = p.getInputStream(); // If "is" is not already buffered, wrap a
* BufferedInputStream // around it. if (!(is instanceof BufferedInputStream)) is = new
* BufferedInputStream(is); int c; while ((c = is.read()) != -1) System.out.write(c);
*/
String ct = p.getContentType();
try {
pr("CONTENT-TYPE: " + (new ContentType(ct)).toString());
} catch (ParseException pex) {
pr("BAD CONTENT-TYPE: " + ct);
}
String filename = p.getFileName();
if (filename != null) pr("FILENAME: " + filename);
/*
* Using isMimeType to determine the content type avoids
* fetching the actual content data until we need it.
*/
if (p.isMimeType("text/plain")) {
pr("This is plain text");
pr("---------------------------");
if (!showStructure && !saveAttachments) System.out.println((String) p.getContent());
} else if (p.isMimeType("multipart/*")) {
pr("This is a Multipart");
pr("---------------------------");
Multipart mp = (Multipart) p.getContent();
level++;
int count = mp.getCount();
for (int i = 0; i < count; i++) dumpPart(mp.getBodyPart(i), claimsViewer);
level--;
} else if (p.isMimeType("message/rfc822")) {
pr("This is a Nested Message");
pr("---------------------------");
level++;
dumpPart((Part) p.getContent(), claimsViewer);
level--;
} else {
if (!showStructure && !saveAttachments) {
/*
* If we actually want to see the data, and it's not a
* MIME type we know, fetch it and check its Java type.
*/
Object o = p.getContent();
if (o instanceof String) {
pr("This is a string");
pr("---------------------------");
System.out.println((String) o);
} else if (o instanceof InputStream) {
pr("This is just an input stream");
pr("---------------------------");
InputStream is = (InputStream) o;
int c;
while ((c = is.read()) != -1) System.out.write(c);
} else {
pr("This is an unknown type");
pr("---------------------------");
pr(o.toString());
}
} else {
// just a separator
pr("---------------------------");
}
}
/*
* If we're saving attachments, write out anything that
* looks like an attachment into an appropriately named
* file. Don't overwrite existing files to prevent
* mistakes.
*/
if (saveAttachments && level != 0 && !p.isMimeType("multipart/*")) {
String disp = p.getDisposition();
// many mailers don't include a Content-Disposition
if (disp == null || disp.equalsIgnoreCase(Part.ATTACHMENT)) {
if (filename == null) filename = "Attachment" + attnum++;
pr("Saving attachment to file " + filename);
try {
File f = new File(System.getProperty("user.dir"), filename);
/* if (f.exists())
// XXX - could try a series of names
throw new IOException("file exists");*/
OutputStream os = new BufferedOutputStream(new FileOutputStream(f));
InputStream is = p.getInputStream();
int c;
while ((c = is.read()) != -1) os.write(c);
os.close();
if (p.isMimeType("text/xml") || p.isMimeType("application/octet-stream")) {
processBrRequisitionFile(
f, claimsViewer, claimsViewer.getInvoiceVector(), claimsViewer.getFilesVector());
}
System.out.println("I have saved file [" + f.getAbsolutePath() + "]");
} catch (IOException ex) {
pr("Failed to save attachment: " + ex);
}
pr("---------------------------");
}
}
}
public boolean send() {
try {
// creamos las propiedades del mail
Properties propiedades = System.getProperties();
propiedades.put("mail.smtp.host", hostSmtp);
propiedades.put("mail.smtp.auth", "true");
propiedades.put("mail.smtp.port", puertoSMTP);
// creamos la sesión para enviar el mail
SMTPAuthentication auth = new SMTPAuthentication();
Session mailSesion = Session.getInstance(propiedades, auth);
// creamos el mensaje
MimeMessage mens = new MimeMessage(mailSesion);
// Definimos la dirección del remitente
mens.setFrom(new InternetAddress(this.origen));
// creamos un array de las direcciones de los destinatarios
InternetAddress[] addressTo = new InternetAddress[this.direcciones.size()];
for (int i = 0; i < this.direcciones.size(); i++) {
addressTo[i] = new InternetAddress((String) this.direcciones.get(i));
}
// definimos los destinatarios
mens.addRecipients(Message.RecipientType.TO, addressTo);
// definiemos la fecha de envio
mens.setSentDate(new Date());
// Definimos el asunto
mens.setSubject(asunto);
Multipart multipart = new MimeMultipart();
MimeBodyPart texto = new MimeBodyPart();
texto.setContent(this.mensaje, "text/html");
multipart.addBodyPart(texto);
if (this.rutaAdjunto != null) {
BodyPart adjunto = new MimeBodyPart();
adjunto.setDataHandler(new DataHandler(new FileDataSource(this.rutaAdjunto)));
adjunto.setFileName(this.nombreAdjunto);
multipart.addBodyPart(adjunto);
}
// Definimos el cuerpo del mensaje
mens.setContent(multipart);
// Creamos el objeto transport con el método
Transport transporte = mailSesion.getTransport("smtp");
// enviamos el correo
transporte.send(mens);
} catch (AddressException ex) {
ex.printStackTrace();
return false;
} catch (SendFailedException ex) {
ex.printStackTrace();
return false;
} catch (MessagingException ex) {
ex.printStackTrace();
return false;
} catch (Exception ex) {
ex.printStackTrace();
return false;
}
return true;
}
public static void dumpPart(Part p) throws Exception {
if (p instanceof Message) {
Message m = (Message) p;
Address[] a;
// FROM
if ((a = m.getFrom()) != null) {
for (int j = 0; j < a.length; j++) System.out.println("FROM: " + a[j].toString());
}
// TO
if ((a = m.getRecipients(Message.RecipientType.TO)) != null) {
for (int j = 0; j < a.length; j++) System.out.println("TO: " + a[j].toString());
}
// SUBJECT
System.out.println("SUBJECT: " + m.getSubject());
// DATE
Date d = m.getSentDate();
System.out.println("SendDate: " + (d != null ? d.toLocaleString() : "UNKNOWN"));
// FLAGS:
Flags flags = m.getFlags();
StringBuffer sb = new StringBuffer();
Flags.Flag[] sf = flags.getSystemFlags(); // get the system flags
boolean first = true;
for (int i = 0; i < sf.length; i++) {
String s;
Flags.Flag f = sf[i];
if (f == Flags.Flag.ANSWERED) s = "\\Answered";
else if (f == Flags.Flag.DELETED) s = "\\Deleted";
else if (f == Flags.Flag.DRAFT) s = "\\Draft";
else if (f == Flags.Flag.FLAGGED) s = "\\Flagged";
else if (f == Flags.Flag.RECENT) s = "\\Recent";
else if (f == Flags.Flag.SEEN) s = "\\Seen";
else continue; // skip it
if (first) first = false;
else sb.append(' ');
sb.append(s);
}
String[] uf = flags.getUserFlags(); // get the user flag strings
for (int i = 0; i < uf.length; i++) {
if (first) first = false;
else sb.append(' ');
sb.append(uf[i]);
}
System.out.println("FLAGS = " + sb.toString());
}
System.out.println("CONTENT-TYPE: " + p.getContentType());
/* Dump input stream
InputStream is = ((MimeMessage)m).getInputStream();
int c;
while ((c = is.read()) != -1)
System.out.write(c);
*/
Object o = p.getContent();
if (o instanceof String) {
System.out.println("This is a String");
System.out.println((String) o);
} else if (o instanceof Multipart) {
System.out.println("This is a Multipart");
Multipart mp = (Multipart) o;
int count = mp.getCount();
for (int i = 0; i < count; i++) dumpPart(mp.getBodyPart(i));
} else if (o instanceof InputStream) {
System.out.println("This is just an input stream");
InputStream is = (InputStream) o;
int c;
while ((c = is.read()) != -1) System.out.write(c);
}
}
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 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;
}
}
public static List<String> getText(BytesWritable value, Boolean tokenizep)
throws InterruptedException {
Session s = Session.getDefaultInstance(new Properties());
InputStream is = new ByteArrayInputStream(value.getBytes());
List<String> out = new ArrayList<String>();
try {
MimeMessage message = new MimeMessage(s, is);
message.getAllHeaderLines();
Analyzer standard_analyzer = new StandardAnalyzer(Version.LUCENE_43);
Analyzer email_analyzer = new UAX29URLEmailAnalyzer(Version.LUCENE_43);
Address[] fromAddrs = message.getFrom();
String fromAddrstr = "";
if (fromAddrs != null) {
for (Address addr : fromAddrs) {
fromAddrstr += (addr.toString() + " ");
}
}
Address[] toAddrs = message.getAllRecipients();
String toAddrstr = "";
if (toAddrs != null) {
for (Address addr : toAddrs) {
toAddrstr += (addr.toString() + " ");
}
}
String subject = message.getSubject();
String body = "";
try {
Object content = message.getContent();
// System.err.println(content.getContentType());
if (content instanceof String) {
body = (String) content;
} else if (content instanceof Multipart) {
Multipart mp = (Multipart) content;
for (int i = 0; i < mp.getCount(); i++) {
BodyPart bp = mp.getBodyPart(i);
// System.err.println(bp.getContentType());
Object c = bp.getContent();
if (c instanceof String) {
body = (String) c;
}
}
}
// people do really evil things with email, we're not sorting through it all now
} catch (DecodingException e) {
System.err.println("DecodingException");
} catch (UnsupportedEncodingException e) {
System.err.println("UnsuportedEncodingException");
} catch (IOException e) {
System.err.println("IOException");
}
if (tokenizep) {
List<String> fromData = new ArrayList<String>();
List<String> toData = new ArrayList<String>();
List<String> subjectData = new ArrayList<String>();
List<String> bodyData = new ArrayList<String>();
if (fromAddrstr != null) {
fromData = tokenizeString(email_analyzer, fromAddrstr);
}
if (toAddrstr != null) {
toData = tokenizeString(email_analyzer, toAddrstr);
}
if (subject != null) {
subjectData = tokenizeString(standard_analyzer, subject);
}
if (body != null) {
bodyData = tokenizeString(standard_analyzer, body);
}
out.add("FROM ");
out.addAll(fromData);
out.add("TO ");
out.addAll(toData);
out.add("SUBJECT ");
out.addAll(subjectData);
out.add("BODY ");
out.addAll(bodyData);
} else {
// if not tokenizep, return list with from and subject fields only
out.add(fromAddrstr);
out.add(subject);
}
} catch (MessagingException e) {
System.err.println("MessagineException");
}
return out;
}
