Spring[1].NET+到Nhibernate到精通

1.Java对象持久化概述1.1.应用程序的分层体系结构1.1.1.基于B/S的典型三层架构说明：1，展现层：提供与用户交互的界面。

2，业务逻辑层：实现各种业务逻辑。

3，数据访问层：负责存放和管理应用程序的持久化业务数据。

1.1.2.数据访问层与Hibernate在Java应用程序中的角色数据访问层（持久化层）封装了数据访问的细节，为业务逻辑层提供了面向对象的API。

完善的持久化层应该达到的目标：1，代码重用性高，可完成所有的数据访问操作。

2，如果需要的话，能够支持多种数据库平台。

3，具有相对独立性，当持久化层变化时，不会影响上层实现。

在数据访问层（持久化层）中可以使用Hibernate框架以实现要求，如下图所示：1.2.软件模型1.2.1.各种模型的说明概念模型：模拟问题域中的真实实体。

描述每个实体的概念和属性及实体间关系。

不描述实体行为。

实体间的关系有一对一、一对多和多对多。

关系数据模型：在概念模型的基础上建立起来的，用于描述这些关系数据的静态结构。

有以下内容组成：1，若干表2，表的所有索引3，视图4，触发器5，表与表之间的参照完整性域模型：在软件的分析阶段创建概念模型，在软件设计阶段创建域模型。

组成部分：1，具有状态和行为的域对象。

2，域对象之间的关联。

域对象(domain object)：构成域模型的基本元素就是域对象。

对真实世界的实体的软件抽象，也叫做业务对象（Business Object，BO）。

域对象可代表业务领域中的人、地点、事物或概念。

域对象分为以下几种:1，实体域对象：通常是指业务领域中的名词。

（plain old java object，简单Java 对象）。

2，过程域对象：应用中的业务逻辑或流程。

依赖于实体域对象，业务领域中的动词。

如发出订单、登陆等。

3，事件域对象：应用中的一些事件（警告、异常）。

1.2.2.域对象间的关系关联：类间的引用关系。

以属性定义的方式表现。

依赖：类之间访问关系。

Hibernate+Spring多数据库解决方案我以前在项目中的探索和实践，写出来与大家分享。

大家有其他好的方式，也欢迎分享。

环境：JDK 1.4.x , Hibernate 3.1, Spring 2.0.6, JBOSS4.0, 开发模式: Service + DAO我们项目中需要同时使用多个数据库. 但 Hibernate 不能直接支持，为此我们对比了网上网友的方案，自己做了一点探索。

1. Demo需求我们的项目使用一个全省的公共库加十多个地市库的架构。

本文主要说明原理，将需求简化为两库模型。

主库：User管里，主要是系统管理，鉴权等数据；订单库：Order 管理，存放订单等业务性数据。

2. 原理：1） Hibernate 的每个配置文件对应一个数据库，因此多库需要做多个配置文件。

本文以两个为例：主库 hibernate_sys.cfg.xml，订单库 hibernate_order.cfg.xml每个库，Hibernate 对应一个 sessionFactory 实例，因此Hibernate 下的多库处理，就是在多个 sessionFactory 之间做好路由。

2) sessionFactory 有个 sessionFactory.getClassMetadata(voClass) 方法，返回值不为空时，表示该 VO 类在该库中(hbm.xml文件配置在了对应的hibernate.cfg.xml中)，该方法是数据路由的核心和关键所在。

因此， User.hbm.xml 配置在 hibernate_sys.cfg.xml ，Order数据位于配置到 hibernate_order.cfg.xml3）多库处理时，需要使用 XA 事务管理。

本例中使用 Jboss4.0 来做JTA事务管理；用JOTM，其他应用服务器原理相同。

3. 实现1）为做多 sessionFactory 实例的管理，设计 SessionFactoryManager 类，功能就是做数据路由，控制路由的核心是 sessionFactoryMap 属性，它按dbFlag=sessionFactory 的方式存储了多个库的引用。

Hibernate项目的构建与配置1.在项目里倒入Hibernate所必须的Jar包(1)Hibernate框架可以使用在任何的Java项目里，并不一定是Web项目。

只需要在项目里倒入Hibernate所必须要使用的jar包就可以了。

(2)在Hibernate的官网下载hibernate-release-4.2.2.Final.zip解压，要使用Hibernate必须导入的jar包就在目录“hibernate-release-4.2.2.Final\lib\required”下。

倒入此路径下的所有jar包就可以了。

