Sending e-mails in Java with Spring – GMail SMTP server example (original) (raw)

For e-mail sending in Java, the JavaMail API is the standard solution. As the official web page states, “The JavaMail API provides a platform-independent and protocol-independent framework to build mail and messaging applications”. The necessary classes are included in the JavaEE platform, but to use it in a standalone JavaSE application you will have to download the corresponding JAR from here.

Note: Unless you’re using Java SE 6, you will also need the JavaBeans Activation Framework (JAF) extension that provides the javax.activation package. We suggest you use version 1.1.1 of JAF, the latest release. JAF is included with Java SE 6.

JavaMail can unfortunately be a little cumbersome and difficult to configure and use. In case you have embraced the Spring framework for your applications, you will be glad to find out that Spring provides a mail abstraction layer. As the reference documentation states, “The Spring Framework provides a helpful utility library for sending email that shields the user from the specifics of the underlying mailing system and is responsible for low level resource handling on behalf of the client.” Great, let’s see now how to leverage this library.

First, create a new Eclipse project named “SpringMailProject”. In the project’s classpath, make sure to include the following libraries (note that the 3.0.2.RELEASE Spring version was used):

Note1: The commons-logging library from Apache is needed and was included in the classpath
Note2: You will also need the Java Activation Framework if you are using Java 1.5 or earlier

We will use MailSender, a Spring interface that defines a strategy for sending simple mails. Since this is just an interface, we need a concrete implementation and that comes in the form of JavaMailSenderImpl. This class supports both JavaMail MimeMessages and Spring SimpleMailMessages.

We will create a simple Spring service that will be used for sending mail. One method will create a SimpleMailMessage on the spot, while the other will use a preconfigured default message. The source code for the service is the following:

package com.javacodegeeks.spring.mail;

import org.springframework.beans.factory.annotation.Autowired; import org.springframework.mail.MailSender; import org.springframework.mail.SimpleMailMessage; import org.springframework.stereotype.Service;

@Service("mailService") public class MailService {          @Autowired     private MailSender mailSender;     @Autowired     private SimpleMailMessage alertMailMessage;          public void sendMail(String from, String to, String subject, String body) {                  SimpleMailMessage message = new SimpleMailMessage();                   message.setFrom(from);         message.setTo(to);         message.setSubject(subject);         message.setText(body);         mailSender.send(message);              }          public void sendAlertMail(String alert) {                  SimpleMailMessage mailMessage = new SimpleMailMessage(alertMailMessage);         mailMessage.setText(alert);         mailSender.send(mailMessage);              }      }

The class is just a POJO and its service name is “mailService”, marked by the stereotype Service annotation. The beans wiring strategy used is the one of autowiring, thus the Autowired annotation is used. Note that the autowiring can be performed using both the name and the type of a bean.

The corresponding Spring XML file that bootstraps the container is the following:

<beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xmlns:p="http://www.springframework.org/schema/p"     xmlns:aop="http://www.springframework.org/schema/aop"     xmlns:context="http://www.springframework.org/schema/context"     xmlns:jee="http://www.springframework.org/schema/jee"     xmlns:task="http://www.springframework.org/schema/task"     xsi:schemaLocation="             http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd             http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd             http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd             http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd             http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd             http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd"

    <context:component-scan base-package="com.javacodegeeks.spring.mail" />                                                                                                smtp                                 true                                 true                 true                                                                 myusername@gmail.com                                         myusername@gmail.com                        

This is a quite simple Spring config file. Some things to mention though:

In case you wish to use Gmail’s SMTP server, make sure that the following JavaMail properties are configured appropriately:

host=smtp.gmail.com port=25 username=your-gmail-username password=your-gmail-password mail.transport.protocol=smtp mail.smtp.auth=true mail.smtp.starttls.enable=true

While in development phase, set “mail.debug” to true if you want the mail client to generate informative logs. However, remember to set this to false when in production, because the amount of logs could degrade the application’s performance and/or fill-up your hard disks.

Finally, we create a class that will be used to create the Spring container and test the simple mail service we created. The source code is the following:

package com.javacodegeeks.spring.mail;

import org.springframework.context.ApplicationContext; import org.springframework.context.support.FileSystemXmlApplicationContext;

public class MailServiceTest {

    public static void main(String[] args) {                 ApplicationContext context = new FileSystemXmlApplicationContext("conf/spring.xml");

        MailService mailService = (MailService) context.getBean("mailService");                 mailService.sendMail("myusername@gmail.com", "myusername@gmail.com", "Testing123", "Testing only \n\n Hello Spring Email Sender");                 mailService.sendAlertMail("Exception occurred");             }     }

The FileSystemXmlApplicationContext class is used as the ApplicationContext. We pass the Spring’s XML file location in the constructor and the class creates the container, instantiates the beans and takes care of the dependencies. Don’t you love Spring? Next, we retrieve a reference of our “MailService” service using the “getBean” method and invoke the two methods.

That’s all. As always, you can download the full Eclipse project from here.

Related Articles :

Photo of Ilias Tsagklis

Ilias is a software developer turned online entrepreneur. He is co-founder and Executive Editor at Java Code Geeks.