hibernate+spring

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多数据库解决方案我以前在项目中的探索和实践，写出来与大家分享。

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

环境：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 的方式存储了多个库的引用。

spring4.x + hibernate4.x 配置详解关于spring和hibernate的使用以及特征等等，在此不再啰嗦，相信大家也都知道，或者去搜索一下即可。

本篇博文的内容主要是我最近整理的关于spring4.x 和hibernate 4.x 相关配置和使用方式，当然spring3.x以及hibernate4.x也可以借鉴。

首先是配置文件web.xml 增加以下代码即可<!-- 加载spring相关的配置文件--><context-param><param-name>contextConfigLocation</param-name><param-value>classpath*:/applicationContext.xml</param-value> </context-param><!-- 启用spring监听--><listener><listener-class>org.springframework.web.context.ContextLoaderListener</l istener-class></listener>然后建立 applicationContext.xml 文件，src下。

文件内容如下，注释我尽量写的很详细<beans xmlns:xsi="/2001/XMLSchema-instance"xmlns="/schema/beans"xmlns:aop="http://ww /schema/aop"xmlns:context="/schema/context"xmlns:tx="ht tp:///schema/tx"xmlns:cache="/schema/cache"xmlns:p="http:// /schema/p"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-4.0.xsd/schema/aop/schema/aop/spring-aop-4.0.xsd/schema/context/schema/context/spring-context-4.0.xsd/schema/tx/schema/tx/spring-tx-4.0.xsd/schema/cache http://www.springframewor /schema/cache/spring-cache-4.0.xsd"><!-- 引入properties文件--><context:property-placeholder location="classpath*:/appConfig.properties"/> <!-- 定义数据库连接池数据源bean destroy-method="close"的作用是当数据库连接不使用的时候,就把该连接重新放到数据池中,方便下次使用调用--> <bean id="dataSource"class="boPooledDataSourc e"destroy-method="close"><!-- 设置JDBC驱动名称--><property name="driverClass"value="${jdbc.driver}"/><!-- 设置JDBC连接URL --><property name="jdbcUrl"value="${jdbc.url}"/><!-- 设置数据库用户名--><property name="user"value="${ername}"/><!-- 设置数据库密码--><property name="password"value="${jdbc.password}"/><!-- 设置连接池初始值--><property name="initialPoolSize"value="5"/></bean><!-- 配置sessionFactory --><bean id="sessionFactory"class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><!-- 数据源--><property name="dataSource"ref="dataSource"/><!-- hibernate的相关属性配置--><property name="hibernateProperties"><value><!-- 设置数据库方言-->hibernate.dialect=org.hibernate.dialect.MySQLDialect<!-- 设置自动创建|更新|验证数据库表结构-->hibernate.hbm2ddl.auto=update<!-- 是否在控制台显示sql -->hibernate.show_sql=true<!-- 是否格式化sql，优化显示-->hibernate.format_sql=true<!-- 是否开启二级缓存-->e_second_level_cache=false<!-- 是否开启查询缓存-->e_query_cache=false<!-- 数据库批量查询最大数-->hibernate.jdbc.fetch_size=50<!-- 数据库批量更新、添加、删除操作最大数-->hibernate.jdbc.batch_size=50<!-- 是否自动提交事务-->hibernate.connection.autocommit=true<!-- 指定hibernate在何时释放JDBC连接-->hibernate.connection.release_mode=auto<!-- 创建session方式hibernate4.x 的方式-->hibernate.current_session_context_class=org.springframework.or m.hibernate4.SpringSessionContext<!-- javax.persistence.validation.mode默认情况下是auto的，就是说如果不设置的话它是会自动去你的classpath下面找一个bean-validation**包所以把它设置为none即可-->javax.persistence.validation.mode=none</value></property><!-- 自动扫描实体对象tdxy.bean的包结构中存放实体类--><property name="packagesToScan"value="tdxy.bean"/> </bean><!-- 定义事务管理--><bean id="transactionManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager "><property name="sessionFactory"ref="sessionFactory"/> </bean><!-- 定义Autowired 自动注入bean --><bean class="org.springframework.beans.factory.annotation.AutowiredAnnotati onBeanPostProcessor"/><!-- 扫描有注解的文件base-package 包路径--><context:component-scan base-package="tdxy"/><tx:advice id="txAdvice"transaction-manager="transactionManager"> <tx:attributes><!-- 事务执行方式REQUIRED：指定当前方法必需在事务环境中运行，如果当前有事务环境就加入当前正在执行的事务环境，如果当前没有事务，就新建一个事务。