2.配置hibernate.cfg.xml文件(1)配置hibernate.cfg.xml文件可以参考“\project\etc”目录下的hibernate.cfg.xml文件与hibernate.properties文件。

(2)使用Hibernate连接MySQL的hibernate.cfg.xml配置文件如下：<hibernate-configuration><session-factory>（设置显示Hibernate产生的SQL语句）<property name="show_sql">true</property>（设置MySQL的SQL语法的方言）<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>（设置MySQL的驱动程序）<property name="hibernate.connection.driver_class">org.gjt.mm.mysql.Driver</property>（设置MySQL的数据库路径、用户名、密码）<property name="hibernate.connection.url">jdbc:mysql:///java</property><property name="ername">root</property><property name="hibernate.connection.password">lizhiwei</property>（设置当数据库要保存的表不存在时，就新建表）<property name="hibernate.hbm2ddl.auto">update</property>（设置对象与数据库表的关系映射文件）<mapping resource="vo/User.hbm.xml"/></session-factory></hibernate-configuration>(3)此配置文件一般放在项目的src目录下。

• Transation：功能上和数据库中的事务完全一样，通过它实现对数据库中事 务的控制。Transation对象是Session对象产生的，所以他的生命周期比 Session短。一个Session的生命周期中可以有多个Transaction对象。
• ConnectonProvider：主要作用是生成与数据库建立了连接的JDBC对象， 同时他还作为数据库连接的缓冲池。通过ConnectionProvider实现了应用程 序和底层的DataSource和DriverManager的隔离。
10
11
1）Increment标识符生成器
HIbernate会以自增的方式生成标识符，事实上是在hibernate的初始化阶段读取将要操 作的表中的最大的ID（select max（ID） from tableName），在向数据库中插入记录 时再在此基础上递增。 这样就会存在并发的问题：如果同时有两个hibernate进程读取 了这个最大值（假设为100），在向数据库中插入数据的时候都会想插入ID为101的记 录，这样就违反了数据库的约束。这个问题只要是存在两个sessionFacotry就会发生， 不能在集群下使用。
• TransactionFactory：是生成Transaction对象的工厂，通过
4
TransactionFactory实现了事务的封装，使其具体的实现方法与应用程序无关
Configuration 接口：配置Hibernate,根启动Hibernate,创建 。 sessionFactory对象
第二章 Hibernate API
目标： •Hibernate API
1
整体概述
概况一
点击此处输入相关文本内容 点击此处输入相关文本内容

3.3. 创建 Hibernate 配置文件 hibernate.cfg.xml
如果在src/resource目录下面建立，需要把resource目录作为源代码路径，目的 是使applicationContext.xml可以输出到WebRoot\WEB-INF\CLASSES目录下面；
第 6 页 共 11 页
Hibernate.cfg.xml配置文件的内容如下：
<?xml version='1.0' encoding='UTF-8'?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "/hibernate-configuration3.0.dtd"> <hibernate-configuration> <session-factory> <property name="connection.url">jdbc:mysql://localhost:3306/test</property> <property name="ername">root</property> <property name="connection.password">123123</property> <property name="connection.driver_class">com.mysql.jdbc.Driver</property> <!-- 数据库方言 --> <property name="dialect">org.hibernate.dialect.MySQLDialect</property> <!-- 显示SQL语句 --> <property name="show_sql">true</property> <!-- 根据需要自动创建数据表 --> <property name="hbm2ddl.auto">update</property> <!-- 指定连接池最小、最大连接数 --> <property name="hibernate.c3p0.min_size">1</property> <property name="hibernate.c3p0.max_size">20</property> <!-- 指定连接池连接的超时时长 --> <property name="hibernate.c3p0.timeout">5000</property> <!-- 指定连接池最大缓存多少个statement对象 --> <property name="hibernate.c3p0.max_statements">100</property> <property name="hibernate.c3p0.idle_test_period">3000</property> <property name="hibernate.c3p0.acquire_increment">2</property> <property name="hibernate.c3p0.validate">true</property> <!-- 对象与数据库表格映像文件 --> <mapping resource="com/pakko/bus/domain/User.cfg.xml" /> </session-factory> </hibernate-configuration>

Nhibernate操作原生SQL以及查询DataTable使用Nhibernate时我们很方便实现实体映射，但是如果遇到复杂查询则显得力不从心，这是我们可以利用Nhibernate来操作原生sql来查询到DataTable来实现我们复杂的查询及其它操作。

