(友情提示:本文介紹的SSH整合中所需要的完整jar包免費下載地址: http://download.csdn.net/detail/eson_15/9522068

  今天開始做一個網上商城的項目,首先從搭建環境開始,一步步整合S2SH。這篇博文主要總結一下如何整合Struts2 、Hibernate4.3和Spring4.2。

  整合三大框架得先從搭建各部分環境開始,也就是說首先得把Spring,Hibernate和Struts2的環境搭建好,確保它們 沒有問題了,再做整合。這篇博文遵從的順序是:先搭建Spring環境-->然后搭建Hibernate環境--> 整合Spring和 Hibernate --> 搭建Struts2環境 --> 整合Spring和Struts2。

  1. 整個項目jar包的管理

  Spring的jar包很多,開發的時候建議將它們分個類,然后依次添加到User Library,方便管理,也一目了然。這里我 總結一下整個SSH所需要的基本jar包,看下圖:

SSH電商項目實戰之一:整合Struts2、Hibernate和Spring

  從圖中可以看出,首先將Spring的jar分為四類:spring-4.2.4-core、spring-4.2.4-aop、spring-4.2.4-persistence 以及spring-4.2.4-web。將spring的核心包都放到core中,與aop相關的都放到aop中,與持久化(與Hibernate整合)相關的 放到persistence中,與web(與struts2整合)相關的放到web中。每個部分都有哪些jar包呢?請看下面的截圖:

SSH電商項目實戰之一:整合Struts2、Hibernate和SpringSSH電商項目實戰之一:整合Struts2、Hibernate和Spring

  注:以上每個分類的包中,并非包含原來包中所有的jar,有些jar文件并沒有用到,等具體項目需要的時候再往里加 就行了,上圖是保證項目的環境可以搭建所需要的的最基本的jar包。

  2.搭建Spring環境

  上面的jar包截圖是最后整合好的所有jar包,剛開始搭建環境的時候不需要一次性全部加進來,可以一點一點的加, 這樣也更利于理解每個部分的jar包都有什么作用,當然,一次都加進來也是可以的。

  2.1 添加配置文件beans.xml和相應的jar包

  新建一個工程,然后添加在User Library中添加自己的庫,這里主要添加兩個,即spring-4.2.4-core和spring4.2.4- aop,添加jar包不再贅述。添加完了后,在src目錄下添加beans.xml文件,這個文件的模板網上很多,Spring自帶的例子里也 有,考一份過來就行,見下圖:

SSH電商項目實戰之一:整合Struts2、Hibernate和Spring

  2.2 測試Spring的IoC環境

  我們寫一個普通的java類java.util.Date類來測試一下Spring IoC是否正常,如果在測試程序中能正常注入,則說明 Spring的IoC環境搭建成功,下面我們寫一個測試用例:

Java代碼
  1. /**  
  2.  * @Description TODO(采用Spring的注解調試,僅僅支持Spring3.1及以上)  
  3.  * @author Ni Shengwu  
  4.  *  
  5.  */    
  6. /*  
  7.  * Spring3.1后多了個spring-test-4.2.4.RELEASE.jar包,這個jar包專門用來支持JUnit基于注解的測試的,該jar包在spring-4.2.4-core中  
  8.  * 該jar包里有個SpringJUnit4ClassRunner.class,用@RunWith注解加進來即可  
  9.  *   
  10.  * 注解@ContextConfiguration表示將ApplicationContext對象注入進來,就不用像以往那樣在測試程序里先new了,直接使用  
  11.  */    
  12. @RunWith(SpringJUnit4ClassRunner.class)    
  13. @ContextConfiguration(locations="classpath:beans.xml")    
  14. public class SSHTest {    
  15.         
  16.     @Resource    
  17.     private Date date;    
  18.         
  19.     @Test //測試Spring IOC的開發環境    
  20.     public void springIoc() {    
  21.         System.out.println(date);    
  22.     }    
  23. }    

  最后能正常輸出:Thu Apr 28 22:45:13 CST 2016。說明Date對象已經被Spring給注入進來了,從而驗證了Spring IoC功能正常,為此,Spring的環境搭建完成。

  3. 搭建Hibernate環境

  Hibernate的環境搭建相比于Spring要復雜一些,因為用到了MyEclipse中的逆向工程。我們按以下步驟來搭建 Hibernate開發環境:

  3.1 添加相應的jar包

  這里主要是向User Library中添加兩項jar包:hibernate4.3.11和MySQL驅動包mysql-connector-java-5.1.26,不再 贅述。

  3.2 新建數據庫和表

SQL代碼
  1. drop database if exists shop;    
  2. create database shop default character set utf8;    
  3. use shop;    
  4. drop table if exists category;    
  5. create table category    
  6. (    
  7.    /* 類別編號,自動增長 */    
  8.    id  int not null auto_increment,    
  9.    /* 類別名稱 */    
  10.    type varchar(20),    
  11.    /* 類別是否為熱點類別,熱點類別才有可能顯示在首頁*/    
  12.    hot  bool default false,    
  13.    /* 設置類別編號為主鍵*/    
  14.    primary key (id)    
  15. );    

  3.3 DB瀏覽器連接到Mysql數據庫

  DB瀏覽器指的是MyEclipse中的一個視圖窗口,可以很直觀的看到MySQL中都有哪些數據庫和表,打開DB瀏覽器的 方法:Window->Open Perspective->DB Browser打開DB瀏覽器工作窗口。如果沒有DB Browser,按照下面: Window->Show View->other->輸入DB Browser,找到打開即可。

  打開后,我們開始連接到MySQL數據庫了,在DB Browser窗口的空白處右鍵->new,就會彈出下面的對話框:

SSH電商項目實戰之一:整合Struts2、Hibernate和Spring

  填好后,點擊Test Driver測試一下,測試通過表示DataBase connection Driver已經配置好,然后finish即可,這樣 我們就能在DB瀏覽器窗口中看到數據庫MySQL5.6了,右鍵打開就能看到數據庫中已有的庫和表了,如下:

SSH電商項目實戰之一:整合Struts2、Hibernate和Spring

  3.4 創建xml映射文件和sessionFactory

  sessionFactory是用來創建session的,我們通過如下方式創建:工程名右鍵->myeclipse->Add Hibernate Capabilities,如果沒有Add Hibernate Capabilities,就點擊project facets->Install Hibernate Facets,會彈出如下窗口 :

SSH電商項目實戰之一:整合Struts2、Hibernate和Spring

  下一步,在MyEclipse中添加Hibernate Support,即hibernate.cfg.xml映射文件和sessionFactory。這里主要是給 sessionFactory建個包,默認包不行。

SSH電商項目實戰之一:整合Struts2、Hibernate和Spring

  下一步,添加驅動,由于我們之前已經配置好了一個驅動了,所以在這里直接選擇剛剛配置好的即可。

SSH電商項目實戰之一:整合Struts2、Hibernate和Spring

  下一步,由于之前我們已經添加過自己的jar保留,這里不用選擇,直接finish。

SSH電商項目實戰之一:整合Struts2、Hibernate和Spring

  這樣我們就完成了Hibernate配置文件和sessionFactory的創建。下面我們簡單看一下MyEclipse創建的 sessionFactory里面都有啥:

Java代碼
  1. public class HibernateSessionFactory {    
  2.     
  3.     private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>(); //sessionFactory中用的是線程池技術    
  4.     private static org.hibernate.SessionFactory sessionFactory; //sessionFactory:創建session的工廠    
  5.         
  6.     private static Configuration configuration = new Configuration();    
  7.     private static ServiceRegistry serviceRegistry;     
  8.     
  9.     static { //類加載時初始化sessionFactory    
  10.         try {    
  11.         configuration.configure();    
  12.         serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties()).buildServiceRegistry();    
  13.         sessionFactory = configuration.buildSessionFactory(serviceRegistry); //Hibernate4中創建sessionFactory的方法    
  14.     } catch (Exception e) {    
  15.         System.err.println("%%%% Error Creating SessionFactory %%%%");    
  16.         e.printStackTrace();    
  17.     }    
  18.     }    
  19.     private HibernateSessionFactory() { //私有構造方法阻止new出對象,保證sessionFactory的單例    
  20.     }    
  21.         
  22.     public static Session getSession() throws HibernateException {    
  23.         Session session = (Session) threadLocal.get();  //從線程池中拿session    
  24.     
  25.         if (session == null || !session.isOpen()) { //如果線程池是空的,或者session打開失敗    
  26.             if (sessionFactory == null) {    
  27.                 rebuildSessionFactory(); //如果sessionFactory是空的,那就再創建一次,和static部分一樣的    
  28.             }    
  29.             session = (sessionFactory != null) ? sessionFactory.openSession() : null//sessionFactory不為空就創建一個session    
  30.             threadLocal.set(session); //然后把這個session放到線程池中,下次再拿    
  31.         }    
  32.     
  33.         return session;    
  34.     }    
  35.     
  36.     public static void rebuildSessionFactory() {    
  37.     try {    
  38.         configuration.configure();    
  39.         serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties()).buildServiceRegistry();    
  40.         sessionFactory = configuration.buildSessionFactory(serviceRegistry);    
  41.     } catch (Exception e) {    
  42.         System.err.println("%%%% Error Creating SessionFactory %%%%");    
  43.         e.printStackTrace();    
  44.     }    
  45.     }    
  46.     
  47.     public static void closeSession() throws HibernateException {    
  48.         Session session = (Session) threadLocal.get();    
  49.         threadLocal.set(null);    
  50.     
  51.         if (session != null) {    
  52.             session.close();    
  53.         }    
  54.     }    
  55.     
  56.     public static org.hibernate.SessionFactory getSessionFactory() {//提供一個公共接口讓外界獲得這個單例sessionFactory    
  57.     return sessionFactory;    
  58.     }    
  59.     
  60.     public static Configuration getConfiguration() {    
  61.     return configuration;    
  62.     }    
  63.     
  64. }

  從創建的HibernateSessionFactory中可以看出,主要用到了單例模式和線程池技術。也不難理解。

  3.5 通過逆向工程生成model、orm映射文件

  下面開始使用逆向工程創建實例對象了,也就是數據庫的表對應的model。在DB Browsera窗口右擊我們剛剛創建的 表shop,選擇Hibernate Reverse Engineering開始創建:

