Struts1.3+Spring2.5+Hibernate3手动整合

[size=medium]1.首先准备好整合用的jar包

Hibernate的jar包:hibernate3.jar、lib\required下的所有jar包(共6个)、lib\optional\ehche下的ehcache-1.2.3.jar、slf4j-nop-1.5.2.jar共9个包
Spring的jar包:dist\spring.jar、lib\jakarta-commons下的commons-logging.jar、commons-dbcp.jar、commons-pool.jar、lib\aspectj下的两个jar包、lib\cglib\cglib-nodep-2.1_3.jar、lib\j2ee下的common-annotations.jar、lib\log4j\log4j-1.2.15.jar、dist\modules\spring-webmvc-struts.jar共10个包
Struts的jar包:lib下面的包除antlr-2.7.6.jar(由于Spring中已经存在一个antlr-2.7.6.jar,所以把Struts中的antlr-2.7.2.jar删除，避免jar冲突)外，全部都要，共19个
另外还有数据库驱动包,我用的是MySQL数据库,mysql-connector-java-5.0.5-bin.jar

2.在创建好的WEB项目中引入Hibernate、Spring、Struts以及数据库驱动等所必须的jar包

3.先整合Spring和Hibernate,在SpringXML配置文件中配置数据源[/size]

<?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">
	<!-- 配置数据源 -->
	<bean id="dataSource"
		class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<property name="driverClassName"
			value="org.gjt.mm.mysql.Driver" />
		<!--&是XML支持的&符号，在XML文件中一定记得转义-->
		<property name="url"
			value="jdbc:mysql://localhost:3306/czcspring?useUnicode=true&characterEncoding=UTF-8" />
		<property name="username" value="root" />
		<property name="password" value="netjava" />
		<!--连接池启动时的初始值-->
		<property name="initialSize" value="1" />
		<!--连接池的最大值-->
		<property name="maxActive" value="500" />
		<!--最大空闲值，当经过一个高峰时间后，连接池可以慢慢将已经用不到的链接慢慢释放一部分，一直减少到maxIdle为止-->
		<property name="maxIdle" value="2" />
		<!--最小空闲值，当空闲的链接数少于阀值时，连接池就会预申请去一些链接，以免洪峰来时来不及申请-->
		<property name="minIdle" value="1" />
	</bean>
	<context:annotation-config />
</beans>

[size=medium]4.在SpringXML配置文件中配置Hibernate的SessionFacotry[/size]

<!-- 用于定义SessionFactory对象，对象在容器中是一个单例的形式 -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<!-- 数据源属性 -->
		<property name="dataSource" ref="dataSource" />
		<!-- hibernate实体bean的映射文件,可以配置有多个映射文件 -->
		<property name="mappingResources">
			<list>
				<value>cn/netjava/bean/Userinfo.hbm.xml</value>
			</list>
		</property>
		<!--用来配置hibernate的属性信息-->
		<property name="hibernateProperties">
			<value>
				hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
				hibernate.hbm2ddl.auto=update hibernate.show_sql=false
				hibernate.format_sql=false
			</value>
		</property>
	</bean>

[size=medium]5.SpringXML配置文件中配置事务管理[/size]

<!-- 配置事务管理 -->
	<bean id="txManager"
	class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"></property>
	</bean>
	<!--采用@Transaction注解方式使用事务 事务管理器由txManager配置好的-->
	<tx:annotation-driven transaction-manager="txManager" />

[size=medium]6.建立user表的pojo类[/size]

package cn.netjava.pojo;

public class Userinfo {
	private Integer id;
	private String name;
	private Integer age;

	public Userinfo() {
	}

	public Userinfo(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;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	public String toString() {
		return "id: " + id + "  name: " + name + " age: " + age;
	}
}

[size=medium]7.实体Bean配置Userinfo.hbm.xml[/size]

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<!-- 这里一定要指明不延迟加载才行 -->
	<class name="cn.netjava.pojo.Userinfo" table="user" lazy="false">
		<id name="id" column="id">
			<generator class="native" />
		</id>
		<property name="name" column="name" length="20"
			not-null="true">
		</property>
		<property name="age" column="age" not-null="true"></property>
	</class>
</hibernate-mapping>

[size=medium]8.创建业务层服务接口UserinfoService[/size]

package cn.netjava.service;

import java.util.List;

import cn.netjava.pojo.Userinfo;

public interface UserinfoService {
	/**
	 * 保存Userinfo
	 * 
	 * @param user
	 */
	public void save(Userinfo user);

