Using JavaMail in Website forms

While building Web sites, Java developers have to sometimes provide
functionality of allowing user to submit feedback by an email account; or a
functionality wherein logged-in users can send messages as emails to customers
or clients from a common account. For providing such functionality there's a
Java API called JavaMail API. It provides a mail and messaging framework that
can be used to send messages from the host mail server. For cases where the
website hosting provider does not provide a mail server, developers are forced
to save the users' feedback to a database and retrieve information from there
later. In such a situation Google Mail comes to the rescue. In this article we
will see through a demo app how to incorporate a user's feedback form submission
through the JavaMail API and the feedback data being sent to a Gmail account.

About JavaMail API

JavaMail API provides a complete set of abstract classes defining objects that
would comprise a complete mail system. With this API, Java has given developers
a platform from which they can create their own mailing system app that can not
only send but also receive messages. The JavaMail API has support for different
messaging system implementations like Message class for messaging details such
as subject line, etc, store class for different message privileges like read,
write, etc, and Transport class for message sending over a particular protocol.

JavaMail subclasses also expose additional messaging system features, for
instance, the MimeMessage sub class that exposes and implements characteristics
of an Internet mail message that are as per RFC822 and MIME standards.
Developers can now subclass the JavaMail classes to provide them with
implementations for particular messaging systems, such as IMAP, POP3, and SMTP.
By using these abstract classes the base can be configured for defining the
client application for a messaging system.

Setup and Configuration

For the demo app we will build a component of the website that will have a
feedback form designed in JSP, which we'll call the 'Java Servlet.' This will
use JavaMail to send the form-data as an email. The web server for the demo will
be Tomcat. For this purpose let's first do some basic configuration of the APIs.
With this month's PCQ_PRFESSIONAL CD we have provided JavaMail API version 1.4
along with Java Activation Framework (JAF) version 1.1.1 zip files. Extract the
zip files to some base folder and then append the paths to the Classpath entry
for system environment variables pointing to mail.jar under JAVA_MAIL/bin folder
and activation.jar under JAF/bin folder.

Now from within Eclipse IDE start a new project from File > New > Project and
then select Tomcat project (considering that the Tomcat-Eclipse plug-in is
installed). Name the project as 'JavaMail.' As we intend to deploy our app on a
hosting service provider's server, we will have to pack the JavaMail APIs into
the WAR file so that during deployment the programs could get reference to the
JavaMail libraries. For this reason copy the mail.jar and activation.jar files
into the WEB-INF/lib folder. Also add these two jar files into the project's
classpath. Once this initial configuration of the project 'JavaMail' has been
completed we can now start building our Web app.

Packing the mail and activation JAR files result in their avilabity  on remote host

Designing the form and its Servlet

The feedback form for the demo app is simple with two input fields for
taking sender's e-mail address and his name, while the text area will be used
for taking the user's feedback/comment. Name the fields appropriately so that
their values can be retrieved by the Servlet while sending the mail. On the
form's action attribute set the mapped path that will call for the Servlet. Now
let's start coding for the Servlet that will retrieve the values from the
feedback form and will send them across to an email account

For the demo app we are using Google Mail as the mail server to send mails.
To send mails via Gmail, the SMTP mail protocol is used and the port for that on
Gmail server is 465 and the host is smtp.gmail.com. The email account we refer
here as 'demoaccount' is just for reference. Also Google only allows messages to
be sent over SSL, so we will have to enable it. Also we have to login into the
Gmail account and after authentication only the mail could be sent, so for this
we will use Authentication also and set the property for that as true. Once the
message is sent the transporter waits for a QUIT command, we can close the
connection immediately by setting the quitwait property as false. Now with
initial properties configured, we can proceed by sending the message. Let's look
at the demo Servlet first then we will discuss some of the parameters used in
that.

public class SendMailServlet extends HttpServlet

{ ...

public void service(HttpServletRequest request, HttpServletResponse
response)throws ServletException, IOException{ senderName=request.getParameter("name");

comment=request.getParameter("comment");

String to="demoaccount@gmail.com";

String from="demoacc@gmail.com";

String host = "smtp.gmail.com";

Properties p = new Properties();

p.put("mail.smtp.host", host);

p.put("mail.smtp.port", "465");

p.put("mail.smtp.starttls.enable","true");

p.put("mail.smtp.auth", "true");

p.put("mail.smtp.debug", "true");

p.put("mail.smtp.socketFactory.port", "465");

p.put("mail.smtp.socketFactory.class","javax.net.ssl.SSLSocketFactory");

p.put("mail.smtp.socketFactory.fallback", "false");

p.put("mail.debug", "true");

p.setProperty("mail.smtp.quitwait", "false");

SecurityManager security = System.getSecurityManager();

try {Authenticator auth = new SMTPAuthenticator(); Session session = Session.
getInstance(p, auth);

MimeMessage msg = new MimeMessage(session);

msg.setFrom(new InternetAddress(from));

InternetAddress<> address = {new InternetAddress(to)};

msg.setRecipints(Message.RecipientType.TO, address);

msg.setSubject("Test Mail");

msg.setSentDate( new Date() );

message.setContent(comment,“mptext/plain");

msg.saveChanges();

Transport.send(msg);

System.out.println("Mail Send Successfully....");

}

catch (MessagingException mex) { mex.printStackTrace();

System.out.println("Mail not sent");}

} //service ends here}

For the above code mention the init() and destroy() method also. Then in the
Properties we have set all the parameters for forwarding the mail. The
MimeMessage initiates the session that will use the Properties parameters and
set the values from the feedback form and configure the message body. The
Transport will send the message over the set protocol, in our case SMTP. As we
use Authenticator class named as SMTPAuthenticator for password verification,
let's define the same.

class SMTPAuthenticator extends javax.mail.Authenticator {

public PasswordAuthentication getPasswordAuthentication() {

return new PasswordAuthentication( "demoaccount", "password");

}

This way we can use JavaMail to send the feedback of a user as e-mail message
to a Gmail account. Even when the web hosting provider does not facilitate you
with a mail server you have JavaMail and Gmail to implement the mailing system
for Web app.

In Conclusion

JavaMail API provides facility with which a developer can configure a complete
mail system for sending/receiving mails over standard mail protocols. It's a
great way to enhance your Web applications.