本地事件调度

        对于任何的GUI应用程序，不管所使用的是哪一种编程语言和UI工具包，背后的运行机制都是操作系统探测GUI事件并把它们放到应用程序的事件队列中去。这种机制在不同的操作系统平台中大同小异。当用户点击鼠标、键入字符、或者使窗口获得焦点，操作系统就会生成应用程序的GUI事件，例如鼠标点击、键盘输入、或窗口重绘事件。操作系统决定哪一个窗口和应用程序应该接收用户触发的每一个事件并把它放入应用程序的事件队列中。

        任何基于窗口的GUI应用程序的底层实现结构都是一个事件循环(event loop)，应用程序初始化并运行一个循环(loop)，用于从事件队列中读取GUI事件，并作出相应的反应。处理事件的工作必须迅速完成，以保证GUI应用程序能够对用户作出快速反应。

        UI事件触发的耗时较长的操作应该在一个单独的线程中执行，这样才能让事件循环主线程能够快速返回，获取应用程序事件队列中的下一个事件。但是，在非UI线程中访问图形界面部件和平台API 必须通过锁和串行化的机制(locking and serialization)来实现。违反这个规则的应用程序会引起系统调用失败，更严重的是锁住整个GUI系统，使GUI失去反应。

SWT UI 线程

        SWT 遵循系统平台所直接支持的这种线程模型，应用程序在它的主线程中运行事件循环(event loop)，并在主线程中直接调度线程。UI线程就是Display 对象被创建的线程，所有其他的图形部件都必须在这个UI线程中创建。

        既然所有的处理事件的代码是在应用程序的UI线程中触发的，那么处理事件的程序代码就能够不需要任何特殊方法自由访问和调用图形部件。不过，在处理长耗时的事件操作时，需要使用多线程来实现应用程序的功能。

注：在非UI线程中调用任何必须在UI线程调用的程序，SWT将会触发一个 SWTException 异常。

SWT 应用程序的主线程，包括事件循环，其代码结构如下：

Java代码  

1. public static void main (String [] args) {   
2.    Display display = new Display ();   
3.    Shell shell = new Shell (display);   
4.    shell.open ();   
5.    // start the event loop. We stop when the user has done   
6.    // something to dispose our window.   
7.    while (!shell.isDisposed ()) {   
8.       if (!display.readAndDispatch ())   
9.          display.sleep ();   
10.    }   
11.    display.dispose ();   
12. }  

   public static void main (String [] args) {
Display display = new Display ();
Shell shell = new Shell (display);
shell.open ();
// start the event loop. We stop when the user has done
// something to dispose our window.
while (!shell.isDisposed ()) {
if (!display.readAndDispatch ())
display.sleep ();
}
display.dispose ();
}

        创建图形部件和打开shell 窗口之后，程序读取和分发来自操作系统事件队列的事件，直到shell 窗口被销毁。如果在队列中不存在有效事件，display 进入睡眠状态，把运行机会交给其他程序。

        SWT 提供了在后台主线程中调用图形部件代码的访问方法。

运行非UI线程

         在非UI 线程中不能直接调用UI 代码，必须提供一个 Runnable对象，在Runable中调用UI代码。Display 类中的syncExec(Runnable) 和 asyncExec(Runnable) 方法用于在事件循环运行期间，在UI 线程中运行这些Runnable对象。

• syncExec(Runnable)  当非UI 线程中的程序代码依赖于UI 代码的返回值，或者为了确保在返回到主线程之前Runnable 必须执行完成时，应该使用这个方法。SWT 将会阻塞调用线程，直到在应用程序的UI 线程中运行的这个Runnable运行结束为止。例如，一个后台线程需要基于一个窗口的当前尺寸进行某种计算，就会需要同步地运行获取窗口尺寸的代码，然后继续其后面的计算。
• asyncExec(Runnable)  当程序需要执行一些UI 操作，但在继续执行之前不依赖这些操作必须完成的时候，应该使用这个方法。例如，后台主线程更新进度条，或者重绘一个窗口，它可以异步地发出更新或重绘的请求，并接着继续后面的处理，在这种情况下，后台主线线程的运行时间和Runnable的运行没有必然的关系。

Java代码  

1. // do time-intensive computations   
2. ...   
3. // now update the UI. We don't depend on the result,   
4. // so use async.   
5. display.asyncExec (new Runnable () {   
6.    public void run () {   
7.       if (!myWindow.isDisposed())   
8.          myWindow.redraw ();   
9.    }   
10. });   
11. // now do more computations   
12. ...  

   // do time-intensive computations
