import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;

import org.apache.log4j.Logger;

public class MailSender {
 public static Logger logger = Logger.getLogger(MailSender.class);
 public static boolean send(Mail mail) throws Exception {
  try {
   Properties props = new Properties();
   props.put("mail.smtp.host", "localhost");
   Session session = Session.getDefaultInstance(props, null);
   MimeMessage mimemessage = new MimeMessage(session);
   mimemessage.setFrom(new InternetAddress(mail.getFrom()));
   mimemessage.setSentDate(mail.getDate());
   // set SUBJECT
   mimemessage.setSubject(mail.getSubject());

   // set TO address
   String mailto = mail.getTo();
   String ccmailid = mail.getCcusers();
   String strResult = "";
   try {
    mimemessage.setRecipients(javax.mail.Message.RecipientType.TO,
      mailto);
   } catch (Exception exception1) {
    throw exception1;
   }

   // set message BODY
   MimeBodyPart mimebodypart = new MimeBodyPart();
   mimebodypart.setText(mail.getContent());

   // attach message BODY
   MimeMultipart mimemultipart = new MimeMultipart();
   mimemultipart.addBodyPart(mimebodypart);

   // attach FILE
   ArrayList attachedFileList = mail.getAttachedFileList();
   if (attachedFileList != null) {
    DataSource ds = null;;
    for (Iterator e = attachedFileList.iterator(); e.hasNext();) {
     ds = (DataSource) e.next();
     mimebodypart = new MimeBodyPart();
     try {
      mimebodypart.setDataHandler(new DataHandler(
        ds));
     } catch (Exception exception3) {
      throw exception3;
     }
     mimebodypart.setFileName(ds.getName()); // set FILENAME
     mimemultipart.addBodyPart(mimebodypart);
    }
   }// end if
   mimemessage.setContent(mimemultipart);
   // set CC MAIL and SEND the mail
   if (!mailto.equals("")) {
    // set CC MAIL
    if (ccmailid != null && (!ccmailid.equals("")))
     mimemessage.setRecipients(
       javax.mail.Message.RecipientType.CC, ccmailid);
    try {
     // send MAIL
     Transport.send(mimemessage);
     logger.info(mailto + " Sent Successfully..........");
    } catch (Exception exception4) {
     throw exception4;
    }
   } else {
    logger.info(mailto + " Mail operation Failed..........");
   }
  } catch (Exception e) {
   throw e;
  }
  return true;
 }

}

Mail.java
import java.util.ArrayList;
import java.util.Date;
import java.util.StringTokenizer;

public class Mail {
 
 private String from = null;
 private String to = null;
 private String subject = null;
 private String content = null;
 private String ccusers = null;
 private ArrayList attachedFileList = null;
 private Date date = null;

 public Mail() {
  // TODO Auto-generated constructor stub
 }

 public ArrayList getAttachedFileList() {
  return attachedFileList;
 }

 public void setAttachedFileList(ArrayList attachedFileList) {
  this.attachedFileList = attachedFileList;
 }

 public String getContent() {
  return content;
 }

 public void setContent(String content) {
  this.content = content;
 }

 public String getFrom() {
  return from;
 }

 public void setFrom(String from) {
  this.from = from;
 }

 public String getSubject() {
  return subject;
 }

 public void setSubject(String subject) {
  this.subject = subject;
 }

 public String getTo() {
  return to;
 }

 public void setTo(String to) {
  this.to = to;
 }

 public Date getDate() {
  return date;
 }

 public void setDate(Date date) {
  this.date = date;
 }

 public String getCcusers() {
  return ccusers;
 }

 public void setCcusers(String ccusers) {
  this.ccusers = ccusers;
 }

}

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class PasswordUtil {
 public final static int ITERATION_NUMBER = 1000;
 public static final String algorithm = "Blowfish";// we can use DES,DESede,Blowfish
 
 /**
  *
  * @param password
  * @return
  * @throws Exception
  */
 public static PasswordBean encry(String password) throws Exception {
  Security.addProvider(new com.sun.crypto.provider.SunJCE());

  try {
   KeyGenerator keygen = KeyGenerator.getInstance(algorithm);
   SecretKey deskey = keygen.generateKey();
   Cipher c1 = Cipher.getInstance(algorithm);
   c1.init(Cipher.ENCRYPT_MODE, deskey);
   byte[] cipherByte = c1.doFinal(password.getBytes());
   String saltKey = PasswordUtil.byteToBase64(deskey.getEncoded());
   String pass = PasswordUtil.byteToBase64(cipherByte);
   return new PasswordBean(saltKey, pass);
   //System.out.println("After encry:" + key + "====" + password);
  } catch (Exception e) {
   throw e;
  }
 }
 
 /**
  *
  * @param bean
  * @return
  * @throws Exception
  */
 public static String decry(PasswordBean bean) throws Exception {
  return decry(bean.getSaltKey(), bean.getPassword());
 }
 
 /**
  *
  * @param saltKey
  * @param pass
  * @return
  * @throws Exception
  */
 public static String decry(String saltKey, String pass) throws Exception {
  //Security.addProvider(new com.sun.crypto.provider.SunJCE());
  try {
   Security.addProvider(new com.sun.crypto.provider.SunJCE());
   byte[] keyser = PasswordUtil.base64ToByte(saltKey);
   javax.crypto.spec.SecretKeySpec destmp = new javax.crypto.spec.SecretKeySpec(keyser, algorithm);
   SecretKey mydeskey = destmp;

   Cipher c1 = Cipher.getInstance(algorithm);
   c1.init(Cipher.DECRYPT_MODE, mydeskey);
   byte[] clearByte = c1.doFinal(PasswordUtil.base64ToByte(pass));
   return new String(clearByte);
  } catch (Exception e) {
   //e.printStackTrace();
   System.out.println("saltKey:" + saltKey + "   pass:" + pass) ;
   throw e;
  }
 }
 
 
 
 /**
  * From a password, a number of iterations and a salt, returns the
  * corresponding digest
  *
  * @param iterationNb
  *            int The number of iterations of the algorithm
  * @param password
  *            String The password to encrypt
  * @param salt
  *            byte[] The salt
  * @return byte[] The digested password
  * @throws NoSuchAlgorithmException
  *             If the algorithm doesn't exist
  */
 public static byte[] getHash(int iterationNb, String password, byte[] salt)
   throws NoSuchAlgorithmException {
  MessageDigest digest = MessageDigest.getInstance("SHA-1");
  digest.reset();
  digest.update(salt);
  byte[] input = digest.digest(password.getBytes());
  for (int i = 0; i < iterationNb; i++) {
   digest.reset();
   input = digest.digest(input);
  }
  return input;
 }

 /**
  * From a base 64 representation, returns the corresponding byte[]
  *
  * @param data
  *            String The base64 representation
  * @return byte[]
  * @throws IOException
  */
 public static byte[] base64ToByte(String data) throws IOException {
  BASE64Decoder decoder = new BASE64Decoder();
  return decoder.decodeBuffer(data);
 }

 /**
  * From a byte[] returns a base 64 representation
  *
  * @param data
  *            byte[]
  * @return String
  * @throws IOException
  */
 public static String byteToBase64(byte[] data) {
  BASE64Encoder endecoder = new BASE64Encoder();
  return endecoder.encode(data);
 }
}

