[计算机软件及应用]ssh框架

1、精品文档1.新建Web工程ssh_test新建Web工程ssh_test，如图15-2所示。 点击查看大图图15-2  创立Web工程J2EE的版本要选择Java EE5，这样会默认支持JSTL。单击"Finish"按钮完成创立。2.添加Struts1.3框架支持文件添加Struts 1.3框架支持文件，如图15-3所示。 点击查看大图图15-3  添加Struts 1.3框架文件Struts框架选择版本为1.3，并且设置包的名称为"struts"。单击"Finish"按钮完成设置。3.添加Hi

2、bernate Database Explorer数据库连接进入数据库浏览透视图，新建一个数据库连接，如图15-4所示。 点击查看大图图15-4  新建数据库连接单击"Next"按钮继续添加，如图15-5所示。 点击查看大图图15-5  选择数据库单击"Finish"按钮完成设置。双击数据库连接查看是否正确连接数据库，如图15-6所示。 图15-6  是否连接数据库正确连接到数据库，可以看到table_1表。4.添加Hibernate 3.1框架支持文件添加Hibernate 3.1框架支持文件

3、，如图15-7所示。 点击查看大图图15-7  添加Hbiernate 3.1框架支持文件这里需要取消勾选Hibernate 3.1的核心JAR包复选框和高级JAR包复选框。因为在本SSH整合中会使用Spring自带Hibernate的JAR包，单击"Next"按钮继续添加，后面的步骤按默认的设置即可，但在后面的向导中需要创立一个orm包，用来存放Hibernate实体类和DAO文件。5. 添加Spring 2.0框架支持文件添加Spring 2.0框架支持文件，如图15-8所示。 点击查看大图图15-8  添加spring 2.0框

4、架支持文件按图中的示意添加相应的JAR包，然后单击"Next"按钮继续添加，如图15-9所示。 点击查看大图图15-9  配置文件的选项这步会设置配置文件applicationContext.xml的生成方式，"New"是新建一个，"Existing"是使用存在的。由于本例如是一个全新的工程，所以要新建一个配置文件，单击"Next"按钮继续配置，如图15-10所示。 点击查看大图图15-10  LocalSessionFactory的id名称这步会设置session工厂的id

5、别名，这里选择默认即可。单击"Finish"按钮完成设置6. 自动创立的applicationContext.xml文件在工程中src目录下自动创立了一个applicationContext.xml文件，其代码如下：1. <?xml version="1.0" encoding="UTF-8"?>  2. <beans xmlns=" :/ /schema/beans" 3.    

6、; xmlns:xsi=" :/ /2001/XMLSchema-instance" 4.     xsi:schemaLocation=" :/ /schema/beans   5. :/ /schema/beans/spring-beans-2.0.xsd">  6.  7.   / 新建了LocalSessionFactoryB

7、ean类型的变量sessionFactory，用来从hibernate.cfg.xml配置  8.   / 文件中取得数据库的连接，以便用hibernate来操作数据库  9.     <bean id="sessionFactory" 10.     class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> 

8、0;11.   / 设置LocalSessionFactoryBean类型的变量sessionFactory的configLocation属性来源于一个  12.   / hibernate.cfg.xml配置文件，也就是Hibernate的配置文件，classpath的意思是在当前工程  13.   / 的classpath路径中寻找这个hiberante.cfg.xml配置文件，从配置文件中取得数据库的连接  14.   / 信息，是一个典型

9、的Spring注入案例  15.         <property name="configLocation" 16.             value="classpath:hibernate.cfg.xml">  17.       

10、60; </property>  18.     </bean>  19. </beans> 从代码中可以看到：1. org.springframework.orm.hibernate3.LocalSessionFactoryBean Spring封装了Hibernate 3.0版本的操作，使用Spring的方式接管了Hibernate的session创立、销毁，以及创立SessionFactory的周边信息。如数据库连接地址、用户名和密码等都来源于hibernate.

11、cfg.xml配置文件。7. 在web.xml文件中参加Spring的utf-8过滤器更改后的代码如下：1. <?xml version="1.0" encoding="UTF-8"?>  2. <web-app xmlns=" :/java.sun /xml/ns/javaee" 3.     xmlns:xsi=" :/ /2001/XMLSchema-instance" versi

12、on="2.5" 4.     xsi:schemaLocation=" :/java.sun /xml/ns/javaee     5. :/java.sun /xml/ns/javaee/web-app_2_5.xsd">  6.     <filter>  7.     /过滤器使用spring类CharacterEncodingFilter

