收听收到的邮件-JavaMail

我正在尝试编写一个类，该类应该侦听传入的消息。 我在收件箱中添加了一个侦听器

我解析收件箱中的邮件以查找特定的电子邮件，当发现该电子邮件时，我希望我的听众停止收听收件箱

如何做到这一点

这是我的代码：

public Map<String, Object> read(String id, Risk risk) {

    setID(id);

        try {
            Properties props = new Properties();
            props.setProperty("mail.store.protocol", "imaps");
            Session session = Session.getInstance(props, null);
            Store store = session.getStore();
            store.connect("imap.gmail.com", email, password);
            Folder inbox = store.getFolder("INBOX");
            inbox.open(Folder.READ_ONLY);

            inbox.addMessageCountListener(new MessageCountAdapter() {
                public void messagesAdded(MessageCountEvent ev) {
                    setListenerExists(true);
                    boolean emailFound = false;
                    Message[] msgs = ev.getMessages();
                    System.out.println("Got " + msgs.length + " new messages");

                    if (msgs.length >= 1){
                        for (Message msg: msgs){
                            try {
                                Object o = msg.getContent();
                                if (o instanceof String){
                                    hm = parser.parseMessage(adr, msg.getSubject(), msg.getContent(), getID());

                                    System.out.println("FROM : " + adr);
                                    System.out.println("SUBJECT : " + msg.getSubject());
                                    System.out.println("HTML : " + msg.getContent());


                                }
                                else if (o instanceof Multipart){
                                    Multipart mp = (Multipart) o;
                                    BodyPart bp = mp.getBodyPart(0);
                                    hm = parser.parseMessage(adr, msg.getSubject(), bp.getContent(), getID());
                                    /*
                                    System.out.println("FROM : " + adr);
                                    System.out.println("SUBJECT : " + msg.getSubject());
                                    System.out.println("HTML : " + bp.getContent());
                                    */
                                }
                                    Iterator<Integer> it = hm.keySet().iterator();
                                    while (it.hasNext()){
                                        if (it.next() == 1){
                                            map = extractValues(hm.get(1));
                                            setMap(map);
                                            //emailReceived = true;
                                            //setEmailReceived(true);
                                            //extractValues(hm.get(1));
                                        }else{
                                            /*
                                             * TODO : remove listener
                                             * setLisetn
                                             */
                                            System.out.println("HM is Null!");
                                        }
                                    }

                            } catch (IOException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            } catch (MessagingException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                    }
                    }
                    /*
                    while (emailFound == false){
                         for (Message msg : msgs){
                             try {
                                Object o = msg.getContent();

                            } catch (IOException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            } catch (MessagingException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                         }
                    }
                    */
                }

            });
            // Check mail once in "freq" MILLIseconds
            boolean supportsIdle = false;
            try {
            if (inbox instanceof IMAPFolder) {
                IMAPFolder f = (IMAPFolder)inbox;
                f.idle();
                supportsIdle = true;
            }
            } catch (FolderClosedException fex) {
            throw fex;
            } catch (MessagingException mex) {
            supportsIdle = false;
            }
            for (;;) {
            if (supportsIdle && inbox instanceof IMAPFolder) {
                IMAPFolder f = (IMAPFolder)inbox;
                f.idle();
                System.out.println("IDLE done");
            } else {
                Thread.sleep(20000); // sleep for freq milliseconds

                // This is to force the IMAP server to send us
                // EXISTS notifications. 
                inbox.getMessageCount();
            }
        } 

        }catch (MessagingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return getMap();


}

public void setID(String id){
    this.riskId = id;
}
public String getID(){
    return riskId;
}
public void setMap(Map<String, Object> m){
    this.map = m;
}
public Map<String, Object> getMap(){
    return map;
}
public void setListenerExists(boolean exists){
    this.listener = exists;
}
public boolean getListenerExists(){
    return listener;
}

/** extracts values from hashmap received from the parser **/
public Map<String, Object> extractValues(HashMap<String, EmailData> h){
    System.out.println("I'M Called");
    Risk risk = new Risk();
    String id = "";
    String sender = "";
    String answer = "";
    HashMap<String, String> data;
    Iterator<String> it = h.keySet().iterator();
    while (it.hasNext()){
        id = it.next();
        EmailData ed = h.get(id);
        sender = ed.getEmail();
        answer = ed.getAnswer();
    }
    Map<String, Object> map = createVariablesToInsert(id, sender, answer);
    return map;
}
   public Map<String, Object> createVariablesToInsert(String id, String sender, String answer){
       Map<String, Object> map = new HashMap<String, Object>();
       System.out.println("I'M Called");
       System.out.println("UUID : " + id);
       System.out.println("USER : " + sender);
       System.out.println("ANSWE : " + answer);
        map.put("uuid", id);
        map.put("user", sender);
        map.put("ans", answer);
        System.out.println("ID : " + map.get("uuid"));
        System.out.println("USER : " + map.get("user"));
        System.out.println("ANS : " + map.get("ans"));

        System.out.println("ID in insert");

        return map;
   }

公共地图读取（字符串id，风险）{
setID（id）；
试一试{
Properties props=新属性（）；
props.setProperty（“mail.store.protocol”、“imaps”）；
Session Session=Session.getInstance（props，null）；
Store Store=session.getStore（）；
store.connect（“imap.gmail.com”、电子邮件、密码）；
文件夹收件箱=store.getFolder（“收件箱”）；
收件箱。打开（文件夹。只读）；
inbox.addMessageCountListener（新MessageCountAdapter（）{
public void messagesAdded（MessageCountEvent ev）{
setListenerExists（true）；
布尔值=false；
Message[]msgs=ev.getMessages（）；
System.out.println（“Got”+msgs.length+“newmessages”）；
如果（msgs.length>=1）{
对于（消息msg:msgs）{
试一试{
对象o=msg.getContent（）；
如果（字符串的o实例）{
hm=parser.parseMessage（adr，msg.getSubject（），msg.getContent（），getID（））；
System.out.println（“FROM:+adr”）；
System.out.println（“主题：+msg.getSubject（））；
System.out.println（“HTML:+msg.getContent（））；
}
else if（多部分的o实例）{
多部分mp=（多部分）o；
BodyPart bp=mp.getBodyPart（0）；
hm=parser.parseMessage（adr，msg.getSubject（），bp.getContent（），getID（））；
/*
System.out.println（“FROM:+adr”）；
System.out.println（“主题：+msg.getSubject（））；
System.out.println（“HTML:+bp.getContent（））；
*/
}
迭代器it=hm.keySet（）.Iterator（）；
while（it.hasNext（））{
if（it.next（）==1）{
map=提取值（hm.get（1））；
setMap（map）；
//emailReceived=true；
//setEmailReceived（true）；
//提取值（hm.get（1））；
}否则{
/*
*TODO:删除侦听器
*setLisetn
*/
System.out.println（“HM为Null！”）；
}
}
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}捕获（消息异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}
/*
while（emailFound==false）{
对于（消息msg:msgs）{
试一试{
对象o=msg.getContent（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}捕获（消息异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}
*/
}
});
//在“频率”毫秒内检查邮件一次
布尔支持sidle=false；
试一试{
if（IMAPFolder的收件箱实例）{
IMAPFolder f=（IMAPFolder）收件箱；
f、 空闲（）；
supportsIdle=true；
}
}捕获（FolderClosedException fex）{
投加fex；
}捕获（消息例外mex）{
supportsIdle=false；
}
对于（；；）{
if（IMAPFolder的supportsIdle和收件箱实例（&S）{
IMAPFolder f=（IMAPFolder）收件箱；
f、 空闲（）；
System.out.println（“空闲完成”）；
}否则{
Thread.sleep（20000）；//睡眠频率毫秒
//这是为了强制IMAP服务器向我们发送
//存在通知。
getMessageCount（）；
}
} 
}捕获（消息异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}捕捉（中断异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
返回getMap（）；
}
公共无效集合id（字符串id）{
this.riskId=id；
}
公共字符串getID（）{
返回风险ID；
}
公共无效集合映射（映射m）{
这个.map=m；
}
公共地图getMap（）{
返回图；
}
公共无效setListenerEx
final Folder inbox = store.getFolder("INBOX");
final MessageCountAdapter listener = new MessageCountAdapter() {
    boolean emailFound = false;
    // do something
    if (emailFound) {
        inbox.removeMessageCountListener(listener);
    }
}
inbox.addMessageCountListener(listener);