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 飛飛 閱讀(183) | 評論 (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 飛飛 閱讀(327) | 評論 (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中,最重要的無非就是兩點,一是配置數據庫連接池,二是配置實體類的映射文件。現在我貼出上述兩點在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 飛飛 閱讀(211) | 評論 (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 文件中,就像 前面討論的那樣。控制器和服務配置好后,這個簡單的應用程序就完成了。現在我們來看看部署和測試它時會發生什么!
            
            部署應用程序
            
            我把示例應用程序部署在 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 的視圖層集成。總結這篇文章時,我演示了如何在 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">
           <id
            column="ID"
            name="id"
            type="integer"
           >

            <generator 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 飛飛 閱讀(486) | 評論 (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 飛飛 閱讀(5095) | 評論 (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 飛飛 閱讀(560) | 評論 (0)編輯 收藏

          僅列出標題
          共12頁: First 上一頁 4 5 6 7 8 9 10 11 12 下一頁 
          主站蜘蛛池模板: 凌源市| 开原市| 滦南县| 彩票| 鹤峰县| 略阳县| 临汾市| 鹤庆县| 兴安县| 宁乡县| 色达县| 晋江市| 四子王旗| 五河县| 旌德县| 景泰县| 榆林市| 荥阳市| 平安县| 隆回县| 邢台县| 宁陵县| 车险| 剑阁县| 中宁县| 宁海县| 遵义县| 伊吾县| 武强县| 嘉善县| 桓台县| 揭东县| 通海县| 德江县| 江北区| 资溪县| 日照市| 海宁市| 邢台县| 饶平县| 白城市|