http://www.developer.com/

Back to article

Consolidating Email using Java, Part 2


November 15, 2005

Java Programming Notes # 2402


Preface

Multiple Email accounts?

In Part 1 of this lesson, I asked the following questions:

  1. How many different Email accounts do you have?
  2. Do you check them all regularly?
  3. Do you have an easy way to consolidate them so that you only have to check one Email account in order to read all of your Email?

I then went on to provide and explain an interactive Java program that you can use to consolidate all of your Email messages from different accounts onto a single Email server.

If the answer to the first question above was more than one Email account, and the answer to the last question was no, then either the program that I provided in Part 1 or the program that I will provide in this lesson may be of considerable interest to you.

The difference between the two programs

This lesson provides a non-interactive version of the program from Part 1 that you can use to consolidate all of your Email messages onto a single Email server on a scheduled, unattended, automatic basis.

By non-interactive, I mean that the difference between this program and the program from Part 1 is:

  • The program in Part 1 requires user interaction each time messages are moved from one Email server to another.
  • The program that I will present in this lesson is a "set it and forget it" program.

Set it and forget it

In other words, you can set this program up as a Scheduled Task in a task scheduler so that it will run automatically on whatever schedule your task scheduler supports.

You can set up different instances of this program as separate Scheduled Tasks to automatically consolidate Email messages from different Email accounts onto a single Email server, even if the managers of those accounts refuse to forward your Email messages for you.

If you also need to consolidate Email messages on a demand (non-scheduled) basis, you can accomplish that with a couple of mouse clicks.

As a result, by using this program, you will have an easy way to consolidate Email messages from all of your Email accounts onto a single Email server so that you only have to check one Email account in order to read all of your Email? Then you can answer yes to the third question that I posed earlier.

Third lesson in a series

This is the third lesson in a series of lessons on the general topic of moving Email messages among servers and local computers.

The first lesson was entitled Consolidating Email using Java. That is the document that I will refer to as Part 1 of this lesson.

The second and previous lesson was entitled Uploading Old Email to Gmail using Java.

Viewing tip

You may find it useful to open another copy of this lesson in a separate browser window. That will make it easier for you to scroll back and forth among the different listings and figures while you are reading about them.

Supplementary material

I recommend that you also study the other lessons in my extensive collection of online Java tutorials. You will find those lessons published at Gamelan.com. However, as of the date of this writing, Gamelan doesn't maintain a consolidated index of my Java tutorial lessons, and sometimes they are difficult to locate there. You will find a consolidated index at www.DickBaldwin.com.

General Background Information

Multiple Email accounts

The previous two lessons in this series discussed the background, the desirability, and the rationale for using a program like the one that I will present in this lesson to consolidate Email messages from multiple Email accounts onto a single Email server. I won't repeat that discussion here. Rather, this lesson will concentrate on the technical aspects of the automated version of a program for performing such consolidation.

Even if you decide that you would prefer to use the automated version of the program presented in this lesson, it is strongly recommended that you study Part 1 before embarking on this lesson. The code in the program in this lesson is very similar to, but organized differently from the code in Part 1. Therefore, I won't explain the details of the code in this lesson. Rather, I will simply refer you to the appropriate section of Part 1 for detailed explanations of the code.

Discussion and Sample Code

An Email forwarding program

In this lesson, I will provide the following two Java classes, which work together as a program to download Email messages from one POP3 server and to forward those messages to another Email server on a totally unattended, automated, and scheduled basis:

  • BigDog06fetch
  • BigDog06forward

The first class listed above replaces the class named BigDog04g in Part 1. The second class listed above replaces the class named BigDog04i in Part 1.

Command-line parameters

As was the case in Part 1, all of the user-specific information required by the program is provided by the following eight command-line parameters:

  1. pop3Server: Server from which the messages will be downloaded
  2. userName: On pop3Server
  3. password: On pop3Server
  4. destinationAddress: Email address to which the messages will be forwarded
  5. smtpServer: An available SMTP server that can be used to forward the messages
  6. workingDir: Messages are temporarily stored here
  7. archiveDir: Messages are moved to here from the workingDir for long-term storage if desired (optional)
  8. fwdTag: String prepended to the subject when the message is forwarded. (Can be an empty string.)

Automation was my long-term goal

As I mentioned in Part 1, I'm aware that parameter input via command-line parameters isn't nearly as sexy as input via a graphical user interface. However, it is much easier to automate command-line input. Command-line input can be automated using batch files. Unattended automated execution of the program was my long-term goal for this project from the very beginning.

Doing the setup for unattended automated execution

In the next few paragraphs, I will explain how to use batch files to schedule the execution of the program under the Windows XP operating system. If you are running under a different operating system, you will need to examine the documentation for that operating system to learn how to schedule tasks on your machine.

One batch file for each POP3 Server

