Java Tutorial/Servlet/Email
Send out Mail in a Servlet
JavaMail Servlet
~~~~~~~~~~~~~~~~
Overview:
=========
JavaMailServlet should not be taken as a demo of how to use the Java
Servlet API. It is rather an example of how the JavaMail APIs could
be used in a server in a three-tier environment described by the
following diagram:
+-----------+ +-----------+ +-----------+
| IMAP | | | | |
| Server |<-IMAP->| JavaMail |<-HTTP->| WWW |
+-----------+ | Servlet |--HTML->| Browser |
| SMTP |<-SMTP->| | | |
| Server | | | | |
+-----------+ +-----------+ +-----------+
The JavaMailServlet supports the following functionality:
* login to an IMAP server
* list all the messages in the INBOX folder
* view the selected message
* compose and send a message
Setting up and running the demo:
================================
Note: These instructions explain how to compile and run the servlet
demo with Java Web Server (JWS). The procedure should be similar with
other web servers that support the Java Servlet API.
1. Download the latest version of the Java Web Server from
http://www.sun.ru/software/jwebserver/index.html and
install according to the included documentation. Make
sure JWS is listening to requests on port 80 (you may
need to modify it from default port 8080; use the JWS
Admin Applet). Make sure you can load the Java Web
Server welcome page when you connect with your browser
to the machine that the server is installed on. Also,
make sure your web browser has cookie support turned on.
2. Set your classpath to include the following:
* mail.jar: in the JavaMail API distribution
* activation.jar: in the JAF distribution
* jws.jar: in the /lib/ directory in JWS installation
3. In javamail-1.1/demo/servlet directory, compile the
JavaMailServlet.java file. That produces two class files,
JavaMailServlet.class and MailUserData.class. Copy these
class files to the /servlets/ directory in the JWS
installation.
4. Copy the mail.jar and activation.jar to the /lib/
directory in the JWS installation.
5. Copy the JavaMail.html file to the /public_html/
directory in the JWS installation.
6. Restart Java Web Server to pick up the new jar files
added to its lib directory. Check again that you can
load the default JWS page to verify that the server
is working fine.
7. Using a web browser, go to
http://<hostname>/JavaMail.html and login to a
valid IMAP account. From here on, you can view
messages in your INBOX and create and send new
messages.
JavaMailServlet Design:
=======================
The following is a brief description of JavaMailServlet class. It
is not intended to serve as an example of how to develop servlets;
see http://java.sun.ru/products/servlet for information on the Java
Servlet API. You may find it useful to refer to JavaMailServlet.java
source while reading this.
The JavaMailServlet uses two primary methods to process all
requests: doPost() and doGet(). doPost() processes submissions
from the login and compose forms. When the user logs in, the
doPost() method gets a JavaMail Session and uses the values
of the "hostname", "username" and "password" parameters to login
to the IMAP Store and get the INBOX Folder. To preserve state
between multiple HTTP requests, the necessary information
(Session, Store, Folder, URLName) are collected in the
MailUserData object which is stored using JWS"s Session
technology (don"t confuse HttpSession and JavaMail"s Session--
they are different). Finally, the doPost() method outputs
a table listing the INBOX and the number of messages in it.
Clicking on the "INBOX" link calls the doGet() method
which displays a table of message headers. (See the doGet()
and displayHeaders() methods.)
Clicking on a message generates a request to the servlet with
the message sequence number as a parameter. The doGet() method
receives the request and calls the displayMessage() method
passing it the message sequence number to display. The
displayMessage() method first lists the message headers
by calling the displayMessageHeaders() utility method.
For text/plain messages, the message content is then displayed
as a string wrapped in HTML <pre>...</pre> tags. For multipart
messages, each part is passed to the displayPart() method.
There are two displayPart() methods. The one with signature
displayPart(MailUserData mud, int msgNum, Part part,
int partNum, HttpServletRequest req,
ServletOutputStream out)
is called from the displayMessage() method for each part. For
any part with text/plain content type, the content is output
as a string wrapped in HTML <pre>...</pre> tags. For other
content types, a link representing the part is displayed,
along with the part filename and description, if available.
Clicking in the part link generates a request to the servlet
with two parameters: the message sequence number and the
part number. The doGet() method interprets the parameters and
invokes the second displayPart() method with the signature
displayPart(MailUserData mud, int msgNum,
int partNum, ServletOutputStream out,
HttpServletResponse res)
This method retrieves the specified part from the message and
streams it to the web browser, preceded by the MIME content type
of this part. For example, if the part has a MIME type image/gif,
the method will set the servlet response MIME content type to
"image/gif" and then follow it with the bytes of the actual
image. This leverages the web browser"s content handling
ability to display different media types.
Message composition and sending is very similar to message
viewing. When the "Compose" link is clicked in the headerlist
page, the servlet outputs the HTML source for the compose
form stored in the composeForm variable. The user then fills
in the destination address, subject, text, and presses
send. This sends a POST request to the servlet, which
invokes the doPost() method. doPost() calls the servlet"s
send() method, which creates a new MimeMessage and fills
it with data retrieved from the POST request. The message
is then sent to its destination using the Transport.send()
static method.