以下实例已经过调试，现与大家分享。

///<summary>///执行ExecuteNonQuery///</summary>///<param name="sql"></param>public void ExecuteNonQuery(string sql){ISession session = null;ITransaction transaction = null;try{session = NHibernateHelper.GetCurrentSession();transaction = session.BeginTransaction();IDbCommand command = session.Connection.CreateCommand();transaction.Enlist(command);//注意此处要把command添加到事物中mandText = sql;command.ExecuteNonQuery();mit();}catch (Exception ex){if (transaction != null){transaction.Rollback();}throw ex;}finally{if (session != null){session.Close();}}}///<summary>///填充DataSet///</summary>///<param name="sql"></param>///<returns></returns>public static DataSet ExecuteDataset(string sql){ISession session = null;DataSet ds = new DataSet();try{session = NHibernateHelper.GetCurrentSession();IDbCommand command = session.Connection.CreateCommand(); mandText = sql;IDataReader reader = command.ExecuteReader();DataTable result = new DataTable();//result.Load(reader);//此方法亦可DataTable schemaTable = reader.GetSchemaTable();for (int i = 0; i < schemaTable.Rows.Count; i++){string columnName = schemaTable.Rows[i][0].ToString(); result.Columns.Add(columnName);}while (reader.Read()){int fieldCount = reader.FieldCount;object[] values = new Object[fieldCount];for (int i = 0; i < fieldCount; i++){values[i] = reader.GetValue(i);}result.Rows.Add(values);}ds.Tables.Add(result);}catch (Exception ex){Debug.Assert(false);}finally{if (session != null){session.Close();}}return ds;}///<summary>///填充DataSet（此方法亦可）///</summary>///<param name="sql"></param>///<returns></returns>public DataSet ExecuteDataset(string sql){ISession session = null;DataSet ds = new DataSet();try{session = NHibernateHelper.GetCurrentSession();IDbCommand command = session.Connection.CreateCommand(); mandText = sql;SqlDataAdapter da = new SqlDataAdapter(cmd as SqlCommand); da.Fill(ds);}catch (Exception ex){Debug.Assert(false);}finally{if (session != null){session.Close();}}return ds;}。

长久以来，程序员和数据库总是保持着一种微妙的关系，在商用应用程序中，数据库一定是不可或缺的元件，这让程序员一定要为了连接与访问数据库而去学习SQL 指令，至少对于我而言，我觉得这是一个很不爽的事情。

因此在信息业中有很多人都在研究如何将程序设计模型和数据库集成在一起，对象关系对应(Object-Relational Mapping) 的技术就是由此而生，像Hibernate或NHibernate都是这个技术下的产物，而微软官方一直没有推出类似的框架，依旧依靠这个传统的数据访问工具。

估计微软也听到了来自程序员的抱怨，于是从一个ObjectSpace（ObjectSpace最早在2005年？被提出，可以让应用程序可以用完全对象化的方法连接与访问数据库，其技术概念与NHibernate相当类似）的概念最后在2008年随.net framework 3.5 SP1发布了 Entity Framework，一个附带有图形化设计器的面向实体数据库访问框架。

Entity Framework 利用了抽象化数据结构的方式，将每个数据库对象都转换成应用程序对象(entity)，而数据字段都转换为属性(property)，关系则转换为结合属性(association)，让数据库的E/R 模型完全的转成对象模型，如此让程序设计师能用最熟悉的编程语言来调用访问。

而在抽象化的结构之下，则是高度集成与对应结构的概念层、对应层和储存层，以及支持Entity Framework 的数据提供者(provider)，让数据访问的工作得以顺利与完整的进行。

Entity Framework 以Entity Data Model (EDM) 为主，将数据逻辑层切分为三块，分别为Conceptual Schema, Mapping Schema 与Storage Schema 三层：(1) 概念层：负责向上的对象与属性显露与访问,让上层的应用程序码可以如面向对象的方式般访问数据。

*编写环境：*开发工具：Myeclipse6.01*SPRING ：spring2.0*STRUTS ：struts1.2*HIBERNATE：hibernate3.0*JDK: 1.6*TOMCAT: 6.0*WINDOW641.新建web项目。

2.选中新建项目，右键--》选择“myeclipse”--》添加Struts支持。

3.在弹出的信息框，有必要修改一下图中的地方。

4.上面的操作完成之后，打开我们的项目我们可以看到我们的项目结构发生了变化，引入了一些struts标签和生成了struts-config.xml配置文件。