SSH電商項目實戰之一:整合Struts2、Hibernate和Spring

  創建的時候有兩種方式,基于配置文件的和基于注解的,具體的看開發人員心情了,可以選擇:

SSH電商項目實戰之一:整合Struts2、Hibernate和Spring

  然后下一步,選擇一下native主鍵自增方式,然后便完成了逆向工程創建model和orm映射了。

SSH電商項目實戰之一:整合Struts2、Hibernate和Spring

  完成后,會有Category的model生成,同時在hibernate.cfg.xml文件中也會生成相應的映射,前面基于配置文件的 和基于注解的在hibernate.cfg.xml中生成的映射時不同的。

  3.6 測試Hibernate持久化數據庫

  因為這里還沒有與Spring整合,只是單純的搭建Hibernate開發環境,所以我們沒有必要使用注解,我們通過直接 new一個service的方式執行數據入庫。

  先寫CategoryService接口和實現類:

Java代碼
  1. public interface CategoryService {    
  2.     public void save(Category category); //用來測試Hibernate環境    
  3. }    
  4.     
  5. public class CategoryServiceImpl implements CategoryService {    
  6.     
  7.     @Override //沒有和Spring整合的情況    
  8.     public void save(Category category) {    
  9.         //通過剛剛生成的sessionFactory獲取session    
  10.         Session session = HibernateSessionFactory.getSession();    
  11.         try {    
  12.             //手動事務    
  13.             session.getTransaction().begin();    
  14.             //執行業務邏輯    
  15.             session.save(category);    
  16.             //手動提交    
  17.             session.getTransaction().commit();    
  18.         } catch(Exception e) {    
  19.             session.getTransaction().rollback();    
  20.             throw new RuntimeException(e);    
  21.         } finally {    
  22.             HibernateSessionFactory.closeSession();    
  23.         }           
  24.     }    
  25. }

  下面在剛剛的測試用例中添加對Hibernate的測試:

