Spring+Hibernate整合
SpringMVC+Spring+Hibernate框架整合原理,作用及使用方法
SpringMVC+Spring+Hibernate框架整合原理,作⽤及使⽤⽅法SSM框架是spring MVC ，spring和mybatis框架的整合，是标准的MVC模式，将整个系统划分为表现层，controller层，service层，DAO层四层使⽤spring MVC负责请求的转发和视图管理spring实现业务对象管理，mybatis作为数据对象的持久化引擎原理：SpringMVC：1.客户端发送请求到DispacherServlet（分发器）2.由DispacherServlet控制器查询HanderMapping，找到处理请求的Controller3.Controller调⽤业务逻辑处理后，返回ModelAndView4.DispacherSerclet查询视图解析器，找到ModelAndView指定的视图5.视图负责将结果显⽰到客户端Spring：我们平时开发接触最多的估计就是IOC容器，它可以装载bean（也就是我们中的类，当然也包括service dao⾥⾯的），有了这个机制，我们就不⽤在每次使⽤这个类的时候为它初始化，很少看到关键字new。
另外spring的aop，事务管理等等都是我们经常⽤到的。
Mybatis：mybatis是对jdbc的封装，它让数据库底层操作变的透明。
mybatis的操作都是围绕⼀个sqlSessionFactory实例展开的。
mybatis通过配置⽂件关联到各实体类的Mapper⽂件，Mapper⽂件中配置了每个类对数据库所需进⾏的sql语句映射。
在每次与数据库交互时，通过sqlSessionFactory拿到⼀个sqlSession，再执⾏sql命令。
使⽤⽅法：要完成⼀个功能：1. 先写实体类entity，定义对象的属性，（可以参照数据库中表的字段来设置，数据库的设计应该在所有编码开始之前）。
2. 写Mapper.xml（Mybatis），其中定义你的功能，对应要对数据库进⾏的那些操作，⽐如 insert、selectAll、selectByKey、delete、update等。
Hibernate+Spring多数据库解决方案
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 的方式存储了多个库的引用。
三大框架整合及其原理
一搭建三大框架步骤1 搭建s2sh步骤分析:1.1在MyEclipse 里面新建一个 java web project1.2新建三个 Source Folder :src : 源文件config : 存放配置文件 : hibernate , spring , struts2test: 测试类1.3 导入环境需要的jar 包 : WebRoot/WEB-INF/lib (一共64个)2 搭建Hibernate 和Spring 整合(*根据搭建需求谁能先测试就先搭建谁)2.1 在 src 源文件里面建立一个 cola.s2sh.domain[并且在该包下创建一个持久类和该类的映射文件] .2.2 配置核心文件在 config 里面建立一个hibernate 文件夹里面创建hibernate.cfg.xml配置文件(里面的内容拷贝就可以)2.3 在spring 文件夹里面创建并且把sessionFactory 交给spring 来管理: [applicationContext-db.xml中引入][<bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation"><value>classpath:hibernate/hibernate.cfg.xml</value> </property></bean>]在 applicationContext.xml 中 : 导入<import resource="applicationContext-db.xml"/>2.4 测试sessionFactory[编写SpringUtils 然后继承这个][public class SpringUtils {public static ApplicationContext context;static {context = newClassPathXmlApplicationContext("spring/applicationContext.xml" );}}]2.5 编写 dao .service 的包类和接口;PersonDaoImpl 要继承HibernateDaoSupport[public class PersonDaoImpl extends HibernateDaoSupport implements PersonDao {public void savePerson(Person person) {this.getHibernateTemplate().save(person);}}]2.6 把 dao ,service 放在spring 容器中:[<bean id="personDao"class="cola.s2sh.daoImpl.PersonDaoImpl"> <property name="sessionFactory"><ref bean="sessionFactory"/></property></bean><bean id="personService"class="cola.s2sh.service.impl.PersonServiceImpl"><property name="personDao"><ref bean="personDao"/></property></bean>]2.7 完成 spring 声明式处理 :[<!-- 事务管理 --><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory"><ref bean="sessionFactory"/></property></bean><tx:advice id="tx"transaction-manager="transactionManager"><tx:attributes><tx:method name="save*"read-only="false"/><tx:method name="update*"read-only="false"/><tx:method name="delete*"read-only="false"/><!--除了上面三种情况以外的情况--><tx:method name="*"read-only="true"/></tx:attributes></tx:advice><aop:config><aop:pointcutexpression="execution(* cola.s2sh.service.impl.*.*(..))"id="perform"/><aop:advisor advice-ref="tx"pointcut-ref="perform"/> </aop:config>]2.8 整合struts 创建 action 类包 ;2.9 把action 放在spring 容器中* 注意在personAction的spring的配置中一定要写一个属性scope="prototype"[<bean id="personAction"class="cola.s2sh.action.PersonAction" scope="prototype"><property name="personService"><ref bean="personService"/></property></bean>]在这个中引入下面3.0 编写struts2中配置文件Struts –person.xml中Struts.xml3.1 编写web .xml文件[<?xml version="1.0"encoding="UTF-8"?><web-app xmlns:xsi="/2001/XMLSchema-instance"xmlns="/xml/ns/javaee"xmlns:web="/xml/ns/javaee/web-app_2_5.xsd"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_3_0.xsd"id="WebApp_ID"version="3.0"><display-name>cola.s2sh</display-name><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener><!—将srping放在SrvletContext中进行加载当servlet加载时 spring 也完成加载 --> <context-param><param-name>contextConfigLocation</param-name><param-value>classpath:spring/applicationContext.xml</param-value> </context-param><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>*.action</url-pattern></filter-mapping><filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter -class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping>]二原理分析:一、 Struts 2框架整合Spring步骤1、复制文件。
struts2+spring3+hibernate整合教程
Struts2+Spring3+hibernate3整合（2011年7月末，最新）上次下载了一个教程，上面写着：“献给我亲爱的老婆！”（羡慕不已）。
想了想，我没老婆，难道没什么好写了！不难…献给我暗恋过的每一个女人!（嘿嘿…）如果在你遇到的女生中有一个幽默豁达的女生，不要犹豫，追上去，就娶她了！一，需要的框架包二，建立project，添加相应的.jar文件（重点）1，eclipse中建立dynamic web project，这里是ssh_integrate_0100。
2，src中创建需要的类，这里以一个域模型为user的例子说明。
(现在建立这些类，可以方便我们在搭建时候随时测试!)User.javaIUserDao.javaUserDaoImpl.javaIUserService.javaUserServiceImpl.java3，拷贝spring-framework-3.1.0\dist目录下的所有jar包，注意有一个不是jar的文件，当然拷过去也没事。
4，拷贝spring运行中需要的其他jar文件，主要是mons-logging，可以从spring-framework-3.0.2.RELEASE-dependencies中找到。
ii.Aspectjrt.jar和aspect-waver.jar，可以从spring-framework-2.5.6-with-dependencies/lib/aspectj下面找到（不知道为什么，spring-framework-3.0.2.RELEASE-dependencies中没有aspectjrt的jar包）iii.aopalliance.Jar，apache-dbcp.jar，apache-pool.jar，可以从spring-framework-3.0.2.RELEASE-dependencies中找到。
5，建立beans.xml，这里使用的是annotation和component-scan，这样配置可以大大简化配置，所以是best-practice，其他配置请参考spring文档。
达梦Hibernate Spring集成开发示例
达梦Hibernate Spring集成开发示例DM是武汉华工达梦数据库有限公司推出的新一代高性能、高安全性的数据库产品。
它具有开放的、可扩展的体系结构，高性能事务处理能力，以及低廉的维护成本。
DM是完全自主开发的数据库软件，其安全级别达到了国内所有数据库产品中的最高级---B1级。
在这里我准备用时下比较流行的开发工具，Hibernate和Spring，达梦数据库。
以及MyEclipse来完成一个简单的应用。
数据库采用达梦5.01、用达梦创建一个test数据库，再创建一个user表，再创建两个字段username和password。
脚本如下create database test datafile 'test.dbf' size 100;set current database testcreate login test identified by test123 default database test;create user test related by test;grant resource to test at test;以上脚本为创建test数据库，并且创建一个登陆名为test 密码是test123drop table xt_user;create table xt_user(user_id varchar(30) not null,user_name varchar(20) not null,user_pwd varchar(30) not null,primary key(user_id));2、打开myeclipse的database explore透视图，右键单击左侧的空白区域，点击new 按钮单击“configure database driver”来配置数据库的驱动。
完成以后，做如下操作：然后测试数据库是否连接成功。
如果测试成功显示如下图：1．新建一个web项目testSpring 2．引入Spring包注意：这里为了省得以后再添加spring的相关包，所以一次性的选中了所有的包。
spring与hibernate集成的session问题
主要讨论Spring与Hibernate集成中的session问题1．通过getSession()方法获得session进行操作Java代码利用这种方式获得的session在方法执行结束之后不会自动关闭连接,也就是说我们必须通过session.close()或者releaseSession(session)来手动进行关闭,否则会造成内存泄露或者连接耗尽等问题。
手动关闭:Java代码如果对上述方法进行事务控制，那么spring框架会自动为我们关闭session，此种情况下再执行上述代码，会抛出如下异常:Java代码提示session已经关闭。
但是如果在代码中通过releaseSession(session)的方法来关闭session，则不会抛出异常。
releaseSession(session)方法的代码如下:Java代码也就是说它是通过SessionFactoryUtils的releaseSession方法来实现的:Java代码可见它内部会先进行判断。
查看getSession()方法的源码:Java代码getSession()方法内部通过它的一个重载方法getSession(boolean allowCreate )来实现,变量allowCreate是HibernateTemplate中的变量,默认值为true,也就是创建一个新的session。
如果我们调用getSession(false)来获得session,那么必须对其进行事务控制,原因是:(spring文档)Java代码也就是说,getSession()方法从当前事务或者一个新的事务中获得session,如果想从一个新的事务中获得session(也就意味着当其不存在事务控制),则必须使HibernateTemplate中的allowCreate变量的值为”true”,而现在设置allowCreate变量的值为”false”就意味着无法从新的事务中获得session,也就是只能从当前事务中获取,所以必须对当前方法进行事务控制,否则会抛出如下异常:Java代码同时，如果对getSession()所在的方法进行事务控制，那么类似如下的代码:只会打开一个session,因为事务控制必须确保是同一个连接,spring会确保在整个相关方法中只存在一个session。
SpringMVC+Hibernate4+Spring3整合开发
SpringMVC+Hibernate4+Spring3整合开发·使用开发工具Myeclipse2014 、Subversion、·首先新建立一个项目SHSpringMVC ，组织好文件结构·将所建立的简单的项目发布到SVN服务器上，（如果你仅仅是想在本机搭建一个开发环境的话，不必要用SVN的，下面关于svn的发布，可以略过）选择SVN 点击Next;找到你的SVN服务资源库，如果没有的话，可以选择创建新的资源库位置；默认点击finish，然后把项目提交上去，就OK了，开始配置三个框架的开发，严谨来说是两个框架；看到如下图所示的界面说明你的项目就发布到SVN服务器上了；·接下来，就要配置开发包，也就是支持的JAR包，首先添加Spring支持，同时呢SpringMVC也是添加上了，我们要做的就是配置MVC框架；配置过程分为手动配置和自动配置，现在大部分工具都支持了自动配置，很少人再去手动配置编写配置文件了，那我们就采用自动配置的方式配置这两大框架的整合开发环境；在项目上右键→Myeclipse→Project Facets→Install Spring Facet持，点击Finish;右键空白处→new 按照下图所示配置，添加Hibernate支持，项目右键→myeclipse→project facets→install hibernate facet选择你刚刚创建的一个数据源，也就是下图显示的DB Driver,下面的一些信息就自动生成了；就选择默认核心包，没必要增加其他插件，OK 了；·增加完成之后，Hibernate 在applicationContext.xml 文件之中增加了如下的几个配置； <bean id ="sessionFactory" 这个bean 是用来连接数据库的，但是缺少了数据库的连接属性，连接属性，我们刚刚放到hibernate.cfg.xml文件之中了，但是为了项目的方便移植和可维护方便，我们就要把配置写到一个配置文件之中，所以需要在applicationContext.xml文件的sessionFactory这个bean之中增加priperty属性；class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><property name="configLocation"value="classpath:hibernate.cfg.xml"></property>→当我们将c3p0的数据库配置添加好之后，这个配置也就可以删掉了；</bean><bean id="transactionManager"→这个bean用来配置事务提交的，不过还不完善，还需要配置很多东西，class="org.springframework.orm.hibernate4.HibernateTransactionManager"> <property name="sessionFactory"ref="sessionFactory"/> </bean>·下面我们新建立一个db.properties的资源文件，用来编写数据库连接信息；db.driverClass=org.gjt.mm.mysql.Driverdb.url=jdbc:mysql://localhost:3306/mysqlername=rootdb.password=mysqladmin我们怎么用这个配置文件呢，当然是需要在applicationContext.xml文件之中配置了；要想知道怎么配置使用这个database.properties这个资源文件，我们必须要了解的当然是ComboPooledDataSource这个类了，ng.Objectcom.mchange.v2.c3p0.impl.AbstractIdentityTokenizedcom.mchange.v2.c3p0.impl.IdentityTokenResolvablecom.mchange.v2.c3p0.impl.PoolBackedDataSourceBasecom.mchange.v2.c3p0.impl.AbstractPoolBackedDataSourcecom.mchange.v2.c3p0.AbstractComboPooledDataSourceboPooledDataSource我们看到ComboPooledDataSource这个类本身仅仅定义了几个构造方法而已，我们需要从他的父类中查找看看；我们能从文档中查到，有很多的setter、getter方法，这意味着什么呢，通过反射调用可以设置内容；也就是说，配置的dataSource这个bean的property的name值都是一定的，也就是不能自己定义，需要用提供好的那些属性名称，值也是有范围的；<bean id="dataSource"class="boPooledDataSource"destroy-method="close"><property name="driverClass"value="${db.driverClass}"/><property name="jdbcUrl"value="${db.url}"/><property name="user"value="${ername}"/><property name="password"value="${db.password}"/><property name="maxPoolSize"value="10000"/><property name="minPoolSize"value="1"/><property name="initialPoolSize"value="1"/><property name="maxIdleTime"value="20"/></bean>配置完成此bean就可与修改sessionFactory这个bean了，我们需要做的就是将其中的property修改为<bean id="sessionFactory"class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><property name="dataSource" ref="dataSource"/></bean>配置好这里，那hibernate.cfg.xml文件之中的数据库连接信息也就不需要了，我们就可以直接删掉了，hibernate.cfg.xml文件就编程如下的配置了，可以添加show_sql 、format_sql<?xml version='1.0'encoding='UTF-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/dtd/hibernate-configuration-3.0.dtd"><!-- Generated by MyEclipse Hibernate Tools. --><hibernate-configuration><session-factory><property name="dialect">org.hibernate.dialect.MySQLDialect</property><property name="myeclipse.connection.profile">mysql</property><property name="show_sql">true</property><property name="format_sql">true</property></session-factory></hibernate-configuration>下面还是需要配置applicationContext.xml文件，配置事务通知属性，这个我也不是很了解怎么配置的，在网上找了一份，可以按照这个配置；<tx:advice id="txAdvice"transaction-manager="transactionManager"> <tx:attributes><tx:method name="update*"propagation="REQUIRED"/><tx:method name="insert*"propagation="REQUIRED"/><tx:method name="edit*"propagation="REQUIRED"/><tx:method name="save*"propagation="REQUIRED"/><tx:method name="add*"propagation="REQUIRED"/><tx:method name="new*"propagation="REQUIRED"/><tx:method name="set*"propagation="REQUIRED"/><tx:method name="remove*"propagation="REQUIRED"/><tx:method name="delete*"propagation="REQUIRED"/><tx:method name="change*"propagation="REQUIRED"/><tx:method name="get*"propagation="REQUIRED"read-only="true"/><tx:method name="list*"propagation="REQUIRED"read-only="true"/><tx:method name="find*"propagation="REQUIRED"read-only="true"/><tx:method name="load*"propagation="REQUIRED"read-only="true"/><tx:method name="*"propagation="REQUIRED"read-only="true"/> </tx:attributes></tx:advice>然后需要找一个log4j.properties的组件，在hibernate的开发文件包之中有一个，应该可以用，你从网上下载好hibernate的文件解压之后，从下面的这个目录可以找到一个log4j.properties文件；\hibernate-release-4.3.8.Final\hibernate-release-4.3.8.Final\project\etc最后要为项目添加annotation、aop、mvc开发支持，最重要的不要忘了，添加database.properties文件的位置，放到dataSource的bean上面就可以了；<context:property-placeholder location="classpath:database.properties"/>配置Annotation<context:annotation-config/><context:component-scan base-package="cn.oracle"/><mvc:annotation-driven/><mvc:default-servlet-handler/>接下来配置web.xml文件，配置Spring MVC的默认servlet处理用户请求；<servlet><servlet-name>springmvc</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet -class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext.xml</param-value> </init-param></servlet><servlet-mapping><servlet-name>springmvc</servlet-name><url-pattern>*.action</url-pattern></servlet-mapping>此时你把项目部署到tomcat 或者weblogic上，看会不会报错，不报错误应该可开发使用了；如果你还要配置Springmvc的资源文件的话，还需要在applicationContext.xml文件之中配置另外一个bean <bean id="messageSource"class="org.springframework.context.support.ResourceBundleMessageSource"> <property name="basenames"><array><value>Message</value><value>Pages</value></array></property></bean>这上面的配置其实就是配置了ResourceBundleMessageSource 这个类下的basenames属性；private String[] basenames = new String[0];。
整合struts1+spring+hibernate框架完成简单的登录
*编写环境：*开发工具：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与hibernate整合实例
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的主要配置文件，包括数据源等的配置。
Struts+Spring+Hibernate整合入门详解
3、运行eclipse，选择一个空目录作为工作区（工程结构如下：其中我们要写的Java代码在Java Resource: src（以后直接称src）下，网站根目录内容在WebContent下，类所在根目录是WEB-INF/classes，Eclipse 会自动将build/classes里面已经编译的类同步过去。
向WEB-INF下的lib目录添加如下所列的jar包。
（1）这些包在下载解压后Spring，Struts，Hibernate的lib目录或者dist/module目录下面（如果不在，可以到网上google一把。
列表中mysql-*.jar包是MySQL数据库的JDBC Driver）。
也可以把所有lib和dist 下的jar包拷贝过来（可以在系统复制这些jar包，然后到Eclipse里面选中WEB-INF里面的lib包，然后粘帖就可以了）。
但要注意全拷贝可能会存在冲突，如struts*plugin.jar等包不能引入，否则不能运行。
（2）这些Jar包是：antlr-2.7.2.jarcglib-nodep-2.1_3.jarcommons-beanutils-1.6.jarcommons-chain-1.1.jarcommons-collections-2.1.1.jarcommons-dbcp.jarcommons-digester.jarcommons-logging-1.0.4.jarcommons-logging-api-1.1.jarcommons-pool.jarcommons-validator-1.3.0.jardom4j-1.6.1.jarel-api.jarel-ri.jarfreemarker-2.3.8.jarhibernate3.jarjsf-api.jarjta.jarmysql-connector-java-3.0.14-production-bin.jarognl-2.6.11.jaroro-2.0.8.jarspring-hibernate3.jarspring.jarstruts-config.xmlstruts-core-1.3.5.jarstruts2-codebehind-plugin-2.0.9.jarstruts2-config-browser-plugin-2.0.9.jarstruts2-core-2.0.9.jarstruts2-jasperreports-plugin-2.0.9.jarstruts2-jfreechart-plugin-2.0.9.jarstruts2-jsf-plugin-2.0.9.jarstruts2-pell-multipart-plugin-2.0.9.jarstruts2-plexus-plugin-2.0.9.jarstruts2-sitegraph-plugin-2.0.9.jarstruts2-sitemesh-plugin-2.0.9.jarstruts2-spring-plugin-2.0.9.jarstruts2-struts1-plugin-2.0.9.jarstruts2-tiles-plugin-2.0.9.jartiles-api-2.0.4.jartiles-core-2.0.4.jartiles-jsp-2.0.4.jarindex.jsp的内容如表，我们暂时不分析。
SpringMVC+Spring+Hibernate集成详解
Spring+SpringMVC+Hibernate框架集成详解注：此文档只说明简单的框架集成，各个框架的高级特性未涉及，此文档适合有框架使用基础的开发人员查看，新手可能需要参考其他资料。
1.准备工作开发环境：JDK 7u80、Eclipse 4.4 、Tomcat 7.0.63、MySQL 5.6、Tomcat JDBC POOL框架：Spring 3.2.14、Hibernate 3.6.10、common-logging 1.2、aopalliance.jar、aspectjweaver.jar、mysql-connector-java-5.1.35-bin.jar在Eclipse下创建动态web项目Test，创建过程中注意勾选web.xml的选项，如果不勾选，项目创建之后需要手动创建web.xml，创建完成后将其部署到Tomcat中，项目结构应该如下(Package Explorer下，看个人习惯)：2.配置Spring1)将以下JAR包复制到lib文件夹下，不要问为什么是这些，想知道为什么可以把其他任意一个删掉看看启动项目报什么错。
2)在web.xml中添加如下代码：3)创建applicationContext.xml，当前版本的Spring默认其位于WEB-INF下，不过大多数开发人员习惯还是将其放到src下，这里我们将其放在src下。
4)向applicationContext.xml中添加bean相关声明，具体如下：5)在web.xml中添加如下内容，用于自定义Spring配置文件的位置：3.测试Spring注：以下均为测试代码，测试完成后可以删除，User类建议保留，之后用于测试框架的集成情况1)新建测试实体类User，路径暂定为com.test.entity，添加如下代码(因为篇幅限制，所以图中无get和set方法，请自行添加)2)applicationContext.xml中添加如下定义：3)新建Test类，暂定路径com.test.test，添加如下代码：4)运行Test类查看结果，如果输出test则表示spring框架运行正常。
Struts,Spring,Hibernate框架的整合与研究
刘 东 旭 马 亚 琦 河南质 量 工 程职 业 学 院信 息工 程 系 河南 平顶山 ４ ００ ６７ ０
【 要】 摘 本文介 绍 了以 Ｓｒ ｇ为基础 ， ｐ ｉ ｎ 结合 Ｓｒｔ 和 Ｈｂｒａ ｅ ｔ ｓ ｕ ｉ ｎｔ 形成 一个 表示层 、 业务层 、持 久层 的 Ｗ ｂ 决方案 ，ｔｕ ｓ ＋ ｉ ｒａ ｅ Ｓ ｒ ｇ ｅ ｅ解 Ｓ ｔ Ｈｂ ｎ ｔ＋ ｐｉ ｒ ｅ ｎ
中 图 分 类 号 ：ＴＰ ９ 文 献 标 识 码 ：Ｂ 文 章 编 号 ：１ ０ —０ ７ ２ ｌ ） ５ １ — ２ ３３ ０ ９４ ６ （ ０ １０ —２５０
１引 言
Ｊｖ ａ ａ作 为 建 立 企 业级 应 用 平 台 的标 准 ，ａ ａ Ｅ得 到 了迅 速 的 发展 。 Ｊｖ Ｅ Ｊｖ Ｅ 规 范包 含 了多项 框架 技术 ， 统开 发人 员可 以通 过使 用 框架很 容 易地 ａａ Ｅ 系 构 建 起成 熟 而又 稳 定的 基 础架 构 ， 从而将 更 多 的精 力 放 到业 务逻 辑 设 计上 。 在 诸 多框 架 中 ， 目前 ， Ｓｒ ｔ、Ｓ ｒｎ 以 ｔｕｓ ｐｉｇ和 Ｈｉｅｎ ｔ 最 为流 行 。为 了 降低 ｂ ｒ ａｅ 代 码 的耦 合 性 ， 高 系 统 的开 发 效 率 ， 文 提 出 了一 种 基 于 Ｓｒ ｔ、 ｐ ｉｇ 提 本 ｔｕｓ Ｓ ｒｎ
Ｓ ｒ ｇ是一 个 以依赖 注入 （ Ｃ原 则 和面 向方 面编 程思 想 （ Ｐ 为基 础 ｐｉ ｎ Ｉ ） ｏ ＡＯ ） 的 轻量 级 框架 。ｏ ＩＣ是 一 个用 于 “ 基于 组 件 的 体 系结 构 ”的 设计 模 式 ， 它将
３ ２添加 Ｓ ｒ ｇ框 架 ． ｐｉ ｎ
struts2+spring+hibernate整合步骤
引用struts2、hibernate、spring所需jar包struts-core-2.x.x.jar ----struts核心包xwork-core-2.x.x.jar -----身体ruts在其撒很难过构建ognl-2.6.x.jar ----对象导航语言freemarker-2.3.x.jar ------struts2的ui标签的模板使用commons-fileupload-1.2.x.jar ----文件上传组件 2.1.6版本后需加入此文件struts-spring-plugin-2.x.x.jar ---用于struts2继承spring的插件hibernate核心安装包下的（下载路径：/ ，点击Hibernate Core 右边的download）hibernate2.jarlib\bytecode\hibernate-cglib-repack-2.1_3.jarlib\required\*.jarhibernate安装包下的（下载路径：/;点击Hibernate Annotations 右边的下载）hibernate-annotations.jarlib\ejb3-persistence.jar、hibernate-commons-annotations.jar hibernate针对JPA的实现包（下载路径：/ ，点击Hibernate Entitymanager右边下载）hibernate-entitymanager.jarlib\test\log4j.jar、 slf4j-log4j12.jarspring安装包下的dist\spring.jarlib\c3p0\c3p0-0.9.1.2.jarlib\aspecti\aspectjweaver.jaraspectjrt.jarlib\colib\cglib-nodep-2.1_3.jarlib\j2ee\common-annotations.jarvlib\log4j\log4j-1.2.15.jarlib\jakarta-commons\commons_loggin.jar数据库驱动包引用创建mysql数据库ssh 设置编码为utf-8 语句：create database ssh character set 'utf8' collate 'utf8_general_ci'引用1.先整合spring和hibernate*将spring和hibernate的jar包放入lib下；*创建spring的beans.xml配置文件Java代码1.<?xml version="1.0" encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3. xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"4. xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"5. xsi:schemaLocation="/schema/beans6./schema/beans/spring-beans-2.5.xsd7. /schema/context8./schema/context/spring-context-2.5.xsd 9. /schema/aop/schema/aop/spring-aop-2.5.xsd10. /schema/tx/schema/tx/spring-tx-2.5.xsd">11.12. <!-- 将bean交由spring管理可以用<bean></bean>和扫描加注 -->13. <!--14. 扫描该包及该包下的子包15. -->16. <context:component-scanbase-package="com.yss"></context:component-scan>17.18.19. <!-- 集成hibernate sessionFactory单例模式线程安全创建耗内存-->20. <!-- 将hibernate的事务也交由spring管理 -->21. <bean id="dataSource"class="boPooledDataSource"22. destroy-method="close">23. <property name="driverClass"value="org.gjt.mm.mysql.Driver" />24. <property name="jdbcUrl"25.value="jdbc:mysql://localhost:3306/ssh?useUnicode=true&characterE ncoding=UTF-8" />26. <property name="user" value="root" />27. <property name="password" value="root" />28. <!--初始化时获取的连接数，取值应在minPoolSize与maxPoolSize 之间。
struts2+hibernate+spring经典整合实例教程
Struts2与Spring、Hibernate三者整合的过程示例：示例工具：MyEclipse 7.0、Tomcat 6.0、MySql步骤：1.创建一个WEB工程，命名为BookShop（名字自己取，此处为示例工程名）；2.导入struts2的核心jar包，也就是在WEB-INF下的lib文件夹中放入jar包文件，如下图（图中jar包为示例版本）：3.加载spring，选中工程名，右击并选择【MyEclipse】选项下的【Add Spring Capabilities...】（或者在工具栏中选择【MyEclipse】下的【Add Spring Capabilities...】），在弹出的对话框中进行如下图所示操作：点击【Next】，点击Folder文本框后的【Browse】，在弹出对话框中选择spring配置文件存储位置为WEB-INF 文件夹，如下图所示：点击【OK】后，再点击【Finish】完成。
至此，已经完成加载spring，在WEB-INF文件夹下已经生成了配置文件applicationContext.xml。
4.加载Hibernate，选择【MyEclipse】下的【Add Hibernate Capabilities...】，在弹出对话框中进行如下图所示操作：点击【Next】后，选择Existing Spring configuration file单选框，在SessionFactory Id文本框中填入"sessionFactory"，如下图所示：点击【Next】，进行如下图所示操作：该操作中，只需在Bean Id文本框中输入一个Id名，作为数据库源的代用名，意义不大。
然后在DB Driver 下拉列表中，选择MyEclipse中创建好的数据库源xiaoqi，其他信息将自动填写。
点击【Next】，在弹出对话框中去掉Create SessionFactory class?复选框，不创建该类，点击【Finish】完成（创建过程中，加载的jar包文件可能有重复，所以这个时候如果提示有某些jar包重复，问全部保存【Keep Exiting】，还是替换掉【Replace】，可以选择替换掉【Replace】）。
Spring和Hibernate的整合应用研究
摘
要： 通过对 Ｓ ｒ ｇ和 Ｈ ｂｒａｅ ｐｉ ｎ ｉｅｎｔ 框架各 自特性 的研究 ， Ｓ ｒ ｇ和 Ｈ ｂｒａｅ的整合应 用 的原 因进行 了分 对 ｐｎ ｉ ｉｅｎｔ
析， 并结合具体 的实例进行 阐述 。Ｓ ｒ ｇ ｐ ｎ 杰出 的事务管理能力 和 良好 的持 久层封装 ， 大节省 了 Ｈｂ ｒａ ｉ 大 ｉｅ ｔ ｎ ｅ应 用程 序的代码量 ， 从而提 高了生产率。 同时 ，ｐ ｎ Ｓｒ ｇ和 Ｈ ｂｒａｅ的整合应 用 ， 建 了符合 ＭＶ ｉ ｉｅｎｔ 构 Ｃ设计模 式的系
对于传统 的基 于特定 事务资源 的事 务处理
分发挥各 自特点， 是能否高效率实现开发工作 的
关键 。 笔者 在从 事 Ｊｖ ａａ平 台 的管 理 系 统 项 目开 发
在 图 １ａ 所 示 情况 下 ， （） 对象 直接 创建所 需 对 象 和 ｃ， 这将 导致 代 码 的 紧耦 合 。对 象 和 ｃ的 任何 改 动 都 将 导 致 对 象 的 重 新 编 译 。在 图 １ （ ） 示情 况 下 ， 用 ＩＣ机 制 ， 象 在 更 高层 创 ｂ所 使 ｏ 对 建 并 传递 到需 要使用 它 们 的其 他 对象 中 。
统架构 ， 实现 了功能层次之间 的松散耦合 ， 使整个系统具备 了良好的稳定性 、 可伸缩性和可扩展性 。 关键 词 ： 整合 ；ｐ ｎ ； ｂｒａｅ Ｓ ｒ ｇＨｉ ｎｔ ｉ ｅ
中 图 法分 类 号 ：Ｐ １ Ｔ３ １ 文献标识码 ： Ａ
基 于 Ｗｅ ｂ的各种 开源框 架 在 ＪＥ ２ Ｅ应 用开 发
维普资讯
第２ 卷 第４ ９ 期
２０ 年４ ０７ 月
武 汉 理 工 大 学 学 报 ・信 息 与 管 理 工 程 版
SSH_三大框架介绍
SSH_三大框架介绍SSH是指Struts、Spring和Hibernate三个开源框架的整合，其中每个框架都有自己的设计思想和特点，通过整合，可以充分发挥它们的优势，提高开发效率和系统性能。
下面将分别介绍这三个框架。
1. Struts：Struts是一个基于MVC设计模式的Web应用程序框架，它将应用程序分为三个层：模型（Model）、视图（View）和控制器（Controller）。
模型负责处理业务逻辑，视图负责展示数据，控制器负责接收用户输入和导航请求。
Struts通过配置文件定义请求的映射和处理逻辑，通过统一的控制器Servlet接收请求，根据配置文件将请求转发给相应的Action。
在Action中进行请求处理和业务逻辑的实现。
2. Spring：Spring是一个轻量级的IoC（Inverse of Control）容器和应用程序框架，它主要解决企业应用中的复杂性问题。
Spring的核心思想是面向接口编程和依赖注入。
通过Spring的IoC容器管理对象的生命周期和依赖关系，将对象的创建和销毁过程交给容器处理。
通过依赖注入，可以将对象之间的依赖关系解耦，提高代码的可维护性和可测试性。
Spring还提供了丰富的功能模块，如AOP（Aspect-Oriented Programming）框架、事务管理、远程调用等，可以在应用程序中灵活地配置和使用。
Spring的优点是具有良好的灵活性和扩展性，可以与其他框架进行无缝集成，支持多种数据库和应用服务器。
同时，Spring还提供了很强的层次化管理和面向切面编程的能力，使得开发人员可以更加精细地控制应用程序的流程和行为。
3. Hibernate：Hibernate是一个开源的对象关系映射框架，用于将Java对象映射到关系数据库中的表结构上。
Hibernate通过配置文件和注解，提供了一种方便的方式来实现数据的持久化和检索。
Hibernate根据对象的映射关系，自动生成相应的SQL语句，实现了对象与数据库之间的映射和转换。
spring练习及答案
31.下面关于AOP的说法错误的是( C )。
A.AOP将散落在系统中的“方面”代码集中实现B.AOP有助于提高系统的可维护性C.AOP已经表现出了将要替代面向对象的趋势D.AOP是一种设计模式,Spring提供了一种实现2.事务隔离级别是由谁实现的?( C )。
A.Java应用程序B.HibernateC.数据库系统D.JDBC驱动程序3.下列哪项不是Spring的依赖注入方式( BC )。
[选两项]A.setter注入B.getter注入 *C.接口注入D.构造注入4.在Spring框架中,面向方面编程(AOP)的目标在于( C )。
A.编写程序时不用关心其依赖组件的实现* B.将程序中涉及的公用问题集中解决* C.封装JDBC访训数据库的代码,简化数据访训层的得复性代码D.实现面面的”无刷新”5.关于Spring 与 Hibernate集成,下面说法错误的是( C)。
A.Spring提供了HibernateDaoSupport类来简化Hibernate的使用B.在Spring配置文件种可以通过Spring提供的LocalSessionFactoryBean,来获得SessionFactory的实例C.通过集成Spring和Hibernate,用Spring管理程序的依赖关系,将SessionFactory注入到DataSource中D.通过Spring,可以在Biz层代码中无需直接实例化DAO类,而是通过注入得到6.依赖注入说法正确的是( A )。
A.依赖注入的目标是在代码之外管理程序组建间的依赖关系B.依赖注入即是“面向接口”的编程C.依赖注入是面向对象技术的替代品D.依赖注入的使用会增大程序的规模7.关于spring说法错误的是(D )。
A.spring是一个轻量级JAVA EE的框架集合B.spring是“依赖注入”模式的实现C.使用spring可以实现声明事务D.spring提供了AOP方式的日志系统8.在Spring 中,配置Hibernate 事务管理器(Hibernate TransactionManager)时,需要注入的属性名称是( B )。
SpringMVC+Hibernate4+Spring3整合开发实现CRUD
·在实现CRUD之前，我想你的开发环境已经搭建好了，我们就不作搭建的说明了，直接进入正题；一般搭建环境都是项目经理的事情，项目经理搭建完环境，就会把环境放到svn服务器上，你只需要从服务器上检出项目环境开发即可；File→Inport→SVN→从SVN检出项目我的资源库已经创建好了，你从视图中打开资源库视图创建一个资源库就好了，选择项目文件夹finish即可；·我们首先要生成简单Java类，也称POJO类，既然有添加hibernate的开发支持，当然要用hibernate提供的功能了,那我们首先编写一个数据库创建脚本，其中包括最常用的字段即可，就编写一个雇员表吧；USE mysql ;DROP TABLE emp ;CREATE TABLE emp(empno INT AUTO_INCREMENT ,ename VARCHAR(30) NOT NULL ,hiredate DATE ,sal VARCHAR(50) NOT NULL ,CONSTRAINT pk_nid PRIMARY KEY(empno)) ;·用hibernate生成一个表的对应的简单java类，打开DB Browser视图→找到对应的表右键→hibernate Reverse Engineering……这个界面就按照下图的设置，下图中没显示的部分，取消勾选，不做设置；·配置完成之后，会生成一个以表名称为类名的一个简单java类，不过首字母大写，采用的annotation注解的方式和数据表配置了映射关系，生成的类会有一些警告，压制一些就OK了，生成的构造方法没有任何用处，删掉即可，一些注释也可以删掉了，另外增加一个toString()方法，这样在做一些异常调试的时候很方便，此类我做了一点简单的注释，可以一看；Emp.javapackage cn.oracle.pojo;import java.util.Date;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.Table;import javax.persistence.Temporal;import javax.persistence.TemporalType;@SuppressWarnings("serial")→压制警告用的@Entity→代表这一个实体，与数据表映射对应；@Table(name = "emp", catalog = "mysql")→此设置了这个实体对应的数据库名称和表名称；name 属性是表名称，catalog 是你用到数据库的名字；public class Emp implements java.io.Serializable {private Integer empno;→对应的字段名称；private String ename; →对应的字段名称；private Date hiredate; →对应的字段名称；private String sal; →对应的字段名称；@Id→表示这个字段值主键，唯一的@GeneratedValue→表示此字段自动增长，@Column(name = "empno", unique = true, nullable = false)→对应表中的列的属性，name 表示列名称，unique表示唯一性,nullable表示是否为空；public Integer getEmpno() {return this.empno;}public void setEmpno(Integer empno) {this.empno = empno;}@Column(name = "ename", nullable = false, length = 30)→length表示长度public String getEname() {return this.ename;}public void setEname(String ename) {this.ename = ename;}@Temporal(TemporalType.DATE)→专门标注日期的；@Column(name = "hiredate", length = 10)public Date getHiredate() {return this.hiredate;}public void setHiredate(Date hiredate) {this.hiredate = hiredate;}@Column(name = "sal", nullable = false, length = 50)public String getSal() {return this.sal;}public void setSal(String sal) {this.sal = sal;}@Overridepublic String toString() {return"Emp [empno=" + empno + ", ename=" + ename + ", hiredate="+ hiredate + ", sal=" + sal + "]";}}·简单java类完成是第一步，然后我们需要配置数据库连接了，这是正常的思维模式，也就是最基本的JDBC开发思维模式，但是这一步spring已经在配置的时候已经交给了spring管理了数据库的连接池，只要得到对应的bean就可以得到数据库连接了，也就能操作数据库了；数据库连接类也就相当于spring给我们提供好了，那接下来就是编写接口了，首先编写DAO层接口，DAO(data access Object) 叫做数据访问对象，首先，我们利用泛型编写一个公共的DAO接口，实现基本的CRUD ，当数据表非常多的时候编写此公共的接口很节省代码的；IDAO.javapackage cn.oracle.dao;import java.util.List;public interface IDAO<K,V> {/*** 增加一条数据；* @param vo 简单Java类对象；* @return返回一个boolean对象，增加成功返回true,增加失败返回false;* @throws Exception*/public boolean doCreate(V vo)throws Exception;/*** 更新一条数据；* @param vo 简单Java类对象；* @return返回一个boolean对象，更新成功返回true,更新失败返回false;* @throws Exception*/public boolean doUpdate(V vo)throws Exception;/*** 删除一条数据；* @param id 简单Java类对象的id；* @return返回一个boolean对象，删除成功返回true,删除失败返回false;* @throws Exception*/public boolean doRemove(int id)throws Exception;/*** 查询出一条数据，* @param id 数据对应的id* @return返回一个简单java类对象；* @throws Exception*/public K findById(int id)throws Exception;/*** 查询所有的数据；* @return返回一个简单Java类对象；* @throws Exception*/public List<V> findAll()throws Exception;/*** 模糊查询，也是分页要用的一个方法；* @param column 列名称* @param keyWord 关键字* @param currentPage 当前页* @param lineSize 每页现实的数据条目* @return返回一个List集合；* @throws Exception*/public List<V> findAll(String column,String keyWord,IntegercurrentPage,Integer lineSize)throws Exception;/*** 统计模糊查询的条目* @param column 列名称* @param keyWord 关键字* @return返回一个整数* @throws Exception*/public int getAllCount(String column,String keyWord)throws Exception;}·公共的接口开发完成了，我们接下来就开发IEmpDAO接口，这个接口直接继承IDAO 接口即可，是不是很方便，直接继承即可，如果你需要扩充什么方法的话，直接编写方法即可，package cn.oracle.dao;import cn.oracle.pojo.Emp;public interface IEmpDAO extends IDAO<Integer, Emp> {}·然后当然是编写接口的实现类了，也就是编写方法的具体实现，EmpDAOImpl.javapackage cn.oracle.dao.impl;import java.util.List;import javax.annotation.Resource;import org.hibernate.Criteria;import org.hibernate.Query;import org.hibernate.SessionFactory;import ponent;import cn.oracle.dao.IEmpDAO;import cn.oracle.pojo.Emp;@Component→这个就是Annotation注解，其实你可以理解为在applicationContext.xml文件之中配置了一个bean<bean id=”empDAOImpl” class=”cn.oracle.dao.impl.EmpDAOImpl”>→Component<property name=”sessionFactory” ref=”sessionFactory”/>→Resource</bean>public class EmpDAOImpl implements IEmpDAO {@Resourceprivate SessionFactory sessionFactory;@Overridepublic boolean doCreate(Emp vo) throws Exception {return this.sessionFactory.getCurrentSession().save(vo) != null;}→使用Session接口的save方法来保存数据；@Overridepublic boolean doUpdate(Emp vo) throws Exception {String hql="UPDATE Emp AS e SET e.ename=?,e.hiredate=?,e.sal=? WHERE e.empno=?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setString(0, vo.getEname());query.setDate(1, vo.getHiredate());query.setString(2, vo.getSal());return query.executeUpdate()>0;}→使用Query实现更新；@Overridepublic boolean doRemove(int id) throws Exception {String hql="DELETE FROM Emp As e WHERE e.empno=?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setInteger(0, id);return query.executeUpdate()>0;}→使用Query接口实现删除；@Overridepublic Emp findById(int id) throws Exception {return (Emp) this.sessionFactory.getCurrentSession().get(Emp.class, id);}→使用Session接口查询数据；@SuppressWarnings("unchecked")@Overridepublic List<Emp> findAll() throws Exception {Criteriacriteria=this.sessionFactory.getCurrentSession().createCriteria(Emp.class);List<Emp> all=criteria.list();return all;} →使用criteria接口实现全部查询；@SuppressWarnings("unchecked")@Overridepublic List<Emp> findAll(String column, String keyWord,Integer currentPage, Integer lineSize) throws Exception { String hql="FROM Emp AS e WHERE e."+column+" LIKE ?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setString(0, "%"+keyWord+"%");query.setFirstResult((currentPage-1)*lineSize);query.setMaxResults(lineSize);return (List<Emp>)query.list();}→使用query接口实现分页模糊查询；@Overridepublic int getAllCount(String column, String keyWord) throws Exception { String hql="SELECT COUNT(e.empno) FROM Emp AS e WHERE "+column+" LIKE ?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setString(0, "%"+keyWord+"%");Integer count=((Long)query.uniqueResult()).intValue();return count;} →使用query接口完成统计；}·编写完成DAO层之后，我们就要做的就是编写服务层了，也就是对DAO层接口的调用，IEmpService.javapackage cn.oracle.service;import java.util.List;import java.util.Map;import cn.oracle.pojo.Emp;public interface IEmpService {public boolean insert(Emp vo)throws Exception;public boolean update(Emp vo)throws Exception;public boolean delete(int id)throws Exception;public Emp get(int id)throws Exception;public List<Emp> list()throws Exception;public Map<String ,Object> list(String column,String keyWord,Integer currentPage,Integer lineSize)throws Exception;}·接口编写完成，之后我们就应该编写实现类了；EmpServiceImpl.javapackage cn.oracle.service.impl;import java.util.HashMap;import java.util.List;import java.util.Map;import javax.annotation.Resource;import org.springframework.stereotype.Service;import cn.oracle.dao.IEmpDAO;import cn.oracle.pojo.Emp;import cn.oracle.service.IEmpService;@Service Service层的专用Annotation注解；public class EmpServiceImpl implements IEmpService {@Resourceprivate IEmpDAO empDAO;@Overridepublic boolean insert(Emp vo) throws Exception {return this.empDAO.doCreate(vo);}@Overridepublic boolean update(Emp vo) throws Exception {return this.empDAO.doUpdate(vo);}@Overridepublic boolean delete(int id) throws Exception {return this.empDAO.doRemove(id);}@Overridepublic Emp get(int id) throws Exception {return this.empDAO.findById(id);}@Overridepublic List<Emp> list() throws Exception {return this.empDAO.findAll();}@Overridepublic Map<String, Object> list(String column, String keyWord,Integer currentPage, Integer lineSize) throws Exception { Map<String ,Object> map=new HashMap<String,Object>();map.put("allEmps", this.empDAO.findAll(column, keyWord, currentPage, lineSize));map.put("allCount", this.empDAO.getAllCount(column, keyWord));return map;}}·到此，后台业务层的增删改查就完成了，然后就是控制器的编写了，我们用的是springmvc的话，自然编写起来很方便的；EmpAction.javapackage cn.oracle.action;import java.util.List;import javax.annotation.Resource;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;import org.springframework.web.servlet.ModelAndView;import cn.oracle.pojo.Emp;import cn.oracle.service.IEmpService;@Controller→spring mvc的专用annotation注解，代表一个控制器；@RequestMapping("/pages/front/emp/*") →映射路径public class EmpAction {@Resourceprivate IEmpService empService;@RequestMapping(value="emp_list.jsp",method=RequestMethod.GET)public ModelAndView list(HttpServletRequest request,HttpServletResponse response){List<Emp> allEmps=null;try {allEmps=this.empService.list();} catch (Exception e) {e.printStackTrace();}ModelAndView mav=new ModelAndView();mav.setViewName("/pages/front/emp/emp_list.jsp");mav.addObject("allEmps", allEmps);System.out.println(allEmps); 我们就用一个简单的连接做测试，如果后台输出了这些对象的话，说明我们就完成了页面的操作了；return mav;}}如果后台有输出这些信息，说明你的所有配置正常，开发CRUD没任何问题的；。
第9章 Spring与Struts2、Hibernate框架的整合
第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()。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Spring、Hibernate框架整合通过MyEclipse工具快速整合作者：杜鹏目录一、开发环境 (2)二、新建工程 (2)三、添加Spring支持 (3)四、添加Hibernate支持 (5)五、在配置文件中添加Hibernate配置 (9)六、创建实体类entity (10)七、创建DAO类并注入SessionFactory (14)八、声明式事务 (16)一、开发环境开发工具：MyEclipse2013用到的Jar包：log4j-1.2.17.jar、mysql-connector-java-commercial-5.1.25-bin.jar使用框架类库：Spring 3.1 Libraries、Hibernate 3.2.7 Libraries二、新建工程新建一个Web Project，命名为SpringHibernate如图1所示。
图1接着将Log4j和Log4j的配置文件导入工程中，导入后的路径如图2所示：图2其中log4j.properties中做如下配置：log4j.rootLogger=ERROR,consolelog4j.appender.console=org.apache.log4j.ConsoleAppenderlog4j.appender.console.Target=System.outyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%d{[yyyy-MM-ddHH\:mm\:ss,SSS]}%p%m%n至于配置文件为什么这样写，这里不做解释。
本文重点描述怎样将Spring和Hibernate两个框架集成起来。
在完成了上面的Log4j导入工作后，再将数据库连接Jar包导入，这里用的是MySQL数据库，所以使用mysql-connector-java-commercial-5.1.25-bin.jar，这个也是直接将Jar包拷到工程的WebRoot/WEB-INF/lib目录下即可。
所有基础工作做完后工程的结构应该是图3的样子：图3三、添加Spring支持导入Spring支持最简单最常用的方法是直接将Spring所需的Jar包导入工程，然后新建Spring的配置文件，进行配置。
但这样做效率低，而且容易出错，这里我们使用MyEclipse 工具来为工程添加Spring的支持。
在工程名上鼠标右键，选择“MyEclipse”-->“Project Facets[Capabilities]”-->“Install Spring Facet”如图4所示：图4在弹出的窗体中选择Spring 3.1然后点击下一步，如图5所示：图5接下来的页面保持选项不变直接Next，如图6所示：图6在最后的页面中确认一下所使用的库和Jar包，如图7所示：图7确认要选中Core、Facets和Spring Web三个库，然后点击Finish按钮完成。
添加了Spring 支持后，我们发现工程的支持库多了Spring 3.1 Libraries，src目录下自动添加了applicationContext.xml配置文件。
打开配置文件，里面已经有了默认的空配置文件，内容如下：<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.1.xsd"></beans>这样，我们只要编写相关的类和接口，再在applicationContext,xml中的<beans>节点里添加相应的bean配置，就可以使用Spring容器了。
但我们先不急着去写代码，接下来我们先为工程添加Hibernate支持，然后用Spring来管理Hibernate，最后在去写代码。
四、添加Hibernate支持同样的，我们通过MyEclipse工具来添加Hibernate支持。
这样一方面效率较高，而且不容易出错，最主要的是MyEclipse为我们提供了可视化配置文件管理界面，这将让我们配置Hibernate时更加简便。
添加Hibernate支持，同样是右键工程名，选择“MyEclipse”-->“Project Facets[Capabilities]”-->“Install Hibernate Facet”如图8所示：图8在弹出的界面中，选择Hibernate版本为3.2，然后Next，如图9所示：图9然后在接下来的页面中，取消Create SessionFactory class?的选项，因为我们接下来会使用Spring来管理Hibernate，Spring中为我们提供了HibernateDaoSupport类的支持，所以不再使用HibernateSessionFactory类。
如图10所示，点击Next按钮。
图10接下来的页面中，我们取消Specify Spring DataSource connection details?选项，如图11所示，然后点击Next。
图11在最后一页中确认Hibernate的相关Jar包后点击Finish按钮完成，如图12所示：图12记得一定要确认Core选中。
最后工程的结构应该是这样，如图13所示：图13这个时候，我们再来看看applicationContext.xml配置文件，<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance" xmlns:p="/schema/p"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.1.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> </bean></beans>我们发现，配置文件中自动添加了id为sessionFactory的bean，这个是由于我们添加了Hibernate支持后MyEclipse为我们自动生成的配置，当然了这个还不能直接使用，我们还需要进行详细的配置。
五、在配置文件中添加Hibernate配置之前的Hibernate配置是配置在Hibernate.cfg.xml中的，但现在由于使用了Spring框架来管理Hibernate，所以直接将Hibernate的配置写在applicationContext.xml（Spring配置文件）中。
首先来配置dataSouce。
配置如下：<!-- 配置dataSource --><bean id="dataSource"class="mons.dbcp.BasicDataSource"> <property name="driverClassName"value="com.mysql.jdbc.Driver"></property><property name="url"value="jdbc:mysql://localhost:3306/test_db"/><property name="username"value="root"/><property name="password"value=""/></bean>对应于Hibernate配置文件中的配置信息，Spring配置中同样有driverClassName，url，username，password的配置。
url是连接字符串，username是数据库访问的用户名，password 是访问数据库的密码。
有了dataSource，我们接着就需要为Hibernate配置sessionFactory用于管理Hibernate。
配置如下：<!-- 配置sessionFactory --><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"><property name="dataSource"ref="dataSource"/><!-- Hibernate参数配置--><property name="hibernateProperties"><props><prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop><prop key="hibernate.show_sql">true</prop></props></property><!-- Hibernate mapping配置--><property name="mappingResources"><list > <value >com/gobang/test/entity/Project.hbm.xml </value ><value >com/gobang/test/entity/User.hbm.xml </value ></list ></property ></bean >sessionFactory 包括dataSource 属性、hibernateProperties 属性和mappingResource 属性。