pop3store.java

mywork是rcp开发的很好的例子

	 *
	 * @return	ꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 */
	protected File getRootDirectory() {
		return rootDirectory;
	}
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 *
	 * @param	folder	ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ Folder.
	 * @param	actionName	ꆼꆼꆼꆼꆼ.
	 */
	protected synchronized void receiveMessages(POP3Folder folder, String actionName) throws MessagingException {
		String dbgmsg = "POP3Store.receiveMessages(): folder=" + folder.getFullName() + " actionName=" + actionName;
		if (receivingFolderName.equalsIgnoreCase(folder.getFullName()) && checkActions.contains(actionName)) {
			dbgmsg += " receiving...";
			debugOut(dbgmsg);
			if (checkInterval > 0 && timerThread == null) {
				timerThread = new IntervalTimer(folder, receiver);
				timerThread.start();
			} else {
				receiver.receive(folder);
			}
		} else {
			dbgmsg += " skipped.";
			debugOut(dbgmsg);
		}
	}
	
	/**
	 * Folder.list()ꆼꆼꆼꆼꆼFilenameFilterꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ
	 *
	 * @see	jp.gr.java_conf.roadster.net.pop.POP3Folder.list()
	 */
	FilenameFilter getFilenameFilter(String pattern) {
		return new SubFolderFilter(pattern, listHiddenFolders);
	}
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 */
	class DefaultMessageReceiver implements MessageReceiver {
		/**
		 * POP3Client.
		 */
		private POP3Client client;
		
		/**
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ DefaultMessageReceiver ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 *
		 * @param	client	POP3Client.
		 */
		public DefaultMessageReceiver(POP3Client client) {
			this.client = client;
		}
		
		/*
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ appendMessage()ꆼꆼꆼꆼꆼ
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.<BR>
		 *
		 * @param	targetFolder	ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 * @exception	javax.mail.MessagingException	ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 */
		public synchronized void receive(POP3Folder targetFolder) throws MessagingException {
			try {
				if (! targetFolder.exists()) {
					debugOut(targetFolder + " not exits.");
					return;
				}
				if (! client.isConnected()) {
					client.connect();
				}
				client.rset();
				final int messageCount = client.getMessageCount();
				debugOut("MessageCount=" + messageCount);
				
				// ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
				// ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼUIDLꆼꆼꆼ.
				boolean failedUIDL = false;
				Vector latestUIDL = new Vector();
				try {
					for (int i = 0; i < messageCount; ++i) {
						latestUIDL.addElement(client.getUID(i));
					}
				} catch (POP3NegativeResponseException p3nre) {
					debugOut("UIDL command failed: " + p3nre);
					failedUIDL = true;
				}
				
				// ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
				BitSet needReceive = new BitSet();
				//如果邮件服务器不支持UIDL命令，则只好全取
				if(failedUIDL){
					for(int i=0;i<messageCount;++i){
						needReceive.set(i);
					}
				}
					
				for (int i = 0; i < latestUIDL.size(); ++i) {
					if (! uidList.contains(latestUIDL.elementAt(i))) {
						needReceive.set(i);
					}
				}
				BitSet received = new BitSet();
				
				//准备一下spamcheck
				Map<String, String> mapProperty = ConfigHelper.getMapProperty("mail.spam");
				double check= Double.valueOf(mapProperty.get("checkpoint"));
				IExtensionPoint extension = Platform.getExtensionRegistry().getExtensionPoint("net.sf.mywork.mail.checkSpamMail");
				ISpamChecker checker=null;
				if(extension != null){
					IConfigurationElement[] configElements = extension.getConfigurationElements();
					if(configElements.length > 0){
						try {
							checker=(ISpamChecker) configElements[0].createExecutableExtension("class");
						} catch (CoreException e) {
							e.printStackTrace();
						}
					}
				}
				
				Message msgs[] = new Message[1];
				for (int i = 0; i < messageCount; ++i) {
					if (needReceive.get(i)) {
						debugOut("Retrieve message:" + (i + 1));
						InputStream ins = client.retrieve(i);
						MimeMessage message = new MimeMessage(session, ins);
						ins.close();
						message.setFlag(Flags.Flag.SEEN, false);
						message.setFlag(Flags.Flag.RECENT, true);

						msgs[0] = message;

						//进行垃圾邮件识别，并增加自定义简单保留规则
						if(mapProperty.get("enable") != null && Boolean.valueOf(mapProperty.get("enable")) && needCheckSpam(message) && checker != null){
							//取垃圾邮件检测的扩展点，简化，就用取到的第一个扩展
							File tempFile=File.createTempFile("spam", null);
							BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(tempFile), 16 * 1024);
							message.writeTo(bos);
							bos.close();
							double spam=checker.checkSpamMail(new FileInputStream(tempFile));
							tempFile.delete();
							if(spam > check){
								POP3Folder trashFolder = (POP3Folder) targetFolder.getStore().getFolder(MailPlugin.TRASHBOX);
								if(!trashFolder.isOpen())
									trashFolder.open(Folder.READ_WRITE);
								trashFolder.appendMessages(msgs);
							} else {
								targetFolder.appendMessages(msgs);
							}
						}else {
							targetFolder.appendMessages(msgs);
						}
					}
					received.set(i);
				}
				
				// ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
				if (! leaveOnServer) {	// ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
					for (int i = 0; i < messageCount; ++i) {
						if (received.get(i)) {
							debugOut("Delete message: " + (i + 1));
							client.delete(i);
						}
					}
				}
				// ꆼꆼꆼꆼꆼꆼꆼꆼUIDLꆼꆼꆼꆼꆼ.
				uidList.removeAllElements();
				for (int i = 0; i < latestUIDL.size(); ++i) {
					if (received.get(i)) {
						uidList.addElement(latestUIDL.elementAt(i));
					}
				}
				client.disconnect();
			} catch (POP3AuthenticationFailedException pafe) {
				debugOut("POP3 authentication is faield:" + pafe);
				throw new MessagingException("POP3AuthenticationFailedException", pafe);
			} catch (IOException ioe) {
				debugOut("IOException occured while receiving message(s):" + ioe);
				throw new MessagingException("IOException", ioe);
			} finally {
				try {
					saveUIDL(uidList);
				} catch (IOException ioe) {
					debugOut("IOException occured while receiving message(s):" + ioe);
					throw new MessagingException("IOException", ioe);
				}
			}
		}
		
		/**
		 * UIDLꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ
		 *
		 * @param	uidList	ꆼꆼꆼꆼꆼꆼꆼUIDL
		 * @throws	java.io.IOException	ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ
		 */
		private void saveUIDL(Vector uidList) throws IOException {
			FileOutputStream fos = new FileOutputStream(uidlFile);
			ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(fos, 16 * 1024));
			oos.writeObject(uidList);
			oos.close();
			debugOut("Saving UIDL file ... done");
		}
	}
	
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼMessageReceiver.
	 */
	class OfflineMessageReceiver implements MessageReceiver {
		/**
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 *
		 * @param	folder	ꆼꆼꆼꆼ.ꆼꆼꆼꆼꆼ.
		 * @exception	javax.mail.MessagingException	ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 */
		public void receive(POP3Folder folder) throws MessagingException {
			return;
		}
	}
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 * ꆼꆼꆼꆼ NORM_PRIORITY - 1 ꆼꆼꆼꆼꆼ.
	 */
	class BackgroundMessageReceiver extends Thread implements MessageReceiver {
		/**
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ Folder ꆼꆼꆼꆼ.
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 * ꆼVector ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ
		 */
		private Vector waitingQueue = new Vector(1);
		
		/**
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 */
		private volatile boolean running;
		
		/**
		 * MessageReceiver.
		 */
		private MessageReceiver receiver;
		
		/**
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ BackgroundMessageReceiver ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.<BR>
		 * ꆼꆼꆼꆼꆼꆼꆼ Daemon thread ꆼꆼꆼꆼꆼꆼꆼ.
		 *
		 */
		protected BackgroundMessageReceiver(MessageReceiver receiver) {
			this.receiver = receiver;
			setDaemon(true);
		}
		
		/*
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 * <OL>
		 *  <LI>ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 *  <LI>ꆼꆼꆼꆼ wait() ꆼꆼ.
		 *  <LI>ꆼꆼꆼꆼꆼFolderꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 *  <LI>ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼFolderꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 *  <LI>ꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 * </OL>
		 * ꆼꆼꆼꆼꆼ.<BR>
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 */
		public void run() {
			running = true;
			try {
				while (running) {
					POP3Folder targetFolder = null;
					synchronized (this) {
						while (running && waitingQueue.isEmpty()) {
							wait();
						}
						if (! running) {
							return;
						}
						targetFolder = (POP3Folder) waitingQueue.elementAt(0);
					}
					receiver.receive(targetFolder);
					waitingQueue.removeElementAt(0);
				}
			} catch (MessagingException me) {
				debugOut("BackgroundMessageReceiver.run():MessagingException occured. " + me);
				notifyStoreListeners(StoreEvent.ALERT, me.toString());
			} catch (InterruptedException ie) {
				debugOut("MessageReceiver.run():InterruptedException occured. " + ie);
				notifyStoreListeners(StoreEvent.ALERT, ie.toString());
			} finally {
				running = false;
			}
		}
		
		/**
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ Folder ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.<BR>
		 *
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 *
		 * @param	folder	ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ folder.
		 */
		public synchronized void receive(POP3Folder folder) throws MessagingException {
			if (waitingQueue.isEmpty()) {
				debugOut("MessageReceiver.receive():waitingQueue is empty.");
				waitingQueue.addElement(folder);
				notify();
			} else {
				debugOut("MessageReceiver.receive():waitingQueue is NOT empty, skipped.");
			}
		}

		/**
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 */
		public synchronized void stopReceiving() {
			try {
				running = false;
				notify();
				join();
			} catch (InterruptedException ie) {
				ie.printStackTrace();
			}
		}

		public boolean isRunning() {
			return running;
		}
	}
	
	/**
	 * ꆼꆼꆼꆼMessageReceiver.receive() ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ NORM_PRIORITY + 1 ꆼꆼꆼꆼꆼ.
	 * ꆼꆼꆼꆼꆼꆼꆼꆼ sleep() ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ
	 * MessageReceiver.receive() ꆼꆼꆼꆼꆼꆼꆼꆼꆼ sleep() ꆼꆼ.
	 */
	private class IntervalTimer extends Thread {
		/**
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ Folder.
		 */
		private POP3Folder targetFolder;
		
		/**
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 */
		private MessageReceiver receiver;
		
		/**
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ append ꆼꆼ
		 * IntervalTimer ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 *
		 * @param folder	ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 * @param	receiver	ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 */
		public IntervalTimer(POP3Folder folder, MessageReceiver receiver) {
			targetFolder = folder;
			this.receiver = receiver;
			setPriority(Thread.NORM_PRIORITY + 1);
			setDaemon(true);
		}
		
		/**
		 * MessageReceiver.receive() ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ sleep() ꆼꆼ
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 * checkInterval ꆼ 0 ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 */
		public void run() {
			if (checkInterval <= 0) {
				debugOut("IntervalTimer.run():checkInterval <= 0");
				return;
			}
			while (isConnected()) {
				try {
					receiver.receive(targetFolder);
					sleep(checkInterval);
				} catch (InterruptedException ie) {
					debugOut("IntervalTimer.run():" + ie);
					ie.printStackTrace();
				} catch (MessagingException me) {
					debugOut("IntervalTimer.run():" + me);
					me.printStackTrace();
				}
			}
		}
	}

	public boolean isSsl() {
		return ssl;
	}

	public void setSsl(boolean ssl) {
		this.ssl = ssl;
	}

	//收取邮件
	public void checkMail(){
		//如果有后台线程，且正在收取，则退出
//		if(receiver != null && receiver instanceof BackgroundMessageReceiver && ((BackgroundMessageReceiver)receiver).isRunning())
//			return ;
		DefaultMessageReceiver messageReceiver=new DefaultMessageReceiver(client);
		try {
			POP3Folder folder = (POP3Folder) this.getFolder(INBOX_NAME);
			MessageCount messageCount = new MessageCount((FolderViewer) PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().findView(FolderViewer.ID));
			folder.addMessageCountListener(messageCount);
			messageReceiver.receive(folder);
			folder.removeMessageCountListener(messageCount);
			if(folder.isOpen())
				folder.close(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	//用简单规则检查是否为非垃圾邮件
	public static boolean needCheckSpam(Message msg){
		//如果发件人在联系人列表中，则认为是Ham
		try {
			String address = ((InternetAddress)msg.getFrom()[0]).getAddress();
			for(IEntry entry:ContractSelectComposite.getContractList()){
				if(((Contract)entry).mail.equals(address))
					return false;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return true;
	}	
}