Hibernate+spring+struts1的整合

最新推荐文章于 2019-08-26 21:46:41 发布

会飞行的猪

最新推荐文章于 2019-08-26 21:46:41 发布

阅读量569

点赞数

分类专栏： SSH 文章标签： hibernate spring struts1

本文链接：https://blog.csdn.net/u011249702/article/details/51015453

版权

SSH 专栏收录该内容

0 篇文章 0 订阅

订阅专栏

现在一般的项目都是整合的struts2，现在也介绍下怎么样整合struts1，和struts2的整合有诸多类似的。
一.首先明确开发需要解决的问题确定使用的框架，使用的框架又需要引入必要jar包和其他辅助类jar包，所以第一步是引入一般情况下需要的jar包：
Hibernate：

hibernate3.jar
lib\optional\ehcache\ehcache-1.5.0.jar
slf4j-log4j12-1.5.0.jar（Hibernate注解包）
lib\required*.jar｛
antlr-2.7.6.jar
commons-collections-3.1.jar
dom4j-1.6.1.jar
javassist-3.12.0.GA.jar
jta-1.1.jar
slf4j-api-1.6.1.jar
｝

Spring：
dist\spring.jar
dist\modules\spring-webmvc-struts.jar
lib\jakarta-commons\commons-logging.jar,commons-dbcp.jar,commons-pool.jar
lib\aspectj\aspectjrt.jar,aspectjweaver.jar
lib\cglib\cglib-nodep-2.1_3.jar
lib\j2ee\common-annotations.jar
lib\log4j\log4j-1.2.15.jar
Struts-1.3.8：

建议官网下载的包添加lib下所有的jar，注意的是替换低版本重复的jar，比如jstl.jar，standard.jar，antlr-2.7.2.jar在Hibernate中已经添加,记得添加hibernate中的jpa包，有的可能会报错

这里写图片描述

集成一般都是一步一步的，首先是hibernate和spring的集成，首先搭建spring的环境：

配置模版中拷贝bean.xml的配置文件，记住引入必要的命名空间：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

    <context:annotation-config/>

        <bean id="personService" class="com.heying.service.impl.PersonServiceBean"></bean>

        <!-- 配置数据连接池 -->
        <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
            <property name="url" value="jdbc:mysql:///hibernate_001?useUnicode=true&amp;characterEncoding=UTF-8"></property>
            <property name="driverClassName" value="org.gjt.mm.mysql.Driver"></property>
            <property name="username" value="root"></property>
            <property name="password" value="heyingxxx"></property>

            <!-- 连接池初始值 -->
            <property name="initialSize" value="1"/>
            <!-- 连接池最大值 -->
            <property name="maxActive" value="500"/>
            <!-- 连接池最大空闲值 -->
            <property name="maxIdle" value="2"/>
            <!-- 连接池最小空闲值 -->
            <property name="minIdle" value="1"/>
        </bean>   
</beans>