13、 8.         <filter-name>encodingFilter</filter-name>  9.         <filter-class>  10.             org.springframework.web.filte

14、r.CharacterEncodingFilter  11.         </filter-class>  12.         <init-param>  13.             <param-name>encoding</para

15、m-name>  14.     /过滤器过滤后的编码为utf-8  15.             <param-value>utf-8</param-value>  16.         </init-param>  17.     

16、;</filter>  18.     <filter-mapping>  19.     /过滤所有的路径：/*代表所有的路径  20.         <filter-name>encodingFilter</filter-name>  21.         <

17、;url-pattern>/*</url-pattern>  22.     </filter-mapping>  23.  24.     <servlet>  25.         <servlet-name>action</servlet-name>  26.     /st

18、ruts中的ActionServlet，所有的请求应答由ActionServlet来处理  27.         <servlet-class>  28.             org.apache.struts.action.ActionServlet  29.        &#

19、160;</servlet-class>  30.         <init-param>  31.     /struts中的配置文件的存放位置  32.             <param-name>config</param-name>  33.  &

20、#160;          <param-value>/WEB-INF/struts-config.xml</param-value>  34.         </init-param>  35.         <init-param>  36. 

21、0;           <param-name>debug</param-name>  37.             <param-value>3</param-value>  38.         </ini

22、t-param>  39.         <init-param>  40.             <param-name>detail</param-name>  41.             <

23、;param-value>3</param-value>  42.         </init-param>  43.         <load-on-startup>0</load-on-startup>  44.     </servlet>  45.   

24、0; <servlet-mapping>  46.     /映射的后缀扩展名名称  47.         <servlet-name>action</servlet-name>  48.         <url-pattern>*.do</url-pattern>  49. 

25、0;   </servlet-mapping>  50.     <welcome-file-list>  51.         <welcome-file>index.jsp</welcome-file>  52.     </welcome-file-list>  53. </web-app>

26、; 类org.springframework.web.filter.CharacterEncodingFilter是Spring特有的，专门解决Web的中文utf-8乱码问题。8. 在struts-config.xml文件中参加spring的request代理更改后的struts_config.xml配置文件如下：1. <?xml version="1.0" encoding="UTF-8"?>  2. <!DOCTYPE struts-config PUBLIC &

27、quot;-/Apache Software Foundation/DTD Struts Configuration 1.3  3. /EN" " ://dtds/struts-config_1_3.dtd">  4.  5. <struts-config>  6.     <form-beans />  7.   

28、0; <global-exceptions />  8.     <global-forwards />  9.     <action-mappings />  10.     / 参加Spring框架中的DelegatingRequestProcessor代理请求处理，目的是将Struts的请求  11.    

29、60;/ 及应答用Spring的ioc容器中的Bean来处理  12.     <controller  13.     processorClass="org.springframework.web.struts.DelegatingRequestProcessor">  14.     </controller>  15.  16.    

30、 <message-resources parameter="struts.ApplicationResources" />  17.     / Struts的请求和应答由Spring的DelegatingRequestProcessor类进行拦截，使用Spring框  18.     / 架的IOC容器来处理，那么如何知道Struts的Action的路径对应IOC容器中的哪个Bean  19.

31、60;   / 呢？通过设置插件ContextLoaderPlugIn的属性contextConfigLocation为配置文件的所在  20.     / 位置及文件名来指定即可  21.     <plug-in  22.     className="org.springframework.web.struts.ContextLoaderPlugIn"> &#

32、160;23.         <set-property property="contextConfigLocation" 24.             value="/WEB-INF/classes/applicationContext.xml" />  25.    &

33、#160;</plug-in>  26. </struts-config>  27. 类可以将Struts的请求拦截，使用Spring的IOC容器进行管理，这样方便在一个request请求下进行数据库操作的事务封装。另外由于Spring是一个容器，所以包括Struts的Action类也要由Spring来管理，这样Action的路径就需要和applicationContext.xml文件中的配置进行匹配，所以在下面的代码中使用了插件的方式将Struts的Action路径和Spring中的IOC容器中的Bean进行匹配：  28.  

34、   <plug-in  29.         className="org.springframework.web.struts.ContextLoaderPlugIn">  30.         <set-property property="contextConfigLocation" 31.

35、60;           value="/WEB-INF/classes/applicationContext.xml" />  32.     </plug-in>  33. 另外需要注意一点，如果是ssh+dwr(ajax)整合时，在Struts中的配置文件就可以把<plug-in>节点去掉，而在web.xml文件中参加以下代码：  34. <?

36、xml version="1.0" encoding="UTF-8"?>  35. <web-app xmlns=" :/java.sun /xml/ns/javaee" 36.     xmlns:xsi=" :/ /2001/XMLSchema-instance" version="2.5" 37.     xsi:sc

37、hemaLocation=" :/java.sun /xml/ns/javaee     38. :/java.sun /xml/ns/javaee/web-app_2_5.xsd">  39.     <context-param>  40.         <param-name>contextConfigLocation</param-name> &

38、#160;41.         <param-value>  42.             /WEB-INF/classes/applicationContext.xml  43.         </param-value>  44.   

39、  </context-param>  45.     <listener>  46.         <listener-class>  47.             org.springframework.web.context.ContextLoaderListen

40、er  48.         </listener-class>  49.     </listener> 这样在容器启动时，就需要将Spring配置文件applicationContext.xml中的Bean加载到内存，以便dwr可以正确地访问到内存中的Bean实例。9. 对MySQL数据库中的table_1表进行Hibernate逆向工程逆向第1步的截图如图15-11所示。 点击查看大图图15-11

41、0; 逆向的第1步在第1步中需要取消勾选Create abstract class复选框，即不创立DAO的抽象类。需要留意的是要选择逆向目标工程的名称，另外读者需要注意，本DAO类是基于Spring DAO的。单击"Next"按钮继续配置，如图15-12所示。 点击查看大图图15-12  主键生成策略主键生成策略为native，是自增类型，取决于数据库的规那么。由于MySQL的主键是自增的，所以以整型每次加1的规那么来创立主键的生成。后面的步骤按照默认即可，最后单击"Finish"按钮完成数据库表的逆向工程。10. 了解继承自Hibe

42、rnateDaoSupport类DAO在orm包中创立了一个DAO：Table1DAO，其代码如下：1. package orm;  2.  3. import java.util.List;  4. import org.apache mons.logging.Log;  5. import org.apache mons.logging.LogFactory;  6. import org.hibernate.LockMode;  7. import org.spring

43、framework.context.ApplicationContext;  8. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;  9.  10. / 继承自HibernateDaoSupport的Table1DAO类具有Spring封装Hibernate操作数据库  11. / 的完全功能，继承自HibernateDaoSupport的目的是让Spring管理事务并且DAO具有  12. / 面向接口编程的特

44、点，多态性使DAO类的实现多样化，而且在Spring的管理下，  13. / 数据库连接的翻开和关闭，事务的处理也都变成自动化了  14. public class Table1DAO extends HibernateDaoSupport   15.     private static final Log log = LogFactory.getLog(Table1DAO.class);  1

45、6.     / property constants  17.     public static final String USERNAME = "username"  18.  19.     protected void initDao()   20.     

46、    / do nothing  21.       22.  23.     public void save(Table1 transientInstance)   24.         log.debug("saving Table1 instance&quo

47、t;);  25.         try   26.             getHibernateTemplate().save(transientInstance);/保存数据  27.             log.debug(

48、"save successful");  28.          catch (RuntimeException re)   29.             log.error("save failed", re);  30.   

49、60;         throw re;  31.           32.       33.  34.     public void delete(Table1 persistentInstance)   35.   &

50、#160;     log.debug("deleting Table1 instance");  36.         try   37.             getHibernateTemplate().delete(persistentInstance);/删除数据

51、 38.             log.debug("delete successful");  39.          catch (RuntimeException re)   40.          

52、;   log.error("delete failed", re);  41.             throw re;  42.           43.       44.  45.    

53、 public Table1 findById(java.lang.Integer id)   46.         log.debug("getting Table1 instance with id: " + id);  47.         try  

54、0;48.             Table1 instance = (Table1) getHibernateTemplate().get("orm.Table1",  49.                    

55、 id);/根据id取得实体类  50.             return instance;  51.          catch (RuntimeException re)   52.          

56、60;  log.error("get failed", re);  53.             throw re;  54.           55.       56.  57.     p

57、ublic List findByExample(Table1 instance)   58.         log.debug("finding Table1 instance by example");  59.         try   60.    

58、0;        List results = getHibernateTemplate().findByExample(instance);  61.             log.debug("find by example successful, result size: &qu

59、ot; 62.                     + results.size();/根据QBE来取得数据  63.             return results;  64.    &#

60、160;     catch (RuntimeException re)   65.             log.error("find by example failed", re);  66.           

61、;  throw re;  67.           68.       69.  70.     public List findByProperty(String propertyName, Object value)   71.      &

62、#160;  log.debug("finding Table1 instance with property: " + propertyName  72.                 + ", value: " + value);  

63、73.         try   74.             String queryString = "from Table1 as model where model." 75.       

64、0;             + propertyName + "= ?"/根据属性值取得数据  76.             return getHibernateTemplate().find(queryString, value);  77.

65、          catch (RuntimeException re)   78.             log.error("find by property name failed", re);  79.     

66、60;       throw re;  80.           81.       82.  83.     public List findByUsername(Object username)   84.     

67、60;   return findByProperty(USERNAME, username);/根据姓名取得数据  85.       86.  87.     public List findAll()   88.         log.debug("finding all Tabl

68、e1 instances");  89.         try   90.             String queryString = "from Table1"  91.         &

69、#160;   return getHibernateTemplate().find(queryString);  92.             /查询全部数据  93.          catch (RuntimeException re)   94.   

70、60;         log.error("find all failed", re);  95.             throw re;  96.           97.    

71、   98.  99.     public Table1 merge(Table1 detachedInstance)   100.         log.debug("merging Table1 instance");  101.         try

72、0;  102.             Table1 result = (Table1) getHibernateTemplate().merge(  103.                     detached

73、Instance);  104.             log.debug("merge successful");  105.             return result;  106.        

74、0; catch (RuntimeException re)   107.             log.error("merge failed", re);  108.             throw re;  109.  

75、;         110.       111.  112.     public void attachDirty(Table1 instance)   113.         log.debug("attaching dirty Table1 

76、;instance");  114.         try   115.             getHibernateTemplate().saveOrUpdate(instance);  116.             

77、log.debug("attach successful");  117.          catch (RuntimeException re)   118.             log.error("attach failed", re);  119

78、.             throw re;  120.           121.       122.  123.     public void attachClean(Table1 instance)   1

79、24.         log.debug("attaching clean Table1 instance");  125.         try   126.             getHibernateTemplate().lo

80、ck(instance, LockMode.NONE);  127.             log.debug("attach successful");  128.          catch (RuntimeException re)   129.   

81、0;         log.error("attach failed", re);  130.             throw re;  131.           132.     

82、;  133.  134.     public static Table1DAO getFromApplicationContext(ApplicationContext ctx)   135.         return (Table1DAO) ctx.getBean("Table1DAO");  136.    

83、;   137.  从DAO类中可以看到自动生成了根本CURD操作的代码，类是继承自Spring封装Hibernate的操作类：public class Table1DAO extends HibernateDaoSupport。HibernateDaoSupport提供了基于AOP事务的自动处理，程序员完全可以不用理会事务的开始与提交。在JDBC中一个Connection对象使用一个事务，那么在Hibernate中一个事务肯定要关联一个SessionFactory了，然而这个SessionFactory却没有在DAO中表达。其实主要的原因是HibernateDa

84、oSupport类已经默默地做了封装的工作，它用一个setSessionFactory方法将SessionFactory进行注入，所以继承自HibernateDaoSupport类的DAO都会具有SessionFactory的属性，从而可以通过SessionFactory创立Session实例操作数据库，如图15-13所示。 点击查看大图图15-13  HibernateDaoSupport类的结构虽然有set方法，但在哪注入的呢？当然是在applicationContext.xml文件上。翻开这个配置文件后，可以看到如下代码：1. <?xml versio

85、n="1.0" encoding="UTF-8"?>  2. <beans xmlns=" :/ /schema/beans" 3.     xmlns:xsi=" :/ /2001/XMLSchema-instance" 4.     xsi:schemaLocation=" :/ springframework.

86、org/schema/beans   5. :/ /schema/beans/spring-beans-2.0.xsd">  6.  7.  8.     <bean id="sessionFactory" 9.         class="org.springframework.orm.hibernate3.Loc

87、alSessionFactoryBean">  10.         <property name="configLocation" 11.             value="classpath:hibernate.cfg.xml">  12.    &#

88、160;    </property>  13.     </bean>  14.     <bean id="Table1DAO" class="orm.Table1DAO">  15.     /将ref bean="sessionFactory"注入到Table1DAOr的pr

89、operty   16.     /name="sessionFactory"属性中  17.         <property name="sessionFactory">  18.             <ref bean="

90、;sessionFactory" />  19.         </property>  20.     </bean>  21. </beans> MyEclipse工具自动将创立的DAO注入了sessionFactory的对象，所以DAO对象就具有了通过Hibernate操作数据库的功能。11. 创立All_DAO对象本例如是使用分层的结构，在service效劳层有可能

91、需要使用到某些DAO当然本例如只有一个DAO，所以要想方法将这些零散的DAO集中起来，以供某一个service类进行调用。根据本例如的结构，创立All_DAO类，并且在All_DAO类中添加属性table1dao，这里一定要注意，属性的名称一定要小写，因为Spring对属性名称有自己的认知性，小写不会出现错误，并且生成get和set方法，如图15-14所示。 点击查看大图图15-14  生成get和set方法生成后的代码如下：1. package orm;  2.  3. public class All_DAO 

92、  4.  5.     Table1DAO table1dao;  6.     /声明Table1DAO类的变量table1dao，All_DAO就相当于一个手袋一样  7.     /把所有的dao封装进这个All_DAO中  8.  9.     public Table1DAO getTable1dao() /get方法

93、60;10.         return table1dao;  11.       12.  13.     public void setTable1dao(Table1DAO table1dao) /set方法  14.         this.table1d

94、ao = table1dao;  15.       16.  17.  12. 创立Table1_Service效劳对象创立Table1DAO的service效劳对象Table1_Service，并且把这个效劳对象放入到service包中，所以还需要新建一个service包。由于Table1_Service效劳类会使用到很多的DAO，所以在效劳类中声明一个All_DAO类的对象，这样就可以在一个效劳类中使用全部的DAO了，具有很强的灵活性。手动创立的代码如下：1. package s

95、ervice;  2.  3. import java.util.List;  4.  5. import orm.All_DAO;  6.  7. public class Table1_Service   8.  9.     All_DAO all_dao;/声明All_DAO类的实例变量all_dao  10.  11.     public

96、0;void setAll_dao(All_DAO all_dao) /set方法  12.         this.all_dao = all_dao;  13.       14.  15.     public List get_table1_all() /取得表中所有数据的方法  16.  

97、;17.         return this.all_dao.getTable1dao().findAll();  18.  19.       20.  21.  在效劳类中创立了一个get_table1_all方法，用于获取table_1表中的所有数据。13. 创立All_Service效劳对象创立All_Service效劳对象的目的是将所有的效劳对象集中管理，这样在控制层Action调用时只需要调用All_

98、Service对象，就可以调用所有的效劳了，而那些效劳又可以调用所有的DAO，软件模块之间数据的流动性大大增强。手动创立的代码如下：1. package service;  2.  3. public class All_Service   4. /All_Service又相当于一个手袋一样，将所有的自定义的Service类进行封装  5. /以便Struts的Action对象调用。  6.     Table1_Service table1_servic

99、e;/创立Table1_Service类的变量table1_service  7.  8.     public Table1_Service getTable1_service() /get方法  9.         return table1_service;  10.       11.  12.   

100、0; public void setTable1_service(Table1_Servicetable1_service) /set方法  13.         this.table1_service = table1_service;  14.       15.  16.  到此已经将All_DAO、Table1_Service和All_Service对象创立

101、完成了，当然这还是不够的，还必须将这些类注册到Spring的IOC容器中，即在applicationContext.xml配置文件中配置这些类之间的关系。14. 在applicationContext.xml文件中配置dao和service的关系手动配置后的applicationContext.xml的代码如下：1. <?xml version="1.0" encoding="UTF-8"?>  2. <beans xmlns=" :/ /schem

102、a/beans" 3.     xmlns:xsi=" :/ /2001/XMLSchema-instance" 4.     xsi:schemaLocation=" :rg/schema/beans   5. :/ /schema/beans/spring-beans-2.0.xsd">  6.  7.    

103、0;/声明一个类型为LocalSessionFactoryBean的变量bean id="sessionFactory"  8.     <bean id="sessionFactory" 9.         class=Bean">  10.         <property

104、 name="configLocation" 11.             value="classpath:hibernate.cfg.xml">  12.         </property>  13.     </bean>  14. /将orm.Table1DAO中sessionFactory属性进行注入：ref bean="sessionFactory"