5.开始添加spring支持，同样选中新建项目，右键--》选择“myeclipse”--》“添加spring 支持”，在弹出的信息框，做如下内容修改：6.点击“next”，直接选择默认，当然也可根据自己的规则做修改。

7.在添加“Hibernate”支持的时候，首先做的工作是创建一个数据源。

这个创建方法有很多中（找百度可得）这里只介绍一种：打开你的myeclipse的右上角的小三角，选择“myeclipsedatabase explorer”在弹出的界面中，在如图位置右键“new”在弹出的界面中做如下修改：修改完成后点击“test driver”成功则继续。

8.暂时回到myeclipse开发界面。

正式开始添加“Hibernate”支持。

在弹出的界面中做如图修改：点击“next”这里如图，选择spring的配置文件。

下一步操作后，做如下图修改操作：下一步之后，界面修改操作，如下图：去掉复选框中的选项，然后点击“finish”完成整个操作。

之后将会直接打开spring的配置文件，然后你核对一下您的数据库连接是否正确。

至此三大支持操作完成，启动没有问题说明框架雏形已经完成。

9.在项目中的WEB-INF下找到web.xml,做如下修改：格式头部分省略，下面是需要新增的代码<!--初始化spring配置参数 --><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext.xml</param-value></context-param><!-- 配置监听 --><listener><listener-class>org.springframework.web.context.ContextLoaderListener</list ener-class></listener><!-- 配置spring过滤器解决中文乱码问题 --><filter>Ps ：这个时候我们再次启动服务的时候，发现可能会报错：因为我们在刚才已经把spring 的配置文件做了初始化，而在spring 的配置文件中有数据源的连接，而我们的项目中可能还缺少一个包：commons-pool-1.4.jar(/detail/u013806366/7897665 )当我们把这个包放在lib 下，我们再次启动项目的时候，错误信息应该会消失。

SpringMVC的搭建一直以来接触到的都是SSH的框架，形成了MVC模式，本来并没有想着去弄另一个MVC模式，但现在springMVC模式很热，所以我也学习一下，首先我声明一下，这个框架我也是在网上找了一些资料才完成的，源文件等也是利用的网上的现成的，但是有对其进行修改。

下面来详细的说一说这个模式的搭建。

首先在spring中是以controller来作为控制器（相当于SSH中的action），其他的和SSH框架没有区别。

因为Spring是基于注解的，所以在整个的模式中都是采用注解的方式来处理，这个项目是用springMVC+hibernate一起来搭建的。

这个项目的搭建我花了很久的时间，也弄了蛮久才成功，希望日后能更加完善！理解更加的深入。

一：整体框架的结构图以及所需的jar包。

这里spring是3.0.1，hibernate是用的3.6，数据库是用的mysql 5.6 ，前提工作是要建立好一个数据库，我这里是名为springmvc的数据库来进行操作，这里是采用的hibernate自动更新的方式，所以可以不需要建表只需要建立起数据库就好。

项目框架的代码结构：二：开始搭建环境。

1，首先把上面所需的包添加进来后，我们要在/WEB-INF目录下的web.xml里面添加spring的监听器，以及相关的配置。

源码如下：<?xml version="1.0"encoding="UTF-8"?><web-app version="2.5"xmlns="/xml/ns/javaee"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_2_5.xsd"><display-name>s3h3</display-name><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext*.xml</param-value> </context-param><listener><listener-class>org.springframework.web.context.ContextLoaderList ener</listener-class></listener><servlet><servlet-name>spring</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</se rvlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/spring-servlet.xml</param-value> </init-param><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>spring</servlet-name><!-- 这里在配成spring,下边也要写一个名为spring-servlet.xml的文件，主要用来配置它的controller --> <url-pattern>*.do</url-pattern></servlet-mapping><welcome-file-list><welcome-file>index.html</welcome-file><welcome-file>index.htm</welcome-file><welcome-file>index.jsp</welcome-file><welcome-file>default.html</welcome-file><welcome-file>default.htm</welcome-file><welcome-file>default.jsp</welcome-file></welcome-file-list></web-app>2，接下来可以编写spring的配置文件，来整合hibernate，主要的配置写在一个专门存放配置文件的源码目录下config文件夹下，这里的applicationContext.xml是spring的主要配置文件，包括数据源等的配置。

