The JavaMail API provides a protocol-independent and platform-independent framework to provide e-mail support for a Java application. The JavaMail API is a collection of classes and interfaces that comprise an e-mail system. The steps involved in sending a simple e-mail using the JavaMail API are as follows:

Sending a simple e-mail requires the use of a number of classes and interfaces that are present in the javax.mail and javax.mail.internet packages. The important classes and interfaces in the JavaMail API are listed in the following table:

The JavaMail application uses the JavaMail API to exchange e-mails, as shown in the following figure:

The JavaMail API can be used to create a class to send an e-mail using the MailHelper class. This MailHelper class contains a constructor, which can be used to initialize the host, username, and password. This MailHelper class also contains the sendMail() method.

The following code snippet shows the MailHelper.java class:

public class MailHelper {

   private Properties props;
   private String host;
   private String userName;
   private String password;

   public MailHelper(String host, String username, String password){
          this.userName = username;
          this.password = password;
          props = new Properties();
          // put host information
          props.put("mail.stmp.host", host);
          // put true for authentication mechanism
          props.put("mail.smtp.auth", "true");
   }

   public void sendMail(String from, String to, String subject, String body){
          Session session = Session.getDefaultInstance(props, new PasswordAuthenticator());
          try{
                Message message = new MimeMessage(session);
                message.setFrom(new InternetAddress(from));
                InternetAddress toAddress = new InternetAddress(to);
                message.addRecipient(RecipientType.TO, toAddress);
                message.setSub(subject);
                message.setText(body);
                Transport transport = session.getTransport("smtp");
                transport.connect();
                transport.sendMessage(message, message.getAllRecipients());
                transport.close();
          } catch(NoSuchProviderException ex){
                ex.printStackTrace();
          } catch(MessagingException ex){
                ex.printStackTrace();
          }
   }

   private class PasswordAuthenticator extend Authenticator{
          protected PasswordAuthentication getPasswordAuthentication(){
                return new PasswordAuthentication(userName, password);
          }
   }
}

In the preceding code snippet, the MailHelper class has instance variables and a constructor. The props variable, of the Properties collection type, used to specify the common properties to connect to the e-mail provider host.

Simple Mail Transfer Protocol (SMTP) is a protocol that is used to send e-mails. The SMTP server performs this job. The props.put("mail.stmp.host", host) code inside the constructor is used to specify the host information, where we connect to the SMTP server of our host. The props.put("mail.smtp.auth", "true") code inside the constructor specifies the use of an authentication mechanism to connect to the SMTP server.

The sendMail method of the MailHelper class creates a Session object using the host information and the username-password credentials. The from-address and the to-address are added to the instance of the MimeMessage class. The subject and the body of the e-mail are also added to this MimeMessage object. Finally, the message is sent using an instance of the Transport class.

The PasswordAuthenticator class is an inner class that has been used by a Session object to hold the username and the password.

From the preceding code, the following problems can be encountered:

Let's understand the use of the Spring API for the JavaMail API and rewrite the MailHelper class.

The Spring Framework provides an API to simplify the use of the JavaMail API. The classes handle the initialization, clean-up operations, and exceptions. The packages for the JavaMail API provided by the Spring Framework are listed in the following table:

In the Spring mail API hierarchy, the org.springframework.mail package is the root-level package for the Spring Framework's e-mail support, as shown here:

The important classes and interfaces in the org.springframework.mail package are listed in the following table:

The important classes and interfaces in the org.springframework.mail.java package are listed in the following table:

The Java application can use Spring to access the JavaMail API for sending e-mails, as shown in the following figure:

In the preceding figure, the Java classes use the Spring API, which indirectly uses the JavaMail API to send e-mails.

Let's create a JavaMail API with the Spring application for sending e-mails via the Gmail SMTP server using the Spring mail API. Here, we develop a basic e-mail application that creates simple e-mails containing text only.

<!-- SET default mail properties -->
<bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
   <property name="host" value="smtp.gmail.com" />
   <property name="port" value="25" />
   <property name="username" value="username" />
   <property name="password" value="password" />
 
   <property name="javaMailProperties">
      <props>
                <prop key="mail.smtp.auth">true</prop>
                <prop key="mail.smtp.starttls.enable">true</prop>
             </props>
   </property>
</bean>

<bean id="emailService" class="org.packt.Spring.chapter10.mail">  
    <property name="mailSender" ref="mailSender" />  
</bean>

package org.packt.Spring.chapter10.mail;

import org.springframework.mail.MailSender;
import org.springframework.mail.SimpleMailMessage;
 
public class EmailService
{

   @Autowired
   private MailSender mailSender;
 
   public void sendEmail(String to, String subject, String msg) {
 
          // creates a simple e-mail object
          SimpleMailMessage email = new SimpleMailMessage();
 
          email.setTo(to);
          email.setSubject(subject);
          email.setText(msg);

          // sends the e-mail
          mailSender.send(email);
   }
}

package org.packt.Spring.chapter10.mail;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class MailerTest
{
    public static void main( String[] args )
    {
         //Create the application context
         ApplicationContext context = 
             new ClassPathXmlApplicationContext("Spring.xml");
 
      //Get the mailer instance
       EmailService emailService = (EmailService)context.getBean("emailService ");

        //Send a composed mail
        emailService.sendEmail("****@gmail.com",
                   "Email Test Subject", 
                   "Email Testing body");
 
    }
}