JavaMail quick start -- Send and receive email with the JavaMail APIs (转-来自JavaWorld)

最新推荐文章于 2018-08-12 10:54:00 发布
最新推荐文章于 2018-08-12 10:54:00 发布
阅读量4.7k 收藏
点赞数
分类专栏： Java 文章标签： javamail email string exception java session
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangxp_82/article/details/533399
版权

In JavaMail you'll find APIs and provider implementations allowing you to develop fully functional email client applications. "Email client applications" invokes thoughts of Microsoft Outlook; and, yes, you could write your own Outlook replacement. But an email client need not reside on a client machine at all. Indeed, it could be a servlet or an EJB running on a remote server, providing end-user access to email via a Web browser. Think of Hotmail (yes, you could write your own version of Hotmail too). Or you could avoid a user interface altogether. How about an auto-responder that reads incoming messages and sends replies, customized according to the original sender?

In my own pet project, a talking email client reads -- that is, speaks -- incoming messages. It's based on a refinement of an idea I introduced in "Talking Java!" I'll tell you more about it later.

For now, start by installing and configuring the JavaMail software.

Setup
If you use Java 2 Platform, Enterprise Edition (J2EE) 1.3, you're in luck: it includes JavaMail, so no additional setup is required. If, however, you're running Java 2 Platform, Standard Edition (J2SE) 1.1.7 and upwards, and you want email capability for your applications, download and install the following:

To install, simply unzip the downloaded files and add the contained jar files to your classpath. As an example, here's my classpath for this project:

.;C:/Apps/Java/javamail-1.2/mail.jar;C:/Apps/Java
/javamail-1.2/mailapi.jar;C:/Apps/Java/javamail-1.2
/pop3.jar;C:/Apps/Java/javamail-1.2/smtp.jar;C:/Apps
/Java/jaf-1.0.1/activation.jar

.;C:/Apps/Java/javamail-1.2/mail.jar;C:/Apps/Java
/javamail-1.2/mailapi.jar;C:/Apps/Java/javamail-1.2
/pop3.jar;C:/Apps/Java/javamail-1.2/smtp.jar;C:/Apps
/Java/jaf-1.0.1/activation.jar

