Java Mail Examples

Go to >> Java Code Samples

1.How to send a simple email in java
2.How to authenticate user and send email in java

1.How to send a simple email in java

package email;

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;

public class EmailExample {

 public static void main(String[] args) {

  EmailExample.sendEmail("mail.test.com", "121", 
    "webmaster@test.com", "to@test.com", 
    "Wazz up!", "Testing...");
 }

 public static void sendEmail(String smtpHost, String smtpPort
   , String from, String to, String subject, String body) {

  Properties props = System.getProperties();
  props.put("mail.smtp.host", smtpHost);
  props.put("mail.smtp.port", smtpPort);
  Session session = Session.getInstance(props, null);
  MimeMessage message = new MimeMessage(session);
  try {
   message.setFrom(new InternetAddress(from));
   message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
   message.setSubject(subject);
   message.setText(body);
   Transport.send(message);
  } catch (MessagingException ex) {
   System.err.println("Opps!! could not send email. " + ex);
  }
 }
}

2.How to authenticate user and send email in java

package basics;

import java.util.Date;
import java.util.Map;
import java.util.Properties;

import javax.mail.*;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

import org.apache.log4j.Logger;

/**
 * This is a default mail sender instance, which is implemented based on 
 * javax.mail API. This handles the actual mail sending part.
 * The caller should create a map of email parameters and pass it to 
 * the send(Map) method.
 * 
 * Map<String, String> params = new HashMap<String, String>();
 * params.put(Mail.SMTP_HOST, "smtp.blogspot.test.com"));
 * params.put(Mail.FROM, "testz_apps@blogger.test.com");
 * params.put(Mail.TO, "testz_apps@blogger.test.com");
 * params.put(Mail.SUBJECT, "");
 * params.put(Mail.BODY, "");
 * mailSender.send(params);
 * 
 * It supports only "text/plain" as body content. When there are multiple 
 * emails concatenated in one String for Mail.TO,Mail.CC or 
 * Mail.BCC, use ',' as a separator or use  Mail.ADDRESS_SEPERATOR instead. 
 * If the credentials need to be authenticated, a Mail.AUTH parameter 
 * should be set in the parameters map with the value of "true" along 
 * with Mail.USER_NAME and Mail.PASSWORD params.
 * 
 * Map<String, String> params = new HashMap<String, String>();
 * params.put(Mail.SMTP_HOST, "smtp.blogspot.test.com"));
 * params.put(Mail.FROM, "testz_apps@blogger.test.com");
 * params.put(Mail.TO, "testz_apps@blogger.test.com");
 * params.put(Mail.SUBJECT, "");
 * params.put(Mail.BODY, "");
 * params.put(AUTH, "true");
 * params.put(USER_NAME, "kannan");
 * params.put(PASSWORD, "password");
 * mailSender.send(params);
 * 
 * @author Kannan
 * @version 1.0
 */
public class MailSender implements IMailSender {

 // TODO Implement replyTo
 // TODO Implement files attachment
 // TODO Implement template content

 /** The log handler. */
 private Logger logger = Logger.getLogger(this.getClass().getName());

 /**
  * {@inheritDoc}
  */
 public boolean send(Map mailParams) throws EmailSendException {
  boolean result = false;
  try {
   // validate the mandatory parameters, and throws the EmailSendException.
   validateParams(mailParams);

   // Sends the mail if the validation is fine.
   sendMail(mailParams);
   result = true;
   if (logger.isDebugEnabled()) {
    logger.debug("mails sent successfully");
   }
  } catch (Exception e) {
   logger.error(e.getMessage(), e);
   throw new EmailSendException(e.getMessage());
  }
  return result;
 }