Java代碼
  1. @RunWith(SpringJUnit4ClassRunner.class)    
  2. @ContextConfiguration(locations="classpath:beans.xml")    
  3. public class SSHTest {    
  4.         
  5.     @Resource    
  6.     private Date date;      
  7.         
  8.     @Test //測試Spring IOC的開發環境    
  9.     public void springIoc() {    
  10.         System.out.println(date);    
  11.     }    
  12.         
  13.     @Test  //測試Hibernate的開發環境,因為沒有整合,可以直接new    
  14.     public void hihernate() {    
  15.         CategoryService categoryService = new CategoryServiceImpl();    
  16.         Category category = new Category("男士休閑"true);    
  17.         categoryService.save(category);    
  18.     }    
  19. }    

  我們查看數據庫,發現多了剛剛插入的這項,說明Hibernate環境沒有問題。至此,Hibernate的開發環境我們就搭 建好了。

  4. 整合Spring和Hibernate

  搭建好了Spring和Hibernate的開發環境后,我們開始整合這兩者。整合Spring和Hibernate后就可以使用AOP讓 Spring來管理Hibernate的事務了。整合Spring和Hibernate主要從兩大方面入手,一是導入必要的jar包,二是配置 beans.xml文件。下面我們一步步整合Spring和Hibernate。

  4.1 導入相應的jar包

  整合Spring和Hibernate時需要導入的jar包有兩大塊,spring4.2.4-persistence和c3p0-0.9.5.1,每一塊jar包中的具 體jar文件請參見上面的截圖,這里不再贅述。下面開始配置beans.xml文件了。

  4.2 配置數據源dataSource

  首先配置一下dataSource,然后hibernate.cfg.xml中相應的部分可以干掉了。因為在Spring中配置好了,Spring會 去初始化這個dataSource,也就是說這就交給Spring來完成了,hibernate.cfg.xml中的相應部分可以刪掉了。如下:

