在Hibernate的事务配置
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"元素来指定实体类的映射文件。
spring4.x + hibernate4.x 配置详解
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:指定当前方法必需在事务环境中运行,如果当前有事务环境就加入当前正在执行的事务环境,如果当前没有事务,就新建一个事务。
Spring考试试卷(有答案)
Spring考试试卷(题库)1.下列关于AOP的说法错误的是()。
A.AOP将散落在系统中的“方面”代码集中实现B.AOP有助于提高系统的可维护性C.AOP已经表现出了将要替代面向对象的趋势D.AOP是一种设计模式,Spring为其提供了一种实现2.在SSH整合时,事务隔离级别是由()实现的。
A.Java应用程序 B.Hibernate C.数据库系统 D.JDBC驱动程序3.下列()不是Spring的依赖注入方式。
【选两项】A.setter注入B.getter注入 C.接口注入 D.构造注入4.在Spring框架中,面向方面编程(AOP)的目标在于()。
A.编写程序时不用关心其依赖组件的实现B.将程序中涉及的公用问题集中解决C.封装JDBC访训数据库的代码,简化数据访训层的得复性代码D.实现画面的“无刷新”5.关于Spring 与 Hibernate集成,下列说法错误的是()。
A.Spring提供了HibernateDaoSupport类来简化Hibernate的使用B.在Spring配置文件中,可以通过Spring提供的LocalSessionFactoryBean来获得SessionFactory的实例C.通过集成Spring和Hibernate,用Spring管理程序的依赖关系,将SessionFactory 注入到DataSource中D.通过Spring,可以在Biz层代码中无需直接实例化DAO类,而是通过注入得到6.在Spring中,下列关于依赖注入的说法,正确的是()。
A.依赖注入的目标是在代码之外管理程序组建间的依赖关系(组件?组建?)B.依赖注入即“面向接口”的编程C.依赖注入是面向对象技术的替代品D.依赖注入的使用会增大程序的规模7.下列关于Spring的说法错误的是()。
A.Spring是一个轻量级JAVA EE的框架集合 B.Spring是“依赖注入”模式的实现 C.使用Spring可以实现声明事务 D.Spring提供了AOP方式的日志系统8.在Spring 中,配置Hibernate 事务管理器(Hibernate TransactionManager)时,需要注入的属性名称是()。
hibernate配置
目录
1 Hibernate概述 2 第一个Hibernate程序 3 Hibernate的配置文件 4 深入理解持久化对象 5 Hibernate的映射文件 6持久化对象 如果PO 实例与Session实例关联起来,且该实例关联到数据库的记录
脱管对象 如果PO实例曾经与Session实例关联过,但是因为Session的关闭等原 因,PO实例脱离了Session 的管理
Hibernate全面解决方案架构解释
事务(Transaction) 代表一次原子操作,它具有数据库事务的概念 但它通过抽象,将应用程序从底层的具体的JDBC、JTA和CORBA 事务中隔离开。 一个Session 之内可能包含多个Transaction对象。 所有的持久化操作都应该在事务管理下进行,即使是只读操作。
管态,对该对象操作无须锁定数据库,不会造成性能的下降。
持久化对象的状态迁移
持久化实体: 1、Serializable save(object obj) 将对象变为持久化状态 2、void persist(object obj) 将对象转化为持久化状态 3、Serializable save(object obj,object pk) 将obj对象转化为持久化状态,该对象保存到数据库,指定主键值 4、void persist(object obj,object pk) 也加了一个设定主键
Hibernate工作原理
Configuration cfg = new Configuration().configure();
开始
启动hibernate
构建Configuration 实例,初始 化该实例中的所有变量
hibernet的原理
hibernet的原理Hibernate的原理简介Hibernate是一个开源的对象关系映射(ORM)框架,用于将Java应用程序中的对象与关系型数据库之间进行映射。
它可以大大简化数据库操作,并提供了高度的灵活性和可维护性。
ORM的基本概念•对象关系映射(ORM):将关系数据库中的表和对象之间的映射关系定义在一个配置文件中,使得Java中的对象可以直接操作数据库,无需编写复杂的SQL查询语句。
•持久化:将对象保存在数据库中,以便随时从数据库中获取对象。
•对象关系映射文件(ORM文件):包含了实体类和数据库表之间的映射关系。
•实体类:表示Java应用程序中的一个实体,通常与数据库表中的一行数据对应。
Hibernate的工作原理1.配置文件–创建``配置文件,包含了数据库连接信息、实体类与数据库表之间的映射关系等。
2.实体类–创建实体类,为类添加注解或使用XML文件,用于定义实体类与数据库表之间的映射关系。
3.SessionFactory–在应用程序启动时,使用配置文件和实体类来创建SessionFactory对象。
SessionFactory是线程安全的,通常一个应用只需要一个SessionFactory实例。
4.Session–在应用程序运行过程中,通过()方法创建Session对象。
–Session代表了与数据库的一次会话,可用于执行数据库操作,如增删改查等。
–Session具有缓存机制,它会缓存从数据库检索到的实体对象,以提高性能。
5.事务管理–Hibernate使用事务来管理数据库操作,保证数据的一致性。
–开启事务:();–提交事务:();–回滚事务:();6.对象操作–使用Session对象操作数据库,如保存对象、更新对象、删除对象等。
–查询操作:使用HQL(Hibernate Query Language)或Criteria API进行查询,它们提供了更高级的查询功能。
7.数据库操作–Hibernate会根据实体类和数据库表之间的映射关系,自动生成对应的SQL语句并执行。
Hibernate常见面试题汇总
一. H ibern ate工作使用步骤?1.读取并解析配置文件2. 读取并解析映射信息,创建Ses sionF actor y3.打开Sess sion4. 创建事务Tran satio n5.持久化操作6. 提交事务7.关闭Sess ion 8. 关闭Se sstio nFact ory 二.Hib ernat e的查询方式有几种?(1)导航对象图检索方式。
根据已经加载的对象,导航到其他对象。
(2)OID查询方式。
根据对象的O ID来查询对象。
Se ssion的get()和loa d()方法。
(3)HQL查询方式。
HQ L是面向对象的查询语言,ses sion的find()方法用于执行HQL查询语句。
可以利用Q uery接口。
Q ueryquery = se ssion.crea teQue ry(“f rom C ustom er as c wh ere c.name=: c ustom erNam e”);quer y.set Strin g(“cu stome rName”,”张三”);Listresul tList = qu ery.l ist();(4)QBC查询方式。
这种API封装了基于字符串形式的查询语句。
Crit eriacrite ria = sess ion.c reate Crite ria(U ser.c lass);Cr iteri on cr iteri on1 = Expe ssion.like(“nam e”,”T%”);Crite rioncrite rion2 = Ex pessi on.eq(age,new I ntege r(30));cr iteri a =crite ria.a dd(cr iteri on1);crit eria = cr iteri a.add(crit erion2);L ist r esult List= cri teria.list();这种查询方式使用的较少,主要是在查询中需要用户输入一系列的查询条件,如果采用HQL查询代码会比较烦。
Spring+Hibernate+Atomikos配置JTA事务
Spring+Hibernate+Atomikos配置JTA事务例子1.依赖jar包2.配置文件(1)数据源、JTA事务配置文件src/applicationContext-common.xml<?xml version="1.0" encoding="GBK"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:tx="/schema/tx"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd /schema/tx/schema/tx/spring-tx-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><!--chh用户datasource --><bean id="oracleDataSource"class="com.atomikos.jdbc.AtomikosDataSourceBean"><property name="uniqueResourceName"><value>chh</value></property><propertyname="xaDataSourceClassName"><value>oracle.jdbc.xa.client.OracleXADat aSource</value></property><property name="xaProperties"><props><prop key="user">chh</prop><prop key="password">chh</prop><prop key="URL">jdbc:oracle:thin:@127.0.0.1:1521:chh</prop></props></property><property name="poolSize"><value>1</value></property><property name="borrowConnectionTimeout"><value>60</value></property> </bean><!--chh1用户datasource --><bean id="oracleDataSource1"class="com.atomikos.jdbc.AtomikosDataSourceBean"><property name="uniqueResourceName"><value>chh1</value></property><propertyname="xaDataSourceClassName"><value>oracle.jdbc.xa.client.OracleXADat aSource</value></property><property name="xaProperties"><props><prop key="user">chh1</prop><prop key="password">chh1</prop><prop key="URL">jdbc:oracle:thin:@127.0.0.1:1521:chh</prop></props></property><property name="poolSize"><value>1</value></property><property name="borrowConnectionTimeout"><value>60</value></property> </bean><!--为hibernate-jtatest1.cfg.xml注入chh用户datasource--><bean id="chhSessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"><property name="configLocation"value="classpath:hibernate-jtatest1.cfg.xml" /><property name="dataSource" ref="oracleDataSource"></property></bean><!--为hibernate-jtatest2.cfg.xml注入chh1用户datasource--><bean id="chh1SessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation"value="classpath:hibernate-jtatest2.cfg.xml" /><property name="dataSource" ref="oracleDataSource1"></property></bean><!-- atomikos事务管理器 --><bean id="atomikosTransactionManager"class="erTransactionManager"init-method="init" destroy-method="close"><property name="forceShutdown"><value>true</value></property></bean><!-- atomikos事务的实现 --><bean id="atomikosUserTransaction"class="erTransactionImp"><property name="transactionTimeout"><value>300</value></property> </bean><!-- atomiko事务管理器封装成Spring事务管理器--><bean id="springTransactionManager"class="org.springframework.transaction.jta.JtaTransactionManager"><property name="transactionManager"><refbean="atomikosTransactionManager" /></property><property name="userTransaction"><ref bean="atomikosUserTransaction" /></property><property name="allowCustomIsolationLevels" value="true"/></bean><!-- 通知配置 --><tx:advice id="txAdvice"transaction-manager="springTransactionManager"><tx:attributes><tx:method name="delete*" rollback-for="Exception"/><tx:method name="save*" rollback-for="Exception"/><tx:method name="update*" rollback-for="Exception"/><tx:method name="*" read-only="true" rollback-for="Exception"/></tx:attributes></tx:advice><!-- 事务切面配置 --><aop:config><aop:pointcut id="point"expression=" execution(* com.zte.jta.serviceImp.*.*(..))" /><!-- 指定使用jta事务的类、方法 --><aop:advisor advice-ref="txAdvice" pointcut-ref="point" /></aop:config></beans>(2) 业务配置文件src/applicationContext-service.xml<?xml version="1.0" encoding="GBK"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:tx="/schema/tx"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd /schema/tx/schema/tx/spring-tx-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="biz" class="impl"><property name="productDao" ref="productDao" /><property name="userDao" ref="userDao" /></bean><bean id="userDao" class="erDaoimpl"><property name="sessionFactory" ref="chhSessionFactory" /></bean><bean id="productDao" class="com.zte.jta.daoImp.ProductDaoimpl"><property name="sessionFactory" ref="chh1SessionFactory" /></bean></beans>(3)数据源1 hibernate 配置文件src/hibernate-jtatest1.cfg.xml<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><propertyname="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop erty><property name="show_sql">true</property><mapping resource="com/zte/jta/test/Users.hbm.xml" /></session-factory></hibernate-configuration>(3) 数据源2 hibernate 配置文件src/hibernate-jtatest2.cfg.xml<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><propertyname="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop erty><property name="show_sql">true</property><mapping resource="com/zte/jta/test/Product.hbm.xml" /></session-factory></hibernate-configuration>(4)对象映射关系数据配置文件src/com/zte/jta/test/Product.hbm.xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping><class name="com.zte.jta.test.Product" table="product" ><id name="id" type="ng.Integer"><column name="id" /><generator class="sequence" ><param name="sequence">SEQ_product</param></generator></id><property name="price" type="ng.Float"><column name="price" precision="53" scale="0" not-null="true" /></property></class></hibernate-mapping>(5)对象映射关系数据配置文件src/com/zte/jta/testUsers.hbm.xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping><class name="ers" table="tusers" ><id name="id" type="ng.Integer"><column name="id" /><generator class="sequence" ><param name="sequence">SEQ_tusers</param></generator></id><property name="name" type="ng.String"><column name="name" length="100" not-null="true" /> </property></class></hibernate-mapping>3.Java代码(1)src/com/zte/jta/dao/ProductDao.javapackage com.zte.jta.dao;import com.zte.jta.test.Product;public interface ProductDao {public abstract void save(Product p);}(2)src/com/zte/jta/dao/UserDao.javapackage com.zte.jta.dao;import ers;public interface UserDao {public abstract void save(Users u);}(3)src/com/zte/jta/daoImp/ProductDaoimpl.javapackage com.zte.jta.daoImp;importorg.springframework.orm.hibernate3.support.HibernateDaoSupport;import com.zte.jta.dao.ProductDao;import com.zte.jta.test.Product;public class ProductDaoimpl extends HibernateDaoSupport implements ProductDao {public void save(Product p){this.getHibernateTemplate().save(p);}}(4)src/com/zte/jta/daoImp/UserDaoimpl.javapackage com.zte.jta.daoImp;importorg.springframework.orm.hibernate3.support.HibernateDaoSupport;import erDao;import ers;public class UserDaoimpl extends HibernateDaoSupport implements UserDao {public void save(Users u){this.getHibernateTemplate().save(u);}}(5)src/com/zte/jta/service/Biz.javapackage com.zte.jta.service;import com.zte.jta.test.Product;import ers;public interface Biz {public void save(Product p, Users u);}(6)src/com/zte/jta/serviceImp/Bizimpl.javapackage com.zte.jta.serviceImp;import com.zte.jta.dao.ProductDao;import erDao;import ;import com.zte.jta.test.Product;import ers;public class Bizimpl implements Biz {private ProductDao productDao = null;private UserDao userDao = null;public void save(Product p, Users u) {productDao.save(p);userDao.save(u);}public void setProductDao(ProductDao productDao) {this.productDao = productDao;}public void setUserDao(UserDao userDao) {erDao = userDao;}}4.数据库建对象create user chh identified by chh;create user chh identified by chh1;grant dba,resource,connect to chh;grant dba,resource,connect to chh1;grant select on sys.dba_pending_transactions to chh;grant select on sys.pending_trans$to chh;grant select on sys.dba_2pc_pending to chh;grant execute on sys.dbms_system to chh;grant select on sys.dba_pending_transactions to chh1; grant select on sys.pending_trans$to chh1;grant select on sys.dba_2pc_pending to chh1;grant execute on sys.dbms_system to chh1;create sequence chh.SEQ_tusersminvalue 1maxvalue 10000000000000000start with 1increment by 1cache 20order;create sequence chh1.SEQ_productminvalue 1maxvalue 10000000000000000start with 1increment by 1cache 20order;create table chh.TUSERS(ID INTEGER not null,NAME VARCHAR2(50)not null)tablespace MAPpctfree 10initrans 1maxtrans 255storage(initial 128Knext 128Kminextents 1maxextents unlimitedpctincrease 0);alter table TUSERSadd primary key(ID)using indextablespace MAPpctfree 10initrans 2maxtrans 255storage(initial 128Knext 128Kminextents 1maxextents unlimitedpctincrease 0);create table CHH1.PRODUCT (ID INTEGER not null, PRICE NUMBER not null)tablespace MAPpctfree 10initrans 1maxtrans 255storage(initial 128Knext 128Kminextents 1maxextents unlimitedpctincrease 0);alter table CHH1.PRODUCT add primary key(ID) using indextablespace MAPpctfree 10initrans 2maxtrans 255storage(initial 128Knext 128Kminextents 1maxextents unlimitedpctincrease 0);5.测试方法public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext-common.xml","applicationContext-service.xml"});BeanFactory bf = context;Biz biz = (Biz) bf.getBean("biz");Product p = new Product();p.setPrice(10f);Users u = new Users();u.setName(null); //非空字段插入一个空试试,再给个值试试 "aaa"biz.save(p, u);}。
Hibernate中的事务处理
妻≯ ≯i 0 : . _ . 繇 一誊 ≮ _ 一 _ . 茎 _ .
薯簿 辫搿 蒜穗憩 j
蓉翥 遣辫
H e n i r at 中的事务处 理 b e
一 一 ^ +● ~ 一 — _ _ _ 一 … 一 一 — — … 一
一
致 . 久 和一 定 程度 上 的 隔离 — — 之 所 以说 ” 定 程 度 ” 因 持 一 .
为由于高度 隔离会限制可并行执行 的事务数 , 以一些 应用程 所 序 降低 隔离级别 以换取更大 的吞吐量 。 而我们后面的故事也正
是从这里展开 。
在理想情况 下 , 事务之间应该彼 此隔离 . 一个事务查看数 按照定义 ._次数据库事务应该具 有 A I CD属性 1 ,即 :
场景。但由于牵涉到钱 财出入 , 作为开发 者的我们不得不倍加
事务在完成时 . 必须使所有 的数据都保持一致状态。在相
关数据库 中. 所有规则都必须应用于事务 的修改 ,以保持所有 数据 的完整性 。事 务结 束时 , 有的内部 数据结构 ( B 索 所 如 树
引或 双 向链 表 )都 必 须 是 正 确 的 。 ・ 隔 离 性 【 oai ) Il o s tn
操作子集的可能性。
・ 一 致 性 (o s t c ) C nie y sn
人购买了这件货物 。于是 .前一个人 ( 家)的钱包 卖
里 多了 1 0元钱 ,后 一 个 人 ( 家 ) 的钱 包 里 少 了 1 元 钱 :货 买 0
物 则从卖家 的仓库转移到 了买家的仓库。
在 一 个 网上 交 易 系 统 中 , 是 一 个 最 典 型 也 最 为人 熟 知 的 这
一
控制两条线程——如果算上主控线程的话 . 是三 条线程—— 就
Hibernaet的作用
第一:数据库连接不需要我们自己来管理,如打开和关闭(优点吧)第二:Hibernate对原来的SQL语句进行了封装,以前写很多SQL语句,现在你在保存的时候直接可以用SA VE(对象)来实现了。
(节省代码吧)第三:原来是对表操作,现在是对对象操作,想法上是不是更好呢?都是对象。
Hibernate优点(1) 对象/关系数据库映射(ORM)它使用时只需要操纵对象,使开发更对象化,抛弃了数据库中心的思想,完全的面向对象思想(2) 透明持久化(persistent)带有持久化状态的、具有业务功能的单线程对象,此对象生存期很短。
这些对象可能是普通的JavaBeans/POJO,这个对象没有实现第三方框架或者接口,唯一特殊的是他们正与(仅仅一个)Session相关联。
一旦这个Session被关闭,这些对象就会脱离持久化状态,这样就可被应用程序的任何层自由使用。
(例如,用作跟表示层打交道的数据传输对象。
)(3) 事务Transaction(org.hibernate.Transaction)应用程序用来指定原子操作单元范围的对象,它是单线程的,生命周期很短。
它通过抽象将应用从底层具体的JDBC、JTA以及CORBA事务隔离开。
某些情况下,一个Session之内可能包含多个Transaction对象。
尽管是否使用该对象是可选的,但无论是使用底层的API 还是使用Transaction对象,事务边界的开启与关闭是必不可少的。
(4) 它没有侵入性,即所谓的轻量级框架(5) 移植性会很好(6) 缓存机制,提供一级缓存和二级缓存(7) 简洁的HQL编程2. Hibernate缺点(1) Hibernate在批量数据处理时有弱势(2) 针对单一对象简单的增删查改,适合于Hibernate,而对于批量的修改,删除,不适合用Hibernate,这也是OR框架的弱点;要使用数据库的特定优化机制的时候,不适合用Hibernate1.strutsstruts框架具有组件的模块化,灵活性和重用性的优点,同时简化了基于MVC的web应用程序的开发。
SpringMVC相关试题
SpringMVC相关试题1.下列相关Spring⾃动装配的说法中,错误的是()。
(选择⼀项)A:在Spring配置⽂件中,可以通过<bean>元素的autowire属性指定⾃动装配⽅式B: autowire属性值可以设置为none、byType、byNameC: autowire的属性值之⼀byType表⽰根据属性类型⾃动装配D:通过<beans>元素的default-autowire属性,可以设置全局的⾃动装配⽅式答案:B2.Spr ing中Bean的作⽤域不包括( )。
(选择- -项)A: singletonB: prototypeC: sessionD: application答案:D3.以下关于spr ing核⼼说法不正确的是()(选择⼀项)A: spr ing核⼼包括DIB: spring核⼼包括AOPc: spr ing核⼼包括IOCD: spr ing核⼼包括00P答案:D4.在Spring应⽤中,由于项⽬规模变⼤,Spring配置⽂件的规模也会相应增长,这就造成配置⽂件的可读性和可维护性变差,此事就需要对其进⾏拆分,(选择⼀项)A: Spr ing配置⽂件的拆分可以在web. xm1中实现<context- -par am><par am- name> contex tConf igL ocation</par am- name><par am-value>classpath: applicationContext. xm1,cl as spath: applicationContext- dao. xml,...略</par am - value></context-par am>B: Spr ing配置⽂件的拆分可以在web. xm1中实现<context- -par am><par am- name> contex tConf igLocation</par am- name><par am-value>classpath: apnlig滚动⿏标轴或单击,开始截长图c1 asspath: applicationContext-*. xml</par am-value></context- par am> c: Spring配置⽂件本⾝也可以通过import⼦元素导⼊其他配置⽂件<import resource= ”applicati onContext- dao. xml”/><import resource= ”applicati onContext- service. xml" />.....略D: Spring配置⽂件本⾝也可以通过import⼦元素导⼊其他配置⽂件<import param= ”applicationContext -dao. xml”/><import par am=" applicationContext- service. xml”/>.略答案是D5.在做Spr ing框架和MyBatis框架整合时,关于mapperLocations属性描述错误的是( )。
hibernate配置文件说明
create:每次加载hibernate时都会删除上一次的生成的表,然后根据你的model类再重新来生成新表,哪怕两次没有任何改变也要这样执行。会导致数据库表数据丢失。
create-drop: 每次加载hibernate时根据model类生成表,但是sessionFactory一关闭,表就自动删除。
(2)hibernate.show_sql打印所有的SQL语句到控制台,可以通过设置org.hibernate.SQL类的日志策略到DEBUG级,实现同样的效果。取值 true|false。
(3)hibernate.format_sql 格式化SQL语句在打印到控制台或写入日志文件时。取值true|false。
hibernate.cache.provider_class=org.hibernate.cache.SingletonEhCacheProvider
hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider
# 二级缓存配置文件
#Batch Size越大,批量操作的向数据库发送sql的次数越少,速度就越快。
hibernate.jdbc.batch_size=50
#设置外连接抓取树的最大深度取值. 建议设置为0到3之间
#hibernate.max_fetch_depth
#是否显示最终执行的SQL(开发环境)
hibernate.show_sql=false
# 格式化显示的SQL
hibernate.format_sql=false
# 如果设置为true,Hiberante将为SQL产生注释,这样更利于调试。默认值为false。取值为true|false。
hibernate begintransaction默认事务级别
Hibernate beginTransaction默认事务级别一、概述在使用Hibernate进行数据库操作时,事务管理是非常重要的一部分。
Hibernate提供了一个beginTransaction()方法来开始一个事务。
本文将详细讨论Hibernate beginTransaction()方法的默认事务级别及其相关内容。
二、事务级别概述事务级别是指数据库管理系统提供的处理事务的隔离程度。
不同的数据库管理系统可能支持不同的事务级别,如Read Uncommitted、Read Committed、Repeatable Read和Serializable等。
Hibernate作为一个ORM框架,封装了对数据库的访问,提供了一致的事务管理接口。
三、Hibernate事务管理Hibernate通过Session对象进行数据库操作,而Session对象是与数据库的物理连接相关联的。
在进行数据库操作之前,我们需要通过SessionFactory创建一个Session对象。
在这个Session对象中,我们可以使用beginTransaction()方法来开始一个事务。
3.1 beginTransaction()方法beginTransaction()方法是Session对象提供的一个用于开始事务的方法。
它会返回一个Transaction对象,我们可以通过这个对象来提交、回滚或者关闭事务。
3.2 默认事务级别Hibernate的beginTransaction()方法默认使用的是数据库管理系统的默认事务级别。
不同的数据库管理系统可能有不同的默认事务级别,但通常情况下,Hibernate会选择一个合适的默认事务级别来保证数据的一致性和隔离性。
四、Hibernate事务级别详解Hibernate支持通过Transaction对象来设置事务级别。
在开始事务之后,我们可以使用Transaction对象的setIsolation()方法来设置事务的隔离级别。
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进行开发。
Hibernate连接池的三种配置方式
Hibernate 连接池的三种配置方式:dbcp , c3p0 , proxoolURL的多种指定方式连接池监控在hibernate3.0中,已经不再支持dbcp了,hibernate的作者在中,明确指出在实践中发现dbcp有BUG,在某些种情会产生很多空连接不能释放,所以抛弃了对dbcp的支持。
1 =================== C3P0 配置=============================Xml代码<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><!-- 配置事务实现方式--><property name="transaction.factory_class">org.hibernate.transaction.JDBCTransactionFactory</property><!-- 配置JDBC里batch的大小--><property name="jdbc.batch_size">50</property><property name="e_second_level_cache">false</property><!-- 配置线程安全的session --><property name="current_session_context_class">thread</property><!-- 显示SQL --><property name="show_sql">true</property><property name="format_sql">true</property><!-- 配置数据库方言--><property name="dialect">org.hibernate.dialect.Oracle9Dialect</property><!-- 配置数据库连接--><property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property><property name="ername">0804</property><property name="connection.password">0804</property><property name="connection.url">jdbc:oracle:thin:@192.168.0.200:1521:orcl</property><!-- 配置连接池--><property name="c3p0.max_size">2</property><property name="c3p0.min_size">2</property><property name="c3p0.timeout">5000</property><property name="c3p0.max_statements">100</property><property name="c3p0.idle_test_period">3000</property><property name="c3p0.acquire_increment">2</property><property name="c3p0.validate">false</property><!-- 指定hibernate管理的映射文件--><mapping resource="com/ket/ruan/so/entity/User.hbm.xml"/><mapping resource="com/ket/ruan/so/entity/Product.hbm.xml"/>。
全局事务与本地事务的区别
全局事务:资源管理器管理和协调的事务,可以跨越多个数据库和进程。
资源管理器一般使用XA 二阶段提交协议与“企业信息系统”(EIS) 或数据库进行交互。
本地事务:在单个EIS 或数据库的本地并且限制在单个进程内的事务。
本地事务不涉及多个数据来源。
在Hibernate配置文件中有这么两种配置方式:1.如果使用的是本地事务(jdbc事务)<property name="hibernate.current_session_context_class">thread</property>,这个是我们常用的选项,只针对一个数据库进行操作,也就是说只针对一个事务性资源进行操作.2. 如果使用的是全局事务(jta事务)<property name="hibernate.current_session_context_class">jta</property>以前我们学习的事务类型都属于本地事务。
JTA(全局事务)和thread(本地事务)有什么区别呢?在某些应用场合,只能使用全局事务,比如:有两个数据库:1.mysql2.oracle 现在有个业务需求--转账step 1> update mysql_table set amount=amount-xx where id=aaa 发生扣钱,假设是在mysql数据库扣钱的。
step 2> update oracle_table set amount=amount+xx where id=bbb 加钱,假设是在oracle数据库扣钱的。
现在怎么确保两个语句在同一个事务里执行呢?以前在JDBC里是这样做connection = mysql 连接mysqlconnection.setAutoCommit(false); 不自动提交1> update mysql_table set amount=amount-xx where id=aaa 发生扣钱,假设是在mysql数据库扣钱的。
Spring考试试卷(有答案)
Spring考试试卷〔题库〕1.以下关于AOP的说法错误的选项是〔〕。
A.AOP将散落在系统中的“方面〞代码集中实现B.AOP有助于提高系统的可维护性C.AOP已经表现出了将要替代面向对象的趋势D.AOP是一种设计模式,Spring为其提供了一种实现2.在SSH整合时,事务隔离级别是由〔〕实现的。
A.Java应用程序B.HibernateC.数据库系统D.JDBC驱动程序3.以下〔〕不是Spring的依赖注入方式。
【选两项】A.setter注入B.getter注入C.接口注入D.构造注入4.在Spring框架中,面向方面编程〔AOP〕的目标在于〔〕。
A.编写程序时不用关心其依赖组件的实现B.将程序中涉及的公用问题集中解决C.封装JDBC访训数据库的代码,简化数据访训层的得复性代码D.实现画面的“无刷新〞5.关于Spring与Hibernate集成,以下说法错误的选项是〔〕。
A.Spring提供了HibernateDaoSupport类来简化Hibernate的使用B.在Spring配置文件中,可以通过Spring提供的LocalSessionFactoryBean来获得SessionFactory的实例C.通过集成Spring和Hibernate,用Spring管理程序的依赖关系,将SessionFactory 注入到DataSource中D.通过Spring,可以在Biz层代码中无需直接实例化DAO类,而是通过注入得到6.在Spring中,以下关于依赖注入的说法,正确的选项是〔〕。
A.依赖注入的目标是在代码之外管理程序组建间的依赖关系〔组件?组建?〕B.依赖注入即“面向接口〞的编程C.依赖注入是面向对象技术的替代品D.依赖注入的使用会增大程序的规模7.以下关于Spring的说法错误的选项是〔〕。
A.Spring是一个轻量级JAVAEE的框架集合B.Spring是“依赖注入〞模式的实现C.使用Spring可以实现声明事务D.Spring提供了AOP方式的日志系统8.在Spring中,配置Hibernate事务管理器〔HibernateTransactionManager〕时,需要注入的属性名称是〔〕。
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)描述不正确的是()。
Hibernete基本概念
认识Hibernate一、Hibernate是一个优秀的持久化框架,了解持久化之前,先了解两种状态:1.瞬时状态:保存在内存中的程序数据,程序退出了,数据就消失了。
2.持久状态:保存在磁盘中的程序数据,程序退出了,数据依然存在。
持久化就是程序数据在瞬时状态和持久状态之间转换的一种机制。
二、hibernate是JDBC的轻量级封装,是一个独立的对象持久层框架;Hibernate可以用在任何JDBC可以使用的场合;Hibernate是一个和JDBC密切关联的框架,所以Hibernate的兼容性和JDBC驱动,和数据库都有一定的关系。
但是和使用它的Java程序,和App Server没有任何关系,也不存在兼容性问题;由于两者读取方式不一样,hibernate采用uuid.hex构造主键,性能稍慢与jdbc;特别是jdbc使用批处理的时候,显得jdbc更快,但是JVM(java虚拟机)内存也就要求大;总而言之,所有的ORM比如CMP、JDO、Hibernate都是对jdbc的封装,理论上讲ORM的性能不会高于jdbc,就像所有的高级语言性能不会高于汇编语言是一个道理。
所以,JDBC占着灵活效率高的优势,而hibernate占着易学易使用的优势。
那么hibernate与JDBC有什么区别呢:相同点:1.都是java数据库操作的中间件;2.两者对数据库对象的操作都不是线程安全的,都需要及时关闭;3.两者都可以对数据库的更新操作进行显式的事务处理;不同点:1.hibernate先检索缓存中的映射对象( 即hibernate操作的是对象),而jdbc则是直接操作数据库,将数据直接通过SQl传送到数据库......(操作的对象不同)2.JDBC使用基于关系数据库的标准SQL(Structured Query Language)语言,hibernate使用HQL(Hibernate Query Language)语言....(使用的语言不同)3.Hibernate操作的数据是可持久化的,也就是持久化的对象属性的值,可以和数据库中保持一致,而jdbc操作数据的状态是瞬时的,变量的值无法和数据库中一致....(数据状态不同)三、ORM(Object Relational Mapping)对象关系映射完成对象数据到关系型数据映射的机制,称为:对象·关系映射,简ORM总结:Hibernate是一个优秀的对象关系映射机制,通过映射文件保存这种关系信息;在业务层以面向对象的方式编程,不需要考虑数据的保存形式。
事务——Nhibernate操作原生SQL以及查询DataTable
Nhibernate操作原生SQL以及查询DataTable使用Nhibernate时我们很方便实现实体映射,但是如果遇到复杂查询则显得力不从心,这是我们可以利用Nhibernate来操作原生sql来查询到DataTable来实现我们复杂的查询及其它操作。
以下实例已经过调试,现与大家分享。
///<summary>///执行ExecuteNonQuery///</summary>///<param name="sql"></param>public void ExecuteNonQuery(string sql){ISession session = null;ITransaction transaction = null;try{session = NHibernateHelper.GetCurrentSession();transaction = session.BeginTransaction();IDbCommand command = session.Connection.CreateCommand();transaction.Enlist(command);//注意此处要把command添加到事物中mandText = sql;command.ExecuteNonQuery();mit();}catch (Exception ex){if (transaction != null){transaction.Rollback();}throw ex;}finally{if (session != null){session.Close();}}}///<summary>///填充DataSet///</summary>///<param name="sql"></param>///<returns></returns>public static DataSet ExecuteDataset(string sql){ISession session = null;DataSet ds = new DataSet();try{session = NHibernateHelper.GetCurrentSession();IDbCommand command = session.Connection.CreateCommand(); mandText = sql;IDataReader reader = command.ExecuteReader();DataTable result = new DataTable();//result.Load(reader);//此方法亦可DataTable schemaTable = reader.GetSchemaTable();for (int i = 0; i < schemaTable.Rows.Count; i++){string columnName = schemaTable.Rows[i][0].ToString(); result.Columns.Add(columnName);}while (reader.Read()){int fieldCount = reader.FieldCount;object[] values = new Object[fieldCount];for (int i = 0; i < fieldCount; i++){values[i] = reader.GetValue(i);}result.Rows.Add(values);}ds.Tables.Add(result);}catch (Exception ex){Debug.Assert(false);}finally{if (session != null){session.Close();}}return ds;}///<summary>///填充DataSet(此方法亦可)///</summary>///<param name="sql"></param>///<returns></returns>public DataSet ExecuteDataset(string sql){ISession session = null;DataSet ds = new DataSet();try{session = NHibernateHelper.GetCurrentSession();IDbCommand command = session.Connection.CreateCommand(); mandText = sql;SqlDataAdapter da = new SqlDataAdapter(cmd as SqlCommand); da.Fill(ds);}catch (Exception ex){Debug.Assert(false);}finally{if (session != null){session.Close();}}return ds;}。
Hibernate的LockMode
Hibernate的LockMode在了解Hibernate的LockMode之前,我们先讲一下LockMode是什么东西?其实LockMode只是在使用Hibernate 中的session.load()加载数据时指定的模式,也叫悲观锁(模式),然而,悲观锁是为了弥补read-committed 机制的不足,从而解决non-repeatable (不可重复读)和phantom-read (幻读)问题,而non-repeatable 和phantom-read 这两个问题也只是事务并发是产生的两种问题...看了我写的这一段后,我相信很多读者会有点懵,这就对了,看完下面的文章,再后过头来读这一段,就全都明白了。
一、事务的特性我们知道,事务由那几个特性,四个(ACID):1.原子性(Atomicity):整个事务中的所有操作,要么全部完成,要么全部不完成,不可能停滞在中间某个环节。
事务在执行过程中发生错误,会被回滚(Rollback)到事务开始前的状态,就像这个事务从来没有执行过一样。
2.一致性(Consistency)在事务开始之前和事务结束以后,数据库的完整性约束没有被破坏。
3.隔离性(Isolation)两个事务的执行是互不干扰的,一个事务不可能看到其他事务运行时,中间某一时刻的数据。
4.持久性(Durability)在事务完成以后,该事务所对数据库所作的更改便持久的保存在数据库之中,并不会被回滚。
由于一项操作通常会包含许多子操作,而这些子操作可能会因为硬件的损坏或其他因素产生问题,要正确实现ACID并不容易。
ACID建议数据库将所有需要更新以及修改的资料一次操作完毕,但实际上并不可行。
一个支持事务(Transaction)的数据库系统,必需要具有这四种特性,否则在事务过程(Transaction processing)当中无法保证数据的正确性,交易过程极可能达不到交易方的要求。
在处理事务过程中,事务并发是不可避免的,从而会出现以下几个问题:1.丢失更新(Lost Update)(第一类和第二类)2.脏读(Dirty Read)3.不可重复读(Non-repeatable Read)4.幻读(Phantom Read)二、事务隔离机制针对并发事务出现的问题,Hibernate 采用了数据库的事务隔离机制(详细文档见Herbernate 参考文档的java.sql.Connection ),一般有以下四种处理机制:1) read-uncommitted2) read-committed3) repeatable read4) serializable2.1 四种机制的具体价值:A. 只要数据库支持事务,就不可能出现第一类丢失更新。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
struts+hibernate+spring事务配置博客分类:SSHhibernatespringstruts原文:/group/wiki/1675-struts-hibernate-spr ing-services-configurationStruts+hibernate+spring整合开发web应用是相当流行的,只需要简单的配置就能轻松的对数据库进行crud操作,下面就hibernate+spring的配置做一下剖析,一边与大家一起分享经验:1、准备工作:可以利用hibernate tools生成相关映射文件已经po对象、dao对象,dao也可以自己手动编写,无非就是实现crud,如果通过继承hibernate提供的HibernateDaoSupport,则可以更轻松的实现关键就在于配置文件,下面看一个样例app.xml:<?xml version="1.0" encoding="utf-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/bean s /schema/beans/spring-beans.xsd"><!--配置数据源--><bean id="dataSource"class="boPooledDataSource"destroy-method="close"><!-- 指定连接数据库的驱动 --><property name="driverClass" value="com.mysql.jdbc.Driver"/><!-- 指定连接数据库的URL --><property name="jdbcUrl"value="jdbc:mysql://localhost/auction"/><!-- 指定连接数据库的用户名 --><property name="user" value="root"/><!-- 指定连接数据库的密码 --><property name="password" value="root"/><!-- 指定连接数据库连接池的最大连接数 --><property name="maxPoolSize" value="20"/><!-- 指定连接数据库连接池的最小连接数 --><property name="minPoolSize" value="1"/><!-- 指定连接数据库连接池的初始化连接数 --><property name="initialPoolSize" value="1"/><!-- 指定连接数据库连接池的连接的最大空闲时间 --><property name="maxIdleTime" value="20"/></bean><!--配置数据库会话工厂--><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="dataSource" ref="dataSource"/><property name="mappingResources"><list><value>com/ouya/User.hbm.xml</value></list></property><property name="hibernateProperties"><props><propkey="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop><prop key="hibernate.show_sql">true</prop><prop key="e_reflection_optimizer">true</prop></props></property></bean><!--配置事务管理器--><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager "><property name="sessionFactory"><reflocal="sessionFactory"/></property></bean><!—-配置Spring 事务管理器代理 --><bean id="transactionProxyFactory" abstract="true" lazy-init="true" class="org.springframework.transaction.interceptor.TransactionProxyFa ctoryBean"><property name="transactionManager"><ref local="transactionManager"/></property><property name="transactionAttributes"><props><prop key="save*">PROPAGATION_REQUIRED</prop><prop key="insert*">PROPAGATION_REQUIRED</prop><prop key="del*">PROPAGATION_REQUIRED</prop><prop key="add*">PROPAGATION_REQUIRED</prop><prop key="update*">PROPAGATION_REQUIRED</prop><prop key="find*">PROPAGATION_REQUIRED,readOnly</prop> <prop key="search*">PROPAGATION_REQUIRED,readOnly</prop> <prop key="remove*">PROPAGATION_REQUIRED,readOnly</prop> <prop key="query*">PROPAGATION_REQUIRED,readOnly</prop> <prop key="list*">PROPAGATION_REQUIRED,readOnly</prop> <prop key="count*">PROPAGATION_REQUIRED,readOnly</prop> <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop></props></property></bean><!-- Hibernate模板 --><bean id="hibernateTemplate"class="org.springframework.orm.hibernate3.HibernateTemplate"><property name="sessionFactory"><ref local="sessionFactory" /></property></bean><!--服务层对象--><bean id="us" class="erService"><property name="userDao"><ref local="userDao"/></property></bean><!-- spring代理用户服务对象 --><bean id="userService" parent="transactionProxyFactory"><!-- 如果上面的服务层对象实现了接口,则此处必须设置proxyTargetClass 为true,否则会报classcast异常 --><!--<property name="proxyTargetClass" value="true"/>--><property name="target" ref="us"/></bean><!-- 用户数据访问对象DATA ACCESS OBJECT --><bean id="userDao" class="erDAO"><property name="hibernateTemplate" ref="hibernateTemplate"/></bean></beans>可以看到配置文件的步骤:1、配置数据源2、配置会话工厂(依赖注入上面的数据源,还要注入hbm映射文件[注意正确的位置]、hibernate属性文件)3、配置事务管理器(依赖注入上面的会话工厂)4、 Spring中声明事务管理器(根据需要又可分为几种,但都要依赖注入上面的事务管理器,此外还需要配置transationAttributes)后面的一些普通的bean配置就不用说了上面的例子中使用的声明事务管理器是:TransactionProxyFactoryBean,这样的话我们就需要在后面配置目标bean,比如上面的例子中我们的原服务对象是id 为us的UserService(没有实现接口),所以我们为他配置了id为userService 的代理对象(目标bean),程序中使用时只能通过使用代理对象才能实现数据库操作功能(代理对象的父类是上面声明的事务管理器,一边我们使用的时候开启事务),如果直接使用服务对象就无法开启事务程序中调用:UserService us = (UserService) app.getBean("userService");注:userService就是上面配置的代理对象的id,而不是原服务对象的id但是如果我们想通过原服务对象的id来使用对象,则我们需要使用代理事务管理器BeanNameAutoProxyCreator(根据beanname自动代理),上面的配置文件需要做改动,做两件事(当然先要删除原来配置的TransactionProxyFactoryBean,不然就混乱了,可能会报错的):1、增加一个事务拦截器<bean id="transactionInterceptor"class="org.springframework.transaction.interceptor.TransactionInterce ptor"><property name="transactionManager"><ref local="transactionManager"/></property><property name="transactionAttributes"><props><prop key="save*">PROPAGATION_REQUIRED</prop><prop key="insert*">PROPAGATION_REQUIRED</prop><prop key="del*">PROPAGATION_REQUIRED</prop><prop key="add*">PROPAGATION_REQUIRED</prop><prop key="update*">PROPAGATION_REQUIRED</prop><prop key="find*">PROPAGATION_REQUIRED,readOnly</prop><prop key="search*">PROPAGATION_REQUIRED,readOnly</prop><prop key="remove*">PROPAGATION_REQUIRED,readOnly</prop><prop key="query*">PROPAGATION_REQUIRED,readOnly</prop><prop key="list*">PROPAGATION_REQUIRED,readOnly</prop><prop key="count*">PROPAGATION_REQUIRED,readOnly</prop><prop key="get*">PROPAGATION_REQUIRED,readOnly</prop></props></property></bean>2、定义自动代理事务管理器<!-- 定义BeanNameAutoProxyCreator--><beanclass="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyC reator"><!-- 如果服务层对象是接口实现类,则需要设置proxyTargetClass属性为true --><!--<property name="proxyTargetClass" value="true"--><!-- 指定对满足哪些bean name的bean自动生成业务代理 --><property name="beanNames"><!-- 下面是所有需要自动创建事务代理的bean--><list><value>us</value></list><!-- 此处可增加其他需要自动创建事务代理的bean--></property><!-- 下面定义BeanNameAutoProxyCreator所需的事务拦截器--><property name="interceptorNames"><list><!-- 此处可增加其他新的Interceptor --><value>transactionInterceptor</value></list></property></bean>然后我们在程序中调用时应如下:UserService us = (UserService) app.getBean("us");注:注意与上面使用TransactionProxyFactoryBean时的调用区别,此处我们用getbean时直接取原服务层对象的id,不需要去配置目标bea,这也正是BeanNameAutoProxyCreator(根据bean名称自动代理)的含义所在附录:1、关于hibernate的属性详解:<bean id="dataSource"class="boPooledDataSource"destroy-method="close"><!-- 以下配置都是使用 jdbc.properties 属性文件中的配置,而之所以可以这样写,就是因为有属性占位符配置的原因 --><property name="driverClass" value="${jdbc.driverClassName}"/><property name="jdbcUrl" value="${jdbc.url}"/><property name="user" value="${ername}"/><property name="password" value="${jdbc.password}"/><!-- 连接池维持的最小的连接个数 --><property name="minPoolSize" value="5"/><!-- 连接池维持的最大的连接个数 --><property name="maxPoolSize" value="20"/><!-- 最大空闲时间, 当某个连接在这个时间内没活动后将从池中移除,前提是池中至少多于最少的连接数: minPoolSize --><property name="maxIdleTime" value="1800"/><!-- 为加强准备语句的执行性能,此参数指定被缓存的 PreparedStatement 的个数 --><property name="maxStatements" value="50"/></bean>Hibernate 会话厂 SessionFactorySession 就是用于每次与数据库会话的,因此需要:数据库的配置参数,这些参数就是上面的数据源指定的! 因此我们只需引用即可: ref="dataSource";实体映射配置 hibernate.cfg.xml 配置结果缓存配置(这里使用的是开源的 ehcache)<!-- Hibernate SessionFactory --><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"><!-- 引用前面定义的数据源 --><property name="dataSource" ref="dataSource"/><!-- 所有实体映射文件列表, 所有的 hbm.xml 文件 --><property name="mappingResources"><list><value>org/springframework/samples/jpetstore/domain/Account.hbm.xml</ value><value>org/springframework/samples/jpetstore/domain/Banner.hbm.xml</v alue><value>org/springframework/samples/jpetstore/domain/Category.hbm.xml< /value><value>org/springframework/samples/jpetstore/domain/Inventory.hbm.xml </value><value>org/springframework/samples/jpetstore/domain/Item.hbm.xml</val ue><value>org/springframework/samples/jpetstore/domain/LineItem.hbm.xml< /value><value>org/springframework/samples/jpetstore/domain/Order.hbm.xml</va lue><value>org/springframework/samples/jpetstore/domain/Product.hbm.xml</ value><value>org/springframework/samples/jpetstore/domain/Supplier.hbm.xml< /value></list></property><!-- 传统上的 hibernate.cfg.xml 文件的参数放在这里 --><property name="hibernateProperties"><props><!-- 指定数据库方言 --><prop key="hibernate.dialect">${hibernate.dialect}</prop><!-- 是否在日志中输出所有Hibernate与数据库交互的SQL语句 --><prop key="hibernate.show_sql">true</prop><!-- 是否在日志中输出的SQL 语句格式化成易读形式 --><prop key="hibernate.format_sql">true</prop><!-- 是否显示统计形式,一般在测试阶段使用 --><prop key="hibernate.generate_statistics">true</prop><!-- 对于级联查询,一次性获取的级联深度, @todo 需进一步研究 --><prop key="hibernate.max_fetch_depth">2</prop><!--Fetch Size 是设定JDBC的Statement读取数据的时候每次从数据库中取出的记录条数,一般设置为30、50、100。