 /**
  * Validates all parameters. The to address, from address, body, subject 
  * and smtp host address parameters are mandatory. if one of mandatory 
  * parameters is null or one of to address, from address and smtp host 
  * address is empty, then it throws the EmailSendException with a 
  * appropriate message.
  * 
  * @param mailParams the mail parameters.
  * @throws if one of mandatory parameters is null
  * @throws EmailSendException the email send exception
  */
 private void validateParams(Map mailParams) throws EmailSendException {
  if (mailParams == null) {
   logger.error("The mail parameter map is null");
   throw new EmailSendException("The mail parameter map is null");
  }

  // validates the smtp host address, the smtp host can not be empty.
  String smtpHost = (String) mailParams.get(SMTP_HOST);
  if (smtpHost == null || smtpHost.equals("")) {
   logger.error("The mail smtp host is null or empty");
   throw new EmailSendException("The mail smtp host is null or empty");
  }

  // validates the from address, the from address can not be empty.
  String from = (String) mailParams.get(FROM);
  if (from == null || from.equals("")) {
   logger.error("The mail from address is null or empty");
   throw new EmailSendException("The mail from address is null or empty");
  }

  // validates the subject, the subject can be empty.
  String subject = (String) mailParams.get(SUBJECT);
  if (subject == null) {
   logger.error("The mail subject is null");
   throw new EmailSendException("The mail subject is null");
  }

  // validates the body, the body can be empty.
  String body = (String) mailParams.get(BODY);
  if (body == null) {
   logger.error("The mail body is null");
   throw new EmailSendException("The mail body is null");
  }

  // validates the to address, the to address can not be empty.
  String to = (String) mailParams.get(TO);
  if (to == null || to.equals("")) {
   logger.error("The mail to address is null or empty");
   throw new EmailSendException("The mail to address is null or empty");
  }
 }

 /**
  * Sends the email for given toAddress. The message body and subject will be
  * messageBody and messageSubject.
  * 
  * @param mailParams the mail params
  * @throws AddressException throws when a wrongly formatted address is encountered.
  * @throws MessagingException if there are any other unexpected exception is encountered
  * @throws EmailSendException the email send exception
  */
 private void sendMail(Map mailParams) throws EmailSendException {

  String from = (String) mailParams.get(FROM);
  String subject = (String) mailParams.get(SUBJECT);
  String body = (String) mailParams.get(BODY);
  String to = (String) mailParams.get(TO);
  String cc = (String) mailParams.get(CC);
  String bcc = (String) mailParams.get(BCC);
  String smtpHost = (String) mailParams.get(SMTP_HOST);
  String smtpPort = (String) mailParams.get(SMTP_PORT);
  String auth = (String) mailParams.get(AUTH);

  // Get system properties
  Properties props = System.getProperties();

  // Specify the desired SMTP server
  props.put("mail.smtp.host", smtpHost);
  if (smtpPort != null) {// if null, the default port 25 will be used instead
   props.put("mail.smtp.port", smtpPort);
  }

  // Create a new Session object
  Session session = null;
  // If authentication is required
  if (auth != null && auth.toLowerCase().equals("true")) {
   String username = (String) mailParams.get(USER_NAME);
   String password = (String) mailParams.get(PASSWORD);
   SMTPAuthenticator authenticator = new SMTPAuthenticator(username, password);
   session = Session.getInstance(props, authenticator);
  } else {
   // If authentication is not required
   session = Session.getInstance(props, null);
  }

  // Create a new MimeMessage object (using the Session created above)
  Message message = new MimeMessage(session);

  try {
   // Setting the from address
   message.setFrom(new InternetAddress(from));

   // Setting the CC address if it's not null and empty
   message.setRecipients(Message.RecipientType.TO, getInternetAddress(to));
   if (cc != null && !cc.equals("")) {
    message.setRecipients(Message.RecipientType.CC, getInternetAddress(cc));
   }

   // Setting the BCC address if it's not null and empty
   if (bcc != null && !bcc.equals("")) {
    message.setRecipients(Message.RecipientType.BCC, getInternetAddress(bcc));
   }

   // Setting the subject and body content. it supports only "text/plain" for now.
   message.setSubject(subject);
   message.setSentDate(new Date());
   message.setContent(body, "text/plain");

   if (logger.isDebugEnabled()) {
    logger.debug("The mail is going to be sent using the following parameters");
    logger.debug("To : " + to);
    logger.debug("From : " + from);
    logger.debug("Subject : " + subject);
    logger.debug("Body : " + body);
    logger.debug("Smtp host : " + smtpHost);
    logger.debug("CC : " + cc);
    logger.debug("BCC : " + bcc);
   }
   Transport.send(message);
  } catch (Exception e) {
   logger.error(e.getMessage(), e);
   throw new EmailSendException(e.getMessage(), e);
  }
 }