The mailapi.jar file contains the core API classes, while the pop3.jar and smtp.jar files contain the provider implementations for the respective mail protocols. (We won't use the imap.jar file in this article.) Think of the provider implementations as similar to JDBC (Java Database Connectivity) drivers, but for messaging systems rather than databases. As for the mail.jar file, it contains each of the above jar files, so you could restrict your classpath to just the mail.jar and activation.jar files.

The activation.jar file allows you to handle MIME (Multipurpose Internet Mail Extensions) types accessible via binary data streams. Look for the DataHandler class in the Not Just Plain Text section later.

For the record, the rest of this article does not offer comprehensive API coverage; rather, you will learn by doing. If it's in-depth API information you're looking for, then look at the PDF files and Javadocs included in the respective download bundles.

Once you've installed the software, you need to get email account details to run the examples that follow. You'll need your ISP's SMTP (Simple Mail Transfer Protocol) server name and POP (Post Office Protocol) server name, your email account login name, and your mailbox password. Figure 1 shows my details -- not the real ones, you understand -- as used by Microsoft Outlook.


Figure 1. Tony's Internet mail settings

Figure 1. Tony's Internet mail settings

Sending email via SMTP
The first example shows how to send a basic email message via SMTP. Below, you'll find the SimpleSender class, which takes your message's details from the command line and calls a separate method -- send(...) -- to send it:

package com.lotontech.mail;

import javax.mail.*;
import javax.mail.internet.*;

import java.util.*;

/**
  * A simple email sender class.
  */
public class SimpleSender
{

  /**
    * Main method to send a message given on the command line.
    */
  public static void main(String args[])
  {
    try
    {
      String smtpServer=args[0];
      String to=args[1];
      String from=args[2];
      String subject=args[3];
      String body=args[4];

      send(smtpServer, to, from, subject, body);
    }
    catch (Exception ex)
    {
      System.out.println("Usage: java com.lotontech.mail.SimpleSender"
       +" smtpServer toAddress fromAddress subjectText bodyText");
    }

    System.exit(0);
  }

package com.lotontech.mail;

import javax.mail.*;
import javax.mail.internet.*;

import java.util.*;

/**
  * A simple email sender class.
  */
public class SimpleSender
{

  /**
    * Main method to send a message given on the command line.
    */
  public static void main(String args[])
  {
    try
    {
      String smtpServer=args[0];
      String to=args[1];
      String from=args[2];
      String subject=args[3];
      String body=args[4];

      send(smtpServer, to, from, subject, body);
    }
    catch (Exception ex)
    {
      System.out.println("Usage: java com.lotontech.mail.SimpleSender"
       +" smtpServer toAddress fromAddress subjectText bodyText");
    }

    System.exit(0);
  }

Next, run SimpleSender as below. Replace smtp.myISP.net with your own SMTP server, as derived from your mail settings:

> java com.lotontech.mail.SimpleSender smtp.myISP.net bill@lotontech.com ben@lotontech.com "Hello" "Just to say Hello."

> java com.lotontech.mail.SimpleSender smtp.myISP.net bill@lotontech.com ben@lotontech.com "Hello" "Just to say Hello."

And, if it works, at the receiving end you'll see something like what's shown in Figure 2.


Figure 2. Message received from SimpleSender

Figure 2. Message received from SimpleSender

The send(...) method completes the SimpleSender class. I'll show the code first, then detail the theory:

  /**
    * "send" method to send the message.
    */
  public static void send(String smtpServer, String to, String from
   , String subject, String body)
  {
    try
    {
      Properties props = System.getProperties();

      // -- Attaching to default Session, or we could start a new one --

      props.put("mail.smtp.host", smtpServer);
      Session session = Session.getDefaultInstance(props, null);

      // -- Create a new message --
      Message msg = new MimeMessage(session);

      // -- Set the FROM and TO fields --
      msg.setFrom(new InternetAddress(from));
      msg.setRecipients(Message.RecipientType.TO,
        InternetAddress.parse(to, false));

      // -- We could include CC recipients too --
      // if (cc != null)
      // msg.setRecipients(Message.RecipientType.CC
      // ,InternetAddress.parse(cc, false));

      // -- Set the subject and body text --
      msg.setSubject(subject);
      msg.setText(body);

      // -- Set some other header information --
      msg.setHeader("X-Mailer", "LOTONtechEmail");
      msg.setSentDate(new Date());

      // -- Send the message --
      Transport.send(msg);

      System.out.println("Message sent OK.");
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
  }
}

  /**
    * "send" method to send the message.
    */
  public static void send(String smtpServer, String to, String from
   , String subject, String body)
  {
    try
    {
      Properties props = System.getProperties();

      // -- Attaching to default Session, or we could start a new one --

      props.put("mail.smtp.host", smtpServer);
      Session session = Session.getDefaultInstance(props, null);

      // -- Create a new message --
      Message msg = new MimeMessage(session);

      // -- Set the FROM and TO fields --
      msg.setFrom(new InternetAddress(from));
      msg.setRecipients(Message.RecipientType.TO,
        InternetAddress.parse(to, false));

      // -- We could include CC recipients too --
      // if (cc != null)
      // msg.setRecipients(Message.RecipientType.CC
      // ,InternetAddress.parse(cc, false));

      // -- Set the subject and body text --
      msg.setSubject(subject);
      msg.setText(body);

      // -- Set some other header information --
      msg.setHeader("X-Mailer", "LOTONtechEmail");
      msg.setSentDate(new Date());

      // -- Send the message --
      Transport.send(msg);

      System.out.println("Message sent OK.");
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
  }
}

First, notice that you're obtaining a mail session (java.mail.Session), without which you can do nothing. In this case you're calling Session.getDefaultInstance(...) to get a shared session, which other desktop applications may reuse; you can also set up an entirely new session -- via the Session.getInstance(...) method -- that would be unique to your application. The latter could prove important for email clients not isolated on a per-user basis, such as a Web-based email system implemented with servlets.

Establishing a session requires you to set certain properties; at minimum, you need the mail.smtp.host property if you're sending messages via SMTP. You'll find other properties described within the API documentation.

Once you have a session, create a message. In this example, you're setting the message's from and to email addresses, the subject, and the body text, all taken originally from the command line. You're also setting some header information, including the date, and you can specify cc recipients if you want.

Finally, you send the message via the javax.mail.Transport class. If you wonder how it knows about our mail session, look back at the message's constructor.

Not just plain text
The setText(...) convenience method in class javax.mail.Message (inherited from the javax.mail.Part interface) sets the message content to the supplied string and sets the MIME type to text/plain.

You're not limited to plain text, though: you can send other content types via the setDataHandler(...) method. In most cases you can take "other content types" to mean file attachments, such as Word documents, but for something a bit more interesting, check out this code for sending a Java serialized object:

ByteArrayOutputStream byteStream=new ByteArrayOutputStream();
ObjectOutputStream objectStream=new ObjectOutputStream(byteStream);
objectStream.writeObject(theObject);

msg.setDataHandler(new DataHandler( new ByteArrayDataSource( byteStream.toByteArray(), "lotontech/javaobject" )));

ByteArrayOutputStream byteStream=new ByteArrayOutputStream();
ObjectOutputStream objectStream=new ObjectOutputStream(byteStream);
objectStream.writeObject(theObject);

msg.setDataHandler(new DataHandler( new ByteArrayDataSource( byteStream.toByteArray(), "lotontech/javaobject" )));

You won't find the DataHandler class within the javax.mail.* package structure because it belongs to the JavaBeans Activation Framework (JAF) package javax.activation. Remember, you downloaded the JAF distribution as well as JavaMail. JAF provides a mechanism for handling typed data content, which for Internet content means MIME types.

And if you really do try the code above for sending a Java object by email, you'll have trouble locating the ByteArrayDataSource class, as neither mail.jar nor activation.jar include it. Try looking in the JavaMail demo directory!

As for those file attachments that you're more likely to be interested in initially, you would create a javax.activation.FileDataSource instance in the DataHandler's constructor. Of course, you're not likely to send a file alone; rather, it will probably be an attachment to a text message. For that you need to understand the concept of multipart messages, so I'll introduce that concept now, in the context of receiving email.

Receive email via POP3
Earlier, I introduced the javax.mail.Part interface implemented by javax.mail.Message. I'll now explain its message parts, which are important in this example. To start, take a look at Figure 3.

Figure 3 shows a Message as created in the previous example that is both a message and message part, because it implements the Part interface. For any part, you can get its content (any Java object), and, in the case of a simple text message, the content object may be a String. For a multipart message, the content will be of type Multipart, from which we can get hold of the individual body parts, which themselves implement the Part interface.


Figure 3. UML diagram for the mail.Part interface

Figure 3. UML diagram for the mail.Part interface

In practice, all will become apparent as you step through the code for a SimpleReceiver class, which I'll present in three sections: first, the class definition and the main(...) method that takes connection details from the command line; second, the receive(...) method that captures and steps through the incoming messages; and finally, the printMessage(...) method that prints the header information and content of each message.

Here's the first section:

package com.lotontech.mail;

import javax.mail.*;
import javax.mail.internet.*;

import java.util.*;
import java.io.*;

/**
  * A simple email receiver class.
  */
public class SimpleReceiver
{

  /**
    * Main method to receive messages from the mail server specified
    * as command line arguments.
    */
  public static void main(String args[])
  {
    try
    {
      String popServer=args[0];
      String popUser=args[1];
      String popPassword=args[2];

      receive(popServer, popUser, popPassword);
    }
    catch (Exception ex)
    {
      System.out.println("Usage: java com.lotontech.mail.SimpleReceiver"
       +" popServer popUser popPassword");
    }

    System.exit(0);
  }

package com.lotontech.mail;

import javax.mail.*;
import javax.mail.internet.*;

import java.util.*;
import java.io.*;

/**
  * A simple email receiver class.
  */
public class SimpleReceiver
{

  /**
    * Main method to receive messages from the mail server specified
    * as command line arguments.
    */
  public static void main(String args[])
  {
    try
    {
      String popServer=args[0];
      String popUser=args[1];
      String popPassword=args[2];

      receive(popServer, popUser, popPassword);
    }
    catch (Exception ex)
    {
      System.out.println("Usage: java com.lotontech.mail.SimpleReceiver"
       +" popServer popUser popPassword");
    }

    System.exit(0);
  }

I'll take you through a proper test drive later, but for now here is the command line to run it (remember to replace the command arguments with your mail settings):

> java com.lotontech.mail.SimpleReceiver pop.myIsp.net myUserName myPassword

> java com.lotontech.mail.SimpleReceiver pop.myIsp.net myUserName myPassword

The receive(...) method -- called from main(...) -- opens your POP3 INBOX and steps through the messages in turn, each time calling printMessage(...). Here is the code:

  /**
    * "receive" method to fetch messages and process them.
    */
  public static void receive(String popServer, String popUser
   , String popPassword)
  {

    Store store=null;
    Folder folder=null;

    try
    {
      // -- Get hold of the default session --
      Properties props = System.getProperties();
      Session session = Session.getDefaultInstance(props, null);

      // -- Get hold of a POP3 message store, and connect to it --
      store = session.getStore("pop3");
      store.connect(popServer, popUser, popPassword);
      
      // -- Try to get hold of the default folder --
      folder = store.getDefaultFolder();
      if (folder == null) throw new Exception("No default folder");

      // -- ...and its INBOX --
      folder = folder.getFolder("INBOX");
      if (folder == null) throw new Exception("No POP3 INBOX");

      // -- Open the folder for read only --
      folder.open(Folder.READ_ONLY);

      // -- Get the message wrappers and process them --
      Message[] msgs = folder.getMessages();
      for (int msgNum = 0; msgNum < msgs.length; msgNum++)
      {
        printMessage(msgs[msgNum]);
      }

    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
    finally
    {
      // -- Close down nicely --
      try
      {
        if (folder!=null) folder.close(false);
        if (store!=null) store.close();
      }
      catch (Exception ex2) {ex2.printStackTrace();}
    }
  }

  /**
    * "receive" method to fetch messages and process them.
    */
  public static void receive(String popServer, String popUser
   , String popPassword)
  {

    Store store=null;
    Folder folder=null;

    try
    {
      // -- Get hold of the default session --
      Properties props = System.getProperties();
      Session session = Session.getDefaultInstance(props, null);

      // -- Get hold of a POP3 message store, and connect to it --
      store = session.getStore("pop3");
      store.connect(popServer, popUser, popPassword);
      
      // -- Try to get hold of the default folder --
      folder = store.getDefaultFolder();
      if (folder == null) throw new Exception("No default folder");

      // -- ...and its INBOX --
      folder = folder.getFolder("INBOX");
      if (folder == null) throw new Exception("No POP3 INBOX");

      // -- Open the folder for read only --
      folder.open(Folder.READ_ONLY);

      // -- Get the message wrappers and process them --
      Message[] msgs = folder.getMessages();
      for (int msgNum = 0; msgNum < msgs.length; msgNum++)
      {
        printMessage(msgs[msgNum]);
      }

    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
    finally
    {
      // -- Close down nicely --
      try
      {
        if (folder!=null) folder.close(false);
        if (store!=null) store.close();
      }
      catch (Exception ex2) {ex2.printStackTrace();}
    }
  }

Notice that you're obtaining a POP3 message-store wrapper from the session, then connecting to it using the mail settings originally supplied on the command line.

Once connected, you get a handle on the default folder -- effectively the root of the folder tree -- and, from there, the INBOX folder that holds the inbound messages. You open the INBOX for read-only access; you get hold of the messages and step through them one by one.

As an aside, you might wonder if you would ever want to open the INBOX for write access. You would if you intended to mark the messages as received and/or remove them from the server. In our example, you're only looking at them.

Finally, in the code above you're taking care to close the folder and the message store when finished, which leaves only the printMessage(...) method to complete this class.

Print the messages
In this section, the earlier javax.mail.Part interface discussion becomes relevant.

In the code that follows you will see how to implicitly cast the message to its Part interface and assign it to the messagePart variable. For single-part messages you now have something to print.

If a call to messagePart.getContent() yields a Multipart instance, you know you're dealing with a multipart message; in that case, you're getting hold of the first multipart -- via getBodyPart(0) -- and printing it.

Whether you've got a hold of the message itself, or only the first body part, you're printing it only if the content is plain text or HTML, and you're doing so by reading from an InputStream:

  /**
    * "printMessage()" method to print a message.
    */
  public static void printMessage(Message message)
  {
    try
    {
      // Get the header information
      String from=((InternetAddress)message.getFrom()[0]).getPersonal();
      if (from==null) from=((InternetAddress)message.getFrom()[0])
       .getAddress();
      System.out.println("FROM: "+from);

      String subject=message.getSubject();
      System.out.println("SUBJECT: "+subject);

      // -- Get the message part (i.e. the message itself) --
      Part messagePart=message;
      Object content=messagePart.getContent();

      // -- or its first body part if it is a multipart message --
      if (content instanceof Multipart)
      {
        messagePart=((Multipart)content).getBodyPart(0);
        System.out.println("[ Multipart Message ]");
      }

      // -- Get the content type --
      String contentType=messagePart.getContentType();

      // -- If the content is plain text, we can print it --
      System.out.println("CONTENT:"+contentType);

      if (contentType.startsWith("text/plain")
       || contentType.startsWith("text/html"))
      {
        InputStream is = messagePart.getInputStream();

        BufferedReader reader
         =new BufferedReader(new InputStreamReader(is));
        String thisLine=reader.readLine();

        while (thisLine!=null)
        {
          System.out.println(thisLine);
          thisLine=reader.readLine();
        }
      }

      System.out.println("-----------------------------");
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
  }
}

  /**
    * "printMessage()" method to print a message.
    */
  public static void printMessage(Message message)
  {
    try
    {
      // Get the header information
      String from=((InternetAddress)message.getFrom()[0]).getPersonal();
      if (from==null) from=((InternetAddress)message.getFrom()[0])
       .getAddress();
      System.out.println("FROM: "+from);

      String subject=message.getSubject();
      System.out.println("SUBJECT: "+subject);

      // -- Get the message part (i.e. the message itself) --
      Part messagePart=message;
      Object content=messagePart.getContent();

      // -- or its first body part if it is a multipart message --
      if (content instanceof Multipart)
      {
        messagePart=((Multipart)content).getBodyPart(0);
        System.out.println("[ Multipart Message ]");
      }

      // -- Get the content type --
      String contentType=messagePart.getContentType();

      // -- If the content is plain text, we can print it --
      System.out.println("CONTENT:"+contentType);

      if (contentType.startsWith("text/plain")
       || contentType.startsWith("text/html"))
      {
        InputStream is = messagePart.getInputStream();

        BufferedReader reader
         =new BufferedReader(new InputStreamReader(is));
        String thisLine=reader.readLine();

        while (thisLine!=null)
        {
          System.out.println(thisLine);
          thisLine=reader.readLine();
        }
      }

      System.out.println("-----------------------------");
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
  }
}

For simplicity I've assumed that the message itself, or the first body part, is printable. For any real application, you would want to step through every body part in turn and for each one take some appropriate action -- print it or save it to disk, depending on the content type.

As you fetch each message from the message store, you're actually getting hold of a lightweight wrapper. The data content itself is fetched using a lazy approach, at the time you ask for it -- useful if you wish to download only the message headers initially.

SimpleReceiver test drive
Let's take the SimpleReceiver for a test drive. To give it something to receive, I sent out the message illustrated in Figure 4 (notice that the message comprises text and an attachment).


Figure 4. Test message for SimpleReceiver

Figure 4. Test message for SimpleReceiver

Upon reception it was identified as a multipart message. The text printed as:

FROM: Tony Loton
SUBJECT: Number 1
[ Multipart Message ]
CONTENT:text/plain;
        charset="iso-8859-1"
Attachment 1
from Tony Loton.
-----------------------------

Speak the messages
For a bit of fun, and to demonstrate a novel use of the JavaMail APIs, I now briefly turn to my talking email project. To try this out you'll need the lotontalk.jar file (supplied), and you'll need to include it in your classpath, as in:

set CLASSPATH=%CLASSPATH%;lotontalk.jar

set CLASSPATH=%CLASSPATH%;lotontalk.jar

You'll also need to make two code changes within the SimpleReceiver class. First, inside the receive(...) method, replace this code:

// -- Get the message wrappers and process them --
Message[] msgs = folder.getMessages();
for (int msgNum = 0; msgNum < msgs.length; msgNum++)
{
  printMessage(msgs[msgNum]);
}

// -- Get the message wrappers and process them --
Message[] msgs = folder.getMessages();
for (int msgNum = 0; msgNum < msgs.length; msgNum++)
{
  printMessage(msgs[msgNum]);
}

with:

// -- Get the message wrappers and process them --
Message[] msgs = folder.getMessages();
for (int msgNum = 0; msgNum < msgs.length; msgNum++)
{
  printMessage(msgs[msgNum]);
  speakMessage(msgs[msgNum]);
}

// -- Get the message wrappers and process them --
Message[] msgs = folder.getMessages();
for (int msgNum = 0; msgNum < msgs.length; msgNum++)
{
  printMessage(msgs[msgNum]);
  speakMessage(msgs[msgNum]);
}

Now add the following new method, speakMessage(...), which is similar to the original printMessage() method:

/**
  * "speakMessage", a talking version of printMessage().
  */
public static void speakMessage(Message message)
{
  String speech="";

  try
  {
    com.lotontech.talk.LOTONtalk speaker
     =new com.lotontech.talk.LOTONtalk();

    String from=((InternetAddress)message.getFrom()[0]).getPersonal();
    if (from==null) from=((InternetAddress)message.getFrom()[0])
     .getAddress();
    speech=speech+"from "+from+", ";

    String subject=message.getSubject();
    speech=speech+"subject "+subject+", ";

    // -- Get the message part (i.e., the message itself) --
    Part messagePart=message;
    Object content=messagePart.getContent();

    // -- ...or its first body part if it is a multipart message --
    if (content instanceof Multipart)
      messagePart=((Multipart)content).getBodyPart(0);

    String contentType=messagePart.getContentType();

    if (contentType.startsWith("text/plain")
     || contentType.startsWith("text/html"))
    {
      InputStream is = messagePart.getInputStream();

      BufferedReader reader
       =new BufferedReader(new InputStreamReader(is));
      String thisLine=reader.readLine();

      while (thisLine!=null)
      {
        speech=speech+thisLine+". ";
        thisLine=reader.readLine();
      }

      // -- SPEAK --
      speaker.speak(speech,true);
    }
  }
  catch (Exception ex)
  {
    ex.printStackTrace();
  }
}

/**
  * "speakMessage", a talking version of printMessage().
  */
public static void speakMessage(Message message)
{
  String speech="";

  try
  {
    com.lotontech.talk.LOTONtalk speaker
     =new com.lotontech.talk.LOTONtalk();

    String from=((InternetAddress)message.getFrom()[0]).getPersonal();
    if (from==null) from=((InternetAddress)message.getFrom()[0])
     .getAddress();
    speech=speech+"from "+from+", ";

    String subject=message.getSubject();
    speech=speech+"subject "+subject+", ";

    // -- Get the message part (i.e., the message itself) --
    Part messagePart=message;
    Object content=messagePart.getContent();

    // -- ...or its first body part if it is a multipart message --
    if (content instanceof Multipart)
      messagePart=((Multipart)content).getBodyPart(0);

    String contentType=messagePart.getContentType();

    if (contentType.startsWith("text/plain")
     || contentType.startsWith("text/html"))
    {
      InputStream is = messagePart.getInputStream();

      BufferedReader reader
       =new BufferedReader(new InputStreamReader(is));
      String thisLine=reader.readLine();

      while (thisLine!=null)
      {
        speech=speech+thisLine+". ";
        thisLine=reader.readLine();
      }

      // -- SPEAK --
      speaker.speak(speech,true);
    }
  }
  catch (Exception ex)
  {
    ex.printStackTrace();
  }
}

Because you're accumulating the whole message text in a string before speaking it, this solution may be suitable only for small messages. Alternatively, you could speak each line of text as you read it.

Of course, it's impossible for me to show the result visually, so you'll have to try it for yourself. You have everything you need, and, though it's not yet half as good as I'd like it to be, you'll get a feel for where it's heading.

With a little experimentation, possibly outside of this example, you will discover some interesting features of the speech synthesis: how it handles numbers, and how it assumes wholly capitalized words to be acronyms, thus S-P-E-L-L-I-N-G them out.

For further consideration
We've covered quite a bit of ground here, putting in place the basic building blocks for applications that send and receive email messages. As a starting point, it's not difficult to get messages into -- and out of -- your Java applications, is it?

Yet there is more to learn if you look deeper. Here is a rundown of what we've covered and what you might look at next.

Send messages
We looked at how to send single-part messages via the SMTP protocol, though I did hint at how you could send nontext content -- i.e., a Java serialized object -- as the single message part.

Later, we looked at the Part interface in the context of multipart messages. You might now like to apply that knowledge to sending messages. How about sending a multipart message comprising some plain text and a file attachment?

Receive messages
We looked at receiving multipart messages, but for viewing only. The messages we receive remain on the server, to be reread as many times as we like, until we remove them. How would we do that? To change the status of messages on the server, consider this line of code:

message.setFlag(Flags.Flag.ANSWERED,true);

message.setFlag(Flags.Flag.ANSWERED,true);

As an illustration for sending nontext content, I introduced the idea of writing a Java serialized object into a mail message. Could you complete the picture by now receiving such objects, as the basis of a kind of asynchronous Object Request Broker for disconnected applications? Believe it or not, I did something like that, and it's not as ridiculous as it sounds for field engineers who need to send batches of updates to client records whenever they get the chance to go online. Before you all start shouting, I know it's more fashionable these days to use XML -- rather than serialized objects -- for that! If you're interested, the receiving code looks like this:

InputStream is = (InputStream) message.getContent();
ObjectInputStream objectStream=new ObjectInputStream(is);
Object theObject=objectStream.readObject();

InputStream is = (InputStream) message.getContent();
ObjectInputStream objectStream=new ObjectInputStream(is);
Object theObject=objectStream.readObject();

Talking email
Talking email may interest you in terms of a desktop application that reads incoming messages, but I have another idea. Several ISPs -- in the UK at least -- provide a SpeechMail service that allows you to dial a telephone number from anywhere in the world and have your INBOX messages spoken to you. You can see the kind of service I mean at http://www.btinternet.com.

I don't think that this service is built with Java, but it is possible -- and the speech sounds distinctly allophonic, meaning that the BT Internet developers have taken more or less the same approach to speech synthesis as I have.

Finally
I hope I've provided a good starting point for your email-enabled Java applications, with a few ideas thrown in for where to take it next. I'll judge the usefulness of this article by the number of Java-based email clients and Webmail sites that spring up over the coming months!

About the author
Tony Loton works through his company -- LOTONtech Limited -- to provide software solutions, consultancy, training, and technical writing services. The writing bug seems to have bitten Tony this year, with his involvement in book projects for John Wiley & Sons and Wrox Press.


FROM: Tony Loton
SUBJECT: Number 1
[ Multipart Message ]
CONTENT:text/plain;
        charset="iso-8859-1"
Attachment 1
from Tony Loton.
-----------------------------

Speak the messages
For a bit of fun, and to demonstrate a novel use of the JavaMail APIs, I now briefly turn to my talking email project. To try this out you'll need the lotontalk.jar file (supplied), and you'll need to include it in your classpath, as in:

set CLASSPATH=%CLASSPATH%;lotontalk.jar

set CLASSPATH=%CLASSPATH%;lotontalk.jar

You'll also need to make two code changes within the SimpleReceiver class. First, inside the receive(...) method, replace this code:

// -- Get the message wrappers and process them --
Message[] msgs = folder.getMessages();
for (int msgNum = 0; msgNum < msgs.length; msgNum++)
{
  printMessage(msgs[msgNum]);
}

// -- Get the message wrappers and process them --
Message[] msgs = folder.getMessages();
for (int msgNum = 0; msgNum < msgs.length; msgNum++)
{
  printMessage(msgs[msgNum]);
}

with:

// -- Get the message wrappers and process them --
Message[] msgs = folder.getMessages();
for (int msgNum = 0; msgNum < msgs.length; msgNum++)
{
  printMessage(msgs[msgNum]);
  speakMessage(msgs[msgNum]);
}

// -- Get the message wrappers and process them --
Message[] msgs = folder.getMessages();
for (int msgNum = 0; msgNum < msgs.length; msgNum++)
{
  printMessage(msgs[msgNum]);
  speakMessage(msgs[msgNum]);
}

Now add the following new method, speakMessage(...), which is similar to the original printMessage() method:

/**
  * "speakMessage", a talking version of printMessage().
  */
public static void speakMessage(Message message)
{
  String speech="";

  try
  {
    com.lotontech.talk.LOTONtalk speaker
     =new com.lotontech.talk.LOTONtalk();

    String from=((InternetAddress)message.getFrom()[0]).getPersonal();
    if (from==null) from=((InternetAddress)message.getFrom()[0])
     .getAddress();
    speech=speech+"from "+from+", ";

    String subject=message.getSubject();
    speech=speech+"subject "+subject+", ";

    // -- Get the message part (i.e., the message itself) --
    Part messagePart=message;
    Object content=messagePart.getContent();

    // -- ...or its first body part if it is a multipart message --
    if (content instanceof Multipart)
      messagePart=((Multipart)content).getBodyPart(0);

    String contentType=messagePart.getContentType();

    if (contentType.startsWith("text/plain")
     || contentType.startsWith("text/html"))
    {
      InputStream is = messagePart.getInputStream();

      BufferedReader reader
       =new BufferedReader(new InputStreamReader(is));
      String thisLine=reader.readLine();

      while (thisLine!=null)
      {
        speech=speech+thisLine+". ";
        thisLine=reader.readLine();
      }

      // -- SPEAK --
      speaker.speak(speech,true);
    }
  }
  catch (Exception ex)
  {
    ex.printStackTrace();
  }
}

/**
  * "speakMessage", a talking version of printMessage().
  */
public static void speakMessage(Message message)
{
  String speech="";

  try
  {
    com.lotontech.talk.LOTONtalk speaker
     =new com.lotontech.talk.LOTONtalk();

    String from=((InternetAddress)message.getFrom()[0]).getPersonal();
    if (from==null) from=((InternetAddress)message.getFrom()[0])
     .getAddress();
    speech=speech+"from "+from+", ";

    String subject=message.getSubject();
    speech=speech+"subject "+subject+", ";

    // -- Get the message part (i.e., the message itself) --
    Part messagePart=message;
    Object content=messagePart.getContent();

    // -- ...or its first body part if it is a multipart message --
    if (content instanceof Multipart)
      messagePart=((Multipart)content).getBodyPart(0);

    String contentType=messagePart.getContentType();

    if (contentType.startsWith("text/plain")
     || contentType.startsWith("text/html"))
    {
      InputStream is = messagePart.getInputStream();

      BufferedReader reader
       =new BufferedReader(new InputStreamReader(is));
      String thisLine=reader.readLine();

      while (thisLine!=null)
      {
        speech=speech+thisLine+". ";
        thisLine=reader.readLine();
      }

      // -- SPEAK --
      speaker.speak(speech,true);
    }
  }
  catch (Exception ex)
  {
    ex.printStackTrace();
  }
}

Because you're accumulating the whole message text in a string before speaking it, this solution may be suitable only for small messages. Alternatively, you could speak each line of text as you read it.

Of course, it's impossible for me to show the result visually, so you'll have to try it for yourself. You have everything you need, and, though it's not yet half as good as I'd like it to be, you'll get a feel for where it's heading.

With a little experimentation, possibly outside of this example, you will discover some interesting features of the speech synthesis: how it handles numbers, and how it assumes wholly capitalized words to be acronyms, thus S-P-E-L-L-I-N-G them out.

For further consideration
We've covered quite a bit of ground here, putting in place the basic building blocks for applications that send and receive email messages. As a starting point, it's not difficult to get messages into -- and out of -- your Java applications, is it?

Yet there is more to learn if you look deeper. Here is a rundown of what we've covered and what you might look at next.

Send messages
We looked at how to send single-part messages via the SMTP protocol, though I did hint at how you could send nontext content -- i.e., a Java serialized object -- as the single message part.

Later, we looked at the Part interface in the context of multipart messages. You might now like to apply that knowledge to sending messages. How about sending a multipart message comprising some plain text and a file attachment?

Receive messages
We looked at receiving multipart messages, but for viewing only. The messages we receive remain on the server, to be reread as many times as we like, until we remove them. How would we do that? To change the status of messages on the server, consider this line of code:

message.setFlag(Flags.Flag.ANSWERED,true);

message.setFlag(Flags.Flag.ANSWERED,true);

As an illustration for sending nontext content, I introduced the idea of writing a Java serialized object into a mail message. Could you complete the picture by now receiving such objects, as the basis of a kind of asynchronous Object Request Broker for disconnected applications? Believe it or not, I did something like that, and it's not as ridiculous as it sounds for field engineers who need to send batches of updates to client records whenever they get the chance to go online. Before you all start shouting, I know it's more fashionable these days to use XML -- rather than serialized objects -- for that! If you're interested, the receiving code looks like this:

InputStream is = (InputStream) message.getContent();
ObjectInputStream objectStream=new ObjectInputStream(is);
Object theObject=objectStream.readObject();

InputStream is = (InputStream) message.getContent();
ObjectInputStream objectStream=new ObjectInputStream(is);
Object theObject=objectStream.readObject();

Talking email
Talking email may interest you in terms of a desktop application that reads incoming messages, but I have another idea. Several ISPs -- in the UK at least -- provide a SpeechMail service that allows you to dial a telephone number from anywhere in the world and have your INBOX messages spoken to you. You can see the kind of service I mean at http://www.btinternet.com.

I don't think that this service is built with Java, but it is possible -- and the speech sounds distinctly allophonic, meaning that the BT Internet developers have taken more or less the same approach to speech synthesis as I have.

Finally
I hope I've provided a good starting point for your email-enabled Java applications, with a few ideas thrown in for where to take it next. I'll judge the usefulness of this article by the number of Java-based email clients and Webmail sites that spring up over the coming months!

About the author
Tony Loton works through his company -- LOTONtech Limited -- to provide software solutions, consultancy, training, and technical writing services. The writing bug seems to have bitten Tony this year, with his involvement in book projects for John Wiley & Sons and Wrox Press.


yangxp_82
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
javamail-1.4.7完整.rar
06-09
1. **JAR 文件**：`javamail-1.4.7.jar` - 这是 JavaMail 的主库，包含了所有核心功能。 2. **Demo 应用**：可能包含演示如何使用 JavaMail API 的示例代码，这些示例可以帮助开发者快速理解和学习如何使用 JavaMail...
javax.mail-1.6.2_javamailjar1.6.2_javamail-1.6.2_javax.mail_java
10-04
`javax.mail-1.6.2_javamailjar1.6.2_javamail-1.6.2_javax.mail_java` 这个标题暗示了我们正在讨论的是 JavaMail 的 1.6.2 版本，这是一个稳定且广泛使用的版本。 JavaMail API 提供了一套标准的接口，用于与邮件...
java web -tomcat
weixin_30608503的博客
08-12 185
一，什么是web服务器 Web服务器可以解析HTTP协议。当Web服务器接收到一个HTTP请求,会返回一个HTTP响应,例如送回一个HTML页面。为了处理一个请求Web服务器可以响应一个静态页面或图片，进行页面跳转或者把动态响应的产生委托给一些其它的程序例如CGI脚本，JSP脚本，servlets，ASP脚本，服务器端JavaScript，或者一些其它的服务器端技术。无论它们的目的如...
Java基础- JAVA知识体系
hoonee
09-21 239
JAVA知识体系 j2se 1.Java语言基础 具体包括：1、对象的初始化；2、继承时，对象的初始化过程；3、关于构造方法；4、有关public、private和protected；5、抽 象类；6、final关键字；7、接口interface；8、多重继承；9、接口的嵌入；10、类的嵌入；11、异常类等。 2.网络编程 Java程序可以获取网络上结点的图象、声音、HTML文档及文本...
Class000-Java体系
junife的专栏
11-22 321
JAVA知识体系 j2se 1.Java语言基础 具体包括：1、对象的初始化；2、继承时，对象的初始化过程；3、关于构造方法；4、有关public、private和protected；5、抽 象类；6、final关键字；7、接口interface；8、多重继承；9、接口的嵌入；10、类的嵌入；11、异常类等。 2.网络编程 Java程序可以获取网络上结点的图象、声音、HTML文档及文本...
曾颖明的博客关于作者
shushan49的专栏
02-25 6717
 9条警世箴言 • 学Java流程 • J2EE之Eclipse+JBoss+MySQL开发环境设置全攻略 • 玩转Java的CLASSPATH • JSP开发前设置篇 • 图解MySQL数据库的安装和操作 • 测试数据库连通: • MySQL安装与设置指南 • To
An introduction to the Java 2 Platform, Enterprise Edition specification by way of BEA's WebLogic Se...
weixin_33854644的博客
12-15 226
Develop n-tier applications using J2EE An introduction to the Java 2 Platform, Enterprise Edition specification by way of BEA's WebLogic Server BySteven Gould,JavaWorld.com,12/01/00 Java origina...
[转] tomcat和web服务器,应用服务器的关系
ccav4137的专栏
04-28 328
Tomcat服务器是一个免费的开放源代码的Web应用服务器。因为Tomcat技术先进、性能稳定且免费，所以深受Java爱好者的喜爱并得到了部分软件开发商的认可，成为目前比较流行的Web应用服务器。 一、Tomcat与应用服务器 到目前为止，Tomcat一直被认为是Servlet/JSP API的执行器，也就所谓的Servlet容器。然而，Tomcat并不仅仅如此，它还提供了JND...
Java性能提示（全）
weixin_34161029的博客
11-15 2175
http://www.onjava.com/pub/a/onjava/2001/05/30/optimization.htmlComparing the performance of LinkedLists and ArrayLists (and Vectors) (Page last updated May 2001, Added 2001-06-18, Author Jack Shirazi,...
Tomcat介绍
意外
06-13 739
一，什么是web服务器      Web服务器可以解析HTTP协议。当Web服务器接收到一个HTTP请求,会返回一个HTTP响应,例如送回一个HTML页面。为了处理一个请求Web服务器可以响应一个静态页面或图片，进行页面跳转或者把动态响应的产生委托给一些其它的程序例如CGI脚本，JSP脚本，servlets，ASP脚本，服务器端JavaScript，或者一些其它的服务器端技术。无论它们的目的如何，...
javamail-javadoc-1.4.6-8.el7.noarch.rpm
01-08
官方离线安装包，测试可用。使用rpm -ivh [rpm完整包名] 进行安装
java_mail.rar_ javamail_java mail_java 下载_javamail-1.4.1_javamai
09-20
标题中的 "javamail-1.4.1" 和 "javamail-1.4.2" 提到了两个特定的版本号，这表明提供的资源可能是这两个版本的 JavaMail 库。 在描述中提到，这个压缩包包含的功能已经实现，可以直接复制到工程中使用，这意味着...
geronimo-spec-javamail-1.3.1-rc3.jar
最新发布
05-21
geronimo-spec-javamail-1.3.1-rc3 java实现 发送mail工具包之一
Java IO学习笔记（１）
09-13 1824
java IO最关键的四个父类：InputStream、OutputStream、Reader、Writer。它们都是public abstract class。 InputSream和OutputStream对于数据的传送是以“byte”为单位的，而Reader和Writer对于数据的传送是以“character”为单位的。所以我们看到java.io包中的类大体上可以分为两大类，一类是以byte
对象池（参考《Thinking in Patterns》）
09-19 1776
        在Bruce Eckel的《Thinking in Patterns》书中给出了一个Object Pool的例子，看上去很舒服，所以照着写了一下，在这里存档。/* * EmptyPoolException.java *  * Date: 2005.9.19 */package objectpool;/** * 对象池为空异常 * @author Sunny * @version 1
毕业后开始程序员生活
06-06 1515
        已经在一家软件公司试用一段时间了，感觉自己的软件设计能力还是跟公司的老程序员有比较大的差距。想要成为一名出色的程序员，我要走的路要是很长的，需要学习的东西还有很多！       今天看了一篇如何成为出色程序员的文章，里面提出了一些很好的建议，我现在也必须给自己制定一个详细的计划，争取迅速成为一名出色的程序员！       首先，开发工具是每个程序员必须通过的第一关，如果没有掌握好开
读取属性文件
11-21 1465
        在很多的J2EE项目中都使用属性文件来存储应用的基本状态、特性等等。下面就具体介绍属性文件是如何使用的。（通过代码学习）首先是用到的属性文件：----------- test.properties ------------test=0000000以下是测试代码：import java.util.Properties;import java.io.*;public class Tes
Java使用javamail-1.5.3-src实现自动发送邮件
JavaMail API 提供了这样的能力，让我们能够通过编程的方式发送电子邮件。这里我们将探讨如何使用JavaMail API（版本1.5.3）来配置和实现邮件发送功能。 首先，为了使用JavaMail，我们需要引入相应的库。有多种方式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值