web学习：Spring2.5+Hibernate3.3+Struts1.3整合小例子

写android有段时间了，感觉思维越写越狭窄，考虑问题越来越局限了，看不到一个项目整体的设计和构架，觉得很有必要多多写一些大型的框架性的东西来提高自己的视野。

从接触java到现在一年多了，在我的印象里，struts好像是用来接收请求然后处理，将处理结果在跳转到jsp上显示的；spring就是一个 大型的工厂，专门生产业务的类；hibernate就是负责和数据库勾结，然后提供数据的。惭愧啊，我居然从来都没有用过SSH三大框架，居然我也能鬼使 神差的工作了，而且工作了这么长时间了，趁现在空暇和还未在被公司开掉之前，赶紧学习学习，也为将来复习记录一笔。

工欲善其事，必先利其器。首先要把所有的jar文件找好，查了一下百度，发现需要的jar文件如下：

[plain] view plaincopy
  1. <strong>*Spring2.5 jar文件</strong>  
  2.      distspring.jar  
  3.     distmodulesspring-webmvc-struts.jar  
  4.     libjakarta-commonscommons-logging.jar   
  5.     libaspectjaspectjweaver.jar、aspectjrt.jar  
  6.     libcglibcglib-nodep-2.1_3.jar  
  7.     libj2eecommon-annotations.jar  
  8.   
  9. <strong>*Struts1.3 jar文件</strong>  
  10.        appsstruts-blank-1.3WEB-INFlib 下有所有的jar文件  
  11.   
  12. <strong>*Hibernate3.3 jar文件</strong>  
  13.       hibernate3.jar  
  14.       lib equired*.jar  
  15.       liboptionalehcache-1.2.3.jar  
  16.       hibernate 注解安装包下的  
  17.       lib estslf4j-log4j12.jar  
  18.      Struts  
  19.         下 载struts-1.3.8-lib.zip，需要使用到解压目录下的所有jar，建议把jstl-1.0.2.jar和standard- 1.0.2.jar更换为1.1版本。Spring中已经存在一个antlr-2.7.6.jar，所以把struts中的antlr- 2.7.2.jar删除，避免jar冲突。  
  20.   
  21. <strong>*数据库驱动jar</strong>  


看到上面N多的jar是不是感觉脑袋都大了，上面列出来的只是为了让自己更明白到底使用了哪些东西？属于谁的？分别有什么用？如果你没有把它一个一个从下载好的包里面把它们挑选出来，那么就点击这里下载吧，这里我已经把上面所提到和未提到但是也需要的jar都选了出来。

当然，其他的比如Tomcat和jdk环境配置以及数据库神马的（说到数据库，因为我使用的是ubuntu系统，使用mysql数据库，一直用的是 一个叫emma的图标是一个海豚的图形管理工具，感觉用起来很不错，ubuntu软件中心就有的下，搜索关键字：mysql），我就不多说了。默认都是可 用的。

三大框架大体的整合思路应该是先写好spring，然后把hibernate弄进来，最后在写struts。在这里，就整一个小小的人员管理。好吧，整合开始！

1，新建一个web项目SSH,将上面下载的jar一股脑的放到WEB-INF中的lib目录下

2，在类路径下新建beans.xml文件，并且定义Person.java类，里面包含三个id，name，age字段

beans.xml:

[html] view plaincopy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"   
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.        xmlns:context="http://www.springframework.org/schema/context"  
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans   
  6.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
  7.         <bean id="personService" class="com.pccw.service.impl.PersonServiceImpl"/>  
  8. </beans>  

Person.java:

[java] view plaincopy
  1. public class Person {  
  2.     private Integer id;  
  3.     private String name;  
  4.     private Integer age;  
  5.       
  6.     public Person() {}  
  7.       
  8.     public Person(String name,Integer age){  
  9.         this.name = name;  
  10.         this.age = age;  
  11.     }  
  12.   
  13.     public Integer getId() {  
  14.         return id;  
  15.     }  
  16.   
  17.     public void setId(Integer id) {  
  18.         this.id = id;  
  19.     }  
  20.   
  21.     public String getName() {  
  22.         return name;  
  23.     }  
  24.   
  25.     public void setName(String name) {  
  26.         this.name = name;  
  27.     }  
  28.   
  29.     public Integer getAge() {  
  30.         return age;  
  31.     }  
  32.   
  33.     public void setAge(Integer age) {  
  34.         this.age = age;  
  35.     }  
  36.       
  37.     @Override  
  38.     public String toString() {  
  39.         return "name:"+this.name+",age:"+age;  
  40.     }  
  41. }  

3，定义一个接口PersonService，里面包含对人员的增删改查方法，并写一个实现类PersonServiceImpl来实现他

PersonService:

[java] view plaincopy
  1. public interface PersonService {  
  2.     public void save(Person person);  
  3.     public void delete(Integer personId);  
  4.     public void update(Person person);  
  5.     public Person getPerson(Integer personId);  
  6.     public List<Person> getPersons();  
  7. }  


PersonServiceImpl:

[java] view plaincopy
  1. public class PersonServiceImpl implements PersonService {  
  2.      private SessionFactory sessionFactory;  
  3.       
  4.     @Override  
  5.     public void save(Person person) {  
  6.           
  7.     }  
  8.   
  9.     @Override  
  10.     public void delete(Integer personId) {  
  11.           
  12.     }  
  13.   
  14.     @Override  
  15.     public void update(Person person) {  
  16.           
  17.     }  
  18.   
  19.     @Override  
  20.     public Person getPerson(Integer personId) {  
  21.         return null;  
  22.     }  
  23.   
  24.     @SuppressWarnings("unchecked")  
  25.     @Override  
  26.     public List<Person> getPersons() {  
  27.         return null;  
  28.     }  
  29.   
  30. }  


4，加入hibernate的一些元素，在2中定义好的beans.xml中加入数据源，hinernate的SessionFactory，hinernate的事务管理器，以及配置注解和各种的命名空间地址

beans.xml:

[html] view plaincopy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.        xmlns:context="http://www.springframework.org/schema/context"   
  5.        xmlns:aop="http://www.springframework.org/schema/aop"  
  6.        xmlns:tx="http://www.springframework.org/schema/tx"  
  7.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
  8.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
  9.            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd  
  10.            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd  
  11.            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
  12.     <context:annotation-config />  
  13.     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
  14.         <property name="driverClassName" value="org.gjt.mm.mysql.Driver"/>  
  15.         <property name="url" value="jdbc:mysql://localhost:3306/duan?useUnicode=true&characterEncoding=UTF-8"/>  
  16.         <property name="username" value="root"/>  
  17.         <property name="password" value="19891126"/>  
  18.          <!-- 连接池启动时的初始值 -->  
  19.          <property name="initialSize" value="1"/>  
  20.          <!-- 连接池的最大值 -->  
  21.          <property name="maxActive" value="500"/>  
  22.          <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->  
  23.          <property name="maxIdle" value="2"/>  
  24.          <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->  
  25.          <property name="minIdle" value="1"/>  
  26.     </bean>  
  27.       
  28.     <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
  29.         <property name="dataSource" ref="dataSource"/>  
  30.         <property name="mappingResources">  
  31.             <list>  
  32.               <value>com/pccw/damon/Person.hbm.xml</value>  
  33.             </list>  
  34.         </property>  
  35.         <property name="hibernateProperties">  
  36.             <value>  
  37.                 hibernate.dialect=org.hibernate.dialect.MySQL5Dialect  
  38.                 hibernate.hbm2ddl.auto=update  
  39.                 hibernate.show_sql=false  
  40.                 hibernate.format_sql=false  
  41.             </value>  
  42.         </property>  
  43.     </bean>  
  44.   
  45.     <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
  46.         <property name="sessionFactory" ref="sessionFactory"/>  
  47.     </bean>  
  48.     <tx:annotation-driven transaction-manager="txManager"/>  
  49.   
  50.     <bean id="personService" class="com.pccw.service.impl.PersonServiceImpl"/>  
  51. </beans>  