XML/HTML代碼
  1. <!-- com.mchange.v2.c3p0.ComboPooledDataSource類在c3p0-0.9.5.1.jar包的com.mchange.v2.c3p0包中 -->    
  2. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">    
  3.     <property name="driverClass" value="com.mysql.jdbc.Driver" />    
  4.     <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/shop" />    
  5.     <property name="user" value="root" />    
  6.     <property name="password" value="root" />    
  7. </bean>   

  hibernate.cfg.xml中需要干掉的部分:

SSH電商項目實戰之一:整合Struts2、Hibernate和Spring

  4.3 配置sessionFactory

  配置sessionFactory是用來產生一個session的,另外HibernateTemplate也可以,但是這里采用sessionFactory而 不用HibernateTemplate,是因為HibernateTemplate是Spring提供的,依賴于Spring,如果哪天不用Spring了,就會報錯 。而sessionFactory是Hibernate提供的,沒有問題。HibernateTemplate的依賴性太強了。下面看一下具體配置:

XML/HTML代碼
  1. <!-- org.springframework.orm.hibernate4.LocalSessionFactoryBean類在spring-orm-4.2.4.RELEASE.jar包的org.springframework.orm.hibernate4包中 -->    
  2. <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">    
  3.      <property name="dataSource" ref="dataSource" />    
  4.      <property name="configLocation" value="classpath:hibernate.cfg.xml" /> <!-- 加載hibernate配置文件 -->    
  5. </bean>    

  sessionFactory中的dataSource我們用剛剛配好的dataSource,用ref屬性引用進來即可,configLocation我們不在 這配了,直接加載hibernate.cfg.xml文件,使用hibernate配置文件中的配置,更加簡潔方便。

  4.4 配置事務管理器

  配置事務管理器,是用來管理sessionFactory的,這樣所有的由sessionFactory產生的session將會有聲明式的管理。 配置如下:

