<rt id="bn8ez"></rt>
<label id="bn8ez"></label>

  • <span id="bn8ez"></span>

    <label id="bn8ez"><meter id="bn8ez"></meter></label>

    176142998

      BlogJava :: 首頁 :: 聯系 :: 聚合  :: 管理
      116 Posts :: 0 Stories :: 45 Comments :: 0 Trackbacks

    #

    為你的數據庫屬性hibernate.dialect設置正確的 org.hibernate.dialect.Dialect子類. 如果你指定一種方言, Hibernate將為上面列出的一些屬性使用合理的默認值, 為你省去了手工指定它們的功夫.

    表 4.8.  Hibernate SQL方言 (hibernate.dialect)
    RDBMS 方言
    DB2 org.hibernate.dialect.DB2Dialect
    DB2 AS/400 org.hibernate.dialect.DB2400Dialect
    DB2 OS390 org.hibernate.dialect.DB2390Dialect
    PostgreSQL org.hibernate.dialect.PostgreSQLDialect
    MySQL org.hibernate.dialect.MySQLDialect
    MySQL with InnoDB org.hibernate.dialect.MySQLInnoDBDialect
    MySQL with MyISAM org.hibernate.dialect.MySQLMyISAMDialect
    Oracle (any version) org.hibernate.dialect.OracleDialect
    Oracle 9i/10g org.hibernate.dialect.Oracle9Dialect
    Sybase org.hibernate.dialect.SybaseDialect
    Sybase Anywhere org.hibernate.dialect.SybaseAnywhereDialect
    Microsoft SQL Server org.hibernate.dialect.SQLServerDialect
    SAP DB org.hibernate.dialect.SAPDBDialect
    Informix org.hibernate.dialect.InformixDialect
    HypersonicSQL org.hibernate.dialect.HSQLDialect
    Ingres org.hibernate.dialect.IngresDialect
    Progress org.hibernate.dialect.ProgressDialect
    Mckoi SQL org.hibernate.dialect.MckoiDialect
    Interbase org.hibernate.dialect.InterbaseDialect
    Pointbase org.hibernate.dialect.PointbaseDialect
    FrontBase org.hibernate.dialect.FrontbaseDialect
    Firebird org.hibernate.dialect.FirebirdDialect

    posted @ 2008-06-19 23:33 飛飛 閱讀(185) | 評論 (0)編輯 收藏

    Oracle導入excel數據方法匯總
    摘要:在程序編制過程和數據匯總交換過程中,經常會碰到需要將其他人員在office辦公環境下編制的文件數據內容導入oracle中的情況。目前程序開發者經常使用的方法有如下幾種:1,使用oracle提供的導入工具sql*loader;2,使用plsql developer工具;3使用其他數據轉移工具做中轉站。下面我們采用實例的方式分別描述幾種導入方式的優缺點及其操作步驟。假設‘e:\test.xls’文件中存在三列數據分別代表客戶編號,客戶名稱和聯系電話。其內容如下:
    10001
    zjaxi01
    13562485246
    10002
    zjaxi02
    13562485247
    10003
    zjaxi03
    13562485248
    10004
    zjaxi04
    13562485249
    10005
    zjaxi05
    13562485250
    10006
    zjaxi06
    13562485251
    10007
    zjaxi07
    13562485252
    10008
    zjaxi08
    13562485253
    10009
    zjaxi09
    13562485254
    10010
    zjaxi10
    13562485255
    10011
    zjaxi11
    13562485256
    10012
    zjaxi12
    13562485257
    10013
    zjaxi13
    13562485258
    10014
    zjaxi14
    13562485259
    使用sql *loader
    SQL*LOADER是oracle的數據加載工具,在NT下sql*loader的命令為SQLLDR,在UNIX下一般為SQLLDR/SQLLOAD。通常用來將操作系統文件遷移到oracle數據庫中。它是大型數據倉庫選擇使用的加載方法,因為它提供了最快速的途徑(direct,parallel)。但這種方法要求存儲數據的oracle表是已經存在的。
    使用這種方法導入excel內容到oracle時,首先需要將excel文件另存為文本格式,文件類型選文本類型或者csv類型即將e:\test.xls另存為e:\test.csv。
    如果oracle沒有對應存儲數據的表結構,則需要創建表test(id,name,telphone)。
    用記事本創建sql*loader控制文件test.ctl(ctl后綴是企圖證明這是一個控制文件,但實際上這個文件后綴不重要,用戶可以自由選擇,但文件格式一定要是文本格式),內容如下:
    Load data
    Infile ‘e:\test.csv’          --數據源文件名稱
    Append|insert|replace       --append在表后追加,insert插入空表,replace替代原有內容
    Into table test            --要導入的數據庫表名稱
    [when id = id_memo]     --過濾條件
    Fields terminated by X’09’ --字段分隔符
    (id,name,telphone)        --字段名稱列表
    最后在命令窗口輸入sqlldr命令行執行導入操作Sqlldr userid = system/manager control=’e:\test.ctl’
    Sqlldr的函數關鍵字說明:
    Userid   --oracle用戶名 userid = username/password
    Control --控制文件名稱 control = ‘e:\insert.ctl’
    Log     –-日志文件名稱 log = ‘e:\insert.log’
    Bad     --損壞文件名稱
    Data     --data file name
    Discard    --discard file name
    Discardmax --number of discards to allow(默認全部)
    Skip       --導入時跳過的記錄行數(默認0)
    Load       --導入時導入的記錄行數(默認全部)
    Errors    --允許錯誤的記錄行數(默認50)
    使用plsql developer
    PL/SQL Developer是一種專門用于開發、測試、調試和優化oracle PL/SQL存儲程序單元,比如觸發器,存儲過程,函數和程序包等集成開發環境。
    在單個文件數據不多(小于10w行),并且目的表結構已經存在的情況下可以使用plsql developer工具將excel內容直接通過簡單的copy,paste操作導入oracle數據庫。具體操作方式如下:
    l         在plsql developer的sql window里輸入select * from test for update,其中test是要導入的oracle數據表名稱;
    l         執行查詢(通過點擊按鈕或者快捷鍵F8可以實現);
    l         點擊查詢結果上面的鎖狀按鈕,使得查詢到的內容處于編輯狀態。
    l         從excel數據表中copy(ctrl +C)要導入oracle中的數據,如果是單列數據導入,可以先按plsql developer中查詢結果上面的“添加(+)”按鈕,使得數據表處于添加數據狀態,然后將鼠標在plsql developer的列名稱上單擊,最后使用快捷鍵ctrl + v 完成數據導入操作,并單擊plsql developer中的“提交(對號)”按鈕提交所做的修改。
    l         如果是同時導入所有列,首先選擇copy所有數據,然后點增加(+)并點擊編輯那一行最前面的星號使得整行數據都處于被選擇狀態,最后paste即可將數據導入。
    l         如果分列導入數據,則需要逐列完成,首先選擇copy要導入的數據,然后然后點增加(+)并點擊編輯那一列的名稱,使得整列數據都處于被選擇狀態,最后paste即可將數據導入。
    使用PLSQL developer執行數據的導入和導出操作主要存在的問題是在大數據量情況下對中文數據可能出錯,估計將接收數據表的類型定義為nvarchar2的類型會比較好一點。另外,就是這種方法需要人工更多的參與,不能達到自動導入的效果。
    使用sql server中轉
        這部操作執行時,需要先用sqlserver的導入導出工具將excel內容導入sqlserver數據庫中,然后使用同樣的工具將sqlserver中轉內容導入oracle數據庫,這里需要兩次的數據復制與IO操作,效率相對是比較低的。并且根據csdn網友jkflyfox的描述,這種方式下需要將oracle文件的名稱全部大寫,否則會出錯。
     
    posted @ 2008-06-16 15:17 飛飛 閱讀(551) | 評論 (0)編輯 收藏

    實現的功能:

    每隔一分鐘自動向getSysDate表中插入當前的系統時間。

    一、創測試表

    create table getSysDate(test date);

    二、創要定時執行的存儲過程

    create or replace procedure insertSysDate as

    begin

    insert into getSysDate values (sysdate);

    end ;

    三、創建JOB,即創建待執行的定時任務過程

    variable job1 number;

    begin

    dbms_job.submit(:job1,'insertSysdate;',sysdate,'sysdate+1/1440');

    end;

    四、啟動JOB,即啟動并運行定時任務過程

    begin

    dbms_job.run(:job1);

    end;

    五、查看運行效果

    select to_char(test,'yyyy/mm/dd hh24:mi:ss') from getSysDate;

    結果如下:

    2007/08/03 10:53:11

    2007/08/03 11:05:51

    部分重點參數補充說明:

    DBMS_JOB.SUBMIT(:jobno,//job號

    'your_procedure;',//要執行的過程

    trunc(sysdate)+1/24,//下次執行時間

    'trunc(sysdate)+1/24+1'//每次間隔時間

    );

    刪除job:dbms_job.remove(jobno);

    修改要執行的操作:job:dbms_job.what(jobno,what);

    修改下次執行時間:dbms_job.next_date(job,next_date);

    修改間隔時間:dbms_job.interval(job,interval);

    停止job:dbms.broken(job,broken,nextdate);

    啟動job:dbms_job.run(jobno);

    修改job_queue_processes的值:(保證其不為0否則JOB不自動運行)

    可通過select * from v$parameter;查看其值;

    或者直接用show parameter job_queue_processes;查看如下:

    NAME TYPE VALUE

    --------------- ----------- ------------

    job_queue_processes integer 10

    方法1.startup pfile='C:oracleora90databaseinitorcl.ora';

    //這個方法用來修改initorcl.ora文件的job_queue_processes參數,然后重新啟動數據庫

    方法2.alter system set job_queue_processes=10

    //這個方法不用重啟數據庫就可以生效,系統自動修改init.ora文件以后即可生效 。

    posted @ 2008-06-16 12:07 飛飛 閱讀(400) | 評論 (0)編輯 收藏

    在網上漫無邊際地搜索了一天,絕大部分都是垃圾信息,只好自己做一遍

        好了,下面我就將我所完成的例子程序完整的敘述,希望對讀者有所幫助。

    一、開發環境

       myeclipse6.01GA,mysql。

    二、表結構

       CREATE TABLE `user` (
      `id` int(10) unsigned NOT NULL auto_increment,
      `username` varchar(64) NOT NULL,
      `password` varchar(64) NOT NULL,
      `first_name` varchar(128) NOT NULL,
      `last_name` varchar(128) NOT NULL,
      `date_created` bigint(20) unsigned NOT NULL,
      PRIMARY KEY  (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

    三、具體步驟:

    1、在myeclipse中建立一個“java project”,工程名為:HibernateSpringProject,這個程序用java應用程序就可以實現。

     

    2、右鍵點擊工程文件,然后選擇MyEclipse->Add Spring Capabilities...

    第一步選擇需要加載的包,如下圖所示:



    其余的選項默認,點擊 “下一步”,提示是否建立spring配置文件,選擇默認,然后直接點擊“finish”。

    3、右鍵點擊工程文件,然后選擇MyEclipse->Add Hibernate Capabilities...

    第一步選擇默認,點擊“下一步”。

    第二步提示你是用hibernate的配置文件還是用spring的配置文件進行SessionFactory的配置,選擇使用spring來對hibernate進行管理,這樣最后生成的工程里就不包含hibernate.cfg.xml了,好處是在一個地方就可以對hibernate進行管理了。

     

    第三步提示你是創建一個新的hibernate配置文件還是使用已有的配置文件,由于我們剛才已經生成了spring配置文件,并且要在其中進行hibernate的配置,所以選擇復選框“Existing Spring configuration file”,選擇該項后,下方的“Spring Config:”后的下拉列表框自動填入了剛才生成的spring配置文件路徑。這時候有個錯誤,要求你填寫SessionFactory ID,這個id就是我們要為hibernate注入的一個類的ID,隨便取一個名字,例如“sessionFactory”。點擊“下一步”。

     

    第四步要求選擇數據庫連接信息,這個步驟可以參照網上的信息進行配置,很簡單。這里需要注意一點,“bean id”處填寫一個數據源的名稱,例如“datasource”,下面的單選按鈕選擇“Use Jdbc Driver”就行了,此處沒有用jndi。在“DB Driver”處選擇配置好的數據庫連接信息,其他信息自動填入余下的輸入框中,點擊下一步。

     

    第四步提示是否創建“SessionFactory”類,由于本程序用spring替我們注入sessionfactory,此處可以不用創建,勾掉復選框。然后直接點擊“finish”。

     

    4、建立三個包,分別是com.simon.dao,com.simon.model,com.simon.service。

    在用ssh開發web應用時,需要對生成的各個類文件進行組織,下面就對一個可行的目錄方案進行介紹:

    譬如應用中有一個用戶管理模塊,則在公共包下建立一個user包,如該公共包可以為com.simon.oa,

    在user包下包括如下子包

    1、controler包

    該包放置各種struts的action。

     

    2、dao包

    該包放置各類dao(data access object),也就是放置對數據庫訪問的實現類,在用myeclipse中的“Hibernate Reverse Engineering”進行反向操作時在某一個目錄中就會生成對應某個表的DAO,生成后可將該DAO拖到dao包中。在某些應用中將DAO作為接口,在該接口中包括所有對數據庫的操作方法,然后在dao包建立一個hibernate包,在hibernate包中放置對DAO接口的實現,譬如:UserDAO接口有一個實現類為UserDaoImpl,將該類放置到hibernate包中,實際的開發傾向于后一種方式,因為對這個DAO接口可以實現spring的IoC操作。(不知道myeclipse對此是怎么考慮的,這個問題讓我糾纏了很久,誤將DAO理解成一個能夠進行實際操作的類,而不是一個接口,以后開發要注意)

     

    3、model包

    該包中放置hibernate反向工程生成的bean和該bean對應的.hbm.xml文件。

     

    4、service包

    該包放置業務操作類,譬如用戶服務類,一般情況將該用戶操作類提取一個接口,然后在service包下生成一個impl包,在impl包中才放置用戶操作接口的實現類。該用戶接口實現類中調用DAO接口對數據庫進行操作,而調用該實現類的方法在struts的action中。

     

    5、vo包(value object)

    vo包中的中包括struts中使用的POJO及actionform等信息。

    VO:  Value Object
    DTO: Data Transfer Object
    個人理解VO和DTO是類似的東西,原則上VO和DTO只有Public Fields,主要用于進程之間數據傳遞的問題,VO和DTO不會傳遞到表示層,在業務層就會被吸收。但看到很多人在建立VO和DTO時,也含有Setter,Getter屬性和一些其它的輔助方法,這也無可厚非,我自己也不能確定這對不對。

    實際的結構如下:


     

    5、打開myeclipse的database exployer perspective,右鍵選擇user表,選擇Hibernate reverse engineering

    按照下圖所示進行設置


    點擊下一步,在“ID generator”中選擇native,如果愿意可以直接點擊finish

    這時再觀察applicationContext.xml文件,發現在sessionFactory定義中增加了如下代碼:

      <property name="mappingResources">
       <list>
        <value>com/simon/model/User.hbm.xml</value>
        </list>
      </property>

    此時在觀察類結構:


    在model包下生成了三個類和一個映射文件。AbstractUser是User的抽象類,在此需要說明一點的是,在標準的spring應用中UserDAO應該是一個接口,而不是一個具體的類,而myeclipse將數據庫操作方法直接寫到了UserDAO中,另外,按照標準寫法,DAO實現類要實現DAO接口,并且要包括SessionFactory的變量聲明,但是生成的代碼中UserDAO直接實現了HibernateDaoSupport類,需要特別注意。所以,如果你需要標準寫法,可以將UserDAO中的方法提取出來,只保留方法聲明,然后再間一個impl目錄,將該DAO的實現類放在該impl中,按照管理將該類命名為UserDAOImpl,另外一點最好將DAO和它的實現類移到dao包中,結構和model包中的相同。

    在這個例子中暫且將生成的文件都放到model中。

    此時我們可以寫一個測試程序將一條記錄插入到user表中,當然這個測試程序并沒有用事務控制,后面我們還會介紹,測試程序如下:

    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import com.simon.model.UserDAO;
    import com.simon.model.User;
    public class TestWithoutTx {

     /**
      * @param args
      */
     public static void main(String[] args) {
      // TODO Auto-generated method stub
            User user=new User();
            user.setFirstName("first name");
            user.setLastName("last name");
            user.setUsername("user name");
            user.setPassword("password");
            user.setDateCreated(new Long(111111));
            ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
            UserDAO userdao=(UserDAO)context.getBean("UserDAO");
            userdao.save(user);       
     }
    }

    現在的問題是增加事務處理功能,跟我繼續,這時候源程序不需要修改,只需要修改applicationContext.xml配置文件,首先增加事務管理器,因為事務管理器也需要使用數據庫,所以需要引入sessionFactory

    如下:

     <bean id="myTransactionManager"  class="org.springframework.orm.hibernate3.HibernateTransactionManager">
     <property name="sessionFactory">
     <ref bean="sessionFactory" />
     </property>
     </bean> 

    繼續增加如下配置信息:

    <bean id="userDAOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
      <property name="proxyTargetClass">
       <value>true</value>
      </property>

      <property name="transactionManager">
       <ref bean="myTransactionManager" />
      </property>
      <property name="target">
       <ref local="UserDAO" />
      </property>
      <property name="transactionAttributes">
       <props>
        <!-- 這里的方法簽名可以精確到方法, 先懶惰一下全配置上 -->
        <prop key="*">PROPAGATION_REQUIRED</prop>
       </props>
      </property>
     </bean>

     

    注意以上紅色部分:  注意這個屬性,必須為 true, 使用CGLIB時才不用強制編寫DAO接口,也就是由于myeclipse并沒有為我們生成DAO接口,而是生成了一個數據庫實現類,為了使spring不強迫我們必須定義一個DAO接口,只需要將這個proxyTargetClass屬性定義為true,這點非常重要,程序出錯很有可能和這個屬性設置錯誤有關。

    下面再寫一個測試程序,和上面的測試程序基本相同,唯一不同是將上面的

    UserDAO userdao=(UserDAO)context.getBean("userDAO");

    換成

    UserDAO userdao=(UserDAO)context.getBean("userDAOProxy");

    執行,一切ok,數據正確的插入到數據庫中。

    posted @ 2008-06-13 16:40 飛飛 閱讀(329) | 評論 (0)編輯 收藏

    一說起傳說中的SSH(Struts+Spring+Hibernate)架構,許多人的心里面就沒有底。

    依照本人來看,所謂的整合沒有什么神秘的,只不過就是讓三個框架在一起協同的工作,我們做的主要工作就是讓其知道彼此的存在,打成“統一戰線聯盟”以后,再各自為戰,互不干擾。

    下面就本人知道的一些整合方法一一敘述。

    1 Struts+Spring

    主要就是讓Struts知道Spring的存在,我們可以采用兩種辦法。

    (1) 運用Struts的插件方法,添加struts-congif.xml的<plug-in>節點。

    示例代碼如下:

    xml 代碼
    1. <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">  
    2.         <set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml" />  
    3.     </plug-in>   

    上段代碼意圖很簡單:把Struts的配置文件和Spring的配置文件聯系起來,這樣Struts就知道了Spring的存在。

    另外,在web.xml里面需要配置一個Spring的監聽器,示例代碼如下:

    xml 代碼
    1. <listener>  
    2.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
    3.     </listener>   

    第一種方法完畢。

    (2) 直接在web.xml里面進行加載。

    這種方法與上種方法的不同之處在于Spring的配置文件加載的位置不同,上種方法是在struts-cong.xml中聲明,而這種方法是在web.xml里面進行聲明,示例代碼如下:

    xml 代碼
    1. <context-param>  
    2.         <param-name>contextConfigLocation</param-name>  
    3.         <param-value>  
    4.              /WEB-INF/applicationContext-module1.xml,   
    5.              /WEB-INF/applicationContext-module2.xml  
    6.         </param-value>  
    7.     </context-param>  

    這樣我們就實現了第二種方法的SS整合。

    問題至于我們還要遇到一個小問題,那就是Struts如何實用Spring的特性?Struts怎么就知道Spring注入的Bean呢?當然,這需要我們進行編程式的聲明,眾所周知,在Strus的Action里面有一個setServlet方法,我們此時就需要覆蓋這個方法,當ActionServlet把請求轉發到此Action時,Action就可以實用Spring的特性。

    示例代碼如下:

     

    java 代碼
    1. import org.springframework.context.ApplicationContext;   
    2. import org.springframework.web.context.support.WebApplicationContextUtils;   
    3.   
    4. public void setServlet(ActionServlet actionServlet) {   
    5.         try {   
    6.             super.setServlet(actionServlet);   
    7.              ServletContext servletContext = actionServlet.getServletContext();   
    8.              context = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);   
    9.          } catch(Exception e) {   
    10.              e.printStackTrace();   
    11.          }   
    12.      }  

     

    其中context是ApplicationContext的實例,有了上串代碼以后我們就可以以下面的方式進行Spring的特性利用了!

    java 代碼
    1. protected IXjdjService getXjdjServiceImp(){   
    2.         return (IXjdjService) context.getBean("xjdj");   
    3.      }  

    到此OK,Struts與Spring的整合成功。

    2 Spring+Hibernate

    可以說Spring與Hibernate的整合是非常完善的,具體要素如下:

    在Hibernate中,最重要的無非就是兩點,一是配置數據庫連接池,二是配置實體類的映射文件?,F在我貼出上述兩點在Spring里面是怎么配的,配置完畢以后,我們完全可以刪除hibernate.cfg.xml文件。示例代碼如下:

    xml 代碼
    1. <bean id="dataSource"     
    2.         class="org.springframework.jdbc.datasource.DriverManagerDataSource">     
    3.         <property name="driverClassName">     
    4.             <value>com.microsoft.jdbc.sqlserver.SQLServerDriver</value>     
    5.         </property>     
    6.         <property name="url">     
    7.             <value>jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=EXAM</value>     
    8.         </property>     
    9.         <property name="username">     
    10.             <value>sa</value>     
    11.         </property>     
    12.         <property name="password">     
    13.             <value>135780</value>     
    14.         </property>     
    15.     </bean>     
    16.     <!-- 配置Hibernate會話工廠 -->     
    17.     <bean id="sessionFactory"     
    18.         class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">     
    19.         <property name="dataSource">     
    20.             <ref bean="dataSource" />     
    21.         </property>     
    22.         <!-- 在此可以配置Hibernate會話工廠的屬性 -->     
    23.         <property name="hibernateProperties">     
    24.             <props>     
    25.                 <prop key="hibernate.dialect">     
    26.                      org.hibernate.dialect.SQLServerDialect      
    27.                 </prop>     
    28.                 <prop key="hibernate.show_sql">true</prop>     
    29.                      
    30.              </props>     
    31.         </property>     
    32.         <!-- 在此可以匹配*.hbm.xml映射文件 -->     
    33.         <property name="mappingDirectoryLocations">     
    34.             <list>     
    35.                 <value>     
    36.                      classpath:/com/wjh/comm/framework/bean      
    37.                 </value>     
    38.                    
    39.             </list>     
    40.         </property>     
    41.         <property name="mappingResources">  
    42.            <list>  
    43.                 <value>com/wjh/example/User.hbm.xml</value>  
    44.           </list>  
    45. </property>  
    46. </bean>   

    OK,到此就完成了Spring+Hibernate的整合,縱觀整個過程,我們可以發現一點,那就是所謂的整合就是他們配置文件的融合,只要抓住這一點,再復雜的程序也會變的簡單。

    網友經常說,我也是這么做的,但是總是不成功。說實在的這個東西理論很簡單,但是實際操作起來確實要費一番周折,大家在整合過程中出現了什么問題,不妨貼出來,我們一起討論討論!

    http://hi.baidu.com/ziheng65/blog/item/0546d01609bedb4f21a4e904.html

    posted @ 2008-06-13 13:45 飛飛 閱讀(263) | 評論 (0)編輯 收藏

    最近,在 bartsandbox 上,有人問我在 WebLogic 上配置 Hibernate 的具體步驟。您可能知道, Hibernate 是一個非常流行的開源對象關系映射 (Object Relational Mapping , ORM) 工具。下面是在 WebLogic 8.1 上配置 Hibernate 的具體步驟:
      
      首先要創建一個域。我創建了一個 WebLogic Workshop (WLW) 域,因為我打算使用 WLW 來創建和實現應用程序。
      
      將 hibernate...\lib\antlr-2.7.5H3.jar 添加到 PRE_CLASSPATH ,或者在 hibernate.cfg.XML 文件中將 query.factory_class 屬性設為 user 2.x's query factory 。
      
      WLW 域還啟動了一個 PointBase 數據庫實例。我將使用這個內置實例。我創建了一個新的用戶和模式。并為該模式填充了一些示例數據。
      
      在服務器實例中配置連接池和數據源。
      
      創建應用程序。我打算使用 WebLogic Workshop 創建。
      
      應該將庫( jar 文件)(它們是成功運行 Hibernate 所必需的)放在哪里呢?放在應用程序的 APP-INF/lib 文件夾中。庫包括 hibernate.jar 和附加的第三方庫。引用 Hibernate Reference 的表格 3-1 。
      
      在 WLW 中創建一個 Java 項目。該 Java 項目包括映射到數據庫的域類。 WLW 編譯該項目,并將生成的 jar 文件放到 APP-INF/lib 目錄下。在 Java 項目中編碼域類。創建 Hibernate 映射文件和 Hibernate 配置文件。此外,從 Hibernate Reference 復制實現,創建 HibenateUtil 類。 Hibernate 配置文件包括數據源的 JNDI 名。
      
      創建一個 EJB 對象(例如,一個模塊)。該項目包含了會話 bean 。編寫一個操縱域類的會話 bean 。
      
      創建一個 Web 或 Web Service 項目(例如,一個模塊)。該項目包含了可互操作性地測試會話 bean 的組件。
      
      完整、有效、自包含的示例應用程序 在此 。其中包括了模式和所有的 Hibernate 配置文件。(注:需要有 bartsandbox 的免費會員資格。)

    http://www.knowsky.com/365592.html
    posted @ 2008-06-13 09:17 飛飛 閱讀(214) | 評論 (0)編輯 收藏

    Spring MVC 框架。用銀行示例介紹如何建模和構建簡單的應用程序。示例應用程序包含了已經學過的一些技術(例如依賴注入),但是主要演示 Spring MVC 的特性。
      
      在開始之前,請 下載這篇文章的源代碼。請參閱 參考資料 訪問 Spring 框架和 Tomcat 5.0,運行示例需要它們。
      
      Spring MVC 框架
      
      Spring 框架提供了構建 Web 應用程序的全功能 MVC 模塊。使用 Spring 可插入的 MVC 架構,可以選擇是使用內置的 Spring Web 框架還是 Struts 這樣的 Web 框架。通過策略接口,Spring 框架是高度可配置的,而且包含多種視圖技術,例如 JavaServer Pages(JSP)技術、Velocity、Tiles、iText 和 POI。Spring MVC 框架并不知道使用的視圖,所以不會強迫您只使用 JSP 技術。Spring MVC 分離了控制器、模型對象、分派器以及處理程序對象的角色,這種分離讓它們更容易進行定制。
      
      Spring 的 Web MVC 框架是圍繞 DispatcherServlet 設計的,它把請求分派給處理程序,同時帶有可配置的處理程序映射、視圖解析、本地語言、主題解析以及上載文件支持。默認的處理程序是非常簡單的 Controller 接口,只有一個方法 ModelAndView handleRequest(request, response)。Spring 提供了一個控制器層次結構,可以派生子類。如果應用程序需要處理用戶輸入表單,那么可以繼承 AbstractFormController。如果需要把多頁輸入處理到一個表單,那么可以繼承 AbstractWizardFormController。
      
      示例應用程序有助于直觀地學習這些特性。銀行應用程序允許用戶檢索他們的帳戶信息。在構建銀行應用程序的過程中,可以學到如何配置 Spring MVC 框架和實現框架的視圖層,視圖層包括 JSTL 標記(用于顯示輸出的數據)和JavaServer Pages 技術。
      
      配置 Spring MVC
      
      要開始構建示例應用程序,請配置 Spring MVC 的 DispatcherServlet。請在 web.xml 文件中注冊所有配置。清單 1 顯示了如何配置 sampleBankingServlet。
      
      清單 1. 配置 Spring MVC DispatcherServlet
      
      <servlet>
      <servlet-name>sampleBankingServlet</servlet-name>
      <servlet-class>
      org.springframework.we.servlet.DispatcherServlet
      <servlet-class>
      <load-on-startup>1<load-on-startup>
      <servlet>
      
      DispatcherServlet 從一個 XML 文件裝入 Spring 應用程序上下文,XML 文件的名稱是 servlet 的名稱后面加上 -servlet 。在這個示例中,DispatcherServlet 會從 sampleBankingServlet-servlet.xml 文件裝入應用程序上下文。
      
      配置應用程序的 URL
      
      下一步是配置想讓 sampleBankingServlet 處理的 URL。同樣,還是要在 web.xml 中注冊所有這些信息。
      
      清單 2. 配置想要處理的 URL
      
      <servlet-mapping>
      <servlet-name> sampleBankingServlet<servlet-name>
      <url-pattern>*.jsp</url-pattern>
      </servlet-mapping>
      
      裝入配置文件
      
      下面,裝入配置文件。為了做到這點,請為 Servlet 2.3 規范注冊 ContextLoaderListener 或為 Servlet 2.2 及以下的容器注冊 ContextLoaderServlet。為了保障后向兼容性,請用 ContextLoaderServlet。在啟動 Web 應用程序時,ContextLoaderServlet 會裝入 Spring 配置文件。清單 3 注冊了 ContextLoaderServlet。
      
      清單 3. 注冊 ContextLoaderServlet
      
      <servlet>
      <servlet-name>context>servlet-name>
      <servlet-class>
      org.springframework.web.context.ContextLoaderServlet
      </servlet-class>
      <load-on-startup>1</load-on-startup>
      </servlet>
      
      contextConfigLocation 參數定義了要裝入的 Spring 配置文件,如下面的 servlet 上下文所示。
      
      <context-param>
      <param-value>contextConfigLocation</param-value>
      <param-value>/WEB-INF/sampleBanking-services.xml</param-value>
      </context-param>
      
      sampleBanking-services.xml 文件代表示例銀行應用程序服務的配置和 bean 配置。如果想裝入多個配置文件,可以在 <param-value> 標記中用逗號作分隔符。
      
      Spring MVC 示例
      
      示例銀行應用程序允許用戶根據惟一的 ID 和口令查看帳戶信息。雖然 Spring MVC 提供了其他選項,但是我將采用 JSP 技術作為視圖頁面。這個簡單的應用程序包含一個視圖頁用于用戶輸入(ID 和口令),另一頁顯示用戶的帳戶信息。
      
      我從 LoginBankController 開始,它擴展了 Spring MVC 的 SimpleFormController。SimpleFormContoller 提供了顯示從 HTTP GET 請求接收到的表單的功能,以及處理從 HTTP POST 接收到的相同表單數據的功能。LoginBankController 用 AuthenticationService 和 AccountServices 服務進行驗證,并執行帳戶活動。“ 配置視圖屬性 ”一節中的 清單 5 描述了如何把 AuthenticationService 和 AccountServices 連接到 LoginBankController。 清單 4 顯示了 LoginBankController 的代碼。
     

    清單 4. LoginBankController 擴展 SimpleFormController

    public class LoginBankController extends SimpleFormController {

       public LoginBankController(){

       }

       protected ModelAndView onSubmit(Object command) throws Exception{

          LoginCommand loginCommand = (LoginCommand) command;
          authenticationService.authenticate(loginCommand);
          AccountDetail accountdetail = accountServices.getAccountSummary(loginCommand.getUserId());
          return new ModelAndView(getSuccessView(),"accountdetail",accountdetail);
       }

       private AuthenticationService authenticationService;

       private AccountServices accountServices;

       public AccountServices getAccountServices() {
          return accountServices;
       }

       public void setAccountServices(AccountServices accountServices) {
          this.accountServices = accountServices;
       }

       public AuthenticationService getAuthenticationService() {
          return authenticationService;
       }

       public void setAuthenticationService(
             AuthenticationService authenticationService) {
          this.authenticationService = authenticationService;
       }
    }

     
      配置視圖屬性
      
      下面,我必須注冊在接收到 HTTP GET 請求時顯示的頁面。我在 Spring 配置中用 formView 屬性注冊這個頁面,如清單 5 所示。sucessView 屬性代表表單數據提交而且 doSubmitAction() 方法中的邏輯成功執行之后顯示的頁面。formView 和 sucessView 屬性都代表被定義的視圖的邏輯名稱,邏輯名稱映射到實際的視圖頁面。
      
      清單 5. 注冊 LoginBankController
      
      <bean id="loginBankController"
      class="springexample.controller.LoginBankController">
      <property name="sessionForm"><value>true</value></property>
      <property name="commandName"><value>loginCommand</value></property>
      <property name="commandClass">
      <value>springexample.commands.LoginCommand</value>
      </property>
      
      <property name="authenticationService">
      <ref bean="authenticationService" />
      </property>
      <property name="accountServices">
      <ref bean="accountServices" />
      </property>
      <property name="formView">
      <value>login</value>
      </property>
      <property name="successView">
      <value>accountdetail</value>
      </property>
      
      </bean>
      
      commandClass 和 commandName 標記決定將在視圖頁面中活動的 bean。例如,可以通過 login.jsp 頁面訪問 loginCommand bean,這個頁面是應用程序的登錄頁面。一旦用戶提交了登錄頁面,應用程序就可以從 LoginBankController 的 onSubmit() 方法中的命令對象檢索出表單數據。
      
      視圖解析器
      
      Spring MVC 的 視圖解析器 把每個邏輯名稱解析成實際的資源,即包含帳戶信息的 JSP 文件。我用的是 Spring 的 InternalResourceViewResolver,如 清單 6 所示。

    清單 6. InternalResourceViewResolver

    <bean id="view-Resolver"
          class="org.springframework.web.servlet.view.InternalResourceViewResolver">
       <property name="viewClass">
          <value>org.springframework.web.servlet.view.JstlView</value>
       </property>
       <property name="prefix"><value>/jsp/</value></property>
       <property name="suffix"><value>.jsp</value></property>
    </bean>


      因為我在 JSP 頁面中使用了 JSTL 標記,所以用戶的登錄名稱解析成資源 /jsp/login.jsp,而 viewClass 成為 JstlView。
      
      驗證和帳戶服務
      
      就像前面提到的,LoginBankController 內部連接了 Spring 的 AccountServices 和 AuthenticationService。AuthenticationService 類處理銀行應用程序的驗證。AccountServices 類處理典型的銀行服務,例如查找交易和電匯。清單 7 顯示了銀行應用程序的驗證和帳戶服務的配置。
      
      清單 7. 配置驗證和帳戶服務
      
      <beans>
      
      <bean id="accountServices"
      class="springexample.services.AccountServices">
      
      </bean>
      
      <bean id="authenticationService"
      class="springexample.services.AuthenticationService">
      
      </bean>
      
      </beans>
      
      以上服務在 sampleBanking-services.xml 中注冊,然后裝入 web.xml 文件中,就像 前面討論的那樣。控制器和服務配置好后,這個簡單的應用程序就完成了?,F在我們來看看部署和測試它時會發生什么!
      
      部署應用程序
      
      我把示例應用程序部署在 Tomcat servlet 容器中。Tomcat 是 Java Servlet 和 Java ServerPagest 技術的官方參考實現中使用的 servlet 容器。如果以前沒這么做過,請 下載 jakarta-tomcat-5.0.28.exe 并運行它把 Tomcat 安裝到自己喜歡的任何位置,例如 c:\tomcat5.0。
      
      接下來,下載示例代碼 并釋放到驅動器(例如 c:\ )上。創建了 Spring 項目的文件夾之后,打開它并把 spring-banking 子文件夾拷貝到 c:\tomvat5.0\webapps。spring-banking 文件夾是一個 Web 檔案,里面包含 Spring MVC 示例應用程序。lib 文件夾包含應用程序需要的 Spring 框架、與Spring 相關的 MVC 庫以及 JSTL 標記庫和 jar 文件。
      
      要啟動 Tomcat 服務器,請使用以下命令:
      
      cd bin C:\Tomcat 5.0\bin> catalina.bat start
      Tomcat 應當啟動并部署 Spring MVC 示例應用程序。
      
      測試應用程序
      
      要測試應用程序,請打開 Web 瀏覽器,指向 http://localhost:tomcatport/springbanking 并用 Tomcat 服務器實際運行的端口替換 tomcatport。應當看到圖 1 所示的登錄屏幕。輸入用戶 ID “admin”和口令“password”,并按下登錄按鈕。其他用戶 ID 或口令會造成來自驗證服務的錯誤。
      
      圖 1. Spring MVC 示例登錄屏幕


    登錄成功之后,會看到圖 2 所示的帳戶細節頁面。
      
      圖 2. Spring MVC 示例帳戶細節頁面
      


      結束語
      
      在三部分的 Spring 系列 的第三篇文章中,我介紹了 Spring MVC 框架的特性。我演示了如何配置和開發 Spring MVC 應用程序、如何配置 Spring MVC 控制器和向其中插入依賴項、如何用 JavaServer Pages 技術開發應用程序視圖,以及如何把自己的頁面與 Spring MVC 的視圖層集成??偨Y這篇文章時,我演示了如何在 Tomcat servlet 容器中部署應用程序以及如何在瀏覽器中測試它。

    posted @ 2008-06-12 23:48 飛飛 閱讀(330) | 評論 (0)編輯 收藏

    本文是開發基于spring的web應用的入門文章,前端采用Struts MVC框架,中間層采用spring,后臺采用Hibernate。

      本文包含以下內容:

       ·配置Hibernate和事務

       ·裝載Spring的applicationContext.xml文件

       ·建立業務層和DAO之間的依賴關系

       ·將Spring應用到Struts中

      簡介

      這個例子是建立一個簡單的web應用,叫MyUsers,完成用戶管理操作,包含簡單的數據庫增,刪,查,該即CRUD(新建,訪問,更新,刪除)操作。這是一個三層的web應用,通過Action(Struts)訪問業務層,業務層訪問DAO。圖一簡要說明了該應用的總體結構。圖上的數字說明了流程順序-從web(UserAction)到中間層(UserManager),再到數據訪問層(UserDAO),然后將結果返回。

      Spring層的真正強大在于它的聲明型事務處理,幫定和對持久層支持(例如Hiberate和iBATIS)

      以下下是完成這個例子的步驟:

      1. 安裝Eclipse插件

      2. 數據庫建表

      3. 配置Hibernate和Spring

      4. 建立Hibernate DAO接口的實現類

      5. 運行測試類,測試DAO的CRUD操作

      6. 創建一個處理類,聲明事務

      7. 創建web層的Action和model

      8. 運行Action的測試類測試CRUD操作

      9. 創建jsp文件通過瀏覽器進行CRUD操作

      10. 通過瀏覽器校驗jsp

      安裝eclipse插件

      1. Hibernate插件http://www.binamics.com/hibernatesync

      2. Spring插件http://springframework.sourceforge.net/spring-ide/eclipse/updatesite/

      3. MyEclipse插件(破解版)

      4. Tomcat插件. tanghan

      5. 其他插件包括xml,jsp,

      數據庫建表


    create table app_user(id number not null primary,firstname vchar(32),lastname vchar(32));

      新建項目

      新建一個web project,新建后的目錄結構同時包含了新建文件夾page用于放jsp文件,和源文件夾test用于放junit測試文件。同時將用到的包,包括struts,hibernate,spring都導入到lib目錄下。

      創建持久層O/R mapping

      1. 在src/com.jandar.model下用hibernate插件從數據庫導出app_user的.hbm.xml文件改名為User.hbm.xml

    <?xml version="1.0"?>
    <!DOCTYPE hibernate-mapping PUBLIC
       "-//Hibernate/Hibernate Mapping DTD//EN"
       "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >
    <hibernate-mapping package="com.jandar.model">
    <class name="User" table="APP_USER">
    ?。糹d
      column="ID"
      name="id"
      type="integer"
    ?。?br />
     ?。糶enerator class="assigned" />

    ?。?id>

     <property
       column="LASTNAME"
       length="10"
       name="lastname"
       not-null="false"
       type="string"
     />

     <property
       column="FIRSTNAME"
       length="10"
       name="firstname"
       not-null="true"
       type="string"
     />

    </class>
    </hibernate-mapping>

      2. 通過hibernate synchronizer->synchronizer file生成User.java文件,User對象對應于數據庫中的app_user表

      注:在eclipse下自動生成的對象文件不完全相同,相同的是每個對象文件必須實現Serializable接口,必需又toString和hashCode方法;

    import java.io.Serializable;
    import org.apache.commons.lang.builder.EqualsBuilder;
    import org.apache.commons.lang.builder.HashCodeBuilder;
    import org.apache.commons.lang.builder.ToStringBuilder;
    import org.apache.commons.lang.builder.ToStringStyle;

    public class BaseObject implements Serializable {
     public String toString() {
      return ToStringBuilder.reflectionToString(this,
      ToStringStyle.MULTI_LINE_STYLE);
     }

     public boolean equals(Object o) {
      return EqualsBuilder.reflectionEquals(this, o);
     }

     public int hashCode() {
      return HashCodeBuilder.reflectionHashCode(this);
     }
    }

    public class User extends BaseObject {
     private Long id;
     private String firstName;
     private String lastName;

     /**
     * @return Returns the id.
     */

     public Long getId() {
      return id;
     }

     /**
      * @param id The id to set.
     */

     public void setId(Long id) {
      this.id = id;
     }

     /**
     * @return Returns the firstName.
     */

     public String getFirstName() {
      return firstName;
     }

     /**
      * @param firstName The firstName to set.
     */

     public void setFirstName(String firstName) {
      this.firstName = firstName;
     }

     /**
     * @return Returns the lastName.
     */

     public String getLastName() {
      return lastName;
     }

     /**
     * @param lastName The lastName to set.
     */

     public void setLastName(String lastName) {
      this.lastName = lastName;
     }
    }

    創建DAO訪問對象

      1. 在src/com.jandar.service.dao新建IDAO.java接口,所有的DAO都繼承該接口

    package com.jandar.services.dao;

    public interface IDAO {

    }

      2. 在src/com.jandar.service.dao下新建IUserDAO.java接口

    public interface IUserDAO extends DAO {
     List getUsers();
     User getUser(Integer userid);
     void saveUser(User user);
     void removeUser(Integer id);
    }

      該接口提供了訪問對象的方法,

      3. 在src/com.jandar.service.dao.hibernate下新建UserDAOHiberante.java

    import java.util.List;
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.springframework.orm.hibernate.support.HibernateDaoSupport;
    import com.jandar.model.User;
    import com.jandar.service.dao.IUserDAO;

    public class UserDaoHibernate extends HibernateDaoSupport implements IUserDAO {

     private Log log=LogFactory.getLog(UserDaoHibernate.class);
     /* (非 Javadoc)
     * @see com.jandar.dao.IUserDAO#getUsers()
     */

     public List getUsers() {
      return getHibernateTemplate().find("from User");
     }

     /* (非 Javadoc)
     * @see com.jandar.dao.IUserDAO#getUser(java.lang.Long)
     */

     public User getUser(Integer id) {
      // TODO 自動生成方法存根
      return (User) getHibernateTemplate().get(User.class,id);
     }

     /* (非 Javadoc)
     * @see com.jandar.dao.IUserDAO#saveUser(com.jandar.model.User)
     */

     public void saveUser(User user) {
      log.debug("xxxxxxx");
      System.out.println("yyyy");
      getHibernateTemplate().saveOrUpdate(user);
      if(log.isDebugEnabled())
      {
       log.debug("userId set to "+user.getId());
      }
     }

     /* (非 Javadoc)
     * @see com.jandar.dao.IUserDAO#removeUser(java.lang.Long)
     */

     public void removeUser(Integer id) {
      Object user=getHibernateTemplate().load(User.class,id);
      getHibernateTemplate().delete(user);
      if(log.isDebugEnabled()){
       log.debug("del user "+id);
      }
     }
    }

      在這個類中實現了IUserDAO接口的方法,并且繼承了HibernateDAOSupport類。這個類的作用是通過hibernate訪問、操作對象,進而實現對數據庫的操作。
    posted @ 2008-06-12 23:17 飛飛 閱讀(487) | 評論 (0)編輯 收藏

    這里主要講在Eclipse下如何搭配Spring MVC + Hibernate框架進行Web開發,至于Eclipse以及JDK以及MyEclipse等的安裝不在此列,也不使用MyEclipse來搭建,只是手工搭建的方式。

    1.版本

    JDK1.50;Eclipse3.2;MyEclipse 5.0;Tomcat 5.0;Spring2.0;Hibernate3.2。

    2.準備

    安裝好Eclipse和JDK環境,由于不使用MyEclipse,需要自行準備兩個主要的包:Spring.jar包、Hibernate3.jar,還有commons-dbcp.jar,commons-pool.jar,spring-orm.jar等這些包;這些表都可以在相應的項目網站中下載到,或者網上搜索。

    安裝好后Lib下包會有:

    activation.jar

    antlr-2.7.6.jar

    asm.jar

    cglib-2.1.3.jar

    commons-beanutils.jar

    commons-collections.jar

    commons-collections-2.1.1.jar

    commons-digester.jar

    commons-fileupload.jar

    commons-logging.jar

    commons-logging-1.0.4.jar

    commons-validator.jar

    dom4j-1.6.1.jar

    ehcache-1.2.jar

    jakarta-oro.jar

    jstl.jar

    jta.jar

    log4j-1.2.11.jar

    mail.jar

    ojdbc14.jar

    standard.jar

    以下幾個是比較重要的:

    commons-dbcp.jar

    commons-pool.jar

    hibernate3.jar

    spring.jar

    spring-orm.jar

    如果要用到Struts,會有一個struts.jar包。

    3.搭建:

    首先在"File"菜單下"new" 一個"Project",選擇"Other"下的MyEclipse下的"Web Project",把上面的包放到WebRoot/WEB-INF/lib下;

    建立好工程后,我們在項目下的WebRoot/WEB-INF/下新建兩個.xml文件,名字可以隨便起(也可新建一個,內容和兩個文件里面的內容一樣即可),在這里命名為web-config.xml和model-config.xml,顧名思義,web-config.xml下配置和servlet以及控制邏輯等與WEB相關的bean,model-config.xml下配置與數據模型層相關的Bean,如數據訪問的bean。

    以下是model-config.xml內容:

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns=" xmlns:xsi=" xsi:schemaLocation="http://www.springframework.org/schema/beans

        <!-- 設定數據庫連接池相關參數,這里使用的是Oracel的數據庫 -->
        <bean id="dataSource"
        class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close">
       <property name="driverClassName">
        <value>oracle.jdbc.driver.OracleDriver</value>
       </property>
       <property name="url">
        <value>jdbc:oracle:thin:@192.168.6.4:1521:database</value>
       </property>
       <property name="username">
        <value>username</value>
       </property>
       <property name="password">
        <value>password</value>
       </property>
    </bean>
       
        <!-- 定義Hibernate sessionFactory 和Hibernate映射文件,所有的Hibernate映射文件統一在這里定義 -->
        <bean id="sessionFactory"
              class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"
              destroy-method="destroy">
            <property name="dataSource" ref="dataSource"/>
            <property name="mappingResources">
                <list>
    <!-- Hibernate映射文件 把Hibernate的配置文件在這里映射,這里定義了一個UUser類的持久化類映射文件 -->
                    <value>com/yondor/yuejiao/orm/UUser.hbm.xml</value>
                </list>
            </property>
            <property name="hibernateProperties">
                <props>
                    <prop key="hibernate.dialect">
                        org.hibernate.dialect.Oracle9Dialect
                    </prop>
                </props>
            </property>
        </bean>
       
        <!-- Spring hibernateTemplate 模板定義 -->
        <bean id="hibernateTemplate"
              class="org.springframework.orm.hibernate3.HibernateTemplate">
            <property name="sessionFactory" ref="sessionFactory"/>
        </bean>
          

    <!-- Hibernate數據模型Bean定義 -->        
        <bean id="dbDAO"
               class="com.yondor.yuejiao.model.common.DbDAO">
            <property name="hibernateTemplate" ref="hibernateTemplate"/>
        </bean>


    <!-- 以下是業務邏輯Bean的定義 -->

    <!-- User模塊開始 定義的bean可以在web-config.xml配置文件中使用-->
        <bean id="userDAO"
               class="com.yondor.yuejiao.model.example.UserDAO">
            <property name="dbDAO" ref="dbDAO"/>
         </bean>  
        <!-- User模塊結束 -->

    </beans>

     

    以下是web-config.xml的內容:

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="
    xmlns:xsi=" xsi:schemaLocation="http://www.springframework.org/schema/beans
      
       <!-- Controller方法調用規則定義 -->
        <bean id="paraMethodResolver"
            class="org.springframework.web.servlet.mvc.multiaction.ParameterMethodNameResolver">
            <property name="paramName" value="action"/>
            <property name="defaultMethodName" value="list"/>
        </bean>
      
       <!-- 頁面View層基本信息設定 -->
        <bean id="viewResolver"
              class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="viewClass"
                value="org.springframework.web.servlet.view.JstlView"/>
            <property name="prefix" value="/yuejiao/"/>
            <property name="suffix" value=".jsp"/>
        </bean>

     

    <!-- servlet映射列表,所有控制層Controller的servlet在這里定義 -->
        <bean id="urlMapping"
              class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
            <property name="mappings">
                <props>
                    <prop key="example.do">userController</prop>
                </props>
            </property>
        </bean>


    <!-- 以下控制層Controller Bean定義開始 -->

    <!-- User模塊開始 -->
    <!-- 一共注入了7個屬性(Bean),其中userDAO為業務邏輯Bean,該Bean定義在model-config.xml相應的模塊中 -->
        <bean id="userController"
                    class="com.yondor.yuejiao.controller.example.UserController">
            <property name="methodNameResolver" ref="paraMethodResolver"/>

           <!-- 使用了在model-config.xml文件里定義userDAO-->
            <property name="userDAO" ref="userDAO"/>
            <!-- 以下的屬性與處理后的跳轉有有關 -->
            <property name="login_success" value="example/login_success"/>
            <property name="login_failure" value="example/login"/>
            <property name="register_success" value="example/register_success"/>
            <property name="register_failure" value="example/register"/>
            <property name="userInfoList" value="example/list"/>
        </bean>
        <!-- User模塊結束 -->
       
       
        
    </beans>

     

    最后,還需要配置一下web.xml文件,內容如下:

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="
    xmlns:xsi=" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee version="2.4">

        <session-config>
            <session-timeout>
                30
            </session-timeout>
        </session-config>

        <servlet>
            <servlet-name>dispatcherServlet</servlet-name>
            <servlet-class>
                org.springframework.web.servlet.DispatcherServlet
            </servlet-class>
            <init-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>/WEB-INF/model-config.xml,/WEB-INF/web-config.xml</param-value>
            </init-param>
            <load-on-startup>1</load-on-startup>
        </servlet>

        <servlet-mapping>
            <servlet-name>dispatcherServlet</servlet-name>
            <url-pattern>*.do</url-pattern>
        </servlet-mapping>
    </web-app>

     

    到此,基本上已完成開發環境的搭建,最后,

    右鍵單擊項目名稱——properties——java bulid path ——libraries,Add Jars把剛才加入的包引入到工程里面去即可。

     

    資料來源:http://hi.baidu.com/lhx222/blog/item/3fc769cb4b4ae01bbe09e67a.html

    posted @ 2008-06-12 16:34 飛飛 閱讀(5097) | 評論 (0)編輯 收藏

    Struts+Spring+Hibernate
      本次配置環境:Myeclipse5.5、MySQL5.0、Struts1.2、Spring2.0、Hibernate3.1
      一、建工程
      略。。。。。。
      二、要使用Struts、Spring、Hibernate必須導入必需的包
      1、Struts(和之前沒區別)
      2、Spring
         分別導入Spring 2.0 Core Libraries、Spring 2.0 Web Libraries
         選擇把*.jar Copy到工程/WebRoot/WEB-INF/lib下; 點擊NEXT
         選擇applicationContext.xml的目錄,/WebRoot/WEB-INF;點擊finish
      3、Hibernate
         在導入Hibernate時,當然先要配置DataSource咯,這里就不再說了
         選擇導入Hibernate全選上
         選上復選框:Hibernate 3.1 Core......、Hibernate 3.1 Advanced......、Spring 2.0 ORM/DAO.......
         同樣選擇把*.jar Copy到工程/WebRoot/WEB-INF/lib下; 點擊NEXT
         這里我們選擇把hibernate交給spring去管理
      選中單選按鈕 Spring configuration file...... 點擊NEXT
         選擇已存在的applicationContext.xml文件,
         填寫SessionFactory ID :sessionFactory 點擊NEXT
         這里我們需要填寫Bean Id :dataSource
         選擇 DB Driver :選擇剛才配置的DataSource 點擊NEXT
         這里不需要創建 SessionFactory Class 點擊Finish
         注意:查看applicationContext.xml的變化
      三、映射VO、數據操作
      首先工程的結構建好,比較簡單的結構:
      org.chenwj.dao
      org.chenwj.struts
      org.chenwj.struts.action
      org.chenwj.struts.form
      org.chenwj.vo
      映射表userinfo創建持久類到org.chenwj.vo目錄
      在dao下創建數據庫操作類 UserDAO 這里只是對數據庫進去插入,代碼如下:
      private SessionFactory sessionFactory;

          public SessionFactory getSessionFactory() ...{
             return sessionFactory;
          }
          public void setSessionFactory(SessionFactory sessionFactory) ...{
             this.sessionFactory = sessionFactory;
          }
          /**//* 用戶注冊 */
          public boolean regist(Userinfo user) ...{
             try ...{
                 Session session = sessionFactory.openSession();
                 Transaction tx = session.beginTransaction();
                 session.save(user);
                 tx.commit();
                 session.close();
                 return true;
             } catch (Exception ex) ...{
                 ex.printStackTrace();
                 return false;
                    }
             }
          使用依賴注入,setter設值 sessionFactory
          到此數據層已經完成

      四、配置struts-config.xml
          添加action、form、jsp 略……
          首先在struts-config.xml添加一個插件
          <plug-in
          className="org.springframework.web.struts.ContextLoaderPlugIn">
             <set-property property="contextConfigLocation"
                 value="/WEB-INF/applicationContext.xml" />
          </plug-in>
          為什么要添回這個插件呢?
          因為在后面會在applicationContext.xml下配置action,讓action交給spring
          去管理,實現了struts的依賴注入機制
          接下來添加cuntroller,這里你可以使用DelegatingActionProxy代理
          <controller processorClass=
          "org.springframework.web.struts.DelegatingRequestProcessor"/>
          Controller取代了struts的RequestProcessor,在定義action里,我們可以省略
      type屬性。(我個人比較喜歡用這個)下面讓我們看配置好的struts-config.xml:
      <struts-config>
              <data-sources />
              <form-beans>
                 <form-bean name="userForm"
                 type="org.chenwj.struts.form.UserForm" />
              </form-beans>
          <global-exceptions />
          <global-forwards />
          <action-mappings>
             <action attribute="userForm" input="/index.jsp" name="userForm"
                 path="/user" scope="request">
                 <forward name="success" path="/success.jsp" />
                 <forward name="error" path="/index.jsp" />
             </action><!--type屬性可不寫-->
          </action-mappings>

          <controller processorClass=
      "org.springframework.web.struts.DelegatingRequestProcessor"/>

           <message-resources
             parameter="org.chenwj.struts.ApplicationResources" />
           <plug-in
          className="org.springframework.web.struts.ContextLoaderPlugIn">
             <set-property property="contextConfigLocation"
                 value="/WEB-INF/applicationContext.xml" />
           </plug-in>
      </struts-config>

    五、在applicationContext.xml配置action
          這里我們先在 action類里添加一些業務邏輯,代碼如下:
          public class UserAction extends Action ...{

     

          private UserDAO userDao;
          private Userinfo user;

          public ActionForward execute(ActionMapping mapping, ActionForm form,
             HttpServletRequest request, HttpServletResponse response) ...{
         UserForm userForm = (UserForm) form;
         //封裝數據
         user.setName(userForm.getName());
             user.setPassword(userForm.getPassword());
             if(userDao.regist(user))...{
                 return mapping.findForward("success");
             }
             return mapping.findForward("error");
          }

          public Userinfo getUser() ...{
             return user;
          }
          public void setUser(Userinfo user) ...{
             this.user = user;
          }
          public UserDAO getUserDao() ...{
             return userDao;
          }
          public void setUserDao(UserDAO userDao) ...{
             this.userDao = userDao;
          }}
          這里使用setter實現依賴注入了兩個bean,接下來配置applicationContext.xml
          <beans xmlns="略……">
          <!—- 數據源 -->
          <bean id="dataSource"
             class="org.apache.commons.dbcp.BasicDataSource">
             <property name="driverClassName"
                 value="com.mysql.jdbc.Driver">
             </property>
              <property name="url"
      value="jdbc:mysql://localhost:3306/demo"></property>
             <property name="username" value="root"></property>
             <property name="password" value="root"></property>
          </bean>
          <!--  sessionFactory -->
          <bean id="sessionFactory" class=
      "org.springframework.orm.hibernate3.LocalSessionFactoryBean">
      <property name="dataSource">
                 <ref bean="dataSource" />
             </property>
             <property name="hibernateProperties">
                 <props>
                    <prop key="hibernate.dialect">
                        org.hibernate.dialect.MySQLDialect
                    </prop>
                 </props>
             </property>
             <property name="mappingResources">
                 <list>
                    <value>org/chenwj/vo/Userinfo.hbm.xml</value>
                 </list>
             </property>
          </bean>
          <!--  數據庫操作類  -->
          <bean id="userDao" class="org.chenwj.dao.UserDAO">
             <property name="sessionFactory">
                 <ref local="sessionFactory" />
             </property>
          </bean>
          <!--  action需要注意:這里是name屬性不是ID,同時要和struts-config.xml
            對應的 action path屬性值相同,斜線也是必需的,通過這個屬性scope=
            "prototype" 每次獲取bean實例時都會產生新的實例,默認是單例-->
          <bean name="/user" class="org.chenwj.struts.action.UserAction"
             abstract="false" lazy-init="default" autowire="default"
             scope="prototype" dependency-check="default">
             <property name="userDao" ref="userDao" />
             <property name="user" ref="user" />
          </bean>
          <bean id="user" class="org.chenwj.vo.Userinfo" abstract="false"
             lazy-init="default" autowire="default"
               dependency-check="default">
          </bean>
      </beans>
          到此所有的配置已經完成,測試:
          HTTP Status 404 - Servlet action is not available
      The requested resource (Servlet action is not available) is not available
      這個錯誤是大部初學者整合 SSH 時都會遇到的問題

          首先建議你使用測試類進行測試,這樣我們可以很快找到錯誤所在的地方
      public static void main(String[] args) ...{
          ApplicationContext context = new FileSystemXmlApplicationContext(
                    "/WebRoot/WEB-INF/applicationContext.xml");
              UserDAO dao = (UserDAO)context.getBean("userDao");
             Userinfo user = new Userinfo();
             user.setName("aaa");
             user.setPassword("bbb");
             boolean a = dao.regist(user);
             if(a)...{
                 System.out.println("OK");
             }
         }
      如果這里沒出錯,那么請你好好檢查你的配置文件,是否寫錯或少了些什么東東了
          這里出的錯誤也跟使用的版本有關系,這里報的錯一般都是說找不到XX類所報的異常
      那么請檢查lib下有沒commons-pool-1.2.jar包,如沒請導入,這個問題也有可能是包
      之間的****,刪除這個包hibernate-annotations.jar

      六、.sql文件、.jsp文件
      create table userinfo(
             id int(10) not null auto_increment,
     name varchar(20),
     password varchar(20),
     PRIMARY KEY  (id))
         <body>
            <html:form action="/user">
                name : <html:text property="name"/><br/>
                password : <html:password property="password"/><br/>
                <html:submit/><html:cancel/>
            </html:form>
         </body>

    posted @ 2008-06-12 15:56 飛飛 閱讀(561) | 評論 (0)編輯 收藏

    僅列出標題
    共12頁: First 上一頁 4 5 6 7 8 9 10 11 12 下一頁 
    主站蜘蛛池模板: 亚洲午夜成激人情在线影院| 无码天堂va亚洲va在线va| 18禁无遮挡无码网站免费| 美女隐私免费视频看| 在线观看亚洲av每日更新| 18禁止观看免费私人影院| 国产亚洲视频在线观看网址| 亚洲AV无码不卡无码| 国产精彩免费视频| 曰批免费视频播放在线看片二| 国产亚洲婷婷香蕉久久精品| 国产免费久久精品99re丫y| 人妻巨大乳hd免费看| 亚洲中文久久精品无码1 | 91香蕉视频免费| 高潮毛片无遮挡高清免费视频| 久久久久久亚洲精品成人| 免费一级一片一毛片| 99久久免费国产香蕉麻豆| 国产精品美女免费视频观看| 亚洲无吗在线视频| 亚洲成Av人片乱码色午夜| 日本不卡在线观看免费v| 91精品国产免费入口| 青青久久精品国产免费看| 99热亚洲色精品国产88| 久久精品国产96精品亚洲| 国产午夜免费福利红片| free哆啪啪免费永久| 免费无码又爽又刺激高潮软件 | 永久黄色免费网站| 有码人妻在线免费看片| 亚洲男同gay片| 亚洲一卡2卡3卡4卡国产网站 | 久久国产精品亚洲一区二区| 免费一看一级毛片| 毛片免费视频播放| 4hu四虎最新免费地址| 国色精品va在线观看免费视频 | 日韩在线一区二区三区免费视频 | 天天摸夜夜摸成人免费视频|