5，根据SessionFactory中的属性，还需要定义一个Person.hbm.xml文件，该文件为Person类与数据库中的表对应关系的一个文件

Person.hbm.xml:

[html] view plaincopy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC  
  3.         "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.         "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="com.pccw.damon">  
  6.     <class name="Person" table="person">  
  7.         <id name="id">  
  8.             <generator class="native"/>  
  9.         </id>  
  10.         <property name="name" length="20" not-null="true"/>  
  11.         <property name="age" type="integer" not-null="true"/>  
  12.     </class>  
  13. </hibernate-mapping>  

可以看到该文件对应的数据库中的表为person，三个字段。


6，当上面的步骤都完成之后，在第3步中的实现类PersonServiceImpl中补全所有的方法

PersonServiceImpl:

[java] view plaincopy
  1. @Transactional  //事务注解  
  2. public class PersonServiceImpl implements PersonService {  
  3.     @Resource private SessionFactory sessionFactory;  //注解注入  
  4.       
  5.     @Override  
  6.     public void save(Person person) {  
  7.         sessionFactory.getCurrentSession().persist(person);  
  8.     }  
  9.   
  10.     @Override  
  11.     public void delete(Integer personId) {  
  12.         sessionFactory.getCurrentSession().delete(sessionFactory.getCurrentSession().load(Person.class, personId));  
  13.     }  
  14.   
  15.     @Override  
  16.     public void update(Person person) {  
  17.         sessionFactory.getCurrentSession().merge(person);  
  18.     }  
  19.   
  20.     @Override  
  21.     public Person getPerson(Integer personId) {  
  22.         return (Person)sessionFactory.getCurrentSession().get(Person.class, personId);  
  23.     }  
  24.   
  25.     @SuppressWarnings("unchecked")  
  26.     @Override  
  27.     public List<Person> getPersons() {  
  28.         return (List<Person>)sessionFactory.getCurrentSession().createQuery("from Person").list();  //这里的Person为大写的P，及第5步里面的class的name  
  29.     }  
  30.   
  31. }  


7，确定无误之后，测试一下spring于hibernate的整合效果，新建一个测试单元SSHTest.java，测试PersonServiceImpl中的所有的方法。

[java] view plaincopy
  1. public class SHTest {  
  2.     private static PersonService personService;  
  3.     @BeforeClass  
  4.     public static void setUpBeforeClass() throws Exception {  
  5.         ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");    //实例化spring容器  
  6.         personService = (PersonService)ctx.getBean("personService");                 //得到PersonService  
  7.     }  
  8.   
  9.     @Test  
  10.     public void testSave() {  
  11.         for(int i = 0;i<10;i++){  
  12.             personService.save(new Person("canmeng"+(i+1),20+i));  
  13.         }  
  14.     }  
  15.   
  16.     @Test  
  17.     public void testDelete() {  
  18.         personService.delete(1);  
  19.     }  
  20.   
  21.     @Test  
  22.     public void testUpdate() {  
  23.         Person person = personService.getPerson(2);  
  24.         person.setName("canmeng2");  
  25.         person.setAge(21);  
  26.         personService.update(person);  
  27.     }  
  28.   
  29.     @Test  
  30.     public void testGetPerson() {  
  31.         System.out.println(personService.getPerson(2).toString());  
  32.     }  
  33.   
  34.     @Test  
  35.     public void testGetPersons() {  
  36.         List<Person> list = personService.getPersons();  
  37.         for(Person person : list){  
  38.             System.out.println(person.toString());  
  39.         }  
  40.     }  
  41.   
  42. }  