XML/HTML代碼
  1. <!-- org.springframework.orm.hibernate4.HibernateTransactionManager類spring-orm-4.2.4.RELEASE.jar包的org.springframework.orm.hibernate4包中 -->    
  2. <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">    
  3.      <property name="sessionFactory" ref="sessionFactory" />    
  4. </bean>

  同樣,sessionFactory我們用剛剛配置好的sessionFactory,用ref屬性引用進來即可。到這里就會發現,從上面一直 配下來,都是一連串的操作,一個個引用下來。

  4.5 配置advice(通知)

  配置advice的目的是指定哪些方法需要什么類型的事務模式。看配置:

XML/HTML代碼
  1. <tx:advice id="advice" transaction-manager="transactionManager">    
  2.     <tx:attributes>    
  3.         <tx:method name="save*" propagation="REQUIRED"/>    
  4.         <tx:method name="update*" propagation="REQUIRED"/>    
  5.         <tx:method name="delete*" propagation="REQUIRED"/>    
  6.         <tx:method name="*" propagation="SUPPORTS"/>    
  7.     </tx:attributes>    
  8. </tx:advice>    

  REQUIRED表示如果存在事務,則支持當前的事務,如果沒有則創建一個新的事務,這個事務模式應用在所有以save 、update和delete開頭的方法上,也就是說對數據庫的增刪改的時候需要添加事務支持。SUPPORTS表示如果存在事務,則 支持當前的事務,如果沒有就算了。

  4.6 配置AOP切面

XML/HTML代碼
  1. <aop:config>    
  2.     <!-- 配置哪些包的類要切入事務 -->    
  3.     <aop:pointcut id="pointcut" expression="execution(* cn.it.shop.service.impl.*.*(..))" />    
  4.     <aop:advisor advice-ref="advice" pointcut-ref="pointcut"/><!-- 連接了<span style="font-family:Microsoft YaHei;">上</span>面的advice和上面的pointcut -->    
  5.     <!-- aop:pointcut要寫在aop:advisor上面,否則會報錯 -->    
  6.  </aop:config>    

  AOP即面向切面編程,aop:pointcut定義一個切面,expression屬性中配置的意思是所有cn.it.shop.service.impl包 下的所有方法,不管返回值和參數是什么,都要切入事務。該包是屬于dao層的,直接操作數據庫的。aop:advice將通知和切 面結合起來,我們直接使用上面配置好的advice和pointcut,將其引入進來即可。這樣配置好了后,意思就是說,凡是 cn.it.shop.service.impl包下的方法都需要切入事務管理,具體地,以save、update、delete開頭的方法使用REQUIED方式, 其他方法使用SUPPORTS方式。這樣就很好理解這個配置的意思了。

  4.7 測試整合結果

  之前搭建Hibernate環境的時候,我們測試是直接new了一個Service來操作數據庫,因為當時還沒有和Spring整合。 現在通過配置beans.xml后,讓Spring去管理Hibernate的事務了,所以現在的測試要把Service交給Spring管理,通過Spring 注入進來,并且依賴sessionFactory,如果能插入數據到數據庫,則說明聲明事務OK。

  首先,我們要在Spring的配置文件beans.xml中配一下這個Service:

XML/HTML代碼
  1. <bean id="categoryService" class="cn.it.shop.service.impl.CategoryServiceImpl">    
  2.     <property name="sessionFactory" ref="sessionFactory" /><!-- 依賴的sessionFactory用我們之前配好的sessionFactory-->    
  3. </bean>    

  其次,我們需要在CategoryService接口和它的實現類CategoryServiceImpl中增加一個方法用來測試整合后的情況 :