...
// now update the UI. We don't depend on the result,
// so use async.
display.asyncExec (new Runnable () {
public void run () {
if (!myWindow.isDisposed())
myWindow.redraw ();
}
});
// now do more computations
...

        在使用asyncExec 的时候，在runnable 中检查图形部件是否被销毁是一个好的习惯做法，在调用asyncExec和Runnable执行期间主线程中有可能会发生其他的事情，不能保证runnable执行时图形部件当前处于什么状态。

工作台(Workbench)和多线程

        实现SWT应用程序的多线程规则非常明确，你可以控制事件循环的初始化，在应用程序中使用多线程解决复杂问题。

        向工作台添加插件时的工作机制要父子一些，下面是使用平台(workbench platform)UI 类的一些“规约”(Rules of engagement)，随着eclipse 的不断发布，可能会出现一些例外：

• 通常，任何添加到平台中的工作台(workbench) UI 扩展都是在工作台的UI 主线程中执行的，除非是明确地把它们添加线程中或者是后台作业(background job)中，例如后台作业进度条。
• 如果从工作台接收到一个事件，不能保证它是在UI线程中执行的，查阅定义了监听器或事件的类的java文档，如果没有特别说明使用线程，这个类就是一个UI 相关类，可以在工作台主线程中获得和运行。
• 同样，除非是文档明确说明，平台UI库不能视作是线程安全的。请注意，大部分平台UI类是在触发事件的调用线程中运行监听器的，平台和JFace API调用并不检查是在UI 线程中执行的，这意味着如果在非UI 线程中调用一个能够触发事件的方法，可能会引入问题。从非UI 线程中调用SWT的API，SWT会抛出 SWTException 异常。通常，除非文档中明确规定，避免在别的线程中调用平台UI 代码。
• 如果你的插件使用多线程或工作台作业(workbench job)，必须使用 Display 类的asyncExec(Runnable) 或 syncExec(Runnable) 方法，类调用任何的工作台(workbench)、JFace或SWT 的应用程序接口(API)，除非是API明确说明是可以直接调用的。
• 如果在插件中使用 JFace的IRunnableContext 接口 调用进度监视器(progress monitor)，以运行一个操作，IRunnableContext 提供了一个参数来确定是不是在一个新的线程中运行操作。

    
package com.tr069im.ui;  
    
 
    
import org.eclipse.swt.SWT;  
    
import org.eclipse.swt.layout.GridData;  
    
import org.eclipse.swt.widgets.Button;  
    
import org.eclipse.swt.widgets.Display;  
    
import org.eclipse.swt.widgets.MessageBox;  
    
import org.eclipse.swt.widgets.ProgressBar;  
    
import org.eclipse.swt.widgets.Shell;  
    
 
    
/**  
    
 * 此类通过实现SWT滚动条，说明多线程问题 .解决了后台线程访问前台界面的问题   
    
 * @author llwbrothers  
    
 */ 
    
public class Login implements Runnable {  
    
    private static Shell shell;  
    
    private String loginResponse = "right";  
    
    private static boolean flag = false;  
    
 
    
    public Login() {  
    
 
    
    }  
    
 
    
    public static void main(String[] args) {  
    
          
    
        final Display display = Display.getDefault();  
    
        shell = new Shell(SWT.MIN);  
    
        shell.setSize(290, 520);  
    
        shell.setLocation(300, 5);  
    
        shell.setText("SWT多线程");  
    
 
    
        // 添加平滑的进度条  
    
        final ProgressBar pb1 = new ProgressBar(shell, SWT.HORIZONTAL  
    
                | SWT.SMOOTH);  
    
        pb1.setBounds(72, 282, 160, 20);  
    
        pb1.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));  
    
        // 显示进度条的最小值  
    
        pb1.setMinimum(0);  
    
        // 设置进度条的最大值  
    
        pb1.setMaximum(30);  
    
 
    
        // 登录按钮  
    
        final Button btnLogin = new Button(shell, SWT.FLAT | SWT.PUSH);  
    
        btnLogin.setBounds(80, 363, 111, 36);  
    
        btnLogin.setText("取消");  
    
 
    
        shell.open();  
    
        // 异步线程处理其他数据  
    
        display.asyncExec(new Runnable() {  
    
            public void run() {  
    
                Login pl = new Login();  
    
                Thread t = new Thread(pl);  
    
                t.start();  
    
            }  
    
        });  
    
        // 添加线程，在线程中处理长时间的任务，并最终反映在平滑进度条上  
    
        Runnable runnable = new Runnable() {  
    
            public void run() {  
    
                for (int i = 0; i < 30; i++) {  
    
                    try {  
    
                        Thread.sleep(100);  
    
                    } catch (InterruptedException e) {  
    
                    }  
    
                    display.asyncExec(new Runnable() {  
    
                        public void run() {  
    
                            if (pb1.isDisposed())  
    
                                return;  
    
                            // 进度条递增  
    
                            pb1.setSelection(pb1.getSelection() + 1);  
    
                        }  
    
                    });  
    
                    if (flag) { // 作为标志，使滚动条起作用  
    
                        break;  
    
                    }  
    
                    if (i == 29) {  
    
                        open();  
    
                    }  
    
                }  
    
            }  
    
        };// 启动这个线程  
    
        new Thread(runnable).start();  
    
 
    
        while (!shell.isDisposed()) { // 如果主窗体没有关闭  
    
            if (!display.readAndDispatch()) { // 如果display不忙  
    
                display.sleep(); // 休眠  
    
            }  
    
        }  
    
        display.dispose(); // 销毁display  
    
    }  
    
 
    
    public void run() {  
    
        try {  
    
            // 收到验证信息后进行  
    
            if (loginResponse.equals("right")) {  
    
                // 后台线程访问前台界面  
    
                Display.getDefault().asyncExec(new Runnable() {  
    
                    public void run() {  
    
                        flag = true;  
    
                        Shell shell = new Shell(SWT.MIN);  
    
                        MessageBox messageBox = new MessageBox(shell,  
    
                                SWT.ICON_WARNING);  
    
                        messageBox.setMessage("用户名或密码错误!");  
    
                        messageBox.open();  
    
                    }  
    
                });  
    
 
    
            } else {      
    
            }  
    
        } catch (Exception ee) {  
    
        }  
    
    }  
    
 
    
    public static void open() {  
    
        Display.getDefault().asyncExec(new Runnable() {  
    
            public void run() {  
    
                // 进度条进行完之后，执行的程序  
    
            }  
    
        });  
    
    }  
    
}  

