Spring的HibernateDaoSupport类详解
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的基本用法
hibernate的基本用法Hibernate是一个开源的Java框架，用于简化数据库操作。
它为开发人员提供了一个更加简单、直观的方式来管理数据库，同时也提高了应用程序的性能和可维护性。
本文将逐步介绍Hibernate的基本用法，包括配置、实体映射、数据操作等。
一、配置Hibernate1. 下载和安装Hibernate：首先，我们需要下载Hibernate的压缩包并解压。
然后将解压后的文件夹添加到Java项目的构建路径中。
2. 创建Hibernate配置文件：在解压后的文件夹中，可以找到一个名为"hibernate.cfg.xml"的文件。
这是Hibernate的主要配置文件，我们需要在其中指定数据库连接信息和其他相关配置。
3. 配置数据库连接：在"hibernate.cfg.xml"文件中，我们可以添加一个名为"hibernate.connection.url"的属性，用于指定数据库的连接URL。
除此之外，还需要指定数据库的用户名和密码等信息。
4. 配置实体映射：Hibernate使用对象关系映射（ORM）来将Java类映射到数据库表。
我们需要在配置文件中使用"mapping"元素来指定实体类的映射文件。
这个映射文件描述了实体类与数据库表之间的对应关系。
二、实体映射1. 创建实体类：我们需要创建一个Java类，用于表示数据库中的一行数据。
这个类的字段通常与数据库表的列对应。
同时，我们可以使用Hibernate提供的注解或XML文件来配置实体的映射关系。
2. 创建映射文件：可以根据个人喜好选择使用注解还是XML文件来配置实体类的映射关系。
如果使用XML文件，需要创建一个与实体类同名的XML文件，并在其中定义实体类与数据库表之间的映射关系。
3. 配置实体映射：在配置文件中，我们需要使用"mapping"元素来指定实体类的映射文件。
Struts、Spring、Hibernate三大框架的原理和优点
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等。
Spring的HibernateTemplate
使用spring的hibernateTemplate的方法分类：Struts+Hibernate+Spring2009-05-22 15:486178人阅读评论(6)收藏举报使用spring的hibernateTemplate的方法- [spring]版权声明：转载时请以超链接形式标明文章原始出处和作者信息及本声明/logs/24775065.html1.管理SessionFactory使用Spring整合Hibernate时我们不需要hibernate.cfg.xml文件。
首先，在applicationContext.xml中配置数据源（dataSource）bean和session工厂（sessionFactory）bean。
其中，在配置session工厂bean 时，应该注入三个方面的信息：●数据源bean●所有持久化类的配置文件●Hibernate的SessionFactory的属性Hibernate的SessionFactory的属性信息又包括两个内容，一，Hibernate的连接方法；二，不同数据库连接，启动时的选择。
2.为HibernateTemplate注入SessionFactory对象，通过HibernateT emplate来持久化对象Spring提供了HibernateTemplate，用于持久层访问，该模板无需打开Session及关闭Session。
它只要获得SessionFactory的引用，将可以只能地打开Session，并在持久化访问结束后关闭Session，程序开发只需完成持久层逻辑，通用的操作（如对数据库中数据的增，删，改，查）则有HibernateTemplate完成。
HibernateTemplate有三个构造函数，不论是用哪一种构造，要使HibernateTemplate能完成持久化操作，都必须向其传入一个SessionFactory的引用。
HibernateTemplate的用法有两种，一种是常规的用法，另一种是复杂的用。
Spring试题及答案
Spring考试试题1)下面关于Spring的说话正确的是（）（选择两项）A）Spring是一个重量级的框架B）Spring是一个轻量级的框架C）Spring是一个IOC和AOP容器D）Spring是一个入侵式的框架2）下面关于IOC的理解，正确的是（）（选择两项）A）控制反转B）对象被动的接受依赖类C）对象主动的去找依赖类D）一定要用接口3）下面关于AOP的理解，正确的是（）（选择两项）A）面向纵向的开发B）面向横向的开发C）AOP关注是面D）AOP关注的是点4）Spring的组成一共有（）块组成。
A）1 B）3 C）5 D）75）Spring各模块之间关系（）（选择两项）A）Spring各模块之间是紧密联系的，相互依赖的B）Spring各模块之间可以单独存在C）Spring的核心模块是必须的，其他模块是基于核心模块D）Spring的核心模块不是必须的，可以不要6）Spring核心模块的作用（）A）做AOP的B）做IOC的，用来管理Bean的C）是用来支持HiberneteD）是用来支持Struts的7）对Hibernate的支持主要用到Spring的那个模块（）A）Spring核心模块B）Spring ORM模块C）Spring MVC模块D）Spring Web模块8）对Struts的支持主要用到Spring的那个模块（）A）Spring核心模块B）Spring ORM模块C）Spring MVC模块D）Spring Web模块9）Spring的通知类型有（）（多项选择）A）Before通知B）After return通知C）Throws通知D）Around通知10）下面关于切入点的说法正确的是（）（多项选择）A）是AOP中一系列连连接点的集合B）在做AOP时定义切入点是必须的C）在做AOP时定义切入点不是必须的D）可以用正则表达式来定义切入点11)Spring包装Hibernate之后的Hibernate的DAO应该继承那个类（）A）HibernateDAOB）SessionFactoryC）HibernateDAOSuportD）Session12）下面对Spring包装Struts1.2的说法正确的是（）（选择两项）A）Spring包装Struts的ActionServletB）Spring包装Struts的ActionC）主要是利用Spring的依赖注入D）主要利用Spring的面向方面的编程13）Spring包装Struts时那些Spring模块是必须的（）（选择两项）A）Spring核心模块B）Spring AOP模块C）Spring MVC模块D）Spring WEB模块14)Spring中Before通知的目标对象要实现的接口是（）A）MethodBeforeAdviceB）ThrowsAdviceC）AfterReturningAdviceD）MethodInterceptor15）Spring中around通知的目标对象要实现的接口是（）A）MethodBeforeAdviceB）ThrowsAdviceC）AfterReturningAdviceD）MethodInterceptor16）Spring中Before通知的目标对象要实现的接口中before方法中的三个常用的参数依次是（）A）方法，方法的参数，目标对象B）方法的参数，方法，目标对象C）目标对象，方法，方法的参数D）方法的参数，目标对象，方法17）Spring中around通知的目标对象要实现的接口中invoke中方法的参数是（）A）方法B）目标对象C）方法执行参数D）Exception18）下面是Spring依赖注入方式的是（）（选择两项）A）set方法注入B）构造方法的注入C）get方法的注入D）接口的注入19）下面关于在Spring中配置Bean的id属性的说法正确的是（）（选择两项）A）id属性是必须，没有id属性就会报错B）id属性不是必须的，可以没有C）id属性的值可以重复D）id属性的值不可以重复20）下面关于在Spring中配置Bean的name属性的说法正确的是（）（选择两项）A）name属性是必须，没有name属性就会报错B）name属性不是必须的，可以没有C）name属性的值可以重复D）name属性的值不可以重复21)下面是IOC自动装载方法的是（）（选择两项）A）byNameB）byTypeC）constructorD）byMethod22）下面关于在Spring中配置Bean的init-method的说法正确的是（）A）init-method是在最前面执行的B）init-method在构造方法后，依赖注入前执行C）init-method在依赖注入之后执行D）init-method在依赖注入之后，构造函数之前执行23）下面关于Spring配置文件说话正确的是（）（选择两项）A）Spring配置文件必须叫applicationContext.xmlB）Spring配置文件可以不叫applicationContext.xmlC）Spring配置文件可以有多个D）Spring配置文件只能有一个24）看下面的代码，说法正确的是（）<bean id="userTable" class="erTable"><property name="userName"><value>ACCP</value></property></bean>A）其中<property name="userName">的userName是UserTable中的属性，可以不要get、set方法。
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的内容如表，我们暂时不分析。
SpringBoot框架中各层（DTO、DAO、Service、Controller）理解
SpringBoot框架中各层（DTO、DAO、Service、Controller）理解1.粗略理解View层 Controller层（响应⽤户请求） Service层（接⼝ 接⼝实现类） DAO层，即Mapper层（抽象类：xxxMapper.java⽂件，具体实现在xxxMapper.xml） Model层（实体类：xxx.java）2.VO，DTO，DO，PO理解2.1解释VO：View Object，视图层，其作⽤是将指定页⾯的展⽰数据封装起来。
DTO：Data Transfer Object，数据传输对象DO：Domain Object，领域对象PO：Persistent Object，持久化对象2.2模型⽤户发出请求（填写表单），表单的数据被展⽰层匹配为VO展⽰层把VO转换为服务层对应⽅法所要求的DTO，提交给服务层服务层先将DTO的数据构造（或重建）⼀个DO，调⽤DO的业务⽅法完成具体业务服务层再将DO转换为持久层对应的PO，调⽤持久层的持久化⽅法，把PO传递持久化⽅法，完成持久化操3.PO，VO，BO，DTO，JavaBean，JavaBeans，POJO，DAOPO：持久对象 (persistent object)，po(persistent object)就是在Object/Relation Mapping框架中的Entity，po的每个属性基本上都对应数据库表⾥⾯的某个字段。
完全是⼀个符合Java Bean规范的纯Java对象，没有增加别的属性和⽅法。
持久对象是由insert数据库创建，由数据库delete删除的。
基本上持久对象⽣命周期和数据库密切相关。
VO：表现层对象(View Object)，主要对应展⽰界⾯显⽰的数据对象，⽤⼀个VO对象来封装整个界⾯展⽰所需要的对象数据，数据脱敏，去掉⽤户隐私数据。
BO：业务对象层的缩写(Business Object)，封装业务逻辑的java对象，通过调⽤DAO⽅法，结合PO,VO进⾏业务操作。
dao层使用的注解
dao层使用的注解在Java开发中，DAO（Data Access Object）层承担着与数据库交互的任务。
为了简化和优化DAO层的编写，我们可以使用一些注解来简化代码的撰写和理解。
以下是关于DAO层使用的一些常见注解：1. @Repository：用于标注DAO层的类。
这个注解用于将DAO实现标记为Spring的组件，方便程序的组织和管理。
通过这个注解，我们可以将DAO实例纳入到Spring容器中，并将其作为依赖进行注入。
2. @Autowired：用于自动装配DAO层的对象。
当我们在DAO层需要使用其他对象时，可以使用@Autowired注解自动将需要的对象注入进来。
这样可以省去手动创建对象和设置依赖的工作，减少了代码的冗余和错误。
3. @Transactional：用于控制事务的注解。
在DAO层的数据操作中，我们经常会遇到需要开启事务、提交事务或回滚事务的情况。
通过@Transactional注解，我们可以将整个方法或者类标记为需要进行事务管理的操作。
这样，在方法执行时，Spring会自动为其开启事务，并根据业务逻辑的成功与否来决定是提交事务还是回滚事务。
4. @Query：用于自定义查询的注解。
在DAO层的查询方法中，我们经常需要定义一些复杂的查询语句。
通过使用@Query注解，我们可以直接在方法上面编写SQL语句或者JPQL语句，从而实现我们所需要的查询功能。
这样可以提高开发效率，同时也可以避免对数据库进行频繁的访问，提升查询的性能。
5. @Modifying：用于更新操作的注解。
在DAO层的更新方法中，我们经常会遇到更新数据的情况。
通过@Modifying注解，我们可以标记该方法为更新操作，并且在方法上面编写相应的更新语句。
这样，Spring会根据方法的返回值来判断更新操作是否成功，并且可以自动将更新操作放入到事务中进行管理。
以上是DAO层常用的一些注解，使用这些注解可以使DAO层的编写更加简洁、易读和易维护。
项目中需要用到spring 的地方
对结果列表进行加工：不论通过jdbc还是hibernate方式，如果需要对find方法取得的列表中的对象进行加工，显然使用回调模式进行效率更高。实际上如果使用HibernateTemplate并且希望查询出的结果不是对象列表而是数组列表，那么也可以使用回调，如下：
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
另外在实际项目中有一个发现，在websphere6.0的容器下部署的web应用，使用websphere自带的数据库连接池，当spring事务配置为readOnly,在数据量比较大，并且有一定并发量时会导致websphere连接池抛出异常，并导致性能严重下降。去掉readOnly选项就恢复正常了，这种情况不容易在测试环境重现，因此只能去掉readOnly选项，发现去掉以后性能也没有太多的下降。
service端的框架支持：在serivce层通过ioc进行bean的管理配置，同时进行事务控制的定义。
aop：利用拦截器配置管理特性
jndi：利用spring的context组件对jndi进行定义，通常用于数据库连接池的配置和查找
其他：spring1.2版本的mvc组件是针对web端的应用框架，尽管理念非常oop，不过实际使用的时候确实不如struts2好使，spring 2.0以后的mvc据说有很大改进，以后有机会再用吧。另外spring的定时任务（job）也经常用到，后边会有提及。
Hibernate基础知识详解
Hibernate基础知识详解<hibernate-mapping><class name="*.*.*" table="t_customer" catalog="***"><id name="id" column="c_id"><generator class="identity"/></id><property name="name" column="c_name" length="20"/><set name="orders" inverse="false" cascade="save-update"><key column="c_customer_id"/></set></class></hibernate-mapping>(1)统⼀声明包名，这样在<class>中就不需要写类的全名。
(2)关于<class>标签配置name 属性:类的全名称table 表的名称,可以省略，这时表的名称就与类名⼀致catalog 属性:数据库名称可以省略.如果省略，参考核⼼配置⽂件中 url 路径中的库名称(3)关于<id>标签,<id>是⽤于建⽴类中的属性与表中的主键映射。
name 类中的属性名称column 表中的主键名称 column 它也可以省略，这时列名就与类中属性名称⼀致length 字段长度type 属性指定类型<generator>它主要是描述主键⽣成策略。
HibernateDaoSupport详解
Processed in 0.0527 second(s), 8 queries
2006
2005
2004
2003
2002
2001
2000
1999
1998
1997
1996
1995
1994
1993
1992
1991
1990
1989
1988
1987
1986
1985
1984
1983
1982
1981
1980
1979
1978
1977
个评论)
全部 作者的其他最新笔记 面试心得 jqs.exe进程 java:读取文件、控制台显示 网页设计中字体排版（大小、间距） 09年的零零总总
热门笔记导读湘潭大学 朱云翔(C/C++老师): 实现动画的方法——计算机达人成长之路（21） 蒋轶民(游戏开发): windows c++编程获取当前路径
向黑客迈进！！！ 吕海鹏(Net老师): 坚持每天学英语，5年弹指一挥间 Leo张大志(职业指导老师): 什么决定了技术人员的薪水——Leo网上答疑49
金陵科技学院 李小飞(Net): 不要混生活，小心生活混了你 左飞(C/C++老师): 我们都可以学好C语言
CSDN学生大本营 - 联系我们
中的SessionFactory实例，getHibernateTemplate方法用来利用刚才的SessionFactory生成Session，
hibernate高级用法
hibernate高级用法Hibernate是一种Java持久化框架，用于将对象转换为数据库中的数据。
除了基本的用法，Hibernate还提供了一些高级的用法，以下是一些常见的Hibernate高级用法：1、继承Hibernate支持类继承，可以让子类继承父类的属性和方法。
在数据库中，可以使用表与表之间的关系来实现继承，例如使用一对一、一对多、多对一等关系。
使用继承可以让代码更加简洁、易于维护。
2、聚合Hibernate支持聚合，可以将多个对象组合成一个对象。
例如，一个订单对象可以包含多个订单行对象。
在数据库中，可以使用外键来实现聚合关系。
使用聚合可以让代码更加简洁、易于维护。
3、关联Hibernate支持关联，可以让对象之间建立关联关系。
例如，一个订单对象可以关联一个客户对象。
在数据库中，可以使用外键来实现关联关系。
使用关联可以让代码更加简洁、易于维护。
4、延迟加载Hibernate支持延迟加载，可以在需要时才加载对象。
延迟加载可以减少数据库的负担，提高性能。
Hibernate提供了多种延迟加载的策略，例如按需加载、懒惰加载等。
5、事务Hibernate支持事务，可以确保数据库的一致性。
事务是一组数据库操作，要么全部成功，要么全部失败。
Hibernate提供了事务管理的方法，例如开始事务、提交事务、回滚事务等。
6、缓存Hibernate支持缓存，可以减少对数据库的访问次数，提高性能。
Hibernate提供了多种缓存策略，例如一级缓存、二级缓存等。
使用缓存需要注意缓存的一致性和更新问题。
7、HQL查询语言Hibernate提供了HQL查询语言，可以让开发人员使用面向对象的查询方式来查询数据库。
HQL查询语言类似于SQL查询语言，但是使用的是Java类和属性名，而不是表名和列名。
HQL查询语言可以更加灵活、易于维护。
以上是一些常见的Hibernate高级用法，它们可以帮助开发人员更加高效地使用Hibernate进行开发。
struts2+spring+hibernate分页显示完整代码
分页显示一直是web开发中一大烦琐的难题，传统的网页设计只在一个JSP或者ASP页面中书写所有关于数据库操作的代码，那样做分页可能简单一点，但当把网站分层开发后，分页就比较困难了，下面是我做Spring+Hibernate+Struts2项目时设计的分页代码，与大家分享交流。
1、DAO层接口的设计，在MemberDao接口中定义了如下两个方法：publicinterface MemberDao {@SuppressWarnings("unchecked")/*** 分页查询* @param hql查询的条件* @param offset 开始记录* @param length 一次查询几条记录* @return*/public List queryForPage(final Stringhql,finalint offset,finalint length);/*** 查询所有记录数* @param hql查询的条件* @param offset 开始记录* @return总记录数*/publicint getAllRowCount(String hql);}2、DAO层实现类MemberDaoImpl对上面两个方法的实现如下：publicclass MemberDaoImpl extends HibernateDaoSupport implements Me mberDao {/*** 查询所有记录数* @return总记录数*/publicint getAllRowCount(String hql) {return getHibernateTemplate().find(hql).size();}/*** 分页查询* @param hql查询的条件* @param offset 开始记录* @param length 一次查询几条记录* @return*/@SuppressWarnings("unchecked")public List queryForPage(final String hql, finalint offset, finalint length) {List list =getHibernateTemplate().executeFind(new HibernateCallback(){ public Object doInHibernate(Session session)throws HibernateException, SQLException {Query query = session.createQuery(hql);query.setFirstResult(offset);query.setMaxResults(length);List list = query.list();return list;}});return list;}}细心的读者会发现，这个类继承了HibernateDaoSupport类，HibernateDaoSupport是Spring 提供的对Hibernate支持的类，getHibernateTemplate().executeFind(new HibernateCallback(){....})方法中的参数，我们使用了接口回调，在其参数内，我们能像原生的Hibernate一样调用query.setFirstResult(offset)和query.setMaxResults(length)来实现分页查询功能。
Hibernate4在开发当中的一些改变
Hibernate4的改动较大只有spring3.1以上版本能够支持，Spring3.1取消了HibernateTemplate，因为Hibernate4的事务管理已经很好了，不用Spring再扩展了。
这里简单介绍了hibernate4相对于hibernate3配置时出现的错误，只列举了问题和解决方法，详细原理如果大家感兴趣还是去自己搜吧，网上很多。
1. Spring3.1去掉了HibernateDaoSupport类。
hibernate4需要通过getCurrentSession()获取session。
并且设置<propkey="hibernate.current_session_context_class">org.springframework.orm.hibe rnate4.SpringSessionContext</prop>（在hibernate3的时候是thread和jta）。
2. 缓存设置改为<propkey="hibernate.cache.provider_class">net.sf.ehcache.hibernate.EhCacheProvi der</prop><propkey="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhC acheRegionFactory</prop>3. Spring对hibernate的事务管理，不论是注解方式还是配置文件方式统一改为：<bean id="txManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager" ><property name="sessionFactory"><ref bean="sessionFactory"/></property></bean>4. getCurrentSession()事务会自动关闭，所以在有所jsp页面查询数据都会关闭session。
spring练习及答案
31.下面关于AOP的说法错误的是（ C ）。
A．AOP将散落在系统中的“方面”代码集中实现B．AOP有助于提高系统的可维护性C．AOP已经表现出了将要替代面向对象的趋势D．AOP是一种设计模式，Spring提供了一种实现2.事务隔离级别是由谁实现的？（ C ）。
A．Java应用程序 B．Hibernate C．数据库系统 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 )。
Spring笔试试题答卷
一、选择题(共25题，每题4分，满分100分)1) 下列关于Spring特性中IoC描述错误的是（）。
A．IoC就是指程序之间的关系由程序代码直接操控B．所谓“控制反转”是指控制权由应用代码转到外部容器，即控制权的转移C．IoC将控制创建的职责搬进了框架中，从应用代码脱离开来D．使用Spring的IoC容器时只需指出组件需要的对象，在运行时Spring的IoC容器会根据XML配置数据提供给它2）在Spring中，数据连接是通过数据源获得的，下列关于Spring数据源描述错误的是（）。
B．Spring在第三方依赖包中包含了两个数据源的实现类包，其一是Apache的DBCP，其二是C3P0C．Spring提供引用JNDI资源的类是JndiObjectFactoryBean D．DriverManagerDataSource比较适合在单元测试或简单的独立应用中使用3) 下列关于Spring配置文件的说法不正确的是（）。
A．Spring默认是读取/WEB-INF/applicationContext.xml配置文件B．Spring的配置文件可以配置在类路径下，并可以重命名，但是需要在web.xml文件中指定C．把applicationContext.xml文件放到src目录下，Spring也可以读到D．可以通过在web.xml中的<context-param><param-name>和<param-value>进行指定Spring配置文件4) 下面关于Spring中的bean的作用域，描述错误的是（）。
A．Spring中的bean的作用域可以通过scope属性进行配置B．Spring中的bean的作用域默认是prototypeC．当一个bean的scope设为“singleton”时，可以被多个线程同时访问D．一个bean的scope只对它自己起作用，与其它bean无关5) 下列关于Spring的装配模式（default-autowire）描述不正确的是（）。
马士兵Spring课堂笔记(超级详细版)
课程内容---…详细包括整合struts hibernate------------------------------------1.面向接口（抽象）编程的概念与好处2.IOC/DI的概念与好处a)inversion of controlb)dependency injection3.AOP的概念与好处4.Spring简介5.Spring应用IOC/DI（重要）a)xmlb)annotation6.Spring应用AOP（重要）a)xmlb)annotation7.Struts2.1.6 + Spring2.5.6 + Hibernate3.3.2整合（重要）a)opensessionInviewfilter（记住，解决什么问题，怎么解决）8.Spring JDBC面向接口编程…（面向抽象编程）1.场景：用户添加2.Spring_0100_AbstractOrientedProgramminga)不是AOP:Aspect Oriented Programming3.好处：灵活什么是IOC（DI）,,，有什么好处1.把自己new的东西改为由容器提供a)初始化具体值b)装配<?xml version="1.0"?>-<beans><bean class="erDAOImpl" id="u"/>（class 是个类。
Id就等于构造了一个对象）<bean class="erService" id="userService"><property bean="u" name="userDAO"/> </bean>（把u这个对象注入到UserService这个类的一个userDAO的一个属性里）-</beans>2.好处：灵活装配Spring简介包括整合struts hibernate------------------------------------1.项目名称：Spring_0200_IOC_Introduction2.环境搭建a)只用IOCi.spring.jar , jarkata-commons/commons-loggin.jar3.IOC容器a)实例化具体beanb)动态装配4.AOP支持a)安全检查b)管理transactionSpring IOC配置与应用1.FAQ:不给提示：a)window – preferences – myeclipse – xml – xml catalogb)User Specified Entries – addi.Location: D:\share\0900_Spring\soft\spring-framework-2.5.6\dist\resources\spring-beans-2.5.xsdii.URI:file:///D:/share/0900_Spring/soft/spring-framework-2.5.6/dist/resources/spring-beans-2.5.xsd iii.Key Type: Schema Locationiv.Key: /schema/beans/spring-beans-2.5.xsd2.注入类型a)Spring_0300_IOC_Injection_Typeb)setter（重要）c)构造方法（可以忘记）d)接口注入（可以忘记）3.id vs. Name(可以把Id换成name，没什么区别！)a)Spring_0400_IOC_Id_Nameb)name可以用特殊字符4.简单属性的注入a)Spring_0500_IOC_SimplePropertyb)<property name=… value=….>在配置文件里直接赋值！（在此简单属性为int和string，会自动转换）5.<bean 中的scope属性a)Spring_0600_IOC_Bean_Scopeb)singleton 单例（无论去多少次都是同一个bean）c)proptotype 每次创建新的对象6.集合注入a)Spring_0700_IOC_Collectionsb)很少用，不重要！参考程序7.自动装配a)Spring_0800_IOC_AutoWireb)byNamec)byTyped)如果所有的bean都用同一种，可以使用beans的属性：default-autowire-<bean class="erDAOImpl" name="userDAO"><property name="daoId" value="1"/> </bean><bean class="erDAOImpl" name="userDAO2"><property name="daoId" value="2"/> </bean><bean class="erService"autowire="byType" scope="prototype" id="userService"></bean> </beans>（这里会报错，因为有两个userDAO和UserDAO2都是int类型！）（如果说byname则会显示第一个的内容“1”！，因为UserService类里面的userDAO属性与第一个的名字一样！）8.生命周期a)Spring_0900_IOC_Life_Cycleb)lazy-init (不重要)c)init-method与destroy-methd 不要和prototype一起用（了解）<bean class="erDAOImpl" id="u"></bean><bean class="erService" id="userService" scope="prototype"destroy-method="destroy" init-method="init"></bean></beans>9.Annotation第一步：a)修改xml文件，参考文档<context:annotation-config />b)默认按类型by typec)如果想用byName，使用@Qulifierd)写在private field（第三种注入形式）（不建议，破坏封装）e)如果写在set上，@qualifier需要写在参数上f)10.@Resource（重要）a)加入：j2ee/common-annotations.jarb)默认按名称，名称找不到，按类型c)可以指定特定名称d)推荐使用e)不足：如果没有源码，就无法运用annotation，只能使用xml11.@Component@Service @Controller @Repository（四个一样的功能！！）a)初始化的名字默认为类名首字母小写b)可以指定初始化bean的名字首先先加载ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml"); 即读beans.xml里面的内容，然后通过找从com.bjsxt开始“scan”含@component的类，找到之后就初始化对象，结果在其一个属相的set方法上找到一个源为“u”的一个bean，于是就加载那个bean！12.@Scope13.@PostConstruct = init-method;(在构造对象后执行此方法)@PreDestroy = destroy-method；（在容器销毁前执行此方法）什么是AOP1.面向切面编程Aspect-Oriented-Programminga)是对面向对象的思维方式的有力补充2.Spring_1400_AOP_Introduction3.好处：可以动态的添加和删除在切面上的逻辑而不影响原来的执行代码a)Filterb)Struts2的interceptor4.概念：a)JoinPoint 释意:切面与原方法交接点即切入点b)PointCut 释意:切入点集合是com.xyz.someapp.service.下面的任何类，任何方法，任何返回值的一个切入点的集合。
Springboot的entity,dao,controller,service层级理解
Springboot的entity,dao,controller,service层级理解1.Dao层：持久层，主要与数据库交互DAO层⾸先会创建Dao接⼝，接着就可以在配置⽂件中定义该接⼝的实现类；接着就可以在模块中调⽤Dao的接⼝进⾏数据业务的处理，⽽不⽤关注此接⼝的具体实现类是哪⼀个类，Dao层的数据源和数据库连接的参数都是在配置⽂件中进⾏配置的。
2.Entity层：实体层，数据库在项⽬中的类主要⽤于定义与数据库对象应的属性，提供get/set⽅法,tostring⽅法,有参⽆参构造函数。
3.Service层：业务层控制业务业务模块的逻辑应⽤设计，和DAO层⼀样都是先设计接⼝，再创建要实现的类，然后在配置⽂件中进⾏配置其实现的关联。
接下来就可以在service层调⽤接⼝进⾏业务逻辑应⽤的处理。
好处：封装Service层的业务逻辑有利于业务逻辑的独⽴性和重复利⽤性。
4.Controller层：控制层控制业务逻辑具体的业务模块流程的控制，controller层主要调⽤Service层⾥⾯的接⼝控制具体的业务流程，控制的配置也要在配置⽂件中进⾏。
Controller和Service的区别是：Controller负责层负责业务模块的逻辑应⽤设计逻辑应⽤设计流程的控制；的控制；Service层负责业务模块的的业务模块流程负责具体具体的业务模块总结：具体的⼀个项⽬中有：controller层调⽤了Service层的⽅法，Service层调⽤Dao层的⽅法，其中调⽤的参数是使⽤Entity层进⾏传递的。
补充：5、View层此层与控制层结合⽐较紧密，需要⼆者结合起来协同⼯发。
View层主要负责前台jsp页⾯的表⽰，。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
HibernateDaoSupport:
（创建一个子类对象的时候，会先创建一个父类对象）。
当LogDAOImpl继承HibernateDaoSupport的时候，程序执行报错，原因是必须要注入SessionFactory或者HibernateTemplate。
因为HibernateDaoSupport是abstract类，所以无法生成HibernateDaoSupport对象来实现注入；那我们只能生成其子类LogDAOImpl的对象，在调用HibernateDaoSupport类中的set方法进行注入，但这个方法还是不行，因为HibernateDaoSupport类中的set方法为final方法。
总之，我们无法使用annotation方式在HibernateDaoSupport中注入SessionFactory或者HibernateTemplate。
，那么我们的LogDAOImpl类就不能使用annotation的方式生成了，我们只能（暂且，以后会有其他方法）在beans.xml中进行注入如下：
使用这种方式进行注入，我们又会有另外一个问题：假如现在有很多的DAO的实现需要继承HibernateDaoSupport，那么我们在beans.xml文件中就需要配很多的<bean……>，这样仅配置文件就非常庞大了。
到现在，我们已经知道了HibernateDaoSupport怎么使用了。
使用上面的方法直接继承HibernateDaoSupport比较复杂，现在介绍一种简便的方法：我们可以把DAO抽象处理，写一个抽象类，让它去继承HibernateDaoSupport，如下：
如下修改beans.xml文件，将sessionFactory注入给它：
然后在DAO实现中继承，如下：
这样，如果我们再有一个DAO的实现，我们只要再写一个实现类即可，而无须在beans.xml文件中再进行一个配置。
综上，如果要使用HibernateDaoSupport的话，就采用这样的方法：抽象出DAO，让它去继承HibernateDaoSupport，所有DAO实现继承这个抽象的DAO，在beans.xml只要将这个抽象的DAO，也就是顶层的DAO初始化bean则可。
这样，在DAO实现中又可以使用annotation。
但这种方式经过实验不行，运行的时候还是无法配置一次就可以在很多DAO实现中使用，仍然会报错说需要SessionFactory或者HibernateTemplate。
原因是：当我们在调用DAO 实现的时候，确确实实会初始化父类DAO对象，这个初始化过程Spring确实也能帮我们管理起来，但是，现在的问题是由于我们在DAO实现中使用的是annotation，而父类的初始化用的是beans.xml方式，所以子类和父类的初始化方式不匹配。
怎么证明呢？现在我们的父类DAO我们不使用xml方式，而是采用annotation方式来初始化。
但是，使用annotation 方式，父类DAO是继承HibernateDaoSupport，上面已经分析了，继承自HibernateDaoSupport 我们又无法注入SessionFactory或者HibernateTemplate。
最后，我们干脆不要HibernateDaoSupport了。
继承自HibernateDaoSupport抽象类是因为我们可以不用在每个DAO实现类里面写HibernateTemplate，然而继承自HibernateDaoSupport，我们却又无法注入SessionFactory或者HibernateTemplate，程序报错。
那现在我们干脆就不继承自HibernateDaoSupport了，而是我们自己抽象出父类DAO，我们在父类DAO中自己实现注入HibernateTemplate（annotation方式，与子类初始化方式一致）。
如下：
父类DAO实现了HibernateTemplate注入，那么我们在DAO实现类中就可以直接使用HibernateTemplate了，如下：
总结：HibernateDaoSupport不重要，不需要。
继承HibernateDaoSupport可以使我们不用在每个子类(DAO实现)中注入HibernateDaoSupport，但HibernateDaoSupport只能在beans.xml文件中配置，当子类使用annotation注入方式，则会出现父类和子类注入方式不匹配的错误。
所以我们不要继承自HibernateDaoSupport了，而是抽象出一个父类DAO，在父类DAO中使用annotation方式注入HibernateTemplate，这样，子类（同样使用annotation 方式注入）继承自父类DAO，就同时拥有了父类DAO已经注入的HibernateTemplate，可以直接使用this.getHibernateTemplate().save(user)，这样就不用再每一个DAO实现中都注入HibernateTemplate，既完成了HibernateDaoSupport的功能，有免去了HibernateDaoSupport 所带来的麻烦。
最后得出结论，HibernateDaoSupport没有用。