Java EE | 浅谈SSH三大框架及整合流程

本文链接： https://blog.csdn.net/ZYZMZM_/article/details/94669078

传统的Java Web应用程序是采用JSP+Servlet+Javabean来实现的，这种模式实现了最基本的MVC分层，有负责前端视图展示的 JSP、负责流程逻辑控制的Servlet以及负责数据封装的Javabean。但是这种结构仍然存在问题：如JSP页面中需要使用符号嵌入很多的 Java代码，造成页面结构混乱，Servlet和Javabean负责了大量的跳转和运算工作，耦合紧密，程序复用度低等等。基于传统框架的问题，引出了SSH三大框架。

配置文件
action与拦截器
Structs2 标签

Hibernate

常用方法
配置文件
为什么使用Hibernat

Spring

核心技术

SSH框架整合

SSH的整合思想
配置文件

什么是SSH

SSH是 struts + spring + hibernate 的一个集成框架，是目前比较流行的一种Web应用程序开源框架。

集成SSH框架的系统从职责上分为四层：表示层、业务逻辑层、数据持久层和域模块层(实体层)，以帮助开发人员在短期内搭建结构清晰、可复用性好、维护方便的Web应用程序。其中使用Struts作为系统的整体基础架构，负责MVC的分离，在Struts框架的模型部分，控制业务跳转，利用Hibernate框架对持久层提供支持，Spring做管理，管理struts(action)和hibernate(sessionFactory)。

对于三大框架的理解：首先是 struts2，就是一个控制器，负责接收页面数据并通过action调用视图层的方法返回所需要的数据，一般采用的是关系型数据库，java是面向对象的语言，hibernate负责数据库的操作，hibernate从原来的业务逻辑层分离出来持久层，对数据库进行操作不需要编写繁琐的sql语句，可以专注业务的开发，更加方便的对数据库进行操作。Spring是一个轻量级的控制反转（ioc）和面向切面（aop）的非侵入性的容器框架。Spring通过ioc的Di思想和各类相互依赖的关系放置在配置文件中，使得各类相对独立存在，调用关系由配置文件完成，这样就实现了各个层之间的解耦合，有利于提高各模块之间的复用，使系统各趋近于高内聚低耦合。

Spring：单单说Spring在SSH中的作用。
①管理Struts：在xml配置文件中为struts的action进行注入。
②管理hibernate：在xml配置文件中配置hibernate的配置信息（dataSource，sessionFactory），为hibernate的dao操作注入sessionFactory属性值。

Struts：用来响应用户的action，对应到相应的类进行处理。

Hibernate：用来把实体类对应到数据库。提供增删改查的基本底层操作。

Struts2

Struts2是一个基于MVC设计模式的Web应用框架，它本质上相当于一个servlet，在MVC设计模式中，Struts2作为控制器(Controller)来建立模型与视图的数据交互。Struts 2 是 Struts的下一代产品，是在 struts 1和WebWork的技术基础上进行了合并的全新的Struts 2框架。其全新的Struts 2的体系结构与Struts 1的体系结构差别巨大。Struts 2以WebWork为核心，采用拦截器的机制来处理用户的请求，这样的设计也使得业务逻辑控制器能够与Servlet API完全脱离开，所以Struts 2可以理解为WebWork的更新产品。

struts2框架的运行结构如下图所示：