原文地址：http://hi.baidu.com/gg7663/blog/item/f7bfb70f74a5c1f536d122b9.html

开发项目涉及到的表太多，一个一个的写JAVA实体类很是费事。MyEclipse提供简便的方法：反向数据库 

在空白区点击右键,新建一个数据库对象。我用的是mysql，其实我一直想用oracle之类的，只是机子内存小，又懒得倒腾别的，结果截个图吧：

左边的属性按照自己使用的数据库填就行了，左边部分是我建好以后的结果，数据库名叫shop，有个user表 是专门这次测试用的

如果需要用到在实体类上添加注释的话那么选中紧挨着的add Hibernate Annotations Support（据说现在都用annotations了就选上吧！！）

然后下一步选中一个目录存放自动生成hibernate.cfg.xml文件，一般毫无例外的放在src根目录下，下一步选中一个DB Driver中我们第一步建立的那个（对我来说是com.mysql....反正就是自己建的那个呗），然后下一步选中一个目录存放自动生成的HibernateSessionFactory工具类 ，结果出来以后我看了一下，这个hibernateSessionFactory工具类就是一个拿Session的单例，还有一些其它关闭session之类的方法，一看便知。下图是生成的配置文件：

第三步反向生成实体类 

到DB Brower中找到要反向的表选中并且点击右键--->Hibernate Reverse Enginnering

看选项：java src folder 源码包，不用多解释，java package——存放将要反转出来的实体类，选择目录（应该是提前建好的com.xxx.model之类的包）；Create pojo<>db。。。这个选项选中，就是我们建立从表到简单java 对象（即pojo）的配置，把下面的add hibernate mapping annotations to pojo的选上，其它不管，这个选项用来“添加映射注解到pojo对象上”，它上面的那个选项用来创建xml的，据说不太用了，就用annotation吧！

这样应该就够了，下一步

看图：type Mapping要选上hibernatetypes，这样这些注解都是来自 javax.persistence.*了 （刚观察过！）

id generator 看下拉列表就知道是配置id生成策略的

那两个enable 是说映射关系发现（detection），明白了吧？英文好就是沾光，不用像我一样还得查字典了。

下一步：没啥理解不了的 动手点点就知道了

直接完成，发现代码很漂亮，注释很完美，而且肯定没有错误，几分钟都能搞定数十个表，不得不感叹myeclipse，真是个大金矿。

import java.text.Collator;
import java.util.Locale;

import org.eclipse.swt.*;
import org.eclipse.swt.widgets.*;

public class TableColumnSorter {

