在使用SWT構建應用程序時，理解系統底層讀取和調度平臺GUI事件的線程模型是非常重要的，UI線程的實現方式會影響到在應用程序中使用 Java 線程時必須遵守的規則。

 

本地事件調度

        對于任何的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 應用程序的主線程，包括事件循環，其代碼結構如下：

   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的運行沒有必然的關系。

工作臺(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 提供了一個參數來確定是不是在一個新的線程中運行操作。

一.概述
如果你是SWT/Jface的初學者，那么本片所描述的問題很可能是你已經碰到或者將要碰到的。
這是關于多線程開辟的問題，比較常見。

二.問題：
當你在GUI主線程開辟一個新線程，進行其它操作，并且需要更新UI控件，意外發
生了：
Exception in thread "Thread-1" java.lang.NullPointerException。

三。解決方案
使用:Display#asyncExec（Runnable）或者Display#syncExec（Runnable）。
把你的UI更新操作另開一個線程，比如：
Display.getCurrent().asyncExec(new Runnable() {
    public void run() {
        button.setText("update");
    }
}；


如果其它數據處理操作耗時不長，可以把這部分代碼放入到與UI更新同一個線程，
Display.getCurrent().asyncExec(new Runnable() {
    public void run() {
        //Do business action
        button.setText("update");
    }
}；

如果其它數據處理耗時長，那么為了不讓UI響應遲鈍，應該把邏輯操作和UI更新分開:
Thread t = new Thread(new Runnable() {
    public void run() {
        //Do business action
        Display.getCurrent().asyncExec(new Runnable() {
            public void run() {
                button.setText("update");
            }
        }；
       
    }

}

要在后臺線程里對前臺界面組件進行訪問.

    
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() {  
    
                // 進度條進行完之后，執行的程序  
    
            }  
    
        });  
    
    }  
    
}  

S2SH框架集成步驟：

1、框架依賴jar文件
（這些jar包可以去官網自己下載，地址不在連接）

1.1 sping     所依賴工程 spring-framework-2.5.6
     dist\spring.jar          
     lib\cglib\cglib-nodep-2.1_3.jar        
     lib\jakarta-commons\commons-logging.jar        
     lib\aspectj\aspectjweaver.jar和aspectjrt.jar      lib\j2ee\common-annotations.jar

1.2 hibernate   所依賴工程 hibernate-distribution-3.3.2.GA
     hibernate3.jar
     lib\required\jta-1.1.jar        javassist-3.9.0.GA.jar        dom4j-1.6.1.jar        commons-collections-3.1.jar        antlr-2.7.6.jar        slf4j-api-1.5.8.jar
     lib\bytecode\cglib\cglib-2.2.jar
     [二級緩存可選]lib\optional\oscache\oscache-2.1.jar        同時需要把\project\etc\oscache.properties 拷貝到src 下
     [二級緩存可選]lib\optional\ehcache\ehcache-1.2.3.jar  同時需要把\project\etc\ehcache.xml
     [二級緩存可選]lib\optional\c3p0\    配置c3p0數據庫連接池的使用 作用等同于apache的dbcp

     *使用hibernate注解：hibernate-annotations-3.4.0.GA\
     hibernate-annotations.jar
     lib\hibernate-commons-annotations.jar
     lib\ejb3-persistence.jar

     *若使用slf的日志還需要：slf4j-1.5.8
     slf4j-nop-1.5.8.jar

1.3 struts2  所依賴工程  struts-2.1.8.1
     lib目錄下的：
        struts2-core-2.1.8.1.jar
        xwork-core-2.1.6.jar
        ognl-2.7.3.jar
            freemarker-2.3.15.jar
        commons-fileupload-1.2.1.jar
        commons-io-1.3.2.jar
        struts2-spring-plugin-2.1.8.1.jar
             aopalliance-1.0.jar
        classworlds-1.1.jar
        commons-beanutils-1.7.0.jar
        commons-chain-1.2.jar
        commons-collections-3.2.jar  在hibernate中已經引用          
        commons-digester-2.0.jar        
        commons-lang-2.3.jar
        commons-logging-1.0.4.jar  此文件在spring中已存在
        commons-logging-api-1.1.jar
        commons-validator-1.3.1.jar
        ezmorph-1.0.3.jar
        json-lib-2.1.jar 若使用json可選
        oro-2.0.8.jar
        oval-1.31.jar


2、框架的配置文件

2.1 spring框架配置文件及集成hibernate、二級緩存
        $WEB_ROOT/WEB-INF/applicationContext.xml
            src/ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
           <http://www.springframework.org/schema/beans/spring-beans-2.5.xsd>
           <http://www.springframework.org/schema/context> <http://www.springframework.org/schema/context/spring-context-2.5.xsd>
           <http://www.springframework.org/schema/aop> <http://www.springframework.org/schema/aop/spring-aop-2.5.xsd>
           <http://www.springframework.org/schema/tx> <http://www.springframework.org/schema/tx/spring-tx-2.5.xsd>">
    
    <!-- 配置數據源 -->
        <context:property-placeholder location="classpath:jdbc4mysql.properties" />
        <bean id="dataSource"
                class="org.apache.commons.dbcp.BasicDataSource"
                destroy-method="close">
                <property name="driverClassName" value="${driverClassName}" />
                <property name="url" value="${url}" />
                <property name="username" value="${username}" />
                <property name="password" value="${password}" />
                <!-- 連接池啟動時的初始值 -->
                <property name="initialSize" value="${initialSize}" />
                <!-- 連接池的最大值 -->
                <property name="maxActive" value="${maxActive}" />
                <!-- 最大空閑值.當經過一個高峰時間后，連接池可以慢慢將已經用不到的連接慢慢釋放一部分，一直減少到maxIdle為止 -->
                <property name="maxIdle" value="${maxIdle}" />
                <!--  最小空閑值.當空閑的連接數少于閥值時，連接池就會預申請去一些連接,以保證應急 -->
                <property name="minIdle" value="${minIdle}" />
        </bean>
        
         <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
         <property name="dataSource" ref="dataSource"/>
         <property name="mappingResources">
            <list>
              <value>cn/tsp2c/sshdemo/domain/User.hbm.xml</value>
            </list>
         </property>
         <property name="hibernateProperties">
            <value>
                hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
                hibernate.hbm2ddl.auto=update
                hibernate.show_sql=false
                hibernate.format_sql=false
                hibernate.cache.use_second_level_cache=true
                hibernate.cache.use_query_cache=false
                hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider
              </value>
         </property>
         </bean>
        
    <!-- 配置事務管理器 -->
        <bean id="txManager"
                class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
                <property name="dataSource" ref="dataSource" />
        </bean>
        
        <!-- spring支持兩種事務聲明方式：注解和xml配置，建議使用注解方式 -->
        <!-- 采用@Transactional注解方式使用事務,在dao類及方法需用注解方式標明事務方式 -->
        <tx:annotation-driven transaction-manager="txManager" />   

     <!-- 用戶DAO實現,實現方式：JDBC
    <bean id="userDao" class="cn.tsp2c.sshdemo.dao.impl.UserDaoImpl">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    -->
    <!-- 用戶DAO實現,實現方式：hibernte  -->    
    <bean id="userDao" class="cn.tsp2c.sshdemo.dao.impl.hibernate.UserDaoHibernateImpl">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
   
     
        <!-- 用戶服務bean -->
        <bean id="userService" class="cn.tsp2c.sshdemo.service.impl.UserServiceImpl" >
           <property name="userDao" ref="userDao"/>
        </bean>
        
        <!-- 用戶Action bean,scope=prototype符合struts2的action生成機制 -->
    <bean id="userAction" class="cn.tsp2c.sshdemo.web.action.UserAction" scope="prototype">
        <property name="userService" ref="userService"/>
    </bean>
</beans>

其中集成hibernate需要屬性文件：jdbc4mysql.properties

driverClassName=com.mysql.jdbc.Driver
url=jdbc\:mysql\://localhost\:3306/sshdemodb?useUnicode\=true&characterEncoding\=utf-8
username=root
password=1234
initialSize=1
maxActive=500
maxIdle=2
minIdle=1

需要配置hibernate的二級緩存，如使用ehcache：在src路徑下加入ehcache.xml
<?xml version="1.0" encoding="UTF-8"?>
<!--
     defaultCache 設置節點為缺省的緩存策略
     maxElementsInMemory 設置內存中最大允許存在的對象數量
     eternal 設置緩存中的對象是否永遠不過期
     overflowToDisk 把超出內存設定的溢出的對象存放到硬盤上
     timeToIdleSeconds 設置緩存對象空閑多長時間就過期,過期的對象會被清除掉
     timeToLiveSeconds 設置緩存對象總的存活時間
     diskPersistent 當jvm結束時是否把內存中的對象持久化到磁盤
     diskExpiryThreadIntervalSeconds 設置用于清除過期對象的監聽線程的輪詢時間
-->
<ehcache>
    <diskStore path="e:\cache"/>
    <defaultCache  maxElementsInMemory="1000" eternal="false" overflowToDisk="true"
        timeToIdleSeconds="120"
        timeToLiveSeconds="180"
        diskPersistent="false"
        diskExpiryThreadIntervalSeconds="60"/>
        <cache name="cn.tsp2c.sshdemo.domain.User" maxElementsInMemory="100" eternal="false"
    overflowToDisk="true" timeToIdleSeconds="300" timeToLiveSeconds="500" diskPersistent="false"/>
</ehcache>

2.2 struts2的配置文件： src/struts.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "<http://struts.apache.org/dtds/struts-2.0.dtd>">

<struts>
    <!-- 指定web應用的默認編碼為UTF-8，功能等同于request.setCharacterEncoding() -->
    <constant name="struts.i18n.encoding" value="UTF-8"/>
    <!-- 指定struts2的請求處理后綴，匹配*.action的所有請求 -->
    <constant name="struts.action.extension" value="action"/>
    <!-- 關閉struts2的!動態方法調用,建議使用通配符匹配方式實現動態方法調用 -->
    <constant name="struts.enable.DynamicMethodInvocation" value="false"/>
    <!-- 設置瀏覽器是否緩存靜態頁面，默認為true，建議：開發階段關閉，生產環境打開 -->
    <constant name="struts.serve.static.browserCache" value="false" />
    <!-- 當struts.xml修改時自動重新加載，默認為false。建議：開發階段打開，生產環境關閉 -->
    <constant name="struts.configuration.xml.reload" value="true"/>
    <!-- 開發模式下打開，便于打印詳細日志，生產環境下關閉 -->
    <constant name="struts.devMode" value="true" />
    <!-- 設置視圖主題為css_xhtml -->
    <constant name="struts.ui.theme" value="simple" />
    <!-- 指定struts中action交由spring創建 -->
    <constant name="struts.objectFactory" value="spring"/>
    
    <package name="base" extends="struts-default">
        <global-results>
               <result name="message">/WEB-INF/page/message.jsp</result>
               <result name="error">/WEB-INF/page/error.jsp</result>
        </global-results>
    </package>
    
    <package name="user" namespace="/user" extends="base">
        <action name="login" class="cn.tsp2c.sshdemo.web.action.LoginAction" method="execute">
            <result name="success">/index.jsp</result>
            <result name="input">/login.jsp</result>
        </action>
        <action name="user_*" class="cn.tsp2c.sshdemo.web.action.UserAction" method="{1}">
            <result name="list">/userlist.jsp</result>
            <result name="add" type="redirect">/useradd.jsp</result>
        </action>
    </package>
</struts>


3、需要把spring、strusts2框架注入到web容器（hibernate框架被spring集成，和web容器沒有關系。所以不需要在web.xml中配置）

web.xml文件：
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
        <http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd>">
    <!-- 配置spring的xml文件，若配置文件有多個，可用,或空格分隔 -->
        <context-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>
                        /WEB-INF/applicationContext.xml
                </param-value>
        </context-param>

        <!-- web容器加載struts2配置 -->
        <filter>
                <filter-name>struts2</filter-name>
                <filter-class>
                        org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
                </filter-class>
        </filter>
        <filter-mapping>
                <filter-name>struts2</filter-name>
                <url-pattern>/*</url-pattern>
        </filter-mapping>

        <!-- web容器加載spring配置 -->
        <listener>
                <listener-class>
                        org.springframework.web.context.ContextLoaderListener
                </listener-class>
        </listener>

        <!-- web容器增加字符集轉換的過濾器,由于struts2框架解決了字符集轉碼，此配置可以注釋掉
        <filter>
                <filter-name>encoding</filter-name>
                <filter-class>
                        org.springframework.web.filter.CharacterEncodingFilter
                </filter-class>
                <init-param>
                        <param-name>encoding</param-name>
                        <param-value>UTF-8</param-value>
                </init-param>
        </filter>
        <filter-mapping>
                <filter-name>encoding</filter-name>
                <url-pattern>/*</url-pattern>
        </filter-mapping>
    -->
        <!-- 解決hibernate的session關閉導致延遲加載異常的問題 -->
        <!--  
                <filter>
                <filter-name>Spring OpenEntityManagerInViewFilter</filter-name>
                <filter-class>
                  org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter
                </filter-class>
                </filter>
                <filter-mapping>
                  <filter-name>Spring OpenEntityManagerInViewFilter</filter-name>
                  <url-pattern>/*</url-pattern>
                </filter-mapping>
        -->

        <welcome-file-list>
                <welcome-file>index.jsp</welcome-file>
        </welcome-file-list>
</web-app>

3.1 web容器集成spring

        <!-- 配置spring的xml文件，若配置文件有多個，可用,或空格分隔 -->
        <context-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>
                        /WEB-INF/applicationContext.xml
                </param-value>
        </context-param>

        <!-- web容器加載spring配置 -->
        <listener>
                <listener-class>
                        org.springframework.web.context.ContextLoaderListener
                </listener-class>
        </listener>


3.2 web容器集成struts2
        <!-- web容器加載struts2配置 -->
        <filter>
                <filter-name>struts2</filter-name>
                <filter-class>
                        org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
                </filter-class>
        </filter>
        <filter-mapping>
                <filter-name>struts2</filter-name>
                <url-pattern>/*</url-pattern>
        </filter-mapping>

3.3 關于在session范圍內解決hibernate的延遲加載問題

<!-- 解決hibernate的session關閉導致延遲加載異常的問題 -->
<filter>
    <filter-name>HibernateSessionInViewFilter</filter-name>
    <filter-class>
      org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
    </filter-class>
</filter>
<filter-mapping>
    <filter-name>HibernateSessionInViewFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>


4、如何使用s2sh框架實現MVC

4.1 action

struts.xml:
    <!-- 指定struts中action交由spring創建 -->
    <constant name="struts.objectFactory" value="spring"/>

<action name="user_*" class="cn.tsp2c.sshdemo.web.action.UserAction" method="{1}">
    <result name="list">/userlist.jsp</result>
    <result name="add" type="redirect">/useradd.jsp</result>
</action>

在spring中配置：
<!-- 用戶Action bean,scope=prototype符合struts2的action生成機制 -->
    <bean id="userAction" class="cn.tsp2c.sshdemo.web.action.UserAction" scope="prototype">
        <property name="userService" ref="userService"/>
    </bean>

4.2 service
<!-- 用戶服務bean -->
<bean id="userService" class="cn.tsp2c.sshdemo.service.impl.UserServiceImpl" >
   <property name="userDao" ref="userDao"/>
</bean>

4.3 dao
<!-- 用戶DAO實現,實現方式：JDBC -->
<bean id="userDao" class="cn.tsp2c.sshdemo.dao.impl.UserDaoImpl">
    <property name="dataSource" ref="dataSource"/>
</bean>

在空白區點擊右鍵,新建一個數據庫對象。我用的是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，真是個大金礦。