PasswordBean.java

public class PasswordBean {
 
 private String saltKey = null;
 private String password = null;

 public PasswordBean(String key, String pass) {
  this.saltKey = key;
  this.password = pass;
 }
 
 public String getPassword() {
  return password;
 }
 public void setPassword(String password) {
  this.password = password;
 }
 public String getSaltKey() {
  return saltKey;
 }
 public void setSaltKey(String saltKey) {
  this.saltKey = saltKey;
 }
 
}


使用的时候可以是：
String password = PasswordUtil.decry(salt, encodePassword);
PasswordBean passwordBean = PasswordUtil.encry(password);

 }

 private void createSystemTray() {
  Tray tray = Display.getDefault().getSystemTray();
  TrayItem item = new TrayItem(tray, SWT.NONE);
  item.setText("JDishNetwork");
  item.setToolTipText("JDishNetwork");
  Image image = new Image(Display.getDefault(), 16, 16);
  item.setImage(image);
  this.trayManager = new TrayItemManager();
  item.addSelectionListener(this.trayManager);
  item.addListener(SWT.MenuDetect, this.trayManager);
 }

 private class TrayItemManager implements SelectionListener, Listener {
  // TODO: Convert to one class
  private final class WindowStateListener extends SelectionAdapter {
   public void widgetSelected(SelectionEvent e) {
    minimizeWindow();
   }
  }
  private final class RestoreWindowListener extends SelectionAdapter {
   public void widgetSelected(SelectionEvent e) {
    restoreWindow();
   }
  }
  private boolean minimized = false;
  private Menu menu;
  private MenuItem[] menuItems = new MenuItem[0];
  private RestoreWindowListener restoreWindowListener;
  private WindowStateListener minimizeWindowListener;

  public TrayItemManager() {
   this.menu = new Menu(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), SWT.POP_UP);
   this.restoreWindowListener = new RestoreWindowListener();
   this.minimizeWindowListener = new WindowStateListener();

  }

  protected void closeApplication() {
   PlatformUI.getWorkbench().close();
  }

  public void widgetSelected(SelectionEvent e) {
   //
  }

  public void widgetDefaultSelected(SelectionEvent e) {
   if (this.minimized) {
    restoreWindow();
   } else {
    minimizeWindow();
   }
  }

  protected void minimizeWindow() {
   PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell().setMinimized(true);
   this.minimized = true;
  }

  protected void restoreWindow() {
   Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
   shell.open();
   shell.setMinimized(false);
   shell.forceActive();
   shell.forceFocus();
   this.minimized = false;
  }

  public void showMenu() {
   clearItems();
   MenuItem mi;
   MenuItem closeItem;
   mi = new MenuItem(this.menu, SWT.PUSH);
   closeItem = new MenuItem(this.menu, SWT.NONE);
   closeItem.setText("Close");
   closeItem.addSelectionListener(new SelectionAdapter() {
    public void widgetSelected(SelectionEvent e) {
     closeApplication();
    }
   });
   this.menuItems = new MenuItem[] { mi, closeItem };

   if (this.minimized) {
    mi.setText("Maximize");
    mi.addSelectionListener(this.restoreWindowListener);
   } else {
    mi.setText("Minimize");
    mi.addSelectionListener(this.minimizeWindowListener);
   }
   this.menu.setVisible(true);
  }

  private void clearItems() {
   for (int i = 0; i < this.menuItems.length; i++) {
    MenuItem item = this.menuItems[i];
    item.removeSelectionListener(this.minimizeWindowListener);
    item.removeSelectionListener(this.restoreWindowListener);
    this.menuItems[i].dispose();
   }
  }

  public void handleEvent(Event event) {
   showMenu();
  }

 }