8，以上测试无误后，开始整合struts，在web.xml中注册spring配置文件，也就是在web容器中实例化spring容器，并在web.xml中指定struts的Servlet和请求格式

web.xml:

[html] view plaincopy
  1. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">  
  2.   <display-name>SSH</display-name>  
  3.         <!-- 指定spring的配置文件，默认从web根目录寻找配置文件，我们可以通过spring提供的classpath:前缀指定从类路径下寻找 -->  
  4.     <context-param>  
  5.        <param-name>contextConfigLocation</param-name>  
  6.        <param-value>classpath:beans.xml</param-value>  
  7.     </context-param>                                                                                                                                          <!-- 对Spring容器进行实例化 -->  
  8.     <listener>  
  9.           <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
  10.     </listener>   
  11.      
  12.     <servlet>  
  13.         <servlet-name>action</servlet-name>  
  14.         <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>  
  15.         <init-param>  
  16.           <param-name>config</param-name>  
  17.           <param-value>/WEB-INF/struts-config.xml</param-value>  
  18.         </init-param>  
  19.         <load-on-startup>2</load-on-startup>  
  20.     </servlet>   
  21.   <servlet-mapping>  
  22.     <servlet-name>action</servlet-name>  
  23.     <url-pattern>*.do</url-pattern>  
  24.   </servlet-mapping>   
  25. </web-app>  


9，从上面的配置文件中可以看出，需要在WEB-INF目录下建立struts-config.xml的配置文件，在这里，整合struts有三种方法，先讲第一种。

struts-config.xml:

[html] view plaincopy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE struts-config PUBLIC  
  3.           "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"  
  4.           "http://struts.apache.org/dtds/struts-config_1_3.dtd">  
  5.   
  6.   
  7. <struts-config>  
  8. <span style="white-space:pre">  </span><form-beans>   
  9.     </form-beans>   
  10. <span style="white-space:pre">  </span><action-mappings>  
  11. <span style="white-space:pre">      </span><action path="/person/list" type="com.pccw.action.PersonAction">  
  12. <span style="white-space:pre">          </span><forward name="list" path="/WEB-INF/page/personlist.jsp"></forward>  
  13. <span style="white-space:pre">      </span></action>  
  14. <span style="white-space:pre">  </span></action-mappings>  
  15. <span style="white-space:pre">  </span>  
  16. </struts-config>  

可以看到访问路径/person/list，对应的Action为PersonAction，跳转的jsp为WEB-INF下的page目录下的personlist.jsp

10，web.xml定义好之后，着手写Action，定义PersonAction，继承Action，实现其中的excute方法，这里要小 鑫，excute在这里有两个方法，需要实现方法里面参数是HttpServletRequest request, HttpServletResponse response的才能接收到请求

PersonAction:

[java] view plaincopy
  1. public class PersonAction extends Action {  
  2.       
  3.     @Override  
  4.     public ActionForward execute(ActionMapping mapping, ActionForm form,  
  5.             HttpServletRequest request, HttpServletResponse response)  
  6.             throws Exception {                                                                                                                 //---------------------------------------  1  ---------------------------------------------------------------  
  7.         System.out.println("request come ~~~~~");  
  8.         WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(this.getServlet().getServletContext());    //为了获得业务服务，使用 WebApplicationContextUtils获得一个 ApplicationContext。可以查找一个 Spring bean。  
  9.         PersonService personService = (PersonService)ctx.getBean("personService");  
  10.         request.setAttribute("persons", personService.getPersons());  
  11.         System.out.println("get size:"+personService.getPersons().size());  
  12.         return mapping.findForward("list");  
  13.   
  14.     }  
  15.       
  16. }  