I have a different batch file set up for each of the POP3 servers from which I want messages to be downloaded and consolidated onto a common Email server. (I use Google's Gmail as my common Email account.)

The Windows XP Scheduled Tasks feature

For a particular POP3 server, all I have to do to cause the messages to be moved from the POP3 server to my Gmail account is to register the batch file for that POP3 server as a Scheduled Task under Windows XP.

(Actually I have two batch files set up for each POP3 server because I have to use a different SMTP server depending on whether I am at home with my laptop or at work with my laptop. (See Figure 2.) I normally have half of the Scheduled Tasks disabled when I am at home, and have the other half disabled when I am at work.)

What is the Scheduled Tasks feature?

Figure 1 contains part of what the Microsoft help system has to say about the Scheduled Tasks feature.

Scheduled Tasks overview

With Scheduled Tasks, you can schedule any script, program, or document to run at a time that is most convenient for you. Scheduled Tasks starts each time you start Windows XP and runs in the background.

With Scheduled Tasks, you can also:

  • Schedule a task to run daily, weekly, monthly, or at certain times (such as system startup).
  • Change the schedule for a task.
  • Stop a scheduled task.
  • Customize how a task will run at a scheduled time.
Figure 1

The idle time option is missing

One thing that the Microsoft help system fails to mention is that the Scheduled Tasks feature also allows tasks to be scheduled for execution anytime following a specified amount of idle time. I have my system set up so that each of the batch files is executed as a Scheduled Task after a few minutes of idle time.

(As you will see shortly, this idle-time capability is also missing from the Windows Scheduled Tasks Wizard. However, there is a workaround that can be used to incorporate the idle-time capability.)

Icons on the desktop

I also have icons with shortcuts to each of the batch files on my desktop so that I can force a batch file to be executed whenever I want even if such execution isn't scheduled to occur any time soon.

Registering Scheduled Tasks

To schedule tasks under Windows XP, go to the Control Panel and double click on Scheduled Tasks.

When the Scheduled Tasks folder appears, (see Figure 2), double click on "Add Scheduled Task." This will start the Scheduled Task Wizard running.

Just follow the instructions provided by the wizard and browse to the appropriate batch file when you are given the opportunity to Select Program to Schedule.

Idle time option is missing from the wizard also

Be aware, however, that in the version of Windows XP that I am currently running (Windows XP Professional, Version 5.1, Service Pack 2), there is an apparent bug in the Scheduled Task Wizard. In particular, when using the wizard to set up a Scheduled Task, you are only given the following six choices as to when the task should be performed:

  • Daily
  • Weekly
  • Monthly
  • One time only
  • When my computer starts
  • When I log on

The ability to cause the task to be performed during idle time is missing from the list.

Can correct for the omission later

However, even though it is inconvenient, if you go ahead and select one of the items in the list and click Next a couple of times, you will reach the point where you can check a box that reads "Open advanced properties for this task when I click Finish." The Advanced Properties dialog (see Figure 3) will let you change your selection to When idle if you choose to do so.

When you check that box and click Finish, the Advanced Properties dialog having the following three tabs (see Figure 3, Figure 4, and Figure 5) will appear:

  • Task
  • Schedule
  • Settings

A more-complete list

Select the Schedule tab shown in Figure 4 and you will have access to a pull-down list entitled Schedule Task that contains the items in the list given above. The pull-down list also provides an additional selection that reads "When idle."

If that is your choice, make that selection and then select the Settings tab shown in Figure 5. The dialog on the Settings tab will give you an opportunity to customize the selection in more detail.

Scheduled Tasks on the desktop

Because you may want to make modifications later to tasks that you have scheduled, it is convenient to go to the Control Panel and create a shortcut on the desktop to Scheduled Tasks. You can do this by right-clicking on Scheduled Tasks on the Control Panel and then selecting Create Shortcut.

Having created the Scheduled Tasks shortcut on the desktop, whenever you double-click the shortcut, the Scheduled Tasks folder should appear on your screen, looking something like that shown in Figure 2.


Figure 2

Creating a new Scheduled Task

To create a new Scheduled Task, double-click on the top item in Figure 2 that reads Add Scheduled Task. This will start the Scheduled Task Wizard that I discussed earlier.

Existing Scheduled Tasks

Each of the bottom four items in Figure 2 represent scheduled tasks. Those with the red x are temporarily disabled.

Modifying a Scheduled Task

Once you have created a Scheduled Task, you can modify that task (or use it to create a new one) without having to deal with the wizard. If you right-click on a Scheduled Task in Figure 2, a popup menu will appear with the following selections:

  • Run
  • Cut
  • Copy
  • Delete
  • Rename
  • Properties

The first five choices are generally self-explanatory. For example, you can cause the task to run at a non-scheduled time by selecting Run on the popup menu.

Using an existing task to create a new one

You can create a new Scheduled Task by:

  • Copying an existing Scheduled Task to the clipboard
  • Pasting it into a different directory
  • Renaming it in the other directory
  • Copying it back into the Scheduled Tasks directory
  • Modifying the properties of the new Scheduled Task to suit the new requirements

The Scheduled Task Properties

Selecting Properties in the popup menu produces the dialog shown in Figure 3. This is the dialog that I referred to as the Advanced Properties dialog earlier.


Figure 3

Modifying a Scheduled Task

Once you have opened the Advanced Properties dialog on a Scheduled Task and have selected one of the tabs, you can make any modification to the task that is allowed by the system.

Disable and/or enable a Scheduled Task

For example, the checkbox in the bottom left corner of Figure 3 can be used to enable and disable the Scheduled Task. (Figure 2 shows two Scheduled Tasks that have been disabled.)

The Schedule and Settings tabs

Figure 4 shows the Schedule tab.


Figure 4

Figure 5 shows the Settings tab.


Figure 5

There are no GUIs with this version of the program

That's enough talk about Windows. Let's discuss Java programming.

This version of the program does not display GUIs on the screen as was the case with the version presented in Part 1. Rather, this version runs in batch mode, from start to finish, with no user interaction.

From start to finish ...

From start to finish includes the following operations:

  • Download messages and save them as individual files in a local working directory.
  • Transform the message files into Email messages and send the messages to the specified destination Email address.
  • Upon confirmation that each message has been sent successfully, delete the original message from the POP3 server, and remove the message file from the working directory.

If a problem is recognized anywhere along the way, the messages are not deleted from the POP3 server and the message files are not removed from the working directory. This makes it possible to recover from the problem, if necessary, by downloading the messages from the POP3 server into an ordinary Email client program.

Status and progress information

Status and progress information appears in the command-line window while the program is running. However, unless you put a PAUSE command at the end of the batch file, that window will probably disappear before you have much time to study it.

(If you want the command-line window to remain visible until you dismiss it, put a PAUSE command at the end of the batch file. This might be useful if you suspect that there is a problem, but it will probably also prevent the next scheduled running of the batch file and the program.)

A batch-file command

A typical batch file command is shown in Figure 6.

(Note that it was necessary for me to manually enter line breaks into Figure 6 to force the command to fit in this narrow publication format.)

java BigDog06fetch pop.austincc.edu userName 
password acct@xyz.com smtp-server.austin.rr.com 
./temp/ c:/z-MailArchives/ "ACC-"
Figure 6

You should be able to match up the individual command-line parameters in Figure 6 with the description of the parameters discussed earlier.

Two classes are used

This program consists of the following two classes:

  • BigDog06fetch
  • BigDog06forward

As mentioned earlier, the BigDog06fetch class replaces the class named BigDog04g in Part 1. The BigDog06forward class replaces the class named BigDog04i in Part 1.

Because the user interactivity has been removed, the two classes presented here are much simpler than the two classes presented in Part 1.

Overall control

The class named BigDog06fetch is a Java application and serves as the driver for the entire program. The main method instantiates an object of the BigDog06fetch class.

The BigDog06fetch object downloads all of the available messages from a POP3 server and writes them as individual files in a local working directory. Then it instantiates an object of the class BigDog06forward.

The object of the class BigDog06forward

  • Forwards the messages to a specified Email address.
  • Deletes the messages from the POP3 server.
  • Removes the message files from the working directory.

Deleting messages and moving message files

Messages are not deleted from the POP3 server until they have been successfully forwarded to the specified Email address. When the messages are deleted from the POP3 server, the message files are also removed from the working directory.

By enabling and disabling blocks of code prior to compilation, a user can customize the program to cause the message files to be moved from the working directory into an archive directory or to simply be deleted from the working directory without saving them in an archive directory.

Directories must already exist

Note that both of the directories specified by command-line parameters must already exist when the program is run for the first time.

If message files are not being saved in an archive directory, the seventh command line parameter is a dummy parameter, which is essentially ignored by the program. Even though it is ignored, it must be provided as a command-line parameter to cause the number of parameters to be correct.

Tagging the forwarded messages

The eighth command-line parameter is a string that is prepended onto the beginning of the Subject line in the message before the message is forwarded. For example, it can be used to indicate the originating Email account. If you don't want to tag the Subject of the forwarded message, just enter an empty string, "", as the eighth command-line parameter.

POP3 technical information

For technical information on POP3, see RFC 1725 at http://www.cse.ohio-state.edu/cgi-bin/rfc/rfc1725.html

A POP3 Command Summary is provided in the program comments in Listing 9 near the end of the lesson.

Program testing

The entire program was successfully tested using JDK 1.5.0_01 running under WinXP. JDK 1.5 or later is required because of the use of generics in the program.

Will discuss in fragments, (but not very much)

Complete listings of both classes are provided in Listing 9 and Listing 10 near the end of the lesson. Normally, I would break both classes down into fragments and discuss the fragments in detail.

However, because of the similarities between these classes and the classes that I explained in Part 1, my discussion of code in this lesson will be very limited. I will concentrate on those aspects of the code in this lesson that are different from the code in Part 1.

BigDog06fetch is not a Frame

Unlike the class definition for BigDog04g in Part 1, the class definition for BigDog06fetch is not a Frame. That is because this version of the program doesn't present a GUI to the user. The class definition for BigDog06fetch begins in Listing 1.

class BigDog06fetch{
  static String workingDir;
  int numberMsgs = 0;
  int msgNumber;
  String uidl = "";//unique msg ID
  BufferedReader inputStream;
  PrintWriter outputStream;
  Socket socket;
  String pathFileName;
  static String[] params;

Listing 1

The code in Listing 1 simply declares some necessary variables.

The main method

BigDog06fetch is a Java application and therefore requires a main method. The main method begins in Listing 2.

As mentioned earlier, certain critical information is provided to the program by way of eight command-line parameters. The code in Listing 2 tests to confirm that the user has entered eight command-line parameters. If not, usage information is displayed and the program terminates at that point.

  public static void main(String[] args){
    if(args.length != 8){
      System.out.println(
                   "Wrong number of parameters");
      System.out.println(
         "Usage: java BigDog06fetch "
         + "npop3Server nuserName npassword "
         + "ndestinationAddress nsmtpServer"
         + "nworkingDir narchiveDir nfwdTag");
      System.out.println("If not saving msg "
        + "files in archive, seventh parameter "
        + "is a dummy parameter.");
      System.out.println("Terminating program.");
      System.exit(0);
    }//end if

Listing 2

Save command-line parameter values

Assuming that the number of command-line parameters is correct, the program saves some of them and uses others.

Listing 3 saves a reference to the args array so that it will be available later.

Listing 3 also identifies and saves the name of the working directory where the message files will be temporarily stored awaiting forwarding to the destination Email address.

    params = args;
    workingDir = args[5];

Listing 3

(Once again, note that for proper operation, the working directory and the archive directory must both exist when the program is run. The program is not designed to create those directories if they don't already exist.)

Instantiate a BigDog06fetch object

Finally, as shown in Listing 4, the main method displays the command-line parameters and then uses the first three command-line parameters to instantiate an object of the BigDog06fetch class.

    System.out.println(
                     "pop3Server: " + params[0]);
    System.out.println("userName: " + params[1]);
    System.out.println("password: .........."); 
    System.out.println(
             "destinationAddress: " + params[3]);
    System.out.println(
                     "smtpServer: " + params[4]);
    System.out.println(
                    "workingDir: " +  params[5]);
    System.out.println(
                     "archiveDir: " + params[6]);
    System.out.println("fwdTag: " + params[7]);
 
    new BigDog06fetch(args[0],args[1],args[2]);
  }//end main

Listing 4

Once constructed, this object will download and save the messages on the specified POP3 Email server as individual files in the local working directory.

Instantiate a BigDog06forward object

The BigDog06fetch object will, in turn, instantiate an object of the BigDog06forward class, which will forward the messages in the working directory to the destination Email address. The BigDog06forward object will also delete the messages from the POP3 server and remove the message files from the working directory.

The BigDog06fetch constructor

The BigDog06fetch constructor is shown (with most of the code removed for brevity) in Listing 5. The constructor consists of two main parts. The first part gets a connection to the POP3 Email server using the three incoming parameters. This part is essentially the same as the corresponding code in the constructor for the program in Part 1.

  BigDog06fetch(String pop3Server,
                String userName,
                String password){
  //First part
    int port = 110; //pop3 mail port
    try{
      //Code removed for brevity
    
    }//end try
    catch(Exception e){
      e.printStackTrace();
      System.exit(0);
    }//end catch
  //Second part
    fetchMsgs();
  }//end constructor

Listing 5

The second part of the constructor

The second part, shown in boldface near the end of Listing 5, invokes the method named fetchMsgs to download the messages from the POP3 server and to save them as individual files in the working directory.

Code to get a connection

I explained all of the code involved in getting the connection to the POP3 server in Part 1, and won't repeat that explanation here.

The fetchMsgs method

The fetchMsgs method is new to this lesson, although most of the code in the method appeared in a method named actionPerformed in Part 1.

Don't register a WindowListener object

Because the constructor in Part 1 created a GUI, it registered a WindowListener object on the Frame. There is no Frame in this version of the program, and hence no WindowListener object.

Don't instantiate GUI objects

For similar reasons, the code in this constructor doesn't instantiate Button and TextArea objects as was the case in Part 1.

Don't register an ActionListener object

Also, for the same reason, there is no reason for the code in this version of the program to register an ActionListener object on a Button (there is no button).

Where did the work get done in Part 1?

In the version of the program in Part 1, the code in the actionPerformed method belonging to the ActionListener object did the work of downloading the messages from the POP3 server and writing those messages into local files in the working directory.

Where does the work get done in this version?

In this version of the program, the code to do that work is contained in the method named fetchMsgs.

The difference is that in the version in Part 1, once the connection to the POP3 server was made, message downloading was deferred until the user clicked a Button in the GUI, thus invoking the actionPerformed method. In this version, as soon as the connection is made, the fetchMsgs method is invoked by the constructor causing message downloading to begin immediately.

The fetchMsgs method

The fetchMsgs method is shown in Listing 6 with most of the code omitted for brevity. (You can view all of the code for the fetchMsgs method in Listing 9 near the end of the lesson.)

  void fetchMsgs(){
    //Download all messages on the pop3Server.
    try{
      //The communication process is now in the
      // TRANSACTION state.
      //Retrieve and save messages
//Code deleted for brevity
      //All messages have been downloaded and
      // saved as local files.  Instantiate an
      // object that will forward each of the
      // messages to the specified email
      // address.
      new BigDog06forward(
          params[0],//pop3Server
          params[1],//userName
          params[2],//password
          params[3],//destinationAddress
          params[4],//smtpServer
          params[5],//workingDir
          params[6],//archiveDir
          params[7]);//fwdTag
    }//end try
    catch(Exception ex){
      ex.printStackTrace();
      System.exit(0);
    }//end catch
  }//end fetchMsgs
  //===========================================//
}//end class BigDog06fetch
//=============================================//

Listing 6

Same as the actionPerformed method

The code in the fetchMsgs method in this version is essentially the same as the code in the actionPerformed method in the version in Part 1. I explained that code in detail in that lesson, and won't repeat that explanation here.

Instantiate an object of the BigDog06forward class

Note that in addition to downloading the messages, the code in Listing 6 also instantiates an object of the BigDog06forward class to cause the messages to be sent to the destination Email address.

Listing 6 also signals the end of the definition of the BigDog06fetch class.

The BigDog06forward class

Now that you understand how the program downloads the messages from the POP3 server, it is time to learn how it forwards those messages to the destination Email address.

An object of the BigDog06forward class is instantiated by the code in Listing 6 to tag and forward a set of message files that were written into the working directory by the BigDog06fetch object.

Tag and forward the messages

This BigDog06forward object tags the messages with a tag defined by the user as a command-line parameter to the main method of the class named BigDog06fetch. Then the object forwards the messages to a destination Email account that is specified as a command-line parameter. It uses an SMTP server that is also specified as a command-line parameter.

The DELE command

This object uses the DELE command to delete messages from the POP3 server from which the messages were originally downloaded.

(Deletion of the messages from the server can be temporarily disabled for test purposes by disabling a block of code before compiling the program. Search for the word disable in the source code to identify the code that needs to be temporarily disabled for this purpose.)

The BigDog06forward class

The class definition for the BigDog06forward class begins in Listing 7. As you can see, the class does not extend Frame, as was the case for the version of the program in Part 1 Once again, this version of the program does not present GUIs to the user, and therefore there is no reason for the class to extend Frame.

class BigDog06forward{
  //User-specific information is stored here.
  // This information is provided in the form of
  // constructor parameters.
  //ID of the destination email account.
  final String destinationAddress;
  //An smtp server through which the user is
  // authorized to send email messages.
  final String smtpServer;
  //Local folder where message files are stored
  // awaiting processing.
  final String workingDir;
  //Local folder for archiving message files.
  final String archiveDir;
  //Tag that is prepended to the Subject line of
  // the message before forwarding.
  String fwdTag;
  //Following are working variables used by the
  // program for various purposes.
  BufferedReader inputStream;
  PrintWriter outputStream;
  Socket socket;
  String pathFileName;
  Vector  msgToDelete = 
                            new Vector();
  String uidl;
  boolean okToDelete = false;
  int msgNumber = 0;
  String pop3Server;
  String userName;
  String password;

Listing 7

The code in Listing 7 declares a large number of variables, initializing some of them. This code should be self-explanatory and shouldn't require further explanation.

The constructor for the BigDog06forward class

The constructor is shown in its entirety in Listing 8.

  BigDog06forward(final String pop3Server,
            final String userName,
            final String password,
            final String destinationAddress,
            final String smtpServer,
            final String workingDir,
            final String archiveDir,
            final String fwdTag){
    this.pop3Server = pop3Server;
    this.userName = userName;
    this.password = password;
    this.destinationAddress = destinationAddress;
    this.smtpServer = smtpServer;
    this.workingDir = workingDir;
    this.archiveDir = archiveDir;
    this.fwdTag = fwdTag;
    
    System.out.println("Forwarding messages:");
    forwardMsgs();
    deleteMsgs();
  }//end constructor

Listing 8

Much shorter than in Part 1

The constructor for this version of the program is much shorter than was the case for the version of the program in Part 1. That is because the earlier version presented a GUI to the user with two Button objects and a TextArea object.

Forwarding the messages

One of the buttons was used to initiate and handle the forwarding of messages to the specified destination Email address.

An ActionListener object was registered on that button, and the actionPerformed method belonging to that ActionListener object did all of the work.

That same work is done in this program by the method named forwardMsgs that is invoked near the end of the constructor in Listing 8.

The forwardMsgs method

The code in the forwardMsgs method is essentially the same as the code in the actionPerformed method that it replaces. I explained that code in Part 1 and won't repeat that explanation here. You can view the forwardMsgs method in Listing 10 near the end of this lesson.

Deleting messages

The other button in the GUI in Part 1 was used to initiate and handle the deletion of email messages from the POP3 server.

An ActionListener object was registered on that button, and the actionPerformed method belonging to that ActionListener object did all of the work.

That same work is done in this program by the method named deleteMsgs that is invoked near the end of the constructor in Listing 8.

The deleteMsgs method

The code in the deleteMsgs method is essentially the same as the code in the actionPerformed method that it replaces. Once again, I explained that code in Part 1 and won't repeat that explanation here. You can view the deleteMsgs method in Listing 10 near the end of this lesson.

Run the Program

I encourage you to copy the code from Listings 9 and 10 into your text editor, compile it, and execute it. Experiment with it, making changes, and observing the results of your changes.

I do recommend, however, that before compiling and executing the code, you make the changes necessary to prevent messages from being deleted from your POP3 server. That way, if something goes wrong, the messages will still be there for you to access using your regular Email client program. Once you are satisfied with the behavior of the program and are ready to use it on a routine production basis, you can re-enable the deletion of messages from your POP3 server.

Also please be aware of the following disclaimer:

THIS PROGRAM IS PROVIDED TO YOU AT NO COST. BY USING THIS PROGRAM TO PROCESS YOUR EMAIL, YOU AGREE THAT YOU ARE USING IT AT YOUR OWN RISK. THE AUTHOR OF THE PROGRAM, RICHARD G. BALDWIN, ACCEPTS NO LIABILITY FOR ANY LOSS THAT YOU MAY INCUR THROUGH THE USE OF THIS PROGRAM.

Summary

In this lesson, I provided and explained two Java classes that work together as a program to download Email messages from a POP3 server and to forward those messages to another Email server.

Such a program is particularly useful for consolidating all of your Email messages onto a single Email server so that you only need to check your mail on one server to see all of your messages.

I also showed you how to register the program as a Scheduled Task under Windows XP to cause the program to run automatically in an unattended mode on a schedule that you specify.

Complete Program Listings

Complete listings of the classes discussed in this lesson are shown in Listings 9 and 10 below.
 
/*File BigDog06fetch.java 
Copyright 2005, R.G.Baldwin
Rev 08/17/05
This is a modification of the program named
BigDog04g to fully automate the process.
DISCLAIMER:  THIS PROGRAM IS PROVIDED TO YOU AT 
NO COST.  BY USING THIS PROGRAM TO PROCESS YOUR 
EMAIL, YOU AGREE THAT YOU ARE USING IT AT YOUR 
OWN RISK.  THE AUTHOR OF THE PROGRAM, RICHARD G. 
BALDWIN, ACCEPTS NO LIABILITY FOR ANY LOSS THAT 
YOU MAY INCUR THROUGH THE USE OF THIS PROGRAM.
This program downloads all messages from a
pop3Server and writes them as individual files in
a local working directory.  Then it instantiates 
an object of the class BigDog06forward, which 
forwards the messages to a specified email 
address using a specified SMTP server.
Messages are not deleted from the pop3Server 
until they have been forwarded to the specified 
email address. When the messages are deleted from
the pop3Server, the message files are also 
removed from the working directory.
By enabling and disabling blocks of code prior to
compilation, you can customize the program to 
cause the  message files to be moved from the
working directory into an archive directory or 
simply deleted from the working directory without
saving them in an archive directory.
The following information is provided as 
command-line parameters:
pop3Server: server from which the messages will 
  be downloaded
userName: on pop3Server
password: on pop3Server
destinationAddress: email address to which the 
  messages are to be forwarded
smtpServer: an available SMTP server that can be 
  used to forward the messages
workingDir: messages are temporarily stored here
archiveDir: messages are moved to here from the 
  workingDir for long-term storage if desired
fwdTag: String prepended to the subject when the 
  message is forwarded.
Note that both of the directories listed above 
must already exist when the program is run for 
the first time.
If message files are not being saved in an 
archive directory, the seventh parameter is a 
dummy parameter, which is essentially ignored by 
the program, but it must be provided.
If you don't want to tag the subject of the 
forwarded msg, just enter "" as the eighth 
command-line parameter.
For technical information on POP3, see RFC 1725
at
http://www.cse.ohio-state.edu/cgi-bin/rfc/
rfc1725.html
A POP3 Command Summary follows based on the
information at that web site.
Minimal POP3 Commands:
USER name
PASS string
QUIT
STAT
LIST [msg]
RETR msg
DELE msg
NOOP
RSET
QUIT
Optional POP3 Commands:
APOP name digest
TOP msg n
UIDL [msg]
POP3 Replies:
+OK
-ERR
Tested using JDK 1.5.0_01 under WinXP
************************************************/
import java.net.*;
import java.io.*;
import java.awt.*;
class BigDog06fetch{
  static String workingDir;
  int numberMsgs = 0;
  int msgNumber;
  String uidl = "";//unique msg ID
  BufferedReader inputStream;
  PrintWriter outputStream;
  Socket socket;
  String pathFileName;
  static String[] params;
  public static void main(String[] args){
    if(args.length != 8){
      System.out.println(
                   "Wrong number of parameters");
      System.out.println(
         "Usage: java BigDog06fetch "
         + "npop3Server nuserName npassword "
         + "ndestinationAddress nsmtpServer"
         + "nworkingDir narchiveDir nfwdTag");
      System.out.println("If not saving msg "
        + "files in archive, seventh parameter "
        + "is a dummy parameter.");
      System.out.println("Terminating program.");
      System.exit(0);
    }//end if
    
    //Save the command-line parameters for later 
    //use by the object of the class
    // BigDog06forward
    params = args;
    //Establish the name of the working
    // directory.  Note that this directory must
    // already exist.
    workingDir = args[5];
    
    System.out.println(
                     "pop3Server: " + params[0]);
    System.out.println("userName: " + params[1]);
    System.out.println("password: .........."); 
    System.out.println(
             "destinationAddress: " + params[3]);
    System.out.println(
                     "smtpServer: " + params[4]);
    System.out.println(
                    "workingDir: " +  params[5]);
    System.out.println(
                     "archiveDir: " + params[6]);
    System.out.println("fwdTag: " + params[7]);
    
    //Instantiate an object that will download
    // and save the messages as individual files.
    // This object will in turn instantiate an
    // object of the class BigDog06forward, which
    // will forward the messages to the
    // destination email address.    
    new BigDog06fetch(args[0],args[1],args[2]);
  }//end main
  //===========================================//
  //Constructor
  BigDog06fetch(String pop3Server,
                String userName,
                String password){
    int port = 110; //pop3 mail port
    try{
      //Get a socket, connected to the specified
      // pop3Server on the specified port.
      socket = new Socket(pop3Server,port);
      //Get an input stream from the socket
      inputStream = new BufferedReader(
                     new InputStreamReader(
                       socket.getInputStream()));
      //Get  an output stream to the socket.
      // Note that this stream will autoflush.
      outputStream = new PrintWriter(
               new OutputStreamWriter(
                 socket.getOutputStream()),true);
      //Display the msg received from the
      // pop3Server on the command-line screen
      // immediately following connection.
      String connectMsg = validateOneLine();
      System.out.println(
        "Connected to pop3Server " + connectMsg);
      //The communication process is now in the
      // AUTHORIZATION state.  Send the user
      // name and password to the pop3Server.
      //Commands are sent in plain text, upper
      // case to the pop3Server.  Some commands
      // require an argument following the
      // command, as is the case with USER.
      //Send the command.
      outputStream.println("USER " + userName);
      //Get response and confirm that the
      // response was +OK and was not -ERR.
      String userResponse = validateOneLine();
      //Display the response on the command-
      // line screen.
      System.out.println("USER " + userResponse);
      //Send the password to the pop3Server
      outputStream.println("PASS " + password);
      //Validate the pop3Server's response as +OK
      // Display the response in the process.
      System.out.println(
                    "PASS " + validateOneLine());
      System.out.println("Downloading Messages");
    }catch(Exception e){
      e.printStackTrace();
      System.exit(0);
    }//end catch
    
    fetchMsgs();
  }//end constructor
  //===========================================//
  //Validate a one-line response.
  //The purpose of this method is to confirm that
  // the pop3Server returned +OK and not -ERR to
  // the previous command.
  //If +OK, the method returns the string
  // returned by the pop3Server.
  //If -ERR, the method displays the string
  // returned by the pop3Server and terminates
  // the session.
  private String validateOneLine(){
    try{
      String response = inputStream.readLine();
      if(response.startsWith("+OK")){
        return response;
      }else{
        System.out.println(response);
        //Terminate the session.
        outputStream.println("QUIT");
        socket.close();
        System.out.println(
                       "Premature QUIT on -ERR");
        System.exit(0);
      }//end else
    }catch(IOException ex){
      ex.printStackTrace();
      System.exit(0);
    }//end catch
    //The following return statement is required
    // to satisfy the compiler, but it can never
    // be reached.
    return "Make compiler happy";
  }//end validateOneLine()
  //===========================================//
  
  void fetchMsgs(){
    //Download all messages on the pop3Server.
    try{
      //The communication process is now in the
      // TRANSACTION state.
      //Retrive and save messages
      outputStream.println("STAT");
      String stat = validateOneLine();
      //Get the number of messages as a String.
      String numberMsgsStr = stat.substring(
                          4,stat.indexOf(" ",5));
      //Convert the String to an int.
      numberMsgs = Integer.parseInt(
                                  numberMsgsStr);
                            
      if(numberMsgs == 0){
        System.out.println(
                          "No msg to download.");
        System.out.println(
                         "Terminating program.");
        System.exit(0);
      }//end if
      //NOTE: Msg numbers begin with 1, not 0.
      //Retrieve and save each message.  Each msg
      // ends with a period on a new line.
      msgNumber = 1;
      while(msgNumber <= numberMsgs){
        //Process the next message.
        //Get and save a unique identifier for
        // the message from the pop3Server and
        // validate the response.
        outputStream.println(
                            "UIDL " + msgNumber);
        uidl = validateOneLine();
        //Open an output file to save the
        // message.  Use the UIDL as the file
        // name.
        pathFileName = workingDir + uidl;
        DataOutputStream dataOut =
                          new DataOutputStream(
                            new FileOutputStream(
                                  pathFileName));
        //Send a RETR command to begin the
        // message retrieval process
        outputStream.println(
                            "RETR " + msgNumber);
        //Validate the response.
        String retrResponse =
                               validateOneLine();
        //Read the first line in the message from
        // the pop3Server.
        String msgLine = inputStream.readLine();
        //Continue reading lines until a "." is
        // encountered as the first char in a
        // line.  That signals the end of the
        // msg.
        while(!(msgLine.equals("."))){
          //Write the line to the output file and
          // read the next line.  Insert newline
          // characters when writing the output
          // to the file.
          dataOut.writeBytes(msgLine + "n");
          msgLine = inputStream.readLine();
        }//end while(!(msgLine.equals(".")
        
        //Close the output file.  The message is
        // now stored in a local file with a file
        // name based on the unique ID provided
        // by the pop3Server.
        dataOut.close();
        //Show progress on the command-line
        // screen
        System.out.print(msgNumber + " ");
        //Increment the message number in
        // preparation for processing the next
        // message.
        msgNumber++;
      }//end while(msgNumber <= numberMsgs)
      System.out.println(
                        "nMessages downloaded");
                 
      //Terminate the session with the
      // pop3Server.
      System.out.println(
                "nDisconnect from pop3Server.");
      outputStream.println("QUIT"); 
      String quitResponse = validateOneLine();
      //Display the response on the
      // command-line screen.
      System.out.println("QUIT " + quitResponse);
      System.out.println();//blank line
      
      socket.close();
      
      //Sound an alarm.
      try{
        Thread.currentThread().sleep(500);
        Toolkit.getDefaultToolkit().beep();
        Thread.currentThread().sleep(500);
        Toolkit.getDefaultToolkit().beep();
        Thread.currentThread().sleep(500);
      }catch(Exception ex){
        ex.printStackTrace();
        System.exit(0);
      }//end catch
                   
      //All messages have been downloaded and
      // saved as local files.  Instantiate an
      // object that will forward each of the
      // messages to the specified email
      // address.
      new BigDog06forward(
          params[0],//pop3Server
          params[1],//userName
          params[2],//password
          params[3],//destinationAddress
          params[4],//smtpServer
          params[5],//workingDir
          params[6],//archiveDir
          params[7]);//fwdTag
    }//end try
    catch(Exception ex){
      ex.printStackTrace();
      System.exit(0);
    }//end catch
  }//end fetchMsgs
  //===========================================//
}//end class BigDog06fetch
//=============================================//

Listing 9

 

/*File BigDog06forward.java
Copyright 2005, R.G.Baldwin
Rev 08/17/05
DISCLAIMER:  THIS PROGRAM IS PROVIDED TO YOU AT 
NO COST.  BY USING THIS PROGRAM TO PROCESS YOUR 
EMAIL, YOU AGREE THAT YOU ARE USING IT AT YOUR 
OWN RISK.  THE AUTHOR OF THE PROGRAM, RICHARD G.
BALDWIN, ACCEPTS NO LIABILITY FOR ANY LOSS THAT 
YOU MAY INCUR THROUGH THE USE OF THIS PROGRAM.
An object of this class is instantiated by an
object of the class named BigDog06fetch to 
process a set of message files written by the
BigDog06fetch object.
This object tags messages with a tag defined by 
the user as a command-line parameter to the 
main method for the class named BigDog06fetch.  
Then the object forwards the messages to a 
destination email account that is specified as a 
command-line parameter using an SMTP server that 
is specified as a command-line parameter.
See additional comments at the beginning of 
BigDog06fetch.java.
This program uses the DELE command to delete
messages from the POP3 server from which the 
messages were originally downloaded.  Deletion of
the messages from the server can be disabled for 
test purposes by disabling a block of code before
compiling the program.
Certain portions of this program may have been
disabled for test purposes.  Search for the word
disable to identify those portions.
Tested using JDK 1.5.0_01 under WinXP
************************************************/
import java.net.*;
import java.io.*;
import java.util.*;
import java.awt.*;
//import java.awt.event.*;
import sun.net.smtp.SmtpClient;
class BigDog06forward{
  //User-specific information is stored here.
  // This information is provided in the form of
  // constructor parameters.
  //ID of the destination email account.
  final String destinationAddress;
  //An smtp server through which the user is
  // authorized to send email messages.
  final String smtpServer;
  //Local folder where message files are stored
  // awaiting processing.
  final String workingDir;
  //Local folder for archiving message files.
  final String archiveDir;
  //Tag that is prepended to the Subject line of
  // the message before forwarding.
  String fwdTag;
  //Following are working variables used by the
  // program for various purposes.
  BufferedReader inputStream;
  PrintWriter outputStream;
  Socket socket;
  String pathFileName;
  Vector <String> msgToDelete = 
                            new Vector<String>();
  String uidl;
  boolean okToDelete = false;
  int msgNumber = 0;
  String pop3Server;
  String userName;
  String password;
  //===========================================//
  //Constructor
  BigDog06forward(final String pop3Server,
            final String userName,
            final String password,
            final String destinationAddress,
            final String smtpServer,
            final String workingDir,
            final String archiveDir,
            final String fwdTag){
    this.pop3Server = pop3Server;
    this.userName = userName;
    this.password = password;
    this.destinationAddress = destinationAddress;
    this.smtpServer = smtpServer;
    this.workingDir = workingDir;
    this.archiveDir = archiveDir;
    this.fwdTag = fwdTag;
    
    System.out.println("Forwarding messages:");
    
    forwardMsgs();
    deleteMsgs();
  }//end constructor
  //===========================================//
  //Validate a one-line response.
  //The purpose of this method is to confirm that
  // the pop3Server returned +OK and not -ERR to
  // the previous command.
  //If +OK, the method returns the string
  // returned by the pop3Server.
  //If -ERR, the method displays the string
  // returned by the pop3Server and terminates
  // the session.
  private String validateOneLine(){
    try{
      String response = inputStream.readLine();
      if(response.startsWith("+OK")){
        return response;
      }else{
        System.out.println(response);
        //Terminate the session.
        outputStream.println("QUIT");
        socket.close();
        System.out.println(
                       "Premature QUIT on -ERR");
        System.exit(0);
      }//end else
    }catch(IOException e){
      e.printStackTrace();
      System.exit(0);
    }//end catch
                
    //The following return statement is requied
    // to satisfy the compiler, but it can never
    // be reached..
    return "Make compiler happy";
  }//end validateOneLine()
  //===========================================//
  
  //Method to move a file from its current
  // location specified by pathFileName to a new
  // location specified by archiveDir.
  public void moveFile(String pathFileName,
                       String archiveDir){
    String fileName = pathFileName.substring(
              pathFileName.lastIndexOf('/') + 1);
    String archiveDirFileName =
                           archiveDir + fileName;
    boolean moved =
                 new File(pathFileName).renameTo(
                   new File(archiveDirFileName));
    if(!moved)System.out.println(
      "Unable to move " + new File(pathFileName)
      + "nto " + new File(archiveDirFileName));
  }//end moveFile method
  //===========================================//
  
  //This method reads and saves lines of data
  // from a file starting with the line that
  // startsWith firstLine and ending with the
  // line that startsWith lastLine.
  //If firstLine is null, data is saved beginning
  // with the first line in the file.
  //If lastLine is null, data is saved to the end
  // of the file.
  //The lines of data from the file are saved by
  // concatenating them into a single string with
  // a newline inserted into the string at the
  // end of each line.
  //The name and path to the file is given by
  // pathFileName.
  public String readLines(String pathFileName,
                          String firstLine,
                          String lastLine){
    StringBuffer strBuf = new StringBuffer();
    try{
      BufferedReader inDataMsg
        = new BufferedReader(new FileReader(
                                  pathFileName));
      String data;
      boolean isSave = false;
      while((data = inDataMsg.readLine())
                                        != null){
        if( ((firstLine == null) ||
             (data.startsWith(firstLine))) &&
             (isSave == false)){
          isSave = true;
        }//end if
        if(isSave){
          strBuf.append(data + "n");
        }//end if
        if((lastLine != null) &&
           (data.startsWith(lastLine))){
          break;//no need to read any more
        }//end if
      }//end while loop
      inDataMsg.close();//Close file
    }catch(Exception e){
      e.printStackTrace();
      System.exit(0);
    }//end catch
    return new String(strBuf);
  }//end readLines
  //===========================================//
  
  //This method is used to construct an email
  // message and send it to the 
  // destinationAddress.
  public boolean forwardEmailMsg(
                       String destinationAddress,
                       String smtpServer,
                       String fwdTag,
                       String pathFileName){
      StringBuffer message = new StringBuffer(
                             "No message found");
      try{
        //Pass a string containing the name of
        // the smtp server as a parameter to the
        // following constructor.
        SmtpClient smtp =
                      new SmtpClient(smtpServer);
        //Pass any valid email address to the
        // from() method.
        smtp.from(destinationAddress);
        //Pass the email address of the
        // destinationAddress to the to() method.
        smtp.to(destinationAddress);
        //Construct the message as a single
        // StringBuffer object by concatenating
        // all of the lines in the message file.
        message = new StringBuffer(readLines(
                        pathFileName,null,null));
        //Insert fwdTag in subject
        message = message.insert(message.indexOf(
                          "Subject: ")+9,fwdTag);
        //Get an output stream for the message
        PrintStream msg = smtp.startMessage();
        //Write the message into the output
        // stream.
        msg.println(new String(message));
        //Close the stream and send the message
        smtp.closeServer();
        return true;
      }catch( Exception e ){
        e.printStackTrace();
        System.out.println(
                       "while forwarding email");
        //Sound an alarm.
        try{
          Thread.currentThread().sleep(500);
          Toolkit.getDefaultToolkit().beep();
          Thread.currentThread().sleep(500);
          Toolkit.getDefaultToolkit().beep();
          Thread.currentThread().sleep(500);
        }catch(Exception ex){
          System.out.println(ex);
        }//end catch
        
        //Return false to indicate that the msg
        // was not successfully forwarded.
        return false;
      }//end catch
  }//end forwardEmailMsg
  //===========================================//
  
  void forwardMsgs(){
    //Get a directory listing
    //The following code creates a directory
    // listing containing only those files that
    // begin with +OK.
    //This is an anonymous implementation of a
    // class that implements FilenameFilter.
    String[] dirList = 
                       new File(workingDir).list(
      new FilenameFilter(){public boolean accept(
                           File dir,String name){
          if(!(new File(dir,name).
            isFile())) return false;
          return name.startsWith("+OK");
        }//end accept
      }//end FilenameFilter
    );//end list
    //Now process the files in the directory
    for(int msgCounter = 0;
                     msgCounter < dirList.length;
                                   msgCounter++){
      String fileName = dirList[msgCounter];
      pathFileName = workingDir + fileName;
      //Get the original message number used by
      // the pop3Server to ID the msg.
      String strMsgNumber =
           fileName.substring(
             fileName.indexOf(" "),
               fileName.lastIndexOf(" ")).trim();
      msgNumber = Integer.parseInt(strMsgNumber);
      System.out.print("" + msgNumber + " ");
      //This code forwards the message to the
      // destination email account and adds the
      // identification of the message to the
      // list of messages scheduled for deletion
      // from the pop3Server later.  The third
      // parameter can be used to tag the message
      // to show that it was forwarded.  This
      // parameter is provided as a command-line
      // parameter to the BigDog06fetch program.
      //  Just pass an empty string, "", if you
      // don't want to tag it.
      //Don't add the message to the deletion
      // list if forwarding failed.
      okToDelete = forwardEmailMsg(
                              destinationAddress,
                              smtpServer,
                              fwdTag,
                              pathFileName);
      if(okToDelete){
        msgToDelete.add(pathFileName);
      }//end if
    }//end for loop on directory length
    //Sound an audio alert
    try{
      Thread.currentThread().sleep(500);
      Toolkit.getDefaultToolkit().beep();
      Thread.currentThread().sleep(500);
      Toolkit.getDefaultToolkit().beep();
      Thread.currentThread().sleep(500);
      Toolkit.getDefaultToolkit().beep();
       Thread.currentThread().sleep(500);
    }catch(Exception ex){
      ex.printStackTrace();
      System.exit(0);
    }//end catch
  }//end forwardMsgs
  //===========================================//
  
  void deleteMsgs(){
    System.out.println(
        "nDelete Msgs from POP3 server.");
    //Get connected to the email pop3Server
    int port = 110; //pop3 mail port
    try{
      //Get a socket, connected to the specified
      // pop3Server on the specified port.
      socket = new Socket(pop3Server,port);
      //Get an input stream from the socket
      inputStream = new BufferedReader(
                     new InputStreamReader(
                       socket.getInputStream()));
      //Get  an output stream to the socket
      outputStream = new PrintWriter(
               new OutputStreamWriter(
                 socket.getOutputStream()),true);
      //Display the msg received from the
      // pop3Server on the command-line screen
      // immediately following connection.
      String connectMsg = validateOneLine();
      System.out.println(
                     "nConnected to pop3Server "
                                   + connectMsg);
      //The communication process is now in the
      // AUTHORIZATION state.  Send the user name
      // and password to the pop3Server.
      outputStream.println("USER " + userName);
      //Get response and confirm that the
      // response was +OK and was not -ERR.
      String userResponse = validateOneLine();
      //Display the response on the command-line
      // screen.
      System.out.println("USER " + userResponse);
      //Send the password to the pop3Server
      outputStream.println("PASS " + password);
      //Validate the pop3Server's response as
      // +OK. Display the response in the
      // process.
      System.out.println("PASS "
                            + validateOneLine());
    }catch(Exception ex){
      ex.printStackTrace();
      System.exit(0);
    }//end catch
    //Process the files in the msgToDelete
    // collection and delete those messages from
    // the email pop3Server.
    System.out.println(
            "nDeleting Msgs from POP3 server.");
    for(int cnt = 0;
                 cnt < msgToDelete.size();cnt++){
      pathFileName = msgToDelete.
                                  elementAt(cnt);
      String strMsgNumber = pathFileName.
         substring(pathFileName.indexOf(" "),
           pathFileName.lastIndexOf(" ")).trim();
      int msgNumber = Integer.parseInt(
                                   strMsgNumber);
      //Deletion of a message from the pop3Server
      // is accomplished by marking the message
      // for deletion while in the TRANSACTION
      // state.  The message is actually deleted
      // when the client sends a QUIT command to
      // the pop3Server causing the pop3Server to
      // enter the UPDATE state.  If the program
      // aborts prematurely before sending a QUIT
      // command, marked messages are not deleted
      // from the pop3Server.
      //Mark the message for deletion.
/*
      //Disable the following statement if you
      // enable message deletion.
      System.out.println(
                    "Message deletion disabled");
*/
      //Disable this code to disable deletion of
      // messages from the pop3Server
      outputStream.println("DELE " + msgNumber);
      //Validate the response and display
      // progress.  Will terminate on DELE ERR.
      validateOneLine();
      System.out.print(msgNumber + " ");
      //Disable to here to disable deletion of
      // messages from the pop3Server
      //You can customize the program to either
      // move the message files from the working
      // directory into an archive directory, or
      // to simply delete the message files from
      // the working directory without saving
      // them in an archive directory.
      
      //To move message files to the archive
      // directory, enable this block of code and
      // disable the next block of code.
      {//Start move block
        moveFile(pathFileName,archiveDir);
      }//End move block
/*
      //To delete message files without saving
      // them in an archive directory, enable
      // this block of code and disable the
      // previous block of code.
      {//Start delete block
        File file = new File(pathFileName);
        boolean isDeleted = file.delete();
        if(!isDeleted)System.out.println(
                     "Unable to delete " + file);
      }//End delete block
*/
    }//end for loop on msgToDelete.size()
    
    System.out.println();//blank line
    //Terminate the session with the pop3Server
    // causing the marked messages to actually be
    // deleted from the pop3Server.
    System.out.println(
                  "Disconnect from POP3 server");
    outputStream.println("QUIT");
    String quitResponse = validateOneLine();
    //Display the response on the command-line
    // screen.
    System.out.println("QUIT " + quitResponse);
    //Server is now in the UPDATE mode. It will
    // delete all files marked with the DELE
    // command earlier in the execution of the
    // program.
    //Close the socket
    try{
      socket.close();
    }catch(Exception ex){
      ex.printStackTrace();
      System.exit(0);
    }//end catch
    System.out.println("Messages deleted "
         + "from pop3Server.");
  }//end deleteMsgs
  //===========================================//
}//end class BigDog06forward
//=============================================//


Listing 10

 


Copyright 2005, Richard G. Baldwin.  Reproduction in whole or in part in any form or medium without express written permission from Richard Baldwin is prohibited.

About the author

Richard Baldwin is a college professor (at Austin Community College in Austin, TX) and private consultant whose primary focus is a combination of Java, C#, and XML. In addition to the many platform and/or language independent benefits of Java and C# applications, he believes that a combination of Java, C#, and XML will become the primary driving force in the delivery of structured information on the Web.

Richard has participated in numerous consulting projects and he frequently provides onsite training at the high-tech companies located in and around Austin, Texas.  He is the author of Baldwin's Programming Tutorials, which have gained a worldwide following among experienced and aspiring programmers. He has also published articles in JavaPro magazine.

In addition to his programming expertise, Richard has many years of practical experience in Digital Signal Processing (DSP).  His first job after he earned his Bachelor's degree was doing DSP in the Seismic Research Department of Texas Instruments.  (TI is still a world leader in DSP.)  In the following years, he applied his programming and DSP expertise to other interesting areas including sonar and underwater acoustics.

Richard holds an MSEE degree from Southern Methodist University and has many years of experience in the application of computer technology to real-world problems.

Baldwin@DickBaldwin.com

Sitemap | Contact Us

Thanks for your registration, follow us on our social networks to keep up-to-date