客户端发送请求到服务器，服务器接收到请求就先进入web.xml配置文件查看是否配置了过滤器，发现有struts2的过滤器，然后就找到struts.xml配置文件，struts.xml配置文件里有定义一个action，然后就去找到类名叫UserAction这个类，返回相应的字符串为给struts.xml配置文件，struts.xml配置文件的action会调用UserAction类的Login()方法，result接收到了返回的字符串，然后查找结果字符串对应的(Result），result就会调用你指定的jsp页面将结果呈现，最后响应返回客户端。

配置文件

下面我们讲解Struts2 应用程序所需的两个基本配置文件：web.xml、struts.xml。

web.xml配置文件是一种J2EE配置文件，决定servlet容器的HTTP元素需求如何进行处理。它严格来说不是一个Struts2 配置文件，但它是Struts2 运作所需要进行配置的文件。这个文件为每个web应用程序提供接入点。在部署描述符（web.xml）中，Struts2 应用程序的接入点将会定义为一个过滤器。web.xml文件需要在WebContent/WEB-INF文件夹下创建。

 <!-- Struts2核心过滤器 -->
  <!--下面的配置表示对于所有的请求都交给struts来处理 -->
  <filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

注意，我们将Struts2 过滤器映射到 /* ，而不是 /*.action ，这意味着所有的url都会被Struts过滤器解析。

struts.xml文件包含有随着Actions的开发你将要修改的配置信息。

<constant name="struts.custom.i18n.resources" value="globalMessages" /><!-- 
		指定国际化资源文件 -->
	<constant name="struts.i18n.encoding" value="UTF-8" /><!-- 指定编码方式 -->
	<!--name：package名称
        extends:继承的父package名称
        namespace:定义package命名空间 该命名空间影响到url的地址 -->
	<package name="json" namespace="/" extends="json-default,struts-default">
		<!-- 定义拦截器 -->
		<interceptors>
			<interceptor name="userAuthority" class="com.bbs.interceptor.UserInterceptor"></interceptor>
			<interceptor name="adminAuthority" class="com.bbs.interceptor.AdminInterceptor"></interceptor>
		</interceptors>
		
		<!-- 全局result配置 -->
		<global-results>
			<result name="login">/login.jsp</result>
		</global-results>
		<!-- action名称 类路径 调用方法 -->
		<action name="user_CheckName" class="UserAction" method="CheckName">
			<result type="json">
			</result>
		</action>

action中的method方法还有以下写法：

<!-- method中的{1}代表通配符中的第一个* -->
		<action name="user_*" class="UserAction" method="{1}">

action与拦截器

Actions是Struts2框架的核心，因为它们适用于任何MVC（Model View Controller）框架。每个URL映射到特定的action，其提供处理来自用户的请求所需的处理逻辑。

但action还有另外两个重要的功能：

action在将数据从请求传递到视图（无论是JSP还是其他类型的结果）方面起着重要作用。
action必须协助框架确定哪个结果应该呈现在响应请求的视图中。

拦截器在概念上与servlet过滤器或JDK代理类相同。拦截器允许横切功能，把action以及框架分开实现。你可以使用拦截器实现以下操作：

在调用action之前提供预处理逻辑。
在调用action后提供后处理逻辑。
捕获异常，以便可以执行备用处理。

Struts2框架中提供的许多功能都是使用拦截器实现的，包括异常处理，文件上传，生命周期回调和验证等。

如下图：左边是自定义拦截器类，右边是在配置文件中定义拦截器。
在这里插入图片描述

Structs2 标签

Struts2 标签分为控制标签、数据标签、表单标签、Ajax标签。

Hibernate

Hibernate 是一个高性能的对象关系型持久化存储和查询的服务，是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate 不仅关注于从 Java 类到数据库表的映射，也有 Java 数据类型到 SQL 数据类型的映射，另外也提供了数据查询和检索服务。Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用。

下面是一个详细的 Hibernate 应用程序体系结构视图以及一些重要的类。

配置对象是你在任何 Hibernate 应用程序中创造的第一个 Hibernate 对象，并且经常只在应用程序初始化期间创造。它代表了 Hibernate 所需一个配置或属性文件。配置对象提供了两种基础组件。

数据库连接：由 Hibernate 支持的一个或多个配置文件处理。这些文件是 hibernate.properties 和 hibernate.cfg.xml（Spring整合后取消）。
类映射设置：这个组件创造了 Java 类和数据库表之间的联系。

SessionFactory 对象

配置对象被用于创造一个 SessionFactory 对象，使用提供的配置文件为应用程序依次配置 Hibernate，并允许实例化一个会话对象。SessionFactory 是一个线程安全对象并由应用程序所有的线程所使用。

SessionFactory 是一个重量级对象所以通常它都是在应用程序启动时创造然后留存为以后使用。每个数据库需要一个 SessionFactory 对象使用一个单独的配置文件。所以若使用多种数据库那么你要创造多种 SessionFactory 对象。

Session 对象

一个会话被用于与数据库的物理连接。Session 对象是轻量级的，并被设计为每次实例化都需要与数据库的交互。持久对象通过 Session 对象保存和检索。

Session 对象不应该长时间保持开启状态因为它们通常情况下并非线程安全，并且它们应该按照所需创造和销毁。

Transaction 对象

一个事务代表了与数据库工作的一个单元并且大部分 RDBMS 支持事务功能。在 Hibernate 中事务由底层事务管理器和事务（来自 JDBC 或者 JTA）处理。

这是一个选择性对象，Hibernate 应用程序可能不选择使用这个接口，而是在自己应用程序代码中管理事务。

Query 对象

Query 对象使用 SQL 或者 Hibernate 查询语言（HQL） 字符串在数据库中来检索数据并创造对象。一个查询的实例被用于连结查询参数，限制由查询返回的结果数量，并最终执行查询。

Criteria 对象

Criteria 对象被用于创造和执行面向规则查询的对象来检索对象

常用方法

增删改的操作:

添加：save(Object obj);
修改：update(Object obj);
删除：delete(Object obj);

查询的操作:

查询一条记录:
- Object get(Class c,Serializable id);
- Object load(Class c,Serializable id);

查询多条记录:

List find(String hql,Object… args);

配置文件

配置数据库连接池 database.properties：

jdbc_driverClassName=com.mysql.jdbc.Driver
jdbc_url=jdbc:mysql://localhost:3306/bbs?useUnicode=true&amp;characterEncoding=utf-8
jdbc_username=root
jdbc_password=root

配置 *.hbm.xml

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<!-- 建立java类与数据表的映射 -->
	<class name="com.bbs.bean.Announces" table="t_announce">
		<id name="id" type="int">
			<column name="id" />
			<!-- 主键生成策略 -->
			<generator class="native"></generator>
		</id>
		<property name="announcement" column="announcement" type="string" length="20000">
		</property>
		<property name="title" type="string" column="title" length="100">
		</property>
		<property name="thetime" type="java.sql.Timestamp" column="newtime">
		</property>
	</class>
</hibernate-mapping>

为什么使用Hibernat

1、对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。

2、Hibernate是一个优秀的ORM实现。很大程度的简化DAO层的编码工作，将软件开发人员从大量相同的数据持久层相关编程工作中解放出来，使开发更对象化了。

3、移植性好，支持各种数据库，如果换个数据库只要在配置文件中变换配置就可以了，不用改变hibernate代码。

4、支持透明持久化，因为hibernate操作的是纯粹的 java类，没有实现任何接口，没有侵入性。所以说它是一个轻量级框架。

Spring

Spring是一个轻量级的开源的Java 开发框架，主要用于层面设计，解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。spring的核心是一个轻量级的容器，为软件开发提供全方位地支持的应用程序框架。

Spring核心有两个方面IOC(依赖注入) 和 AOP（面向对象切面编程）

Spring贯穿在整个项目之中，每当我们需要 new 一个对象的时候，其实很耗资源的，通过spring可以被动的让我们获取想要的对象而不用每次都去new。

整体来说，Spring是个容器，存放着各种bean，在容器创建时，创建bean，并管理bean。SSH整合起来，是让spring来管理struts和hibernate，并且，能让hibernate能用上spring的事物。

简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

下面解释一下容器的基本概念：

容器是符合某种规范/要求的能够提供一系列服务的管理器，其他人员可以利用容器所提供的服务来方便地实现某些特殊的功能。

示例：
1、Web容器是最常见的一种类型的容器，当我们上网访问一个网站时，通过该网站服务器的web服务器来输出网页到浏览器中供访问者浏览，现在使用最广泛的web容器是Apache软件。
2、Servlet容器（如Tomcat），它提供了JSP和Servlet的运行环境，为服务器增加了使用java语言动态输出页面的功能。

每个容器除了提供特殊的服务，例如web容器输出HTML文件，Servlet容器中调用JSP和Servlet程序输出动态的HTML文件外，还要实现一些体现容器基本特征的功能，比如生命周期管理，查询定位，行为配置，依赖性解析，不同协议层的通信支持，扩展支持等。

核心技术

IOC

控制反转（Inversion of Control，英文缩写为IoC）把创建对象的权利交给框架,是框架的重要特征。它包括依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。

IOC实现了对象之间依赖关系的转移。通过spring框架，开发人员不必在自己的代码中维护对象之间的依赖关系，只需在配置文件中设定。Spring会自动依据配置信息来维护对象之间的依赖关系，将被依赖的对象设置给依赖对象。通俗点说，“你不用找我，我会去找你”。

当A需要调用B时，在传统的程序设计过程中，通常由A来创建B的实例。但在Spring里，创建B的工作不再由A来完成，因此，称为控制反转；创建B实例的工作通常由Spring容器来完成，然后注入A，因此也称为依赖注入。

依赖注入有三种实现方式：（1）设值注入（2）构造方法注入（3）接口注入
　　
AOP

这种在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。

AOP是Spring提供的关键特性之一。AOP即面向切面编程，是OOP编程的有效补充。使用AOP技术，可以将一些系统性相关的编程工作，独立提取出来，独立实现，然后通过切面切入进系统。从而避免了在业务逻辑的代码中混入很多的系统相关的逻辑——比如权限管理，事物管理，日志记录等等。这些系统性的编程工作都可以独立编码实现，然后通过AOP技术切入进系统即可。从而达到了将不同的关注点分离出来的效果。

Spring AOP 模块提供拦截器来拦截一个应用程序，例如，当执行一个方法时，你可以在方法执行之前或之后添加额外的功能。

SSH框架整合

SSH的架构图如下：

SSH的整合思想

Web层：Struts2
Service层：Spring
Dao层：Hibernate
基于中间的Spring框架分别与两个框架进行整合，即完成网页项目三大框架的整合。

Spring 和 Struts整合原则

将Struts2的action对象创建过程交给Spring进行管理。

Spring 和 Hibernate整合原则

1、将Hibernate数据库信息的配置交给Spring进行配置，也可以彻底在Spring中进行Hibernate的配置（不推荐）
2、将sessionFactory对象的交给Spring进行管理

配置文件

web.xml，默认位置在WEB-INF的目录中。

<?xml version="1.0" encoding="UTF-8"?>
<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" version="3.0">
  <display-name></display-name>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
    <!-- 过滤器  -->
  <filter>
    <filter-name>urlFilter</filter-name>
    <filter-class>com.bbs.util.UploadFilter</filter-class>
    <init-param>
      <param-name>DEFAULT_URI_ENCODE</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
  </filter>
    <!-- 对所有URL进行过滤拦截 -->
  <filter-mapping>
    <filter-name>urlFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!-- 解决延迟加载无法初始化代理对象的问题 -->
  <filter>
    <filter-name>OpenSessionInViewFilter</filter-name>
    <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>OpenSessionInViewFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <filter>
  <filter-name>struts2</filter-name>
  <filter-class>com.bbs.interceptor.UEditorFilter</filter-class>
</filter>
  <!-- Struts2核心过滤器 -->
  <!--下面的配置表示对于所有的请求都交给struts来处理 -->
  <filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

    <!-- 配置Spring的核心监听器：监听器在创建时自动查找WEB-INF
    下的applicationContext.xml文件，从而创建spring容器-->
    <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/applicationContext.xml</param-value>
  </context-param>
</web-app>

Struts.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "http://struts.apache.org/dtds/struts-2.1.dtd">
<struts>
	<!-- 指定国际化资源文件 -->
	<constant name="struts.custom.i18n.resources" value="globalMessages" />
	<!-- 指定编码方式 -->
	<constant name="struts.i18n.encoding" value="UTF-8" />
	<!--name：package名称
        extends:继承的父package名称
        namespace:定义package命名空间 该命名空间影响到url的地址 -->
	<package name="json" namespace="/" extends="json-default,struts-default">
		<!-- 定义拦截器 -->
		<interceptors>
			<interceptor name="userAuthority" class="com.bbs.interceptor.UserInterceptor"></interceptor>
			<interceptor name="adminAuthority" class="com.bbs.interceptor.AdminInterceptor"></interceptor>
		</interceptors>
		
		<!-- 全局result配置 -->
		<global-results>
			<result name="login">/login.jsp</result>
		</global-results>
		<!-- action名称 类路径 调用方法 -->
		<action name="user_CheckName" class="UserAction" method="CheckName">
			<result type="json">
			</result>
		</action>
		<action name="user_CheckNic" class="UserAction" method="CheckNic">
			<result type="json">
			</result>
		</action>
		<action name="cate_new_getType" class="CategoryAction" method="new_getType">
			<result name="cate_new_getType_ok_json" type="json">
				<param name="includeProperties">listType.*</param>
			</result>
			<interceptor-ref name="userAuthority">
				<param name="includeMethods">new_getType</param>
			</interceptor-ref>
			<interceptor-ref name="defaultStack" />
		</action>
		<action name="cate_ManageAllType" class="CategoryAction"
			method="ManageAllType">
			<result name="cate_manageAllType_ok_json" type="json">
				<param name="includeProperties">listType.*,category.*</param>
			</result>
			<interceptor-ref name="adminAuthority">
				<param name="includeMethods">ManageAllType</param>
			</interceptor-ref>
			<interceptor-ref name="defaultStack" />
		</action>
	</package>
	<package name="user" namespace="/" extends="struts-default">
		<!-- 用户相关操作拦截器 -->
		<interceptors>
			<interceptor name="userAuthority" class="com.bbs.interceptor.UserInterceptor"></interceptor>
			<interceptor name="adminAuthority" class="com.bbs.interceptor.AdminInterceptor"></interceptor>
			<interceptor name="superAdminAuthority" class="com.bbs.interceptor.SuperAdminInterceptor"></interceptor>
		</interceptors>
		<global-results>
			<result name="login">/login.jsp</result>
			<result name="error">/error.jsp</result>
			<result name="a_error">/a/a_error.jsp</result>
		</global-results>
		<!-- 用户action -->
		<!-- method中的{1}代表通配符中的第一个* -->
		<action name="user_*" class="UserAction" method="{1}">
			<!-- 用户登录返回结果处理 -->
			<result name="user_login_ok" type="redirect">/index.jsp</result>
			<result name="login_error">/error.jsp</result>
			<result name="user_register_ok" type="redirect">/index.jsp</result>
			<result name="user_logout_ok" type="redirect">/login.jsp</result>
			<result name="user_goUser_ok">/user.jsp</result>
			<result name="user_goUserAllTopics_ok">/userTopics.jsp</result>
			<result name="user_goHome_ok">/u/home.jsp</result>
			<result name="user_getTopics_ok">/u/topics.jsp</result>
			<result name="user_getComments_ok">/u/comments.jsp</result>
			<result name="user_getNews_ok">/u/news.jsp</result>
			<result name="user_updateInfo_ok">/u/updateInfo.jsp</result>
			<result name="user_updatePass_ok">/u/updatePass.jsp</result>
			<!-- 引用拦截器 -->
			<interceptor-ref name="userAuthority">
				<param name="includeMethods">Logout,GoHome,GetTopics,GetComments,GetNews,UpdateInfo,UpdatePass</param>
			</interceptor-ref>
			<result name="user_manageAll_ok">/a/manageUsers.jsp</result>
			<result name="user_manageGoUser_ok">/a/user.jsp</result>
			<result name="user_manageGoUserAllTopics_ok">/a/userTopics.jsp</result>
			<result name="user_manageRole_ok" type="redirectAction">user_ManageAll</result>
			<result name="user_manageARole_ok" type="redirectAction">user_ManageAll
			</result>
			<result name="user_manageSRole_ok" type="redirectAction">user_ManageAll
			</result>
			<result name="user_manageDelete_ok" type="redirectAction">user_ManageAll
			</result>
			<result name="user_manageUnDelete_ok" type="redirectAction">user_ManageAll
			</result>
			<interceptor-ref name="superAdminAuthority">
				<param name="includeMethods">ManageAll,ManageDelete,ManageUnDelete,ManageARole,ManageSRole</param>
			</interceptor-ref>
			<interceptor-ref name="defaultStack" />
		</action>

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:p="http://www.springframework.org/schema/p" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
      	      http://www.springframework.org/schema/beans/spring-beans.xsd  
              http://www.springframework.org/schema/aop
              http://www.springframework.org/schema/aop/spring-aop.xsd  
              http://www.springframework.org/schema/context
              http://www.springframework.org/schema/context/spring-context.xsd  
              http://www.springframework.org/schema/tx
              http://www.springframework.org/schema/tx/spring-tx.xsd  
			  http://www.springframework.org/schema/util
			  http://www.springframework.org/schema/util/spring-util.xsd "
	default-lazy-init="false">
	<!-- 引入属性文件 -->
	<context:property-placeholder location="classpath:database.properties" />
	<!-- 使用annotation定义事务 -->
	<!-- 支持 @Transactional 标记 -->
	<tx:annotation-driven transaction-manager="transactionManager" />

	<!-- 配置连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
		destroy-method="close">
		<property name="driverClass">
			<value>${jdbc_driverClassName}</value>
		</property>
		<property name="jdbcUrl">
			<value>${jdbc_url}</value>
		</property>
		<property name="user" value="${jdbc_username}" />
		<property name="password" value="${jdbc_password}" />
		<!-- 设置数据库连接池的最大连接数 -->
		<property name="maxPoolSize">
			<value>50</value>
		</property>
		<!-- 设置数据库连接池的最小连接数 -->
		<property name="minPoolSize">
			<value>5</value>
		</property>
		<!-- 设置数据库连接池的初始化连接数 -->
		<property name="initialPoolSize">
			<value>5</value>
		</property>
		<!-- 设置数据库连接池的连接的最大空闲时间,单位为秒 -->
		<property name="maxIdleTime">
			<value>20</value>
		</property>
		<!--c3p0缓存Statement的数量数 -->
		<property name="maxStatements">
			<value>50</value>
		</property>
		<!-- 当连接池里面的连接用完的时候，C3P0一下获取的新的连接数 -->
		<property name="acquireIncrement">
			<value>20</value>
		</property>
	</bean>

	<!-- Hibernate的相关信息 -->
	<!--sessionFactory的创建交给Spring管理 -->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<!-- 注入连接池-->
		<property name="dataSource"> <ref bean="dataSource" />
		</property>
		<!-- 配置Hibernate的映射文件 -->
		<property name="mappingResources">
			<list>
				<value>com/bbs/bean/Users.hbm.xml</value>
				<value>com/bbs/bean/Topics.hbm.xml</value>
				<value>com/bbs/bean/Comments.hbm.xml</value>
				<value>com/bbs/bean/Announces.hbm.xml</value>
				<value>com/bbs/bean/Types.hbm.xml</value>
				<value>com/bbs/bean/Categorys.hbm.xml</value>
				<value>com/bbs/bean/Helps.hbm.xml</value>
				<value>com/bbs/bean/News.hbm.xml</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">
					org.hibernate.dialect.MySQLDialect
				</prop>
				<!-- 解决session关闭问题 -->
				<prop key="hibernate.enable_lazy_load_no_trans">true</prop>
				<!-- <prop key="current_session_context_class">thread</prop> -->
				<!-- 自动创建|更新|验证数据库表结构 validate 加载hibernate时，验证创建数据库表结构 create 每次加载hibernate，重新创建数据库表结构 
					create-drop 加载hibernate时创建，退出是删除表结构 update 加载hibernate自动更新数据库结构 -->
				<prop key="hibernate.hbm2ddl.auto">update</prop>
				<prop key="hibernate.show_sql">false</prop>
				<!-- <prop key="hibernate.format_sql">true</prop> -->
				<prop key="hibernate.cache.provider_class">org.hibernate.cache.HashtableCacheProvider</prop>
				<prop key="hibernate.max_fetch_depth">3</prop>
			</props>
		</property>
	</bean>
	<!-- 事务管理:-->
	<!-- 配置事务管理器（声明式的事务） -->
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate3.HibernateTransactionManager">
	<property name="sessionFactory" ref="sessionFactory" />
</bean>



	<!-- ********************Dao的配置******************** -->
	<!-- 用户 -->
	<bean id="UserDao" class="com.bbs.dao.impl.UserDaoImpl" scope="singleton">
		<!-- 注入sessionFactory -->
		<property name="sessionFactory">
			<ref bean="sessionFactory" />
		</property>
	</bean>
	<!-- ********************Service的配置******************** -->
	<bean id="UserService" class="com.bbs.service.impl.UserServiceImpl"
		scope="singleton">
		<property name="userDao">
			<ref bean="UserDao" />
		</property>
		<property name="pageDao">
			<ref bean="PageDao" />
		</property>
		<property name="topicDao">
			<ref bean="TopicDao" />
		</property>
		<property name="commentDao">
			<ref bean="CommentDao" />
		</property>
		<property name="newDao">
			<ref bean="NewDao" />
		</property>
	</bean>

	<!-- ********************Action的配置******************** -->
	<bean id="UserAction" class="com.bbs.action.UserAction" scope="prototype">
		<!-- 注入Service-->
		<property name="userService">
			<ref bean="UserService" />
		</property>
	</bean>

User.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
                                   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
 	<!--实体类与数据表的配置-->
	<class name="com.bbs.bean.Users" table="t_user"
		batch-size="5">
		<!--实体类属性与主键字段的配置-->
		<id name="id" column="id" type="int">
			<!--主键生成方式，由程序向数据库提供-->
			<generator class="increment" />
		</id>
		<!--其他字段的配置-->
		<property name="username" column="username" type="string"
			length="20"></property>
		<property name="password" column="password" type="string"
			length="20"></property>
		<property name="sex" column="sex" type="string" length="2"></property>
		<property name="picture" column="picture" type="string"></property>
		<property name="email" column="email" type="string" length="20"></property>
		<property name="address" column="come_from" type="string"
			length="200"></property>
		<property name="introduction" column="introduction" type="string"
			length="1000"></property>
		<property name="profession" column="profession" type="string"
			length="40"></property>
		<property name="roleId" column="role_id" type="int"></property>
		<property name="nickname" column="nickname" type="string"
			length="32"></property>
		<property name="clock" column="clock" type="int"></property>
		<property name="topCount" column="topic_count" type="int"></property>
		<property name="comCount" column="comment_count" type="int"></property>
		<property name="registerTime" column="register_time" type="java.sql.Timestamp"></property>
		<property name="status" column="status" type="int"></property>
		<!-- 一对多，一个用户有多个帖子 -->
		<set name="userTopics" lazy="true">
			<key column="topics_user_id" foreign-key="id"></key>
			<one-to-many class="com.bbs.bean.Topics" />
		</set>
		<!-- 一对多，一个用户有多个评论 -->
		<set name="userComments" lazy="true">
			<key column="comments_user_id" foreign-key="id"></key>
			<one-to-many class="com.bbs.bean.Comments" />
		</set>
		<!-- 一对多，一个用户会发布多条评论产生多条消息 -->
		<set name="userCommentNews">
			<key column="news_comment_user_id" foreign-key="id"></key>
			<one-to-many class="com.bbs.bean.News" />
		</set>
	</class>
</hibernate-mapping>

log4j的properties文件:

log4j.rootLogger=DEUBG, CATALINA

# Define all the appenders
log4j.appender.CATALINA=org.apache.log4j.DailyRollingFileAppender
log4j.appender.CATALINA.File=${catalina.base}/logs/catalina.
log4j.appender.CATALINA.Append=true
log4j.appender.CATALINA.Encoding=UTF-8
# Roll-over the log once per day
log4j.appender.CATALINA.DatePattern='.'yyyy-MM-dd'.log'
log4j.appender.CATALINA.layout = org.apache.log4j.PatternLayout
log4j.appender.CATALINA.layout.ConversionPattern = %d [%t] %-5p %c- %m%n

log4j.appender.LOCALHOST=org.apache.log4j.DailyRollingFileAppender
log4j.appender.LOCALHOST.File=${catalina.base}/logs/localhost.
log4j.appender.LOCALHOST.Append=true
log4j.appender.LOCALHOST.Encoding=UTF-8
log4j.appender.LOCALHOST.DatePattern='.'yyyy-MM-dd'.log'
log4j.appender.LOCALHOST.layout = org.apache.log4j.PatternLayout
log4j.appender.LOCALHOST.layout.ConversionPattern = %d [%t] %-5p %c- %m%n

log4j.appender.MANAGER=org.apache.log4j.DailyRollingFileAppender
log4j.appender.MANAGER.File=${catalina.base}/logs/manager.
log4j.appender.MANAGER.Append=true
log4j.appender.MANAGER.Encoding=UTF-8
log4j.appender.MANAGER.DatePattern='.'yyyy-MM-dd'.log'
log4j.appender.MANAGER.layout = org.apache.log4j.PatternLayout
log4j.appender.MANAGER.layout.ConversionPattern = %d [%t] %-5p %c- %m%n

log4j.appender.HOST-MANAGER=org.apache.log4j.DailyRollingFileAppender
log4j.appender.HOST-MANAGER.File=${catalina.base}/logs/host-manager.
log4j.appender.HOST-MANAGER.Append=true
log4j.appender.HOST-MANAGER.Encoding=UTF-8
log4j.appender.HOST-MANAGER.DatePattern='.'yyyy-MM-dd'.log'
log4j.appender.HOST-MANAGER.layout = org.apache.log4j.PatternLayout
log4j.appender.HOST-MANAGER.layout.ConversionPattern = %d [%t] %-5p %c- %m%n

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.Encoding=UTF-8
log4j.appender.CONSOLE.layout = org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern = %d [%t] %-5p %c- %m%n

# Configure which loggers log to which appenders
log4j.logger.org.apache.catalina.core.ContainerBase.[Catalina].[localhost]=INFO, LOCALHOST
log4j.logger.org.apache.catalina.core.ContainerBase.[Catalina].[localhost].[/manager]=INFO, MANAGER
  INFO, MANAGER
log4j.logger.org.apache.catalina.core.ContainerBase.[Catalina].[localhost].[/host-manager]=INFO, HOST-MANAGER
  INFO, HOST-MANAGER