 /**
  * Returns the array of InternetAddress , for given address. it splits the give
  * address with the ADDRESS_SEPERATOR and convert it into a
  * InternetAddress.
  * 
  * @param address the address, can be a single address or multiple address separated by
  *        ADDRESS_SEPERATOR.
  * @return the array of InternetAddress , for given address
  * @throws EmailSendException if there are any AddressException, then it logs the
  *         error and wraps it with EmailSendException and then throws it.
  */
 private InternetAddress[] getInternetAddress(String address) throws EmailSendException {
  String addressArray[] = address.split(ADDRESS_SEPERATOR);
  InternetAddress[] inetAddress = new InternetAddress[addressArray.length];
  for (int i = 0; i < addressArray.length; i++) {
   try {
    inetAddress[i] = new InternetAddress(addressArray[i]);
   } catch (AddressException e) {
    logger.error(e.getMessage(), e);
    throw new EmailSendException(e.getMessage(), e);
   }
  }
  return inetAddress;
 }

 /**
  * The Class SMTPAuthenticator.
  */
 private class SMTPAuthenticator extends javax.mail.Authenticator {

  /** The username. */
  String username = null;

  /** The password. */
  String password = null;

  /**
   * Instantiates a new sMTP authenticator.
   * 
   * @param username the username
   * @param password the password
   */
  SMTPAuthenticator(String username, String password) {
   this.username = username;
   this.password = password;
  }

  public PasswordAuthentication getPasswordAuthentication() {
   return new PasswordAuthentication(username, password);
  }
 }

}

/**
 * The constant class holds the key value pair.
 * 
 * @author  Kannan
 * @version 1.0
 */
public class Mail {

 /** The email address separator */
 public static final String ADDRESS_SEPERATOR = ",";

 /** The key for email from address */
 public static final String FROM = "FROM";

 /** The key for email subject address */
 public static final String SUBJECT = "SUBJECT";

 /** The key for email body address */
 public static final String BODY = "BODY";

 /** The key for email SMTP address */
 public static final String SMTP_HOST = "SMTP_HOST";
 
 /** The key for email SMTP port */
 public static final String SMTP_PORT = "SMTP_PORT";

 /** The key for email to address */
 public static final String TO = "TO";

 /** The key for email CC address */
 public static final String CC = "CC";

 /** The key for email BCC address */
 public static final String BCC = "BCC";

 /** The key for username */
 public static final String USER_NAME = "USER_NAME";

 /** The key for password */
 public static final String PASSWORD = "PASSWORD";

 /** The key for email authentication indicator */
 public static final String AUTH = "AUTH";
}

/**
 * The interface define methods for sending mails.
 * 
 * @author  Kannan
 * @version 1.0
 */
public interface IMailSender {

 /**
  * Send the mail according to the parameters that are set by the mailParams map.
  * 
  * @param the mail parameters. the mail parameters can be set as follows. *
  * 
  *  Map<String, String> params = new HashMap<String, String>();
  *  params.put(Mail.SMTP_HOST, "smtp.blogspot.test.com"));
  *  params.put(Mail.FROM, "testz_apps@blogger.test.com");
  *  params.put(Mail.TO, "testz_apps@blogger.test.com");
  *  params.put(Mail.SUBJECT, "");
  *  params.put(Mail.BODY, "");
  *  mailSender.send(params);
  * 
  * @throws EmailSendException, if there are any exceptions conditions, then it is wrapped with
  *         EmailSendException and thrown.
  */
 boolean send(Map mailParams) throws EmailSendException;
}