Java代碼
  1. public interface CategoryService {    
  2.     public void save(Category category); //用來測試Hibernate環境    
  3.     public void update(Category category); //用來測試Spring和Hibernate整合后    
  4. }    
  5.     
  6. public class CategoryServiceImpl implements CategoryService {    
  7.     
  8.     @Override //沒有和Spring整合的情況    
  9.     public void save(Category category) {    
  10.         //通過工具類獲取session    
  11.         Session session = HibernateSessionFactory.getSession();    
  12.         try {    
  13.             //手動事務    
  14.             session.getTransaction().begin();    
  15.             //執行業務邏輯    
  16.             session.save(category);    
  17.             //手動提交    
  18.             session.getTransaction().commit();    
  19.         } catch(Exception e) {    
  20.             session.getTransaction().rollback();    
  21.             throw new RuntimeException(e);    
  22.         } finally {    
  23.             HibernateSessionFactory.closeSession();    
  24.         }    
  25.             
  26.     }    
  27.     /*Spring和Hibernate整合后*/    
  28.     private SessionFactory sessionFactory; //定義一個sessionFactory    
  29.         
  30.     //當需要使用sessoinFactory的時候,Spring會將sessionFactory注入進來    
  31.     public void setSessionFactory(SessionFactory sessionFactory) {    
  32.         this.sessionFactory = sessionFactory;    
  33.     }      
  34.     protected Session getSession() {    
  35.         //從當前線程獲取session,如果沒有則創建一個新的session    
  36.         return sessionFactory.getCurrentSession();    
  37.     }    
  38.         
  39.     @Override //Spring和Hibernate整合后的情況    
  40.     public void update(Category category) {    
  41.         getSession().update(category);        
  42.     }    
  43. }

  現在我們可以去測試類中增添測試方法,來測試Spring和Hibernate整合后的結果了:

Java代碼
  1. @RunWith(SpringJUnit4ClassRunner.class)    
  2. @ContextConfiguration(locations="classpath:beans.xml")    
  3. public class SSHTest {    
  4.         
  5.     @Resource    
  6.     private Date date;    
  7.         
  8.     @Resource    
  9.     private CategoryService categoryService;    
  10.         
  11.     @Test //測試Spring IOC的開發環境    
  12.     public void springIoc() {    
  13.         System.out.println(date);    
  14.     }    
  15.         
  16.     @Test  //測試Hibernate的開發環境,因為沒有整合,可以直接new    
  17.     public void hihernate() {    
  18.         CategoryService categoryService = new CategoryServiceImpl();    
  19.         Category category = new Category("男士休閑"true);    
  20.         categoryService.save(category);    
  21.     }    
  22.         
  23.     @Test //測試Hibernate和Spring整合后    
  24.     public void hibernateAndSpring() {    
  25.         categoryService.update(new Category(1"休閑女式"true)); //categoryService通過Spring從上面注入進來的    
  26.     }    
  27. }   

  然后我們查看數據庫,發現id=1的category被修改成了休閑女式了,說明更新成功。至此,Spring和Hibernate整合 成功。

  5. 搭建Struts2環境

  5.1 添加相應的配置和jar包

  struts2運行所需的jar包我放在struts2.3.41的Library中了,直接引入即可,不再贅述。另外,還要對web.xml文件進 行配置,配置如下:

XML/HTML代碼
  1. <?xml version="1.0" encoding="UTF-8"?>    
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">    
  3.   <display-name>E_shop</display-name>    
  4.   <welcome-file-list>    
  5.     <welcome-file>index.jsp</welcome-file>    
  6.   </welcome-file-list>    
  7.       
  8.   <filter>    
  9.     <filter-name>struts2</filter-name>    
  10.     <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>    
  11.   </filter>    
  12.       
  13.   <filter-mapping>    
  14.     <filter-name>struts2</filter-name>    
  15.     <url-pattern>*.action</url-pattern>    
  16.   </filter-mapping>    
  17.       
  18. </web-app>    

  如上,我們配置了一個StrutsPrepareAndExecuteFilter過濾器,并將過濾器的url-pattern設置為*.action,即所 有.action后綴的都會首先經過這個過濾器,這也是struts2的入口處。

  5.2 創建Action并且配置到struts.xml文件中

  我們創建一個Action如下:

Java代碼
  1. public class CategoryAction extends ActionSupport {    
  2.     private CategoryService categoryService; //設置categoryService是為了很直觀的看出與Spring整合前后的不同    
  3.         
  4.     public void setCategoryService(CategoryService categoryService) {    
  5.         this.categoryService = categoryService;    
  6.     }    
  7.         
  8.     public String update() {    
  9.         System.out.println("----update----");    
  10.         System.out.println(categoryService); //整合前后輸出不同    
  11.         return "index";    
  12.     }    
  13.         
  14.     public String save() {    
  15.         System.out.println("----save----");    
  16.         System.out.println(categoryService);//整合前后輸出不同    
  17.         return "index";    
  18.     }    
  19. }    

  然后我們配置struts.xml文件,該文件放在src目錄下:

XML/HTML代碼
  1. <?xml version="1.0" encoding="UTF-8" ?>    
  2. <!DOCTYPE struts PUBLIC    
  3.     "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"    
  4.     "http://struts.apache.org/dtds/struts-2.3.dtd">    
  5.     
  6. <struts>    
  7.     <package name="shop" extends="struts-default">    
  8.         <!-- category_update.actiocan: 訪問update方法 -->    
  9.         <action name="category_*" class="cn.it.shop.action.CategoryAction" method="{1}">    
  10.             <result name="index">/index.jsp</result>    
  11.         </action>    
  12.     </package>    
  13.     
  14. </struts>    

  5.3 測試Struts2環境

  測試方法是:寫一個jsp訪問Action,如果Action可以創建,則表示struts2環境OK。即struts2的一連串流程可以正 常走完:jsp-->struts.xml-->Action-->struts.xml-->jsp,這樣struts2的環境就算搭好了。我們寫一個簡單的 index.jsp

XML/HTML代碼
  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>    
  2.     
  3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">    
  4. <html>    
  5.   <head>    
  6.     <title>My JSP 'index.jsp' starting page</title>    
  7.   </head>    
  8.       
  9.   <body>     
  10.     <!-- 下面兩種寫法都可以訪問 --></span>    
  11.     <a href="${pageContext.request.contextPath }/category_update.action">訪問update</a>    
  12.     <a href="category_save.action">訪問save</a>    
  13.   </body>    
  14. </html>    

  然后我們部署以下工程,打開tomcat服務器,在瀏覽器中輸入:http://localhost:8080/E_shop/index.jsp后,能出 現正常jsp頁面,然后點擊兩個按鈕,仍然跳轉到index.jsp,然后我們看一下控制臺的輸出信息:

XML/HTML代碼
  1. ----update----    
  2. null    
  3. ----save----    
  4. null    

  說明struts2的一條線走完了,環境沒有問題,至此,struts2開發環境搭建完畢。

  我們看控制臺輸出了null,也就是說categoryService是空,也就是說根本沒拿到categoryService,因為我們沒有和 Spring進行整合,沒有被注入進來,所以null是正常的。我們沿著控制臺輸出的信息往上翻,會發現一條信息:Choosing bean (struts) for (com.opensymphony.xwork2.ObjectFactory)。括號里是struts說明沒有和Spring整合前,Action是有 Struts2產生的。

  6. Spring和Struts2整合

  6.1 添加相應的jar包

  Spring與Struts2整合時的jar包主要在spring4.2.4-web里面,里面包括struts2-spring-plugin-2.3.24.1.jar,導包不 再贅述。

  6.2 把Action和它的依賴交給Spring管理

  在Spring的配置文件beans.xml中配置Action和它的依賴,我們目前只有一個Action,配置如下所示:

XML/HTML代碼
  1. <bean id="date" class="java.util.Date" />    
  2. <bean id="categoryAction" class="cn.it.shop.action.CategoryAction" scope="prototype">    
  3.     <property name="categoryService" ref="categoryService" /> <!-- 依賴的categoryService用上面和Hibernate整合時配置好的categoryService -->    
  4. </bean>    

  6.3 修改struts.xml中的配置

  原來在struts.xml中,class屬性對應的是具體Action的完全限定名,現在將class屬性的值改為Spring中配置action的 id值,即categoryAction,如下:

XML/HTML代碼
  1. <struts>    
  2.     <package name="shop" extends="struts-default">    
  3.     
  4.         <!-- class對應的是Spring中配置該Action的id值,因為要交給Spring管理 -->    
  5.         <action name="category_*" class="categoryAction" method="{1}">    
  6.             <result name="index">/index.jsp</result>    
  7.         </action>    
  8.     </package>    
  9.     
  10. </struts>    

  6.4 配置監聽器

  在web.xml中配置監聽器ContextLoaderListener,這樣在服務器啟動的時候就可以加載Spring的配置文件了。如下 :

