|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
javax.mail Class Folder
java.lang.Object javax.mail.Folder
public abstract class Folder
- extends Object
Folder 是表示邮件消息文件夹的抽象类。子类实现特定于协议的 Folder。
Folder 可以包含 Message、其他 Folder 或两者,这提供了以 Store 的默认文件夹为根的树状层次结构。(注意,有些 Folder 实现可能不允许 Message 和其他 Folder 都位于同一 Folder 中)。
文件夹名称的解释是与实现相关的。文件夹完全名称中不同的层次结构级别是用层次结构分界符字符将彼此隔开的。
保留不区分大小写的完全文件夹名称(即相对于 Store 的默认文件夹的完全名称)INBOX 来表示“此服务器上此用户的主文件夹”。并不是所有 Store 都会提供一个 INBOX 文件夹,也不是所有用户都会一直拥有一个 INBOX 文件夹。保留名称 INBOX 是为了在该文件夹存在时在提供它的 Store 中引用此文件夹。
从 Store 中获得的 Folder 对象无需实际存在于后端存储中。exists
方法测试文件夹是否存在。create
方法创建一个 Folder。
Folder 最初处于关闭状态。某些方法在这种状态下是有效的;这些方法的文档注明了这一点。通过调用其 'open' 方法打开 Folder。除了 open
、delete
和 renameTo
之外,所有 Folder 方法在这种状态下都是有效的。
获得 Folder 的唯一方式是调用 Store、Folder 或 Session 上的 getFolder
方法,或者调用 Folder 上的 list
或 listSubscribed
方法。Store 不缓存上述方法返回的 Folder 对象。因此,用相同文件夹名称多次调用 getFolder
方法将返回不同的 Folder 对象。对于 list
和 listSubscribed
方法也是如此。
Folder 缓存 Folder 中的 Message 对象。因此,用同一消息编号多次调用 getMessage(msgno)
将返回相同的 Message 对象,直到对此 Folder 执行清除操作。
注意,如果使用清除方法清除了该包含 Folder,则 Message 的消息编号可在会话中发生更改。使用消息编号作为对消息的引用的客户端应该意识到这一点,并且应该做好准备应对这种情况(可能通过清空现有消息编号引用并重新加载它们来应对)。由于这种复杂性,客户端最好使用 Message 对象作为对消息的引用,而不使用消息编号。已清除的 Message 对象仍然必须被删改,但该文件夹中的其他 Message 对象不受清除的影响。
Folder is an abstract class that represents a folder for mail messages. Subclasses implement protocol specific Folders.
Folders can contain Messages, other Folders or both, thus providing a tree-like hierarchy rooted at the Store's default folder. (Note that some Folder implementations may not allow both Messages and other Folders in the same Folder).
The interpretation of folder names is implementation dependent. The different levels of hierarchy in a folder's full name are separated from each other by the hierarchy delimiter character.
The case-insensitive full folder name (that is, the full name relative to the default folder for a Store) INBOX is reserved to mean the "primary folder for this user on this server". Not all Stores will provide an INBOX folder, and not all users will have an INBOX folder at all times. The name INBOX is reserved to refer to this folder, when it exists, in Stores that provide it.
A Folder object obtained from a Store need not actually exist
in the backend store. The exists
method tests whether
the folder exists or not. The create
method
creates a Folder.
A Folder is initially in the closed state. Certain methods are valid
in this state; the documentation for those methods note this. A
Folder is opened by calling its 'open' method. All Folder methods,
except open
, delete
and
renameTo
, are valid in this state.
The only way to get a Folder is by invoking the
getFolder
method on Store, Folder, or Session, or by invoking
the list
or listSubscribed
methods
on Folder. Folder objects returned by the above methods are not
cached by the Store. Thus, invoking the getFolder
method
with the same folder name multiple times will return distinct Folder
objects. Likewise for the list
and listSubscribed
methods.
The Message objects within the Folder are cached by the Folder.
Thus, invoking getMessage(msgno)
on the same message number
multiple times will return the same Message object, until an
expunge is done on this Folder.
Note that a Message's message number can change within a session if the containing Folder is expunged using the expunge method. Clients that use message numbers as references to messages should be aware of this and should be prepared to deal with situation (probably by flushing out existing message number references and reloading them). Because of this complexity, it is better for clients to use Message objects as references to messages, rather than message numbers. Expunged Message objects still have to be pruned, but other Message objects in that folder are not affected by the expunge.
- Author:
- John Mani, Bill Shannon
Field Summary | |
---|---|
static int |
HOLDS_FOLDERS
This folder can contain other folders |
static int |
HOLDS_MESSAGES
This folder can contain messages |
protected int |
mode
The open mode of this folder. |
static int |
READ_ONLY
The Folder is read only. |
static int |
READ_WRITE
The state and contents of this folder can be modified. |
protected Store |
store
The parent store. |
Constructor Summary | |
---|---|
protected |
Folder(Store store)
Constructor that takes a Store object. |
Method Summary | |
---|---|
void |
addConnectionListener(ConnectionListener l)
Add a listener for Connection events on this Folder. |
void |
addFolderListener(FolderListener l)
Add a listener for Folder events on this Folder. |
void |
addMessageChangedListener(MessageChangedListener l)
Add a listener for MessageChanged events on this Folder. |
void |
addMessageCountListener(MessageCountListener l)
Add a listener for MessageCount events on this Folder. |
abstract void |
appendMessages(Message[] msgs)
Append given Messages to this folder. |
abstract void |
close(boolean expunge)
Close this Folder. |
void |
copyMessages(Message[] msgs,
Folder folder)
Copy the specified Messages from this Folder into another Folder. |
abstract boolean |
create(int type)
Create this folder on the Store. |
abstract boolean |
delete(boolean recurse)
Delete this Folder. |
abstract boolean |
exists()
Tests if this folder physically exists on the Store. |
abstract Message[] |
expunge()
Expunge (permanently remove) messages marked DELETED. |
void |
fetch(Message[] msgs,
FetchProfile fp)
Prefetch the items specified in the FetchProfile for the given Messages. |
protected void |
finalize()
|
int |
getDeletedMessageCount()
Get the number of deleted messages in this Folder. |
abstract Folder |
getFolder(String name)
Return the Folder object corresponding to the given name. |
abstract String |
getFullName()
Returns the full name of this Folder. |
abstract Message |
getMessage(int msgnum)
Get the Message object corresponding to the given message number. |
abstract int |
getMessageCount()
Get total number of messages in this Folder. |
Message[] |
getMessages()
Get all Message objects from this Folder. |
Message[] |
getMessages(int[] msgnums)
Get the Message objects for message numbers specified in the array. |
Message[] |
getMessages(int start,
int end)
Get the Message objects for message numbers ranging from start through end, both start and end inclusive. |
int |
getMode()
Return the open mode of this folder. |
abstract String |
getName()
Returns the name of this Folder. |
int |
getNewMessageCount()
Get the number of new messages in this Folder. |
abstract Folder |
getParent()
Returns the parent folder of this folder. |
abstract Flags |
getPermanentFlags()
Get the permanent flags supported by this Folder. |
abstract char |
getSeparator()
Return the delimiter character that separates this Folder's pathname from the names of immediate subfolders. |
Store |
getStore()
Returns the Store that owns this Folder object. |
abstract int |
getType()
Returns the type of this Folder, that is, whether this folder can hold messages or subfolders or both. |
int |
getUnreadMessageCount()
Get the total number of unread messages in this Folder. |
URLName |
getURLName()
Return a URLName representing this folder. |
abstract boolean |
hasNewMessages()
Returns true if this Folder has new messages since the last time this indication was reset. |
abstract boolean |
isOpen()
Indicates whether this Folder is in the 'open' state. |
boolean |
isSubscribed()
Returns true if this Folder is subscribed. |
Folder[] |
list()
Convenience method that returns the list of folders under this Folder. |
abstract Folder[] |
list(String pattern)
Returns a list of Folders belonging to this Folder's namespace that match the specified pattern. |
Folder[] |
listSubscribed()
Convenience method that returns the list of subscribed folders under this Folder. |
Folder[] |
listSubscribed(String pattern)
Returns a list of subscribed Folders belonging to this Folder's namespace that match the specified pattern. |
protected void |
notifyConnectionListeners(int type)
Notify all ConnectionListeners. |
protected void |
notifyFolderListeners(int type)
Notify all FolderListeners registered on this Folder and this folder's Store. |
protected void |
notifyFolderRenamedListeners(Folder folder)
Notify all FolderListeners registered on this Folder and this folder's Store about the renaming of this folder. |
protected void |
notifyMessageAddedListeners(Message[] msgs)
Notify all MessageCountListeners about the addition of messages into this folder. |
protected void |
notifyMessageChangedListeners(int type,
Message msg)
Notify all MessageChangedListeners. |
protected void |
notifyMessageRemovedListeners(boolean removed,
Message[] msgs)
Notify all MessageCountListeners about the removal of messages from this Folder. |
abstract void |
open(int mode)
Open this Folder. |
void |
removeConnectionListener(ConnectionListener l)
Remove a Connection event listener. |
void |
removeFolderListener(FolderListener l)
Remove a Folder event listener. |
void |
removeMessageChangedListener(MessageChangedListener l)
Remove a MessageChanged listener. |
void |
removeMessageCountListener(MessageCountListener l)
Remove a MessageCount listener. |
abstract boolean |
renameTo(Folder f)
Rename this Folder. |
Message[] |
search(SearchTerm term)
Search this Folder for messages matching the specified search criterion. |
Message[] |
search(SearchTerm term,
Message[] msgs)
Search the given array of messages for those that match the specified search criterion. |
void |
setFlags(int[] msgnums,
Flags flag,
boolean value)
Set the specified flags on the messages whose message numbers are in the array. |
void |
setFlags(int start,
int end,
Flags flag,
boolean value)
Set the specified flags on the messages numbered from start through end, both start and end inclusive. |
void |
setFlags(Message[] msgs,
Flags flag,
boolean value)
Set the specified flags on the messages specified in the array. |
void |
setSubscribed(boolean subscribe)
Subscribe or unsubscribe this Folder. |
String |
toString()
override the default toString(), it will return the String from Folder.getFullName() or if that is null, it will use the default toString() behavior. |
Methods inherited from class java.lang.Object |
---|
clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait |
Field Detail |
---|
英文文档:
store
protected Store store
- The parent store.
英文文档:
mode
protected int mode
- The open mode of this folder. The open mode is
Folder.READ_ONLY
,Folder.READ_WRITE
, or -1 if not known.- Since:
- JavaMail 1.1
英文文档:
HOLDS_MESSAGES
public static final int HOLDS_MESSAGES
- This folder can contain messages
- See Also:
- Constant Field Values
英文文档:
HOLDS_FOLDERS
public static final int HOLDS_FOLDERS
- This folder can contain other folders
- See Also:
- Constant Field Values
英文文档:
READ_ONLY
public static final int READ_ONLY
- The Folder is read only. The state and contents of this
folder cannot be modified.
- See Also:
- Constant Field Values
英文文档:
READ_WRITE
public static final int READ_WRITE
- The state and contents of this folder can be modified.
- See Also:
- Constant Field Values
Constructor Detail |
---|
protected
Folder(Store store)
带有 Store 对象的构造方法。
store | 保存此文件夹的 Store |
Folder
protected Folder(Store store)
- Constructor that takes a Store object.
- Parameters:
store
- the Store that holds this folder
Method Detail |
---|
abstract public String
getName()
返回此 Folder 的名称。
可以对关闭的 Folder 调用此方法。
return | Folder 的名称 |
getName
public abstract String getName()
- Returns the name of this Folder.
This method can be invoked on a closed Folder.
- Returns:
- name of the Folder
abstract public String
getFullName()
返回此 Folder 的完全名称。如果该文件夹位于此 Store 的根层次结构下,则返回的名称是相对于根的。否则返回一个以层次结构分界符开头的绝对名称。
可以对关闭的 Folder 调用此方法。
return | Folder 的完全名称 |
getFullName
public abstract String getFullName()
- Returns the full name of this Folder. If the folder resides under
the root hierarchy of this Store, the returned name is relative
to the root. Otherwise an absolute name, starting with the
hierarchy delimiter, is returned.
This method can be invoked on a closed Folder.
- Returns:
- full name of the Folder
public URLName
getURLName() throws MessagingException
返回表示此文件夹的 URLName。返回的 URLName 不 包括用来访问 store 的密码。
return | 表示此文件夹的 URLName | |
since |
| |
See also | javax.mail.URLName |
getURLName
public URLName getURLName() throws MessagingException
- Return a URLName representing this folder. The returned URLName
does not include the password used to access the store.
- Returns:
- the URLName representing this folder
- Throws:
MessagingException
- Since:
- JavaMail 1.1
- See Also:
URLName
public Store
getStore()
返回拥有此 Folder 对象的 Store。可以对关闭的 Folder 调用此方法。
return | Store |
getStore
public Store getStore()
- Returns the Store that owns this Folder object.
This method can be invoked on a closed Folder.
- Returns:
- the Store
abstract public Folder
getParent() throws MessagingException
返回此文件夹的父文件夹。可以对关闭的 Folder 调用此方法。如果此文件夹位于文件夹层次结构的顶部,则此方法返回 null。
注意,因为 Folder 对象未被缓存,所以调用此方法将返回一个新的截然不同的 Folder 对象。
return | 父文件夹 |
getParent
public abstract Folder getParent() throws MessagingException
- Returns the parent folder of this folder.
This method can be invoked on a closed Folder. If this folder
is the top of a folder hierarchy, this method returns null.
Note that since Folder objects are not cached, invoking this method returns a new distinct Folder object.
- Returns:
- Parent folder
- Throws:
MessagingException
abstract public boolean
exists() throws MessagingException
测试此文件夹在物理上是否存在于该 Store 上。可以对关闭的 Folder 调用此方法。
return | 如果文件夹存在,则返回 true;否则返回 false |
Throws | MessagingException: 如果到该服务器的连接丢失,则通常抛出此异常。 |
See also | create |
exists
public abstract boolean exists() throws MessagingException
- Tests if this folder physically exists on the Store.
This method can be invoked on a closed Folder.
- Returns:
- true if the folder exists, otherwise false
- Throws:
MessagingException
- typically if the connection to the server is lost.- See Also:
create(int)
abstract public Folder[]
list(String pattern) throws MessagingException
返回一个 Folder 列表,这些 Folder 属于此 Folder 的与指定模式匹配的名称空间。模式可能包含通配符字符 "%"
和 "*"
,前者匹配除层次结构分界符以外的任意字符,后者匹配任意字符。
例如,假定文件夹层次结构如下所示:
Personal/ Finance/ Stocks Bonus StockOptions Jokes对 "Personal" 调用
list("*")
将返回整个层次结构。对 "Personal" 调用
list("%")
将返回 "Finance" 和 "Jokes"。对 "Personal" 调用
list("Jokes")
将返回 "Jokes"。对 "Finance" 调用
list("Stock*")
将返回 "Stocks" 和 "StockOptions"。 Store 不缓存 Folder 对象,因此用相同的模式多次调用此方法将返回许多不同的 Folder 对象。
可以对关闭的 Folder 调用此方法。
pattern | 匹配模式 |
return | 匹配的 Folder 对象的数组。如果不存在匹配的 Folder,则返回一个空数组。 |
Throws | FolderNotFoundException: 如果此文件夹不存在。 |
Throws | MessagingException: |
See also | listSubscribed |
list
public abstract Folder[] list(String pattern) throws MessagingException
- Returns a list of Folders belonging to this Folder's namespace
that match the specified pattern. Patterns may contain the wildcard
characters
"%"
, which matches any character except hierarchy delimiters, and"*"
, which matches any character.As an example, given the folder hierarchy:
Personal/ Finance/ Stocks Bonus StockOptions Jokes
list("*")
on "Personal" will return the whole hierarchy.
list("%")
on "Personal" will return "Finance" and "Jokes".
list("Jokes")
on "Personal" will return "Jokes".
list("Stock*")
on "Finance" will return "Stocks" and "StockOptions".Folder objects are not cached by the Store, so invoking this method on the same pattern multiple times will return that many distinct Folder objects.
This method can be invoked on a closed Folder.
- Parameters:
pattern
- the match pattern- Returns:
- array of matching Folder objects. An empty array is returned if no matching Folders exist.
- Throws:
FolderNotFoundException
- if this folder does not exist.MessagingException
- See Also:
listSubscribed(java.lang.String)
public Folder[]
listSubscribed(String pattern) throws MessagingException
返回已订阅 Folder 的列表,这些 Folder 属于此 Folder 的与指定模式匹配的名称空间。如果该文件夹不支持订阅,则此方法应该解析为 list
。(此处提供的默认实现就是完成此操作的)。该模式可以包含通配符,这与 list
类似。
注意,在给定的文件夹层次结构级别上,可能未订阅某个特定文件夹,但可以订阅文件夹层次结构中该文件夹下的文件夹。为了允许遍历文件夹层次结构,可返回此类未订阅的文件夹,指示该层次结构中更低级别的某个文件夹被订阅了。文件夹上的 isSubscribed
方法可判断任何特定文件夹是否被实际订阅了。
Store 不缓存 Folder 对象,因此用相同的模式多次调用此方法将返回许多不同的 Folder 对象。
可以对关闭的 Folder 调用此方法。
pattern | 匹配模式 |
return | 匹配的已订阅 Folder 对象的数组。如果不存在匹配的已订阅文件夹,则返回一个空数组。 |
Throws | FolderNotFoundException: 如果此文件夹不存在。 |
Throws | MessagingException: |
See also | list |
listSubscribed
public Folder[] listSubscribed(String pattern) throws MessagingException
- Returns a list of subscribed Folders belonging to this Folder's
namespace that match the specified pattern. If the folder does
not support subscription, this method should resolve to
list
. (The default implementation provided here, does just this). The pattern can contain wildcards as forlist
.Note that, at a given level of the folder hierarchy, a particular folder may not be subscribed, but folders underneath that folder in the folder hierarchy may be subscribed. In order to allow walking the folder hierarchy, such unsubscribed folders may be returned, indicating that a folder lower in the hierarchy is subscribed. The
isSubscribed
method on a folder will tell whether any particular folder is actually subscribed.Folder objects are not cached by the Store, so invoking this method on the same pattern multiple times will return that many distinct Folder objects.
This method can be invoked on a closed Folder.
- Parameters:
pattern
- the match pattern- Returns:
- array of matching subscribed Folder objects. An empty array is returned if no matching subscribed folders exist.
- Throws:
FolderNotFoundException
- if this folder does not exist.MessagingException
- See Also:
list(java.lang.String)
public Folder[]
list() throws MessagingException
返回此 Folder 下文件夹的列表的便捷方法。此方法只使用 "%"
作为匹配模式来调用 list(String pattern)
方法。可以对关闭的 Folder 调用此方法。
return | 此 Folder 下的 Folder 对象的数组。如果不存在子文件夹,则返回一个空数组。 |
Throws | FolderNotFoundException: 如果此文件夹不存在。 |
Throws | MessagingException: |
See also | list |
list
public Folder[] list() throws MessagingException
- Convenience method that returns the list of folders under this
Folder. This method just calls the
list(String pattern)
method with"%"
as the match pattern. This method can be invoked on a closed Folder. - Returns:
- array of Folder objects under this Folder. An empty array is returned if no subfolders exist.
- Throws:
FolderNotFoundException
- if this folder does not exist.MessagingException
- See Also:
list(java.lang.String)
public Folder[]
listSubscribed() throws MessagingException
返回此 Folder 下已订阅文件夹的列表的便捷方法。此方法只使用 "%"
作为匹配模式来调用 listSubscribed(String pattern)
方法。可以对关闭的 Folder 调用此方法。
return | 此 Folder 下已订阅 Folder 对象的数组。如果不存在已订阅子文件夹,则返回一个空数组。 |
Throws | FolderNotFoundException: 如果此文件夹不存在。 |
Throws | MessagingException: |
See also | listSubscribed |
listSubscribed
public Folder[] listSubscribed() throws MessagingException
- Convenience method that returns the list of subscribed folders
under this Folder. This method just calls the
listSubscribed(String pattern)
method with"%"
as the match pattern. This method can be invoked on a closed Folder. - Returns:
- array of subscribed Folder objects under this Folder. An empty array is returned if no subscribed subfolders exist.
- Throws:
FolderNotFoundException
- if this folder does not exist.MessagingException
- See Also:
listSubscribed(java.lang.String)
abstract public char
getSeparator() throws MessagingException
返回将此 Folder 的路径名与直接子文件夹名称分隔开的分界符字符。可以对关闭的 Folder 调用此方法。
Throws | FolderNotFoundException: 如果该实现需要该文件夹存在,但该文件夹不存在 |
return | 层次结构分隔符字符 |
getSeparator
public abstract char getSeparator() throws MessagingException
- Return the delimiter character that separates this Folder's pathname
from the names of immediate subfolders. This method can be invoked
on a closed Folder.
- Returns:
- Hierarchy separator character
- Throws:
FolderNotFoundException
- if the implementation requires the folder to exist, but it does notMessagingException
abstract public int
getType() throws MessagingException
返回此 Folder 的类型,即此文件夹是保存消息,还是保存子文件夹,还是二者都包括。返回的值是带有适当位集的整数位字段。可以对关闭的 Folder 调用此方法。
return | 带有适当位集的整数 |
Throws | FolderNotFoundException: 如果此文件夹不存在。 |
See also | HOLDS_FOLDERS, HOLDS_MESSAGES |
getType
public abstract int getType() throws MessagingException
- Returns the type of this Folder, that is, whether this folder can hold
messages or subfolders or both. The returned value is an integer
bitfield with the appropriate bits set. This method can be invoked
on a closed folder.
- Returns:
- integer with appropriate bits set
- Throws:
FolderNotFoundException
- if this folder does not exist.MessagingException
- See Also:
HOLDS_FOLDERS
,HOLDS_MESSAGES
abstract public boolean
create(int type) throws MessagingException
在 Store 上创建此文件夹。在创建此文件夹时,还将创建其路径中不存在的任何文件夹。
如果创建成功,则向此 Folder 和此 Store 上注册的所有 FolderListener 传送 CREATED FolderEvent。
type | 此文件夹的类型。 |
return | 如果创建成功,则返回 true;否则返回 false。 |
Throws | MessagingException: |
See also | HOLDS_FOLDERS, HOLDS_MESSAGES, javax.mail.event.FolderEvent |
create
public abstract boolean create(int type) throws MessagingException
- Create this folder on the Store. When this folder is created, any
folders in its path that do not exist are also created.
If the creation is successful, a CREATED FolderEvent is delivered to any FolderListeners registered on this Folder and this Store.
- Parameters:
type
- The type of this folder.- Returns:
- true if the creation succeeds, else false.
- Throws:
MessagingException
- See Also:
HOLDS_FOLDERS
,HOLDS_MESSAGES
,FolderEvent
public boolean
isSubscribed()
如果此 Folder 被订阅,则返回 true。
可以对关闭的 Folder 调用此方法。
此处提供的默认实现只返回 true。
return | 如果此 Folder 被订阅,则返回 ture |
isSubscribed
public boolean isSubscribed()
- Returns true if this Folder is subscribed.
This method can be invoked on a closed Folder.
The default implementation provided here just returns true.
- Returns:
- true if this Folder is subscribed
public void
setSubscribed(boolean subscribe) throws MessagingException
订阅或取消订阅此 Folder。并不是所有 Store 都支持订阅。
可以对关闭的 Folder 调用此方法。
此处提供的实现只抛出 MethodNotSupportedException。
subscribe | 该参数为 ture 表示订阅,为 false 表示取消订阅 |
Throws | FolderNotFoundException: 如果此文件夹不存在。 |
Throws | MethodNotSupportedException: 如果此 Store 不支持订阅 |
Throws | MessagingException: |
setSubscribed
public void setSubscribed(boolean subscribe) throws MessagingException
- Subscribe or unsubscribe this Folder. Not all Stores support
subscription.
This method can be invoked on a closed Folder.
The implementation provided here just throws the MethodNotSupportedException.
- Parameters:
subscribe
- true to subscribe, false to unsubscribe- Throws:
FolderNotFoundException
- if this folder does not exist.MethodNotSupportedException
- if this store does not support subscriptionMessagingException
abstract public boolean
hasNewMessages() throws MessagingException
如果自上次重置此指示后,此 Folder 有了新的消息,则返回 ture。设置或重置此指示的时间取决于 Folder 实现(在使用 IMAP 的情况下,取决于服务器)。可使用此方法在 Folder 上实现轻量级“检查新邮件”操作,无需打开该 Folder。(例如,监视邮箱和邮箱中有新邮件时的标志的线程。)此方法应该指示 Folder 中的任何消息是否设置了 RECENT
标志。
注意,这不是对新邮件的增量检查,也就是说,无法用它来确定自上次调用此方法以来是否有任何新邮件到达。要实现增量检查,需要打开 Folder。
可以对能够包含 Message 的关闭的 Folder 调用此方法。
return | 如果 Store 有新 Message,则返回 true |
Throws | FolderNotFoundException: 如果此文件夹不存在。 |
Throws | MessagingException: |
hasNewMessages
public abstract boolean hasNewMessages() throws MessagingException
- Returns true if this Folder has new messages since the last time
this indication was reset. When this indication is set or reset
depends on the Folder implementation (and in the case of IMAP,
depends on the server). This method can be used to implement
a lightweight "check for new mail" operation on a Folder without
opening it. (For example, a thread that monitors a mailbox and
flags when it has new mail.) This method should indicate whether
any messages in the Folder have the
RECENT
flag set.Note that this is not an incremental check for new mail, i.e., it cannot be used to determine whether any new messages have arrived since the last time this method was invoked. To implement incremental checks, the Folder needs to be opened.
This method can be invoked on a closed Folder that can contain Messages.
- Returns:
- true if the Store has new Messages
- Throws:
FolderNotFoundException
- if this folder does not exist.MessagingException
abstract public Folder
getFolder(String name) throws MessagingException
返回与给定名称相对应的 Folder 对象。注意,此文件夹不必在物理上存在于该 Store 中。Folder 上的 exists()
方法可指示其是否实际存在于 Store 上。
在某些 Store 中,名称可以是绝对路径,如果它以层次结构分界符开始。否则,它将被解释为相对于此 Folder 的路径。
Store 不缓存 Folder 对象,因此用相同的名称多次调用此方法将返回许多不同的 Folder 对象。
可以对关闭的 Folder 调用此方法。
name | Folder 的名称 |
return | Folder 对象 |
Throws | MessagingException: |
getFolder
public abstract Folder getFolder(String name) throws MessagingException
- Return the Folder object corresponding to the given name. Note that
this folder does not physically have to exist in the Store. The
exists()
method on a Folder indicates whether it really exists on the Store.In some Stores, name can be an absolute path if it starts with the hierarchy delimiter. Otherwise, it is interpreted relative to this Folder.
Folder objects are not cached by the Store, so invoking this method on the same name multiple times will return that many distinct Folder objects.
This method can be invoked on a closed Folder.
- Parameters:
name
- name of the Folder- Returns:
- Folder object
- Throws:
MessagingException
abstract public boolean
delete(boolean recurse) throws MessagingException
删除此 Folder。此方法只有在关闭的 Folder 上才会成功。
recurse
标志控制删除是否影响子文件夹。如果该标志为 true,则删除所有子文件夹,然后删除此文件夹本身。如果该标志为 false,则具体行为取决于文件夹类型,如下方详述:
-
文件夹只能包含消息:(type == HOLDS_MESSAGES)。
移除文件夹内的所有消息。然后移除文件夹本身。Store 和此文件夹将生成相应的 FolderEvent。 -
文件夹只能包含子文件夹:(type == HOLDS_FOLDERS)。
如果此文件夹为空(根本不包含任何子文件夹),则移除它。Store 和此文件夹将生成相应的 FolderEvent。
如果此文件夹包含任何子文件夹,则删除失败并返回 false。 -
文件夹可以包含子文件夹和消息:
如果文件夹为空(没有消息或子文件夹),则移除它。如果文件夹不包含子文件夹,只包含消息,则移除所有消息。然后移除文件夹本身。在上述两种情况下,Store 和此文件夹将生成相应的 FolderEvent。如果该文件夹包含子文件夹,则有 3 种可能的选择,实现可以任选其一:
- 操作失败,而不考虑此文件夹是否包含消息。有些实现可能选择使用这种简单的方法。delete() 方法返回 false。
- 移除该文件夹内的所有消息。不移除子文件夹。不以任何方式移除文件夹本身或影响它。delete() 方法返回 true。且此文件夹上的 exists() 方法将返回 true,指示此文件夹仍然存在。
Store 和此文件夹将生成相应的 FolderEvent。 - 移除该文件夹内的所有消息。不移除子文件夹。文件夹本身将其类型从 HOLDS_FOLDERS | HOLDS_MESSAGES 更改为 HOLDS_FOLDERS。这样就无法将新消息添加到此文件夹中,但可以在此文件夹下创建新的子文件夹。delete() 方法返回 true,指示操作成功。此文件夹上的 exists() 方法将返回 true,指示此文件夹仍然存在。
Store 和此文件夹将生成相应的 FolderEvent。
return | 如果成功删除该 Folder,则返回 true |
Throws | FolderNotFoundException: 如果此文件夹不存在 |
Throws | IllegalStateException: 如果此文件夹不处于关闭状态。 |
Throws | MessagingException: |
See also | javax.mail.event.FolderEvent |
delete
public abstract boolean delete(boolean recurse) throws MessagingException
- Delete this Folder. This method will succeed only on a closed
Folder.
The
recurse
flag controls whether the deletion affects subfolders or not. If true, all subfolders are deleted, then this folder itself is deleted. If false, the behaviour is dependent on the folder type and is elaborated below:-
The folder can contain only messages: (type == HOLDS_MESSAGES).
All messages within the folder are removed. The folder itself is then removed. An appropriate FolderEvent is generated by the Store and this folder. -
The folder can contain only subfolders: (type == HOLDS_FOLDERS).
If this folder is empty (does not contain any subfolders at all), it is removed. An appropriate FolderEvent is generated by the Store and this folder.
If this folder contains any subfolders, the delete fails and returns false. -
The folder can contain subfolders as well as messages:
If the folder is empty (no messages or subfolders), it is removed. If the folder contains no subfolders, but only messages, then all messages are removed. The folder itself is then removed. In both the above cases, an appropriate FolderEvent is generated by the Store and this folder.If the folder contains subfolders there are 3 possible choices an implementation is free to do:
- The operation fails, irrespective of whether this folder contains messages or not. Some implementations might elect to go with this simple approach. The delete() method returns false.
- Any messages within the folder are removed. Subfolders
are not removed. The folder itself is not removed or affected
in any manner. The delete() method returns true. And the
exists() method on this folder will return true indicating that
this folder still exists.
An appropriate FolderEvent is generated by the Store and this folder. - Any messages within the folder are removed. Subfolders are
not removed. The folder itself changes its type from
HOLDS_FOLDERS | HOLDS_MESSAGES to HOLDS_FOLDERS. Thus new
messages cannot be added to this folder, but new subfolders can
be created underneath. The delete() method returns true indicating
success. The exists() method on this folder will return true
indicating that this folder still exists.
An appropriate FolderEvent is generated by the Store and this folder.
-
The folder can contain only messages: (type == HOLDS_MESSAGES).
- Returns:
- true if the Folder is deleted successfully
- Throws:
FolderNotFoundException
- if this folder does not existIllegalStateException
- if this folder is not in the closed state.MessagingException
- See Also:
FolderEvent
abstract public boolean
renameTo(Folder f) throws MessagingException
重命名此 Folder。此方法只有在关闭的 Folder 上才会成功。
如果重命名成功,则向此文件夹及其包含 Store 上注册的 FolderListener 传送 RENAMED FolderEvent。
f | 表示此 Folder 的新名称的文件夹 |
return | 如果成功重命名该 Folder,则返回 true |
Throws | FolderNotFoundException: 如果此文件夹不存在 |
Throws | IllegalStateException: 如果此文件夹不处于关闭状态。 |
Throws | MessagingException: |
See also | javax.mail.event.FolderEvent |
renameTo
public abstract boolean renameTo(Folder f) throws MessagingException
- Rename this Folder. This method will succeed only on a closed
Folder.
If the rename is successful, a RENAMED FolderEvent is delivered to FolderListeners registered on this folder and its containing Store.
- Parameters:
f
- a folder representing the new name for this Folder- Returns:
- true if the Folder is renamed successfully
- Throws:
FolderNotFoundException
- if this folder does not existIllegalStateException
- if this folder is not in the closed state.MessagingException
- See Also:
FolderEvent
abstract public void
open(int mode) throws MessagingException
打开此 Folder。此方法仅对可以包含 Message 并处于关闭状态的 Folder 有效。
如果成功打开此文件夹,则向此 Folder 上注册的所有 ConnectionListener 传送 OPENED ConnectionEvent。
打开多个到特定 Store 上同一文件夹的连接的效果是与实现相关的。有些实现允许有多个读者,但只允许有一个编写者。其他实现则允许有多个编写者和读者。
mode | 打开 Folder READ_ONLY 或 READ_WRITE |
Throws | FolderNotFoundException: 如果此文件夹不存在。 |
Throws | IllegalStateException: 如果此文件夹不处于关闭状态。 |
Throws | MessagingException: |
See also | READ_ONLY, READ_WRITE, getType(), javax.mail.event.ConnectionEvent |
open
public abstract void open(int mode) throws MessagingException
- Open this Folder. This method is valid only on Folders that
can contain Messages and that are closed.
If this folder is opened successfully, an OPENED ConnectionEvent is delivered to any ConnectionListeners registered on this Folder.
The effect of opening multiple connections to the same folder on a specifc Store is implementation dependent. Some implementations allow multiple readers, but only one writer. Others allow multiple writers as well as readers.
- Parameters:
mode
- open the Folder READ_ONLY or READ_WRITE- Throws:
FolderNotFoundException
- if this folder does not exist.IllegalStateException
- if this folder is not in the closed state.MessagingException
- See Also:
READ_ONLY
,READ_WRITE
,getType()
,ConnectionEvent
abstract public void
close(boolean expunge) throws MessagingException
关闭此 Folder。此方法只对打开的 Folder 有效。
向此 Folder 上注册的所有 ConnectionListener 传送 CLOSED ConnectionEvent。注意,即使此方法通过抛出 MessagingException 异常终止,该文件夹也会关闭。
expunge | 如果此标志为 ture,则清除所有已删除的消息 |
Throws | IllegalStateException: 如果此文件夹没有打开 |
Throws | MessagingException: |
See also | javax.mail.event.ConnectionEvent |
close
public abstract void close(boolean expunge) throws MessagingException
- Close this Folder. This method is valid only on open Folders.
A CLOSED ConnectionEvent is delivered to any ConnectionListeners registered on this Folder. Note that the folder is closed even if this method terminates abnormally by throwing a MessagingException.
- Parameters:
expunge
- expunges all deleted messages if this flag is true- Throws:
IllegalStateException
- if this folder is not openedMessagingException
- See Also:
ConnectionEvent
abstract public boolean
isOpen()
指示此 Folder 是否处于 'open' 状态。
return | 如果此 Folder 处于 'open' 状态,则返回 true |
isOpen
public abstract boolean isOpen()
- Indicates whether this Folder is in the 'open' state.
- Returns:
- true if this Folder is in the 'open' state.
public int
getMode()
返回此文件夹的打开模式。返回 Folder.READ_ONLY
、Folder.READ_WRITE
或如果打开模式未知,则返回 -1(这通常只是因为某个旧的 Folder
提供者未更新到使用此新方法)。
Throws | IllegalStateException: 如果此文件夹没有打开 | |
return | 此文件夹的打开模式 | |
since |
|
getMode
public int getMode()
- Return the open mode of this folder. Returns
Folder.READ_ONLY
,Folder.READ_WRITE
, or -1 if the open mode is not known (usually only because an olderFolder
provider has not been updated to use this new method). - Returns:
- the open mode of this folder
- Throws:
IllegalStateException
- if this folder is not opened- Since:
- JavaMail 1.1
abstract public Flags
getPermanentFlags()
获取此 Folder 支持的持久标志。返回包含所有受支持标志的 Flag 对象。
特殊标志 Flags.USER
指示此 Folder 支持用户定义的任意标志。
在打开文件夹之前,该文件夹的受支持持久标志可能是不可用的。
return | 持久标志;如果持久标志未知,则返回 null |
getPermanentFlags
public abstract Flags getPermanentFlags()
- Get the permanent flags supported by this Folder. Returns a Flags
object that contains all the flags supported.
The special flag
Flags.USER
indicates that this Folder supports arbitrary user-defined flags.The supported permanent flags for a folder may not be available until the folder is opened.
- Returns:
- permanent flags, or null if not known
abstract public int
getMessageCount() throws MessagingException
获取此 Folder 中消息的总数。
可以对关闭的 Folder 调用此方法。但要注意的是,对于某些文件夹实现而言,获取总消息计数可能是一个开销很大的操作,涉及到实际打开该文件夹。在这种情况下,提供者可以选择在关闭状态下不支持此功能,此时此方法必须返回 -1。
对关闭的文件夹调用此方法的客户端必须要意识到这可能是一个开销很大的操作。这种情况下,客户端还必须准备好处理返回值 -1。
return | 消息总数。如果对关闭的文件夹调用此方法,则某些实现可能返回 -1。 |
Throws | FolderNotFoundException: 如果此文件夹不存在。 |
Throws | MessagingException: |
getMessageCount
public abstract int getMessageCount() throws MessagingException
- Get total number of messages in this Folder.
This method can be invoked on a closed folder. However, note that for some folder implementations, getting the total message count can be an expensive operation involving actually opening the folder. In such cases, a provider can choose not to support this functionality in the closed state, in which case this method must return -1.
Clients invoking this method on a closed folder must be aware that this is a potentially expensive operation. Clients must also be prepared to handle a return value of -1 in this case.
- Returns:
- total number of messages. -1 may be returned by certain implementations if this method is invoked on a closed folder.
- Throws:
FolderNotFoundException
- if this folder does not exist.MessagingException
public int
getNewMessageCount() throws MessagingException
获取此 Folder 中新消息的数量。
可以对关闭的 Folder 调用此方法。但要注意的是,对于某些文件夹实现而言,获取新消息计数可能是一个开销很大的操作,涉及到实际打开该文件夹。在这种情况下,提供者可以选择在关闭状态下不支持此功能,此时此方法必须返回 -1。
对关闭的文件夹调用此方法的客户端必须要意识到这可能是一个开销很大的操作。这种情况下,客户端还必须准备好处理返回值 -1。
如果此文件夹是关闭的,则此实现返回 -1。否则,此实现将使用 getMessage(int)
获取该文件夹中的每个 Message,并检查它是否设置了 RECENT
标志。返回设置了此标志的消息总数。
return | 新消息数。如果对关闭的文件夹调用此方法,则某些实现可能返回 -1。 |
Throws | FolderNotFoundException: 如果此文件夹不存在。 |
Throws | MessagingException: |
getNewMessageCount
public int getNewMessageCount() throws MessagingException
- Get the number of new messages in this Folder.
This method can be invoked on a closed folder. However, note that for some folder implementations, getting the new message count can be an expensive operation involving actually opening the folder. In such cases, a provider can choose not to support this functionality in the closed state, in which case this method must return -1.
Clients invoking this method on a closed folder must be aware that this is a potentially expensive operation. Clients must also be prepared to handle a return value of -1 in this case.
This implementation returns -1 if this folder is closed. Else this implementation gets each Message in the folder using
getMessage(int)
and checks whether itsRECENT
flag is set. The total number of messages that have this flag set is returned. - Returns:
- number of new messages. -1 may be returned by certain implementations if this method is invoked on a closed folder.
- Throws:
FolderNotFoundException
- if this folder does not exist.MessagingException
public int
getUnreadMessageCount() throws MessagingException
获取此 Folder 中未读消息的总数。
可以对关闭的 Folder 调用此方法。但要注意的是,对于某些文件夹实现而言,获取未读消息计数可能是一个开销很大的操作,涉及到实际打开该文件夹。在这种情况下,提供者可以选择在关闭状态下不支持此功能,此时此方法必须返回 -1。
对关闭的文件夹调用此方法的客户端必须要意识到这可能是一个开销很大的操作。这种情况下,客户端还必须准备好处理返回值 -1。
如果此文件夹是关闭的,则此实现返回 -1。否则,此实现将使用 getMessage(int)
获取该文件夹中的每个 Message,并检查它是否设置了 SEEN
标志。返回未设置此标志的消息总数。
return | 未读消息的总数。如果对关闭的文件夹调用此方法,则某些实现可能返回 -1。 |
Throws | FolderNotFoundException: 如果此文件夹不存在。 |
Throws | MessagingException: |
getUnreadMessageCount
public int getUnreadMessageCount() throws MessagingException
- Get the total number of unread messages in this Folder.
This method can be invoked on a closed folder. However, note that for some folder implementations, getting the unread message count can be an expensive operation involving actually opening the folder. In such cases, a provider can choose not to support this functionality in the closed state, in which case this method must return -1.
Clients invoking this method on a closed folder must be aware that this is a potentially expensive operation. Clients must also be prepared to handle a return value of -1 in this case.
This implementation returns -1 if this folder is closed. Else this implementation gets each Message in the folder using
getMessage(int)
and checks whether itsSEEN
flag is set. The total number of messages that do not have this flag set is returned. - Returns:
- total number of unread messages. -1 may be returned by certain implementations if this method is invoked on a closed folder.
- Throws:
FolderNotFoundException
- if this folder does not exist.MessagingException
public int
getDeletedMessageCount() throws MessagingException
获取此 Folder 中已删除消息的数量。
可以对关闭的 Folder 调用此方法。但要注意的是,对于某些文件夹实现而言,获取已删除消息计数可能是一个开销很大的操作,涉及到实际打开该文件夹。在这种情况下,提供者可以选择在关闭状态下不支持此功能,此时此方法必须返回 -1。
对关闭的文件夹调用此方法的客户端必须要意识到这可能是一个开销很大的操作。这种情况下,客户端还必须准备好处理返回值 -1。
如果此文件夹是关闭的,则此实现返回 -1。否则,此实现将使用 getMessage(int)
获取该文件夹中的每个 Message,并检查它是否设置了 DELETED
标志。返回设置了此标志的消息总数。
return | 已删除消息的数量。如果对关闭的文件夹调用此方法,则某些实现可能返回 -1。 | |
Throws | FolderNotFoundException: 如果此文件夹不存在。 | |
Throws | MessagingException: | |
since |
|
getDeletedMessageCount
public int getDeletedMessageCount() throws MessagingException
- Get the number of deleted messages in this Folder.
This method can be invoked on a closed folder. However, note that for some folder implementations, getting the deleted message count can be an expensive operation involving actually opening the folder. In such cases, a provider can choose not to support this functionality in the closed state, in which case this method must return -1.
Clients invoking this method on a closed folder must be aware that this is a potentially expensive operation. Clients must also be prepared to handle a return value of -1 in this case.
This implementation returns -1 if this folder is closed. Else this implementation gets each Message in the folder using
getMessage(int)
and checks whether itsDELETED
flag is set. The total number of messages that have this flag set is returned. - Returns:
- number of deleted messages. -1 may be returned by certain implementations if this method is invoked on a closed folder.
- Throws:
FolderNotFoundException
- if this folder does not exist.MessagingException
- Since:
- JavaMail 1.3
abstract public Message
getMessage(int msgnum) throws MessagingException
获取与给定消息编号相对应的 Message 对象。Message 对象的消息编号是此 Message 在其 Folder 中的相对位置。消息编号从 1 开始,到达文件夹中的消息总数为止。注意,如果 Folder 中的其他消息被删除且该 Folder 被清除,则某一特定 Message 的消息编号可在会话期间发生更改。
Message 对象是对按需填充的实际消息的轻量级引用。因此 Folder 实现应该提供轻量级 Message 对象。
与 Folder 对象不同,使用同一消息编号重复调用 getMessage 将返回相同的 Message 对象只要此文件夹中没有消息被清除。
因为如果文件夹被清除,消息编号就可在会话中发生更改,所以建议客户端不要使用消息编号作为对消息的引用。请使用 Message 对象替代。
msgnum | 消息编号 |
return | Message 对象 |
Throws | FolderNotFoundException: 如果此文件夹不存在。 |
Throws | IllegalStateException: 如果此文件夹没有打开 |
Throws | IndexOutOfBoundsException: 如果消息编号超出范围。 |
Throws | MessagingException: |
See also | getMessageCount, fetch |
getMessage
public abstract Message getMessage(int msgnum) throws MessagingException
- Get the Message object corresponding to the given message
number. A Message object's message number is the relative
position of this Message in its Folder. Messages are numbered
starting at 1 through the total number of message in the folder.
Note that the message number for a particular Message can change
during a session if other messages in the Folder are deleted and
the Folder is expunged.
Message objects are light-weight references to the actual message that get filled up on demand. Hence Folder implementations are expected to provide light-weight Message objects.
Unlike Folder objects, repeated calls to getMessage with the same message number will return the same Message object, as long as no messages in this folder have been expunged.
Since message numbers can change within a session if the folder is expunged , clients are advised not to use message numbers as references to messages. Use Message objects instead.
- Parameters:
msgnum
- the message number- Returns:
- the Message object
- Throws:
FolderNotFoundException
- if this folder does not exist.IllegalStateException
- if this folder is not openedIndexOutOfBoundsException
- if the message number is out of range.MessagingException
- See Also:
getMessageCount()
,fetch(javax.mail.Message[], javax.mail.FetchProfile)
public Message[]
getMessages(int start, int end) throws MessagingException
获取从 start 到 end 消息编号范围内(包括 start 和 end)的 Message 对象。注意,消息编号从 1 而不是从 0 开始。
Message 对象是对按需填充的实际消息的轻量级引用。因此 Folder 实现应该提供轻量级 Message 对象。
此实现使用 getMessage(index) 获取所需的 Message 对象。注意,返回的数组必须包含 (end-start+1)
Message 对象。
start | 第一条消息的编号 |
end | 最后一条消息的编号 |
return | Message 对象 |
Throws | FolderNotFoundException: 如果此文件夹不存在。 |
Throws | IllegalStateException: 如果此文件夹没有打开。 |
Throws | IndexOutOfBoundsException: 如果开始或结束的消息编号超出范围。 |
Throws | MessagingException: |
See also | fetch |
getMessages
public Message[] getMessages(int start, int end) throws MessagingException
- Get the Message objects for message numbers ranging from start
through end, both start and end inclusive. Note that message
numbers start at 1, not 0.
Message objects are light-weight references to the actual message that get filled up on demand. Hence Folder implementations are expected to provide light-weight Message objects.
This implementation uses getMessage(index) to obtain the required Message objects. Note that the returned array must contain
(end-start+1)
Message objects. - Parameters:
start
- the number of the first messageend
- the number of the last message- Returns:
- the Message objects
- Throws:
FolderNotFoundException
- if this folder does not exist.IllegalStateException
- if this folder is not opened.IndexOutOfBoundsException
- if the start or end message numbers are out of range.MessagingException
- See Also:
fetch(javax.mail.Message[], javax.mail.FetchProfile)
public Message[]
getMessages(int[] msgnums) throws MessagingException
获取具有数组中指定的消息编号的 Message 对象。
Message 对象是对按需填充的实际消息的轻量级引用。因此 Folder 实现应该提供轻量级 Message 对象。
此实现使用 getMessage(index) 获取所需的 Message 对象。注意,返回的数组必须包含 msgnums.length
Message 对象。
msgnums | 消息编号的数组 |
return | Message 对象的数组。 |
Throws | FolderNotFoundException: 如果此文件夹不存在。 |
Throws | IllegalStateException: 如果此文件夹没有打开。 |
Throws | IndexOutOfBoundsException: 如果给定数组中的任何消息编号超出范围。 |
Throws | MessagingException: |
See also | fetch |
getMessages
public Message[] getMessages(int[] msgnums) throws MessagingException
- Get the Message objects for message numbers specified in
the array.
Message objects are light-weight references to the actual message that get filled up on demand. Hence Folder implementations are expected to provide light-weight Message objects.
This implementation uses getMessage(index) to obtain the required Message objects. Note that the returned array must contain
msgnums.length
Message objects - Parameters:
msgnums
- the array of message numbers- Returns:
- the array of Message objects.
- Throws:
FolderNotFoundException
- if this folder does not exist.IllegalStateException
- if this folder is not opened.IndexOutOfBoundsException
- if any message number in the given array is out of range.MessagingException
- See Also:
fetch(javax.mail.Message[], javax.mail.FetchProfile)
public Message[]
getMessages() throws MessagingException
获取此 Folder 中的所有 Message 对象。如果文件夹为空,则返回一个空数组。
客户端可使用 Message 对象(而不是序列号)作为对文件夹中消息的引用;此方法为客户端提供 Message 对象。文件夹实现应该提供轻量级 Message 对象,这些对象是按需填充的。
此实现调用 getMessageCount()
获取当前消息计数,然后使用 getMessage()
获取从 1 到该消息计数的 Message 对象。
return | Message 对象的数组,如果文件夹为空,则返回一个空数组。 |
Throws | FolderNotFoundException: 如果此文件夹不存在。 |
Throws | IllegalStateException: 如果此文件夹没有打开。 |
Throws | MessagingException: |
See also | fetch |
getMessages
public Message[] getMessages() throws MessagingException
- Get all Message objects from this Folder. Returns an empty array
if the folder is empty.
Clients can use Message objects (instead of sequence numbers)
as references to the messages within a folder; this method supplies
the Message objects to the client. Folder implementations are
expected to provide light-weight Message objects, which get
filled on demand.
This implementation invokes
getMessageCount()
to get the current message count and then usesgetMessage()
to get Message objects from 1 till the message count. - Returns:
- array of Message objects, empty array if folder is empty.
- Throws:
FolderNotFoundException
- if this folder does not exist.IllegalStateException
- if this folder is not opened.MessagingException
- See Also:
fetch(javax.mail.Message[], javax.mail.FetchProfile)
abstract public void
appendMessages(Message[] msgs) throws MessagingException
将给定 Message 追加到此文件夹。可以对关闭的 Folder 调用此方法。当消息到达文件夹时,向此文件夹上注册的所有 MessageCountListener 传送相应的 MessageCountEvent。
即使发现给定消息数组中的某个 Message 是已清除的 Message,文件夹实现也不得中止此操作。
msgs | 要追加的 Message 的数组 |
Throws | FolderNotFoundException: 如果此文件夹不存在。 |
Throws | MessagingException: 如果追加失败。 |
appendMessages
public abstract void appendMessages(Message[] msgs) throws MessagingException
- Append given Messages to this folder. This method can be
invoked on a closed Folder. An appropriate MessageCountEvent
is delivered to any MessageCountListener registered on this
folder when the messages arrive in the folder.
Folder implementations must not abort this operation if a Message in the given message array turns out to be an expunged Message.
- Parameters:
msgs
- array of Messages to be appended- Throws:
FolderNotFoundException
- if this folder does not exist.MessagingException
- if the append failed.
public void
fetch(Message[] msgs, FetchProfile fp) throws MessagingException
预获取给定 Message 的 FetchProfile 中指定的项。
客户端使用此方法指示需要给定消息范围内的全部指定项。实现应该以有效方式获取给定消息范围内的这些项。注意,此方法只是预获取所需项实现的提示。
一个例子是客户端使用文件夹中所有消息的 Subject、From 和 X-mailer 头填充其头视图窗口。
Message[] msgs = folder.getMessages(); FetchProfile fp = new FetchProfile(); fp.add(FetchProfile.Item.ENVELOPE); fp.add("X-mailer"); folder.fetch(msgs, fp); for (int i = 0; i < folder.getMessageCount(); i++) { display(msg[i].getFrom()); display(msg[i].getSubject()); display(msg[i].getHeader("X-mailer")); }
此处提供的实现未做任何有用的操作就返回了。想为此方法提供一个真正实现的提供者应该重写此方法。
msgs | 获取这些消息的项 |
fp | FetchProfile |
Throws | IllegalStateException: 如果此文件夹没有打开 |
Throws | MessagingException.: |
fetch
public void fetch(Message[] msgs, FetchProfile fp) throws MessagingException
- Prefetch the items specified in the FetchProfile for the
given Messages.
Clients use this method to indicate that the specified items are needed en-masse for the given message range. Implementations are expected to retrieve these items for the given message range in a efficient manner. Note that this method is just a hint to the implementation to prefetch the desired items.
An example is a client filling its header-view window with the Subject, From and X-mailer headers for all messages in the folder.
Message[] msgs = folder.getMessages(); FetchProfile fp = new FetchProfile(); fp.add(FetchProfile.Item.ENVELOPE); fp.add("X-mailer"); folder.fetch(msgs, fp); for (int i = 0; i < folder.getMessageCount(); i++) { display(msg[i].getFrom()); display(msg[i].getSubject()); display(msg[i].getHeader("X-mailer")); }
The implementation provided here just returns without doing anything useful. Providers wanting to provide a real implementation for this method should override this method.
- Parameters:
msgs
- fetch items for these messagesfp
- the FetchProfile- Throws:
IllegalStateException
- if this folder is not openedMessagingException.
MessagingException
public void
setFlags(Message[] msgs, Flags flag, boolean value) throws MessagingException
在数组中指定的消息上设置指定标志。这将导致向此 Message 包含文件夹上注册的所有 MessageChangedListener 传送相应的 MessageChangedEvent。
注意,指定的 Message 对象必须属于此文件夹。某些 Folder 实现可以为一组消息优化设置 Flag 的操作,因此客户端可能希望使用此方法,而不是对每个 Message 调用 Message.setFlags
。
此实现退化到对每个 Message 对象调用 setFlags()
。能够优化这种情况的特定 Folder 实现应该采取优化的操作。同样,即使发现数组中的某个 Message 是已清除的 Message,实现也不得中止操作。
msgs | 消息对象的数组 |
flag | 包含要设置的标志的 Flag 对象 |
value | 将标志设置为此 boolean 值 |
Throws | IllegalStateException: 如果此文件夹没有打开;如果它以 READ_ONLY 模式打开。 |
Throws | MessagingException: |
See also | setFlags, javax.mail.event.MessageChangedEvent |
setFlags
public void setFlags(Message[] msgs, Flags flag, boolean value) throws MessagingException
- Set the specified flags on the messages specified in the array.
This will result in appropriate MessageChangedEvents being
delivered to any MessageChangedListener registered on this
Message's containing folder.
Note that the specified Message objects must belong to this folder. Certain Folder implementations can optimize the operation of setting Flags for a group of messages, so clients might want to use this method, rather than invoking
Message.setFlags
for each Message.This implementation degenerates to invoking
setFlags()
on each Message object. Specific Folder implementations that can optimize this case should do so. Also, an implementation must not abort the operation if a Message in the array turns out to be an expunged Message. - Parameters:
msgs
- the array of message objectsflag
- Flags object containing the flags to be setvalue
- set the flags to this boolean value- Throws:
IllegalStateException
- if this folder is not opened or if it has been opened READ_ONLY.MessagingException
- See Also:
Message.setFlags(javax.mail.Flags, boolean)
,MessageChangedEvent
public void
setFlags(int start, int end, Flags flag, boolean value) throws MessagingException
在编号从 start 到 end(包括 start 和 end)的消息上设置指定标志。注意,消息编号从 1 而不是从 0 开始。这将导致向此 Message 包含文件夹上注册的所有 MessageChangedListener 传送相应的 MessageChangedEvent。
某些 Folder 实现可以为一组消息优化设置 Flag 的操作,因此客户端可能希望使用此方法,而不是对每个 Message 调用 Message.setFlags
。
默认实现使用 getMessage(int)
获取每个 Message
对象,然后对要设置标志的对象调用 setFlags
。能够优化这种情况的特定 Folder 实现应该采取优化的操作。同样,即使某个消息编号引用了已清除的消息,实现也不得中止操作。
start | 第一条消息的编号 |
end | 最后一条消息的编号 |
flag | 包含要设置的标志的 Flag 对象 |
value | 将标志设置为此 boolean 值 |
Throws | IllegalStateException: 如果此文件夹没有打开;如果它以 READ_ONLY 模式打开。 |
Throws | IndexOutOfBoundsException: 如果开始或结束的消息编号超出范围。 |
Throws | MessagingException: |
See also | setFlags, javax.mail.event.MessageChangedEvent |
setFlags
public void setFlags(int start, int end, Flags flag, boolean value) throws MessagingException
- Set the specified flags on the messages numbered from start
through end, both start and end inclusive. Note that message
numbers start at 1, not 0.
This will result in appropriate MessageChangedEvents being
delivered to any MessageChangedListener registered on this
Message's containing folder.
Certain Folder implementations can optimize the operation of setting Flags for a group of messages, so clients might want to use this method, rather than invoking
Message.setFlags
for each Message.The default implementation uses
getMessage(int)
to get eachMessage
object and then invokessetFlags
on that object to set the flags. Specific Folder implementations that can optimize this case should do so. Also, an implementation must not abort the operation if a message number refers to an expunged message. - Parameters:
start
- the number of the first messageend
- the number of the last messageflag
- Flags object containing the flags to be setvalue
- set the flags to this boolean value- Throws:
IllegalStateException
- if this folder is not opened or if it has been opened READ_ONLY.IndexOutOfBoundsException
- if the start or end message numbers are out of range.MessagingException
- See Also:
Message.setFlags(javax.mail.Flags, boolean)
,MessageChangedEvent
public void
setFlags(int[] msgnums, Flags flag, boolean value) throws MessagingException
在其消息编号位于数组中的消息上设置指定标志。这将导致向此 Message 包含文件夹上注册的所有 MessageChangedListener 传送相应的 MessageChangedEvent。
某些 Folder 实现可以为一组消息优化设置 Flag 的操作,因此客户端可能希望使用此方法,而不是对每个 Message 调用 Message.setFlags
。
默认实现使用 getMessage(int)
获取每个 Message
对象,然后对要设置标志的对象调用 setFlags
。能够优化这种情况的特定 Folder 实现应该采取优化的操作。同样,即使某个消息编号引用了已清除的消息,实现也不得中止操作。
msgnums | 消息编号的数组 |
flag | 包含要设置的标志的 Flag 对象 |
value | 将标志设置为此 boolean 值 |
Throws | IllegalStateException: 如果此文件夹没有打开;如果它以 READ_ONLY 模式打开。 |
Throws | IndexOutOfBoundsException: 如果给定数组中的任何消息编号超出范围。 |
Throws | MessagingException: |
See also | setFlags, javax.mail.event.MessageChangedEvent |
setFlags
public void setFlags(int[] msgnums, Flags flag, boolean value) throws MessagingException
- Set the specified flags on the messages whose message numbers
are in the array.
This will result in appropriate MessageChangedEvents being
delivered to any MessageChangedListener registered on this
Message's containing folder.
Certain Folder implementations can optimize the operation of setting Flags for a group of messages, so clients might want to use this method, rather than invoking
Message.setFlags
for each Message.The default implementation uses
getMessage(int)
to get eachMessage
object and then invokessetFlags
on that object to set the flags. Specific Folder implementations that can optimize this case should do so. Also, an implementation must not abort the operation if a message number refers to an expunged message. - Parameters:
msgnums
- the array of message numbersflag
- Flags object containing the flags to be setvalue
- set the flags to this boolean value- Throws:
IllegalStateException
- if this folder is not opened or if it has been opened READ_ONLY.IndexOutOfBoundsException
- if any message number in the given array is out of range.MessagingException
- See Also:
Message.setFlags(javax.mail.Flags, boolean)
,MessageChangedEvent
public void
copyMessages(Message[] msgs, Folder folder) throws MessagingException
将指定 Message 从此 Folder 复制到另一个 Folder 中。此操作会将这些 Message 追加到目标 Folder。不必打开目标 Folder。当消息到达文件夹时,向目标文件夹上注册的所有 MessageCountListener 传送相应的 MessageCountEvent。
注意,指定的 Message 对象必须属于此文件夹。文件夹实现可能能够通过进行服务器端复制来优化此方法。
此实现只需对目标文件夹调用 appendMessages()
就可以追加给定 Message。如果目标文件夹的 Store 与此文件夹的 Store 相同,那么支持服务器端复制的特定文件夹实现就应该这样做。同样,即使发现数组中的某个 Message 是已清除的 Message,实现也不得中止操作。
msgs | 消息对象的数组 |
folder | 将消息复制到的文件夹 |
Throws | FolderNotFoundException: 如果目标文件夹不存在。 |
Throws | IllegalStateException: 如果此文件夹没有打开。 |
Throws | MessagingException: |
See also | appendMessages |
copyMessages
public void copyMessages(Message[] msgs, Folder folder) throws MessagingException
- Copy the specified Messages from this Folder into another
Folder. This operation appends these Messages to the
destination Folder. The destination Folder does not have to
be opened. An appropriate MessageCountEvent
is delivered to any MessageCountListener registered on the
destination folder when the messages arrive in the folder.
Note that the specified Message objects must belong to this folder. Folder implementations might be able to optimize this method by doing server-side copies.
This implementation just invokes
appendMessages()
on the destination folder to append the given Messages. Specific folder implementations that support server-side copies should do so, if the destination folder's Store is the same as this folder's Store. Also, an implementation must not abort the operation if a Message in the array turns out to be an expunged Message. - Parameters:
msgs
- the array of message objectsfolder
- the folder to copy the messages to- Throws:
FolderNotFoundException
- if the destination folder does not exist.IllegalStateException
- if this folder is not opened.MessagingException
- See Also:
appendMessages(javax.mail.Message[])
abstract public Message[]
expunge() throws MessagingException
清除(永久移除)标记为 DELETED 的消息。返回包含已清除消息对象的数组。对这些消息对象中的每一个调用 getMessageNumber
方法将返回该 Message 的原始序列号(即清除之前的序列号)。向该文件夹上注册的所有 MessageCountListener 传送包含已清除消息的 MessageCountEvent。
清除会导致对这些已清除消息之后的 Message 对象重新编号。使用消息编号作为对消息的引用的客户端应该意识到这一点,并且应该做好准备应对这种情况(可能通过清空现有消息编号缓存并重新加载它们来应对)。由于这种复杂性,客户端最好使用 Message 对象作为对消息的引用,而不使用消息编号。任何已清除的 Message 对象仍然必须被删改,但该文件夹中的其他 Message 不受清除的影响。
在清除某个消息之后,只有 isExpunged
和 getMessageNumber
方法在相应的 Message 对象上仍然有效;其他方法可能抛出 MessageRemovedException
。
return | 已清除的 Message 对象的数组 |
Throws | FolderNotFoundException: 如果此文件夹不存在 |
Throws | IllegalStateException: 如果此文件夹没有打开。 |
Throws | MessagingException: |
See also | isExpunged, javax.mail.event.MessageCountEvent |
expunge
public abstract Message[] expunge() throws MessagingException
- Expunge (permanently remove) messages marked DELETED. Returns an
array containing the expunged message objects. The
getMessageNumber
method on each of these message objects returns that Message's original (that is, prior to the expunge) sequence number. A MessageCountEvent containing the expunged messages is delivered to any MessageCountListeners registered on the folder.Expunge causes the renumbering of Message objects subsequent to the expunged messages. Clients that use message numbers as references to messages should be aware of this and should be prepared to deal with the situation (probably by flushing out existing message number caches and reloading them). Because of this complexity, it is better for clients to use Message objects as references to messages, rather than message numbers. Any expunged Messages objects still have to be pruned, but other Messages in that folder are not affected by the expunge.
After a message is expunged, only the
isExpunged
andgetMessageNumber
methods are still valid on the corresponding Message object; other methods may throwMessageRemovedException
- Returns:
- array of expunged Message objects
- Throws:
FolderNotFoundException
- if this folder does not existIllegalStateException
- if this folder is not opened.MessagingException
- See Also:
Message.isExpunged()
,MessageCountEvent
public Message[]
search(SearchTerm term) throws MessagingException
在此 Folder 中搜索与指定搜索标准匹配的消息。返回包含匹配消息的数组。如果不存在任何匹配项,则返回空数组。
此实现调用 search(term, getMessages())
,以便在此文件夹中的所有消息上应用该搜索。能够实现服务器端搜索的提供者可能希望重写此方法,以提供更有效的实现。
term | 搜索标准 |
return | 匹配消息的数组 |
Throws | SearchException: 如果搜索条目过于复杂,该实现无法处理。 |
Throws | FolderNotFoundException: 如果此文件夹不存在。 |
Throws | IllegalStateException: 如果此文件夹没有打开。 |
Throws | MessagingException: |
See also | javax.mail.search.SearchTerm |
search
public Message[] search(SearchTerm term) throws MessagingException
- Search this Folder for messages matching the specified
search criterion. Returns an array containing the matching
messages . Returns an empty array if no matches were found.
This implementation invokes
search(term, getMessages())
, to apply the search over all the messages in this folder. Providers that can implement server-side searching might want to override this method to provide a more efficient implementation. - Parameters:
term
- the search criterion- Returns:
- array of matching messages
- Throws:
SearchException
- if the search term is too complex for the implementation to handle.FolderNotFoundException
- if this folder does not exist.IllegalStateException
- if this folder is not opened.MessagingException
- See Also:
SearchTerm
public Message[]
search(SearchTerm term, Message[] msgs) throws MessagingException
在给定的消息数组中搜索与指定搜索标准匹配的那些消息。返回包含匹配消息的数组。如果不存在任何匹配项,则返回空数组。
注意,指定的 Message 对象必须属于此文件夹。
此实现在给定的消息数组中迭代,并通过使用给定条目调用其 match()
方法在每个消息上应用搜索标准。返回成功匹配的消息。能够实现服务器端搜索的提供者可能希望重写此方法,以提供更有效的实现。如果搜索条目太复杂或者包含在服务器上无法执行的用户定义条目,那么提供者可能选择抛出 SearchException,或者退化到客户端搜索,通过调用 super.search()
来调用此实现。
term | 搜索标准 |
msgs | 要搜索的消息 |
return | 匹配消息的数组 |
Throws | SearchException: 如果搜索条目过于复杂,该实现无法处理。 |
Throws | IllegalStateException: 如果此文件夹没有打开 |
Throws | MessagingException: |
See also | javax.mail.search.SearchTerm |
search
public Message[] search(SearchTerm term, Message[] msgs) throws MessagingException
- Search the given array of messages for those that match the
specified search criterion. Returns an array containing the
matching messages. Returns an empty array if no matches were
found.
Note that the specified Message objects must belong to this folder.
This implementation iterates through the given array of messages, and applies the search criterion on each message by calling its
match()
method with the given term. The messages that succeed in the match are returned. Providers that can implement server-side searching might want to override this method to provide a more efficient implementation. If the search term is too complex or contains user-defined terms that cannot be executed on the server, providers may elect to either throw a SearchException or degenerate to client-side searching by callingsuper.search()
to invoke this implementation. - Parameters:
term
- the search criterionmsgs
- the messages to be searched- Returns:
- array of matching messages
- Throws:
SearchException
- if the search term is too complex for the implementation to handle.IllegalStateException
- if this folder is not openedMessagingException
- See Also:
SearchTerm
public void
addConnectionListener(ConnectionListener l)
为此 Folder 上的 Connection 事件添加侦听器。
此处提供的实现将此侦听器添加到 ConnectionListener 的内部列表。
l | Connection 事件的 Listener |
See also | javax.mail.event.ConnectionEvent |
addConnectionListener
public void addConnectionListener(ConnectionListener l)
- Add a listener for Connection events on this Folder.
The implementation provided here adds this listener to an internal list of ConnectionListeners.
- Parameters:
l
- the Listener for Connection events- See Also:
ConnectionEvent
public void
removeConnectionListener(ConnectionListener l)
移除 Connection 事件侦听器。
此处提供的实现将从 ConnectionListener 的内部列表中移除此侦听器。
l | 侦听器 |
See also | addConnectionListener |
removeConnectionListener
public void removeConnectionListener(ConnectionListener l)
- Remove a Connection event listener.
The implementation provided here removes this listener from the internal list of ConnectionListeners.
- Parameters:
l
- the listener- See Also:
addConnectionListener(javax.mail.event.ConnectionListener)
protected void
notifyConnectionListeners(int type)
通知所有 ConnectionListener。文件夹实现应该使用此方法广播 Connection 事件。
提供的实现将该事件加入到内部事件队列。事件分发程序线程取消队列中事件的排队,并将其分发给注册的 ConnectionListener。注意,事件分发发生在不同的线程中,因此避免了可能出现的死锁问题。
type | ConnectionEvent 类型 |
See also | javax.mail.event.ConnectionEvent |
notifyConnectionListeners
protected void notifyConnectionListeners(int type)
- Notify all ConnectionListeners. Folder implementations are
expected to use this method to broadcast connection events.
The provided implementation queues the event into an internal event queue. An event dispatcher thread dequeues events from the queue and dispatches them to the registered ConnectionListeners. Note that the event dispatching occurs in a separate thread, thus avoiding potential deadlock problems.
- Parameters:
type
- the ConnectionEvent type- See Also:
ConnectionEvent
public void
addFolderListener(FolderListener l)
为此 Folder 上的 Folder 事件添加侦听器。
此处提供的实现将此侦听器添加到 FolderListener 的内部列表。
l | Folder 事件的 Listener |
See also | javax.mail.event.FolderEvent |
addFolderListener
public void addFolderListener(FolderListener l)
- Add a listener for Folder events on this Folder.
The implementation provided here adds this listener to an internal list of FolderListeners.
- Parameters:
l
- the Listener for Folder events- See Also:
FolderEvent
public void
removeFolderListener(FolderListener l)
移除 Folder 事件侦听器。
此处提供的实现将从 FolderListener 的内部列表中移除此侦听器。
l | 侦听器 |
See also | addFolderListener |
removeFolderListener
public void removeFolderListener(FolderListener l)
- Remove a Folder event listener.
The implementation provided here removes this listener from the internal list of FolderListeners.
- Parameters:
l
- the listener- See Also:
addFolderListener(javax.mail.event.FolderListener)
protected void
notifyFolderListeners(int type)
通知此 Folder 和此文件夹的 Store 上注册的所有 FolderListener。文件夹实现应该使用此方法广播 Folder 事件。
此处提供的实现将该事件加入到内部事件队列。事件分发程序线程取消队列中事件的排队,并将其分发给在此文件夹上注册的 FolderListener。该实现还调用此文件夹的 Store 上的 notifyFolderListeners
来通知该 Store 上注册的所有 FolderListener。
type | FolderEvent 的类型 |
See also | notifyFolderRenamedListeners |
notifyFolderListeners
protected void notifyFolderListeners(int type)
- Notify all FolderListeners registered on this Folder and
this folder's Store. Folder implementations are expected
to use this method to broadcast Folder events.
The implementation provided here queues the event into an internal event queue. An event dispatcher thread dequeues events from the queue and dispatches them to the FolderListeners registered on this folder. The implementation also invokes
notifyFolderListeners
on this folder's Store to notify any FolderListeners registered on the store. - Parameters:
type
- type of FolderEvent- See Also:
notifyFolderRenamedListeners(javax.mail.Folder)
protected void
notifyFolderRenamedListeners(Folder folder)
通知此 Folder 和此文件夹的 Store 上注册的所有 FolderListener 有关此文件夹重命名的信息。文件夹实现应该使用此方法广播 Folder 事件,指示文件夹的重命名。
此处提供的实现将该事件加入到内部事件队列。事件分发程序线程取消队列中事件的排队,并将其分发给在此文件夹上注册的 FolderListener。该实现还调用此文件夹的 Store 上的 notifyFolderRenamedListeners
来通知该 Store 上注册的所有 FolderListener。
folder | 表示新名称的文件夹。 | |
since |
| |
See also | notifyFolderListeners |
notifyFolderRenamedListeners
protected void notifyFolderRenamedListeners(Folder folder)
- Notify all FolderListeners registered on this Folder and
this folder's Store about the renaming of this folder.
Folder implementations are expected to use this method to
broadcast Folder events indicating the renaming of folders.
The implementation provided here queues the event into an internal event queue. An event dispatcher thread dequeues events from the queue and dispatches them to the FolderListeners registered on this folder. The implementation also invokes
notifyFolderRenamedListeners
on this folder's Store to notify any FolderListeners registered on the store. - Parameters:
folder
- Folder representing the new name.- Since:
- JavaMail 1.1
- See Also:
notifyFolderListeners(int)
public void
addMessageCountListener(MessageCountListener l)
为此 Folder 上的 MessageCount 事件添加侦听器。
此处提供的实现将此侦听器添加到 MessageCountListener 的内部列表。
l | MessageCount 事件的 Listener |
See also | javax.mail.event.MessageCountEvent |
addMessageCountListener
public void addMessageCountListener(MessageCountListener l)
- Add a listener for MessageCount events on this Folder.
The implementation provided here adds this listener to an internal list of MessageCountListeners.
- Parameters:
l
- the Listener for MessageCount events- See Also:
MessageCountEvent
public void
removeMessageCountListener(MessageCountListener l)
移除 MessageCount 侦听器。
此处提供的实现将从 MessageCountListener 的内部列表中移除此侦听器。
l | 侦听器 |
See also | addMessageCountListener |
removeMessageCountListener
public void removeMessageCountListener(MessageCountListener l)
- Remove a MessageCount listener.
The implementation provided here removes this listener from the internal list of MessageCountListeners.
- Parameters:
l
- the listener- See Also:
addMessageCountListener(javax.mail.event.MessageCountListener)
protected void
notifyMessageAddedListeners(Message[] msgs)
通知所有 MessageCountListener 有关向此文件夹中添加消息的信息。文件夹实现应该使用此方法广播 MessageCount 事件,指示新消息的到达。
提供的实现将该事件加入到内部事件队列。事件分发程序线程取消队列中事件的排队,并将其分发给注册的 MessageCountListener。注意,事件分发发生在不同的线程中,因此避免了可能出现的死锁问题。
notifyMessageAddedListeners
protected void notifyMessageAddedListeners(Message[] msgs)
- Notify all MessageCountListeners about the addition of messages
into this folder. Folder implementations are expected to use this
method to broadcast MessageCount events for indicating arrival of
new messages.
The provided implementation queues the event into an internal event queue. An event dispatcher thread dequeues events from the queue and dispatches them to the registered MessageCountListeners. Note that the event dispatching occurs in a separate thread, thus avoiding potential deadlock problems.
protected void
notifyMessageRemovedListeners(boolean removed, Message[] msgs)
通知所有 MessageCountListener 有关从此 Folder 中移除消息的信息。文件夹实现应该使用此方法广播 MessageCount 事件,指示消息的移除。
提供的实现将该事件加入到内部事件队列。事件分发程序线程取消队列中事件的排队,并将其分发给注册的 MessageCountListener。注意,事件分发发生在不同的线程中,因此避免了可能出现的死锁问题。
notifyMessageRemovedListeners
protected void notifyMessageRemovedListeners(boolean removed, Message[] msgs)
- Notify all MessageCountListeners about the removal of messages
from this Folder. Folder implementations are expected to use this
method to broadcast MessageCount events indicating removal of
messages.
The provided implementation queues the event into an internal event queue. An event dispatcher thread dequeues events from the queue and dispatches them to the registered MessageCountListeners. Note that the event dispatching occurs in a separate thread, thus avoiding potential deadlock problems.
public void
addMessageChangedListener(MessageChangedListener l)
为此 Folder 上的 MessageChanged 事件添加侦听器。
此处提供的实现将此侦听器添加到 MessageChangedListener 的内部列表。
l | MessageChanged 事件的 Listener |
See also | javax.mail.event.MessageChangedEvent |
addMessageChangedListener
public void addMessageChangedListener(MessageChangedListener l)
- Add a listener for MessageChanged events on this Folder.
The implementation provided here adds this listener to an internal list of MessageChangedListeners.
- Parameters:
l
- the Listener for MessageChanged events- See Also:
MessageChangedEvent
public void
removeMessageChangedListener(MessageChangedListener l)
移除 MessageChanged 侦听器。
此处提供的实现将从 MessageChangedListener 的内部列表中移除此侦听器。
l | 侦听器 |
See also | addMessageChangedListener |
removeMessageChangedListener
public void removeMessageChangedListener(MessageChangedListener l)
- Remove a MessageChanged listener.
The implementation provided here removes this listener from the internal list of MessageChangedListeners.
- Parameters:
l
- the listener- See Also:
addMessageChangedListener(javax.mail.event.MessageChangedListener)
protected void
notifyMessageChangedListeners(int type, Message msg)
通知所有 MessageChangedListener。文件夹实现应该使用此方法广播 MessageChanged 事件。
提供的实现将该事件加入到内部事件队列。事件分发程序线程取消队列中事件的排队,并将其分发给注册的 MessageChangedListener。注意,事件分发发生在不同的线程中,因此避免了可能出现的死锁问题。
notifyMessageChangedListeners
protected void notifyMessageChangedListeners(int type, Message msg)
- Notify all MessageChangedListeners. Folder implementations are
expected to use this method to broadcast MessageChanged events.
The provided implementation queues the event into an internal event queue. An event dispatcher thread dequeues events from the queue and dispatches them to registered MessageChangedListeners. Note that the event dispatching occurs in a separate thread, thus avoiding potential deadlock problems.
protected void
finalize() throws Throwable
英文文档:
finalize
protected void finalize() throws Throwable
public String
toString()
重写默认的 toString(),它将返回从 Folder.getFullName() 获得的 String;如果返回结果为 null,则将使用默认的 toString() 行为。
英文文档:
toString
public String toString()
- override the default toString(), it will return the String
from Folder.getFullName() or if that is null, it will use
the default toString() behavior.
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
Submit a bug or feature
Copyright 2007 Sun Microsystems, Inc. All rights reserved. Use is subject to license terms.
PS : 未经我党受权你也可自由散发此文档。 如有任何错误请自行修正;若因此而造成任何损失请直接找人民主席,请勿与本人联系。谢谢!