首先引入spring的环境配置bean和数据源，可以测试jar包和数据源是否可以使用：
前面已经介绍怎么测试得到bean，只要在ClassPathXmlApplicationContext得到这个bean，然后使用dataSource的实例可以测试数据库是否可以连接

    @Test
    public void testCase() throws Exception {
        try {
            DataSource dataSource = (DataSource) context.getBean("dataSource");
            System.out.println(dataSource.getConnection());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

这里写图片描述

可以使用数据源，现在需要使用hibernate的sessionFaction来管理到session，所以需要将数据源注入到sessionFaction，sessionFaction有几个常用的属性：dataSource（数据源），mappingResources（实体bean的映射文件），hibernateProperties（数据库的配置，包括方言，建表方式，是否打印执行语句，是否格式化打印的语句等）

    <!-- 配置sessionFactory,注入dataSource -->
        <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
            <property name="dataSource" ref="dataSource"></property>
            <property name="mappingResources">
                <list>
                    <value>com/heying/bean/Person.hbm.xml</value>
                </list>
            </property>
            <property name="hibernateProperties">
                <value>
                    hibernate.dialect=org.hibernate.dialect.MySQLDialect
                    hibernate.hbm2ddl.auto=update
                    hibernate.show_sql=true
                    hibernate.format_sql=false
                </value>
            </property>
        </bean>

一般的逻辑都会涉及到事务管理，所以需要把sessionFaction交给事务管理


        <!-- 配置事务管理器 -->
        <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
            <property name="sessionFactory" ref="sessionFactory"></property>
        </bean>


        <!-- 注册事务管理器 -->
        <tx:annotation-driven transaction-manager="txManager"/>

这样bean.xml文件可算配置好了，接下来就是配置服务层，这边只是简单的写增删改查方法来模拟，现实的开发要复杂，所以大家还需多多去体会和学习

这边只给出实现类，不提供接口类了：

package com.heying.service.impl;

import java.util.List;

import javax.annotation.Resource;

import org.hibernate.SessionFactory;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.heying.bean.Person;
import com.heying.service.PersonService;

@Transactional // 开启事务管理
public class PersonServiceBean implements PersonService {

    // 注解方式定义 SessionFactory，默认按照名称查找，然后按照类型
    @Resource 
    private SessionFactory sessionFactory;


    public void save(Person person) throws Exception{
        sessionFactory.getCurrentSession().persist(person); // persist 持久化对象
    }

    public void update(Person person){
        sessionFactory.getCurrentSession().merge(person);
    }


    @Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true)
    public Person get(Integer id){
        return (Person) sessionFactory.getCurrentSession().get(Person.class, 1);
    }


    public void delete(Integer id){
        Person person = (Person) sessionFactory.getCurrentSession().load(Person.class, id);
        sessionFactory.getCurrentSession().delete(person);
    }

    @SuppressWarnings("unchecked")
    public List<Person> findAll() {
        return sessionFactory.getCurrentSession().createQuery("from Person").list();
    }
}

一个实体，一个实体需要对应的实体xml文件，这种文件是实体和数据库的映射，所以需要对属性定义必须小心，另外注意的是实体必须存在一个无参数的构造器，有的开发者使用调用实体初始化时候一定要注意添加一个无参数的构造器，否者会报错。

package com.heying.bean;

public class Person {

    private Integer id;
    private String name;

    public Person() {} // 实体bean必须保留一个无参数的构造器

    public Person(String name) {
        this.name = name;
    }

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

Person.hbm.xml，带有.hbm的可以让开发工具识别，其实和其他的xml文件无异，其中注意几项：
package: 实体的包名

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
          "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.heying.bean">
    <class name="Person" table="t_person">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name" type="string"></property>
    </class>

</hibernate-mapping>

测试保存：

    @Test
    public void testSave() {
        try {
            personService.save(new Person("heying_"+new SimpleDateFormat("yyyy-MM-dd").format(new Date())));
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            List<Person> list = personService.findAll();
            for (int i = 0; i < list.size(); i++) {
                System.out.println("编号："+list.get(i).getId());
                System.out.println("姓名："+list.get(i).getName());
            }
        }
    }

结果：

这里写图片描述
其他的方法可以自己写测试，这边不一一测试。

接下来是struts的集成
①导入lib包
②在web.xml文件中使用过滤器初始化spring容器，使用contextConfigLocation加载配置文件，这个在官方文件中有介绍：

这里写图片描述

在wen.xml配置这两项：

  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:bean.xml</param-value> <!-- 默认为WEB-INF/下，这边更改为classPath下，大家注意下路径 -->
  </context-param>
  <!-- 实例化spring容器 -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener> 

  <!-- 配置struts --> 
  <servlet>
    <servlet-name>struts</servlet-name>
    <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
    <init-param>
        <param-name>config</param-name>
        <param-value>/WEB-INF/struts-config.xml</param-value>
    </init-param>
    <load-on-startup>0</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>struts</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>

③建立Action配置struts-config.xml文件：

PersonAction.java：

package com.heying.web;

import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

import com.heying.bean.Person;
import com.heying.service.PersonService;

public class PersonAction extends Action{
    @Override
    public ActionForward execute(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response)throws Exception {

            WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(
                    this.getServlet().getServletContext()); //通过Struts的WebApplicationContext获取去spring的容器实例

            PersonService personService = (PersonService) context.getBean("personService");// getBean
            List<Person> list = personService.findAll();
            request.setAttribute("list", list);

            return (mapping.findForward("success"));
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts-config PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
    "http://struts.apache.org/dtds/struts-config_1_3.dtd">

<struts-config>
    <form-beans></form-beans>

    <action-mappings>
        <action path="/test" type="com.heying.web.PersonAction" scope="request">
            <forward name="success" path="/WEB-INF/searchPerson.jsp"></forward>
        </action>
    </action-mappings>
</struts-config>

jsp：

<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<%@ page contentType="text/html; charset=utf-8" %>
<%@page import="com.heying.bean.Person"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<%
List<Person> list = (List<Person>)request.getAttribute("list");
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>search</title>
    <meta http-equiv="pragma" content="no-cache">
  </head>

  <body>
    <table>
    <c:forEach items="${list}" var="person">
        <tr>
            <td>编号： </td> <td>${person.id}</td>
            <td>姓名： </td> <td>${person.name}</td>
        </tr>
    </c:forEach>
    </table>
  </body>
</html>

测试：
这里写图片描述

这边struts并没有交给spring管理，所以需要把struts交给spring管理的流程是：
这里写图片描述

一直配置控制器，请求在selvet处理后直接给DelegatingRequestProcesso处理后在spring容器中寻找请求路径去掉.do结尾的字符匹配，如果在spring容器中没有找到，就会交给struts容器中的action-mappings中按照type寻找Action，一般不会配置type。