ｌｓ，ｈ ｒｉｌ ｒ ｏｅ ｈ ｔｕｉｇｔｅｔ ｉｄｏ ｅ ｈ ｑ ｅ ｏｄ ｖ ｌｐｔ ｅｓ ｓｅ ｃ ｌｉ ｒｖ ｈ ｅ ｅｏ ｍｅ ｆｉｉｎ ｙａ ｄｗｉ ｅｏ — ａｔｔ ｅａｔ ｅｐｏｐ ｓｓｔａ ｓｎ ｈ ＷＯｋｎ ｆｔｃ ｎｉｕ ｔ ｅ ｅｏ ｈ ｙ ｔｍ ａｌｍｐｏ ｅｔ ｅｄ ｖ ｌｐ ｎｔ ｆ ｅ ｃ ｎ ｌｄ ｃ ｕ ｃ ｓ ｅ ｃ ｌ ｐｅｔ ｅｃ ｄ ． ｌ ｈ ｏ ｅ
ｅ ｒｈ ｓａ ｎ ｌｚ ｓｔ ｅａ ｐｉ ｔ ｆＨｉ ｎ ｔ ｎＳｐ ｉ ｍａ ｅ ｘｎ ｒｔ ｘｍ ｌ ｏ ｉｔｏ ｕ ｅｔ ｙ ｔ ｎｅ ａｅ ｗｉｈ ｔ ｅ Ａｔ ｓａ ｃ ｅ ｄａ ａｙｅ ｈ ｐ ｌ ａｉｎｏ ｂ ｒ ａｅｉ ｒ ｇ， ｋ ｓａｃ）ｃｅｅｅ ａ ｐｅｔ ｎｒ ｄ ｃ ｈｅｗａ ｏ ｉｔｇｒｔ ｔ ｈｍ ． ｎ ｃ ｏ ｅ ｎ
Ａｂ ｔａ ｔ Ｈｉｅｎ ｔ ｓｅ ｔｅ ｌ ｏ ｕａ ｓａ ｔｏ Ｒ ａ ｐｎ ． Ｉ ｓａｐ ｒｉｔｎ ｅｓ ｒｉｅ Ｓ）ｉｇ ｉ ａｎ ｗ ＶＣ ｒｍ ｅ ｒ ｎ ｓｒ ｃ ： ｂ ｒａｅｉ ｘ ｒｍｅｙ ｐ ｐ ｌｒａ ｏ ｌｏｆＯ／ Ｍ ｐ ｉｇ ｔｉ ｅｓｓｅ ｃ ｅ ｖｃ ． ｒ ｎ ｓ ｅ Ｍ ｒ ｆａ ｗｏｋ ａｄ
Ｈｉｅｎ ｔ 在 Ｓ ｒｎ ｂ ｒ ａｅ ｐ ｉｇ中 的 研 究 与 应 用
周彩兰 ， 李素芬 ， 孙 琳
（ 汉理工 大学 计 算机科 学 与技 术 学 院 ， 武 湖北 武汉 ４０ ７ ） ３ ００
摘 要 ： ｉ ｒａｅ Ｈｂ ｎｔ是非 常 流行 的数 据库 Ｏ ＲＭａｐ ｇ ｅ ／ ｐ ｉ 工具 ， ｎ 主要 用来实现 对 象持久化 。Ｓｒ ｇ ｐｉ 是继 Ｓｒｔ后又一 新 的 ＭＶＣ ｎ ｔ ｓ ｕ
用 了 ＥＢ 术 。Ｓ ｒ ｇ中降 低代 码 耦 合 度是 通 过控 制 反 Ｊ技 ｐｎ ｉ

spring配置详解1.前⾔公司⽼项⽬的后台，均是基于spring框架搭建，其中还⽤到了log4j.jar等开源架包。

在新项⽬中，则是spring和hibernate框架均有使⽤，利⽤了hibernate框架，来实现持久化，简化sql操作等。

Hibernate配置⽂件可以有两种格式，⼀种是 hibernate.properties，另⼀种是hibernate.cfg.xml。

后者稍微⽅便⼀些，当增加hbm映射⽂件的时候，可以直接在 hibernate.cfg.xml ⾥⾯增加，不必像 hibernate.properties 必须在初始化代码中加⼊。

我们新项⽬中使⽤的是hibernate.cfg.xml格式。

不过在本⽂中不将细述，后续有机会再补上。

公司项⽬中，中间件主要有tomcat，webshpere，WebLogic。

以下，将对项⽬中spring基本配置，log4j的配置，还有中间件的相关参数配置做⼀个初步的介绍。

