- 浏览: 685212 次
- 性别:
- 来自: 上海
文章分类
- 全部博客 (254)
- java分布式应用架构 (22)
- SSH框架整合 (6)
- java web 学习笔记 (49)
- java 学习笔记 (56)
- struts 2 学习 (6)
- Hibernate学习 (10)
- spring 学习 (2)
- 客户端编程(javascript) (4)
- IDE使用 (13)
- 生命 人生 (6)
- 系统维护 (3)
- 技术篇 (10)
- MySql (2)
- J2ME (1)
- java网络编程 (4)
- 数据库 (5)
- C/C++ (8)
- Oracle (7)
- 软件测试 (0)
- 软件的安装和部署 (0)
- Java快讯 (1)
- swt (1)
- Flex (1)
- 软件工程 (1)
- PostgreSQL (1)
- sql server2000 (2)
- 嵌入式数据库sqlite (5)
- J2EE (1)
- XML (1)
- ibatis3(MyBatis) (6)
- Linux&Unix (1)
- velocity (1)
- 回报社会 (4)
- 软件项目管理 (3)
- android研究 (3)
- C# (2)
- Objective-C (1)
- 音乐 (0)
- webx (1)
- JMS (1)
- maven软件项目管理 (1)
- 分布式服务 (0)
- 云平台 (0)
- 分布式存储 (1)
- 分布式系统架构 (0)
- 移动互联网 (1)
- ZooKeeper (1)
最新评论
-
liyys:
楼主,可不可以发这个项目的源码工程出来分享一下,少了几个类。楼 ...
仿照Hibernate实现一个SQLite的ORM框架 -
liyys:
少了一些类的源码没有粘贴出来
仿照Hibernate实现一个SQLite的ORM框架 -
honglei0412:
我使用的是这种方式获取db文件的目录但是 URL p = Fi ...
使用sqlite注意事项 -
honglei0412:
大侠 能不能说明下DbFile您是怎么做的吗?
使用sqlite注意事项 -
ahack:
刚写完mapping才发现早就有人写好了。仔细一看还都是针对的 ...
仿照Hibernate实现一个SQLite的ORM框架
1.管理SessionFactory
使用Spring整合Hibernate时我们不需要hibernate.cfg.xml文件。首先,在applicationContext.xml中配置数据源(dataSource)bean和session工厂(sessionFactory)bean。其中,在配置session工厂bean时,应该注入三个方面的信息:
●数据源bean
●所有持久化类的配置文件
●Hibernate的SessionFactory的属性
Hibernate的SessionFactory的属性信息又包括两个内容,一,Hibernate的连接方法;二,不同数据库连接,启动时的选择。
2.为HibernateTemplate注入SessionFactory对象,通过HibernateTemplate来持久化对象
Spring提供了HibernateTemplate,用于持久层访问,该模板无需打开Session及关闭Session。它只要获得SessionFactory的引用,将可以只能地打开Session,并在持久化访问结束后关闭Session,程序开发只需完成持久层逻辑,通用的操作(如对数据库中数据的增,删,改,查)则有HibernateTemplate完成。
HibernateTemplate有三个构造函数,不论是用哪一种构造,要使HibernateTemplate能完成持久化操作,都必须向其传入一个SessionFactory的引用。
HibernateTemplate的用法有两种,一种是常规的用法,另一种是复杂的用。
一,常规的用法
HibernateTemplate通过它自己的delete(Object entity) ,find(String queryString),save(Object entity)等等常用的方法即可完成大多数DAO对象的增,删,改,查等操作。
二,复杂的用法
HibernateTemplate的复杂的用法是通过如下的两个方法来完成的:
●Object execute(HibernateCallback action)
●List execute(HibernateCallback action)
这两个方法都需要一个HibernateCallback实例,程序开发者通过HibernateCallback,可以完全使用Hibernate灵活的方式来访问数据库,解决了Spring封装Hibernate后灵活不足的缺陷。HibernateCallback是一个接口,该接口只有一个方法doInHibernate(org.hibernate.Session session),该方法只有一个参数Session。
通常,程序中采用实现HibernateCallback的匿名内部类来获取HibernateCallback的实例,方法doInHibernate就是Spring执行的持久化操作。具体的代码实例如下:
public class PersonDaoImpl {
private SessionFactory sessionFactory;
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
public List findPersonByName(final String name) {
HibernateTemplate hibernateTemplate =
new HibernateTemplate(this.sessionFactory);
return (List)hibernateTemplate.execute(
public Object doInHibernate(Session session) throws Hibernate Exception {
List result =session.createCriteria(Person.clsss)
.add(Restrictions.like("name",name+"%")).list();
return result;
}
);
}
}
注:在方法doInHibernate内可以访问Session,该Session对象是绑定到该线程的Session实例,该方法内的持久层操作与不使用Spring时的持久层操作完全相同,这保证了对于复杂的持久层访问时,依然可以使用Hibernate的访问方式。
3.DAO的实现
DAO的实现有两种方式:一,继承HibernateDaoSupport实现DAO;二,基于Hibernate3.0实现DAO。
一,继承HibernateDaoSupport实现DAO
Spring为Hibernate的DAO提供了工具类HibernateDaoSupport。该类主要提供了如下两个方法来方便DAO的实现:
●public final HibernateTemplate getHibernateTemplate()
●public final void setSessionFactory(SessionFactory sessionFactory)
其中,setSessionFactory方法用来接收Spring的ApplicationContext依赖注入的SessionFactory实例;getHibernateTemplate方法则用来根据刚才的SessionFactory产生Session,最后由HibernateTemplate来完成数据库访问。
二,基于Hibernate3.0实现DAO
在Hibernate处于事务的管理下时(通常Spring为Hibernate提供事务管理),通过SessionFactory的getCurrentSession()方法可以返回当前的Session,如果当前的JTA事务关联的Session不存在,则系统打开一次新的Session,并关联到当前的JTA事务;如果当前JTA事务关联的Session已经存在,则直接返回该Session。获得了当前的Session后就可以进行持久化操作了。
可见,不论使用上面的哪一种方式实现DAO都需要用Spring来注入SessionFactory实例。
4.事务的管理
Hibernate建议所有的对数据库的访问都应放在事务内进行,即使进行的只是读操作。Spring同时支持编程式事务和声明式事务。通常推荐使用声明式事务。
编程式事务管理:
编程式事务提供了TransactionTemplate模板类,用的时候必须向其体提供一个PlatformTransactionManager实例。只要TransactionTemplate获取了PlatformTransactionManager的引用,TransactionTemplate就可以完成事务操作了。TransactionTemplate提供了一个execute方法,它接收一个TransactionCallback实例。TransactionCallback包含如下方法:
●Object doInTransaction(TransactionStatus status)
这是需要有返回值的情况。如果不需要有返回值的话,我们可以用TransactionCallbackWithOutResult类来代替TransactionCallback类,它也有一个方法:
●void doInTransaction(TransactionStatus status)
在这个两个方法中,在出现异常时,TransactionStatus的实例status可以调用setRollbackOnly()方法进行回滚。
一般情况下,向execute方法传入TransactionCallback或TransactionCallbackWithOutResult实例时,采用的是匿名内部类的形式。
声明式事务管理:
声明式事务管理的配置方式通常有三种:
●使用TransactionProxyFactoryBean为目标bean生成事务代理的配置。
●使用BeanNameAutoProxyCreator,根据bean name自动生成事务代理的方式,这是直接利用Spring的AOP框架配置事务代理的方式,需要对Spring的AOP框架有所了解。
●使用DefaultAdvisorAutoProxyCreator,这也是直接利用Spring的AOP框架配置事务代理的方式,只是这种配置方式的可读性不如使用BeanNameAutoProxyCreator的配置方式。
------------------------------------------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost/test</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value>8093</value>
</property>
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref local="dataSource"/>
</property>
<property name="mappingResources">
<list>
<value>user.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>
<bean id="userDAO" class="com.dang.action.UserDAOImpl">
<property name="sessionFactory">
<ref local="sessionFactory"/>
</property>
</bean>
<bean name="/regedit" class="com.dang.action.RegeditAction">
<property name="userDAO">
<ref bean="userDAO"/>
</property>
</bean>
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>
<bean id="userDAOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager">
<ref bean="transactionManager" />
</property>
<property name="target">
<ref local="userDAO" />
</property>
<property name="transactionAttributes">
<props>
<prop key="create*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
</beans>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean id="localSessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.cache.use_query_cache">true</prop>
<prop key="hibernate.connection.username">liufei</prop>
<prop key="hibernate.connection.password">liufei1229</prop>
<prop key="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:liufei</prop>
<prop key="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</prop>
<prop key="hibernate.cache.provider_class">org.hibernate.cache.HashtableCacheProvider</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
<prop key="hibernate.connection.autocommit">true</prop>
</props>
</property>
<property name="mappingResources">
<list>
<value>org/liufei/model/User.hbm.xml</value>
</list>
</property>
</bean>
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory" ref="localSessionFactory"></property>
</bean>
<bean id="hibernateTransactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="localSessionFactory" bean="localSessionFactory"/>
</property>
</bean>
<!--<bean id="transactionProxyFactory" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager">
<ref bean="hibernateTransactionManager"/>
</property>
<property name="proxyTargetClass" value="true"></property>
<property name="target">
<ref bean="dao"/>
</property>
<property name="proxyInterfaces">
<list>
<value>org.liufei.dao.UserDao</value>
</list>
</property>
<property name="transactionAttributes">
<props>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="create*">PROPAGATION_REQUIRED</prop>
<prop key="delete*">PROPAGATION_REQUIRED</prop>
<prop key="modify*">PROPAGATION_REQUIRED</prop>
<prop key="merge*">PROPAGATION_REQUIRED</prop>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="load*">PROPAGATION_REQUIRED, readOnly</prop>
<prop key="read*">PROPAGATION_REQUIRED, readOnly</prop>
<prop key="list*">PROPAGATION_REQUIRED, readOnly</prop>
</props>
</property>
</bean>
--><!-- 装配事务拦截器
<bean id="transationInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
为transationManager属性制定一个事务管理对象
<property name="transactionManager">
<ref bean="hibernateTransactionManager"/>
</property>
设定事务属性
<property name="transactionAttributes">
<props>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="create*">PROPAGATION_REQUIRED</prop>
<prop key="delete*">PROPAGATION_REQUIRED</prop>
<prop key="modify*">PROPAGATION_REQUIRED</prop>
<prop key="merge*">PROPAGATION_REQUIRED</prop>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="load*">PROPAGATION_REQUIRED, readOnly</prop>
<prop key="read*">PROPAGATION_REQUIRED, readOnly</prop>
<prop key="list*">PROPAGATION_REQUIRED, readOnly</prop>
</props>
</property>
</bean>
--><!-- 通过Bean名自动代理数据访问层对象
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
指定需要代码类的实现接口
<property name="beanNames">
<list>
<value>dao</value>
<value></value>
<value></value>
<value></value>
</list>
</property>
<property name="interceptorNames">
<list>
<value>transationInterceptor</value>
</list>
</property>
</bean>
-->
<bean id="daoSupport" class="org.liufei.dao.DaoSupport">
<constructor-arg>
<ref bean="hibernateTemplate"/>
</constructor-arg>
</bean>
<bean id="dao" class="org.liufei.dao.UserDaoImpl" parent="daoSupport">
</bean>
<bean id="service" class="org.liufei.service.UserServiceImpl">
<constructor-arg>
<ref bean="dao"/>
</constructor-arg>
</bean>
</beans>
使用Spring整合Hibernate时我们不需要hibernate.cfg.xml文件。首先,在applicationContext.xml中配置数据源(dataSource)bean和session工厂(sessionFactory)bean。其中,在配置session工厂bean时,应该注入三个方面的信息:
●数据源bean
●所有持久化类的配置文件
●Hibernate的SessionFactory的属性
Hibernate的SessionFactory的属性信息又包括两个内容,一,Hibernate的连接方法;二,不同数据库连接,启动时的选择。
2.为HibernateTemplate注入SessionFactory对象,通过HibernateTemplate来持久化对象
Spring提供了HibernateTemplate,用于持久层访问,该模板无需打开Session及关闭Session。它只要获得SessionFactory的引用,将可以只能地打开Session,并在持久化访问结束后关闭Session,程序开发只需完成持久层逻辑,通用的操作(如对数据库中数据的增,删,改,查)则有HibernateTemplate完成。
HibernateTemplate有三个构造函数,不论是用哪一种构造,要使HibernateTemplate能完成持久化操作,都必须向其传入一个SessionFactory的引用。
HibernateTemplate的用法有两种,一种是常规的用法,另一种是复杂的用。
一,常规的用法
HibernateTemplate通过它自己的delete(Object entity) ,find(String queryString),save(Object entity)等等常用的方法即可完成大多数DAO对象的增,删,改,查等操作。
二,复杂的用法
HibernateTemplate的复杂的用法是通过如下的两个方法来完成的:
●Object execute(HibernateCallback action)
●List execute(HibernateCallback action)
这两个方法都需要一个HibernateCallback实例,程序开发者通过HibernateCallback,可以完全使用Hibernate灵活的方式来访问数据库,解决了Spring封装Hibernate后灵活不足的缺陷。HibernateCallback是一个接口,该接口只有一个方法doInHibernate(org.hibernate.Session session),该方法只有一个参数Session。
通常,程序中采用实现HibernateCallback的匿名内部类来获取HibernateCallback的实例,方法doInHibernate就是Spring执行的持久化操作。具体的代码实例如下:
public class PersonDaoImpl {
private SessionFactory sessionFactory;
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
public List findPersonByName(final String name) {
HibernateTemplate hibernateTemplate =
new HibernateTemplate(this.sessionFactory);
return (List)hibernateTemplate.execute(
public Object doInHibernate(Session session) throws Hibernate Exception {
List result =session.createCriteria(Person.clsss)
.add(Restrictions.like("name",name+"%")).list();
return result;
}
);
}
}
注:在方法doInHibernate内可以访问Session,该Session对象是绑定到该线程的Session实例,该方法内的持久层操作与不使用Spring时的持久层操作完全相同,这保证了对于复杂的持久层访问时,依然可以使用Hibernate的访问方式。
3.DAO的实现
DAO的实现有两种方式:一,继承HibernateDaoSupport实现DAO;二,基于Hibernate3.0实现DAO。
一,继承HibernateDaoSupport实现DAO
Spring为Hibernate的DAO提供了工具类HibernateDaoSupport。该类主要提供了如下两个方法来方便DAO的实现:
●public final HibernateTemplate getHibernateTemplate()
●public final void setSessionFactory(SessionFactory sessionFactory)
其中,setSessionFactory方法用来接收Spring的ApplicationContext依赖注入的SessionFactory实例;getHibernateTemplate方法则用来根据刚才的SessionFactory产生Session,最后由HibernateTemplate来完成数据库访问。
二,基于Hibernate3.0实现DAO
在Hibernate处于事务的管理下时(通常Spring为Hibernate提供事务管理),通过SessionFactory的getCurrentSession()方法可以返回当前的Session,如果当前的JTA事务关联的Session不存在,则系统打开一次新的Session,并关联到当前的JTA事务;如果当前JTA事务关联的Session已经存在,则直接返回该Session。获得了当前的Session后就可以进行持久化操作了。
可见,不论使用上面的哪一种方式实现DAO都需要用Spring来注入SessionFactory实例。
4.事务的管理
Hibernate建议所有的对数据库的访问都应放在事务内进行,即使进行的只是读操作。Spring同时支持编程式事务和声明式事务。通常推荐使用声明式事务。
编程式事务管理:
编程式事务提供了TransactionTemplate模板类,用的时候必须向其体提供一个PlatformTransactionManager实例。只要TransactionTemplate获取了PlatformTransactionManager的引用,TransactionTemplate就可以完成事务操作了。TransactionTemplate提供了一个execute方法,它接收一个TransactionCallback实例。TransactionCallback包含如下方法:
●Object doInTransaction(TransactionStatus status)
这是需要有返回值的情况。如果不需要有返回值的话,我们可以用TransactionCallbackWithOutResult类来代替TransactionCallback类,它也有一个方法:
●void doInTransaction(TransactionStatus status)
在这个两个方法中,在出现异常时,TransactionStatus的实例status可以调用setRollbackOnly()方法进行回滚。
一般情况下,向execute方法传入TransactionCallback或TransactionCallbackWithOutResult实例时,采用的是匿名内部类的形式。
声明式事务管理:
声明式事务管理的配置方式通常有三种:
●使用TransactionProxyFactoryBean为目标bean生成事务代理的配置。
●使用BeanNameAutoProxyCreator,根据bean name自动生成事务代理的方式,这是直接利用Spring的AOP框架配置事务代理的方式,需要对Spring的AOP框架有所了解。
●使用DefaultAdvisorAutoProxyCreator,这也是直接利用Spring的AOP框架配置事务代理的方式,只是这种配置方式的可读性不如使用BeanNameAutoProxyCreator的配置方式。
------------------------------------------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost/test</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value>8093</value>
</property>
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref local="dataSource"/>
</property>
<property name="mappingResources">
<list>
<value>user.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>
<bean id="userDAO" class="com.dang.action.UserDAOImpl">
<property name="sessionFactory">
<ref local="sessionFactory"/>
</property>
</bean>
<bean name="/regedit" class="com.dang.action.RegeditAction">
<property name="userDAO">
<ref bean="userDAO"/>
</property>
</bean>
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>
<bean id="userDAOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager">
<ref bean="transactionManager" />
</property>
<property name="target">
<ref local="userDAO" />
</property>
<property name="transactionAttributes">
<props>
<prop key="create*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
</beans>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean id="localSessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.cache.use_query_cache">true</prop>
<prop key="hibernate.connection.username">liufei</prop>
<prop key="hibernate.connection.password">liufei1229</prop>
<prop key="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:liufei</prop>
<prop key="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</prop>
<prop key="hibernate.cache.provider_class">org.hibernate.cache.HashtableCacheProvider</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
<prop key="hibernate.connection.autocommit">true</prop>
</props>
</property>
<property name="mappingResources">
<list>
<value>org/liufei/model/User.hbm.xml</value>
</list>
</property>
</bean>
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory" ref="localSessionFactory"></property>
</bean>
<bean id="hibernateTransactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="localSessionFactory" bean="localSessionFactory"/>
</property>
</bean>
<!--<bean id="transactionProxyFactory" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager">
<ref bean="hibernateTransactionManager"/>
</property>
<property name="proxyTargetClass" value="true"></property>
<property name="target">
<ref bean="dao"/>
</property>
<property name="proxyInterfaces">
<list>
<value>org.liufei.dao.UserDao</value>
</list>
</property>
<property name="transactionAttributes">
<props>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="create*">PROPAGATION_REQUIRED</prop>
<prop key="delete*">PROPAGATION_REQUIRED</prop>
<prop key="modify*">PROPAGATION_REQUIRED</prop>
<prop key="merge*">PROPAGATION_REQUIRED</prop>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="load*">PROPAGATION_REQUIRED, readOnly</prop>
<prop key="read*">PROPAGATION_REQUIRED, readOnly</prop>
<prop key="list*">PROPAGATION_REQUIRED, readOnly</prop>
</props>
</property>
</bean>
--><!-- 装配事务拦截器
<bean id="transationInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
为transationManager属性制定一个事务管理对象
<property name="transactionManager">
<ref bean="hibernateTransactionManager"/>
</property>
设定事务属性
<property name="transactionAttributes">
<props>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="create*">PROPAGATION_REQUIRED</prop>
<prop key="delete*">PROPAGATION_REQUIRED</prop>
<prop key="modify*">PROPAGATION_REQUIRED</prop>
<prop key="merge*">PROPAGATION_REQUIRED</prop>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="load*">PROPAGATION_REQUIRED, readOnly</prop>
<prop key="read*">PROPAGATION_REQUIRED, readOnly</prop>
<prop key="list*">PROPAGATION_REQUIRED, readOnly</prop>
</props>
</property>
</bean>
--><!-- 通过Bean名自动代理数据访问层对象
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
指定需要代码类的实现接口
<property name="beanNames">
<list>
<value>dao</value>
<value></value>
<value></value>
<value></value>
</list>
</property>
<property name="interceptorNames">
<list>
<value>transationInterceptor</value>
</list>
</property>
</bean>
-->
<bean id="daoSupport" class="org.liufei.dao.DaoSupport">
<constructor-arg>
<ref bean="hibernateTemplate"/>
</constructor-arg>
</bean>
<bean id="dao" class="org.liufei.dao.UserDaoImpl" parent="daoSupport">
</bean>
<bean id="service" class="org.liufei.service.UserServiceImpl">
<constructor-arg>
<ref bean="dao"/>
</constructor-arg>
</bean>
</beans>
发表评论
-
Hibernate与iBATIS的较量浅析
2010-11-21 22:18 1233hibernate与ibatis的比较,首先我们从他们的简介开 ... -
Spring中的四种声明式事务的配置
2010-11-03 20:57 1083Spring中的四种声明式事 ... -
在spring中同时使用jdbcTemplate和hibernateTemplate
2010-11-01 11:34 2890就像我们知道的一样,Hib ... -
用过滤器管理hibernate的session及Transaction事务
2010-06-06 19:16 1886过滤器: package org.liufei.filters ... -
一个struts+hibernate分页实例
2010-05-30 12:02 2648前一段时间在做一个作业,用到分页,再网上看里许多例子,发现都很 ...
相关推荐
在Spring框架中,`HibernateTemplate`是一个非常重要的组件,它为开发者提供了与Hibernate持久化库交互的便捷方式。然而,正如描述中所指出的,直接使用`HibernateTemplate`进行事务管理并不总是最佳实践,尤其是在...
1. **Spring Framework**:这是Spring的核心组件,包括`spring-context`、`spring-beans`、`spring-aop`、`spring-jdbc`和`spring-orm`等模块。其中,`spring-orm`模块专门用于支持ORM框架,包括Hibernate。 2. **...
《Spring与Hibernate整合:深入理解HibernateTemplate》 在Java企业级开发中,Spring框架和Hibernate持久层框架的结合使用是常见的技术选型。本篇将深入探讨Spring与Hibernate的集成,特别是Spring提供的...
标题中的"Spring_2000_Spring_Hibernate_HibernateTemplate"显然指的是一个关于Spring框架、Hibernate ORM框架以及其在2000年左右的版本或应用方式的专题。在这个主题下,我们将深入探讨Spring框架的核心特性,以及...
本示例将深入探讨如何使用Spring将SessionFactory注入到HibernateTemplate中,从而实现数据库操作的便捷管理。 首先,让我们了解几个关键组件: 1. SessionFactory:这是Hibernate的核心工厂类,用于创建Session...
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate"> ``` 四、使用HibernateTemplate 1. 依赖注入 在需要操作数据库的Service层,通过@Autowired注解注入...
在Spring框架中,`HibernateTemplate`作为ORM(Object Relational Mapping)技术中的一个重要组件,它提供了简化Hibernate操作的方法集,使得开发人员能够更加便捷地进行数据库操作。通过使用`HibernateTemplate`,...
HibernateTemplate是Spring框架提供的一种操作Hibernate的方式,它简化了Hibernate的使用过程,使开发者无需关注Session的管理与事务控制,极大地提高了开发效率。本文将对HibernateTemplate的主要用法进行详细介绍...
HibernateTemplate 是 Spring 框架中的一個关键组件,用于简化 Hibernate 的使用,提供了許多实用的方法来进行数据库操作。在本文中,我们将对 HibernateTemplate 的主要方法进行总结和解释。 ...
`HibernateTemplate`是Spring框架中用于操作Hibernate的一个便捷工具类,它极大地简化了Hibernate在实际应用中的集成与开发工作。通过`HibernateTemplate`,开发者可以非常方便地进行数据的增删改查等基本操作,而...
其中,`HibernateTemplate`作为Spring框架中的一个重要组件,为开发者提供了丰富的API来处理数据库操作,使得开发人员能够更加专注于业务逻辑的编写,而不是繁琐的数据访问细节。 #### 二、HibernateTemplate简介 ...
《轻量级 J2EE 企业应用实战: Struts+Spring+Hibernate 整合开发》一书中详述了Spring与Hibernate的整合,其中一个重要组件就是HibernateTemplate。它为简化Hibernate在Spring框架中的使用提供了便利,减少了手动...
Spring 可以通过工厂方法或 JdbcTemplate、HibernateTemplate 提供的模板方法来获取 Session。 6. **Service 层设计**:Service 层是业务逻辑的核心,通常会注入 DAO 实例并调用其方法来完成业务处理。Service 层...
而`HibernateTemplate`作为Spring框架对Hibernate的一种封装,更是进一步降低了开发难度,提高了开发效率。 #### 二、核心价值:专注业务逻辑 `HibernateTemplate`的主要价值在于让开发者能够将更多的精力聚焦于...
`HibernateTemplate`是Spring框架中的一个类,位于`org.springframework.orm.hibernate3`包下。它提供了一系列简化Hibernate数据访问操作的方法,并且能够自动将Hibernate异常转换为Spring的数据访问异常体系中的...
1. **HibernateTemplate**:是Spring框架提供的用于简化Hibernate使用的模板类。它提供了大量操作数据库的方法,包括查询、更新等,并且内置了事务管理机制。 2. **分组统计**:指通过SQL语句对查询结果按照一个或多...
3. **配置HibernateTemplate**: Spring通过`HibernateTemplate`提供了一种简化数据访问的方法。它封装了常见的Hibernate操作,如保存、更新、删除和查询。在Spring配置文件中,我们可以定义一个`HibernateTemplate`...
以Spring与Hibernate集成为例,创建一个简单的User实体,配置SessionFactory,并通过Spring的HibernateTemplate进行CRUD操作。通过这种方式,我们可以实现业务逻辑与持久化操作的解耦,提高代码的可维护性和复用性。...
4. **Spring与Hibernate的集成**: Spring通过HibernateTemplate和HibernateDaoSupport简化了Hibernate的使用。`spring集成hibernate配置文件.txt`可能包含了整合步骤、事务配置以及如何处理SessionFactory和Session...
- 利用Spring的数据访问抽象层,如JdbcTemplate、HibernateTemplate等,方便数据库操作。 - 集成其他框架,如MyBatis、Quartz等,构建更复杂的应用系统。 Spring框架的jar包通常包括以下核心组件: - `spring-core...