来自:http://hi.baidu.com/%BB%A8%BB%F0%C8%D5%BC%C7/blog/item/9f4e9325b7384c6e34a80fa3.html
二、spring整合hibernate
1. 查看applicationContext.xml有了变化,多了hibernate的配置
2. 建立表的映射
选择数据库视图,accp数据库
生成users.hbm.xml与Users.java
去掉catagory属性,否则会报错
也在applicationContext.xml中增加了映射
3. 整合hibernate有两种方式
4. 第一种方式,继承
org.springframework.orm.hibernate3.HibernateTemplate,该类是spring封装了操作Hibernate的实现细节的类,用于代替Session的相关操作。主要方法:
Serializable save(Object?entity) :保存记录
void update(Object?entity) :修改记录
void delete(Object?entity) :删除记录
Object get(Class?entityClass, Serializable?id)
Object load(Class?entityClass, Serializable?id)
List executeFind(HibernateCallback?action) :查询,返回集合
Object execute(HibernateCallback?action):查询,返回对象
总的说来,该类的方法和Session接口中定义的方法是一致的.
1)在dao包中写接口IDao,
public interface IDao {
public void save(Users u);
public List getAll();
public boolean validate(Users u);
}
UserDao extends HibernateDaoSupport implements IDao
public class UserDao extends HibernateDaoSupport implements IDao{
public void save(Users u){
this.getHibernateTemplate().save(u);
}
}
2)在spring中配置UserDao,从哪取连接,property二择其一
给继承了HibernateDaoSupport的对象我们注入一个sessionFactory 对象也可以,他会自动生成一个hibernateTemplate对象
<bean id="userdao" class="org.accp.hibernate.dao.UserDao">
<property name="sessionFactory" ref="sessionFactory" />
<!--<property name="hibernateTemplate" ref="hibernateTemplate"/>-->
</bean>
3)测试
导入mysql.jar,不能拷贝到lib下,也找不到,这时要在buildPath中导入外部jar
去掉users.hbm.xml中的catagory属性,否则会报错
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
IDao dele = (IDao)ac.getBean("userdao");
Users u = new Users();
u.setUid("userdao");
u.setPwd("123");
u.setVersion(2);
dele.save(u);
5. 第二种方式
1) 新建一个类UserDao2,加一成员变量HibernateTemplate
加一构造函数,注入sessionFactory
加一setter方法,注入sessionFactory
public class UserDao2 implements IDao{
private HibernateTemplate hibernateTemplate;
public UserDao2(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}
public void save(Users u){
hibernateTemplate.save(u);
}
}
2) 改配置文件applicationContext.xml
<bean id="userdao2" class="org.accp.hibernate.dao.UserDao2">
<constructor-arg>
<ref bean="hibernateTemplate"/>
</constructor-arg>
</bean>
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>
6. HibernateDaoSupport与连接的管理
而调用getHibernateTemplate()就会自动关闭连接。
这是日志
[main] DEBUG org.springframework.orm.hibernate3.SessionFactoryUtils - Closing Hibernate Session
自动关闭连接会造成延迟加载初始化异常,此时可用OpenSessionInView模式解决。Spring提供Open Session In View来解决这个问题, 有两种方式。
1) Interceptor,在applicationContext.xml配置
<bean id="openSessionInViewInterceptor" class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="interceptors" ref="openSessionInViewInterceptor"/>
<property name="mappings">
<props>
......
</props>
</property>
</bean>
2) Filter,在web.xml中配置
<filter>
<filter-name>hibernateFilter</filter-name>
<filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
<!-- 默认情况下,这个Filter会在Spring的bean池中找一个叫做sessionFactory的bean。如果使用了其他名字的SessionFactory,则应该在这里 -->
<init-param>
<param-name>sessionFactoryBeanName</param-name>
<param-value>sessionFactory</param-value>
</init-param>
<!-- singleSession默认为true,若设为false则等于没用OpenSessionInView -->
<init-param>
<param-name>singleSession</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>hibernateFilter</filter-name>
<url-pattern>*.do</url-pattern>
</filter-mapping>
加了这个配置,就要加监听器和初始文件的参数,否则报错
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
7. HibernateDaoSupport与自动提交
每执行一个sql,默认都是由spring自动提交事务。可以在数据源中插入进去
<property name="defaultAutoCommit">
<value>false</value>
</property>
8. spring整合hibernate事务
Don't call me, I will call you
更少代码,更少BUG
Spring提供的事务管理可以分为两类:编程式的和声明式的。
1) 编程式的
比较灵活,但是代码量大,存在重复的代码比较多,当你只有很少的事务操作时,编程式事务管理通常比较合适。
代码
public class UserDao3 extends HibernateDaoSupport implements IDao{
private HibernateTransactionManager transactionManager;
public void setTransactionManager(HibernateTransactionManager transactionManager) {
this.transactionManager = transactionManager;
}
public void save(Users u){
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
TransactionStatus status = transactionManager.getTransaction(def);
try{
this.getHibernateTemplate().save(u);
//不提交插入不了
transactionManager.commit(status);
}catch(Exception e) {
transactionManager.rollback(status);
}
}
}
配置
<bean id="userdao3" class="org.accp.hibernate.dao.UserDao3">
<property name="sessionFactory" ref="sessionFactory"/>
<property name="transactionManager" ref="transactionManager"/>
</bean>
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>
2) 声明式的
其DAO必须要有接口,否则声明式事务就会报错。
a) 事务属性
<prop key="save*">PROPAGATION_REQUIRED,readOnly</prop>
key属性确定代理应该给哪个方法增加事务行为。 PROPAGATION_REQUIRED--支持当前事务,如果当前没有事务,就新建一个事务。这是最常见的选择。
PROPAGATION_SUPPORTS--支持当前事务,如果当前没有事务,就以非事务方式执行。
PROPAGATION_MANDATORY--支持当前事务,如果当前没有事务,就抛出异常。
PROPAGATION_REQUIRES_NEW--新建事务,如果当前存在事务,把当前事务挂起。
PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。
PROPAGATION_NEVER--以非事务方式执行,如果当前存在事务,则抛出异常。
PROPAGATION_NESTED--如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则进行与PROPAGATION_REQUIRED类似的操作。
事务属性中的readOnly标志表示对应的事务应该被最优化为只读事务,避免dirty checking。
b) 事务策略
为了实际执行事务,Spring所有的事务划分功能都通过传递适当的TransactionDefinition实例,委托给PlatformTransactionManager。
Spring具有多种PlatformTransactionManager实现,它们分为两类:
局部事务策略--针对单个资源执行事务(在多数情况下是针对单个的数据库)。
全局事务管理--执行有可能跨越多个资源的全局事务。
c) 事务代理
TransactionProxyFactoryBean是Spring2.0之前的旧版本风格的配置
TransactionInterceptor,它使用一个PlatformTransactionManager实现配合,在方法调用前后实施事务。
d) 例子
配置文件
<bean id="userdao4" class="org.accp.hibernate.dao.UserDao4">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<bean id="proxyTemplate" class="org.springframework.transaction.interceptor.TransactionInterceptor">
<property name="transactionManager">
<ref bean="transactionManager"/>
</property>
<property name="transactionAttributes">
<props>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="query*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>
<bean id="nameproxy" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames">
<list><value>userdao4</value></list>
</property>
<property name="interceptorNames">
<list>
<value>proxyTemplate</value>
</list>
</property>
</bean>
不用事务,即使报错也始终能插入进去一条。用了事务,一报错则一条都不进去。
配置完成前,将defaultAutoCommit设成false后,始终插入不进去。
配置完成后,将使用声明式事务能插入进去了。
9. sql提高,修改UserDao
// executeFind返回集合
public List query() {
return this.getHibernateTemplate().executeFind(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException,
SQLException {
return session.createQuery(
"from " + cls.getName() + " as a order by a.uid desc").list();
}
});
}
// execute返回对象
public boolean validate(final Users u) {
List ls = (List) this.getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Query qy = session
.createQuery("from Users u where u.uid=:uid and u.pwd=:pwd");
qy.setString("uid", u.getUid());
qy.setString("pwd", u.getPwd());
List li = qy.list();
return li;
}
});
return (ls.size() > 0);
}
分享到:
相关推荐
标题"spring整合hibernate示例代码"提示我们,我们将讨论如何在实际项目中结合这两个框架。Spring可以帮助管理Hibernate的SessionFactory和Transaction,提供声明式事务管理,以及通过AOP(面向切面编程)实现更灵活...
标题"Spring整合Hibernate.jar"意味着我们将讨论如何将这两个强大的框架集成在一起,以便在Spring管理的环境中使用Hibernate进行数据库操作。这通常涉及到以下步骤和知识点: 1. **引入依赖**:首先,你需要在项目...
本篇文章将详细探讨如何通过Spring整合Hibernate来实现事务处理,重点介绍注解方式和XML配置方式。 首先,我们了解事务处理在数据库操作中的重要性。事务是一组操作,这些操作要么全部成功,要么全部失败,确保数据...
标题中的“spring整合hibernate的jar包”指的是在Java Web开发中,Spring框架与Hibernate持久层框架的集成。这两个框架结合使用可以提供强大的数据访问和业务逻辑处理能力。Spring作为一个全面的轻量级框架,提供了...
本文将深入探讨Spring整合Hibernate的相关知识点,适合初学者入门。 首先,我们需要理解Spring的核心理念。Spring框架提供了一个轻量级的容器,它能够管理应用程序中的对象,包括初始化、配置和依赖注入。AOP则是...
Spring4整合Hibernate4实现用户购买图书和结账等操作,整合主要实现用IoC容器来管理Hibernate的SessionFactory实例,并使Hibernate使用Spring所提供的声明式事务……
这篇名为"spring整合hibernate实例"的内容,显然是关于如何将这两个框架协同工作,构建一个高效、灵活的Java应用的教程。在整合过程中,我们将探讨以下几个关键知识点: 1. **Spring的ApplicationContext**: 这是...
《Spring整合Hibernate实战指南》 在Java开发领域,Spring框架以其强大的依赖注入、AOP(面向切面编程)以及丰富的模块支持,成为了企业级应用开发的首选。而Hibernate作为持久层框架,以其对象关系映射(ORM)能力...
Spring整合Hibernate是现代Java开发中常见的一种技术组合,利用Spring框架的强大功能来管理和协调Hibernate的持久化操作。Spring为Hibernate提供了全面的集成方案,简化了DAO(Data Access Object)的开发,同时也...
首先,我们需要理解Spring如何与Hibernate和Struts进行整合: 1. **Spring与Hibernate整合**: - Spring通过其`HibernateTemplate`或`HibernateDaoSupport`类简化了对Hibernate的操作,提供了事务管理。你可以定义...
下面,我们将深入探讨Spring整合Hibernate的相关知识点。 1. **依赖注入**:Spring框架的核心特性之一是依赖注入(DI),它允许我们在不进行硬编码的情况下管理对象之间的依赖关系。在整合Hibernate时,Spring可以...
标题"spring整合hibernate与struts2所需jar包"表明我们需要关注的是如何将这三个框架整合在一起,并且提供了所需的一些基础组件。整合SSH可以让开发者利用Spring的管理能力,让Hibernate更易于使用,同时通过Struts2...
Spring整合Hibernate配置测试示例
在"spring整合hibernate开发源码"的压缩包中,可能包含了以下内容: 1. **配置文件**:如`applicationContext.xml`,其中配置了Spring和Hibernate的相关bean,如DataSource、SessionFactory、TransactionManager等。...
这里的jar包只是说Spring自带的关于Hibernate的jar包,即这四个jar包: hibernate3.jar, hibernate-annotations.jar, hibernate-entitymanager.jar hibernate-commons-annotations.jar 因为我原来下载了一个,但是...
这个“Spring+hibernate整合源代码”应该包含了实现上述整合步骤的示例代码,可以作为学习和参考的资源。通过学习和实践这些代码,你可以更好地理解和掌握 Spring 和 Hibernate 整合的细节,提升你的 Java Web 开发...
Spring 整合 Hibernate 是一种常见的企业级应用开发模式,它将 Spring 框架的管理优势与 Hibernate 的持久层功能结合起来,提供了更高效、更稳定的应用解决方案。在本学习笔记中,我们将深入探讨如何实现这一整合,...
Spring整合Hibernate基于HibernateTemplate的方式,极大地简化了数据库操作,同时也让事务管理和代码的编写变得更加规范和高效。在实际项目中,可以根据需求进一步配置和优化,比如使用JPA的...
当我们谈到"Spring整合Hibernate例子"时,这意味着我们将探讨如何将这两个强大的框架结合在一起,以实现更高效、更灵活的数据库操作。 Spring框架的核心特性之一是依赖注入(Dependency Injection,DI),这使得...