 public static void addNumberSorter(final Table table,
   final TableColumn column) {
  column.addListener(SWT.Selection, new Listener() {
   boolean isAscend = true; // 按照升序排序

   public void handleEvent(Event e) {
    int columnIndex = getColumnIndex(table, column);
    TableItem[] items = table.getItems();
    // 使用冒泡法进行排序
    for (int i = 1; i < items.length; i++) {
     String strvalue2 = items[i].getText(columnIndex);
     if (strvalue2.equalsIgnoreCase("")) {
      // 当遇到表格中的空项目时，就停止往下检索排序项目
      break;
     }
     for (int j = 0; j < i; j++) {
      String strvalue1 = items[j].getText(columnIndex);
      // 将字符串类型数据转化为float类型
      float numbervalue1 = Float.valueOf(strvalue1);
      float numbervalue2 = Float.valueOf(strvalue2);
      boolean isLessThan = false;
      if (numbervalue2 < numbervalue1) {
       isLessThan = true;
      }
      if ((isAscend && isLessThan)
        || (!isAscend && !isLessThan)) {
       String[] values = getTableItemText(table, items[i]);
       Object obj = items[i].getData();
       items[i].dispose();
       TableItem item = new TableItem(table, SWT.NONE, j);
       item.setText(values);
       item.setData(obj);
       items = table.getItems();
       break;
      }
     }
    }
    table.setSortColumn(column);
    table.setSortDirection((isAscend ? SWT.UP : SWT.DOWN));
    isAscend = !isAscend;
   }
  });
 }

 public static void addStringSorter(final Table table,
   final TableColumn column) {
  column.addListener(SWT.Selection, new Listener() {
   boolean isAscend = true; // 按照升序排序
   Collator comparator = Collator.getInstance(Locale.getDefault());

   public void handleEvent(Event e) {
    int columnIndex = getColumnIndex(table, column);
    TableItem[] items = table.getItems();
    // 使用冒泡法进行排序
    for (int i = 1; i < items.length; i++) {
     String str2value = items[i].getText(columnIndex);
     if (str2value.equalsIgnoreCase("")) {
      // 当遇到表格中的空项目时，就停止往下检索排序项目
      break;
     }
     for (int j = 0; j < i; j++) {
      String str1value = items[j].getText(columnIndex);
      boolean isLessThan = comparator.compare(str2value,
        str1value) < 0;
      if ((isAscend && isLessThan)
        || (!isAscend && !isLessThan)) {
       String[] values = getTableItemText(table, items[i]);
       Object obj = items[i].getData();
       items[i].dispose();
       TableItem item = new TableItem(table, SWT.NONE, j);
       item.setText(values);
       item.setData(obj);
       items = table.getItems();
       break;
      }
     }
    }
    table.setSortColumn(column);
    table.setSortDirection((isAscend ? SWT.UP : SWT.DOWN));
    isAscend = !isAscend;
   }
  });
 }

 public static int getColumnIndex(Table table, TableColumn column) {
  TableColumn[] columns = table.getColumns();
  for (int i = 0; i < columns.length; i++) {
   if (columns[i].equals(column))
    return i;
  }
  return -1;
 }

 public static String[] getTableItemText(Table table, TableItem item) {
  int count = table.getColumnCount();
  String[] strs = new String[count];
  for (int i = 0; i < count; i++) {
   strs[i] = item.getText(i);
  }
  return strs;
 }

 
 /*
  * table.getColumn(0).addSelectionListener(
     new SelectionAdapter()
     {
      public void widgetSelected(SelectionEvent e)
      {

       //调用排序文件，处理排序
       new TableColumnSorter().addStringSorter(table, table.getColumn(0));
      }
     });
  *
  */
}


2.这里在table中每列实例化的时候添加的列监听事件

/*
   *
   * 添加监听事件
   *
   */
  table.getColumn(0).addSelectionListener(new SelectionAdapter() {
   public void widgetSelected(SelectionEvent e) {

    // 调用排序文件，处理排序
    TableColumnSorter.addStringSorter(table, table
      .getColumn(0));
   }
  });

 public class MainStu {
 public static void main(String args[]){
  Student[] stuArr= new Student[10];
  
  //实例化每一个学生并在学生类数组里添加每一个新人；
  Student s0 = new Student();
  s0.setName("Soap");
  s0.setAge(22);
  s0.setScore(60);
  s0.setDepartment("计算机");
  stuArr[0] = s0;
  
  Student s1 = new Student();
  s1.setName("Price");
  s1.setAge(21);
  s1.setScore(88);
  s1.setDepartment("计算机");
     stuArr[1] = s1;

  Student s2 = new Student();
  s2.setName("Rouch");
  s2.setAge(24);
  s2.setScore(87);
  s2.setDepartment("计算机");
  stuArr[2] = s2;
  
  Student s3 = new Student();
  s3.setName("Ghost");
  s3.setAge(20);
  s3.setScore(70);
  s3.setDepartment("计算机");
     stuArr[3] = s3;

   /*************方法的调用**********/  
     GetScore g=new GetScore();
     g.getScore(stuArr);  
}
}


希望这段小代码能够对大家有所帮助，谢谢各位的参观。