XML/HTML代碼
  1. <?xml version="1.0" encoding="UTF-8"?>    
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">    
  3.   <display-name>E_shop</display-name>    
  4.   <welcome-file-list>    
  5.     <welcome-file>index.jsp</welcome-file>    
  6.   </welcome-file-list>    
  7.       
  8.   <filter>    
  9.     <filter-name>struts2</filter-name>    
  10.     <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>    
  11.   </filter>    
  12.       
  13.   <filter-mapping>    
  14.     <filter-name>struts2</filter-name>    
  15.     <url-pattern>*.action</url-pattern>    
  16.   </filter-mapping>    
  17.     
  18.  <!-- web.xml中監聽器的啟動優先級要高于過濾器,所以配在下面無所謂的 -->    
  19.   <listener>    
  20.     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>    
  21.   </listener>    
  22.       
  23.   <context-param>    
  24.     <param-name>contextConfigLocation</param-name>    
  25.     <param-value>classpath:beans.xml</param-value>    
  26.   </context-param>    
  27.       
  28. </web-app>    

  6.5 測試整合結果

  我們在Action中新加一句更新數據庫的語句,如下:

Java代碼
  1. public class CategoryAction extends ActionSupport {    
  2.         
  3.     private Category category;//設置一個私有成員變量接收url帶過來的參數,注意下面要寫好get和set方法    
  4.         
  5.     private CategoryService categoryService;    
  6.         
  7.     public void setCategoryService(CategoryService categoryService) {    
  8.         this.categoryService = categoryService;    
  9.     }    
  10.         
  11.     public String update() {    
  12.         System.out.println("----update----");    
  13.         System.out.println(categoryService);//由于已經和Spring整合,所以可以拿到這個categoryService了,打印出來就不是null了    
  14.         categoryService.update(category); //新加一條語句,來更新數據庫    
  15.         return "index";    
  16.     }    
  17.         
  18.     public String save() {    
  19.         System.out.println("----save----");    
  20.         System.out.println(categoryService);    
  21.         return "index";    
  22.     }    
  23.     
  24.     public Category getCategory() {    
  25.         return category;    
  26.     }    
  27.     
  28.     public void setCategory(Category category) {    
  29.         this.category = category;    
  30.     }    
  31. }    

  然后我們修改一下index.jsp文件,如下:

XML/HTML代碼
  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>    
  2.     
  3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">    
  4. <html>    
  5.   <head>    
  6.     <title>My JSP 'index.jsp' starting page</title>    
  7.   </head>    
  8.       
  9.   <body>    
  10.     <a href="${pageContext.request.contextPath }/category_update.action?category.id=2&category.type=gga&category.hot=false">訪問update</a>    
  11.     <a href="category_save.action">訪問save</a>    
  12.   </body>    
  13. </html>    

  然后我們部署以下工程,打開tomcat服務器,在瀏覽器中輸入:http://localhost:8080/E_shop/index.jsp后,能出 現正常jsp頁面,然后點擊“訪問update”按鈕,仍然跳轉到index.jsp,然后我們看一下控制臺的輸出信息:

XML/HTML代碼
  1. ----update----    
  2. [email protected]    
  3. Hibernate: update category set hot=?, type=? where id=?    

  我們看到可以輸出categoryService這個對象的信息了,也可以輸出執行update語句時的SQL語句,然后我們查詢一 下數據庫,發現id=2的數據的type被更新為gga,hot更新為false。我們沿著控制臺輸出的信息往上翻,會發現一條信息: Choosing bean (spring) for (com.opensymphony.xwork2.ObjectFactory),括號里為spring,與上面的情況對比可知, Struts2在與Spring整合后,Action交給了Spring去管理了。

  至此,Struts2、Hibernate4和Spring4整合工作已經全部完成。接下來就可以在SSH環境下進行開發了!

  整個項目的源碼下載地址:http://blog.csdn.net/eson_15/article/details/51479994

轉自:倪升武的CSDN博客

除非特別注明,雞啄米文章均為原創
轉載請標明本文地址:http://www.ojizl5.fun/software/759.html
2017年8月30日
作者:雞啄米 分類:軟件開發 瀏覽: 評論:0