2.spring配置——以⽼GIS项⽬为例⼦GISV13中的配置涉及到了SpringMVC,IOC,AOP, Quartz⽅⾯的配置。

配置的实现是通过注记配置和XML配置来合作实现。

这⾥，我将按照Spring的配置流程，将其他⼏个⽅⾯的配置融合其中，来进⾏全⾯解析。

2.1SpringMVC的配置2.1.1.web.xml的配置Web程序中，当中间件启动时，中间件会⾸先读取web.xml中的配置。

在web.xml中可以配置监听器，过滤器，servlet映射等等。

在Spring 框架中，我们主要需配置容器初始化时读取的spring容器配置⽂件的路径以及springMVC中的分发器DispatcherServlet。

在GISV13的web.xml中，我们定义了如下内容：InitGISConfigServlet定义了容器启动时，⾸先要运⾏这个⽅法。

然后servletname为MVC的这部分便是定义了springMVC的分发器以及此servlet所对应的加载配置⽂件的路径。

一．搭建struts-2.3.1.21.Jar包：2.配置struts2.3的过滤器，web.xml位置3.web.xml<?xml version="1.0"encoding="UTF-8"?><web-app id="WebApp_ID"version="3.0"xmlns="/xml/ns/javaee"xmlns:xsi="/2001/XMLSchema-instance" xmlns:web="/xml/ns/javaee/web-app_2_5.xsd "xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_3_0.xsd"><!-- struts2单控制器 --><filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.Struts PrepareAndExecuteFilter</filter-class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping></web-app>4.配置struts.xml<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE struts PUBLIC"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN""/dtds/struts-2.3.dtd"><struts><!-- 默认的配置包 --><package name="ssh"extends="struts-default,json-default,jfreechart-default,s pring-default"><action name="login"class="loginAction"><result name="ok">/loginOk.jsp</result><result name="error">/loginError.jsp</result></action></package></struts>5.测试struts二．整合Spring 3.1.1和Struts-2.3.1.21.jar包在配置好的strutsjar的基础上，添加额外Struts jar包：struts2-spring-plugin-2.3.1.2.jarcommons-logging-1.1.1.jarSpring的jar包：org.springframework.core-3.1.1.RELEASE.jarorg.springframework.context-3.1.1.RELEASE.jarorg.springframework.beans-3.1.1.RELEASE.jarorg.springframework.asm-3.1.1.RELEASE.jarorg.springframework.expression-3.1.1.RELEASE.jarorg.springframework.web-3.1.1.RELEASE.jar2.web.xml<?xml version="1.0"encoding="UTF-8"?>web-app id="WebApp_ID"version="3.0"xmlns="/xml/ns/javaee"xmlns:xsi=/2001/XMLSchema-instancexmlns:web="/xml/ns/javaee/web-app_2 _5.xsd"xsi:schemaLocation="/xml/ns/javaee /xml/ns/javaee/web-app_3_0.xsd"><!-- struts2单控制器 --><filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.Str utsPrepareAndExecuteFilter</filter-class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping><!-- spring创建工厂监听器--><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><!-- 告知spring config location 的存储位置--><context-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/classes/applicationContext.xml</par am-value></context-param></web-app>3.配置springapplicationContext.xml<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xmlns:tx="/schema/tx"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/tx/schema/tx/spring-tx-3.0.xsd/schema/aop/schema/aop/spring-aop-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd"> <context:annotation-config /><context:component-scan base-package="com.excel" /></beans>三．整合Hibernate4.1.11.jar包添加Hibernate jar文件Hibernate压缩包中的lib/required/antlr-2.7.7.jardom4j-1.6.1.jarhibernate-commons-annotations-4.0.1.Final.jarhibernate-core-4.1.1.Final.jarhibernate-jpa-2.0-api-1.0.1.Final.jarjavassist-3.15.0-GA.jarjboss-logging-3.1.0.GA.jarjboss-transaction-api_1.1_spec-1.0.0.Final.jar lib/jpa/hibernate-entitymanager-4.1.1.Final.jarlib/optional/c3p0/hibernate-c3p0-4.1.1.Final.jarc3p0-0.9.1.jarSpring中的jar文件org.springframework.aop-3.1.1.RELEASE.jarorg.springframework.jdbc-3.1.1.RELEASE.jarorg.springframework.orm-3.1.1.RELEASE.jarorg.springframework.transaction-3.1.1.RELEASE.jar 其他的Spring支持文件aopalliance.jar -- AOP要用到的jar包以及连接db2的jarDb2jcc.Jar以及支持el表达式的standard.jar2.配置文件<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:jee="/schema/jee"xmlns:tx="/schema/tx"xmlns:aop="/schema/aop"xmlns:p="/schema/p"xmlns:util="/schema/util"xmlns:tool="/schema/tool" xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd/schema/tx/schema/tx/spring-tx.xsd/schema/aop/schema/aop/spring-aop.xsd/schema/jee/schema/jee/spring-jee.xsd/schema/context/schema/context/spring-context.xsd /schema/util/schema/util/spring-util.xsd/schema/tool/schema/tool/spring-tool.xsd"default-lazy-init="true"default-autowire="byName"> <!--配置数据源 --><bean id="dataSource"class="boPooledDataSource"destroy-method="close"><property name="driverClass"value="com.ibm.db2.jcc.DB2Driver" /><property name="jdbcUrl"value="jdbc:db2://192.168.1.35:50000/ZL_DEMO"/><property name="user"value="db2admin"/><property name="password"value="Forwor888"/></bean><!-- hibernate.cfg.xml Spring config --><bean id="sessionFactory"class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><!-- connection --><property name="dataSource"><ref local="dataSource"/></property><!-- hibernate自身属性 --><property name="hibernateProperties"><props><prop key="hibernate.show_sql">true</prop><prop key="hibernate.format_sql">true</prop><propkey="hibernate.dialect">org.hibernate.dialect.DB2Dialect</prop> </props></property><!-- 映射文件 --><property name="mappingResources"><list><value>com/forwor/ssh/entity/xml/User.hbm.xml</value></list></property></bean><!-- 注入 --><bean id="userDAO"class="erDAOImpl"> <property name="sessionFactory"><ref local="sessionFactory"/></property></bean><!-- aop --><!-- transaction --><bean id="userBiz"class="erBizImpl"> <property name="userDAO"><ref local="userDAO"/></property></bean><!-- advice --><bean id="transactionManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager "><property name="sessionFactory"><ref local="sessionFactory"/></property></bean><!-- 事务处理 --><bean id="transactionInterceptor"class="org.springframework.transaction.interceptor.TransactionInterce ptor"><property name="transactionManager"><ref local="transactionManager"/></property><property name="transactionAttributes"><props><prop key="register">PROPAGATION_REQUIRED</prop><!--hibernate4必须配置为开启事务否则 getCurrentSession()获取不到--><prop key="get*">PROPAGATION_REQUIRED,readOnly</prop><prop key="find*">PROPAGATION_REQUIRED,readOnly</prop><prop key="select*">PROPAGATION_REQUIRED,readOnly</prop><prop key="query*">PROPAGATION_REQUIRED,readOnly</prop><prop key="sync*">PROPAGATION_REQUIRED</prop><prop key="finish*">PROPAGATION_REQUIRED</prop><prop key="add*">PROPAGATION_REQUIRED</prop><prop key="insert*">PROPAGATION_REQUIRED</prop><prop key="edit*">PROPAGATION_REQUIRED</prop><prop key="update*">PROPAGATION_REQUIRED</prop><prop key="save*">PROPAGATION_REQUIRED</prop><prop key="remove*">PROPAGATION_REQUIRED</prop><prop key="delete*">PROPAGATION_REQUIRED</prop><propkey="*">PROPAGATION_REQUIRED,ng.Exception</prop></props></property></bean><!-- autoproxy 自动创建代理--><bean id="ProxyCreator"class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyC reator"><property name="beanNames"><list><value>*Biz</value></list></property><property name="interceptorNames"><list><value>transactionInterceptor</value></list></property></bean><bean id="loginAction"class="com.forwor.ssh.web.LoginAction" scope="prototype"><property name="userBiz"><ref local="userBiz"/></property></bean></beans>。

