Sending Email with Attachments using JavaMail

We can send emails using JavaMail API.
Instead of directly using JavaMail API here is a small utility to send emails which shields the user from JavaMail internals.  
EmailConfiguration.java

import java.util.Properties;

public class EmailConfiguration
{
 private Properties properties = new Properties();
 
 public static final String SMTP_HOST = "mail.smtp.host";
 public static final String SMTP_AUTH = "mail.smtp.auth";
 public static final String SMTP_TLS_ENABLE = "mail.smtp.starttls.enable";
 public static final String SMTP_AUTH_USER = "smtp.auth.user";
 public static final String SMTP_AUTH_PWD = "smtp.auth.pwd";
 public static final String DEBUG = "debug";
 
 public Properties getProperties()
 {
  return this.properties;
 }
 
 public void setProperty(String key, String value)
 {
  this.properties.put(key, value);
 }
 
 public void addProperties(Properties props)
 {
  this.properties.putAll(props);
 }
 
 public String getProperty(String key)
 {
  return this.properties.getProperty(key);
 }
}

Email.java

import java.util.ArrayList;
import java.util.List;

public class Email 
{
 private String from;
 private String[] to;
 private String[] cc;
 private String[] bcc;
 private String subject;
 private String text;
 private String mimeType;
 private List<Attachment> attachments = new ArrayList<Attachment>();
 
 public String getFrom()
 {
  return from;
 }
 public void setFrom(String from)
 {
  this.from = from;
 }
 public String[] getTo()
 {
  return to;
 }
 public void setTo(String... to)
 {
  this.to = to;
 }
 public String[] getCc()
 {
  return cc;
 }
 public void setCc(String... cc)
 {
  this.cc = cc;
 }
 public String[] getBcc()
 {
  return bcc;
 }
 public void setBcc(String... bcc)
 {
  this.bcc = bcc;
 }
 public String getSubject()
 {
  return subject;
 }
 public void setSubject(String subject)
 {
  this.subject = subject;
 }
 public String getText()
 {
  return text;
 }
 public void setText(String text)
 {
  this.text = text;
 }
 public String getMimeType()
 {
  return mimeType;
 }
 public void setMimeType(String mimeType)
 {
  this.mimeType = mimeType;
 }
 public List<Attachment> getAttachments()
 {
  return attachments;
 }
 public void addAttachments(List<Attachment> attachments)
 {
  this.attachments.addAll(attachments);
 }
 public void addAttachment(Attachment attachment)
 {
  this.attachments.add(attachment);
 }
 public void removeAttachment(int index)
 {
  this.attachments.remove(index);
 }
 public void removeAllAttachments()
 {
  this.attachments.clear();
 }
}

Attachment.java

public class Attachment
{
 private byte[] data;
 private String filename;
 private String mimeType;
 
 public Attachment()
 {
 }
 
 public Attachment(byte[] data, String filename, String mimeType)
 {
  super();
  this.data = data;
  this.filename = filename;
  this.mimeType = mimeType;
 }

 public byte[] getData()
 {
  return data;
 }
 public void setData(byte[] data)
 {
  this.data = data;
 }
 public String getFilename()
 {
  return filename;
 }
 public void setFilename(String filename)
 {
  this.filename = filename;
 }

 public String getMimeType()
 {
  return mimeType;
 }

 public void setMimeType(String mimeType)
 {
  this.mimeType = mimeType;
 }
 
}

EmailService.java

import java.util.List;

import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.mail.Authenticator;
import javax.mail.BodyPart;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Multipart;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
import javax.mail.util.ByteArrayDataSource;

public class EmailService 
{
 private EmailConfiguration configuration = null;
 private Authenticator auth =null;
 
 public EmailService(EmailConfiguration configuration)
 {
  this.configuration = configuration;
  this.auth = this.buildSmtpAuthenticator();     
 }
 
 private Authenticator buildSmtpAuthenticator()
 {
  String emailId = configuration.getProperty(EmailConfiguration.SMTP_AUTH_USER);
  String password = configuration.getProperty(EmailConfiguration.SMTP_AUTH_PWD);
  return new SMTPAuthenticator(emailId, password);
 }
 
 public void sendEmail(Email email)
 {
  Session session = Session.getDefaultInstance(this.configuration.getProperties(), auth);
  boolean debug = Boolean.valueOf(this.configuration.getProperty(EmailConfiguration.DEBUG));
     session.setDebug(debug);
     
     try 
     {
      Message msg = this.buildEmailMessage(session, email);
   Transport.send(msg);
  } 
     catch (MessagingException e) 
  {
   throw new RuntimeException(e);
  }     
 }
 
 private Message buildEmailMessage(Session session, Email email) throws MessagingException
 {
  Message msg = new MimeMessage(session);
     msg.setSubject(email.getSubject());
     this.addRecievers(msg, email);
     Multipart multipart = new MimeMultipart();
     this.addMessageBodyPart(multipart, email);
     this.addAttachments(multipart, email);   
        msg.setContent(multipart);
     return msg;
 }
 
