Question

Are there any packages available that will efficiently send emails with large attachments (each file is capped at 10mb, but could include multiple files). If not, any suggestions on an appropriate design that wouldn’t result in out of memory exceptions causing issues across applications deployed on the same server?

Files are delivered to the application server by ftp. Once transmission is complete, a web service is invoked (metadata for the transaction). Based on business rules, this service may need need to email the files.

My initial thoughts were a putting the request on a message queue (so the service can return immediately), and having a synchronized method process the request (so multiple requests at or around the same time won’t blow up the heap).

---

updating with code

messageBodyPart = new MimeBodyPart();
FileDataSource fileDataSource =new FileDataSource("locationTo.big.file");
messageBodyPart.setDataHandler(new DataHandler(fileDataSource));
messageBodyPart.setFileName("big.file");
multipart.addBodyPart(messageBodyPart);
<rinse..repeat>

message.setContent(multipart);

Transport.send(msg);

If I attach 5 10mb attachments, 50mb won’t be eaten up by the heap all at once?

Answer 1

Why not use an Executor, with a thread pool growing/shrinking within reason. Each task submitted is a Runnable or Callable. The Task sends via JavaMail, which DOES not take much memory if you implement your own DataSource implementations for the attachments and/or message body. (I am assuming you have have InputStream acccess to the attachments)

Adding code as sample (note this code was written many years ago, and is pretty bad for many reasons. But it shows the concept)

public static void sendMailAndThrowException(SMTPParams sparams,String  subject, DataSource msgTextSource,DataSource[] fids,boolean debug) throws MessagingException {
    Session session=getMailSession(sparams);
PrintStream f = null;
if (debug) {            
        f= getPrintStream();        
} 
// null is System.out by javamail api
session.setDebug(debug);
session.setDebugOut(f);     

try
{
    // create a message
    MimeMessage msg = new MimeMessage(session);
    msg.setFrom(new InternetAddress(sparams.getFrom()));

    // Recipients are comma delimitted
    String to_list[] = sparams.getRecipients().split(",");
    InternetAddress[] address = new InternetAddress[to_list.length];
    for( int i=0; i< to_list.length; i++)
    {
        // MJB: remove extraneous spaces, sanity check
        String temp = to_list[i].trim();
        if (temp.length()>0) {
            address[i] = new InternetAddress(to_list[i].trim());
        }
    }
    // Addresses are always TO, never CC  or BCC in this library
    msg.setRecipients(Message.RecipientType.TO, address);
        if ((msg.getAllRecipients() == null) || (msg.getAllRecipients().length==0)) {
            throw new MessagingException("No valid recipients");
        }

    // Set the subject
    msg.setSubject(subject,"UTF-8");

    // create the Multipart and add its parts to it
    Multipart mp = new MimeMultipart();


    if (msgTextSource != null) {
        // create and fill the first message part
        MimeBodyPart mbp1 = new MimeBodyPart();
        mbp1.setDataHandler(new DataHandler(msgTextSource));
        mp.addBodyPart(mbp1);
    }

    if( fids != null)
    {
        for (int i=0;i<fids.length;i++) {
            //  create the second message part
            if (fids[i]==null) continue;
            MimeBodyPart mbp2 = new MimeBodyPart();
            //  attach the file to the message
            mbp2.setDataHandler(new DataHandler(fids[i]));
            mbp2.setFileName(fids[i].getName());
            mp.addBodyPart(mbp2);
        }
    }

    // add the Multipart to the message
    msg.setContent(mp);

    // set the Date: header
    msg.setSentDate(new java.util.Date());

    // Connect to SMTP server
    smtpSend(session, msg, sparams);

}

catch (MessagingException mex)
{
    throw mex;
} finally {
    closeDebug(f);
}


}