Struct2、Hibernate3、Spring3框架搭建实战采⽤⽬前最新的struts-2.3.1.2、hibernate3.6.10.Final、spring-framework-3.1.1.RELEASE开发包，以及eclipse-jee-indigo-SR2-win32、apache-tomcat-7.0.27服务器、JDK6和mysql5做开发环境，参考了前辈的⼀篇相关⽂章，改正了其中的错误和疏漏，克服了公司分配的“新”机器每⼩时⾃动重启三次的困难，终于把环境给搭好了。

整个过程中遵循的⼀个原则是，避免引⼊⽤不到的jar包，以求搭建⼀个最⼩的SSH 运⾏环境。

⾸先创建⼀个Dynamic web project 输⼊任意名字如SSHBase。

第⼀步：加载Spring环境我们需要引⼊的包有：org.springframework.asm-3.1.1.RELEASE.jarorg.springframework.beans-3.1.1.RELEASE.jarorg.springframework.context-3.1.1.RELEASE.jarorg.springframework.core-3.1.1.RELEASE.jarorg.springframework.expression-3.1.1.RELEASE.jarorg.springframework.jdbc-3.1.1.RELEASE.jarorg.springframework.web-3.1.1.RELEASE.jarorg.springframework.orm-3.1.1.RELEASE.jar由于spring默认开启了⽇志，还需要加⼊commons-logging的jar包，否则会报错。

建议不要⼀次性加⼊应该先加最核⼼的运⾏代码看缺少什么加什么，这样就不会加多余的包进来了，spring3已经把包按功能分开，不像以前⼀个包，这样更灵活，只要运⾏我们需要的功能，⽽没⽤到的就不⽤在硬性的添加进来。

Struts的原理和优点.Struts工作原理MVC即Model—View—Controller的缩写，是一种常用的设计模式。

MVC 减弱了业务逻辑接口和数据接口之间的耦合，以及让视图层更富于变化。