 private void addRecievers(Message msg, Email email) throws MessagingException
 {
  InternetAddress from = new InternetAddress(email.getFrom());
     msg.setFrom(from);
     
     InternetAddress[] to = this.getInternetAddresses(email.getTo());
     msg.setRecipients(Message.RecipientType.TO, to);

     InternetAddress[] cc = this.getInternetAddresses(email.getCc());
     msg.setRecipients(Message.RecipientType.CC, cc);

     InternetAddress[] bcc = this.getInternetAddresses(email.getBcc());
     msg.setRecipients(Message.RecipientType.BCC, bcc);

 }
 private void addMessageBodyPart(Multipart multipart, Email email) throws MessagingException
 {
   BodyPart messageBodyPart = new MimeBodyPart();
   messageBodyPart.setContent(email.getText(), email.getMimeType());      
   multipart.addBodyPart(messageBodyPart);      
 }
 private void addAttachments(Multipart multipart, Email email) throws MessagingException
 {
  List<Attachment> attachments = email.getAttachments();
     if(attachments != null && attachments.size() > 0)
     {
      for (Attachment attachment : attachments) 
      {
       BodyPart attachmentBodyPart = new MimeBodyPart();
          String filename = attachment.getFilename() ;
          DataSource source = new ByteArrayDataSource(attachment.getData(), 
                 attachment.getMimeType());
          attachmentBodyPart.setDataHandler(new DataHandler(source));
          attachmentBodyPart.setFileName(filename);
          multipart.addBodyPart(attachmentBodyPart);
   }
     }  
 }
 private InternetAddress[] getInternetAddresses(String... addresses) 
       throws AddressException
 {
  if(addresses == null || addresses.length == 0)
  {
   return null;
  }
  InternetAddress[] iAddresses = new InternetAddress[addresses.length];
     for (int i = 0; i < addresses.length; i++)
     {
      iAddresses[i] = new InternetAddress(addresses[i]);
     }
     return iAddresses;
 }
}

class SMTPAuthenticator extends javax.mail.Authenticator
{
 private String username;
 private String password;
 
    public SMTPAuthenticator(String username, String password) {
  this.username = username;
  this.password = password;
 }
    
 public PasswordAuthentication getPasswordAuthentication()
    {
        return new PasswordAuthentication(username, password);
    }
}

Add the mail.jar, activation.jar to the classpath. Here is the TestClient on how to use the EmailService Utility.

Testing our classes

public class EmailClient
{
 public static void main(String[] args)
 {
  EmailConfiguration configuration = new EmailConfiguration();
  configuration.setProperty(EmailConfiguration.SMTP_HOST, "smtp.gmail.com");
  configuration.setProperty(EmailConfiguration.SMTP_AUTH, "true");
  configuration.setProperty(EmailConfiguration.SMTP_TLS_ENABLE, "true");
  configuration.setProperty(EmailConfiguration.SMTP_AUTH_USER, "xyz@gmail.com");
  configuration.setProperty(EmailConfiguration.SMTP_AUTH_PWD, "**********");
  
  EmailService emailService = new EmailService(configuration);
  Email email = new Email();
  email.setFrom("kinshuk.ram@gmail.com");
  email.setTo("kinshuk_ram@yahoo.co.in");
  email.setCc("kinshuk_ram@rediffmail.com");
  
  email.setSubject("Test Mail from Java Jazzle");
  email.setText("Hi, 
This is a test email from Java Jazzle");
  email.setMimeType("text/html");
  
  Attachment attachment1 = new Attachment("ABCDEFGH".getBytes(), "test1.txt","text/plain");
  email.addAttachment(attachment1);
  
  Attachment attachment2 = new Attachment("XYZZZZZZ".getBytes(), "test2.txt","text/plain");
  email.addAttachment(attachment2);
  
  emailService.sendEmail(email);
  
 }

}

Sending mail using JavaMail APIs

In this example Google SMTP server is used to send email.

public class Email
{
    String  d_email = “your_id@gmail.com“,
    d_password = “your_password”,
    d_host = “smtp.gmail.com”,
    d_port  = “465″;
    public Email() { }
    public void sendEamil(String m_to , String m_subject , String m_text)
    {
        Properties props = new Properties();
        props.put(”mail.smtp.user”, d_email);
        props.put(”mail.smtp.host”, d_host);
        props.put(”mail.smtp.port”, d_port);
        props.put(”mail.smtp.starttls.enable”,”true”);
        props.put(”mail.smtp.auth”, “true”);
        //props.put(”mail.smtp.debug”, “true”);
        props.put(”mail.smtp.socketFactory.port”, d_port);
        props.put(”mail.smtp.socketFactory.class”, “javax.net.ssl.SSLSocketFactory”);
        props.put(”mail.smtp.socketFactory.fallback”, “false”);
        SecurityManager security = System.getSecurityManager();
        try
        {
            Authenticator auth = new SMTPAuthenticator();
            Session session = Session.getInstance(props, auth);
            session.setDebug(true);
            MimeMessage msg = new MimeMessage(session);
            msg.setText(m_text);
            msg.setSubject(m_subject);
            msg.setFrom(new InternetAddress(d_email));
            msg.addRecipient(Message.RecipientType.TO, new InternetAddress(m_to));
            Transport.send(msg);
        }
        catch (Exception mex)
        {
            mex.printStackTrace();
        }
    }
    private class SMTPAuthenticator extends javax.mail.Authenticator
    {
        public PasswordAuthentication getPasswordAuthentication()
        {
            return new PasswordAuthentication(d_email, d_password);
        }
    }
}