	/**
	 * 更新Userinfo
	 * 
	 * @param user
	 */
	public void update(Userinfo user);

	/**
	 * 获取Userinfo
	 * 
	 * @param userId
	 * @return
	 */
	public Userinfo getUserinfo(Integer userId);

	/**
	 * 获取所有Userinfo
	 * 
	 * @return
	 */
	public List<Userinfo> getUserins();

	/**
	 * 删除指定id的Userinfo
	 * 
	 * @param userId
	 */
	public void delete(Integer userId);
}

[size=medium]9.建立业务层服务类UserinfoServiceBean[/size]

package cn.netjava.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 cn.netjava.pojo.Userinfo;
import cn.netjava.service.UserinfoService;

//spring xml文件中配置事务时采用注解方式进行配置的，所以在此处我们要加上@Transaction
@Transactional
public class UserinfoServiceBean implements UserinfoService {
	// 使用SpringIOC依赖注入的方式注入SessionFactory对象
	@Resource
	private SessionFactory sessionFactory;

	public void delete(Integer userId) {
		sessionFactory.getCurrentSession()
				.delete(
						sessionFactory.getCurrentSession().load(Userinfo.class,
								userId));
		System.out.println("用户删除成功");
	}

	@Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
	public Userinfo getUserinfo(Integer userId) {
		return (Userinfo) sessionFactory.getCurrentSession().load(
				Userinfo.class, userId);
	}

	@Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
	@SuppressWarnings("unchecked")
	// 终止警告
	public List<Userinfo> getUserins() {
		//这个hql语句里面的Userinfo不是表名，而是pojo类名字
		return sessionFactory.getCurrentSession().createQuery("from Userinfo")
				.list();
	}

	public void save(Userinfo user) {
		// 调用persist方法进行保存
		sessionFactory.getCurrentSession().persist(user);
		System.out.println("用户保存成功");
	}

	public void update(Userinfo user) {
		// 从Spring容器中得到当前被Spring容器管理的Session对象 调用merge方法进行更新。
		sessionFactory.getCurrentSession().merge(user);
		System.out.println("用户信息更新成功");
	}
}

[size=medium]最后把下面这代码加入到SpringXML配置文件中去[/size]

<bean id="userinfoService"
		class="cn.netjava.service.impl.UserinfoServiceBean">
	</bean>

[size=medium]10.对业务层UserinfoServiceBean的每个方法进行单元测试[/size]

package cn.netjava.test;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.netjava.pojo.Userinfo;
import cn.netjava.service.UserinfoService;

public class TestUtil {
	private static UserinfoService userinfoService;

	public static void setUpBeforeClass() throws Exception {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
				"spring.xml");
		userinfoService = (UserinfoService) applicationContext
				.getBean("userinfoService");
	}

	public static void main(String args[]) throws Exception {
		setUpBeforeClass();
		List<Userinfo> userlist = userinfoService.getUserins();
		 for (Userinfo u : userlist) {
			System.out.println(u.toString());
		}
	}
}

[size=medium]测试结果如下:
[img]http://dl.iteye.com/upload/attachment/294481/20018ed6-1b54-3b7a-b6d7-476c2eeb97fb.jpg[/img]

到此已经将Spring与Hibernate整合成功,接下来再整合Struts

11.在Web容器中配置Struts，即在web.xml中配置[/size]

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
	http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

	<!-- 配置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>

        <welcome-file-list>
		<welcome-file>index.jsp</welcome-file>
	</welcome-file-list>
</web-app>

[size=medium]12.在Web容器中实例化Spring容器,在web.xml中配置如下：[/size]

<!-- 制定Spring配置文件,默认从Web根目录寻找配置文件, -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:spring.xml</param-value>
	</context-param>
	<!-- 在Web容器中实例化Spring容器,并将实例放入Application范围内 -->
	<listener>
		<listener-class>
			org.springframework.web.context.ContextLoaderListener
		</listener-class>
	</listener>

[size=medium]13.建立Struts的Action文件UserinfoAction[/size]

package cn.netjava.action;

import java.util.List;

import javax.annotation.Resource;
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 cn.netjava.pojo.Userinfo;
import cn.netjava.service.UserinfoService;

public class UserinfoAction extends Action {