JavaWeb开发中的框架选择与对比随着互联网技术的快速发展，JavaWeb应用开发已经成为了企业级开发应用的首选。

目前，JavaWeb开发中主流的框架有Spring、Struts、Hibernate等，对于初学者来说，选择适合自己的框架可能是一个比较困难的问题。

本文将从架构设计、实现方式、性能等几方面对常用JavaWeb框架进行对比，并分析其优劣，以期帮助初学者快速入门。

一、架构设计1. SpringSpring是一个轻量级的应用框架，其核心思想是控制反转（IoC）和面向切面编程（AOP）。

Spring将业务逻辑与技术实现分开，实现了应用的松耦合，使应用更易于维护和扩展。

2. StrutsStruts是一个基于MVC设计模式的Web框架，其核心思想是将应用程序分离为Model（数据模型）、View（用户界面）和Controller（应用程序控制器），以便于管理、维护和扩展。

3. HibernateHibernate是一个轻量级的ORM框架，其核心思想是通过Java类和数据库之间的映射来访问数据库，使开发人员无需关注SQL语句，只需关注业务逻辑。

二、实现方式1. SpringSpring通过IoC容器来管理应用中对象的依赖关系，通过AOP 技术实现面向切面编程。

Spring支持多种数据源，并提供了事务管理、安全、远程访问等功能。