MVC的工作原理，如下图1所示：Struts 是MVC的一种实现，它将Servlet和JSP 标记(属于J2EE 规范）用作实现的一部分。

Struts继承了MVC的各项特性,并根据J2EE的特点，做了相应的变化与扩展.Struts的工作原理，视图:主要由JSP生成页面完成视图，Struts提供丰富的JSP 标签库: Html，Bean，Logic，Template等，这有利于分开表现逻辑和程序逻辑。

控制：在Struts中,承担MVC中Controller角色的是一个Servlet，叫ActionServlet。

ActionServlet是一个通用的控制组件。

这个控制组件提供了处理所有发送到Struts的HTTP请求的入口点。

它截取和分发这些请求到相应的动作类(这些动作类都是Action类的子类）。

另外控制组件也负责用相应的请求参数填充Action From（通常称之为FromBean），并传给动作类（通常称之为ActionBean）。

动作类实现核心商业逻辑，它可以访问java bean 或调用EJB。

最后动作类把控制权传给后续的JSP 文件，后者生成视图。

所有这些控制逻辑利用Struts-config.xml文件来配置。

模型：模型以一个或多个java bean的形式存在。

这些bean分为三类：Action Form、Action、JavaBean or EJB.Action Form通常称之为FormBean，封装了来自于Client的用户请求信息,如表单信息。

Action通常称之为ActionBean，获取从ActionSevlet传来的FormBean,取出FormBean中的相关信息，并做出相关的处理，一般是调用Java Bean或EJB等。

基于Struts Hibernate Spring架构的软件开发摘要:近年来,随着信息技术应用于各行各业，尤其是企业信息化建设的不断发展,构建了基于Web的技术系统之上。

对于当今复杂多变的市场环境,发展壮大信息技术需要考虑他的伸缩性强、扩展性好、重用性高和易维护、易管理的特点，使得Web技术发展成为现当代的热点。

Struts Hibernate Spring三大框架(SSH)主要应用于大型项目。

只有大项目才能体现出SSH的优势。

关键词：Struts Hibernate Spring 构架软件开发随着信息技术的发展需要,构建基于Web的应用系统的需求，从而使Struts Hibernate Spring结构结合，形成对Web的新应用。

1 Struts Hibernate Spring原理概述Struts就是一个MVC模式的框架,它就是将业务代码与视图代码分离,有效地优化系统结构,提高系统的扩展性,降低系统复杂度与维护难度。

Hibernate是一个对象关系数据库映射工具,通过Hibernate的使用,能够很好地解决面向对象编程语言与关系数据库一起使用可能带来的种种麻烦,使得程序设计人员可以减少对关系数据模型的依赖,致力于业务逻辑的开发。

Spring框架的使用将J2EE层次结构中的业务层分离为业务逻辑层和数据持久层,这样业务逻辑便交给Spring处理,而数据访问则交给Hibernate处理,使得层次结构更加清晰。

1.1 StrutsStruts在MVC模块中本原来就是负责将用户数据传入业务层，以及将业务层处理的结果返回给用户，此系统属于较简单Web应用，主要作用在于在用户视图中使用get，set方法来方便地获取关联对象。

1.2 SpringSpring Framework最主要的作用在于与Hibernate的无缝链接，虽然Spring 对Hibernate提供了90％以上的封装，使我们不必去关心Session 的建立，关闭，以及事务使我们能够专心的关注业务逻辑。

达梦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问题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的搭建一直以来接触到的都是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+Hibernate+Spring的系统设计和开发俞国红（健雄职业技术学院计算机工程系，江苏太仓215411）摘要：阐述了以J2EE(JSP、JavaBean、Servlet)、SSH(Struts、Spring、Hibernate)开源框架为核心技术，逐步构建软件架构原型，构建系统原型作为系统开发的基础，提出了基于Struts、Spring和Hibernate框架的轻型J2EE 软件架构技术的系统设计和开发方法。

关键词：J2EE；Struts；Spring；Hibernate；架构中图分类号：TP311.52文献标识码：A1 前言J2EE(Java 2 Enterprise Edition即Java 2 平台企业版)是由Sun公司主持推出的一项中间件技术。

EJB (Enterprise JavaBean)是J2EE的一部分，定义了一个用于开发基于组件的企业多重应用程序的标准。

但由于EJB的复杂性，导致程序的开发效率低。

在Spring和Hibernate 等轻量级框架出现后，大量的开发人员转向到以目前最流行的开源框架，能快速开发出结构清晰、可重用性好、维护方便的轻量级的J2EE企业系统应用。

2 Web应用的分层分析构架Web企业系统应用时需要考虑用户交互、处理业务逻辑、应用数据持久化、扩展性等很多问题，所以一个应用的架构方案和实现技术选择十分重要。

而分层的目的就是对应用的逻辑功能进行划分，使每层在完成自己功能的同时，不影响其它层，实现“高内聚，低耦合”具有易于控制、扩展、维护的优点，图1是一个典型的轻量级J2EE应用架构，Web 应用分层结构基本上都分为三层：表现层、业务逻辑层、数据持久层。

表示层用来处理用户和软件之间的交互，它主要的责任是向用户展现信息以及处理用户请求。

业务逻辑层，又叫做领域逻辑层。

其职责包括处理业图1 典型的Web应用分层结构Fig.1 Typical Web application hierarchical structure务逻辑和存储业务数据，校验从表示层传过来的数据，通过表示层提交的命令来执行相应的业务逻辑。

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的内容如表，我们暂时不分析。

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框架运行正常。

引用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&amp;characterE ncoding=UTF-8" />26. <property name="user" value="root" />27. <property name="password" value="root" />28. <!--初始化时获取的连接数，取值应在minPoolSize与maxPoolSize 之间。

ssh三⼤框架整合Hibernate框架 1 hibernate核⼼配置⽂件 （0）orm思想 - 对象关系映射 （1）数据库信息 （2）hibernate信息 （3）映射配置 （4）hibernate核⼼配置⽂件 - 如果单纯使⽤hibernate框架，核⼼配置⽂件名称 hibernate.cfg.xml和位置 src下⾯固定的 - hibernate和spring整合时候，hibernate核⼼配置⽂件名称和位置没有固定要求的 2 hibernate映射配置⽂件 （1）实体类和数据库表映射关系—使⽤orm思想 3 hibernate操作的步骤 （1）在spring框架对hibernate框架进⾏封装，使⽤hibernateTemplateStruts2框架 1 Action操作 （1）action创建三种⽅式 - 继承类 ActionSupport （2）配置action访问路径 - 创建struts.xml配置⽂件，这个⽂件名称和位置固定 src下⾯的 （3）配置访问action的多个⽅法 - 使⽤通配符⽅式配置 （4）在action获取表单提交数据 - 获取request对象 ** 使⽤ServletActionContext类获取 - 属性封装 - 模型驱动（重点） - 表达式封装 （5）在action操作域对象 - 使⽤ServletActionContext获取域对象 （6）配置struts2的过滤器 2 值栈 （1）向值栈放数据 - set⽅法 - push⽅法 - 定义变量，⽣成get⽅法 （2）从值栈获取数据 - 在jsp中使⽤struts2标签+ognl获取 - <s:property> - <s:iterator> 3 拦截器 （1）aop和责任链模式 （2）⾃定义拦截器 - 继承MethodFilterInterceptor - 重写类⾥⾯的⽅法 - 配置拦截器和action关联Spring框架 1 spring核⼼配置⽂件 （1）名称和位置没有固定要求 （2）在spring核⼼配置⽂件中引⼊schema约束 2 创建对象 （1）xml配置⽅式：<bean id=”” class=”” scope=””/> （2）注解⽅式：四个注解 3 注⼊属性(对象类型属性) （1）xml配置⽅式： （2）注解⽅式：两个注解 - autowired - resource 3 使⽤ServletContext对象和监听器实现 （1）在服务器启动时候，加载spring配置⽂件，创建对象 （2）配置spring的监听器 （3）指定spring配置⽂件位置 4 jdbcTemplate 5 spring事务配置 （1）xml⽅式 （2）注解⽅式SSH框架整合思想 1 三⼤框架应⽤在javaee三层结构 2 struts2框架和spring整合 （1）struts2的action在spring配置 3 spring框架和hibernate框架整合 （1）hibernate的sessionFactory交给spring配置 （2）把hibernate数据库配置交给spring配置整合struts2和spring框架 1 把struts2的action交给spring管理 2 实现过程 第⼀步导⼊struts2的jar包 （1）导⼊⽤于整合的jar包 （log4j.properties为log4j的⽇志输出格式，放⼊src下⾯） （2）Spring为了整合Struts还需要额外再导⼊⼀个jar包：（该包在struts的lib⽬录下） （3）导⼊Struts2的jar包（struts2版本为2.3.24）： （4）创建Actionpublic class UserAction extends ActionSupport {public String execute() throws Exception {System.out.println("Success....");return NONE;}} （5）创建Strut2的核⼼配置⽂件<?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="demo" extends="struts-default" namespace="/"><action name="userAction" class="erAction"></action></package></struts> （6）在web.xml中配置struts2的过滤器<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> （7）导⼊Spring整合Web项⽬的jar包，也就是监控项⽬启动的监听器所在的jar包 （8）创建Spring的核⼼配置⽂件并在其中引⼊约束<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd/schema/aop/schema/aop/spring-aop.xsd/schema/tx/schema/tx/spring-tx.xsd"></beans> （9）把action交给Spring进⾏配置1 <!-- 配置action的对象 -->2 <!-- 注意action是多实例的，因此我们这⾥把scope配置为prototype的 -->3 <bean id="userAction" class="erAction" scope="prototype"></bean> ①在spring配置action对象，在struts.xml中也配置action对象 ②解决： 只需要在spring⾥⾯配置action对象，不要在struts.xml中配置<struts><package name="demo1" extends="struts-default" namespace="/"><!-- class属性⾥⾯不写action全路径了，因为写，action对象创建两次写spring配置的action的bean的id值--><action name="userAction" class="userAction"></action></package></struts> 可以这样写的原因是我们导⼊了⼀个Spring整合Struts2的jar包：struts2-spring-plugin-2.3.24.jar （10）web.xml中Spring监听器的配置<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:bean.xml</param-value></context-param> （11）测试准备 ①所需的为Struts2的核⼼配置⽂件：struts.xml ②Spring的配置⽂件：bean.xml ③项⽬的配置⽂件：web.xml ④Struts2的UserAction类 ⑤在UserAction中对UserService的调⽤ ⑥UserService中对UserDao的调⽤ ⑦UserDao类的编写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="demo1" extends="struts-default" namespace="/"><!-- class属性⾥⾯不写action全路径了，因为写，action对象创建两次写spring配置的action的bean的id值--><action name="userAction" class="userAction"></action></package></struts>bean.xml<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd/schema/aop/schema/aop/spring-aop.xsd/schema/tx/schema/tx/spring-tx.xsd"><bean id="userAction" class="erAction"><property name="userService" ref="userService"></property></bean><bean id="userService" class="erService"><property name="userDao" ref="userDaoImp"></property></bean><bean id="userDaoImp" class="erDaoImp"></bean></beans>web.xml<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="/2001/XMLSchema-instance" xmlns="/xml/ns/javaee" xsi:schemaLocation="/xml/ns/javaee /xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" <display-name>spring-day4-ssh</display-name><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:bean.xml</param-value></context-param><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><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>UserAction.javaimport com.opensymphony.xwork2.ActionSupport;import erService;public class UserAction extends ActionSupport {private UserService userService;public void setUserService(UserService userService) {erService = userService;}public String execute() throws Exception {userService.add();return NONE;}}UserService.javapublic class UserService {private UserDao userDao;public void setUserDao(UserDao userDao) {erDao = userDao;}public void add() {userDao.add();}}UserDao.java 其实现类public class UserDaoImp implements UserDao {public void add() {System.out.println("UserDaoImp....");}} （12）测试结果： 可以在后台观察到如下测试结果：image ⾄此，Spring和Struts2的整合已经完毕，然后是Spring对Hibernate的整合了。

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】）。

Struts2.5+Hibernate3.1+Spring应用开发实例.（Hibernate和Spring是新的知识点，先单独强化，然后再整合训练）任务一：Hibernate（10课时）该任务包括两个部分内容一是Hibernate的基础知识，二是实际完成一个Hibernate应用。

要求：掌握Hibernate的基础知识，掌握开发Hibernate应用的方法。

任务二：Sping（10课时）该任务包括两个部分内容一是介绍Spring的基础知识，二是完成一个Spirng 应用。

要求：掌握Spring的基础知识，掌握开发Spirng应用的方法。

任务三：Hibernate和Spring的联合开发（8课时）使用Hibernate和Spring框架完成Java应用开发要求：掌握使用Hibernate和Spring框架开发Java应用程序的过程。

任务四：基于Struts+Hibernate+Spring的网上购物系统开发（28课时）结合Hibernate和Spring改写《Java Web 应用开发项目教程》的前台要求：掌握使用Struts+Hibernate+Spring框架开发网上购物系统的方法实训要求：1.每位同学独立完成2.每部分内容按时提交代码和学习报告（总成绩由每次的节点成绩统计获得）软件环境需求：1.操作系统：WindowsXP2.数据库及驱动程序：Microsoft SQLServer 2005 JDBC3.JDK: JDK64.IDE：MyEclipse7.05.服务器：Tomcat6.0任务一Hibernate1.1Hibernate基础知识1.Hibernate简介Hibernate是一种Java语言下的对象-关系映射解决方案，它是一种自由、开源的轻量级框架，用于将面向对象的对象模型映射到传统的关系数据库中。

Hibernate对JDBC进行了轻量级的对象封装，不仅提供从Java数据类型到SQL数据类型的ORM映射，还提供数据查询和数据缓存功能，大幅度减少开发时人工使用SQL 和JDBC 处理数据的时间，使得Java程序员可以完全使用面向对象的编程思维通过Hibernata API操作关系数据库。

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语句，实现了对象与数据库之间的映射和转换。

第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()。

Java 面试经典 04--Spring、Hibernate博客分类：javaSpringJava面试HibernateTomcatspring:依赖注入,事务管理,JDBC数据访问,spring中使用hibernate试题选择使用下面的Connection的哪个方法可以建立一个PreparedStatement接口( )A、 createPrepareStatement()B、 prepareStatement()C、 createPreparedStatement()D、 preparedStatement()考点：考察JDBC的api （B）在Jdbc中可以调用数据库的存储过程的接口是( )A、 StatementB、 PreparedStatementC、 CallableStatementD、 PrepareStatement 考点：考察JDBC的api (C)下面的描述正确的是( )A、 PreparedStatement继承自StatementB、 Statement继承自PreparedStatementC、 ResultSet继承自StatementD、 CallableStatement继承自PreparedStatement考点：考察JDBC的api (A)下面的描述错误的是( )A 、Statement的executeQuery()方法会返回一个结果集B、 Statement的executeUpdate()方法会返回是否更新成功的boolean值C、使用ResultSet中的getString()可以获得一个对应于数据库中char类型的值D、 ResultSet中的next()方法会使结果集中的下一行成为当前行考点：返回更新记录的id (B)如果数据库中某个字段为numberic型,可以通过结果集中的哪个方法获取( )A、 getNumberic()B、 getDouble()C、 setNumberic()D、 setDouble()考点：numberic是一种固定精度的浮点数 (B)在Jdbc中使用事务,想要回滚事务事务的方法是( )A、 Connection的commit()B、 Connection的setAutoCommit()C、 Connection的rollback()D、 Connection的close()考点：考察jdbc中的事务管理 (C)关于Class.forName()的作用，下列描述不正确的是：A、Class.forName(xxx.xx.xx);的作用是要求JVM查找并加载指定的驱动器类。