Best practice for "when to close open folders"

Question

Hello,
I've seen several Javamail examples on the net that fetch messages like this:
1. open folder
2. fetch messages
3. close folder
As far as I know, if I close a parent folder of a message, the message object itself could become invalid / out of sync with the server.
That means, if I wanted to execute an operation on such a message (like rename, delete etc..) I could "hit" the wrong one on the server.
The only solution I could think of would be to keep the folder open as long as the user of my program could do something with its content.
In simple terms: If the user clicks on a folder to display its content, I leave the folder open.
When the user clicks on a different folder, I close the old one and open the new one and display its content.
That means that it could happen that folders could stay open for quite a long time.
Is this good practice or is there a better way?
I have some concerns regarding timeouts or connection losses.
Thanks in advance and regards,
Timo Ernst

Answer 1

bshannon wrote:
That's pretty much true.
A much more complex application could copy the content from the messages so that it can be
used "offline", then resynchronize its cached information with the state of the folder when
reconnecting (e.g., after a connection failure).
You probably want to allow connections to time out if the user isn't using the application,
but with the simple approach you'll need to refresh all your information when that happens,
perhaps including telling the user that the session timed out and they need to log in again.
This works fine for a moderate number of active users. If you need to support a huge number
of active users, you'll need a more complex implementation that times out connections more
aggressively while hiding that connection management from users.Hey, thanks for your reply.
I am already caching some information from messages by using an outer class which wraps Javamail Message instances and delegates method calls to this object if the cache is empty.
Otherwise, the cached information will be used.
Example:
public class CachedMessage{
     Message internalMessage = null;
     String subject = null;
     public CachedMessage(){
          super();
     public CachedMessage(Message m){
          super();
          internalMessage = m;
     public String getSubject(boolean useCache){
          if (useCache == false || subject == null){
               if (internalMessage != null){
                    subject = internalMessage.getSubject();
          return subject;
I was just hoping that I could avoid the synchronization issue.
Is there a way to somehow find the corresponding Javamail message of a local, cached message without having a reference to the original Javamail message instance?
As far as I know using the message ID would not work since they seem to be not well defined.
You also mentioned another issue.
The software I am currently developing will be a web application which will serve email functionality to thousands of users.
Thus, an agressive timeout policy is probably unavoidable.
I assume that once a timeout occurs, I'll have to reconnect and then also resynchronize in order to map Javamail message instances with their local cached pendants?