2. StrutsStruts基于MVC设计模式，将用户请求映射到正确的Action，并将结果返回给用户。

Struts提供了一套完整的标签库，使得前端开发更加方便。

3. HibernateHibernate通过Java类和数据库之间的映射来访问数据库，可自动完成数据库表和类之间的ORM映射。

Hibernate提供了多种查询方式，并支持事务管理和缓存功能。

三、性能比较1. SpringSpring具有很高的扩展性，可以扩展到任何规模的应用中。

Spring的IoC容器具有很高的性能，可在大规模应用中实现很好的稳定性和高性能。

第9章Spring与Struts2、Hibernate框架的整合基础一、搭建Struts框架注：导入的jar包与前面课程介绍的不同二、搭建Spring框架1.添加的类库包括AOP、Core、Persistent Core、JDBC、Web库2.修改applicationContext.xml的存储目录为WebRoot/WEB-INF三、搭建hibernate框架1.建立数据库连接2.搭建框架，注意选择的配置文件为applicationContext.xml而不是hibernate.cfg.xml。

1）设置SessionFactory的Bean id为sessionFactory。

2）设置DataSource的Bean Id为dataSource3）取消“Create SessionFactory class”选项4）导入包commons-pool-1.3到lib文件夹。

四、修改web.xml加入Spring监听器配置，至此所有框架搭建完毕。

<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener>五、数据库建表六、在工程下创建domain、dao包，反向工程自动生成实体类、配置文件、dao类。

1）反向工程将生成的dao文件2）移动dao类到dao包，修改由于移动dao类后applicationContext.xml出现的错误，并将id名首字母改成小写。

3）为dao类提取出接口。

在工作区右键dao文件-》refactor-》extract interface七、编写service、service接口并配置1）创建service包2）创建service类，定义方法findScoreBySnumber()。

SessionFactory 注入Spring 可以与Hibernate结合使用，Hibernate的连结、事务管理等是由建立SessionFactory开始的，SessionFactory在应用程式中通常只需存在一个实例，因而SessionFactory底层的DataSource可以使用Spring的 IoC注入，之后您再注入SessionFactory至相依的物件之中。

例如可以改写一下第一个 Hibernate 程式，首先您可以删除hibernate.cfg.xml，因为这部份可以由Spring在Bean定义档中撰写DataSource设定及依赖注入来取代，您可以如下撰写Spring的Bean 定义档：•beans‐config.xml<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING/DTDBEAN/EN""/dtd/spring-beans.dtd"><beans><bean id="dataSource" class="org.springframework.jdbc.→ datasource.DriverManagerDataSource"><property name="driverClassName"><value>com.mysql.jdbc.Driver</value></property><property name="url"><value>jdbc:mysql://localhost:3306/demo</value></property><property name="username"><value>caterpillar</value></property><property name="password"><value>123456</value></property></bean><bean id="sessionFactory" class="org.springframework.orm.→ hibernate3.LocalSessionFactoryBean"destroy-method="destroy"><property name="dataSource"><ref bean="dataSource"/></property><property name="mappingResources"><list><value>onlyfun/caterpillar/User.hbm.xml</value></list></property><property name="hibernateProperties"><props><prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop></props></property></bean><bean id="userDAO" class="erDAO"><property name="sessionFactory"><ref bean="sessionFactory"/></property></bean> </beans>可以看到使用 Spring 整合 Hibernate 的好处，可以直接将 DataSource 注入至 org.springframework.orm.hibernate3.LocalSessionFactoryBean 中，至于Hibernate 所需的相关设定，则可透过 LocalSessionFactoryBean 的相关属性来设定，像是设定资料库名称、使用者名称、密码等， LocalSessionFactoryBean 会建立SessionFactory 的实例，并在执行依赖注入时将这个实例设定给 UserDAO。