	public ActionForward execute(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response)
			throws Exception {
		 // 取得被放置在Application范围里边的Spring容器实例
		WebApplicationContext ctx = WebApplicationContextUtils
				.getWebApplicationContext(this.servlet.getServletContext());
		// 通过Spring容器得到业务bean实例
		UserinfoService userinfoService = (UserinfoService) ctx
				.getBean("userinfoService");
		List<Userinfo> userinfoList = userinfoService.getUserins();
		System.out.println("得到总数：" + userinfoList.size());
		request.setAttribute("userinfoList", userinfoList);
		return mapping.findForward("list");
	}
}

[size=medium]14.建立Struts配置文件struts-config.xml,把UserinfoAction配置好[/size]

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

	<action-mappings>
		<action path="/userinfo" type="cn.netjava.action.UserinfoAction" scope="request">
			<forward name="list" path="/userinfoList.jsp" />
		</action>
	</action-mappings>
</struts-config>

[size=medium]15.创建一个显示查询结果的userinfoList.jsp页面[/size]

<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<%
	String path = request.getContextPath();
	String basePath = request.getScheme() + "://"
			+ request.getServerName() + ":" + request.getServerPort()
			+ path + "/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
	<head>
		<base href="<%=basePath%>">

		<title>用户信息列表</title>

		<meta http-equiv="pragma" content="no-cache">
		<meta http-equiv="cache-control" content="no-cache">
		<meta http-equiv="expires" content="0">
		<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
		<meta http-equiv="description" content="This is my page">
		<!--
	<link rel="stylesheet" type="text/css" href="styles.css">
	-->

	</head>

	<body>
		<h1>
			Test Reslut
		</h1>
		<c:forEach items="${userinfoList}" var="user">
			ID=${user.id},Name=${user.name},Age=${user.age}<br>
		</c:forEach>
	</body>
</html>

[size=medium]页面显示结果如下：
[img]http://dl.iteye.com/upload/attachment/294483/0a758ccb-5ea9-3c4b-bcb3-0cdfcf045efe.jpg[/img]


虽然已成功将SSH整合成功了，但有一点缺陷的地方就是在Action每次要取得Spring容器时，都要通过

WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(this.servlet.getServletContext());

去获取Spring容器实例,其实我们可以通过Spring的依赖注入原理省去其中的步骤

16.使用SpringIOC依赖注入管理Struts的Action

把struts.cfg.xml的内容改为如下形式：[/size]

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

	<!--采用SpringIOC的依赖注入，此处的type可以不配置。
		如果配置type，请求处理器会在Spring容器寻找不到的Bean实例情况下，
		会交给Struts进行处理，Struts会创建该对象并放入缓存中。
		建议：如果使用了Spring的依赖注入，type也就无需要配置了。 -->
	<action-mappings>
		<action path="/userinfo" scope="request">
			<forward name="list" path="/userinfoList.jsp" />
		</action>
	</action-mappings>

	<!-- 配置spring的请求控制器 -->
	<!-- 
	请求路径是/userinfo.do
	首先交给ActionServlet处理，接下来交给Spring的请求处理器来处理
	Spring的请求处理器的工作就是：
	请求处理器会根据用户请求的路径(/userinfo)，到Spring容器中寻找和名称匹配的Bean，
	寻找到之后就采用Bean实例处理用户的请求。
	-->
	<controller>
		<set-property property="processorClass"
			value="org.springframework.web.struts.DelegatingRequestProcessor"></set-property>
	</controller>
</struts-config>

[size=medium] 将下面这行代码加到SpringXML配置文件中去[/size]

	<!-- 配置struts中处理bean的Action-->
	<bean name="/userinfo" class="cn.netjava.action.UserinfoAction"></bean>

注意:一定要确保action的path属性值与bean的名称相同,尤其别掉了"/"

在UserinfoAction中可以写成如下形式:

package cn.netjava.action;

import java.util.List;

import javax.annotation.Resource;
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 cn.netjava.pojo.Userinfo;
import cn.netjava.service.UserinfoService;

public class UserinfoAction extends Action {

	@Resource
	UserinfoService userinfoService;

	public ActionForward execute(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response)

		List<Userinfo> userinfoList = userinfoService.getUserins();
		System.out.println("得到总数：" + userinfoList.size());
		request.setAttribute("userinfoList", userinfoList);
		return mapping.findForward("list");
	}
}

[size=medium]org.springframework.web.struts.DelegatingRequestProcessor处理流程如下:
[img]http://dl.iteye.com/upload/attachment/294485/f3e5c4c2-f887-3d38-9fe6-db9e53590fc0.jpg[/img]

由于用到的库文件太多，在此我只能把源码和数据库文件传上来,希望对刚接触SSH的人有所帮助。[/size]