很 显然，这种写法简单并且易于理解。不幸的是，它将 Struts 动作与 Spring 框架耦合在一起。如果您想替换掉 Spring，那么您必须重写代码。并且，由于 Struts 动作不在 Spring 的控制之下，所以它不能获得 Spring AOP 的优势。当使用多重独立的 Spring 环境时，这种技术可能有用，但是在大多数情况下，这种方法不如另外两种方法合适。
于是，第二种方式就是可以把Action也交给spring容器来管理，通过把业务bean注入的方式注入到Action中，这样可以大大的简化Action，而且可以使得struts和spring解耦。第9步中的struts-config可以改成如下：

[html] view plaincopy
  1. <struts-config>  
  2.     <form-beans>   
  3.     </form-beans>   
  4.     <action-mappings>  
  5.         <action path="/person/list" type="org.springframework.web.struts.DelegatingActionProxy">  
  6.             <forward name="list" path="/WEB-INF/page/personlist.jsp"></forward>  
  7.         </action>  
  8.     </action-mappings>  
  9.       
  10. </struts-config>  

DelegatingActionProxy这个类的作用就是在struts接收到请求之后，会直接交给spring容器处理，spring容器会 根据一开是就在beans.xml中注册的bean来寻找是否对应的bean，beans.xml中一开始需要把Action注册进去：

beans.xml中加入：

[html] view plaincopy
  1. <bean name="/person/list" class="com.pccw.action.PersonAction"/>  


这里的name必须跟签名struts-config中的path规则一样，当beans.xml中这样配置之后，根据name属性找到该bean，就可以产生相应的Action对象，于是Action中的代码可以改成：

PersonAction.java:

[java] view plaincopy
  1. public class PersonAction extends Action {  
  2.     @Resource private PersonService personService;  //注解注入  
  3.     @Override  
  4.     public ActionForward execute(ActionMapping mapping, ActionForm form,  
  5.             HttpServletRequest request, HttpServletResponse response)  
  6.             throws Exception {  
  7. //------------------------------  1 ---------------------------------------------         
  8. //      System.out.println("request come ~~~~~");  
  9. //      WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(this.getServlet().getServletContext());  
  10. //      PersonService personService = (PersonService)ctx.getBean("personService");  
  11. //      request.setAttribute("persons", personService.getPersons());  
  12. //      System.out.println("get size:"+personService.getPersons().size());  
  13. //      return mapping.findForward("list");  
  14.           
  15. // ------------------------------ 2 ---------------------------------------------  
  16.         request.setAttribute("persons", personService.getPersons());  
  17.         return mapping.findForward("list");  
  18.   
  19.     }  
  20.       
  21. }  


第三种方式跟第二种差不多，在struts-config.xml中加入一个控制器属性：

struts-config.xml:

[html] view plaincopy
  1. <struts-config>   
  2.     <form-beans>   
  3.     </form-beans>   
  4.     <action-mappings>   
  5.         <action path="/person/list">  
  6.             <forward name="list" path="/WEB-INF/person/person_list.jsp" />  
  7.         </action>  
  8.     </action-mappings>  
  9.     <controller processorClass="org.springframework.web.struts.DelegatingRequestProcessor"/>   
  10.     <message-resources parameter="MessageResources" />    
  11. </struts-config>  

其作用跟第二种方式中的type类差不多，其他的配置和第二种方式一样，这样的方式称为：动作委托方式。

11，当上面的配置都完成之后，把jsp准备好：

personlist.jsp:

[html] view plaincopy
  1. <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>  
  2. <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>  
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
  4. <html>  
  5. <head>  
  6. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">  
  7. <title>人员列表</title>  
  8. </head>  
  9. <body>  
  10.     <c:forEach items="${persons}" var="person">  
  11.         id=${person.id },name=${person.name },age=${person.age}<br>  
  12.     </c:forEach>  
  13. </body>  
  14. </html>  


12，启动tomcat，把项目加载进去，打开浏览器，输入：http://localhost:8080/SSH/person/list.do，便可以在页面上看到所有的数据库中的数据了。（这里只实现了查询数据库所有数据的功能）。

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/henuyuxiang/p/3934536.html